@sublang/playbook 17.6.0 → 17.8.0

package/reference/sdlc/code.playbook/playbook-captain.ts

@@ -1490,6 +1490,158 @@ function carriedPreExistingFacts(
   });
 }
 
+// DR-089: a turn whose leaf parks in failure still states, as fact, every
+// commit its steps proved before the failure, so a closing reply never tells
+// the Boss that nothing was written when a receipt shows otherwise. A commit
+// the unresolved-effect report already names is not said twice.
+interface CommitBeforeFailure {
+  readonly baselineHead: string;
+  readonly commitOid: string;
+  /** Every new commit, oldest first, where the step made more than one (DR-088). */
+  readonly commits?: readonly string[];
+}
+
+function commitsBeforeFailure(
+  ledger: PlaybookEffectLedger,
+  boundaryPrefixCount: number,
+  unresolvedEffects: readonly PlaybookCaptainUnresolvedEffect[],
+): readonly CommitBeforeFailure[] {
+  // An entry names a commit by its proven OID, or — for a receipt listing
+  // several commits, which projects as `multiple-commits` (DR-088 §3) — by
+  // its after HEAD, the last of them.
+  const named = new Set(
+    unresolvedEffects.flatMap(({ classification, afterHead, commitOid }) =>
+      commitOid !== undefined
+        ? [commitOid]
+        : classification === 'multiple-commits' && afterHead !== undefined
+          ? [afterHead]
+          : [],
+    ),
+  );
+  const commits: CommitBeforeFailure[] = [];
+  for (const boundary of ledger.boundaries) {
+    if (boundary.sequence <= boundaryPrefixCount) continue;
+    const receipt = boundary.physicalReceipt;
+    if (
+      receipt?.classification !== 'one-descendant-commit' ||
+      receipt.commitOid === undefined ||
+      named.has(receipt.commitOid)
+    ) {
+      continue;
+    }
+    named.add(receipt.commitOid);
+    commits.push({
+      baselineHead: receipt.baseline.head,
+      commitOid: receipt.commitOid,
+      ...(receipt.commits === undefined ? {} : { commits: receipt.commits }),
+    });
+  }
+  return commits;
+}
+
+/** What one step committed, with every commit where it made several (DR-088). */
+function commitBeforeFailureClause({
+  baselineHead,
+  commitOid,
+  commits,
+}: CommitBeforeFailure): string {
+  const made =
+    commits === undefined
+      ? 'made one new commit'
+      : `made ${commits.length} new commits, oldest first: ${boundedPathList(commits)}`;
+  return `${made}; HEAD moved from ${baselineHead} to the proven commit ${commitOid}.`;
+}
+
+function commitBeforeFailureFact(commit: CommitBeforeFailure): string {
+  return `Before the failure, a step ${commitBeforeFailureClause(commit)}`;
+}
+
+function commitsBeforeFailureReport(
+  commits: readonly CommitBeforeFailure[],
+): string | undefined {
+  if (commits.length === 0) return undefined;
+  return [
+    'Repository changes made before the failure:',
+    ...commits.map(
+      (commit) => `- A step ${commitBeforeFailureClause(commit)}`,
+    ),
+    'The failure does not undo these commits.',
+  ].join('\n');
+}
+
+/**
+ * DR-088 §2: whether a final text names one commit as a word, by its full OID
+ * or by an abbreviation of at least seven leading hex digits — the
+ * reconciler's own designation rule, read here to say what it accepted.
+ */
+function finalTextNamesCommit(finalText: string, oid: string): boolean {
+  for (const [word] of finalText.matchAll(
+    /(?<![0-9A-Za-z_])[0-9A-Fa-f]{7,64}(?![0-9A-Za-z_])/g,
+  )) {
+    if (oid.startsWith(word.toLowerCase())) return true;
+  }
+  return false;
+}
+
+/**
+ * DR-088 §3: what the steps completed after `boundaryPrefixCount` committed,
+ * one statement each, in boundary sequence order: every new commit where a
+ * receipt proves more than one, and the commit already at HEAD where a step
+ * whose outcomes all commit or ask named it over an `unchanged` receipt. A
+ * step in a deferred chain reads the chain's cumulative receipt at its last
+ * boundary.
+ */
+function stepCommitStatements(
+  ledger: PlaybookEffectLedger,
+  boundaryPrefixCount: number,
+): readonly string[] {
+  const statements: string[] = [];
+  for (const boundary of ledger.boundaries) {
+    if (boundary.sequence <= boundaryPrefixCount) continue;
+    let receipt = boundary.physicalReceipt;
+    if (boundary.logicalOperationId !== undefined) {
+      const operation = ledger.logicalOperations.find(
+        ({ operationId }) => operationId === boundary.logicalOperationId,
+      );
+      if (operation?.boundaryIds.at(-1) !== boundary.boundaryId) continue;
+      receipt = operation.logicalReceipt;
+    }
+    if (receipt === undefined) continue;
+    if (
+      receipt.classification === 'one-descendant-commit' &&
+      receipt.commits !== undefined
+    ) {
+      statements.push(
+        `The step made ${receipt.commits.length} new commits, oldest first: ${boundedPathList(receipt.commits)}.`,
+      );
+      continue;
+    }
+    const candidate = boundary.semanticCandidate;
+    const guard =
+      candidate !== null &&
+      typeof candidate === 'object' &&
+      !Array.isArray(candidate)
+        ? (candidate as { readonly [key: string]: JsonValue }).guard
+        : undefined;
+    const head = receipt.after?.head;
+    if (
+      receipt.classification === 'unchanged' &&
+      head !== undefined &&
+      !/^0+$/.test(head) &&
+      boundary.dispositions.includes('one-descendant-commit') &&
+      !boundary.dispositions.includes('unchanged') &&
+      typeof guard === 'string' &&
+      guard !== BOSS_QUESTION_OUTCOME &&
+      finalTextNamesCommit(boundary.finalText?.trim() ?? '', head)
+    ) {
+      statements.push(
+        `The step made no new commit; it named ${head}, already at HEAD, as its work.`,
+      );
+    }
+  }
+  return statements;
+}
+
 // DR-063 §4: the Boss-visible failure report. Every host sees the same
 // sentences because the shell composes them from the structured cause instead
 // of asking a model to describe facts it may drop. The report exposes no file
