@openwop/openwop-conformance 1.6.1 → 1.11.0

package/schemas/trigger-subscription.schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openwop.dev/spec/v1/trigger-subscription.schema.json",
+  "title": "TriggerSubscription",
+  "description": "RFC 0083 §B. A durable inbound-trigger subscription record (a webhook registration, a schedule, a queue consumer) with a standardized four-state machine layered over the existing per-source registration. Composes RFC 0052/0053/0017 + webhooks.md + RFC 0040 causation; the channel wire format stays a vendor extension (§E). Content-free of inbound payloads/credentials (SR-1).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["subscriptionId", "source", "state"],
+  "properties": {
+    "subscriptionId": { "type": "string", "minLength": 1, "description": "Stable host-unique id for the subscription. Correlates the §C delivery events + the management surface." },
+    "source": { "type": "string", "enum": ["webhook", "schedule", "queue", "email", "form"], "description": "Which trigger source backs the subscription. Channels beyond these (Slack/Discord/SMS) bridge as a vendor extension by registering a subscription of the closest source kind (§E)." },
+    "state": { "type": "string", "enum": ["active", "paused", "failed", "dead-lettered"], "description": "The §B state. `active`: accepting + delivering; `paused`: retained, not delivering (operator-held); `failed`: delivery failing past policy (the webhooks.md circuit-breaker generalized); `dead-lettered`: terminal, deliveries routed to the RFC 0053 sink." },
+    "dedupEnabled": { "type": "boolean", "description": "When true, the host de-duplicates inbound events by `dedupKey` within the retention window (§C-1; the idempotency.md Layer-1 model applied to inbound triggers)." },
+    "retryPolicy": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Delivery retry policy (§C-2). On exhaustion the subscription/delivery transitions to `dead-lettered` (RFC 0053).",
+      "properties": {
+        "maxAttempts": { "type": "integer", "minimum": 1, "description": "Maximum delivery attempts before dead-lettering." },
+        "backoff": { "type": "string", "enum": ["none", "fixed", "exponential"], "description": "Backoff strategy between attempts." }
+      }
+    },
+    "webhookId": { "type": "string", "minLength": 1, "description": "MAY — for `source: \"webhook\"`, the existing webhooks.md register key (unchanged; the state machine layers over it)." },
+    "secretFingerprint": { "type": "string", "minLength": 1, "maxLength": 32, "description": "MAY — for `source: \"webhook\"`, an identifier for the signing secret (the `(webhookId, secretFingerprint)` register key). It MUST be a **salted or host-keyed, TRUNCATED** one-way digest (e.g. the first 8–16 hex of `HMAC(hostKey, secret)`) — NOT the raw secret (SR-1) and NOT a full unsalted `SHA256(secret)` (a full unsalted hash of a low-entropy secret is an offline brute-force / confirmation oracle). The `maxLength: 32` ceiling structurally rejects a full 64-hex digest." }
+  }
+}

package/schemas/workflow-definition.schema.json

@@ -138,6 +138,11 @@
         },
         "credentialsRef": { "type": "string" },
         "settings": { "type": "object" },
+        "outputRole": {
+          "type": "string",
+          "enum": ["primary", "secondary"],
+          "description": "RFC 0065 — author hint that this terminal node's output is the workflow's primary deliverable (`primary`) or an auxiliary output (`secondary`). Advisory: hosts MUST execute the workflow identically regardless of value. Tooling MAY use the hint to pick which of N terminal nodes' outputs to surface as the run's canonical artifact. Unknown values + absent values fall back to default behavior (show all terminal outputs)."
+        },
         "disabled": { "type": "boolean", "default": false },
         "notes": { "type": "string" },
         "groupId": { "type": "string" },

