@openwop/openwop-conformance 1.57.0 → 1.62.0

package/schemas/form-content-pack-manifest.schema.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openwop.dev/spec/v1/form-content-pack-manifest.schema.json",
+  "title": "FormContentPackManifest",
+  "description": "Manifest for a published OpenWOP form-content pack — `pack.json` at the pack root with `kind: \"form-content\"`. Peer to the node / workflow-chain / prompt / artifact-type / card pack manifests; disjoint via the `kind` discriminator. See `spec/v1/form-content-packs.md` for the canonical contract and RFC 0137 for the rationale.\n\nA form-content pack distributes **form templates**: a named, versioned set of typed input fields a host instantiates into an ordinary, fully editable form through its normal create path. It is purely declarative — no `runtime`, no executor bytecode, no entry point. The pack contributes the *shape* of a form; it does not define a submission surface, a handler, or any behavior the host would not otherwise accept.\n\n**A template carries NO submission routing, and MUST NOT gain any.** There is deliberately no `intakeBinding` / destination / webhook / list-id property on `FormTemplate`, and `additionalProperties: false` rejects one. Where a tenant's form submissions go is a decision about the OPERATOR's data; a third-party pack author does not get to make it by shipping a manifest. Enforced as the `form-content-template-no-submission-routing` SECURITY invariant — see `form-content-packs.md` §\"No submission routing\".\n\n**The wire vocabulary governs the WIRE, not host storage.** A host MAY store fields under any internal representation it likes and translate at the pack boundary; the spec constrains what crosses the wire, not what sits in a host's database (`positioning.md`).\n\n**Field types are the RFC 0071 portable subset, not a second vocabulary.** `fields[].type` reuses the closed portable subset defined in `chat-card-packs.md` §\"Input fields — a closed portable subset\" (RFC 0071 Phase 2, gap G9 resolved 2026-05-27) verbatim, including its `vendor.<org>.<kind>` / `x-<kind>` extension escape hatch. Two declarative pack kinds that both collect typed user input MUST agree on what a field type means.",
+  "type": "object",
+  "required": ["name", "version", "kind", "engines", "templates"],
+  "additionalProperties": false,
+  "properties": {
+    "kind": {
+      "type": "string",
+      "const": "form-content",
+      "description": "Pack kind discriminator. MUST be the literal string `\"form-content\"`."
+    },
+    "name": {
+      "type": "string",
+      "description": "Reverse-DNS pack name per `node-packs.md` §Naming. Reserved scopes are identical (`core.*` / `vendor.<org>.*` / `community.<author>.*` / `private.<host>.*`).",
+      "pattern": "^(core|vendor|community|private)\\.[a-z][a-z0-9_-]*(\\.[a-z][a-zA-Z0-9_-]*)+$",
+      "minLength": 1,
+      "maxLength": 256
+    },
+    "version": {
+      "type": "string",
+      "description": "Pack-level SemVer 2.0.0.",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$"
+    },
+    "description": { "type": "string", "maxLength": 1024 },
+    "author": { "type": "string" },
+    "license": { "type": "string", "description": "SPDX license identifier (e.g., `Apache-2.0`, `MIT`)." },
+    "homepage": { "type": "string", "format": "uri" },
+    "repository": { "type": "string", "format": "uri" },
+    "keywords": {
+      "type": "array",
+      "items": { "type": "string", "maxLength": 64 },
+      "maxItems": 50
+    },
+    "engines": {
+      "type": "object",
+      "required": ["openwop"],
+      "properties": {
+        "openwop": { "type": "string", "description": "Semver range — which openwop protocol versions this pack works against." }
+      },
+      "additionalProperties": true
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": { "type": "string" },
+      "description": "Other packs this pack depends on. Map of pack name → semver range."
+    },
+    "peerDependencies": {
+      "type": "object",
+      "additionalProperties": { "type": "string" },
+      "description": "Engine-supplied capabilities the pack consumes (e.g., `{ \"host.forms.contentPacks\": \"supported\" }`). Resolved against the host's advertised capabilities at register time."
+    },
+    "templates": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 100,
+      "items": { "$ref": "#/$defs/FormTemplate" },
+      "description": "Form template definitions this pack contributes. Each MUST have a unique `templateId` within the pack — duplicates MUST be refused at registry `PUT` / install (`form-content-packs.md` §\"Unique identifiers\"); JSON Schema cannot express uniqueness-by-property, so this is a normative prose requirement, as it is for every peer pack kind. `maxItems` is an OUTER resource bound against a render bomb, not product policy — a host MAY enforce a tighter limit locally."
+    },
+    "signing": { "$ref": "#/$defs/Signing" }
+  },
+  "$defs": {
+    "FormTemplate": {
+      "type": "object",
+      "required": ["templateId", "version", "label", "title", "fields"],
+      "additionalProperties": false,
+      "properties": {
+        "templateId": {
+          "type": "string",
+          "description": "Reverse-DNS template identifier. Same pattern and reserved scopes as a pack `name`. This is the id a registry denormalizes for discovery (`registry-operations.md` §\"Type-ID indexing\") and the id a host resolves when instantiating. Third parties MUST NOT publish under `core.*`.",
+          "pattern": "^(core|vendor|community|private)\\.[a-z][a-z0-9_-]*(\\.[a-z][a-zA-Z0-9_-]*)+$",
+          "minLength": 1,
+          "maxLength": 256
+        },
+        "version": {
+          "type": "string",
+          "description": "Per-template SemVer 2.0.0 — the SAME axis as the pack `version`, NOT the non-negative-integer schema-version axis used by `chat-card-pack-manifest.schema.json` `schemaVersion` / `artifact-type-pack-manifest.schema.json` `schemaVersion`. A form template is a distributable artifact whose shape changes are author-meaningful (a removed field is a breaking change to anything storing its submissions), so it carries the same SemVer contract as the pack.",
+          "pattern": "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$"
+        },
+        "label": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 200,
+          "description": "Short human-readable name for a picker / gallery listing. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\". The length bound is a resource guard, NOT a trust boundary."
+        },
+        "title": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 200,
+          "description": "Heading rendered above the instantiated form. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\"."
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 300,
+          "description": "Optional explanatory copy. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\"."
+        },
+        "category": {
+          "type": "string",
+          "maxLength": 64,
+          "description": "Optional grouping hint for a picker. Advisory — the spec assigns no meaning to any particular value and a host MUST NOT treat it as an authorization or visibility boundary."
+        },
+        "fields": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 200,
+          "items": { "$ref": "#/$defs/FormField" },
+          "description": "Typed fields the template contributes, in presentation order. Each MUST have a unique `id` within the template — duplicates MUST be refused (`form-content-packs.md` §\"Unique identifiers\"). Two fields sharing an `id` silently overwrite one another in the submission value bag, losing data with no error, so this is a data-integrity requirement rather than a style rule. `maxItems` is an OUTER resource bound; a host MAY enforce a tighter limit locally."
+        }
+      }
+    },
+    "FormField": {
+      "type": "object",
+      "required": ["id", "type", "label"],
+      "additionalProperties": false,
+      "description": "One typed field. `id` (not `key`) matches `chat-card-pack-manifest.schema.json#/$defs/InputField` so a host renders both declarative kinds through the same machinery.",
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
+          "description": "Field identifier, unique within the template. Mirrors `chat-card-pack-manifest.schema.json` `InputField.id`."
+        },
+        "type": {
+          "type": "string",
+          "description": "Closed portable subset OR a `vendor.<org>.<kind>` / `x-<kind>` host extension other hosts MUST ignore (degrading to a plain text input). The subset is IDENTICAL to `chat-card-pack-manifest.schema.json` `InputField.type` (RFC 0071 G9, resolved 2026-05-27): `text`, `longtext`, `number`, `boolean`, `select`, `multiselect`, `file`, `artifact-ref`. Named by DATA KIND, not widget — a host renders `boolean` as whatever toggle/checkbox it likes, and `longtext` as whatever multi-line control it likes. Validation formats (`email`, `uri`, …) are NOT types; use `format`.",
+          "pattern": "^(text|longtext|number|boolean|select|multiselect|file|artifact-ref|vendor\\.[a-z][a-z0-9-]*\\.[a-z][a-z0-9-]*|x-[a-z][a-z0-9-]*)$"
+        },
+        "format": {
+          "type": "string",
+          "description": "Optional validation-format constraint on the field's value, following the JSON Schema `format` idiom used throughout this corpus. Spec-reserved core identifiers: `email`, `uri`, `date`, `date-time`, `time`. Host extensions MUST be `x-<format>`-prefixed. Only meaningful for `type: \"text\"` / `\"longtext\"`; a host MUST ignore it on any other type. A host that recognizes the format SHOULD apply it as an input-validation constraint; a host that does NOT recognize it MUST ignore it and accept the value as plain text (the same degradation contract as an unrecognized `type`). `format` is a CONSTRAINT on a `text` field — it is deliberately not a member of the `type` vocabulary, so the portable type set stays a stable set of data kinds instead of accreting widgets.",
+          "pattern": "^(email|uri|date|date-time|time|x-[a-z][a-z0-9-]*)$"
+        },
+        "label": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 1000,
+          "description": "Human-readable field label. Bounded at 1000 rather than 200 because a lawful consent label (GDPR/marketing opt-in) is legitimately long-form. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\"."
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 300,
+          "description": "Optional help text. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\"."
+        },
+        "required": {
+          "type": "boolean",
+          "description": "Whether the host SHOULD require a value before accepting the instantiated form. Absent ⇒ `false`."
+        },
+        "default": {
+          "description": "Optional default value. Its JSON type SHOULD match the field `type` (string for `text`/`longtext`, number for `number`, boolean for `boolean`, string for `select`, array of string for `multiselect`); a host MUST ignore a default whose type does not match rather than fail the instantiation."
+        },
+        "options": {
+          "type": "array",
+          "items": { "type": "string", "maxLength": 200 },
+          "maxItems": 250,
+          "description": "Choices for `type: \"select\"` / `\"multiselect\"`. UNTRUSTED pack-authored content — see `form-content-packs.md` §\"Trust boundary\". Mirrors `chat-card-pack-manifest.schema.json` `InputField.options`."
+        }
+      }
+    },
+    "Signing": {
+      "type": "object",
+      "description": "Optional signing metadata. See node-packs.md §signing.",
+      "additionalProperties": false,
+      "properties": {
+        "publicKeyRef": { "type": "string" },
+        "signatureRef": { "type": "string" },
+        "method": { "type": "string", "enum": ["manual", "sigstore"] }
+      }
+    }
+  }
+}

