@warpgogol/werkstatt-shared 0.2.0

package/src/share/tests/llms-0789.test.ts

@@ -0,0 +1,63 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0789: tests for conditional agent discovery links in buildLlmsIndex.</purpose>
+<keywords>RFC-0789, llms.txt, agent surface, discovery links, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">agent absent (default enabled), agent.enabled true, agent.enabled false, absolute URLs.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0789: initial tests for conditional agent discovery links in buildLlmsIndex.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import { buildLlmsIndex } from "../semantic/llms.ts";
+import type { SemanticSiteModel } from "../semantic/models.ts";
+
+function makeSite(overrides: Partial<SemanticSiteModel> = {}): SemanticSiteModel {
+  return {
+    baseUrl: "https://example.com",
+    lang: "de",
+    organization: {
+      name: "Test Org",
+      description: "A test organization.",
+      url: "https://example.com",
+    },
+    pages: [],
+    ...overrides,
+  };
+}
+
+test("buildLlmsIndex: agent absent → all 4 agent discovery links present", () => {
+  const output = buildLlmsIndex(makeSite());
+  expect(output).toContain("agent.json");
+  expect(output).toContain("api-catalog");
+  expect(output).toContain("mcp/server-card.json");
+  expect(output).toContain("agent.openapi.json");
+});
+
+test("buildLlmsIndex: agent.enabled true → all 4 agent discovery links present", () => {
+  const output = buildLlmsIndex(makeSite({ agent: { enabled: true } }));
+  expect(output).toContain("agent.json");
+  expect(output).toContain("api-catalog");
+  expect(output).toContain("mcp/server-card.json");
+  expect(output).toContain("agent.openapi.json");
+});
+
+test("buildLlmsIndex: agent.enabled false → zero agent discovery links", () => {
+  const output = buildLlmsIndex(makeSite({ agent: { enabled: false } }));
+  expect(output).not.toContain("agent.json");
+  expect(output).not.toContain("api-catalog");
+  expect(output).not.toContain("server-card.json");
+  expect(output).not.toContain("agent.openapi.json");
+  expect(output).toContain("llms-full.txt");
+});
+
+test("buildLlmsIndex: agent links use absolute https URLs", () => {
+  const output = buildLlmsIndex(makeSite());
+  expect(output).toContain("https://example.com/.well-known/agent.json");
+  expect(output).toContain("https://example.com/.well-known/api-catalog");
+  expect(output).toContain("https://example.com/.well-known/mcp/server-card.json");
+  expect(output).toContain("https://example.com/.well-known/agent.openapi.json");
+});

package/src/share/tests/manifest.test.ts