package/schemas/workspace-file-create.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openwop.dev/spec/v1/workspace-file-create.schema.json",
+  "title": "WorkspaceFileCreate",
+  "description": "RFC 0059. Request body for `PUT /v1/host/workspace/files/{path}` (atomic create/replace). The `path` is taken from the URL and MUST NOT be supplied here; the host assigns `version`, `etag`, and `updatedAt`. The client supplies only `content` and an optional `contentType`. Optimistic concurrency is expressed via the `If-Match` request header (the file's current `etag`), NOT a body field — a stale `If-Match` returns `409 workspace_conflict`. A `content` exceeding `capabilities.workspace.maxFileBytes` returns `workspace_too_large`. The response is a full `workspace-file.schema.json`.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["content"],
+  "properties": {
+    "content": {
+      "type": "string",
+      "description": "UTF-8 file body to persist. SR-1-redacted on write per RFC 0059 §E WSR-1."
+    },
+    "contentType": {
+      "type": "string",
+      "default": "text/markdown",
+      "description": "Advisory MIME type of `content`. Defaults to `text/markdown`."
+    }
+  }
+}

package/schemas/workspace-file.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openwop.dev/spec/v1/workspace-file.schema.json",
+  "title": "WorkspaceFile",
+  "description": "RFC 0059. A versioned, tenant·workspace-scoped ground-truth file in the `host.workspace` store. Returned by `GET /v1/host/workspace/files/{path}` and `PUT …/{path}`; the `list` endpoint returns the same shape minus `content` (metadata only). `path` is a flat namespace with `/`-in-names (NOT nested directories) — no `..`, no leading `/` (the pattern enforces this). Writes are atomic and optimistically concurrent via the `etag` token (`If-Match`). When `capabilities.workspace.versioned: true`, prior versions are retrievable via `?version=N`. Content is SR-1-redacted on write (RFC 0059 §E WSR-1) — never the BYOK plaintext.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["path", "content", "version", "updatedAt"],
+  "properties": {
+    "path": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$",
+      "description": "Workspace-relative path. Flat namespace with `/`-in-names; MUST NOT contain `..` or a leading `/` (the pattern forbids both). Stable identity of the file within the `{tenant, workspace}` scope."
+    },
+    "content": {
+      "type": "string",
+      "description": "UTF-8 file body. SR-1-redacted on write per RFC 0059 §E WSR-1 — a value the run's BYOK vault resolved is persisted as `[REDACTED:<secretId>]`, never the plaintext."
+    },
+    "contentType": {
+      "type": "string",
+      "default": "text/markdown",
+      "description": "Advisory MIME type of `content`. Defaults to `text/markdown` (the ground-truth-file convention)."
+    },
+    "version": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Monotonic version. 1 on first create; each successful `PUT` bumps it by one. The latest version is always retrievable; historical versions are best-effort up to `capabilities.workspace.maxVersions`."
+    },
+    "etag": {
+      "type": "string",
+      "description": "Opaque version token for `If-Match` optimistic concurrency. A `PUT` carrying a stale `If-Match` MUST be refused with `409 workspace_conflict`."
+    },
+    "updatedAt": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of the write that produced this version."
+    }
+  }
+}