package/schemas/registry-version-manifest.schema.json

@@ -12,13 +12,14 @@
     { "required": ["provider"] },
     { "properties": { "chains": { "type": "array", "minItems": 1 } }, "required": ["chains"] },
     { "properties": { "prompts": { "type": "array", "minItems": 1 } }, "required": ["prompts"] },
-    { "properties": { "cards": { "type": "array", "minItems": 1 } }, "required": ["cards"] }
+    { "properties": { "cards": { "type": "array", "minItems": 1 } }, "required": ["cards"] },
+    { "properties": { "templates": { "type": "array", "minItems": 1 } }, "required": ["templates"] }
   ],
   "allOf": [
     {
-      "$comment": "RFC 0107 — runtime is required for EXECUTABLE kinds (node, or kind absent) and MUST be absent for DECLARATIVE kinds (artifact-type, connection, workflow-chain, prompt, card). NOTE: the chat-card-pack kind string is `card` per RFC 0071 (corrected 2026-06-23; an earlier RFC 0107 draft said `chat-card`).",
+      "$comment": "RFC 0107 — runtime is required for EXECUTABLE kinds (node, or kind absent) and MUST be absent for DECLARATIVE kinds (artifact-type, connection, workflow-chain, prompt, card, form-content). NOTE: the chat-card-pack kind string is `card` per RFC 0071 (corrected 2026-06-23; an earlier RFC 0107 draft said `chat-card`). `form-content` added by RFC 0137.",
       "if": {
-        "properties": { "kind": { "enum": ["artifact-type", "connection", "workflow-chain", "prompt", "card"] } },
+        "properties": { "kind": { "enum": ["artifact-type", "connection", "workflow-chain", "prompt", "card", "form-content"] } },
         "required": ["kind"]
       },
       "then": { "not": { "required": ["runtime"] } },
@@ -58,9 +59,9 @@
     },
     "kind": {
       "type": "string",
-      "enum": ["node", "artifact-type", "connection", "workflow-chain", "prompt", "card"],
+      "enum": ["node", "artifact-type", "connection", "workflow-chain", "prompt", "card", "form-content"],
       "default": "node",
-      "description": "Pack-kind discriminator (RFC 0107). ABSENT ≡ `node` (the original, executable kind — backward compatible). Executable kinds (`node`) carry `runtime` + `nodes[]`/`agents[]`. DECLARATIVE kinds carry their own payload and NO `runtime`: `artifact-type` → `artifactTypes[]` (RFC 0075); `connection` → `provider` (RFC 0095); `workflow-chain` → `chains[]` (RFC 0013); `prompt` → `prompts[]`; `card` → `cards[]` (the chat-card pack, RFC 0071 — kind string is `card`, NOT `chat-card`; an earlier RFC 0107 draft used `chat-card`, corrected 2026-06-23). The registry's runtime-support check (registry-operations.md §Validation flow #7) is skipped for declarative kinds."
+      "description": "Pack-kind discriminator (RFC 0107). ABSENT ≡ `node` (the original, executable kind — backward compatible). Executable kinds (`node`) carry `runtime` + `nodes[]`/`agents[]`. DECLARATIVE kinds carry their own payload and NO `runtime`: `artifact-type` → `artifactTypes[]` (RFC 0075); `connection` → `provider` (RFC 0095); `workflow-chain` → `chains[]` (RFC 0013); `prompt` → `prompts[]`; `card` → `cards[]` (the chat-card pack, RFC 0071 — kind string is `card`, NOT `chat-card`; an earlier RFC 0107 draft used `chat-card`, corrected 2026-06-23); `form-content` → `templates[]` (RFC 0137). The registry's runtime-support check (registry-operations.md §Validation flow #7) is skipped for declarative kinds."
     },
     "artifactTypes": {
       "type": "array",
@@ -87,6 +88,11 @@
       "description": "Present iff `kind == \"card\"` (the chat-card pack, RFC 0071; the registry denormalizes `cards[].cardTypeId` into the per-pack index). Carried loosely; source schema authoritative.",
       "items": { "type": "object", "additionalProperties": true }
     },
+    "templates": {
+      "type": "array",
+      "description": "Present iff `kind == \"form-content\"` (RFC 0137). Form templates the pack contributes (each: `templateId`, `version`, `label`, `title`, `fields[]`). Carried loosely here per the RFC 0107 G1 pattern — `form-content-pack-manifest.schema.json` is the authoritative source contract, and the registry denormalizes `templates[].templateId` into the per-pack index for discovery (`registry-operations.md` §\"Type-ID indexing\").",
+      "items": { "type": "object", "additionalProperties": true }
+    },
     "runtime": {
       "type": "object",
       "required": ["language"],

package/schemas/workflow-chain-pack-manifest.schema.json

@@ -86,6 +86,10 @@
           "type": "string",
           "description": "One-paragraph description of what the chain produces. Surfaced in host editor tile hover-text."
         },
+        "internal": {
+          "type": "boolean",
+          "description": "RFC 0135 — when true, this chain is a composition-only fragment (typically an RFC 0133 sub-chain child): hosts MUST omit it from default template-gallery/picker listings while keeping it loadable, resolvable by id, composable, and expandable exactly like any other chain. Presentational/discovery semantics only — NOT an authorization boundary (a host MUST NOT treat it as access control). Absent ⇒ false (listed). See workflow-chain-packs.md §\"Chain visibility (RFC 0135)\"."
+        },
         "parameters": {
           "type": "object",
           "description": "JSON Schema 2020-12 fragment describing the parameter values the host editor MUST collect from the author at drop time. Authors-supplied values are validated against this schema before expansion proceeds; invalid input MUST be rejected with `chain_parameter_invalid`. RECOGNIZED EXTENSION KEY (RFC 0124 / WCP4): a property MAY carry `x-openwop-sensitive: true` to declare the parameter secret-class. A host that recognizes it MUST NOT expansion-time-freeze that parameter (plaintext secret-at-rest leak, SR-1) and MUST NOT materialize it as a plaintext `source:\"variable\"` binding (the value would land in the run-scoped bag / `RunSnapshot.variables` — the same SR-1 leak one layer down). Instead, per the 2026-07-04 §Security amendment: it is deferrable ONLY in a prompt-body position, where it MUST be materialized as a `source:\"secret\"` `PromptVariable` (BYOK-resolved via `capabilities.secrets`, redacted to `[REDACTED:<secretId>]` in `prompt.composed`, never bagged); in ANY other position (whole-value `node.inputs`, embedded non-prompt `config`, or a host lacking deferred / `secrets` support) it MUST fail closed with `sensitive_param_not_deferrable` (422). Per-run supply is a `credentialRef` secret reference, never plaintext. See `workflow-chain-packs.md` §\"Deferred-parameter expansion\" / RFC 0124 §Security.",

package/src/lib/artifactTypes.ts

@@ -33,13 +33,34 @@ interface DiscoveryDoc {
 }
 
 /** Reads `host.artifactTypes` from discovery (capabilities block or top-level); null when unadvertised. */
+/**
+ * Capability-key lookup order (RFC 0137 G16, resolved 2026-08-05).
+ *
+ * The canonical discovery key for a `host.*` capability family is the PLAIN
+ * family name at the document root — NOT the dotted identifier. Evidence:
+ * `schemas/capabilities.schema.json` declares 82 properties and **zero** dotted
+ * `host.*` keys, and five host capabilities are already declared plainly there —
+ * `fs`, `kvStorage`, `tableStorage`, `queueBus`, `scheduling` — each mapping to a
+ * `§host.<name>` section in `host-capabilities.md` (`§host.fs` ↔ `fs`, and so on).
+ * The `host.` prefix is the capability IDENTIFIER notation used in prose headings,
+ * pack `peerDependencies`, and `error.capability` — not the discovery-document key.
+ *
+ * These helpers previously read the dotted key ONLY, which made them the outlier
+ * against five established precedents and rendered a schema-following host
+ * INVISIBLE to the scenario — a silent soft-skip to green.
+ *
+ * Order: plain at root (canonical) → dotted at root → plain under the deprecated
+ * `capabilities` wrapper → dotted under the wrapper. Root before wrapper per
+ * `capabilities.md` §"Document-root layout (normative — RFC 0073)"; the wrapper
+ * arms retire with the migration window at v2.0.
+ */
 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']
+  const caps = doc?.capabilities && typeof doc.capabilities === 'object'
+    ? (doc.capabilities as Record<string, unknown>)
     : undefined;
-  const cap = fromCaps ?? doc?.['host.artifactTypes'];
+  const cap = doc?.['artifactTypes'] ?? doc?.['host.artifactTypes'] ?? caps?.['artifactTypes'] ?? caps?.['host.artifactTypes'];
   return cap && typeof cap === 'object' ? (cap as Record<string, unknown>) : null;
 }
 

package/src/lib/cardPacks.ts

@@ -29,10 +29,17 @@ 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'];
+  // RFC 0137 G16 (resolved 2026-08-05): the canonical discovery key is the PLAIN
+  // family name at the document root. capabilities.schema.json declares 82 properties
+  // and ZERO dotted host.* keys, and already declares five host capabilities plainly
+  // (fs, kvStorage, tableStorage, queueBus, scheduling), each mapping to a §host.<name>
+  // section. The `host.` prefix is the capability IDENTIFIER (peerDependencies,
+  // error.capability), not the discovery key. Order: plain-root → dotted-root →
+  // plain-wrapper → dotted-wrapper (root before wrapper per RFC 0073).
+  // Accept either a discrete cardPacks key or a `cardPacks` facet under the chat block.
+  const direct = doc?.['chat.cardPacks'] ?? doc?.['host.chat.cardPacks'] ?? caps?.['chat.cardPacks'] ?? caps?.['host.chat.cardPacks'];
   if (direct && typeof direct === 'object') return direct as Record<string, unknown>;
-  const chat = caps?.['host.chat'] ?? doc?.['host.chat'];
+  const chat = doc?.['chat'] ?? doc?.['host.chat'] ?? caps?.['chat'] ?? caps?.['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;
 }

package/src/lib/formContentPacks.ts

@@ -0,0 +1,133 @@
+/**
+ * Shared helpers for the RFC 0137 `host.forms.contentPacks` conformance scenarios.
+ * Lives in lib/ so scenarios import it via `../lib/formContentPacks.js`.
+ *
+ * Hosts wiring form-content packs expose a documented host-extension seam:
+ *
+ *   POST /v1/host/sample/formcontent/instantiate
+ *     body: { templateId: string }
+ *     → 2xx {
+ *         formId?: string,
+ *         fields?: Array<{
+ *           id?: string,
+ *           control?: string,      // the control kind the host chose for this field
+ *           declaredType?: string, // the wire `fields[].type` the template declared
+ *           editable?: boolean,    // the instantiating user may rename/remove it
+ *           locked?: boolean,      // inverse spelling some hosts prefer
+ *         }>,
+ *         viaCreatePath?: boolean, // instantiation went through the host's NORMAL form-create path
+ *         routing?: unknown,       // MUST be absent/empty — a template cannot bind a destination
+ *         refused?: boolean,       // the host refused the template outright
+ *       }
+ *
+ * A 404/405 means the host hasn't wired the seam → soft-skip. Every leg in the
+ * scenario is additionally gated on the `host.forms.contentPacks` advertisement,
+ * so a host that does not implement RFC 0137 skips cleanly and stays v1-compliant.
+ *
+ * @see spec/v1/form-content-packs.md §"Instantiation", §"No submission routing"
+ * @see spec/v1/host-capabilities.md §host.forms
+ */
+import { driver } from './driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+  [k: string]: unknown;
+}
+
+/** A field as reported by the instantiation seam. */
+export interface SeamField {
+  id?: string;
+  control?: string;
+  declaredType?: string;
+  editable?: boolean;
+  locked?: boolean;
+}
+
+export interface InstantiateResult {
+  status: number;
+  json: Record<string, unknown>;
+  fields: SeamField[];
+}
+
+/**
+ * Reads `host.forms.contentPacks` from discovery; null when unadvertised.
+ *
+ * **The key is the DOTTED `host.forms`, at the DOCUMENT ROOT.** Two normative
+ * rules pin this and a host must satisfy both:
+ *
+ *   - `host-capabilities.md` §"How a capability is consumed" step 1 — a host
+ *     advertises `host.<name>: { supported: true, … }`. The literal key carries
+ *     the `host.` prefix; a bare `forms` is a different (undefined) key.
+ *   - `capabilities.md` §"Document-root layout (normative — RFC 0073)" — every
+ *     capability family MUST appear at the **document root**. A top-level
+ *     `capabilities` wrapper is a "deprecated legacy shape", and a host serving
+ *     families exclusively under the wrapper "is non-conformant and is graded as
+ *     such".
+ *
+ * So the canonical advertisement is a root-level `"host.forms": { … }`. Per RFC
+ * 0073, clients SHOULD read the root FIRST and MAY fall back to the wrapper, so
+ * that is the order here — the wrapper fallback exists only for the v1.x
+ * migration window and retires at v2.0.
+ *
+ * Accepts either a discrete `host.forms.contentPacks` key or a `contentPacks`
+ * facet under a `host.forms` block (mirrors how `host.chat.cardPacks` is read).
+ */
+export async function readFormContentCap(): Promise<unknown> {
+  const res = await driver.get('/.well-known/openwop');
+  const doc = res.json as DiscoveryDoc | undefined;
+  // Root first (RFC 0073 MUST); the `capabilities` wrapper is the deprecated
+  // legacy fallback, tolerated only through the v1.x migration window.
+  const caps = doc?.capabilities && typeof doc.capabilities === 'object' ? (doc.capabilities as Record<string, unknown>) : undefined;
+  // RFC 0137 G16 (resolved 2026-08-05): the canonical discovery key is the PLAIN
+  // family name at the document root. capabilities.schema.json declares 82 properties
+  // and ZERO dotted host.* keys, and already declares five host capabilities plainly
+  // (fs, kvStorage, tableStorage, queueBus, scheduling), each mapping to a §host.<name>
+  // section. The `host.` prefix is the capability IDENTIFIER (peerDependencies,
+  // error.capability), not the discovery key. Order: plain-root → dotted-root →
+  // plain-wrapper → dotted-wrapper (root before wrapper per RFC 0073).
+  const direct = doc?.['forms.contentPacks'] ?? doc?.['host.forms.contentPacks'] ?? caps?.['forms.contentPacks'] ?? caps?.['host.forms.contentPacks'];
+  if (direct !== undefined) return direct;
+  const forms = doc?.['forms'] ?? doc?.['host.forms'] ?? caps?.['forms'] ?? caps?.['host.forms'];
+  return forms && typeof forms === 'object' ? (forms as Record<string, unknown>)['contentPacks'] : null;
+}
+
+/** True when the host advertises it resolves + instantiates form-content templates. */
+export function formContentSupported(cap: unknown): boolean {
+  if (cap === true) return true;
+  return typeof cap === 'object' && cap !== null && (cap as Record<string, unknown>)['supported'] === true;
+}
+
+/** Instantiates a registered template via the host-sample seam, or null (soft-skip) when absent. */
+export async function instantiateTemplate(templateId: string): Promise<InstantiateResult | null> {
+  const res = await driver.post('/v1/host/sample/formcontent/instantiate', { templateId });
+  if (res.status === 404 || res.status === 405) return null;
+  const json = (res.json ?? {}) as Record<string, unknown>;
+  const raw = Array.isArray(json['fields']) ? (json['fields'] as unknown[]) : [];
+  const fields = raw.filter((f): f is SeamField => typeof f === 'object' && f !== null);
+  return { status: res.status, json, fields };
+}
+
+/** Finds a seam field by its wire `id`. */
+export function fieldById(fields: SeamField[], id: string): SeamField | undefined {
+  return fields.find((f) => f.id === id);
+}
+
+/**
+ * A field is editable unless the host explicitly says otherwise. Accepts both
+ * spellings (`editable: false` / `locked: true`); absent ⇒ treated as editable,
+ * because §Instantiation #3 makes editability the default expectation and a host
+ * that does not report the facet is not asserting a lock.
+ */
+export function isEditable(field: SeamField | undefined): boolean {
+  if (!field) return false;
+  if (field.locked === true) return false;
+  return field.editable !== false;
+}
+
+/**
+ * The set of control kinds a host may legitimately choose for a degraded
+ * (unrecognized `vendor.*` / `x-`) field type. §Instantiation #2 says "plain text
+ * input"; hosts spell that control differently, so accept the obvious synonyms
+ * rather than pinning one host's vocabulary onto the wire.
+ */
+export const PLAIN_TEXT_CONTROLS: ReadonlySet<string> = new Set(['text', 'string', 'plaintext', 'plain-text', 'input', 'textbox']);