@@ -0,0 +1,100 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0286: determinism + shape tests for the Agent Surface Manifest builder.</purpose>
+<keywords>RFC-0286, agent surface, manifest, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">determinism, sorting, hash stability, empty-input safe default.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0286: initial builder tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import {
+  AGENT_SURFACE_VERSION,
+  buildAgentSurfaceManifest,
+  computeAgentManifestContentHash,
+  canonicalJson,
+} from "../agent/manifest.ts";
+
+const baseInput = {
+  site: "warpgogol-com",
+  baseUrl: "https://warpgogol.com/",
+  languages: { default: "de", supported: ["uk", "de"] },
+};
+
+test("buildAgentSurfaceManifest: strips trailing slash and sorts supported languages", () => {
+  const m = buildAgentSurfaceManifest(baseInput);
+  expect(m.baseUrl).toBe("https://warpgogol.com");
+  expect(m.languages.supported).toEqual(["de", "uk"]);
+});
+
+test("buildAgentSurfaceManifest: safe default — empty knowledge/actions, null interfaces", () => {
+  const m = buildAgentSurfaceManifest(baseInput);
+  expect(m.knowledge).toEqual([]);
+  expect(m.actions).toEqual([]);
+  expect(m.interfaces.openapi).toBe(null);
+  expect(m.interfaces.mcp).toBe(null);
+  expect(m.interfaces.twins).toBe(null);
+  expect(m.proof).toBe(null);
+  expect(m.surfaceVersion).toBe(AGENT_SURFACE_VERSION);
+});
+
+test("buildAgentSurfaceManifest: is deterministic across repeated calls (byte-identical)", () => {
+  const a = buildAgentSurfaceManifest(baseInput);
+  const b = buildAgentSurfaceManifest(baseInput);
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  expect(a.contentHash).toBe(b.contentHash);
+});
+
+test("buildAgentSurfaceManifest: sorts knowledge refs by domain and actions by id", () => {
+  const m = buildAgentSurfaceManifest({
+    ...baseInput,
+    knowledge: [
+      { domain: "offer", url: "/api/agent/v1/offer.json", schema: "gogol.agent.knowledge/offer@1" },
+      {
+        domain: "company",
+        url: "/api/agent/v1/company.json",
+        schema: "gogol.agent.knowledge/company@1",
+      },
+    ],
+    actions: [
+      {
+        id: "lead.submit",
+        url: "/api/agent/actions/lead.submit",
+        title: { de: "Anfrage senden" },
+        inputSchemaRef: "#/components/schemas/lead.submit-input",
+        entitlement: "agent.actions",
+      },
+      {
+        id: "appointment.request",
+        url: "/api/agent/actions/appointment.request",
+        title: { de: "Termin anfragen" },
+        inputSchemaRef: "#/components/schemas/appointment.request-input",
+        entitlement: "agent.actions",
+      },
+    ],
+  });
+  expect(m.knowledge.map((k) => k.domain)).toEqual(["company", "offer"]);
+  expect(m.actions.map((a) => a.id)).toEqual(["appointment.request", "lead.submit"]);
+});
+
+test("computeAgentManifestContentHash: excludes contentHash and proof fields from the hash input", () => {
+  const doc: Record<string, unknown> = { a: 1, b: 2, contentHash: "whatever", proof: { x: 1 } };
+  const withoutHashFields = { a: 1, b: 2 };
+  expect(computeAgentManifestContentHash(doc)).toBe(
+    computeAgentManifestContentHash({ ...withoutHashFields, contentHash: "other", proof: null }),
+  );
+});
+
+test("computeAgentManifestContentHash: is a 64-char lowercase hex sha256 digest", () => {
+  const hash = computeAgentManifestContentHash({ a: 1 });
+  expect(hash).toMatch(/^[0-9a-f]{64}$/);
+});
+
+test("canonicalJson: sorts object keys deeply, preserves array order", () => {
+  expect(canonicalJson({ b: 1, a: { d: 2, c: 3 } })).toBe('{"a":{"c":3,"d":2},"b":1}');
+  expect(canonicalJson([3, 1, 2])).toBe("[3,1,2]");
+});

package/src/share/tests/markdown-twin-provenance.test.ts