package/src/lib/agentLoop.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared helper for the RFC 0061 stateful agent-loop-lifecycle
+ * (`multiAgent.executionModel.version: 5`) conformance scenarios. Lives in lib/
+ * (not a *.test.ts) so scenarios import it via `../lib/agentLoop.js`.
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** Reads `multiAgent.executionModel` from discovery (root-first per RFC 0073);
+ *  null when the host advertises no execution model (treated as no support). */
+export async function readExecutionModelCap(): Promise<Record<string, unknown> | null> {
+  const ma = await readCapabilityFamily<{ executionModel?: unknown }>('multiAgent');
+  const em = ma?.executionModel;
+  return em && typeof em === 'object' ? (em as Record<string, unknown>) : null;
+}
+
+/** True when the host advertises `executionModel.version >= 5`. */
+export function isVersion5(em: Record<string, unknown> | null): boolean {
+  return typeof em?.version === 'number' && (em.version as number) >= 5;
+}
+
+/** True when the host advertises `workspace.supported: true` (root-first per RFC 0073). */
+export async function hasWorkspace(): Promise<boolean> {
+  const ws = await readCapabilityFamily<{ supported?: unknown }>('workspace');
+  return ws?.supported === true;
+}
+
+interface LoopResult {
+  decisions?: Array<{ iteration?: unknown }>;
+  workspaceVisible?: { atWriteTurn?: unknown; atNextTurn?: unknown };
+  resumedIteration?: unknown;
+}
+
+/** Drives one bounded stateful loop via the host-sample seam, or null
+ *  (soft-skip) when the host doesn't expose it. The seam is host-extension
+ *  surface specified in host-sample-test-seams.md §"Open seams":
+ *  `POST /v1/host/sample/agentloop/run` returns the ordered
+ *  `runOrchestrator.decided` payloads (each carrying `iteration`) the host
+ *  would emit, plus optional workspace-visibility + resume reports. */
+export async function invokeAgentLoop(body: Record<string, unknown>): Promise<LoopResult | null> {
+  const res = await driver.post('/v1/host/sample/agentloop/run', body);
+  if (res.status === 404 || res.status === 405) return null; // seam absent — soft-skip
+  return (res.json as LoopResult | undefined) ?? {};
+}

package/src/lib/agentRoster.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared helpers for the RFC 0086 `agents.roster` conformance scenarios.
+ * Lives in lib/ (not a `*.test.ts`) so scenarios import it via
+ * `../lib/agentRoster.js`.
+ *
+ * Two surfaces:
+ *   - the NORMATIVE read (`GET /v1/agents/roster[/{rosterId}]`, RFC 0086 §B),
+ *     exercised black-box against any conformant host; and
+ *   - the host-sample fire seam (`POST /v1/host/sample/roster/fire`), used to
+ *     drive a portfolio trigger so the `roster.run.initiated` attribution +
+ *     ordering can be asserted against the test event-log seam. The fire seam
+ *     is OPTIONAL — scenarios soft-skip on 404/405 (the reference roster store
+ *     is deferred per RFC 0086 §Conformance).
+ *
+ * @see RFCS/0086-standing-agent-roster-and-workflow-portfolio.md
+ * @see spec/v1/agent-roster.md
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** Reads `agents.roster` from discovery (root-first per RFC 0073); null when
+ *  unadvertised. */
+export async function readRosterCap(): Promise<Record<string, unknown> | null> {
+  const agents = await readCapabilityFamily<{ roster?: unknown }>('agents');
+  const r = agents?.roster;
+  return r && typeof r === 'object' ? (r as Record<string, unknown>) : null;
+}
+
+export interface RosterEntry {
+  rosterId?: string;
+  persona?: string;
+  agentRef?: { agentId?: string; version?: string; channel?: string };
+  workflows?: string[];
+  owner?: { tenantId?: string; workspaceId?: string };
+  [k: string]: unknown;
+}
+
+export interface RosterResponse {
+  roster?: RosterEntry[];
+  total?: number;
+}
+
+/** GET the NORMATIVE standing roster (RFC 0086 §B `GET /v1/agents/roster`);
+ *  null when the host doesn't serve it (404/405/501). */
+export async function listRoster(): Promise<RosterResponse | null> {
+  const res = await driver.get('/v1/agents/roster');
+  if (res.status === 404 || res.status === 405 || res.status === 501) return null;
+  return (res.json as RosterResponse | undefined) ?? {};
+}
+
+/** GET a single roster entry by id. Returns `{ status, entry }` so a caller can
+ *  distinguish a 404 (cross-tenant / unknown) from a served entry. */
+export async function getRosterEntry(
+  rosterId: string,
+): Promise<{ status: number; entry: RosterEntry | undefined }> {
+  const res = await driver.get(`/v1/agents/roster/${encodeURIComponent(rosterId)}`);
+  return { status: res.status, entry: res.json as RosterEntry | undefined };
+}
+
+export interface RosterFireResult {
+  runId?: string;
+  rosterId?: string;
+  triggerSubscriptionId?: string;
+}
+
+/** Drive a portfolio trigger for a roster member via the host-sample fire seam.
+ *  `asWorkItem:true` requests the RFC 0083 durable-work-item path (carries a
+ *  `triggerSubscriptionId` + run `causationId`). Returns null when the seam is
+ *  unwired (404/405). */
+export async function fireRosterPortfolio(
+  body: { rosterId?: string; triggerSource?: string; asWorkItem?: boolean } = {},
+): Promise<RosterFireResult | null> {
+  const res = await driver.post('/v1/host/sample/roster/fire', body);
+  if (res.status === 404 || res.status === 405) return null;
+  return (res.json as RosterFireResult | undefined) ?? {};
+}