package/src/lib/workflow-chain-expansion.ts

@@ -280,6 +280,32 @@ export function expandChain(chain: WorkflowChain, ctx: ExpansionContext): Expand
   return { nodes: expandedNodes, edges: expandedEdges, idMap };
 }
 
+// ─── End of the MIRRORED CORE ───────────────────────────────────────────────
+//
+// Everything ABOVE this line is the base chain-expansion algorithm every host
+// that loads workflow-chain packs implements, and it is mirrored verbatim by
+// the in-memory reference host (`examples/hosts/in-memory/src/
+// workflow-chain-expansion.ts`, in the `openwop-examples` repo), which cannot
+// import this package under its zero-runtime-deps policy. That mirror is
+// enforced byte-for-byte by `scripts/check-workflow-chain-expansion-sync.mjs`.
+//
+// Everything BELOW is CAPABILITY-GATED surface added after the mirror was
+// established, and is deliberately NOT mirrored:
+//
+//   • RFC 0124 deferred-parameter expansion (`expandChainDeferred` and its
+//     types) — the host-side deferral path.
+//   • RFC 0133 sub-chain co-expansion + produced variables (`expandChainTree`,
+//     `mintChildWorkflowId`, the `SubChain*` / `VariableUndeclared` errors) —
+//     gated on `capabilities.workflowChainPacks.subChains`. A host that does
+//     not advertise it MUST REFUSE a `subChains`-bearing chain with
+//     `sub_chain_unsupported`, never silently flatten — so a minimal host is
+//     required to reject this surface, not to implement it.
+//
+// Do NOT move the sentinel to "fix" a drift failure. If a change belongs to the
+// base algorithm every host must share, it goes above and the mirror follows.
+// If it is gated on an advertised capability, it goes below.
+// ─────────────────────────────────────────────────────────────────────────────
+
 // ---------------------------------------------------------------------------
 // RFC 0124 (WCP4) — Portable per-run parameter deferral.
 //