@@ -0,0 +1,108 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0613: Regression tests for parseMarkdownTwinFrontmatter null handling
+and buildMarkdownTwinFrontmatter null serialization.
+</purpose>
+<keywords>RFC-0613, RFC-0602, markdown twin, provenance, null parsing, lastModified</keywords>
+<responsibilities>
+  <item>Verify bare YAML null is parsed as JS null for lastModified.</item>
+  <item>Verify quoted "null" is also parsed as JS null (parser strips quotes before null check).</item>
+  <item>Verify valid date strings are parsed as strings.</item>
+  <item>Verify buildMarkdownTwinFrontmatter serializes null as bare YAML null.</item>
+  <item>Verify buildMarkdownTwinFrontmatter serializes date strings as quoted YAML.</item>
+</responsibilities>
+<non-goals>
+  <item>Do not test page.markdown.validate — that is covered in site-kernel-checks tests.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">Vitest cases for parseMarkdownTwinFrontmatter and buildMarkdownTwinFrontmatter null handling.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0613: Added regression tests for null parsing and serialization in markdown twin provenance.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, it, expect } from "vitest";
+import {
+  parseMarkdownTwinFrontmatter,
+  buildMarkdownTwinFrontmatter,
+  type MarkdownTwinProvenance,
+} from "../semantic/markdown-twin-provenance.ts";
+
+const baseProvenance: MarkdownTwinProvenance = {
+  canonical: "https://example.com/page/",
+  language: "de",
+  lastModified: null,
+  license: "https://example.com/ai.txt",
+  generator: "test-generator",
+  sourceKind: "test",
+};
+
+describe("parseMarkdownTwinFrontmatter — null handling (RFC-0613)", () => {
+  it("parses bare YAML null as JS null for lastModified", () => {
+    const content = `---\nlastModified: null\ncanonical: "https://example.com/"\n---\n\nbody`;
+    const parsed = parseMarkdownTwinFrontmatter(content);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBeNull();
+  });
+
+  it('parses quoted YAML "null" as JS null (parser strips quotes before null check)', () => {
+    const content = `---\nlastModified: "null"\ncanonical: "https://example.com/"\n---\n\nbody`;
+    const parsed = parseMarkdownTwinFrontmatter(content);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBeNull();
+  });
+
+  it("parses valid date string as string", () => {
+    const content = `---\nlastModified: "2026-07-30"\ncanonical: "https://example.com/"\n---\n\nbody`;
+    const parsed = parseMarkdownTwinFrontmatter(content);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBe("2026-07-30");
+  });
+
+  it("parses invalid date string as string (not null)", () => {
+    const content = `---\nlastModified: "2026-7-4"\ncanonical: "https://example.com/"\n---\n\nbody`;
+    const parsed = parseMarkdownTwinFrontmatter(content);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBe("2026-7-4");
+  });
+});
+
+describe("buildMarkdownTwinFrontmatter — null serialization (RFC-0613)", () => {
+  it("serializes null lastModified as bare YAML null", () => {
+    const provenance: MarkdownTwinProvenance = { ...baseProvenance, lastModified: null };
+    const fm = buildMarkdownTwinFrontmatter(provenance, "sha256:abc");
+    expect(fm).toContain("lastModified: null");
+    expect(fm).not.toContain('lastModified: "null"');
+  });
+
+  it("serializes date string lastModified as quoted YAML", () => {
+    const provenance: MarkdownTwinProvenance = { ...baseProvenance, lastModified: "2026-07-30" };
+    const fm = buildMarkdownTwinFrontmatter(provenance, "sha256:abc");
+    expect(fm).toContain('lastModified: "2026-07-30"');
+  });
+});
+
+describe("round-trip: build → parse (RFC-0613)", () => {
+  it("null lastModified survives build → parse round-trip as JS null", () => {
+    const provenance: MarkdownTwinProvenance = { ...baseProvenance, lastModified: null };
+    const fm = buildMarkdownTwinFrontmatter(provenance, "sha256:abc");
+    const parsed = parseMarkdownTwinFrontmatter(
+      `${fm}## Summary\n\nTest.\n\n## Business context\n\nTest.`,
+    );
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBeNull();
+  });
+
+  it("date string lastModified survives build → parse round-trip as string", () => {
+    const provenance: MarkdownTwinProvenance = { ...baseProvenance, lastModified: "2026-07-30" };
+    const fm = buildMarkdownTwinFrontmatter(provenance, "sha256:abc");
+    const parsed = parseMarkdownTwinFrontmatter(
+      `${fm}## Summary\n\nTest.\n\n## Business context\n\nTest.`,
+    );
+    expect(parsed).not.toBeNull();
+    expect(parsed!.frontmatter.lastModified).toBe("2026-07-30");
+  });
+});

package/src/share/tests/mcp-card.test.ts