package/src/lib/agentRuntime.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared helper for the RFC 0070 agents.manifestRuntime conformance scenario.
+ * Lives in lib/ (not a *.test.ts) so scenarios import it via `../lib/agentRuntime.js`.
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** Reads `agents.manifestRuntime` from discovery (root-first per RFC 0073);
+ *  null when unadvertised. */
+export async function readManifestRuntimeCap(): Promise<Record<string, unknown> | null> {
+  const agents = await readCapabilityFamily<{ manifestRuntime?: unknown }>('agents');
+  const mr = agents?.manifestRuntime;
+  return mr && typeof mr === 'object' ? (mr as Record<string, unknown>) : null;
+}
+
+interface AgentInventory {
+  agents?: Array<{ agentId?: string; [k: string]: unknown }>;
+  total?: number;
+}
+
+/** GET the NORMATIVE manifest-agent inventory (RFC 0072 §A `GET /v1/agents`);
+ *  null when the host doesn't advertise the capability (404/405/501). */
+export async function listManifestAgents(): Promise<AgentInventory | null> {
+  const res = await driver.get('/v1/agents');
+  if (res.status === 404 || res.status === 405 || res.status === 501) return null;
+  return (res.json as AgentInventory | undefined) ?? {};
+}
+
+export interface DispatchResult {
+  agentId?: string;
+  status?: string;
+  toolSurface?: string[];
+  confidence?: number;
+  threshold?: number;
+  events?: Array<{ type?: string; agentId?: string; decision?: string; [k: string]: unknown }>;
+  result?: unknown;
+  error?: { code?: string; message?: string };
+}
+
+/** Dispatch one manifest-agent turn via the host-sample seam; null when absent. */
+export async function dispatchAgent(agentId: string, body: Record<string, unknown>): Promise<DispatchResult | null> {
+  const res = await driver.post(`/v1/host/sample/agents/${encodeURIComponent(agentId)}/dispatch`, body);
+  if (res.status === 404 || res.status === 405) return null;
+  return (res.json as DispatchResult | undefined) ?? {};
+}

package/src/lib/artifactTypes.ts

