@sublang/slc 0.9.0 → 0.11.0

package/dist/verify.js

@@ -109,6 +109,10 @@ export async function playbookProvenanceForLinkTarget(linkTarget) {
         cursor = parent;
     }
 }
+/** Both XState initial-transition forms select one immediate child key. */
+export function initialStateTarget(initial) {
+    return typeof initial === 'string' ? initial : initial?.target;
+}
 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
@@ -132,6 +136,7 @@ const SECTION_HEADING = /^##\s/;
 const RESULTS_LABEL = /^Results:\s*$/;
 const RESULTS_LABEL_NEAR_MISS = /^Results\s*:?[ \t]*$/;
 const RESULT_BULLET = /^-\s+`([A-Za-z_$][A-Za-z0-9_$]*)`:\s+(\S(?:.*\S)?)\s*$/;
+const PLAYBOOK_CALL_SEQUENCING_NEAR_MISS = /\bCaptain shall (first|then|next|finally) call playbook\b/u;
 /**
  * Parses the GEARS items from a `gears` artifact: each `### <ID>` item's player,
  * blockquoted acting prompt, and optional ordered `Results:` metadata.
@@ -203,7 +208,7 @@ export function parseGearsItems(gears) {
         }
         current = null;
     };
-    for (const line of gears.split('\n')) {
+    for (const line of gears.split(/\r?\n/)) {
         const heading = ITEM_HEADING.exec(line);
         if (heading !== null) {
             flush();
@@ -266,6 +271,7 @@ export function parseGearsItems(gears) {
             if (guard === NEEDS_BOSS_REPLY) {
                 current.resultFindings.push(`${NEEDS_BOSS_REPLY} is compiler-owned and shall not be source metadata`);
             }
+            current.resultFindings.push(...outputFieldGuidanceFindings(guard, description));
             current.results.push([guard, description]);
             continue;
         }
@@ -307,6 +313,68 @@ export function parseGearsItems(gears) {
     flush();
     return items;
 }
+/** Backticks in an output clause declare fields, never nested prose (DR-051). */
+function outputFieldGuidanceFindings(guard, description) {
+    const marker = description.indexOf('Output shall include');
+    if (marker < 0)
+        return [];
+    let depth = 0;
+    const findings = [];
+    for (const [token] of description.slice(marker).matchAll(/`[^`]+`|[()]/g)) {
+        if (token === '(')
+            depth++;
+        else if (token === ')')
+            depth = Math.max(0, depth - 1);
+        else if (depth > 0) {
+            findings.push(`result \`${guard}\` puts ${token} inside parenthetical output guidance; output-clause backticks declare fields, so move the field declaration outside parentheses or use plain guidance text or a complete field annotation`);
+        }
+    }
+    return findings;
+}
+function gearsResultFindings(items) {
+    return items.flatMap((item) => (item.resultFindings ?? []).map((finding) => `GEARS item ${item.id}: ${finding}`));
+}
+function gearsActorFindings(gears) {
+    const findings = [];
+    let item;
+    let inResults = false;
+    for (const line of gears.split('\n')) {
+        const heading = ITEM_HEADING.exec(line);
+        if (heading !== null) {
+            item = heading[1];
+            inResults = false;
+            continue;
+        }
+        if (SECTION_HEADING.test(line)) {
+            item = undefined;
+            inResults = false;
+            continue;
+        }
+        if (item === undefined)
+            continue;
+        if (BLOCKQUOTE.test(line))
+            continue;
+        if (RESULTS_LABEL.test(line) || RESULTS_LABEL_NEAR_MISS.test(line)) {
+            inResults = true;
+            continue;
+        }
+        if (inResults)
+            continue;
+        const nearMiss = PLAYBOOK_CALL_SEQUENCING_NEAR_MISS.exec(line);
+        if (nearMiss === null)
+            continue;
+        findings.push(`GEARS item ${item}: ${JSON.stringify(nearMiss[0])} is not a valid nested-playbook acting clause; use exact \`Captain shall call playbook ...:\` and preserve sequencing in When/While or continuation prose`);
+    }
+    return findings;
+}
+/** Existing GEARS result-parser findings, without requiring a consumer FSM. */
+export function checkGearsResultContract(gears) {
+    return gearsResultFindings(parseGearsItems(gears));
+}
+/** GEARS actor-clause findings, without changing parser classification. */
+export function checkGearsActorContract(gears) {
+    return gearsActorFindings(gears);
+}
 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) {
@@ -475,7 +543,13 @@ function normalizeInvokes(invoke) {
     }
     return typeof invoke === 'object' && invoke !== null ? [invoke] : [];
 }
-function invocationInput(invoke, context = {}) {
+function invocationInput(invoke, context = {}, allowStatic = false) {
+    if (allowStatic &&
+        typeof invoke.input === 'object' &&
+        invoke.input !== null &&
+        !Array.isArray(invoke.input)) {
+        return { value: invoke.input };
+    }
     if (typeof invoke.input !== 'function')
         return { invalid: true };
     let value;
@@ -610,7 +684,7 @@ function enumerateCaptainBindings(config) {
                         state: malformedCaptainState(publicStateId(node, undefined), `invoke.input threw during introspection: ${inspected.error}`, actor, node),
                         node,
                         invoke,
-                        inputFn: invoke.input,
+                        inputFn: typeof invoke.input === 'function' ? invoke.input : undefined,
                         pinActor: true,
                     });
                 }
@@ -625,7 +699,7 @@ function enumerateCaptainBindings(config) {
                             : 'invoke.input is not a function', actor, node),
                         node,
                         invoke,