@@ -0,0 +1,57 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0783: determinism + shape tests for the MCP Server Card projection.</purpose>
+<keywords>RFC-0783, agent surface, MCP Server Card, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">null mcp, mcp card fields, determinism.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0783: initial MCP Server Card projection tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import { buildMcpServerCard } from "../agent/mcp-card.ts";
+import { buildAgentSurfaceManifest } from "../agent/manifest.ts";
+
+test("buildMcpServerCard: null mcp → returns null", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+  });
+  expect(buildMcpServerCard(manifest)).toBeNull();
+});
+
+test("buildMcpServerCard: mcp interface → card with correct fields", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "warpgogol",
+    baseUrl: "https://warpgogol.com",
+    languages: { default: "de", supported: ["de"] },
+    mcp: { url: "/api/agent/mcp", protocolVersion: "2025-06-18" },
+  });
+  const card = buildMcpServerCard(manifest);
+  expect(card).not.toBeNull();
+  expect(card!.serverInfo.name).toBe("warpgogol-agent-gate");
+  expect(card!.serverInfo.version).toBe(manifest.surfaceVersion);
+  expect(card!.transport.type).toBe("streamable-http");
+  expect(card!.transport.url).toBe("/api/agent/mcp");
+  expect(card!.protocolVersion).toBe("2025-06-18");
+  expect(card!.capabilities.tools.listChanged).toBe(false);
+  expect(card!.capabilities.resources.listChanged).toBe(false);
+  expect(card!.capabilities.resources.subscribe).toBe(false);
+  expect(card!.capabilities.prompts.listChanged).toBe(false);
+});
+
+test("buildMcpServerCard: determinism — same input produces identical output", () => {
+  const input = {
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    mcp: { url: "/api/agent/mcp", protocolVersion: "2025-06-18" },
+  };
+  const a = buildMcpServerCard(buildAgentSurfaceManifest(input));
+  const b = buildMcpServerCard(buildAgentSurfaceManifest(input));
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+});

package/src/share/tests/onboarding-yaml.test.ts