@@ -0,0 +1,96 @@
+/**
+ * Shared helpers for the RFC 0071 host.artifactTypes conformance scenarios.
+ * Lives in lib/ (not a *.test.ts) so scenarios import it via `../lib/artifactTypes.js`.
+ *
+ * The behavioral scenarios drive a documented host-extension seam — hosts
+ * wiring RFC 0071 Phase 1 (artifact-type packs) expose:
+ *
+ *   POST /v1/host/sample/artifacttypes/install
+ *     body: { manifest: <artifact-type-pack manifest>,
+ *             schemas: { "<artifactTypeId>": <JSON Schema> } }
+ *     → 2xx { installed: true, artifactTypeIds: string[] }
+ *
+ *   POST /v1/host/sample/artifacttypes/produce
+ *     body: { artifactTypeId: string, payload: unknown }
+ *     → 2xx {
+ *         artifactId: string,
+ *         registered: boolean,   // matched an installed artifact-type pack
+ *         validated: boolean,    // payload checked against the pack schema
+ *         stored: boolean,       // persisted (host.artifactTypes.store)
+ *         rendered: boolean,     // a renderer ran (host.artifactTypes.render)
+ *         runStatus: 'completed' | 'failed',
+ *         artifactCreated?: { registered?: boolean, artifactType?: string }  // the emitted event
+ *       }
+ *
+ * Either seam returning 404/405 means the host hasn't wired it → soft-skip.
+ */
+import { driver } from './driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+  // host.* capabilities may also appear top-level per host-capabilities.md §"The contract pattern".
+  [k: string]: unknown;
+}
+
+/** Reads `host.artifactTypes` from discovery (capabilities block or top-level); null when unadvertised. */
+export async function readArtifactTypesCap(): Promise<Record<string, unknown> | null> {
+  const res = await driver.get('/.well-known/openwop');
+  const doc = res.json as DiscoveryDoc | undefined;
+  const fromCaps = doc?.capabilities && typeof doc.capabilities === 'object'
+    ? (doc.capabilities as Record<string, unknown>)['host.artifactTypes']
+    : undefined;
+  const cap = fromCaps ?? doc?.['host.artifactTypes'];
+  return cap && typeof cap === 'object' ? (cap as Record<string, unknown>) : null;
+}
+
+export function artifactTypesSupported(cap: Record<string, unknown> | null): boolean {
+  return cap?.['supported'] === true;
+}
+
+/** Installs an artifact-type pack via the host-sample seam, or null (soft-skip) when absent. */
+export async function installArtifactTypePack(
+  manifest: unknown,
+  schemas: Record<string, unknown>,
+): Promise<{ status: number; json: unknown } | null> {
+  const res = await driver.post('/v1/host/sample/artifacttypes/install', { manifest, schemas });
+  if (res.status === 404 || res.status === 405) return null;
+  return { status: res.status, json: res.json };
+}
+
+/** Produces an artifact of `artifactTypeId` via the host-sample seam, or null (soft-skip) when absent. */
+export async function produceArtifact(
+  artifactTypeId: string,
+  payload: unknown,
+): Promise<{ status: number; json: Record<string, unknown> } | null> {
+  const res = await driver.post('/v1/host/sample/artifacttypes/produce', { artifactTypeId, payload });
+  if (res.status === 404 || res.status === 405) return null;
+  return { status: res.status, json: (res.json ?? {}) as Record<string, unknown> };
+}
+
+/** A minimal valid artifact-type pack + schema pair the scenarios install. */
+export function sampleArtifactTypePack() {
+  const artifactTypeId = 'vendor.conformance.note';
+  const manifest = {
+    kind: 'artifact-type',
+    name: 'vendor.conformance.notes',
+    version: '1.0.0',
+    engines: { openwop: '>=1.1' },
+    artifactTypes: [
+      {
+        artifactTypeId,
+        schemaVersion: 1,
+        schemaRef: 'schemas/note.schema.json',
+        rendering: { display: 'markdown' },
+      },
+    ],
+  };
+  const schema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://h.example/schemas/artifacts/vendor.conformance.note.schema.json',
+    type: 'object',
+    additionalProperties: false,
+    required: ['title', 'body'],
+    properties: { title: { type: 'string' }, body: { type: 'string' } },
+  };
+  return { artifactTypeId, manifest, schema };
+}