@@ -293,6 +319,7 @@ export function expandChain(chain: WorkflowChain, ctx: ExpansionContext): Expand
 // §"Deferred-parameter expansion (RFC 0124)".
 // ---------------------------------------------------------------------------
 
+
 /** The parameter JSON Schema fragment (`chain.parameters`), narrowed to the
  *  fields deferred expansion reads: each property's `type`, `description`, and
  *  the RFC 0124 `x-openwop-sensitive` extension key. */

package/src/scenarios/form-content-instantiation.test.ts

@@ -0,0 +1,168 @@
+/**
+ * form-content-instantiation — RFC 0137 `form-content-packs.md` §"Instantiation",
+ * §"No submission routing" (F2).
+ *
+ * **This is the behavioral half of RFC 0137, and it exists because the other half
+ * could not witness anything.** `form-content-packs.test.ts` is entirely
+ * server-free: it proves the corpus agrees with itself — the schema carries the
+ * kind, the `anyOf` branch is present, the two field-type vocabularies are
+ * byte-identical. Every one of those legs passes identically against a host that
+ * never implemented RFC 0137, including one that advertises
+ * `host.forms.contentPacks` and does nothing. Running that suite with
+ * `--base-url` and calling the green a witness would be vacuous. This file is
+ * what `OPENWOP_REQUIRE_BEHAVIOR=true` is supposed to make non-vacuous.
+ *
+ * Gated on the `host.forms.contentPacks` advertisement AND the host-sample
+ * instantiate seam, so a host that does not implement RFC 0137 skips cleanly and
+ * stays v1-compliant.
+ *
+ * **The advertisement gate is `behaviorGate`, not a bare `return`.** That is the
+ * difference between a skip you can see and one you cannot: under
+ * `OPENWOP_REQUIRE_BEHAVIOR=true` an unadvertised capability FAILS with a message
+ * naming the profile, instead of quietly skipping to green. A host that
+ * mis-spells its advertisement — serving `capabilities.forms.contentPacks`
+ * instead of a root-level `"host.forms"` — otherwise gets four silent skips and a
+ * green run that witnesses nothing. That is the exact vacuity this scenario
+ * exists to prevent, so the gate must be loud in strict mode.
+ *
+ * The canonical advertisement is a ROOT-LEVEL dotted `"host.forms": { … }`:
+ * `host-capabilities.md` §"How a capability is consumed" pins the `host.`-prefixed
+ * key, and `capabilities.md` §"Document-root layout (normative — RFC 0073)" pins
+ * the document root — a `capabilities` wrapper is a deprecated legacy shape and a
+ * host serving families only under it "is non-conformant and is graded as such".
+ *
+ * What is asserted over the wire (each maps to a numbered §Instantiation rule):
+ *
+ *   #1 — instantiation goes through the host's NORMAL create path, and the
+ *        resulting form carries no routing destination (§F2: a pack MUST NOT
+ *        bind where submissions go; the operator configures that afterward).
+ *   #2 — an unrecognized `vendor.*` / `x-` field type DEGRADES to a plain text
+ *        input rather than failing the instantiation. This is the leg that
+ *        matters most: refuse-everything is a natural implementation instinct
+ *        and it is non-conformant here.
+ *   #3 — pack-authored fields are FULLY EDITABLE, with no privilege over a
+ *        hand-added field.
+ *
+ * F1 (the trust boundary) is deliberately NOT asserted here. Its observable —
+ * a `contentTrust` tag on a composed prompt — is not visible to a black-box
+ * client for a kind that composes no prompt of its own. Claiming to witness it
+ * over HTTP would be the same vacuity this file exists to avoid; it stays a
+ * host-side guarantee backed by the schema/corpus legs and the host's own tests.
+ *
+ * @see spec/v1/form-content-packs.md §"Instantiation", §"No submission routing"
+ * @see spec/v1/host-capabilities.md §host.forms
+ * @see RFCS/0137-form-content-packs.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import {
+  readFormContentCap,
+  formContentSupported,
+  instantiateTemplate,
+  fieldById,
+  isEditable,
+  PLAIN_TEXT_CONTROLS,
+} from '../lib/formContentPacks.js';
+
+/**
+ * Conformance fixture templates a host wires the seam against.
+ * `…form.basic` uses only portable-subset types; `…form.extended` additionally
+ * declares one `vendor.*` field the host is not expected to recognize.
+ */
+/** Profile name for the strict-mode gate (`OPENWOP_REQUIRE_BEHAVIOR=true`). */
+const PROFILE = 'host.forms.contentPacks';
+
+const BASIC_TEMPLATE = 'vendor.conformance.form.basic';
+const EXTENDED_TEMPLATE = 'vendor.conformance.form.extended';
+const VENDOR_FIELD_ID = 'vendorExtended';
+
+describe('form-content-instantiation: a host instantiates a registered template (RFC 0137 §Instantiation)', () => {
+  it('#1 instantiation goes through the host NORMAL create path', async () => {
+    if (!behaviorGate(PROFILE, formContentSupported(await readFormContentCap()))) return;
+    const res = await instantiateTemplate(BASIC_TEMPLATE);
+    if (res === null) return; // seam absent — soft-skip
+
+    expect(
+      res.status >= 200 && res.status < 300,
+      driver.describe('form-content-packs.md §Instantiation', 'a registered template MUST instantiate'),
+    ).toBe(true);
+
+    if (res.json['viaCreatePath'] !== undefined) {
+      expect(
+        res.json['viaCreatePath'],
+        driver.describe(
+          'form-content-packs.md §Instantiation #1',
+          'the host MUST create the form through the SAME path that serves a hand-authored form',
+        ),
+      ).toBe(true);
+    }
+
+    expect(
+      res.fields.length,
+      driver.describe('form-content-packs.md §Instantiation', 'the instantiated form MUST carry the template fields'),
+    ).toBeGreaterThan(0);
+  });
+
+  it('#1/F2 the instantiated form carries NO pack-bound submission destination', async () => {
+    if (!behaviorGate(PROFILE, formContentSupported(await readFormContentCap()))) return;
+    const res = await instantiateTemplate(BASIC_TEMPLATE);
+    if (res === null) return;
+
+    const routing = res.json['routing'];
+    const bound =
+      routing !== undefined &&
+      routing !== null &&
+      !(typeof routing === 'object' && Object.keys(routing as Record<string, unknown>).length === 0);
+
+    expect(
+      bound,
+      driver.describe(
+        'form-content-packs.md §No submission routing (F2)',
+        'a template MUST NOT bind a submission destination — the operator configures routing afterward, as for any hand-authored form',
+      ),
+    ).toBe(false);
+  });
+
+  it('#2 an unrecognized vendor.* field type DEGRADES to plain text, and does NOT fail the instantiation', async () => {
+    if (!behaviorGate(PROFILE, formContentSupported(await readFormContentCap()))) return;
+    const res = await instantiateTemplate(EXTENDED_TEMPLATE);
+    if (res === null) return;
+
+    expect(
+      res.status >= 200 && res.status < 300 && res.json['refused'] !== true,
+      driver.describe(
+        'form-content-packs.md §Instantiation #2',
+        'a well-formed but unrecognized vendor.*/x- type MUST degrade, NOT fail the instantiation — refusing a valid extension breaks forward compatibility',
+      ),
+    ).toBe(true);
+
+    const field = fieldById(res.fields, VENDOR_FIELD_ID);
+    if (field === undefined) return; // host doesn't report per-field controls on the seam — soft-skip
+    expect(
+      field.control !== undefined && PLAIN_TEXT_CONTROLS.has(field.control),
+      driver.describe(
+        'form-content-packs.md §Instantiation #2',
+        `an unrecognized field type MUST render as a plain text input (got control ${JSON.stringify(field.control)})`,
+      ),
+    ).toBe(true);
+  });
+
+  it('#3 pack-authored fields are FULLY EDITABLE — no privilege over a hand-added field', async () => {
+    if (!behaviorGate(PROFILE, formContentSupported(await readFormContentCap()))) return;
+    const res = await instantiateTemplate(BASIC_TEMPLATE);
+    if (res === null) return;
+
+    const reporting = res.fields.filter((f) => f.editable !== undefined || f.locked !== undefined);
+    if (reporting.length === 0) return; // host doesn't report editability — soft-skip
+
+    expect(
+      reporting.every((f) => isEditable(f)),
+      driver.describe(
+        'form-content-packs.md §Instantiation #3',
+        'the host MUST NOT treat a pack-authored field as immutable or privileged relative to a hand-added one',
+      ),
+    ).toBe(true);
+  });
+});