@@ -0,0 +1,111 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-0082 regression tests for parseOnboardingArtifactHeader and
+    parseOnboardingArtifactPayload across the five contract shapes:
+    single-doc file, two-doc file, missing-header file, empty file,
+    doc-count > 2.
+  </purpose>
+  <responsibilities>
+    <item>Pin the "first doc is header, last doc is payload" rule.</item>
+    <item>Pin that single-doc payloads keep schema-declared keys (e.g. generatedAt) even when those overlap with RFC-0076 metadata.</item>
+    <item>Pin the > 2 docs rejection.</item>
+  </responsibilities>
+  <non-goals>
+    <item>Do not test specific content-discipline schemas — they own their own validation.</item>
+  </non-goals>
+</MODULE_CONTRACT>
+*/
+
+import { test, expect } from "vitest";
+import { z } from "zod";
+import {
+  parseOnboardingArtifactHeader,
+  parseOnboardingArtifactPayload,
+  RFC_METADATA_KEYS,
+} from "../onboarding-yaml/index.ts";
+
+const HEADER_FIXTURE = `phase: 04-author
+derivedFromInputHash: sha256:deadbeef
+generatedAt: 2026-05-23T12:00:00.000Z
+generator: agent`;
+
+test("parseOnboardingArtifactHeader returns the metadata in a two-doc file", () => {
+  const source = `---\n${HEADER_FIXTURE}\n---\nclient: warpgogol-com\npayload: 42\n`;
+  const header = parseOnboardingArtifactHeader(source);
+  expect(header).toEqual({
+    phase: "04-author",
+    derivedFromInputHash: "sha256:deadbeef",
+    generatedAt: "2026-05-23T12:00:00.000Z",
+    generator: "agent",
+  });
+});
+
+test("parseOnboardingArtifactHeader reads the merged metadata in a single-doc file", () => {
+  const source = `${HEADER_FIXTURE}\nclient: warpgogol-com\npayload: 42\n`;
+  const header = parseOnboardingArtifactHeader(source);
+  expect(header?.phase).toBe("04-author");
+  expect(header?.derivedFromInputHash).toBe("sha256:deadbeef");
+});
+
+test("parseOnboardingArtifactHeader returns null when the header is missing", () => {
+  const source = "client: warpgogol-com\nfoo: bar\n";
+  expect(parseOnboardingArtifactHeader(source)).toBe(null);
+});
+
+test("parseOnboardingArtifactHeader returns null for an empty source", () => {
+  expect(parseOnboardingArtifactHeader("")).toBe(null);
+});
+
+test("parseOnboardingArtifactPayload returns the second doc unchanged in a two-doc file", () => {
+  const source = `---\n${HEADER_FIXTURE}\n---\nclient: warpgogol-com\npayload: 42\n`;
+  const schema = z.object({ client: z.string(), payload: z.number() }).strict();
+  const data = parseOnboardingArtifactPayload(source, schema);
+  expect(data).toEqual({ client: "warpgogol-com", payload: 42 });
+});
+
+test("parseOnboardingArtifactPayload strips RFC-0076 keys from a single-doc payload", () => {
+  const source = `${HEADER_FIXTURE}\nclient: warpgogol-com\npayload: 42\n`;
+  const schema = z.object({ client: z.string(), payload: z.number() }).strict();
+  const data = parseOnboardingArtifactPayload(source, schema);
+  expect(data).toEqual({ client: "warpgogol-com", payload: 42 });
+});
+
+test("parseOnboardingArtifactPayload preserves a metadata-named key when the schema declares it", () => {
+  // RFC-0082 carve-out: contentAtomsFileSchema (and others) declare
+  // `generatedAt` as a strict payload field. The helper must NOT strip it
+  // from a single-doc payload when the schema's .shape introspects it.
+  const source = `${HEADER_FIXTURE}\nclient: warpgogol-com\n`;
+  const schema = z.object({ client: z.string(), generatedAt: z.string() }).strict();
+  const data = parseOnboardingArtifactPayload(source, schema);
+  expect(data).toEqual({
+    client: "warpgogol-com",
+    generatedAt: "2026-05-23T12:00:00.000Z",
+  });
+});
+
+test("parseOnboardingArtifactPayload throws on an empty source", () => {
+  expect(() => parseOnboardingArtifactPayload("", z.any())).toThrow(/no YAML documents/);
+});
+
+test("parseOnboardingArtifactPayload rejects doc-count > 2", () => {
+  const source = `---\n${HEADER_FIXTURE}\n---\nclient: warpgogol-com\n---\nstray: doc\n`;
+  expect(() => parseOnboardingArtifactPayload(source, z.any())).toThrow(
+    /expected exactly 1 or 2 YAML documents/,
+  );
+});
+
+test("RFC_METADATA_KEYS pins the four header field names", () => {
+  expect([...RFC_METADATA_KEYS].sort()).toEqual([
+    "derivedFromInputHash",
+    "generatedAt",
+    "generator",
+    "phase",
+  ]);
+});
+
+test("parseOnboardingArtifactPayload propagates Zod schema errors", () => {
+  const source = `---\n${HEADER_FIXTURE}\n---\nclient: 42\n`;
+  const schema = z.object({ client: z.string() }).strict();
+  expect(() => parseOnboardingArtifactPayload(source, schema)).toThrow();
+});

package/src/share/tests/ontology-role-by-cosmic-name.test.ts