@@ -4250,6 +4402,15 @@ const unresolvedEffectFromReceipt = (
   baselineHead = receipt.baseline.head,
 ): PlaybookCaptainUnresolvedEffect | undefined => {
   if (receipt.classification === 'unchanged') return undefined;
+  // DR-088 §3: a receipt listing more than one new commit reads as
+  // `multiple-commits`, whose entry names more than one commit and no OID.
+  if (receipt.commits !== undefined) {
+    return {
+      classification: 'multiple-commits',
+      baselineHead,
+      ...(receipt.after === undefined ? {} : { afterHead: receipt.after.head }),
+    };
+  }
   return {
     classification: receipt.classification,
     baselineHead,
@@ -4352,12 +4513,18 @@ const cumulativeOpenLogicalEffect = (
     receipt.classification === 'one-descendant-commit' &&
     (sameProjection || receiptAccountsFromOriginal)
   ) {
-    return {
-      classification: 'one-descendant-commit',
-      baselineHead: original.head,
-      afterHead: after.head,
-      commitOid: after.head,
-    };
+    return receipt.commits === undefined
+      ? {
+          classification: 'one-descendant-commit',
+          baselineHead: original.head,
+          afterHead: after.head,
+          commitOid: after.head,
+        }
+      : {
+          classification: 'multiple-commits',
+          baselineHead: original.head,
+          afterHead: after.head,
+        };
   }
   return {
     classification: 'observation-ambiguous',
@@ -4772,19 +4939,33 @@ export function createPlaybookCaptainShell(
   const reportCarriedPreExistingChanges = (turn: ActiveTurn): void => {
     if (turn.carriedEffectPrefix !== undefined) return;
     let carried: readonly CarriedPreExistingChanges[];
+    let commitStatements: readonly string[];
     try {
       const ledger = assertPlaybookEffectLedger(currentEffectLedger());
       carried = carriedPreExistingChanges(ledger, presentedEffectPrefix);
+      commitStatements = stepCommitStatements(ledger, presentedEffectPrefix);
       turn.carriedEffectPrefix = ledger.boundaries.length;
     } catch {
       return;
     }
     const report = carriedPreExistingReport(carried);
-    if (report === undefined) return;
-    const facts = carriedPreExistingFacts(carried);
-    appendMandatoryPresentationSuffix(turn, report, facts);
-    for (const fact of facts) {
-      joinSettlementFact(turn, fact);
+    if (report !== undefined) {
+      const facts = carriedPreExistingFacts(carried);
+      appendMandatoryPresentationSuffix(turn, report, facts);
+      for (const fact of facts) {
+        joinSettlementFact(turn, fact);
+      }
+    }
+    // DR-088 §3: the commits each step took, read from the same boundaries.
+    if (commitStatements.length > 0) {
+      appendMandatoryPresentationSuffix(
+        turn,
+        commitStatements.join('\n'),
+        commitStatements,
+      );
+      for (const fact of commitStatements) {
+        joinSettlementFact(turn, fact);
+      }
     }
   };
 
@@ -8965,6 +9146,31 @@ export function createPlaybookCaptainShell(
       controls: failureControlLines(view, fenced),
     };
     joinSettlementFact(turn, fact, statement?.fact, speak);
+    reportCommitsBeforeFailure(turn, unresolvedEffects);
+  };
+
+  // DR-089: the commits the turn's receipts proved before its leaf parked,
+  // stated beside the failure report and joined to the settlement facts the
+  // closing-reply prompt reads.
+  const reportCommitsBeforeFailure = (
+    turn: ActiveTurn,
+    unresolvedEffects: readonly PlaybookCaptainUnresolvedEffect[],
+  ): void => {
+    let commits: readonly CommitBeforeFailure[];
+    try {
+      commits = commitsBeforeFailure(
+        assertPlaybookEffectLedger(currentEffectLedger()),
+        presentedEffectPrefix,
+        unresolvedEffects,
+      );
+    } catch {
+      return;
+    }
+    const report = commitsBeforeFailureReport(commits);
+    if (report === undefined) return;
+    const facts = commits.map(commitBeforeFailureFact);
+    appendMandatoryPresentationSuffix(turn, report, facts);
+    for (const fact of facts) joinSettlementFact(turn, fact);
   };
 
   // The runtimes own each frame's position. The shell only joins their stack.

package/reference/sdlc/code.playbook/session-assets.js

@@ -87,9 +87,15 @@ export function createAssetStore(options) {
   const directory = resolve(options.directory);
   const maxAssetBytes = options.maxAssetBytes ?? DEFAULT_MAX_ASSET_BYTES;
   if (!Number.isSafeInteger(maxAssetBytes) || maxAssetBytes <= 0) throw new TypeError('maximum asset bytes must be a positive safe integer');
+  // A session store forbidding creation of its sessions directory creates
+  // only this leaf inside it (session-storage-11).
+  const createAncestors = options.createAncestors ?? true;
   let importTail = Promise.resolve();
   const ensureDirectory = async (create) => {
-    if (create) await mkdir(directory, { recursive: true, mode: 0o700 });
+    if (create) {
+      try { await mkdir(directory, { recursive: createAncestors, mode: 0o700 }); }
+      catch (error) { if (createAncestors || error.code !== 'EEXIST') throw error; }
+    }
     assertDirectory(await lstat(directory));
   };
   const prepare = async () => {

package/reference/sdlc/code.playbook/session-store.d.ts

@@ -285,7 +285,19 @@ export interface SharedSessionStore {
   migrateLegacyDefault(options?: { env?: Readonly<Record<string, string | undefined>>; homeDir?: string }): Promise<{ sourceDir: string; migrated: readonly string[]; skipped: readonly { sessionId: string; reason: string }[] }>;
   migrate(sessionId: string, options?: { sourcePath?: string; cwd?: string; backupDir?: string }): Promise<{ manifest: SessionManifest; migrated: boolean; reasons: readonly string[] }>;
 }
-export declare function createSessionStore(options?: { maxAssetBytes?: number; sessionsDir?: string; env?: Readonly<Record<string, string | undefined>>; homeDir?: string; [key: string]: any }): SharedSessionStore;
+export declare function createSessionStore(options?: {
+  maxAssetBytes?: number;
+  sessionsDir?: string;
+  /**
+   * Default `true`. `false` refuses, rather than creates, a missing sessions directory or ancestor when preparing
+   * session payload, lease, asset or migration directories. Machine-identity provisioning keeps its own rule and may
+   * still create its directory, including an ancestor it shares with the sessions directory.
+   */
+  createSessionsDir?: boolean;
+  env?: Readonly<Record<string, string | undefined>>;
+  homeDir?: string;
+  [key: string]: any;
+}): SharedSessionStore;
 export declare function validateSessionManifest(value: unknown): SessionManifest;
 export declare function validateSessionContext(value: unknown): SessionContext;
 export declare function projectCaptainSessionStructure(value: SessionExecutionProjection): SessionStructuralProjection;

package/reference/sdlc/code.playbook/session-store.js

@@ -21,9 +21,19 @@ export function openSessionStore(sessionsDir) {
 }
 
 function wrapStore(store) {
+  // Preparation is kept once it succeeds; a refusal is not, so the next
+  // operation prepares again once the directory is repaired
+  // (session-storage-1).
   let preparation;
   const prepared = async (operation) => {
-    await (preparation ??= store.prepare());
+    if (preparation === undefined) {
+      const attempt = store.prepare();
+      preparation = attempt;
+      attempt.catch(() => {
+        if (preparation === attempt) preparation = undefined;
+      });
+    }
+    await preparation;
     return operation();
   };
   return Object.freeze({

package/slc/link.md

@@ -341,6 +341,7 @@ interface PlaybookRepositoryReceipt {
   readonly baseline: PlaybookRepositoryObservation;
   readonly after?: PlaybookRepositoryObservation;
   readonly commitOid?: string;
+  readonly commits?: readonly string[];
 }
 
 type PlaybookRepositoryDisposition =
@@ -1286,6 +1287,12 @@ runtime-owned payload field; `guard` shall name exactly one outcome declared
 by both the live result map and `outcomeAuthority`; and every semantic-owned
 field shall satisfy the result map's required-field type before any actor
 output is delivered.
+That type is the value shape the compiled FSM's own validator admits for the
+field: the shared engine reads it once at construction by presenting each
+governed outcome's accepting arm with sample values of a closed set of shapes,
+a field whose shape the FSM admits as a string or does not reveal stays a
+string, and the judge prompt and validation error name every non-string shape
+([DR-089](../specs/decisions/089-judge-replies-take-the-machines-shapes.md)).
 The judge prompt shall render each governed outcome's description with its
 meaning verbatim and its `Output shall include` clause replaced by that reply
 contract — exactly `guard` plus the semantic-owned fields, each keeping its
@@ -1320,10 +1327,16 @@ physical receipt, or the complete cumulative logical receipt of a deferred
 operation, whose classification is exactly the outcome's declared
 `unchanged` or `one-descendant-commit` disposition; a `one-descendant-commit`
 receipt shall carry exactly the after-HEAD OID used for the arm's effect-owned
-fields, while an `unchanged` receipt's complete validated observation supplies
-its observed HEAD OID for them, and a receipt that cannot prove that observed
-HEAD shall leave the envelope unresolved rather than inject a fabricated
-value.
+fields, and lists every new commit in `commits` where HEAD advanced by more
+than one, while an `unchanged` receipt's complete validated observation
+supplies its observed HEAD OID for them, and a receipt that cannot prove that
+observed HEAD shall leave the envelope unresolved rather than inject a
+fabricated value.
+A `one-descendant-commit` outcome shall also resolve over an `unchanged`
+receipt whose HEAD names a commit when no outcome of that call declares
+`unchanged` and the trimmed `finalText` names that commit as a word, by its
+full OID or an abbreviation of at least seven leading hex digits; its
+effect-owned fields then take that HEAD OID.
 A `deferred` candidate shall be admissible only for its already-validated
 effect-authorized `needsBossReply` outcome and only from a complete after
 observation whose HEAD equals the logical operation's original baseline HEAD
@@ -1373,10 +1386,16 @@ player or judge call.
 The adjudicator shall use the same document-order tolerant JSON recovery as
 the Boss classifier. Unlike invalid classification, a reply from which no
 object can be recovered, an undeclared guard, or a missing required field is a
-control-plane error for nongoverned delegated-player and direct-Captain adjudication and
+control-plane error for nongoverned delegated-player adjudication and
 shall throw after the invocation reaches its FSM error path and ordered
 emissions drain; schema-3 governed adjudication follows the bounded
 reconciliation contract above instead.
+Direct-Captain adjudication treats such a reply, or one carrying an undeclared
+field, as a structural error: it makes exactly one corrective adjudication over
+the same visible output that restates the reply and its validation error, and
+a second structural error routes the invocation to its FSM failure state as a
+recoverable `judge-failed` failure rather than a control-plane error
+([DR-089](../specs/decisions/089-judge-replies-take-the-machines-shapes.md)).
 
 Two default adjudication strategies, in selection order:
 
@@ -1389,7 +1408,11 @@ Two default adjudication strategies, in selection order:
   `{ guard, …semanticOwnedPayloadFields }` and explicitly forbids every other
   payload field. The governed form also permits the blocked report above when no outcome matches.
   Both forms exclude the runtime-injected direct-Captain
-  `question` and `response` fields above. The prompt shall identify hidden control work,
+  `question` and `response` fields above. A direct-Captain prompt keeps each
+  description and states under it the exact reply that key takes — `guard`
+  plus the structural fields its `Output shall include` clause names, each with
+  its authored placeholder — naming `question` and `response` as
+  runtime-supplied. The prompt shall identify hidden control work,
   prohibit tool use, file inspection, and external evidence, direct the judge
   to decide only from the supplied actor output and declared outcomes, and
   require exactly one JSON object with no prose. The judge prompt shall not

package/slc/text2gears.md

@@ -35,7 +35,8 @@ E.g.:
 - Coder
 - Reviewer
 
-Capitalize English role names (e.g., `Writer`); quote non-English names (e.g., `作者`) when needed to distinguish from prose.
+Each role name shall be one capitalized word — an uppercase letter, or a letter of a script without case, followed only by letters and digits — so a two-word role is written as one word, e.g. `RiskOfficer`, never `Risk Officer`.
+Quote non-English names (e.g., `作者`) when needed to distinguish from prose.
 
 ## Behaviors
 
@@ -67,14 +68,15 @@ Boss-visible contract and is nonconformant.
 
 ### Authored prompt fragments
 
-Source may compose one acting prompt from authored Markdown instruction blocks and runtime context that it explicitly says to relay in quotes (`>`).
+Source may compose one acting prompt from authored Markdown instruction blocks and runtime context that it explicitly marks as relayed in quotes.
+The relay marker is a backticked `>` in ASCII or full-width parentheses, `` (`>`) `` or `` （`>`） ``, in the prose introducing the blockquote; the words around it, such as "in quotes" or "以引用形式", are prose in the Source's language.
 A fenced `markdown` block introduced as an instruction or prompt is an authored static prompt fragment: its fence delimiters are Source syntax, while every interior line and blank line is prompt content preserved after documented Markdown unescaping.
 
 An instruction fence and a relayed-context fragment that apply to one behavior shall appear in the target blockquote in their Source order.
 Distinct non-empty fragments shall be separated by one blank prompt line unless Source explicitly supplies a different boundary.
 text2gears shall not move a shared instruction ahead of behavior-specific context, move quoted evidence after an instruction that Source says follows the evidence, or otherwise regroup fragments for convenience.
 
-Where Source says that a runtime value is relayed in quotes, the leading `>` is prompt content rather than Source-only blockquote syntax.
+Where Source marks a runtime value as relayed in quotes, the leading `>` is prompt content rather than Source-only blockquote syntax.
 If Source supplies a blockquoted template for that relay, text2gears shall keep one literal leading `>` on every quoted line; the target GEARS line therefore uses its outer blockquote marker followed by the literal marker, such as `> > Coder output: <coder-output>`.
 If Source names the relayed value but supplies no template, text2gears shall emit a bare quoted prompt-content line, exactly `> <token>`, written as `> > <token>` in the GEARS file because the first marker encloses the prompt and the second is literal content, without an added label or surrounding prose, and shall not summarize, paraphrase, or invent the relayed value.
 An ordinary Source blockquote that specifies a complete acting prompt without requiring quoted relay retains the existing rule above: its one leading marker is Source syntax and is not prompt content.

package/src/runtime.d.ts

@@ -255,6 +255,12 @@ export interface PlaybookRepositoryReceipt {
     readonly baseline: PlaybookRepositoryObservation;
     readonly after?: PlaybookRepositoryObservation;
     readonly commitOid?: string;
+    /**
+     * Every new commit, oldest first and ending at `commitOid`, present exactly
+     * when a `one-descendant-commit` receipt's HEAD advanced by more than one
+     * (DR-088).
+     */
+    readonly commits?: readonly string[];
     readonly preExisting?: PlaybookRepositoryPreExistingChanges;
 }
 /** One durably ordered physical governed-player boundary (DR-040). */

package/src/runtime.ts

@@ -618,6 +618,12 @@ export interface PlaybookRepositoryReceipt {
   readonly baseline: PlaybookRepositoryObservation;
   readonly after?: PlaybookRepositoryObservation;
   readonly commitOid?: string;
+  /**
+   * Every new commit, oldest first and ending at `commitOid`, present exactly
+   * when a `one-descendant-commit` receipt's HEAD advanced by more than one
+   * (DR-088).
+   */
+  readonly commits?: readonly string[];
   readonly preExisting?: PlaybookRepositoryPreExistingChanges;
 }
 

package/src/xstate-playbook-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { AnyStateMachine, EventObject, PromiseActorLogic } from 'xstate';
+import { type PlaybookSemanticValueShape, type PlaybookSemanticValueShapes } from './xstate-runtime.js';
 import type { CaptainResult, JsonValue, PlaybookEffectBoundary, PlaybookEffectBoundaryStart, PlaybookEffectLedger, PlaybookEffectLedgerCapability, NormalizedError, PlaybookFailureCause, PlaybookPendingBossQuestion, PlaybookPorts, PlaybookRepositoryReceipt, PlaybookRuntimeFactory, PlaybookSession, PlaybookState, PlayerResult } from './runtime.js';
 export interface PlaybookPendingBossQuestionContext {
     questionId: string;
@@ -494,7 +495,7 @@ export declare function defaultBuildJudgePrompt(input: PlaybookPlayerInput, fina
  * self-inflicted defect. Exported so linked machinery of an artifact's own
  * renders the identical contract instead of restating it.
  */
-export declare function renderGovernedOutcomeContract(guard: string, description: string, outcome: XStateGovernedOutcomeSpec | undefined): string[];
+export declare function renderGovernedOutcomeContract(guard: string, description: string, outcome: XStateGovernedOutcomeSpec | undefined, shapes?: Readonly<Record<string, PlaybookSemanticValueShape>>): string[];
 export interface PlayerAdjudicationSpec {
     buildJudgePrompt?: (input: PlaybookPlayerInput, finalText: string) => string;
     extractRequiredFields?: (description: string) => string[];
@@ -522,13 +523,22 @@ export declare function createPlayerBridge(spec: PlayerBridgeSpec, ports: Playbo
 /**
  * Default direct-Captain adjudicator prompt (DR-025). The single statement of
  * the `{ guard, …structuralPayloadFields }` reply contract, shared with the
- * compiled default Captain artifact so the wording cannot drift.
+ * compiled default Captain artifact so the wording cannot drift. Each declared
+ * key keeps its description verbatim and gains the exact reply it takes
+ * (DR-089): `guard` plus the structural fields its `Output shall include`
+ * clause names, each with its authored placeholder, while the visible
+ * `question` and `response` fields are named as runtime-supplied. A
+ * `correction` restates a structurally invalid first reply and its
+ * validation error for the one corrective adjudication.
  */
 export declare function defaultBuildCaptainJudgePrompt(input: {
     readonly stateId: string;
     readonly sourceItem: string;
     readonly result: Readonly<Record<string, string>>;
-}, finalText: string): string;
+}, finalText: string, correction?: {
+    readonly reply: string;
+    readonly error: string;
+}): string;
 /**
  * Targets of the FSM's `awaitBossReply` BOSS_REPLY transitions, plus — for
  * the parallel shape gears2fsm compiles (DR-067) — the targets of each
@@ -554,6 +564,13 @@ export declare function stateDescriptionsFromMachine(machine: AnyStateMachine):
  * other than `success` or `failure`, is a malformed artifact and throws.
  */
 export declare function terminalOutcomesFromMachine(machine: AnyStateMachine, label?: string): ReadonlyMap<string, 'success' | 'failure'>;
+/**
+ * DR-089: the non-string JSON value shape the compiled machine admits for
+ * each semantic-owned field of each governed outcome, keyed by state id and
+ * then by outcome. Exported so linked machinery of an artifact's own reads
+ * the same contract the shared factory enforces.
+ */
+export declare function inferSemanticValueShapes(machine: AnyStateMachine, authority: XStateOutcomeAuthoritySpec): ReadonlyMap<string, PlaybookSemanticValueShapes>;
 /**
  * Build a `PlaybookRuntimeFactory` that interprets the given FSM artifact
  * under the slc/link.md contract. The factory provides every actor kind the