package/src/lib/cardPacks.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared helpers for the RFC 0071 Phase 2 host.chat.cardPacks conformance scenarios.
+ * Lives in lib/ so scenarios import it via `../lib/cardPacks.js`.
+ *
+ * Hosts wiring chat card packs expose a documented host-extension seam:
+ *
+ *   POST /v1/host/sample/cardpacks/execute
+ *     body: { cardTypeId: string, inputs: Record<string, unknown> }
+ *     → 2xx {
+ *         artifactId?: string,
+ *         registered?: boolean,        // output validated against the linked outputArtifactType
+ *         validated?: boolean,
+ *         contentTrust?: 'trusted' | 'untrusted',   // the composed-envelope trust tag (R2)
+ *         runStatus?: 'completed' | 'failed',
+ *         artifactCreated?: { registered?: boolean, artifactType?: string }
+ *       }
+ *
+ * A 404/405 means the host hasn't wired the seam → soft-skip.
+ */
+import { driver } from './driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+  [k: string]: unknown;
+}
+
+/** Reads `host.chat.cardPacks` (or the `host.chat` block's `cardPacks` facet) from discovery; null when unadvertised. */
+export async function readCardPacksCap(): Promise<Record<string, unknown> | null> {
+  const res = await driver.get('/.well-known/openwop');
+  const doc = res.json as DiscoveryDoc | undefined;
+  const caps = doc?.capabilities && typeof doc.capabilities === 'object' ? (doc.capabilities as Record<string, unknown>) : undefined;
+  // Accept either a discrete `host.chat.cardPacks` key or a `cardPacks` facet under `host.chat`.
+  const direct = caps?.['host.chat.cardPacks'] ?? doc?.['host.chat.cardPacks'];
+  if (direct && typeof direct === 'object') return direct as Record<string, unknown>;
+  const chat = caps?.['host.chat'] ?? doc?.['host.chat'];
+  const facet = chat && typeof chat === 'object' ? (chat as Record<string, unknown>)['cardPacks'] : undefined;
+  return facet && typeof facet === 'object' ? (facet as Record<string, unknown>) : null;
+}
+
+export function cardPacksSupported(cap: Record<string, unknown> | null): boolean {
+  return cap?.['supported'] === true;
+}
+
+/** Executes a registered card via the host-sample seam, or null (soft-skip) when absent. */
+export async function executeCard(
+  cardTypeId: string,
+  inputs: Record<string, unknown>,
+): Promise<{ status: number; json: Record<string, unknown> } | null> {
+  const res = await driver.post('/v1/host/sample/cardpacks/execute', { cardTypeId, inputs });
+  if (res.status === 404 || res.status === 405) return null;
+  return { status: res.status, json: (res.json ?? {}) as Record<string, unknown> };
+}