@@ -0,0 +1,28 @@
+import { test, expect } from "vitest";
+import { roleByCosmicName } from "@warpgogol/werkstatt-shared/ontology/archetypes";
+
+/*
+<MODULE_CONTRACT>
+<purpose>
+  RFC-0263: unit test for the roleByCosmicName re-export — the manifest-
+  authored `role` field, keyed by cosmicName, derived by
+  archetype.registry.build and re-exported from @warpgogol/werkstatt-shared/ontology/archetypes.
+  Guards the two concrete hero-role entries buildPage's hideSectionNumber
+  injection depends on (see hero-section-numbering-parity.test.ts).
+</purpose>
+</MODULE_CONTRACT>
+*/
+
+test("roleByCosmicName is exported and non-empty", () => {
+  expect(typeof roleByCosmicName).toBe("object");
+  expect(Object.keys(roleByCosmicName).length > 0).toBeTruthy();
+});
+
+test('roleByCosmicName: both hero-role planets map to "hero"', () => {
+  expect(roleByCosmicName["Europa"]).toBe("hero"); // cosmic-literals-ignore: fixture cosmicName asserting the real registry output
+  expect(roleByCosmicName["Phobos"]).toBe("hero"); // cosmic-literals-ignore: fixture cosmicName asserting the real registry output
+});
+
+test('roleByCosmicName: a non-hero planet does not map to "hero"', () => {
+  expect(roleByCosmicName["Callisto"]).not.toBe("hero"); // cosmic-literals-ignore: fixture cosmicName for the non-hero control assertion
+});

package/src/share/tests/openapi.test.ts

@@ -0,0 +1,116 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0289: bijection + shape tests for the OpenAPI projection formatter.</purpose>
+<keywords>RFC-0289, agent surface, OpenAPI, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">empty manifest, knowledge ref projection, action ref projection, mcp/proof omission.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0289: initial OpenAPI formatter tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import { formatAgentOpenApi } from "../agent/openapi.ts";
+import { buildAgentSurfaceManifest } from "../agent/manifest.ts";
+
+test("formatAgentOpenApi: empty manifest yields a valid document with no paths", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+  });
+  const doc = formatAgentOpenApi(manifest, []);
+  expect(doc.openapi).toBe("3.1.0");
+  expect(doc.info.title).toBe("s agent surface");
+  expect(doc.info["x-gogol-content-hash"]).toBe(manifest.contentHash);
+  expect(doc.paths).toEqual({});
+  expect("x-gogol-mcp" in doc).toBe(false);
+  expect("x-gogol-proof" in doc).toBe(false);
+});
+
+test("formatAgentOpenApi: one knowledge ref → one GET path + one component schema", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    knowledge: [
+      { domain: "offer", url: "/api/agent/v1/offer.json", schema: "gogol.agent.knowledge/offer@1" },
+    ],
+  });
+  const doc = formatAgentOpenApi(manifest, []);
+  const op = doc.paths["/api/agent/v1/offer.json"]?.get;
+  expect(op).toBeTruthy();
+  expect(op!.operationId).toBe("knowledge.offer.get");
+  expect(op!.tags).toEqual(["knowledge"]);
+  expect(doc.components.schemas["knowledge-offer"]).toBeTruthy();
+});
+
+test("formatAgentOpenApi: one action ref → one POST path with verbatim input/output schemas", () => {
+  const inputSchema = {
+    type: "object" as const,
+    additionalProperties: false as const,
+    required: ["message"],
+    properties: { message: { type: "string" as const } },
+  };
+  const outputSchema = {
+    type: "object" as const,
+    additionalProperties: false as const,
+    properties: { accepted: { type: "boolean" as const } },
+  };
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    actions: [
+      {
+        id: "lead.submit",
+        url: "/api/agent/actions/lead.submit",
+        title: { de: "Anfrage senden" },
+        inputSchemaRef: "#/components/schemas/lead.submit-input",
+        entitlement: "agent.actions",
+      },
+    ],
+  });
+  const doc = formatAgentOpenApi(manifest, [
+    { id: "lead.submit", input: inputSchema, output: outputSchema },
+  ]);
+  const op = doc.paths["/api/agent/actions/lead.submit"]?.post;
+  expect(op).toBeTruthy();
+  expect(op!.operationId).toBe("action.lead.submit");
+  expect(op!.summary).toBe("Anfrage senden");
+  expect(doc.components.schemas["lead.submit-input"]).toEqual(inputSchema);
+  expect(doc.components.schemas["lead.submit-output"]).toEqual(outputSchema);
+  expect(op!.requestBody!.content["application/json"].schema).toEqual(inputSchema);
+});
+
+test("formatAgentOpenApi: an action ref without a matching capability schema is skipped defensively", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    actions: [
+      {
+        id: "lead.submit",
+        url: "/api/agent/actions/lead.submit",
+        title: { de: "x" },
+        inputSchemaRef: "#/components/schemas/lead.submit-input",
+        entitlement: "agent.actions",
+      },
+    ],
+  });
+  const doc = formatAgentOpenApi(manifest, []);
+  expect(doc.paths["/api/agent/actions/lead.submit"]).toBe(undefined);
+});
+
+test("formatAgentOpenApi: mcp interface present → x-gogol-mcp is set", () => {
+  const manifest = buildAgentSurfaceManifest({
+    site: "s",
+    baseUrl: "https://s.example",
+    languages: { default: "de", supported: ["de"] },
+    mcp: { url: "/api/agent/mcp", protocolVersion: "2025-06-18" },
+  });
+  const doc = formatAgentOpenApi(manifest, []);
+  expect(doc["x-gogol-mcp"]).toEqual({ url: "/api/agent/mcp", protocolVersion: "2025-06-18" });
+});

