@sublang/slc 0.5.0 → 0.7.0

package/dist/verify.js

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 /**
  * Compilation-correctness verification for a compiled `playbook` artifact
- * (IR-007 Task 8; DR-009).
+ * (DR-009).
  *
  * A compiled artifact is a judgment-produced program, so `slc` re-checks it
  * against its source. The GEARS↔FSM conformance check verifies that every GEARS
@@ -16,7 +16,7 @@
  * inputs; {@link generateGearsFsmConformanceTest} emits a per-artifact test that
  * runs it beside the artifacts. The checker reads the `text2gears` item format
  * and the `gears2fsm` `invoke.input` contract, not any one artifact, so it holds
- * for every compiled `playbook`. See specs/dev/verification.md.
+ * for every compiled `playbook`. See specs/packages/verification.md.
  */
 import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
@@ -32,6 +32,83 @@ import { hashFile } from './hash.js';
  */
 export const NEEDS_BOSS_REPLY = 'needsBossReply';
 export const BOSS_QUESTION_MARKER = 'Output shall include `question:';
+/**
+ * True when the declaration admits the roleless schema-3 `composed-v3`
+ * generation: `RUNTIME_ABI` is exactly `1` and `SUPPORTED_ARTIFACT_SCHEMAS`
+ * contains `3` (DR-028).
+ */
+export function declaresComposedV3(declaration) {
+    return (declaration.runtimeAbi === 1 &&
+        Array.isArray(declaration.supportedArtifactSchemas) &&
+        declaration.supportedArtifactSchemas.includes(3));
+}
+/** Names a declaration for fail-closed diagnostics. */
+export function describeRuntimeDeclaration(declaration) {
+    const abi = declaration.runtimeAbi === undefined
+        ? 'no RUNTIME_ABI'
+        : `RUNTIME_ABI ${renderDeclared(declaration.runtimeAbi)}`;
+    const schemas = declaration.supportedArtifactSchemas === undefined
+        ? 'no SUPPORTED_ARTIFACT_SCHEMAS'
+        : `SUPPORTED_ARTIFACT_SCHEMAS ${renderDeclared(declaration.supportedArtifactSchemas)}`;
+    return `${declaration.provenance} declares ${abi} and ${schemas}`;
+}
+function renderDeclared(value) {
+    try {
+        const json = JSON.stringify(value);
+        return json === undefined ? String(value) : json;
+    }
+    catch {
+        return String(value);
+    }
+}
+/**
+ * Artifact schema recorded for an exact reviewed Playbook provenance: the
+ * historical map kept as recorded (DR-028). A later release supplies its
+ * schema through the installed engine's declaration instead
+ * ({@link resolveArtifactSchemaForVerification}).
+ */
+export function artifactSchemaForPlaybookProvenance(provenance) {
+    switch (provenance) {
+        case '@sublang/playbook@0.10.0':
+        case '@sublang/playbook@1.0.0':
+        case '@sublang/playbook@2.0.0':
+        case '@sublang/playbook@3.1.0':
+        case '@sublang/playbook@4.0.0':
+            return 1;
+        case '@sublang/playbook@10.0.0':
+            return 3;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Returns the Playbook package provenance that owns an invocation's concrete
+ * link target. The first package manifest above the target owns the file; a
+ * parent workspace manifest must not lend its identity to a nested local file.
+ */
+export async function playbookProvenanceForLinkTarget(linkTarget) {
+    let cursor = dirname(resolve(linkTarget));
+    for (;;) {
+        const manifestPath = join(cursor, 'package.json');
+        if (existsSync(manifestPath)) {
+            try {
+                const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+                return manifest.name === '@sublang/playbook' &&
+                    typeof manifest.version === 'string' &&
+                    manifest.version.length > 0
+                    ? `${manifest.name}@${manifest.version}`
+                    : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            return undefined;
+        cursor = parent;
+    }
+}
 const ITEM_HEADING = /^###\s+([A-Za-z][\w-]*)\s*$/;
 // The `text2gears` item form names a delegated player as "Captain shall prompt
 // <Player>" (or a "relay ... to <Player>" variant); English players are
@@ -41,6 +118,7 @@ const ITEM_HEADING = /^###\s+([A-Za-z][\w-]*)\s*$/;
 const ITEM_PLAYER = /Captain shall (?:prompt|relay\b[^.]*?\bto)\s+(?:`([^`]+)`|"([^"]+)"|“([^”]+)”|([A-Z][\w]*)|([^\p{ASCII}][^\s:：，,。;；]*))/u;
 const ITEM_PLAYBOOK = /Captain shall call playbook\s+(?:`([^`]+)`|"([^"]+)"|“([^”]+)”|([A-Za-z0-9][\w.-]*))\s*:/;
 const ITEM_DYNAMIC_PLAYBOOK = /Captain shall call playbook selected by\s+`([^`]+)`\s*:/;
+const PARALLEL_GROUP = /^Parallel group:\s*(\S(?:.*\S)?)\s*$/;
 const DYNAMIC_TEXT = /^<([A-Za-z_$][A-Za-z0-9_$]*)>$/;
 // An optimizer-introduced script item runs a shell command without any agent
 // (text2gears.md "Script behaviors"; DR-013). The clause is fixed machine
@@ -112,6 +190,9 @@ export function parseGearsItems(gears) {
                         ...(dynamicText === null ? {} : { textContext: dynamicText[1] }),
                     }
                     : {}),
+                ...(current.parallelGroup !== ''
+                    ? { parallelGroup: current.parallelGroup }
+                    : {}),
                 ...(current.resultDeclared
                     ? { result: Object.fromEntries(current.results) }
                     : {}),
@@ -133,6 +214,7 @@ export function parseGearsItems(gears) {
                 script: false,
                 playbookId: '',
                 playbookIdContext: '',
+                parallelGroup: '',
                 prompt: [],
                 resultsEligible: false,
                 resultDeclared: false,
@@ -195,6 +277,10 @@ export function parseGearsItems(gears) {
         }
         if (line.trim() !== '')
             current.resultsEligible = false;
+        const parallelGroup = PARALLEL_GROUP.exec(line.trim());
+        if (parallelGroup !== null && current.parallelGroup === '') {
+            current.parallelGroup = parallelGroup[1];
+        }
         const player = ITEM_PLAYER.exec(line);
         if (player !== null && current.player === '') {
             current.player =
@@ -221,6 +307,152 @@ export function parseGearsItems(gears) {
     flush();
     return items;
 }
+const ROLE_DECLARATION = /^(?:#{1,6}\s+(Roles|Players)|(Roles|Players):)\s*$/;
+/** Canonical lowercase local-role id used by schema-3 artifacts. */
+export function canonicalRoleId(name) {
+    return name.toLowerCase();
+}
+function declarationName(value) {
+    const match = /^[`"“]?([^`"”]+?)[`"”]?\s*$/.exec(value.trim());
+    return match?.[1].trim() || undefined;
+}
+/** Parses Roles/Players plus source-derived concurrent role sets without host bindings. */
+export function inspectGearsRoleContract(gears) {
+    const findings = [];
+    const declarations = [];
+    let active;
+    for (const line of gears.split('\n')) {
+        const heading = ROLE_DECLARATION.exec(line.trim());
+        if (heading !== null) {
+            active = {
+                kind: (heading[1] ?? heading[2]),
+                names: [],
+            };
+            declarations.push(active);
+            continue;
+        }
+        if (active === undefined)
+            continue;
+        if (line.trim() === '')
+            continue;
+        const bullet = /^-\s+(.*)$/.exec(line.trim());
+        if (bullet === null) {
+            active = undefined;
+            continue;
+        }
+        const declaration = bullet[1].trim();
+        if (active.kind === 'Roles' && /[=|]/.test(declaration)) {
+            findings.push(`Roles declaration ${JSON.stringify(declaration)} uses removed alias syntax`);
+            continue;
+        }
+        // Historical schema-1 Players may declare a composite launcher choice
+        // (`Committer = Coder | Reviewer`). It is not one concrete player binding
+        // and therefore does not enter the source-order player list, including
+        // when every name is backtick- or quote-delimited.
+        if (active.kind === 'Players' && declaration.includes('='))
+            continue;
+        const name = declarationName(declaration);
+        if (name === undefined) {
+            findings.push(`malformed ${active.kind} declaration ${JSON.stringify(declaration)}`);
+            continue;
+        }
+        active.names.push(name);
+    }
+    const kinds = new Set(declarations.map(({ kind }) => kind));
+    if (declarations.length > 1) {
+        findings.push('GEARS declares more than one Roles/Players section');
+    }
+    if (kinds.size > 1) {
+        findings.push('GEARS mixes Roles and Players declarations');
+    }
+    const selected = declarations[0];
+    const generation = selected?.kind === 'Roles'
+        ? 'schema-3'
+        : selected?.kind === 'Players'
+            ? 'schema-1'
+            : 'unspecified';
+    const names = selected?.names ?? [];
+    const roleIds = names.map(canonicalRoleId);
+    if (generation === 'schema-3') {
+        const byCanonical = new Map();
+        for (let index = 0; index < names.length; index += 1) {
+            const name = names[index];
+            const roleId = roleIds[index];
+            const existing = byCanonical.get(roleId);
+            if (existing !== undefined) {
+                findings.push(existing === name
+                    ? `Roles declaration repeats ${JSON.stringify(name)}`
+                    : `Roles declarations ${JSON.stringify(existing)} and ${JSON.stringify(name)} collide as canonical role ${JSON.stringify(roleId)}`);
+            }
+            else {
+                byCanonical.set(roleId, name);
+            }
+            // A canonical local role id is the declared name lowercased. Playbook 10
+            // explicitly admits non-English role names ("quote non-English names
+            // (e.g., `作者`)"), and a script without case - Chinese among them -
+            // lowercases to itself, so an ASCII-only class would reject exactly the
+            // names the definition sanctions. Require instead that the id be genuinely
+            // canonical: already lowercase, carrying no whitespace or separator that
+            // would make it ambiguous as an identifier.
+            if (roleId.length === 0 ||
+                roleId !== roleId.toLowerCase() ||
+                /[\s.,;:/\\'"`()[\]{}<>|]/u.test(roleId)) {
+                findings.push(`Roles declaration ${JSON.stringify(name)} derives noncanonical local role ${JSON.stringify(roleId)}`);
+            }
+            else if (roleId === 'captain') {
+                findings.push('Roles declaration uses reserved local role "captain"');
+            }
+        }
+    }
+    const groups = new Map();
+    if (generation === 'schema-3') {
+        const declared = new Set(roleIds);
+        for (const item of parseGearsItems(gears)) {
+            if (item.actor === 'player') {
+                const roleId = canonicalRoleId(item.player);
+                if (!declared.has(roleId)) {
+                    findings.push(`GEARS item ${item.id} delegates to undeclared role ${JSON.stringify(item.player)}`);
+                }
+            }
+            if (item.parallelGroup === undefined)
+                continue;
+            if (item.actor !== 'player') {
+                findings.push(`parallel group ${JSON.stringify(item.parallelGroup)} contains non-role item ${item.id}`);
+                continue;
+            }
+            const roleId = canonicalRoleId(item.player);
+            const members = groups.get(item.parallelGroup) ?? [];
+            if (members.includes(roleId)) {
+                findings.push(`parallel group ${JSON.stringify(item.parallelGroup)} repeats canonical role ${JSON.stringify(roleId)}`);
+            }
+            members.push(roleId);
+            groups.set(item.parallelGroup, members);
+        }
+        const groupByMembers = new Map();
+        for (const [group, members] of groups) {
+            if (members.length < 2) {
+                findings.push(`parallel group ${JSON.stringify(group)} contains fewer than two roles`);
+            }
+            // A concurrent role set is unordered for duplicate detection even
+            // though its source member order remains significant in the FSM export.
+            const signature = JSON.stringify([...members].sort());
+            const existing = groupByMembers.get(signature);
+            if (existing !== undefined) {
+                findings.push(`parallel groups ${JSON.stringify(existing)} and ${JSON.stringify(group)} duplicate concurrent role set ${signature}`);
+            }
+            else {
+                groupByMembers.set(signature, group);
+            }
+        }
+    }
+    return {
+        generation,
+        names,
+        roleIds,
+        concurrentRoleSets: [...groups.values()],
+        findings,
+    };
+}
 /** Walks every state node depth-first in declaration order. */
 function walkStateNodes(config) {
     const out = [];
@@ -277,6 +509,14 @@ function metadataStateId(state) {
     const stateId = playbook.stateId;
     return isNonEmptyString(stateId) ? stateId : undefined;
 }
+function metadataRole(state) {
+    if (typeof state.meta !== 'object' || state.meta === null)
+        return undefined;
+    const playbook = state.meta.playbook;
+    if (typeof playbook !== 'object' || playbook === null)
+        return undefined;
+    return playbook.role;
+}
 function stateIdConsistencyFindings(node, inputStateId) {
     if (!isNonEmptyString(inputStateId))
         return [];
@@ -359,11 +599,11 @@ function enumerateCaptainBindings(config) {
                 (invoke.src !== undefined || !isNonEmptyString(fields.sourceItem))) {
                 continue;
             }
-            // Published artifacts used `captain` for every work call and carried a
-            // player field. Preserve that shape as delegated work until regeneration.
-            // In the new model, direct Captain work omits player and delegated work
-            // names the `player` actor explicitly.
-            const actor = source === 'player' || Object.hasOwn(fields, 'player')
+            // Published schema-1 artifacts carried a concrete player field. Schema 3
+            // carries only its canonical local role and repeats it in public metadata.
+            const actor = source === 'player' ||
+                Object.hasOwn(fields, 'player') ||
+                Object.hasOwn(fields, 'role')
                 ? 'player'
                 : 'captain';
             const pinActor = source === 'player' || (source === 'captain' && actor === 'captain');
@@ -371,8 +611,37 @@ function enumerateCaptainBindings(config) {
             if (!isNonEmptyString(fields.sourceItem)) {
                 bindingFindings.push('invoke.input.sourceItem is not a non-empty string');
             }
-            if (actor === 'player' && typeof fields.player !== 'string') {
-                bindingFindings.push('invoke.input.player is not a string');
+            if (actor === 'player') {
+                const hasPlayer = Object.hasOwn(fields, 'player');
+                const hasRole = Object.hasOwn(fields, 'role');
+                if (hasPlayer && hasRole) {
+                    bindingFindings.push('invoke.input carries both historical player and schema-3 role');
+                }
+                if (hasRole && typeof fields.role !== 'string') {
+                    bindingFindings.push('invoke.input.role is not a string');
+                }
+                if (hasRole && source !== 'player') {
+                    bindingFindings.push('schema-3 delegated work does not invoke the player actor');
+                }
+                if (!hasRole && typeof fields.player !== 'string') {
+                    bindingFindings.push('invoke.input.player is not a string');
+                }
+                const publicRole = metadataRole(node.state);
+                if (hasRole) {
+                    if (typeof publicRole !== 'string') {
+                        bindingFindings.push('state.meta.playbook.role is not a string for schema-3 delegated work');
+                    }
+                    else if (publicRole !== fields.role) {
+                        bindingFindings.push(`state.meta.playbook.role ${JSON.stringify(publicRole)} does not match invoke.input.role ${JSON.stringify(fields.role)}`);
+                    }
+                }
+                else if (publicRole !== undefined) {
+                    bindingFindings.push('historical delegated-player state unexpectedly declares state.meta.playbook.role');
+                }
+            }
+            else if (Object.hasOwn(fields, 'role') ||
+                metadataRole(node.state) !== undefined) {
+                bindingFindings.push('direct-Captain state unexpectedly declares a role binding');
             }
             if (typeof fields.prompt !== 'string') {
                 bindingFindings.push('invoke.input.prompt is not a string');
@@ -395,6 +664,7 @@ function enumerateCaptainBindings(config) {
                         : '',
                     actor,
                     player: typeof fields.player === 'string' ? fields.player : '',
+                    ...(typeof fields.role === 'string' ? { role: fields.role } : {}),
                     prompt: typeof fields.prompt === 'string' ? fields.prompt : '',
                     result: resultMap(fields.result),
                     ...nestedStatePath(node),
@@ -655,24 +925,115 @@ function statePlaybookSignature(state) {
             state.textContext ?? null,
         ]);
 }
+/** Exact action guards of Playbook 10's controller decision result. */
+export const CONTROLLER_ACTION_GUARDS = [
+    'respond',
+    'resume',
+    'start',
+    'switch',
+    'dismiss',
+    'deliver',
+    'runtime',
+];
+/** Whether a result map has the exact Playbook 10 controller domain union. */
+export function isControllerDecisionResult(result) {
+    if (!isStringMap(result))
+        return false;
+    const keys = Object.keys(result).filter((key) => key !== NEEDS_BOSS_REPLY);
+    return (keys.length === CONTROLLER_ACTION_GUARDS.length &&
+        CONTROLLER_ACTION_GUARDS.every((guard) => Object.hasOwn(result, guard)));
+}
+/** A single missing or extra key against Playbook 10's controller domain. */
+export function controllerDecisionNearMiss(result) {
+    if (!isStringMap(result))
+        return undefined;
+    const actual = Object.keys(result).filter((key) => key !== NEEDS_BOSS_REPLY);
+    const expected = new Set(CONTROLLER_ACTION_GUARDS);
+    const present = new Set(actual);
+    const missing = CONTROLLER_ACTION_GUARDS.filter((key) => !present.has(key));
+    const extra = actual.filter((key) => !expected.has(key));
+    return missing.length + extra.length === 1 ? { missing, extra } : undefined;
+}
+/** Whether a machine contains Playbook 10's grounded controller decision state. */
+export function isControllerMachine(config) {
+    return enumerateCaptainBindings(config).some(({ state, pinActor }) => {
+        if (!pinActor || state.actor !== 'captain')
+            return false;
+        if (state.bindingFindings?.includes('invoke.input.result is not a string-valued object')) {
+            return false;
+        }
+        return isControllerDecisionResult(state.result);
+    });
+}
+/** Whether an explicit direct-Captain result is one key from the controller domain. */
+export function hasControllerDecisionNearMiss(config) {
+    return enumerateCaptainBindings(config).some(({ state, pinActor }) => pinActor &&
+        state.actor === 'captain' &&
+        state.result[NEEDS_BOSS_REPLY] === undefined &&
+        controllerDecisionNearMiss(state.result) !== undefined);
+}
+function concurrentRoleSets(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const sets = [];
+    for (const candidate of value) {
+        if (!Array.isArray(candidate) ||
+            candidate.some((role) => typeof role !== 'string')) {
+            return undefined;
+        }
+        sets.push([...candidate]);
+    }
+    return sets;
+}
 /**
  * Checks GEARS↔FSM conformance and returns human-readable findings (empty when
  * conformant): every GEARS item maps to one state with the same player and the
  * prompt verbatim, every captain state references a known item, and every
  * captain state's `result` map declares the Boss-reply suspension key with its
- * adjudicator contract (VERIFY-1, VERIFY-3; DR-009).
+ * adjudicator contract (verification-1, verification-3; DR-009).
  */
-export function checkGearsFsmConformance(gears, config) {
+export function checkGearsFsmConformance(gears, config, options = {}) {
     const items = parseGearsItems(gears);
+    const roleContract = inspectGearsRoleContract(gears);
+    const controller = isControllerMachine(config);
     const captainBindings = enumerateCaptainBindings(config);
     const states = captainBindings.map(({ state }) => state);
+    const controllerNearMisses = captainBindings.flatMap(({ state, pinActor }) => {
+        if (!pinActor ||
+            state.actor !== 'captain' ||
+            state.result[NEEDS_BOSS_REPLY] !== undefined) {
+            return [];
+        }
+        const nearMiss = controllerDecisionNearMiss(state.result);
+        return nearMiss === undefined ? [] : [{ state, nearMiss }];
+    });
+    const controllerNearMissStates = new Set(controllerNearMisses.map(({ state }) => state));
     const explicitActorStates = new Set(captainBindings
         .filter(({ pinActor }) => pinActor)
         .map(({ state }) => state));
     const playbookStates = enumeratePlaybookStates(config);
     const scriptStates = enumerateScriptStates(config);
     const findings = [];
+    for (const { state, nearMiss } of controllerNearMisses) {
+        const detail = nearMiss.missing.length > 0
+            ? `missing ${JSON.stringify(nearMiss.missing[0])}`
+            : `extra ${JSON.stringify(nearMiss.extra[0])}`;
+        findings.push(`FSM state ${state.stateId}: controller decision contract near-miss (${detail}); the controller domain requires exactly ${CONTROLLER_ACTION_GUARDS.join(', ')}`);
+    }
     findings.push(...structuredStateIdentityFindings(walkStateNodes(config)));
+    findings.push(...roleContract.findings);
+    const requiresConcurrentRoleSets = roleContract.generation === 'schema-3' ||
+        controller ||
+        options.artifactSchema === 3;
+    if (requiresConcurrentRoleSets) {
+        const actual = concurrentRoleSets(options.concurrentRoleSets);
+        if (actual === undefined) {
+            findings.push('schema-3 FSM exports no valid concurrentRoleSets array');
+        }
+        else if (JSON.stringify(actual) !== JSON.stringify(roleContract.concurrentRoleSets)) {
+            findings.push(`schema-3 FSM concurrentRoleSets ${JSON.stringify(actual)} do not match GEARS groups ${JSON.stringify(roleContract.concurrentRoleSets)}`);
+        }
+    }
     for (const item of items) {
         findings.push(...(item.resultFindings ?? []).map((finding) => `GEARS item ${item.id}: ${finding}`));
     }
@@ -840,8 +1201,24 @@ export function checkGearsFsmConformance(gears, config) {
             state.actor !== item.actor) {
             findings.push(`${item.id}: FSM actor "${state.actor}" is not GEARS actor "${item.actor}"`);
         }
-        if (item.actor === 'player' && state.player !== item.player) {
-            findings.push(`${item.id}: FSM player "${state.player}" is not GEARS player "${item.player}"`);
+        if (item.actor === 'player') {
+            if (roleContract.generation === 'schema-3') {
+                const expectedRole = canonicalRoleId(item.player);
+                if (state.role !== expectedRole) {
+                    findings.push(`${item.id}: FSM role ${JSON.stringify(state.role ?? '')} is not GEARS canonical role ${JSON.stringify(expectedRole)}`);
+                }
+                if (state.player !== '') {
+                    findings.push(`${item.id}: schema-3 delegated role carries removed invoke.input.player ${JSON.stringify(state.player)}`);
+                }
+            }
+            else {
+                if (state.player !== item.player) {
+                    findings.push(`${item.id}: FSM player "${state.player}" is not GEARS player "${item.player}"`);
+                }
+                if (state.role !== undefined) {
+                    findings.push(`${item.id}: historical delegated player unexpectedly carries invoke.input.role ${JSON.stringify(state.role)}`);
+                }
+            }
         }
         if (state.prompt !== item.prompt) {
             findings.push(`${item.id}: FSM prompt is not the GEARS prompt verbatim`);
@@ -871,11 +1248,19 @@ export function checkGearsFsmConformance(gears, config) {
         if (state.sourceItem !== '' && !itemIds.has(state.sourceItem)) {
             findings.push(`FSM state ${state.stateId} references unknown GEARS item ${state.sourceItem}`);
         }
-        // Every captain-invoking state supports Boss-reply suspension: its result
-        // map carries `needsBossReply` with the adjudicator-facing contract text
-        // (gears2fsm.md; VERIFY-3).
         const bossReply = state.result[NEEDS_BOSS_REPLY];
-        if (bossReply === undefined) {
+        if (controller) {
+            if (bossReply !== undefined) {
+                findings.push(`FSM controller state ${state.stateId} unexpectedly declares ${NEEDS_BOSS_REPLY}`);
+            }
+        }
+        else if (controllerNearMissStates.has(state)) {
+            // The precise controller-domain diagnostic above owns a malformed
+            // near-controller state; do not suggest adding the ordinary wait key to
+            // that state, while retaining ordinary findings for every other state.
+            continue;
+        }
+        else if (bossReply === undefined) {
             findings.push(`FSM state ${state.stateId} declares no ${NEEDS_BOSS_REPLY} result`);
         }
         else if (!bossReply.includes(BOSS_QUESTION_MARKER)) {
@@ -898,7 +1283,7 @@ export function checkGearsFsmConformance(gears, config) {
     return findings;
 }
 /*
- * Machine introspection (VERIFY-4).
+ * Machine introspection (verification-4).
  *
  * `pinIntrospection` reduces a machine config to its structural facts — the
  * captain-state bindings, every transition arm, the root and quiescent event
@@ -963,7 +1348,7 @@ function invokeSource(src) {
 }
 /**
  * Reduces a machine config to the structural facts the emitted introspection
- * test pins (VERIFY-4): captain bindings with result keys and every transition
+ * test pins (verification-4): captain bindings with result keys and every transition
  * arm, the quiescent states' event surfaces, the root event surface, and the
  * `BOSS_INTERRUPT` jumpable set.
  */
@@ -990,6 +1375,7 @@ export function pinIntrospection(config) {
                 : {}),
             sourceItem: binding.state.sourceItem,
             player: binding.state.player,
+            ...(binding.state.role !== undefined ? { role: binding.state.role } : {}),
             resultKeys: Object.keys(binding.state.result).sort(),
             onDone: normalizeArms(binding.invoke.onDone),
             onError: normalizeArms(binding.invoke.onError),
@@ -1061,7 +1447,7 @@ export function pinIntrospection(config) {
     };
 }
 /*
- * Prompt-contract capture and composition checks (VERIFY-5).
+ * Prompt-contract capture and composition checks (verification-5).
  *
  * The contract is derived from the artifacts, never hand-authored: context
  * reads are traced through each state's `invoke.input` thunk with a recording
@@ -1079,6 +1465,7 @@ export const BOSS_REPLY_LABEL = 'Boss reply:';
 // labelled form as well as natural-language variants; occurrence deltas below
 // keep self-hosting prompt bodies free to quote either marker verbatim.
 const PLAYER_BINDING_MARKER = /\bplayer\s+binding\b|(?:^|\n)[ \t]*player[ \t]*:[ \t]*(?=\S)/gi;
+const ROLE_BINDING_MARKER = /\brole\s+binding\b|(?:^|\n)[ \t]*role[ \t]*:[ \t]*(?=\S)/gi;
 const PLAYER_RESUME_MARKER = /\b(?:resume|resuming)\b[^\n]{0,120}\bplayer(?:'s)?\b|\bplayer(?:'s)?\b[^\n]{0,120}\b(?:resume|resuming)\b/gi;
 const PLACEHOLDER = /<[^\s<>`]{1,60}>/g;
 /** Lists the distinct `<...>` placeholder tokens in a prompt body, in order. */
@@ -1139,7 +1526,7 @@ function carriesSentinel(value, sentinel) {
 }
 /**
  * Derives every captain state's prompt contract from the machine config
- * (VERIFY-5): traced context reads, sentinel-traced input wiring, and the
+ * (verification-5): traced context reads, sentinel-traced input wiring, and the
  * prompt body's placeholder tokens.
  */
 export function capturePromptContract(config) {
@@ -1167,6 +1554,7 @@ export function capturePromptContract(config) {
             state: state.stateId,
             sourceItem: state.sourceItem,
             player: state.player,
+            ...(state.role !== undefined ? { role: state.role } : {}),
             reads,
             wires,
             placeholders: placeholdersIn(state.prompt),
@@ -1178,7 +1566,7 @@ export function capturePromptContract(config) {
  * Derives, per captain state, which of its prompt's placeholder tokens the
  * linked composer substitutes when the wired context is present — pinned into
  * the emitted test so a token that later leaks unsubstituted fails it
- * (VERIFY-5).
+ * (verification-5).
  */
 export function deriveSubstitutions(config, compose, actor) {
     const out = {};
@@ -1190,7 +1578,7 @@ export function deriveSubstitutions(config, compose, actor) {
             continue;
         try {
             const reads = probeContextReads(inputFn);
-            const composed = compose(inputFn({ context: ordinaryContext(reads) }));
+            const composed = composeForState(compose, state, inputFn({ context: ordinaryContext(reads) }));
             if (typeof composed !== 'string') {
                 out[state.stateId] = [];
                 continue;
@@ -1201,8 +1589,9 @@ export function deriveSubstitutions(config, compose, actor) {
             // hide valid evidence, while merely deleting a token still cannot
             // masquerade as substitution.
             const evidenced = new Set();
+            const promptReads = promptSentinelFields(state, reads);
             for (const line of state.prompt.split('\n')) {
-                for (const token of matchPromptBody(line, composed, reads)
+                for (const token of matchPromptBody(line, composed, promptReads)
                     ?.substitutions ?? []) {
                     evidenced.add(token);
                 }
@@ -1217,7 +1606,7 @@ export function deriveSubstitutions(config, compose, actor) {
 }
 /**
  * Checks the linked composer against the link contract for every captain state
- * (VERIFY-5), returning findings (empty when conformant): the prompt body is
+ * (verification-5), returning findings (empty when conformant): the prompt body is
  * preserved modulo substituted placeholders, the adjudicator-facing Boss-reply
  * contract never leaks into a player prompt, no continuation appears on an
  * ordinary turn, and a Boss-reply continuation turn opens with the exact
@@ -1225,19 +1614,30 @@ export function deriveSubstitutions(config, compose, actor) {
  */
 export function checkPromptComposition(opts) {
     const findings = [];
+    const controller = isControllerMachine(opts.config);
+    const schemaResolution = resolveArtifactSchemaForVerification({
+        config: opts.config,
+        ...(opts.artifactSchema === undefined
+            ? {}
+            : { artifactSchema: opts.artifactSchema }),
+    });
+    findings.push(...schemaResolution.findings);
+    const inferredArtifactSchema = schemaResolution.artifactSchema;
     const substitutions = deriveSubstitutions(opts.config, opts.compose, opts.actor);
     const composerName = opts.actor === 'captain' ? 'composeCaptainPrompt' : 'composePlayerPrompt';
-    for (const binding of enumerateCaptainBindings(opts.config)) {
+    const bindings = enumerateCaptainBindings(opts.config);
+    for (const binding of bindings) {
         const { state, inputFn } = binding;
         if (opts.actor !== undefined && state.actor !== opts.actor)
             continue;
         if (typeof inputFn !== 'function')
             continue;
         const reads = probeContextReads(inputFn);
+        const promptReads = promptSentinelFields(state, reads);
         const substituted = substitutions[state.stateId] ?? [];
         let ordinary;
         try {
-            ordinary = opts.compose(inputFn({ context: ordinaryContext(reads) }));
+            ordinary = composeForState(opts.compose, state, inputFn({ context: ordinaryContext(reads) }));
             if (typeof ordinary !== 'string') {
                 throw new Error(`${composerName} returned a non-string value`);
             }
@@ -1246,8 +1646,8 @@ export function checkPromptComposition(opts) {
             findings.push(`${state.stateId}: ${composerName} threw on an ordinary turn: ${messageOf(error)}`);
             continue;
         }
-        findings.push(...bodyFindings(state, ordinary, substituted, reads, 'ordinary'));
-        pushUnique(findings, ...directCaptainControlFindings(state, ordinary));
+        findings.push(...bodyFindings(state, ordinary, substituted, promptReads, 'ordinary'));
+        pushUnique(findings, ...promptControlFindings(state, ordinary));
         // A self-hosted playbook's domain body may legitimately quote the
         // adjudicator contract or the continuation texts (it instructs a compiler
         // about them); only occurrences the composer ADDS beyond the body's own
@@ -1259,15 +1659,34 @@ export function checkPromptComposition(opts) {
         if ([CONTINUATION_PREAMBLE, BOSS_QUESTION_LABEL, BOSS_REPLY_LABEL].some((needle) => occurrences(ordinary, needle) > occurrences(state.prompt, needle))) {
             findings.push(`${state.stateId}: continuation blocks appear on an ordinary turn`);
         }
+        // Controllers own no Boss-reply wait. A missing ordinary result is already
+        // diagnosed by conformance, so do not fabricate a continuation contract.
+        if (controller || !Object.hasOwn(state.result, NEEDS_BOSS_REPLY))
+            continue;
+        const artifactSchema = schemaResolution.findings.length > 0
+            ? undefined
+            : (inferredArtifactSchema ??
+                (state.role !== undefined ? 3 : state.player !== '' ? 1 : undefined));
+        if (artifactSchema === undefined) {
+            findings.push(`${state.stateId}: prompt composition requires artifactSchema 1 or 3 to probe this direct-Captain continuation`);
+            continue;
+        }
         // A Boss-reply continuation turn: the thunk carries the pending question
         // and reply, and the composer opens with the exact preamble and labelled
         // Q&A blocks before the domain body (gears2fsm.md, link.md).
         const question = sentinelFor('question');
         const reply = sentinelFor('bossReply');
         const pendingBossQuestion = {
+            ...(artifactSchema === 3
+                ? state.actor === 'captain'
+                    ? { asker: { kind: 'captain' } }
+                    : { asker: { kind: 'role', roleId: state.role ?? '' } }
+                : {
+                    player: state.actor === 'captain' ? 'Captain' : state.player,
+                }),
+            questionId: state.stateId,
             resumeStateId: state.stateId,
             sourceItem: state.sourceItem,
-            player: state.player,
             question,
         };
         let continuation;
@@ -1284,7 +1703,7 @@ export function checkPromptComposition(opts) {
                     bossReplies: { [state.stateId]: reply },
                 },
             });
-            continuation = opts.compose(input);
+            continuation = composeForState(opts.compose, state, input);
             if (typeof continuation !== 'string') {
                 throw new Error(`${composerName} returned a non-string value`);
             }
@@ -1300,7 +1719,7 @@ export function checkPromptComposition(opts) {
         if (!continuation.startsWith(`${CONTINUATION_PREAMBLE}\n\n`)) {
             findings.push(`${state.stateId}: a continuation turn does not open with the exact preamble`);
         }
-        const bodyStart = bodyIndex(state, continuation, substituted, reads);
+        const bodyStart = bodyIndex(state, continuation, substituted, promptReads);
         const questionBlock = `${BOSS_QUESTION_LABEL}\n${question}`;
         const replyBlock = `${BOSS_REPLY_LABEL}\n${reply}`;
         for (const [label, value] of [
@@ -1322,21 +1741,59 @@ export function checkPromptComposition(opts) {
         if (!continuation.startsWith(exactContinuationPrefix)) {
             findings.push(`${state.stateId}: a continuation turn does not preserve the exact ordered Boss question/reply blocks`);
         }
-        findings.push(...bodyFindings(state, continuation, substituted, reads, 'continuation'));
-        pushUnique(findings, ...directCaptainControlFindings(state, continuation));
+        findings.push(...bodyFindings(state, continuation, substituted, promptReads, 'continuation'));
+        pushUnique(findings, ...promptControlFindings(state, continuation));
     }
     return findings;
 }
-function directCaptainControlFindings(state, composed) {
-    if (state.actor !== 'captain')
-        return [];
+function promptSentinelFields(state, reads) {
+    return state.role === undefined
+        ? [...reads]
+        : [...reads, `promptIdentity:${state.role}`];
+}
+function composeForState(compose, state, input) {
+    // Schema-1 composers and the shared default composer use their second
+    // positional argument as a placeholder-field map. A callable proxy with a
+    // property-clean view is therefore both an invocation-scoped schema-3 lookup
+    // and an empty map to historical/default composition, without Function.name,
+    // Function.length, or Function.prototype token collisions.
+    const lookup = (roleId) => {
+        if (state.role === undefined) {
+            throw new Error(`prompt identity lookup used role ${JSON.stringify(roleId)} for a direct-Captain or historical state`);
+        }
+        if (roleId !== state.role) {
+            throw new Error(`prompt identity lookup used role ${JSON.stringify(roleId)} instead of canonical local role ${JSON.stringify(state.role)}`);
+        }
+        return sentinelFor(`promptIdentity:${roleId}`);
+    };
+    const promptIdentity = new Proxy(lookup, {
+        get: () => undefined,
+        has: () => false,
+        ownKeys: () => [],
+        getOwnPropertyDescriptor: () => undefined,
+    });
+    return state.actor === 'player' && state.role !== undefined
+        ? compose(input, promptIdentity)
+        : compose(input);
+}
+function promptControlFindings(state, composed) {
     const findings = [];
-    if (patternOccurrences(composed, PLAYER_BINDING_MARKER) >
-        patternOccurrences(state.prompt, PLAYER_BINDING_MARKER)) {
+    const introducesPlayerBinding = patternOccurrences(composed, PLAYER_BINDING_MARKER) >
+        patternOccurrences(state.prompt, PLAYER_BINDING_MARKER);
+    if (state.actor === 'captain' && introducesPlayerBinding) {
         findings.push(`${state.stateId}: composeCaptainPrompt introduces a player binding into a direct-Captain prompt`);
     }
-    if (patternOccurrences(composed, PLAYER_RESUME_MARKER) >
-        patternOccurrences(state.prompt, PLAYER_RESUME_MARKER)) {
+    else if (state.role !== undefined && introducesPlayerBinding) {
+        findings.push(`${state.stateId}: composePlayerPrompt exposes a concrete player binding in a schema-3 delegated-role prompt`);
+    }
+    if (state.actor === 'captain' &&
+        patternOccurrences(composed, ROLE_BINDING_MARKER) >
+            patternOccurrences(state.prompt, ROLE_BINDING_MARKER)) {
+        findings.push(`${state.stateId}: composeCaptainPrompt introduces a role binding into a direct-Captain prompt`);
+    }
+    if (state.actor === 'captain' &&
+        patternOccurrences(composed, PLAYER_RESUME_MARKER) >
+            patternOccurrences(state.prompt, PLAYER_RESUME_MARKER)) {
         findings.push(`${state.stateId}: composeCaptainPrompt introduces a player resume instruction into a direct-Captain prompt`);
     }
     return findings;
@@ -1429,7 +1886,7 @@ function matchPromptBody(prompt, composed, reads, expectedSubstitutions) {
     }
     return null;
 }
-/** Findings when a composed prompt does not preserve the domain body (VERIFY-5). */
+/** Findings when a composed prompt does not preserve the domain body (verification-5). */
 function bodyFindings(state, composed, substituted, reads, turn) {
     if (matchPromptBody(state.prompt, composed, reads, substituted) !== null) {
         return [];
@@ -1454,7 +1911,7 @@ function bodyFindings(state, composed, substituted, reads, turn) {
 function bodyIndex(state, composed, substituted, reads) {
     return (matchPromptBody(state.prompt, composed, reads, substituted)?.index ?? -1);
 }
-// Local copy: this module is copied verbatim beside the artifact (VERIFY-12),
+// Local copy: this module is copied verbatim beside the artifact (verification-12),
 // so it may not import a sibling module.
 function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -1492,6 +1949,12 @@ export function findMachineConfig(fsmModule) {
     }
     throw new Error('fsm module exports no XState machine with a `.config.states`');
 }
+/** Reads the schema-3 cohort declaration from an imported FSM module. */
+export function findConcurrentRoleSets(fsmModule) {
+    if (typeof fsmModule !== 'object' || fsmModule === null)
+        return undefined;
+    return fsmModule.concurrentRoleSets;
+}
 /**
  * Builds a per-artifact vitest module that fails when the compiled FSM drifts
  * from its GEARS source: it reads the artifact's `gears` file and the machine its
@@ -1502,22 +1965,35 @@ export function generateGearsFsmConformanceTest(opts) {
     return `// SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 
-// Generated by slc (IR-007 Task 8): GEARS↔FSM conformance.
+// Generated by slc (DR-009): GEARS↔FSM conformance.
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 import { describe, expect, it } from 'vitest';
 
-import { checkGearsFsmConformance, findMachineConfig } from ${sourceString(opts.verifyModule)};
+import { checkGearsFsmConformance, findConcurrentRoleSets, findMachineConfig } from ${sourceString(opts.verifyModule)};
 import * as fsm from ${sourceString(opts.fsmModule)};
 
+const SCHEMA_FINDINGS = ${JSON.stringify(opts.schemaFindings ?? [], null, 2)};
+
 describe(${sourceString(`${opts.basename}: GEARS↔FSM conformance`)}, () => {
+  it('uses consistent artifact-schema evidence', () => {
+    expect(SCHEMA_FINDINGS).toEqual([]);
+  });
+
   it('maps every GEARS item to a state with its player and verbatim prompt', () => {
     const gears = readFileSync(
       fileURLToPath(new URL(${sourceString(opts.gearsFile)}, import.meta.url)),
       'utf8',
     );
-    expect(checkGearsFsmConformance(gears, findMachineConfig(fsm))).toEqual([]);
+    expect(
+      checkGearsFsmConformance(gears, findMachineConfig(fsm), {
+        concurrentRoleSets: findConcurrentRoleSets(fsm),
+        ${opts.artifactSchema === undefined
+        ? ''
+        : `artifactSchema: ${opts.artifactSchema},`}
+      }),
+    ).toEqual([]);
   });
 });
 `;
@@ -1526,7 +2002,7 @@ describe(${sourceString(`${opts.basename}: GEARS↔FSM conformance`)}, () => {
  * Emits the GEARS↔FSM conformance test as `slc` output beside a compiled
  * `playbook` artifact: writes `<basename>.gears-fsm.test.ts` into the artifact
  * directory (`<basename>.playbook/`), wiring the artifact's `gears` file and its
- * `fsm` module's machine to the checker, and returns the written path (VERIFY-2;
+ * `fsm` module's machine to the checker, and returns the written path (verification-2;
  * [DR-009](../decisions/009-slc-playbook-pipeline-compilation.md)).
  */
 export async function emitGearsFsmConformanceTest(opts) {
@@ -1537,6 +2013,10 @@ export async function emitGearsFsmConformanceTest(opts) {
         fsmModule: `./${opts.basename}.fsm.js`,
         gearsFile: `./${opts.basename}.gears.md`,
         verifyModule: opts.verifyModule ?? VERIFY_MODULE,
+        ...(opts.artifactSchema === undefined
+            ? {}
+            : { artifactSchema: opts.artifactSchema }),
+        schemaFindings: opts.schemaFindings,
     });
     await mkdir(opts.artifactDir, { recursive: true });
     const path = join(opts.artifactDir, `${opts.basename}.gears-fsm.test.ts`);
@@ -1558,14 +2038,15 @@ export async function loadFsmModule(fsmPath) {
     return import(url.href);
 }
 /**
- * Imports the generated linked TypeScript module before its sibling FSM has
- * been built to JavaScript. NodeNext source correctly names the runtime-safe
- * `./<basename>.fsm.js` edge, but emission-time verification runs while only
- * `./<basename>.fsm.ts` exists. Stage a same-directory copy whose one generated
- * module specifier points at the hashed TypeScript artifact, import that copy,
- * and remove it without changing the linked source or its production import.
+ * Imports generated linked TypeScript for emission-time, standalone, or
+ * equivalence review before its sibling FSM has been built to JavaScript.
+ * NodeNext source correctly names the runtime-safe `./<basename>.fsm.js` edge,
+ * but review may run while only `./<basename>.fsm.ts` exists. Stage a
+ * same-directory copy whose one generated module specifier points at the
+ * hashed TypeScript artifact, import that copy, and remove it without changing
+ * the linked source or its production import.
  */
-async function loadLinkedModuleForVerification(opts) {
+export async function loadLinkedModuleForVerification(opts) {
     const linkedSource = await readFile(opts.linkedPath, 'utf8');
     const fsmStem = basename(opts.fsmPath, '.ts');
     const runtimeSpecifier = `./${fsmStem}.js`;
@@ -1590,7 +2071,7 @@ async function loadLinkedModuleForVerification(opts) {
 }
 /**
  * Builds a per-artifact vitest module that fails when the machine's structure
- * drifts from the topology pinned at build time (VERIFY-4).
+ * drifts from the topology pinned at build time (verification-4).
  */
 export function generateFsmIntrospectionTest(opts) {
     return `// SPDX-License-Identifier: Apache-2.0
@@ -1615,7 +2096,7 @@ describe(${sourceString(`${opts.basename}: FSM introspection`)}, () => {
 }
 /**
  * Builds a per-artifact vitest module pinning the prompt contract derived from
- * the artifacts at build time (VERIFY-5): the per-state context reads, input
+ * the artifacts at build time (verification-5): the per-state context reads, input
  * wiring, and placeholders always; and, when the linked module exposes its
  * matching Captain/player composers, the composition checks and pinned
  * substitution maps.
@@ -1650,6 +2131,9 @@ const ${compose} = (
         config: findMachineConfig(fsm),
         compose: ${compose},
         actor: '${actor}',
+        ${opts.artifactSchema === undefined
+                ? ''
+                : `artifactSchema: ${opts.artifactSchema},`}
       }),
     ).toEqual([]);
   });
@@ -1684,17 +2168,157 @@ import {
 import * as fsm from ${sourceString(opts.fsmModule)};
 ${composerImports}
 const CONTRACT = ${JSON.stringify(opts.rows, null, 2)};
+const SCHEMA_FINDINGS = ${JSON.stringify(opts.schemaFindings ?? [], null, 2)};
 
 describe(${sourceString(`${opts.basename}: prompt contract`)}, () => {
+  it('uses consistent artifact-schema evidence', () => {
+    expect(SCHEMA_FINDINGS).toEqual([]);
+  });
+
   it('matches the prompt contract pinned at build time', () => {
     expect(capturePromptContract(findMachineConfig(fsm))).toEqual(CONTRACT);
   });
 ${composerBlock}});
 `;
 }
+function promptArtifactSchemaSignalsFromConfig(config) {
+    const states = enumerateCaptainStates(config);
+    return {
+        schema1: states.some(({ player }) => player !== ''),
+        schema3: isControllerMachine(config) ||
+            states.some(({ role }) => role !== undefined),
+    };
+}
+function linkedArtifactSchemaSignal(linked) {
+    const factory = linked.default;
+    if (typeof factory !== 'function') {
+        return { historicalFallback: false, invalidCompatibility: false };
+    }
+    if (!Object.hasOwn(factory, 'compat')) {
+        return { historicalFallback: true, invalidCompatibility: false };
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(factory, 'compat');
+    if (descriptor === undefined ||
+        !Object.hasOwn(descriptor, 'value') ||
+        descriptor.enumerable !== true ||
+        descriptor.writable !== false ||
+        descriptor.configurable !== false) {
+        return { historicalFallback: false, invalidCompatibility: true };
+    }
+    const compat = descriptor.value;
+    if (typeof compat !== 'object' ||
+        compat === null ||
+        Array.isArray(compat) ||
+        Object.getPrototypeOf(compat) !== Object.prototype ||
+        !Object.isFrozen(compat) ||
+        Object.getOwnPropertySymbols(compat).length !== 0) {
+        return { historicalFallback: false, invalidCompatibility: true };
+    }
+    const names = Object.getOwnPropertyNames(compat);
+    const artifactSchema = Object.getOwnPropertyDescriptor(compat, 'artifactSchema');
+    const runtimeAbi = Object.getOwnPropertyDescriptor(compat, 'runtimeAbi');
+    const exact = names.length === 2 &&
+        names.includes('artifactSchema') &&
+        names.includes('runtimeAbi') &&
+        artifactSchema?.enumerable === true &&
+        Object.hasOwn(artifactSchema, 'value') &&
+        artifactSchema.value === 3 &&
+        runtimeAbi?.enumerable === true &&
+        Object.hasOwn(runtimeAbi, 'value') &&
+        runtimeAbi.value === 1;
+    return exact
+        ? { schema: 3, historicalFallback: false, invalidCompatibility: false }
+        : { historicalFallback: false, invalidCompatibility: true };
+}
+/**
+ * Schema decision shared by generated and standalone artifact verification
+ * (verification-21). Reviewed provenance is evidence through its exact
+ * historical map; any other provenance is evidence only through the engine
+ * declaration read from the link target's installed package — `RUNTIME_ABI`
+ * `1` with artifact schema `3` — and is otherwise reported unsupported
+ * (DR-028).
+ */
+export function resolveArtifactSchemaForVerification(opts) {
+    const candidates = [];
+    const invalidSignalFindings = [];
+    if (opts.artifactSchema !== undefined) {
+        candidates.push({
+            source: 'review-supplied artifact schema',
+            schema: opts.artifactSchema,
+        });
+    }
+    const provenance = opts.provenance ?? opts.runtimeDeclaration?.provenance;
+    const provenanceSchema = artifactSchemaForPlaybookProvenance(provenance);
+    if (provenanceSchema !== undefined) {
+        candidates.push({
+            source: 'reviewed link-target provenance',
+            schema: provenanceSchema,
+        });
+    }
+    else if (provenance !== undefined) {
+        if (opts.runtimeDeclaration === undefined) {
+            invalidSignalFindings.push(`artifact schema has unsupported link-target provenance ${JSON.stringify(provenance)}`);
+        }
+        else if (declaresComposedV3(opts.runtimeDeclaration)) {
+            candidates.push({ source: 'declared link-target contract', schema: 3 });
+        }
+        else {
+            invalidSignalFindings.push(`artifact schema has an unsupported link-target contract: ${describeRuntimeDeclaration(opts.runtimeDeclaration)}`);
+        }
+    }
+    if (opts.config !== undefined) {
+        const configSignals = promptArtifactSchemaSignalsFromConfig(opts.config);
+        if (configSignals.schema1)
+            candidates.push({ source: 'FSM historical-player structure', schema: 1 });
+        if (configSignals.schema3)
+            candidates.push({ source: 'FSM role/controller structure', schema: 3 });
+    }
+    const linkedSignal = opts.linked === undefined
+        ? undefined
+        : linkedArtifactSchemaSignal(opts.linked);
+    if (linkedSignal?.schema !== undefined) {
+        candidates.push({
+            source: 'linked factory compatibility',
+            schema: linkedSignal.schema,
+        });
+    }
+    if (linkedSignal?.invalidCompatibility) {
+        invalidSignalFindings.push('linked factory has an own compatibility declaration that is not exact immutable schema 3/runtime ABI 1');
+    }
+    if (invalidSignalFindings.length > 0) {
+        return { findings: invalidSignalFindings };
+    }
+    const schemas = new Set(candidates.map(({ schema }) => schema));
+    if (schemas.size > 1) {
+        return {
+            findings: [
+                `artifact schema signals disagree (${candidates
+                    .map(({ source, schema }) => `${source}: ${schema}`)
+                    .join(', ')})`,
+            ],
+        };
+    }
+    const [artifactSchema] = schemas;
+    if (artifactSchema !== undefined) {
+        return { artifactSchema, findings: [] };
+    }
+    if (linkedSignal?.historicalFallback) {
+        return { artifactSchema: 1, findings: [] };
+    }
+    const hasAmbiguousCaptainContinuation = opts.config !== undefined &&
+        enumerateCaptainStates(opts.config).some((state) => state.actor === 'captain' &&
+            Object.hasOwn(state.result, NEEDS_BOSS_REPLY));
+    return hasAmbiguousCaptainContinuation
+        ? {
+            findings: [
+                'artifact schema has no reviewed provenance, generation-specific actor structure, or callable linked factory for a direct-Captain continuation',
+            ],
+        }
+        : { findings: [] };
+}
 /**
  * Emits the prompt-contract test beside a compiled `playbook` artifact
- * (VERIFY-5): derives and pins the per-state contract from the physical
+ * (verification-5): derives and pins the per-state contract from the physical
  * `<basename>.fsm.ts` artifact, then emits NodeNext `.js` imports for that FSM
  * and any linked `<basename>.playbook.ts` module. When the linked module
  * exposes the `_internal` composer matching each state actor —
@@ -1711,6 +2335,20 @@ export async function emitPromptContractTest(opts) {
     const fsmPath = join(opts.artifactDir, `${opts.basename}.fsm.ts`);
     const config = findMachineConfig(await loadFsmModule(fsmPath));
     const rows = capturePromptContract(config);
+    const evidence = {
+        ...(opts.provenance === undefined ? {} : { provenance: opts.provenance }),
+        ...(opts.runtimeDeclaration === undefined
+            ? {}
+            : { runtimeDeclaration: opts.runtimeDeclaration }),
+        ...(opts.artifactSchema === undefined
+            ? {}
+            : { artifactSchema: opts.artifactSchema }),
+    };
+    let schemaResolution = resolveArtifactSchemaForVerification({
+        config,
+        ...evidence,
+    });
+    let artifactSchema = schemaResolution.artifactSchema;
     let composer;
     const linkedPath = join(opts.artifactDir, `${opts.basename}.playbook.ts`);
     if (existsSync(linkedPath)) {
@@ -1719,6 +2357,12 @@ export async function emitPromptContractTest(opts) {
                 linkedPath,
                 fsmPath,
             }));
+            schemaResolution = resolveArtifactSchemaForVerification({
+                config,
+                linked,
+                ...evidence,
+            });
+            artifactSchema = schemaResolution.artifactSchema;
             const actors = new Set(enumerateCaptainStates(config).map(({ actor }) => actor));
             const substitutions = {};
             for (const actor of ['captain', 'player']) {
@@ -1736,6 +2380,7 @@ export async function emitPromptContractTest(opts) {
                     config,
                     compose: typedCompose,
                     actor,
+                    ...(artifactSchema === undefined ? {} : { artifactSchema }),
                 });
                 diagnostics.push(...findings.map((finding) => `prompt contract: ${finding}`));
             }
@@ -1751,11 +2396,14 @@ export async function emitPromptContractTest(opts) {
             diagnostics.push(`prompt contract: linked module could not be imported (${messageOf(error)}); composition checks not emitted`);
         }
     }
+    diagnostics.unshift(...schemaResolution.findings.map((finding) => `prompt contract: ${finding}`));
     const content = generatePromptContractTest({
         basename: opts.basename,
         fsmModule: `./${opts.basename}.fsm.js`,
         verifyModule: opts.verifyModule ?? VERIFY_MODULE,
         rows,
+        ...(artifactSchema === undefined ? {} : { artifactSchema }),
+        schemaFindings: schemaResolution.findings,
         composer,
     });
     await mkdir(opts.artifactDir, { recursive: true });
@@ -1765,7 +2413,7 @@ export async function emitPromptContractTest(opts) {
 }
 /**
  * Emits the introspection test beside a compiled `playbook` artifact
- * (VERIFY-4): derives topology pins from the physical `<basename>.fsm.ts`,
+ * (verification-4): derives topology pins from the physical `<basename>.fsm.ts`,
  * emits a NodeNext `.js` import for that sibling source, and writes
  * `<basename>.fsm.introspect.test.ts` into the artifact directory.
  *
@@ -1785,7 +2433,7 @@ export async function emitFsmIntrospectionTest(opts) {
     await writeFile(path, content);
     return path;
 }
-// Transition-coverage verification (VERIFY-6) lives in its own module — it
+// Transition-coverage verification (verification-6) lives in its own module — it
 // depends on `xstate` to drive the machine — and is re-exported here so every
 // generated test imports one checker module (`@sublang/slc/verify`).
 export * from './verify-coverage.js';