package/src/lib/discovery-capabilities.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared root-first reader for `/.well-known/openwop` capability families.
+ *
+ * Per `spec/v1/capabilities.md` §"Document-root layout" (RFC 0073), every
+ * capability family (`agents`, `secrets`, `aiProviders`, `auth`, `memory`,
+ * `multiAgent`, `authorization`, …) is a property of the discovery document
+ * ROOT — `capabilities.schema.json` defines no `capabilities` wrapper property.
+ * A top-level `capabilities` object is a deprecated legacy shape; the suite
+ * reads the root first and falls back to a `capabilities.*` wrapper only
+ * through the v1.x migration window. Standardizes the ad-hoc dual-read that
+ * already existed (e.g. `aiEnvelope.capBreached.test.ts`,
+ * `ai-envelope-shape.test.ts`) into one accessor so every helper reads the
+ * same way.
+ *
+ * @see spec/v1/capabilities.md §"Document-root layout"
+ * @see RFCS/0073-capability-document-root-layout.md
+ */
+import { driver } from './driver.js';
+
+/**
+ * Read one capability family from an already-fetched discovery doc: document
+ * root first, deprecated `capabilities.*` wrapper as a fallback. Returns
+ * `undefined` when the family is advertised in neither location.
+ */
+export function capabilityFamily<T = Record<string, unknown>>(
+  doc: unknown,
+  name: string,
+): T | undefined {
+  if (!doc || typeof doc !== 'object') return undefined;
+  const root = (doc as Record<string, unknown>)[name];
+  if (root !== undefined) return root as T;
+  const wrapper = (doc as { capabilities?: unknown }).capabilities;
+  if (wrapper && typeof wrapper === 'object') {
+    return (wrapper as Record<string, unknown>)[name] as T | undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Fetch `/.well-known/openwop` and return one capability family (root-first,
+ * wrapper-fallback). `undefined` when the host returns non-200 or doesn't
+ * advertise the family.
+ */
+export async function readCapabilityFamily<T = Record<string, unknown>>(
+  name: string,
+): Promise<T | undefined> {
+  const res = await driver.get('/.well-known/openwop');
+  if (res.status !== 200) return undefined;
+  return capabilityFamily<T>(res.json, name);
+}

package/src/lib/distillation.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared helper for the RFC 0062 scheduled-memory-distillation ("dreams")
+ * conformance scenarios. Lives in lib/ (not a *.test.ts) so scenarios import it
+ * via `../lib/distillation.js`.
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** Reads `memory.distillation` from discovery (root-first per RFC 0073); null
+ *  when the host advertises no distillation sub-block (treated as no support). */
+export async function readDistillationCap(): Promise<Record<string, unknown> | null> {
+  const memory = await readCapabilityFamily<{ distillation?: unknown }>('memory');
+  const d = memory?.distillation;
+  return d && typeof d === 'object' ? (d as Record<string, unknown>) : null;
+}
+
+interface DistillResult {
+  event?: { distillation?: { tokenBudget?: unknown; tokensUsed?: unknown; indexUpdated?: unknown } };
+  error?: unknown;
+  archiveChecksum?: unknown;
+  indexUpdated?: unknown;
+  indexFile?: unknown;
+}
+
+/** Drives one budgeted distillation run via the host-sample seam, or null
+ *  (soft-skip) when the host doesn't expose it. The seam is host-extension
+ *  surface specified in host-sample-test-seams.md §"Open seams":
+ *  `POST /v1/host/sample/memory/distill` returns the `memory.compacted` event
+ *  (with the additive RFC 0062 `distillation` sub-object) the host would emit,
+ *  plus the stable archive's checksum. Returns the raw status alongside the
+ *  body so scenarios can assert the `token_budget_exceeded` failure path. */
+export async function invokeDistill(
+  body: Record<string, unknown>,
+): Promise<{ status: number; body: DistillResult } | null> {
+  const res = await driver.post('/v1/host/sample/memory/distill', body);
+  if (res.status === 404 || res.status === 405) return null; // seam absent — soft-skip
+  return { status: res.status, body: (res.json as DistillResult | undefined) ?? {} };
+}

package/src/lib/feedback.ts

@@ -19,10 +19,10 @@ export async function readFeedbackCap(): Promise<Record<string, unknown> | null>
   return fb && typeof fb === 'object' ? (fb as Record<string, unknown>) : null;
 }
 
-const SEED_FIXTURE = 'conformance-a';
+const SEED_FIXTURE = 'conformance-noop';
 
-/** Seeds a run via the basic `conformance-a` fixture; null (soft-skip) when
- *  the fixture isn't advertised or creation fails. */
+/** Seeds a run via the basic `conformance-noop` fixture; null (soft-skip)
+ *  when the fixture isn't advertised or creation fails. */
 export async function seedRun(tenantId: string): Promise<string | null> {
   if (!isFixtureAdvertised(SEED_FIXTURE)) return null;
   const r = await driver.post('/v1/runs', { workflowId: SEED_FIXTURE, tenantId, inputs: {} });

package/src/lib/heartbeat.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared helper for the RFC 0060 host.heartbeat conformance scenarios.
+ * Lives in lib/ (not a *.test.ts) so scenarios import it via `../lib/heartbeat.js`.
+ */
+import { driver } from './driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+}
+
+/** Reads `capabilities.heartbeat` from discovery; null when unadvertised. */
+export async function readHeartbeatCap(): Promise<Record<string, unknown> | null> {
+  const res = await driver.get('/.well-known/openwop');
+  const caps = (res.json as DiscoveryDoc | undefined)?.capabilities;
+  const hb = caps && typeof caps === 'object' ? (caps as Record<string, unknown>)['heartbeat'] : undefined;
+  return hb && typeof hb === 'object' ? (hb as Record<string, unknown>) : null;
+}
+
+/** True when the host advertises a working heartbeat surface. */
+export function heartbeatSupported(cap: Record<string, unknown> | null): boolean {
+  return cap?.['supported'] === true;
+}
+
+/** Drives one heartbeat tick via the host-sample seam, or null (soft-skip)
+ *  when the host doesn't expose it. The seam is host-extension surface —
+ *  hosts wiring RFC 0060 expose `POST /v1/host/sample/heartbeat/tick`. */
+export async function tickHeartbeat(body: Record<string, unknown>): Promise<{ status: number; json: unknown } | null> {
+  const res = await driver.post('/v1/host/sample/heartbeat/tick', body);
+  if (res.status === 404 || res.status === 405) return null; // seam absent — soft-skip
+  return { status: res.status, json: res.json };
+}

package/src/lib/liveRuntime.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared helpers for the RFC 0077 `agents.liveRuntime` conformance scenarios.
+ * Lives in lib/ (not a `*.test.ts`) so scenarios import it via
+ * `../lib/liveRuntime.js`.
+ *
+ * RFC 0077 adds NO new endpoint — a live manifest invocation rides the existing
+ * run surface (agent as root of `POST /v1/runs`, a `WorkflowNode.agent` step, or
+ * a chat `@mention`) and brackets the existing `agent.*` family with
+ * `agent.invocation.started` / `agent.invocation.completed`. To drive one
+ * deterministically in conformance, the host exposes the OPTIONAL sample seam
+ * `POST /v1/host/sample/agents/live-invoke` returning `{ runId, invocationId }`;
+ * the bracketed events are read back via the test event-log seam. The seam is
+ * deferred per RFC 0077 §Conformance, so scenarios soft-skip on 404/405.
+ *
+ * @see RFCS/0077-agent-run-lifecycle-and-live-manifest-dispatch.md
+ * @see spec/v1/multi-agent-execution.md §"Live manifest dispatch"
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** Reads `agents.liveRuntime` from discovery (root-first per RFC 0073); null
+ *  when unadvertised. */
+export async function readLiveRuntimeCap(): Promise<Record<string, unknown> | null> {
+  const agents = await readCapabilityFamily<{ liveRuntime?: unknown }>('agents');
+  const lr = agents?.liveRuntime;
+  return lr && typeof lr === 'object' ? (lr as Record<string, unknown>) : null;
+}
+
+export interface LiveInvokeResult {
+  runId?: string;
+  invocationId?: string;
+  outcome?: string;
+}
+
+/**
+ * Drive one live manifest invocation via the host-sample seam. Body fields:
+ *   - `agentId` (optional): the manifest agent to invoke; host picks a default
+ *     when omitted.
+ *   - `source` (optional): `workflow-node` | `run-api` | `chat-mention`.
+ *   - `returnSchemaRef` (optional) + `forceInvalidResult` (optional): exercise
+ *     the §B step-6 structured-output enforcement — force a result that violates
+ *     the handoff schema so a `structuredOutput` host fails the run.
+ *   - `attemptTool` (optional): the id of a tool OUTSIDE the agent's
+ *     `toolAllowlist` the invocation should attempt (the §F-1 allowlist floor).
+ * Returns null when the seam is unwired (404/405).
+ */
+export async function invokeLive(
+  body: {
+    agentId?: string;
+    source?: string;
+    returnSchemaRef?: string;
+    forceInvalidResult?: boolean;
+    attemptTool?: string;
+  } = {},
+): Promise<LiveInvokeResult | null> {
+  const res = await driver.post('/v1/host/sample/agents/live-invoke', body);
+  if (res.status === 404 || res.status === 405) return null;
+  return (res.json as LiveInvokeResult | undefined) ?? {};
+}