-                        inputFn: invoke.input,
+                        inputFn: typeof invoke.input === 'function' ? invoke.input : undefined,
                         pinActor: true,
                     });
                 }
@@ -712,7 +786,7 @@ function enumerateCaptainBindings(config) {
                 },
                 node,
                 invoke,
-                inputFn: invoke.input,
+                inputFn: typeof invoke.input === 'function' ? invoke.input : undefined,
                 pinActor,
             });
         }
@@ -733,7 +807,7 @@ function enumeratePlaybookBindings(config) {
         for (const invoke of normalizeInvokes(node.state.invoke)) {
             if (invokeSource(invoke.src) !== 'playbook')
                 continue;
-            const inspected = invocationInput(invoke, initial);
+            const inspected = invocationInput(invoke, initial, true);
             if ('error' in inspected) {
                 out.push({
                     state: malformedPlaybookState(publicStateId(node, undefined), `invoke.input threw during introspection: ${inspected.error}`, node),
@@ -774,7 +848,7 @@ function enumeratePlaybookBindings(config) {
                         ...initial,
                         [fields.playbookIdContext]: playbookIdSentinel,
                         [fields.textContext]: textSentinel,
-                    });
+                    }, true);
                     if ('error' in wired) {
                         bindingFindings.push(`invoke.input threw during dynamic context introspection: ${wired.error}`);
                     }
@@ -1028,6 +1102,28 @@ function concurrentRoleSets(value) {
     }
     return sets;
 }
+/** Reject tags that prevent the public runtime returning a pending child. */
+export function checkFsmChildSuspension(config) {
+    const nodes = walkStateNodes(config);
+    const busy = (tags) => typeof tags === 'string'
+        ? tags === 'playbook.busy'
+        : tags?.includes('playbook.busy') === true;
+    return enumeratePlaybookBindings(config).flatMap(({ node, state }) => {
+        const locations = [
+            ...(busy(config.tags) ? ['machine root'] : []),
+            ...nodes
+                .filter((ancestor) => ancestor.path.length <= node.path.length &&
+                ancestor.path.every((key, index) => key === node.path[index]) &&
+                busy(ancestor.state.tags))
+                .map((ancestor) => ancestor.statePath),
+        ];
+        return locations.length === 0
+            ? []
+            : [
+                `FSM playbook state ${state.stateId}: playbook.busy on ${locations.join(', ')} prevents returning a suspended child call; remove that tag from the call state and its ancestors`,
+            ];
+    });
+}
 /**
  * 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
@@ -1054,9 +1150,29 @@ export function checkGearsFsmConformance(gears, config, options = {}) {
     const explicitActorStates = new Set(captainBindings
         .filter(({ pinActor }) => pinActor)
         .map(({ state }) => state));
-    const playbookStates = enumeratePlaybookStates(config);
+    const playbookBindings = enumeratePlaybookBindings(config);
+    const playbookStates = playbookBindings.map(({ state }) => state);
+    const initialContext = initialMachineContext(config);
+    const literalChecks = new Map();
+    const literalFinding = (item, state) => {
+        let checked = literalChecks.get(state);
+        if (checked === undefined)
+            literalChecks.set(state, (checked = new Map()));
+        if (!checked.has(item.prompt)) {
+            const binding = playbookBindings.find((candidate) => candidate.state === state);
+            checked.set(item.prompt, binding === undefined
+                ? 'has no inspectable invocation'
+                : literalPlaybookTextFinding(item.prompt, binding, initialContext));
+        }
+        return checked.get(item.prompt);
+    };
     const scriptStates = enumerateScriptStates(config);
     const findings = [];
+    if (typeof config.meta === 'object' &&
+        config.meta !== null &&
+        Object.hasOwn(config.meta, 'playbook')) {
+        findings.push('FSM machine root declares meta.playbook; public playbook metadata belongs only to state nodes under states');
+    }
     for (const { state, nearMiss } of controllerNearMisses) {
         const detail = nearMiss.missing.length > 0
             ? `missing ${JSON.stringify(nearMiss.missing[0])}`
@@ -1064,6 +1180,7 @@ export function checkGearsFsmConformance(gears, config, options = {}) {
         findings.push(`FSM state ${state.stateId}: controller decision contract near-miss (${detail}); the controller domain requires exactly ${CONTROLLER_ACTION_GUARDS.join(', ')}`);
     }
     const nodes = walkStateNodes(config);
+    findings.push(...checkFsmChildSuspension(config));
     findings.push(...structuredStateIdentityFindings(nodes));
     findings.push(...roleContract.findings);
     const schema3 = roleContract.generation === 'schema-3' ||
@@ -1079,9 +1196,8 @@ export function checkGearsFsmConformance(gears, config, options = {}) {
             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}`));
-    }
+    findings.push(...gearsResultFindings(items));
+    findings.push(...gearsActorFindings(gears));
     for (const state of states) {
         findings.push(...(state.bindingFindings ?? []).map((finding) => `FSM state ${state.stateId}: ${finding}`));
     }
@@ -1175,6 +1291,20 @@ export function checkGearsFsmConformance(gears, config, options = {}) {
             addPlaybookMatch(groupedItems[index], groupedStates[index]);
         }
     }
+    // Composed literal inputs have no static text signature. The optional
+    // sourceItem remains optional: match otherwise unbound calls by their whole
+    // observable template, never by guessed context-field names.
+    for (const item of playbookItems) {
+        if (item.playbookIdContext !== undefined || playbookMatchesByItem.has(item))
+            continue;
+        const state = playbookStates.find((candidate) => candidate.sourceItem === undefined &&
+            !matchedPlaybookStates.has(candidate) &&
+            candidate.playbookIdContext === undefined &&
+            candidate.playbookId === item.playbookId &&
+            literalFinding(item, candidate) === undefined);
+        if (state !== undefined)
+            addPlaybookMatch(item, state);
+    }
     for (const item of items) {
         if (isPlaybookItem(item)) {
             const matched = playbookMatchesByItem.get(item) ?? [];
@@ -1201,8 +1331,9 @@ export function checkGearsFsmConformance(gears, config, options = {}) {
                 if (state.playbookId !== item.playbookId) {
                     findings.push(`${item.id}: FSM playbook "${state.playbookId ?? ''}" is not GEARS playbook "${item.playbookId ?? ''}"`);
                 }
-                if (state.text !== item.prompt) {
-                    findings.push(`${item.id}: FSM playbook text is not the GEARS prompt verbatim`);
+                const textFinding = literalFinding(item, state);
+                if (textFinding !== undefined) {
+                    findings.push(`${item.id}: FSM playbook text ${textFinding}`);
                 }
             }
             continue;
@@ -1469,7 +1600,7 @@ export function pinIntrospection(config) {
                 id: typeof state.id === 'string' ? state.id : null,
                 publicStateId: metadataStateId(state) ?? null,
                 type: typeof state.type === 'string' ? state.type : null,
-                initial: typeof state.initial === 'string' ? state.initial : null,
+                initial: initialStateTarget(state.initial) ?? null,
                 tags: normalizedTags(state.tags),
                 children: Object.keys(state.states ?? {}),
                 invokes: normalizeInvokes(state.invoke)
@@ -1482,7 +1613,7 @@ export function pinIntrospection(config) {
         }
         : undefined;
     return {
-        initial: typeof config.initial === 'string' ? config.initial : null,
+        initial: initialStateTarget(config.initial) ?? null,
         captain,
         quiescent,
         rootOn,
@@ -1501,10 +1632,12 @@ export function pinIntrospection(config) {
  * linked composer replaces. The derived facts are pinned into the emitted test
  * so contract drift fails it (DR-009).
  */
-/** The exact continuation preamble the link contract mandates (link.md). */
+/** The historical full continuation format, retained for schema-1 and old composers. */
 export const CONTINUATION_PREAMBLE = 'You previously paused this task to ask Boss a question; Boss has now replied. Continue the same task using the reply below.';
 export const BOSS_QUESTION_LABEL = 'Boss question:';
 export const BOSS_REPLY_LABEL = 'Boss reply:';
+const CURRENT_CONTINUATION_PREAMBLE = 'Continue the same task using Boss’s reply below.';
+const CURRENT_BOSS_QUESTION_LABEL = 'Your previous question:';
 // Direct Captain prompts cross the callCaptain boundary and therefore must
 // not acquire player-only routing or session-control text. Match the stable
 // labelled form as well as natural-language variants; occurrence deltas below
@@ -1552,16 +1685,28 @@ initial = {}) {
 function sentinelContext(reads) {
     return Object.fromEntries(reads.map((field) => [field, sentinelFor(field)]));
 }
-// The gears2fsm-normative Boss-reply context fields: present only on a
-// continuation turn, so an ordinary-turn probe must leave them unset.
+// The gears2fsm-normative Boss-reply context fields: filled only on a
+// continuation turn. An ordinary turn holds each at its initial shape — the
+// scalar form absent, the keyed form of a parallel machine an empty record —
+// so a state's input can index its own entry without meeting a shape the
+// machine's context type never admits (verification-5).
 const BOSS_CONTEXT_FIELDS = [
     'pendingBossQuestion',
     'bossReply',
     'pendingBossQuestions',
     'bossReplies',
 ];
+const KEYED_BOSS_CONTEXT_FIELDS = ['pendingBossQuestions', 'bossReplies'];
+function isKeyedBossRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function ordinaryContext(reads) {
-    return sentinelContext(reads.filter((field) => !BOSS_CONTEXT_FIELDS.includes(field)));
+    return {
+        ...sentinelContext(reads.filter((field) => !BOSS_CONTEXT_FIELDS.includes(field))),
+        ...Object.fromEntries(reads
+            .filter((field) => KEYED_BOSS_CONTEXT_FIELDS.includes(field))
+            .map((field) => [field, {}])),
+    };
 }
 /**
  * The machine's resolved initial context (verification-5): a literal record, or
@@ -1597,8 +1742,9 @@ function initialMachineContext(config) {
 /**
  * The context an ordinary-turn probe drives an `invoke.input` thunk with: the
  * machine's initial context, overlaid with one string sentinel per traced read
- * whose initial value is absent or itself a string, and never a Boss-reply
- * field (verification-5).
+ * whose initial value is absent or itself a string, with every Boss-reply
+ * field at its initial shape — absent, or an empty keyed record
+ * (verification-5).
  */
 function ordinaryTurnContext(reads, initial, 
 /** Traces the Boss-reply fields too, for wiring capture rather than a turn. */
@@ -1608,8 +1754,12 @@ includeBossFields = false) {
     }
     const context = { ...initial };
     if (!includeBossFields) {
-        for (const field of BOSS_CONTEXT_FIELDS)
-            delete context[field];
+        for (const field of BOSS_CONTEXT_FIELDS) {
+            if (isKeyedBossRecord(context[field]))
+                context[field] = {};
+            else
+                delete context[field];
+        }
     }
     for (const field of reads) {
         if (!includeBossFields && BOSS_CONTEXT_FIELDS.includes(field))
@@ -1768,13 +1918,69 @@ export function deriveSubstitutions(config, compose, actor) {
     }
     return out;
 }
+/** The shared input-only portion of the canonical continuation probe. */
+function probeContinuationInput(state, inputFn, initial, artifactSchema) {
+    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,
+        question,
+    };
+    return {
+        ...withPlaceholderValues(state, inputFn({
+            context: {
+                ...ordinaryTurnContext(probeContextReads(inputFn, initial), initial),
+                pendingBossQuestion,
+                bossReply: reply,
+                pendingBossQuestions: { [state.stateId]: pendingBossQuestion },
+                bossReplies: { [state.stateId]: reply },
+            },
+        })),
+        question,
+        reply,
+    };
+}
+function continuationInputFinding(stateId, input, question, reply) {
+    return !carriesSentinel(input, question) || !carriesSentinel(input, reply)
+        ? `${stateId}: invoke.input does not carry pendingBossQuestion/bossReply for a continuation turn`
+        : undefined;
+}
+/** Known-schema FSM input checks, without requiring a linked composer. */
+export function checkFsmContinuationInputs(config, artifactSchema) {
+    if (isControllerMachine(config))
+        return [];
+    const initial = initialMachineContext(config);
+    const findings = [];
+    for (const { state, inputFn } of enumerateCaptainBindings(config)) {
+        if (typeof inputFn !== 'function' ||
+            !Object.hasOwn(state.result, NEEDS_BOSS_REPLY))
+            continue;
+        try {
+            const { input, question, reply } = probeContinuationInput(state, inputFn, initial, artifactSchema);
+            const finding = continuationInputFinding(state.stateId, input, question, reply);
+            if (finding !== undefined)
+                findings.push(finding);
+        }
+        catch (error) {
+            findings.push(`${state.stateId}: invoke.input threw on a continuation turn: ${messageOf(error)}`);
+        }
+    }
+    return findings;
+}
 /**
  * Checks the linked composer against the link contract for every captain state
  * (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
- * preamble and labelled Q&A blocks before the body.
+ * ordinary turn, and a Boss-reply continuation turn opens with a supported exact
+ * prefix. Only an explicitly resumed schema-3 player may omit the question.
  */
 export function checkPromptComposition(opts) {
     const findings = [];
@@ -1803,119 +2009,87 @@ export function checkPromptComposition(opts) {
             continue;
         const reads = probeContextReads(inputFn, initial);
         const substituted = substitutions[state.stateId] ?? [];
-        let ordinary;
+        const relayFindingKeys = new Set();
+        const artifactSchema = schemaResolution.findings.length > 0
+            ? undefined
+            : (inferredArtifactSchema ??
+                (state.role !== undefined ? 3 : state.player !== '' ? 1 : undefined));
+        const modes = artifactSchema === 3 && state.actor === 'player'
+            ? [undefined, false, true]
+            : [undefined];
         let promptReads;
-        try {
-            const probed = withPlaceholderValues(state, inputFn({ context: ordinaryTurnContext(reads, initial) }));
-            promptReads = promptSentinelFields(state, reads, probed.fields, roles);
-            ordinary = composeForState(opts.compose, state, probed.input, roles);
-            if (typeof ordinary !== 'string') {
-                throw new Error(`${composerName} returned a non-string value`);
+        for (const resuming of modes) {
+            let ordinary;
+            let input;
+            try {
+                const probed = withPlaceholderValues(state, inputFn({ context: ordinaryTurnContext(reads, initial) }));
+                input = probed.input;
+                promptReads = promptSentinelFields(state, reads, probed.fields, roles);
+                ordinary = composeForState(opts.compose, state, probed.input, roles, resuming);
+                if (typeof ordinary !== 'string') {
+                    throw new Error(`${composerName} returned a non-string value`);
+                }
+            }
+            catch (error) {
+                pushUnique(findings, `${state.stateId}: ${composerName} threw on an ordinary turn: ${messageOf(error)}`);
+                continue;
+            }
+            pushUnique(findings, ...bodyFindings(state, ordinary, substituted, promptReads, 'ordinary'), ...literalPromptRelayFindings(state, ordinary, input, substituted, promptReads, opts.compose, roles, relayFindingKeys, resuming));
+            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
+            // are leaks.
+            if (occurrences(ordinary, BOSS_QUESTION_MARKER) >
+                occurrences(state.prompt, BOSS_QUESTION_MARKER)) {
+                pushUnique(findings, `${state.stateId}: the adjudicator-facing ${NEEDS_BOSS_REPLY} contract leaks into the player prompt`);
+            }
+            if ([
+                CONTINUATION_PREAMBLE,
+                CURRENT_CONTINUATION_PREAMBLE,
+                BOSS_QUESTION_LABEL,
+                CURRENT_BOSS_QUESTION_LABEL,
+                BOSS_REPLY_LABEL,
+            ].some((needle) => occurrences(ordinary, needle) > occurrences(state.prompt, needle))) {
+                pushUnique(findings, `${state.stateId}: continuation blocks appear on an ordinary turn`);
             }
-        }
-        catch (error) {
-            findings.push(`${state.stateId}: ${composerName} threw on an ordinary turn: ${messageOf(error)}`);
-            continue;
-        }
-        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
-        // are leaks.
-        if (occurrences(ordinary, BOSS_QUESTION_MARKER) >
-            occurrences(state.prompt, BOSS_QUESTION_MARKER)) {
-            findings.push(`${state.stateId}: the adjudicator-facing ${NEEDS_BOSS_REPLY} contract leaks into the player prompt`);
-        }
-        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,
-            question,
-        };
-        let continuation;
-        let input;
-        try {
-            const probed = withPlaceholderValues(state, inputFn({
-                context: {
-                    ...ordinaryTurnContext(reads, initial),
-                    pendingBossQuestion,
-                    bossReply: reply,
-                    pendingBossQuestions: {
-                        [state.stateId]: pendingBossQuestion,
-                    },
-                    bossReplies: { [state.stateId]: reply },
-                },
-            }));
-            input = probed.input;
-            promptReads = promptSentinelFields(state, reads, probed.fields, roles);
-            continuation = composeForState(opts.compose, state, input, roles);
-            if (typeof continuation !== 'string') {
-                throw new Error(`${composerName} returned a non-string value`);
+        // Probe absent and explicit fresh modes separately: wrappers may forward
+        // the optional argument incorrectly. Historical composers may ignore it
+        // and keep their complete Q&A prefix even when a player resumes.
+        for (const resuming of modes) {
+            const question = sentinelFor('question');
+            const reply = sentinelFor('bossReply');
+            let continuation;
+            let input;
+            try {
+                const probed = probeContinuationInput(state, inputFn, initial, artifactSchema);
+                input = probed.input;
+                promptReads = promptSentinelFields(state, reads, probed.fields, roles);
+                continuation = composeForState(opts.compose, state, input, roles, resuming);
+                if (typeof continuation !== 'string') {
+                    throw new Error(`${composerName} returned a non-string value`);
+                }
             }
-        }
-        catch (error) {
-            findings.push(`${state.stateId}: ${composerName} threw on a continuation turn: ${messageOf(error)}`);
-            continue;
-        }
-        if (!carriesSentinel(input, question) || !carriesSentinel(input, reply)) {
-            findings.push(`${state.stateId}: invoke.input does not carry pendingBossQuestion/bossReply for a continuation turn`);
-            continue;
-        }
-        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, promptReads);
-        const questionBlock = `${BOSS_QUESTION_LABEL}\n${question}`;
-        const replyBlock = `${BOSS_REPLY_LABEL}\n${reply}`;
-        for (const [label, value] of [
-            [BOSS_QUESTION_LABEL, questionBlock],
-            [BOSS_REPLY_LABEL, replyBlock],
-        ]) {
-            // The composer must ADD the labelled block (beyond any body-carried
-            // occurrence), with its sentinel value immediately below the label and
-            // before the body.
-            const at = continuation.indexOf(value);
-            if (occurrences(continuation, value) <= occurrences(state.prompt, value)) {
-                findings.push(`${state.stateId}: a continuation turn lacks the "${label}" block`);
+            catch (error) {
+                pushUnique(findings, `${state.stateId}: ${composerName} threw on a continuation turn: ${messageOf(error)}`);
+                continue;
             }
-            else if (bodyStart !== -1 && at > bodyStart) {
-                findings.push(`${state.stateId}: the "${label}" block appears after the domain prompt body`);
+            const inputFinding = continuationInputFinding(state.stateId, input, question, reply);
+            if (inputFinding !== undefined) {
+                pushUnique(findings, inputFinding);
+                continue;
             }
+            pushUnique(findings, ...continuationPrefixFindings(state, continuation, substituted, promptReads, artifactSchema, resuming, question, reply), ...bodyFindings(state, continuation, substituted, promptReads, 'continuation'), ...promptControlFindings(state, continuation), ...literalPromptRelayFindings(state, continuation, input, substituted, promptReads, opts.compose, roles, relayFindingKeys, resuming));
         }
-        const exactContinuationPrefix = `${CONTINUATION_PREAMBLE}\n\n${questionBlock}\n\n${replyBlock}\n\n`;
-        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, promptReads, 'continuation'));
-        pushUnique(findings, ...promptControlFindings(state, continuation));
     }
     return findings;
 }
@@ -1925,7 +2099,7 @@ function promptSentinelFields(state, reads, placeholderFields, declaredRoles) {
         ? fields
         : [...fields, ...declaredRoles.map((role) => `promptIdentity:${role}`)];
 }
-function composeForState(compose, state, input, declaredRoles) {
+function composeForState(compose, state, input, declaredRoles, resuming) {
     // 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
@@ -1950,9 +2124,64 @@ function composeForState(compose, state, input, declaredRoles) {
         getOwnPropertyDescriptor: () => undefined,
     });
     return state.actor === 'player' && state.role !== undefined
-        ? compose(input, promptIdentity)
+        ? resuming === undefined
+            ? compose(input, promptIdentity)
+            : compose(input, promptIdentity, resuming)
         : compose(input);
 }
+function continuationPrefixFindings(state, composed, substituted, reads, artifactSchema, resuming, question, reply) {
+    const fullProfiles = [
+        { preamble: CONTINUATION_PREAMBLE, questionLabel: BOSS_QUESTION_LABEL },
+        ...(artifactSchema === 3
+            ? [
+                {
+                    preamble: CURRENT_CONTINUATION_PREAMBLE,
+                    questionLabel: CURRENT_BOSS_QUESTION_LABEL,
+                },
+            ]
+            : []),
+    ];
+    const compactAllowed = artifactSchema === 3 && state.actor === 'player' && resuming === true;
+    const replyBlock = `${BOSS_REPLY_LABEL}\n${reply}`;
+    const prefixes = fullProfiles.map(({ preamble, questionLabel }) => `${preamble}\n\n${questionLabel}\n${question}\n\n${replyBlock}\n\n`);
+    const compactPrefix = `${CURRENT_CONTINUATION_PREAMBLE}\n\n${replyBlock}\n\n`;
+    const compact = compactAllowed && composed.startsWith(compactPrefix);
+    if (compactAllowed)
+        prefixes.push(compactPrefix);
+    const findings = [];
+    if (compact &&
+        [BOSS_QUESTION_LABEL, CURRENT_BOSS_QUESTION_LABEL].some((label) => occurrences(composed, `${label}\n${question}`) >
+            occurrences(state.prompt, `${label}\n${question}`))) {
+        findings.push(`${state.stateId}: a compact continuation adds the Boss question outside its domain prompt body`);
+    }
+    if (!fullProfiles.some(({ preamble }) => composed.startsWith(`${preamble}\n\n`))) {
+        findings.push(`${state.stateId}: a continuation turn does not open with the exact preamble`);
+    }
+    // Select diagnostics by the observed full format, without permitting a
+    // hybrid label or using function arity/package versions as capability evidence.
+    const profile = fullProfiles.find(({ preamble }) => composed.startsWith(`${preamble}\n\n`)) ?? fullProfiles[0];
+    const blocks = [
+        ...(!compact
+            ? [[profile.questionLabel, `${profile.questionLabel}\n${question}`]]
+            : []),
+        [BOSS_REPLY_LABEL, replyBlock],
+    ];
+    const bodyStart = bodyIndex(state, composed, substituted, reads);
+    for (const [label, value] of blocks) {
+        // Authored domain text can itself quote the framework contract; a real
+        // continuation must add its own sentinel-bearing blocks before that body.
+        if (occurrences(composed, value) <= occurrences(state.prompt, value)) {
+            findings.push(`${state.stateId}: a continuation turn lacks the "${label}" block`);
+        }
+        else if (bodyStart !== -1 && composed.indexOf(value) > bodyStart) {
+            findings.push(`${state.stateId}: the "${label}" block appears after the domain prompt body`);
+        }
+    }
+    if (!prefixes.some((prefix) => composed.startsWith(prefix))) {
+        findings.push(`${state.stateId}: a continuation turn does not preserve the exact ordered Boss question/reply blocks`);
+    }
+    return findings;
+}
 function promptControlFindings(state, composed) {
     const findings = [];
     const introducesPlayerBinding = patternOccurrences(composed, PLAYER_BINDING_MARKER) >
@@ -2046,7 +2275,12 @@ function matchPromptBody(prompt, composed, reads, expectedSubstitutions) {
         if (attempt === null)
             continue;
         if (expectedSubstitutions !== undefined) {
-            return { index: start, substitutions: [...expectedSubstitutions] };
+            return {
+                index: start,
+                end: attempt.end,
+                substitutions: [...expectedSubstitutions],
+                values: attempt.values,
+            };
         }
         const modes = new Map();
         for (let gap = 0; gap < tokens.length; gap++) {
@@ -2059,10 +2293,246 @@ function matchPromptBody(prompt, composed, reads, expectedSubstitutions) {
             continue;
         }
         const substitutions = placeholdersIn(prompt).filter((token) => modes.get(token)?.has('sentinel') === true);
-        return { index: start, substitutions };
+        return {
+            index: start,
+            end: attempt.end,
+            substitutions,
+            values: attempt.values,
+        };
     }
     return null;
 }
+/** Probe observed string relays without inventing context fields or input shapes. */
+function literalPromptRelayFindings(state, composed, input, substituted, reads, compose, roles, findingKeys, resuming) {
+    if (typeof input !== 'object' || input === null)
+        return [];
+    const match = matchPromptBody(state.prompt, composed, reads, substituted);
+    if (match === null)
+        return []; // Existing body diagnostics own this case.
+    const tokens = [...state.prompt.matchAll(PLACEHOLDER)];
+    const groups = new Map();
+    for (const [field, value] of Object.entries(input)) {
+        if (CONTRACT_INPUT_FIELDS.includes(field) ||
+            typeof value !== 'string' ||
+            roles.some((role) => value === sentinelFor(`promptIdentity:${role}`)) ||
+            !match.values.some((matched, index) => matched === value && substituted.includes(tokens[index][0])) ||
+            match.values.includes(JSON.stringify(value)))
+            continue;
+        // Equal values may be intentional aliases. Changing them together avoids
+        // guessing which of several indistinguishable fields supplied the token.
+        const fields = groups.get(value) ?? [];
+        fields.push(field);
+        groups.set(value, fields);
+    }
+    if (groups.size === 0)
+        return [];
+    const quotedGroups = new Set([...groups.keys()].filter((value) => tokens.every((token, index) => {
+        if (match.values[index] !== value)
+            return true;
+        const start = state.prompt.lastIndexOf('\n', token.index - 1) + 1;
+        const next = state.prompt.indexOf('\n', token.index);
+        const line = state.prompt
+            .slice(start, next < 0 ? undefined : next)
+            .replace(/\r$/, '');
+        return /^> [^<>\r\n]*(<[^\s<>`]{1,60}>)$/.exec(line)?.[1] === token[0];
+    })));
+    const findings = [];
+    for (const multiline of [false, true]) {
+        const values = new Map();
+        for (const [index, value] of [...groups.keys()].entries()) {
+            if (multiline && !quotedGroups.has(value))
+                continue;
+            const literal = `relay-${index}: $& $$ $\` $' ${placeholdersIn(state.prompt).join(' ')}`;
+            // No empty-line policy is inferred here; all segments are nonempty.
+            values.set(value, multiline ? `${literal}\nsecond-${index}\r\nthird-${index}` : literal);
+        }
+        if (values.size === 0)
+            continue;
+        const probed = { ...input };
+        for (const [value, replacement] of values) {
+            for (const field of groups.get(value))
+                probed[field] = replacement;
+        }
+        let index = 0;
+        const body = state.prompt.replace(PLACEHOLDER, () => {
+            const value = match.values[index++];
+            const replacement = values.get(value);
+            return replacement === undefined
+                ? value
+                : multiline
+                    ? replacement.replace(/\n/g, '\n> ')
+                    : replacement;
+        });
+        const expected = composed.slice(0, match.index) + body + composed.slice(match.end);
+        const label = multiline
+            ? 'multiline quoted-relay'
+            : 'single-pass literal-relay';
+        const key = `${state.stateId}:${label}`;
+        const prefix = `${state.stateId}: prompt composition does not preserve ${label} text`;
+        try {
+            const actual = composeForState(compose, state, probed, roles, resuming);
+            if (actual === expected)
+                continue;
+            pushRelayFinding(findings, findingKeys, key, `${prefix}; probe preserves literal text and LF/CRLF separators/quote markers; ${firstDifferenceDiagnostic(expected, actual)}`);
+        }
+        catch {
+            // One state/representation diagnostic also covers mode-dependent errors.
+            pushRelayFinding(findings, findingKeys, key, prefix);
+        }
+    }
+    return findings;
+}
+function pushRelayFinding(findings, findingKeys, key, finding) {
+    if (findingKeys.has(key))
+        return;
+    findingKeys.add(key);
+    findings.push(finding);
+}
+function firstDifferenceDiagnostic(expected, actual) {
+    let offset = 0;
+    const length = Math.max(expected.length, actual.length);
+    while (offset < length && expected[offset] === actual[offset])
+        offset++;
+    return `first difference at UTF-16 offset ${offset}: expected ${boundedJsonSnippet(expected, offset)}, actual ${boundedJsonSnippet(actual, offset)}`;
+}
+function boundedJsonSnippet(value, offset) {
+    if (offset >= value.length)
+        return '<end>';
+    return JSON.stringify(value.slice(offset, offset + 24));
+}
+/** Verify the FSM-owned composer; child inputs reach the bridge already rendered. */
+function literalPlaybookTextFinding(prompt, binding, initial) {
+    const input = binding.invoke.input;
+    // Only explicit quoted relay notation establishes required runtime slots.
+    // Domain metavariables and inline-code examples remain literal template text.
+    const requiredRelays = new Set(prompt.split(/\r?\n/).flatMap((line) => {
+        const token = /^> (?:[^<>\r\n]+: )?(<[^\s<>`]{1,60}>)$/.exec(line)?.[1];
+        return token === undefined ? [] : [token];
+    }));
+    const unresolvedRelay = (token) => `leaves quoted child-input relay ${token} unresolved`;
+    if (typeof input !== 'function') {
+        if (binding.state.text !== prompt)
+            return 'does not preserve the complete GEARS child-input template';
+        const token = requiredRelays.values().next().value;
+        return token === undefined ? undefined : unresolvedRelay(token);
+    }
+    const base = initial ?? {};
+    const fields = new Set();
+    let context = { ...base };
+    // Later reads can be behind a string-valued branch. Discover them without
+    // overwriting an initialized object, array, boolean, or numeric context field.
+    for (let pass = 0; pass < 4; pass++) {
+        const before = fields.size;
+        for (const field of probeContextReads(input, context)) {
+            if (base[field] === undefined || typeof base[field] === 'string')
+                fields.add(field);
+        }
+        if (fields.size > 128)
+            return 'has unsupported composition (too many scalar reads)';
+        context = {
+            ...base,
+            ...Object.fromEntries([...fields].map((field) => [field, sentinelFor(field)])),
+        };
+        if (fields.size === before)
+            break;
+        if (pass === 3)
+            return 'has unsupported composition (context reads did not stabilize)';
+    }
+    const probe = (values) => {
+        const result = invocationInput(binding.invoke, values);
+        return 'value' in result &&
+            result.value.playbookId === binding.state.playbookId &&
+            result.value.stateId === binding.state.stateId &&
+            typeof result.value.text === 'string'
+            ? result.value.text
+            : undefined;
+    };
+    const text = probe(context);
+    if (text === undefined)
+        return 'has unsupported composition (input evaluation or literal identity changed)';
+    const matched = matchPromptBody(prompt, text, [...fields]);
+    if (matched === null || matched.index !== 0 || matched.end !== text.length) {
+        return 'does not preserve the complete GEARS child-input template';
+    }
+    const tokens = [...prompt.matchAll(PLACEHOLDER)].map((match) => match[0]);
+    const mapping = new Map();
+    const observed = new Map();
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index], value = matched.values[index];
+        if (observed.has(token) && observed.get(token) !== value) {
+            return `uses inconsistent context substitutions for ${token}`;
+        }
+        observed.set(token, value);
+        if (value === token) {
+            if (requiredRelays.has(token))
+                return unresolvedRelay(token);
+            continue;
+        }
+        const field = [...fields].find((name) => value === sentinelFor(name));
+        if (field === undefined)
+            return `has unsupported composition for ${token}`;
+        mapping.set(token, { field });
+    }
+    // A source-labelled complete relay can carry arbitrary prose. Inline slots
+    // can instead be constrained identifiers (for example a commit identity),
+    // so do not invent multiline identifier inputs merely because TS erased the
+    // narrower domain contract. Neither decision depends on the field's name.
+    const multilineFields = new Set();
+    for (const line of prompt.split(/\r?\n/)) {
+        const token = /^> [^<>\r\n]*(<[^\s<>`]{1,60}>)$/.exec(line)?.[1];
+        const field = token === undefined ? undefined : mapping.get(token)?.field;
+        if (field !== undefined)
+            multilineFields.add(field);
+    }
+    const payloads = Object.fromEntries([...fields].map((field) => [
+        field,
+        `«${field}:literal» $& $$ $\x60 $' ${[...new Set(tokens)].join(' ')}` +
+            (multilineFields.has(field) ? `\n\n«${field}:second»` : ''),
+    ]));
+    const render = (values) => {
+        // Only the source-defined standalone relay form owns empty-line removal.
+        const template = prompt
+            .split(/(?<=\n)/)
+            .filter((line) => {
+            const token = /^> (<[^\s<>`]{1,60}>)(?:\r?\n)?$/.exec(line)?.[1];
+            const mapped = token === undefined ? undefined : mapping.get(token);
+            return mapped === undefined || values[mapped.field] !== '';
+        })
+            .join('');
+        return template.replace(PLACEHOLDER, (token, offset) => {
+            const mapped = mapping.get(token);
+            if (mapped === undefined)
+                return token;
+            const value = values[mapped.field];
+            const lineStart = template.lastIndexOf('\n', offset - 1) + 1;
+            return template.startsWith('> ', lineStart)
+                ? value.replace(/\r?\n/g, (separator) => `${separator}> `)
+                : value;
+        });
+    };
+    const composed = probe({ ...base, ...payloads });
+    if (composed === undefined || composed !== render(payloads)) {
+        return 'does not preserve literal substitutions and quoted continuation lines';
+    }
+    const emptyFields = new Set();
+    for (const line of prompt.split(/\r?\n/)) {
+        const token = /^> (<[^\s<>`]{1,60}>)$/.exec(line)?.[1];
+        const field = token === undefined ? undefined : mapping.get(token)?.field;
+        if (field !== undefined)
+            emptyFields.add(field);
+    }
+    if (emptyFields.size > 0) {
+        const values = {
+            ...payloads,
+            ...Object.fromEntries([...emptyFields].map((field) => [field, ''])),
+        };
+        const emptyText = probe({ ...base, ...values });
+        if (emptyText === undefined || emptyText !== render(values)) {
+            return 'does not preserve source-defined empty standalone relay omission';
+        }
+    }
+    return undefined;
+}
 /** 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) {
@@ -2151,7 +2621,7 @@ import { describe, expect, it } from 'vitest';
 import { checkGearsFsmConformance, findConcurrentRoleSets, findMachineConfig } from ${sourceString(opts.verifyModule)};
 import * as fsm from ${sourceString(opts.fsmModule)};
 
-const SCHEMA_FINDINGS = ${JSON.stringify(opts.schemaFindings ?? [], null, 2)};
+const SCHEMA_FINDINGS: readonly string[] = ${JSON.stringify(opts.schemaFindings ?? [], null, 2)};
 
 describe(${sourceString(`${opts.basename}: GEARS↔FSM conformance`)}, () => {
   it('uses consistent artifact-schema evidence', () => {
@@ -2262,7 +2732,7 @@ import { describe, expect, it } from 'vitest';
 import { findMachineConfig, pinIntrospection } from ${sourceString(opts.verifyModule)};
 import * as fsm from ${sourceString(opts.fsmModule)};
 
-const PINNED = ${JSON.stringify(opts.pins, null, 2)};
+const PINNED = ${JSON.stringify(opts.pins, null, 2)} as const;
 
 describe(${sourceString(`${opts.basename}: FSM introspection`)}, () => {
   it('matches the machine topology pinned at build time', () => {
@@ -2294,7 +2764,7 @@ export function generatePromptContractTest(opts) {
         const compose = `compose${label === 'Captain' ? 'Captain' : 'Player'}`;
         return [
             `
-const ${constant} = ${JSON.stringify(substituted, null, 2)};
+const ${constant} = ${JSON.stringify(substituted, null, 2)} as const;
 
 const ${compose} = (
   playbook as unknown as {
@@ -2344,8 +2814,8 @@ import {
 } from ${sourceString(opts.verifyModule)};
 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)};
+const CONTRACT = ${JSON.stringify(opts.rows, null, 2)} as const;
+const SCHEMA_FINDINGS: readonly string[] = ${JSON.stringify(opts.schemaFindings ?? [], null, 2)};
 
 describe(${sourceString(`${opts.basename}: prompt contract`)}, () => {
   it('uses consistent artifact-schema evidence', () => {
@@ -2482,7 +2952,8 @@ export function resolveArtifactSchemaForVerification(opts) {
     if (linkedSignal?.historicalFallback) {
         return { artifactSchema: 1, findings: [] };
     }
-    const hasAmbiguousCaptainContinuation = opts.config !== undefined &&
+    const hasAmbiguousCaptainContinuation = opts.requireContinuationSchema !== false &&
+        opts.config !== undefined &&
         enumerateCaptainStates(opts.config).some((state) => state.actor === 'captain' &&
             Object.hasOwn(state.result, NEEDS_BOSS_REPLY));
     return hasAmbiguousCaptainContinuation