package/src/share/tests/organization-jsonld.test.ts

@@ -0,0 +1,74 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>RFC-0745: test that buildOrganizationNode emits priceCurrency in makesOffer Offer nodes when currency is available.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0745: initial test for priceCurrency in makesOffer Offer nodes.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, expect, it } from "vitest";
+import { buildOrganizationNode } from "../semantic/jsonld/organization.ts";
+import { createJsonLdContext } from "../semantic/jsonld/context.ts";
+import type { SemanticPageModel, SemanticOrganization } from "../semantic/models.ts";
+
+function makeOrgWithPrices(
+  prices: Array<{ id: string; label: string; amount: string; currency?: string }>,
+): SemanticOrganization {
+  return {
+    name: "Test Org",
+    description: "Test organization",
+    url: "https://example.com",
+    offer: { prices },
+  };
+}
+
+function makeModel(org: SemanticOrganization): SemanticPageModel {
+  return {
+    type: "home",
+    lang: "de",
+    url: "https://example.com/de",
+    title: "Test Page",
+    description: "Test description",
+    breadcrumbs: [],
+    blocks: [],
+    organization: org,
+  };
+}
+
+describe("RFC-0745: buildOrganizationNode makesOffer priceCurrency", () => {
+  it("emits priceCurrency when SemanticPrice has currency", () => {
+    const org = makeOrgWithPrices([
+      { id: "monthly", label: "Monthly", amount: "70.00", currency: "EUR" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    const makesOffer = node.makesOffer as Array<Record<string, unknown>>;
+    expect(makesOffer).toHaveLength(1);
+    expect(makesOffer[0].priceCurrency).toBe("EUR");
+    const priceSpec = makesOffer[0].priceSpecification as Record<string, unknown>;
+    expect(priceSpec.price).toBe("70.00");
+  });
+
+  it("omits priceCurrency when SemanticPrice has no currency", () => {
+    const org = makeOrgWithPrices([{ id: "monthly", label: "Monthly", amount: "70.00" }]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    const makesOffer = node.makesOffer as Array<Record<string, unknown>>;
+    expect(makesOffer).toHaveLength(1);
+    expect(makesOffer[0].priceCurrency).toBeUndefined();
+  });
+
+  it("emits priceCurrency for each offer when multiple prices have currency", () => {
+    const org = makeOrgWithPrices([
+      { id: "monthly", label: "Monthly", amount: "70.00", currency: "EUR" },
+      { id: "yearly", label: "Yearly", amount: "840.00", currency: "EUR" },
+    ]);
+    const context = createJsonLdContext(makeModel(org));
+    const node = buildOrganizationNode(context);
+    const makesOffer = node.makesOffer as Array<Record<string, unknown>>;
+    expect(makesOffer).toHaveLength(2);
+    expect(makesOffer[0].priceCurrency).toBe("EUR");
+    expect(makesOffer[1].priceCurrency).toBe("EUR");
+  });
+});