@openwop/openwop-conformance 2.45.14 → 2.45.15

package/src/scenarios/v2-prompt-mutable-lifecycle.test.ts

@@ -0,0 +1,130 @@
+/**
+ * v2 — the mutable prompt library (`spec/v2/core/host-services.md` §`prompts`
+ * → §Library; `api/v2/openapi.yaml` `createPromptTemplate`,
+ * `updatePromptTemplate`, `deletePromptTemplate`; RFC 0028 §A). The v1 twin is
+ * `prompt-mutable-lifecycle`; the legs live in `lib/prompt-library-witness.ts`.
+ *
+ * One round trip on a fresh user template, observed once
+ * (`driveLifecycle`) and judged per step (`judgeLifecycle`, pure):
+ *   create → 201 + Location; read → `meta.source: user`; duplicate
+ *   (templateId, version) → 409; update with a greater SemVer → 200 and stored;
+ *   a lower SemVer → 409; delete → 204, then 404.
+ * Plus: a host built-in is read-only (DELETE → 403); NEW at v2, writes MUST be
+ * authenticated (unauthenticated POST → 401); and, unaided, with
+ * `mutableLibrary` unadvertised a write answers `404 not_found` (errors.md
+ * §Unadvertised operations).
+ *
+ * Dispositions: no target ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`;
+ * `prompts` absent, or `endpointsSupported`/`mutableLibrary` not `true` ⇒ the
+ * write legs are `inapplicable` (gated by presence, never a strict-mode
+ * failure) and the gate-off leg binds; no host built-in listed ⇒ read-only leg
+ * `inapplicable`.
+ *
+ * Proven against a scratch double in `lib/prompt-library-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Library
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { driveLifecycle, gateOffWriteLeg, judgeLifecycle, promptAdverts, readOnlyLeg, unauthenticatedWriteLeg, type LifecycleObservation, type PromptAdverts, type Skip } from '../lib/prompt-library-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_CREATE = 'openwop.requirement.prompts.create-user-template';
+const ID_READ = 'openwop.requirement.prompts.created-template-source-user';
+const ID_DUP = 'openwop.requirement.prompts.duplicate-version-409';
+const ID_UPDATE = 'openwop.requirement.prompts.update-greater-semver';
+const ID_NONMONO = 'openwop.requirement.prompts.update-non-monotonic-409';
+const ID_DELETE = 'openwop.requirement.prompts.delete-user-template';
+const ID_READONLY = 'openwop.requirement.prompts.builtin-read-only';
+const ID_AUTH = 'openwop.requirement.prompts.writes-authenticated';
+const ID_GATE = 'openwop.requirement.prompts.mutable-gate-off-404';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+
+type Ready = { ok: true; a: PromptAdverts } | { ok: false; skip: () => undefined };
+async function ready(): Promise<Ready> {
+  if (HTTP_SKIP) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  return { ok: true, a: promptAdverts(PROFILE, doc) };
+}
+
+/** The round trip runs once per file; each step's `it` judges its own part. */
+let lifecycle: Promise<Skip | LifecycleObservation> | undefined;
+type Step = { ok: true; o: LifecycleObservation } | { ok: false; skip: () => undefined };
+async function step(): Promise<Step> {
+  const r = await ready();
+  if (!r.ok) return r;
+  lifecycle ??= driveLifecycle(PROFILE, r.a);
+  const o = await lifecycle;
+  if ('kind' in o) return { ok: false, skip: () => softSkip(o.disposition, o.reason) };
+  return { ok: true, o };
+}
+
+describe('v2 prompt library: user-template round trip (host-services.md §Library)', () => {
+  it('POST /prompts creates a user template with 201 and a Location', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).create) expect(x.ok, req(ID_CREATE, x.doc, x.message)).toBe(true);
+  });
+
+  it('the created template reads back with meta.source user', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).read) expect(x.ok, req(ID_READ, x.doc, x.message)).toBe(true);
+  });
+
+  it('a second POST of the same templateId and version answers 409', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).duplicate) expect(x.ok, req(ID_DUP, x.doc, x.message)).toBe(true);
+  });
+
+  it('PUT with a greater SemVer replaces the template', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).update) expect(x.ok, req(ID_UPDATE, x.doc, x.message)).toBe(true);
+  });
+
+  it('PUT with a lower SemVer answers 409', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).nonMonotonic) expect(x.ok, req(ID_NONMONO, x.doc, x.message)).toBe(true);
+  });
+
+  it('DELETE answers 204 and the template then reads 404', async () => {
+    const s = await step();
+    if (!s.ok) return s.skip();
+    for (const x of judgeLifecycle(s.o).remove) expect(x.ok, req(ID_DELETE, x.doc, x.message)).toBe(true);
+  });
+});
+
+describe('v2 prompt library: write guards (host-services.md §Library; errors.md §Unadvertised operations)', () => {
+  it('a host built-in template is read-only: DELETE answers 403', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await readOnlyLeg(PROFILE, r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_READONLY, x.doc, x.message)).toBe(true);
+  });
+
+  it('an unauthenticated write is refused 401', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await unauthenticatedWriteLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_AUTH, x.doc, x.message)).toBe(true);
+  });
+
+  it('with mutableLibrary unadvertised, POST /prompts answers 404 not_found', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await gateOffWriteLeg(PROFILE, r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_GATE, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-prompt-pack-install.test.ts

@@ -0,0 +1,78 @@
+/**
+ * v2 — prompt packs on the library surface (`spec/v2/core/host-services.md`
+ * §`prompts` → §Library; `capabilities.schema.json` §prompts.packsSupported;
+ * RFC 0028 §B–§C). The v1 twin is `prompt-pack-install`; the legs live in
+ * `lib/prompt-library-witness.ts`.
+ *
+ *   listing     `GET /prompts?source=pack` answers 200 and lists only pack
+ *               templates; NEW at v2, with `packsSupported` not advertised it
+ *               lists none ("packs are not loaded"). With the operator flag
+ *               `OPENWOP_TEST_PROMPT_PACK_INSTALLED=true` (client-side, as at
+ *               v1) it MUST list at least one;
+ *   stamps      every pack template carries `meta.packName` and a SemVer
+ *               `meta.packVersion` and validates;
+ *   reference   the in-tree reference pack `vendor.openwop.prompt-sample`:
+ *               `writer-system` is fetched by id under its `libraryId` and
+ *               keeps its pack provenance.
+ *
+ * Dispositions: no target ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`;
+ * `prompts` absent or `endpointsSupported` not `true` ⇒ `inapplicable`;
+ * `packsSupported` not `true` ⇒ stamps and reference `inapplicable`; no pack
+ * installed ⇒ stamps `inapplicable` (zero packs is conformant); the reference
+ * pack not installed ⇒ reference `inapplicable`, never `blocked`.
+ *
+ * Proven against a scratch double in `lib/prompt-library-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Library
+ * @see schemas/v2/prompt-pack-manifest.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { packListLeg, packStampLeg, promptAdverts, referencePackLeg, type PromptAdverts } from '../lib/prompt-library-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_LIST = 'openwop.requirement.prompts.pack-listing';
+const ID_STAMPS = 'openwop.requirement.prompts.pack-template-stamps';
+const ID_REFERENCE = 'openwop.requirement.prompts.reference-pack-fetch';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+const REQUIRE_INSTALLED = process.env['OPENWOP_TEST_PROMPT_PACK_INSTALLED'] === 'true';
+const template = v2Validator('prompt-template');
+
+type Ready = { ok: true; a: PromptAdverts } | { ok: false; skip: () => undefined };
+async function ready(): Promise<Ready> {
+  if (HTTP_SKIP) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  return { ok: true, a: promptAdverts(PROFILE, doc) };
+}
+
+describe('v2 prompt packs (host-services.md §Library)', () => {
+  it('GET /prompts?source=pack lists only pack templates, and none unless packsSupported', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await packListLeg(r.a, { requireInstalled: REQUIRE_INSTALLED });
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_LIST, x.doc, x.message)).toBe(true);
+  });
+
+  it('every pack template carries meta.packName and meta.packVersion', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await packStampLeg(r.a, template);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_STAMPS, x.doc, x.message)).toBe(true);
+  });
+
+  it('the reference pack template is fetched by id and keeps its pack provenance', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await referencePackLeg(PROFILE, r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_REFERENCE, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-prompt-render-deterministic.test.ts

@@ -0,0 +1,87 @@
+/**
+ * v2 — `renderPromptTemplate` (`spec/v2/core/host-services.md` §`prompts` →
+ * §Library, §Composition; `api/v2/openapi.yaml` `POST /prompts:render`; RFC
+ * 0028 §A). The v1 twin is `prompt-render-deterministic`; the legs live in
+ * `lib/prompt-library-witness.ts`. The render path is `prompts.library.
+ * renderEndpoint` when advertised, else `/prompts:render`.
+ *
+ *   deterministic  identical (ref, variables) render the identical `hash` and
+ *                  `variableHashes` (the hash MUST equal the dispatch-time
+ *                  `prompt.composed` hash, so it cannot vary per call);
+ *   varies         a changed required binding changes `hash` and its
+ *                  `variableHashes` entry;
+ *   shape          `hash` and every `variableHashes` value are
+ *                  `sha256:<hex64>`; under `observability: full` `composed`
+ *                  carries the body for every kind (a few-shot or schema-hint
+ *                  template preferred), otherwise `composed` is absent —
+ *                  bodies only under `full` (NEW at v2: the v1 file required a
+ *                  body unconditionally);
+ *   unbound        NEW at v2: a required variable left unbound is refused
+ *                  `400 validation_error`.
+ *
+ * Dispositions: no target ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`;
+ * `prompts` absent or `endpointsSupported` not `true` ⇒ `inapplicable` (gated
+ * by presence); no renderable template (none listed, or each needs a secret
+ * binding) or none with a required variable ⇒ `inapplicable`.
+ *
+ * Proven against a scratch double in `lib/prompt-library-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Library
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { deterministicLeg, promptAdverts, renderShapeLeg, unboundRequiredLeg, variesLeg, type PromptAdverts } from '../lib/prompt-library-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_DETERMINISTIC = 'openwop.requirement.prompts.render-deterministic';
+const ID_VARIES = 'openwop.requirement.prompts.render-binding-sensitive';
+const ID_SHAPE = 'openwop.requirement.prompts.render-shape';
+const ID_UNBOUND = 'openwop.requirement.prompts.render-unbound-required-refused';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+
+type Ready = { ok: true; a: PromptAdverts } | { ok: false; skip: () => undefined };
+async function ready(): Promise<Ready> {
+  if (HTTP_SKIP) return { ok: false, skip: () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset') };
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, skip: () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0') };
+  return { ok: true, a: promptAdverts(PROFILE, doc) };
+}
+
+describe('v2 prompt render (host-services.md §Library, §Composition)', () => {
+  it('identical ref and variables render the identical hash and variableHashes', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await deterministicLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_DETERMINISTIC, x.doc, x.message)).toBe(true);
+  });
+
+  it('a changed binding changes the hash and its variableHash', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await variesLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_VARIES, x.doc, x.message)).toBe(true);
+  });
+
+  it('hashes are sha256 hex and the body is present only under observability full', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await renderShapeLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SHAPE, x.doc, x.message)).toBe(true);
+  });
+
+  it('an unbound required variable is refused 400 validation_error', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    const out = await unboundRequiredLeg(r.a);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_UNBOUND, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-prompt-resolution-chain-event.test.ts

@@ -0,0 +1,46 @@
+/**
+ * v2 — the resolution chain on the production wire
+ * (`spec/v2/core/host-services.md` §`prompts` → §Resolution; RFC 0029). The v1
+ * twin is `prompt-resolution-chain-event`; the judge lives in
+ * `lib/prompt-events-witness.ts`.
+ *
+ * A run of `conformance-prompt-end-to-end` is created with `POST /runs` and its
+ * durable log read with `GET /runs/{runId}/events/poll` — no seam. Every
+ * `agent.prompt-resolved` (v1 `agent.promptResolved`) carries a non-empty
+ * `chain[]`, one entry per layer tried, each naming a layer and a boolean
+ * `applied`; at most one is applied, and `resolved` mirrors its `source` (or is
+ * `null` with none applied).
+ *
+ * Stricter than v1: at v2 the emission is a MUST ("MUST emit
+ * agent.prompt-resolved"), so a host advertising `prompts` that emits none
+ * fails, where the v1 file soft-skipped `blocked`.
+ *
+ * Dispositions: `prompts` not advertised or the fixture not in `fixtures[]` ⇒
+ * `inapplicable`; discovery unreadable ⇒ `blocked`.
+ *
+ * Proven against a scratch double in `lib/prompt-events-witness.test.ts`.
+ *
+ * @see spec/v2/core/host-services.md §Resolution
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { END_TO_END_FIXTURE, driveFixture, judgeChain } from '../lib/prompt-events-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_CHAIN = 'openwop.requirement.prompts.resolution-chain-record';
+
+describe('v2 prompt events: the resolution chain record (host-services.md §Resolution)', () => {
+  it('every agent.prompt-resolved records the chain it walked, with one applied layer mirrored by resolved', async () => {
+    if (!process.env['OPENWOP_BASE_URL']) return softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    const o = await driveFixture(PROFILE, doc, END_TO_END_FIXTURE);
+    if ('kind' in o) return softSkip(o.disposition, o.reason);
+    for (const x of judgeChain(o)) expect(x.ok, req(ID_CHAIN, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});

package/src/scenarios/v2-prompt-template-shape.test.ts

@@ -0,0 +1,112 @@
+/**
+ * v2 — prompt wire shapes (`schemas/v2/prompt-kind.schema.json`,
+ * `prompt-template.schema.json`, `prompt-ref.schema.json`,
+ * `prompt-pack-manifest.schema.json`; `spec/v2/core/host-services.md`
+ * §`prompts`; RFCs 0027, 0028). The v1 twin is `prompt-template-shape`.
+ *
+ * Server-free: the four-kind enum; PromptTemplate round-trips and is CLOSED at
+ * v2 (an unknown property is rejected, an `x-`/`vendor.`/`openwop-` extension
+ * is admitted); a `source: pack` meta without `packName`/`packVersion` is
+ * rejected; PromptRef's two forms; and a `kind: "prompt"` pack manifest
+ * carries no `nodes[]` or `chains[]` (host-services.md §Library).
+ *
+ * Live (gated by the presence of the v2 `prompts` record, `inapplicable` when
+ * absent): the advertised record validates against the v2 capabilities schema
+ * — no `supported` seat, `maxTemplateBytes` ≤ 65536, the closed facet set.
+ *
+ * @see spec/v2/core/host-services.md §prompts
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { familyAdvertised, v2Discovery, v2RefValidator, v2Validator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'schemas/v2/prompt-template.schema.json';
+const ID_KIND = 'openwop.requirement.prompts.prompt-kind-enum';
+const ID_TEMPLATE = 'openwop.requirement.prompts.prompt-template-shape';
+const ID_CLOSED = 'openwop.requirement.prompts.prompt-template-closed';
+const ID_REF = 'openwop.requirement.prompts.prompt-ref-forms';
+const ID_PACK = 'openwop.requirement.prompts.prompt-pack-manifest-shape';
+const ID_RECORD = 'openwop.requirement.prompts.capability-record-shape';
+const HTTP_SKIP = !process.env['OPENWOP_BASE_URL'];
+
+const template = v2Validator('prompt-template');
+const ref = v2Validator('prompt-ref');
+const manifest = v2Validator('prompt-pack-manifest');
+const record = v2RefValidator('capabilities.schema.json#/properties/prompts');
+const minimal = { templateId: 'writer-system', version: '1.0.0', kind: 'system', text: 'You are a careful editorial writer.' };
+
+describe('v2 prompt shapes: PromptKind and PromptTemplate (server-free)', () => {
+  it('prompt-kind is a string enum of exactly the four kinds', () => {
+    const k = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'prompt-kind.schema.json'), 'utf8')) as { type?: unknown; enum?: unknown };
+    expect(k.type, req(ID_KIND, 'schemas/v2/prompt-kind.schema.json', 'prompt-kind MUST be type string')).toBe('string');
+    expect(k.enum, req(ID_KIND, 'schemas/v2/prompt-kind.schema.json', 'prompt-kind MUST be exactly system, user, few-shot, schema-hint')).toEqual(['system', 'user', 'few-shot', 'schema-hint']);
+  });
+
+  it('a minimal and a full PromptTemplate validate; a missing text, a non-SemVer version, a bad templateId or kind, or a dashed variable name is rejected', () => {
+    expect(template(minimal).ok, req(ID_TEMPLATE, DOC, `a minimal PromptTemplate MUST validate: ${template(minimal).errors}`)).toBe(true);
+    const full = {
+      templateId: 'writer-user', version: '1.2.3', kind: 'user', text: 'Write about: {{topic}}\nTone: {{tone}}', name: 'Writer', description: 'Two variables.',
+      variables: [{ name: 'topic', type: 'string', required: true, source: 'input' }, { name: 'tone', type: 'string', required: false, source: 'input', defaultValue: 'neutral' }],
+      modelHints: { modelClass: 'writing', temperature: 0.7 }, tags: ['editorial'], meta: { author: 'openwop-conformance', createdAt: '2026-05-20T10:00:00Z', source: 'host' },
+    };
+    expect(template(full).ok, req(ID_TEMPLATE, DOC, `a full PromptTemplate MUST validate: ${template(full).errors}`)).toBe(true);
+    const { text: _t, ...noText } = minimal;
+    expect(template(noText).ok, req(ID_TEMPLATE, DOC, 'text is REQUIRED')).toBe(false);
+    expect(template({ ...minimal, version: 'v1' }).ok, req(ID_TEMPLATE, DOC, 'version MUST be SemVer')).toBe(false);
+    // v2 templateId is the author-minted ids.schema.json grammar `^[A-Za-z0-9._~:-]{1,128}$` (v1 rejected upper case; v2 does not).
+    expect(template({ ...minimal, templateId: 'writer/system' }).ok, req(ID_TEMPLATE, 'schemas/v2/ids.schema.json §templateId', 'templateId MUST match the templateId grammar (no /)')).toBe(false);
+    expect(template({ ...minimal, kind: 'made-up-kind' }).ok, req(ID_TEMPLATE, DOC, 'kind MUST be one of the four')).toBe(false);
+    expect(template({ ...minimal, variables: [{ name: 'has-dash', type: 'string', required: true }] }).ok, req(ID_TEMPLATE, DOC, 'a variable name MUST be a templating identifier (no dashes)')).toBe(false);
+  });
+
+  it('PromptTemplate is closed: an unknown property is rejected, an extension-prefixed one admitted, and a pack meta must carry its stamps', () => {
+    expect(template({ ...minimal, unknownExtra: 'x' }).ok, req(ID_CLOSED, DOC, 'an unknown top-level property MUST be rejected')).toBe(false);
+    expect(template({ ...minimal, 'x-acme-note': 'ok' }).ok, req(ID_CLOSED, `${DOC} patternProperties (RFC 0138)`, 'an x- extension property MUST be admitted')).toBe(true);
+    expect(template({ ...minimal, variables: [{ name: 'topic', type: 'string', required: true, extra: 1 }] }).ok, req(ID_CLOSED, DOC, 'PromptVariable is closed')).toBe(false);
+    expect(template({ ...minimal, meta: { source: 'pack' } }).ok, req(ID_CLOSED, 'host-services.md §Library', 'a pack template MUST carry meta.packName and meta.packVersion')).toBe(false);
+    expect(template({ ...minimal, meta: { source: 'pack', packName: 'vendor.openwop.prompt-sample', packVersion: '1.0.0' } }).ok, req(ID_CLOSED, DOC, 'a stamped pack template MUST validate')).toBe(true);
+  });
+});
+
+describe('v2 prompt shapes: PromptRef (server-free)', () => {
+  it('the string and object forms validate; a missing prefix, a non-SemVer version, a missing templateId or an unknown property is rejected', () => {
+    for (const ok of ['prompt:writer-system', 'prompt:writer-system@1.2.3', 'prompt:vendor.acme.writer.v2@2.0.0']) {
+      expect(ref(ok).ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', `${ok} MUST validate`)).toBe(true);
+    }
+    expect(ref({ templateId: 'writer-system' }).ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'the object form with templateId alone MUST validate')).toBe(true);
+    expect(ref({ libraryId: 'vendor.acme.editorial-prompts', templateId: 'writer-system', version: '1.0.0', variableOverrides: { tone: 'formal' } }).ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'the full object form MUST validate')).toBe(true);
+    expect(ref('writer-system').ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'a string ref MUST start with prompt:')).toBe(false);
+    expect(ref('prompt:writer-system@latest').ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'a string ref version MUST be SemVer')).toBe(false);
+    expect(ref({ version: '1.0.0' }).ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'the object form MUST carry templateId')).toBe(false);
+    expect(ref({ templateId: 'writer-system', unknownExtra: true }).ok, req(ID_REF, 'schemas/v2/prompt-ref.schema.json', 'the object form is closed')).toBe(false);
+  });
+});
+
+describe('v2 prompt shapes: the prompt pack manifest (server-free)', () => {
+  it('a kind prompt pack validates and carries no nodes or chains', () => {
+    const good = { name: 'vendor.openwop.prompt-sample', version: '1.0.0', kind: 'prompt', engines: { openwop: '>=2.0.0' }, prompts: [minimal] };
+    expect(manifest(good).ok, req(ID_PACK, 'schemas/v2/prompt-pack-manifest.schema.json', `a conforming prompt pack MUST validate: ${manifest(good).errors}`)).toBe(true);
+    expect(manifest({ ...good, nodes: [] }).ok, req(ID_PACK, 'host-services.md §Library', 'a kind prompt pack MUST NOT carry nodes[]')).toBe(false);
+    expect(manifest({ ...good, chains: [] }).ok, req(ID_PACK, 'host-services.md §Library', 'a kind prompt pack MUST NOT carry chains[]')).toBe(false);
+    expect(manifest({ ...good, kind: 'node' }).ok, req(ID_PACK, 'schemas/v2/prompt-pack-manifest.schema.json', 'kind MUST be prompt')).toBe(false);
+    expect(manifest({ ...good, prompts: [] }).ok, req(ID_PACK, 'schemas/v2/prompt-pack-manifest.schema.json', 'a prompt pack MUST ship at least one template')).toBe(false);
+  });
+});
+
+describe('v2 prompt shapes: the advertised prompts record (live)', () => {
+  it('the prompts record, when advertised, validates against the v2 capabilities schema', async () => {
+    if (HTTP_SKIP) return softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    const prompts = await familyAdvertised('prompts');
+    if (prompts === null) return softSkip('inapplicable', 'the host does not advertise prompts');
+    const v = record(prompts);
+    expect(v.ok, req(ID_RECORD, 'schemas/v2/capabilities.schema.json §prompts', `the prompts record MUST validate (closed, no supported seat, maxTemplateBytes ≤ 65536): ${v.errors}`)).toBe(true);
+  });
+});

package/src/scenarios/v2-run-execution-bounds.test.ts

@@ -0,0 +1,67 @@
+/**
+ * v2 — run execution bounds (`spec/v2/core/runs.md` §`run` section; RFC 0058).
+ * The v1 twin is `run-execution-bounds-shape`; the legs live in
+ * `lib/run-bounds-witness.ts`, and what differs between majors (the run path,
+ * the closed `configurable` shape, the event name) is the profile row.
+ *
+ *   shape     advertised `limits.maxRunDurationMs` (≥ 1000) and
+ *             `limits.maxLoopIterations` (≥ 1) are well-formed;
+ *   refused   NEW at v2, unaided: `configurable.run.runTimeoutMs: 0` is refused
+ *             `400 validation_error` at create (`runs.md`: "An out-of-range
+ *             recursionLimit or runTimeoutMs MUST return 400");
+ *   breach    the `conformance-run-duration-breach` fixture with a 1 s timeout
+ *             ends `failed` / `run_timeout` and emits `cap.breached
+ *             { kind: 'run-duration' }` with `observed > limit`.
+ *
+ * Dispositions: `limits` not advertised, or neither facet ⇒ shape
+ * `inapplicable`; no advertised fixture to name ⇒ refused `inapplicable`; the
+ * breach fixture unadvertised ⇒ breach `inapplicable` (the fixture is the
+ * opt-in, as for the budget and table-schema witnesses).
+ *
+ * Proven against a scratch double in `lib/run-bounds-witness.test.ts`.
+ *
+ * @see spec/v2/core/runs.md §run section, §Limits
+ */
+
+import { describe, it, expect } from 'vitest';
+import { familyAdvertised, v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { getAdvertisedFixtures } from '../lib/fixtures.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { driveBreach, judgeBreach, refusedLeg, shapeLeg, TIMEOUT_FIXTURE } from '../lib/run-bounds-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_SHAPE = 'openwop.requirement.runs.limits-bounds-shape';
+const ID_REFUSED = 'openwop.requirement.runs.run-timeout-out-of-range-refused';
+const ID_BREACH = 'openwop.requirement.runs.run-timeout-breach';
+
+/** Any advertised fixture names a valid workflow, so a refusal can only be about runTimeoutMs. */
+function aFixture(): string | undefined {
+  const all = [...(getAdvertisedFixtures() ?? [])].sort();
+  return all.includes('conformance-noop') ? 'conformance-noop' : all.includes(TIMEOUT_FIXTURE) ? TIMEOUT_FIXTURE : all[0];
+}
+
+describe('v2 run execution bounds (runs.md §run section)', () => {
+  it('advertised limits.maxRunDurationMs and maxLoopIterations are well-formed', async () => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    if (!(await familyAdvertised('limits'))) return softSkip('inapplicable', 'the host does not advertise limits');
+    const out = shapeLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SHAPE, x.doc, x.message)).toBe(true);
+  });
+
+  it('an out-of-range runTimeoutMs is refused 400 validation_error at create', async () => {
+    const out = await refusedLeg(PROFILE, aFixture());
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_REFUSED, x.doc, x.message)).toBe(true);
+  });
+
+  it('a run exceeding runTimeoutMs fails run_timeout with cap.breached { kind: run-duration }', async () => {
+    const o = await driveBreach(PROFILE);
+    if ('kind' in o) return softSkip(o.disposition, o.reason);
+    for (const x of judgeBreach(o)) expect(x.ok, req(ID_BREACH, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});