@sublang/playbook 10.0.0 → 12.0.0

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

@@ -6,7 +6,8 @@
 // Role metadata: Coder→coder (canonical local role)
 // Boss event:    deterministic START_CODE entry; exact Boss text becomes
 //                callerInput; pending Coder questions retain BOSS_REPLY
-// Adjudication:  LLM judge per player state; coderOutput is carried verbatim
+// Adjudication:  LLM judge per player state; coderOutput is carried verbatim;
+//                the first phase decides among four semantic outcomes
 // Nested call:   literal review target through the shared bridge
 // Compat:        artifact schema 3 / runtime ABI 1
 
@@ -195,7 +196,7 @@ const runtimeSpec = {
     runFirstPhase: {
       role: 'coder',
       label:
-        'Coder is implementing one direct phase or committing a new intent record.',
+        'Coder is running the first coding phase: a direct implementation, a new intent record, or an existing intent-record task.',
     },
     runIrTask: {
       role: 'coder',
@@ -213,6 +214,23 @@ const runtimeSpec = {
           repositoryDisposition: 'one-descendant-commit',
         },
         irCommit: {
+          fields: {
+            coderOutput: 'presentation',
+            latestCommit: 'effect',
+            irNumber: 'semantic',
+          },
+          repositoryDisposition: 'one-descendant-commit',
+        },
+        moreTasks: {
+          fields: {
+            coderOutput: 'presentation',
+            latestCommit: 'effect',
+            irNumber: 'semantic',
+            irTask: 'semantic',
+          },
+          repositoryDisposition: 'one-descendant-commit',
+        },
+        finalTask: {
           fields: {
             coderOutput: 'presentation',
             latestCommit: 'effect',
@@ -231,6 +249,7 @@ const runtimeSpec = {
           fields: {
             coderOutput: 'presentation',
             latestCommit: 'effect',
+            irNumber: 'semantic',
             irTask: 'semantic',
           },
           repositoryDisposition: 'one-descendant-commit',
@@ -239,6 +258,8 @@ const runtimeSpec = {
           fields: {
             coderOutput: 'presentation',
             latestCommit: 'effect',
+            irNumber: 'semantic',
+            irTask: 'semantic',
           },
           repositoryDisposition: 'one-descendant-commit',
         },

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

@@ -7,6 +7,9 @@ interface SessionAgent {
     readonly adapter: string;
     readonly model: TuningSelection;
     readonly effort: TuningSelection<Effort>;
+    /** Adapter-scoped fast mode. Absence is the provider default; `false` is a
+     * literal request, so this carries no provider-default sentinel. */
+    readonly fastMode?: boolean;
     readonly instruction?: string;
     readonly permissions?: PermissionPolicy;
 }
@@ -29,7 +32,7 @@ interface PlaybookCaptainUnresolvedEffectSettlementInput {
     readonly rootPlaybookId: string;
     readonly unresolvedEffects: readonly PlaybookCaptainUnresolvedEffect[];
 }
-type SnapshotAgentEnvelope = DeepReadonly<Omit<SessionAgent, 'model' | 'effort'>>;
+type SnapshotAgentEnvelope = DeepReadonly<Omit<SessionAgent, 'model' | 'effort' | 'fastMode'>>;
 type PlayerLedgerSnapshotEntry = DeepReadonly<PlayerLedgerEntry>;
 export interface PlaybookCaptainDeps {
     loadModule?: (specifier: string) => Promise<unknown>;

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

@@ -1379,10 +1379,16 @@ function snapshotEffortSelection(value, path) {
     }
     return selection;
 }
+function snapshotFastMode(value, path) {
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw new TypeError(`${path} must be a boolean`);
+    }
+    return value;
+}
 function snapshotSessionAgent(value, path) {
     const agent = snapshotRecord(value, path);
-    rejectSnapshotKeys(agent, ['adapter', 'model', 'effort', 'instruction', 'permissions'], path);
-    const fixed = snapshotFixedAgent(Object.fromEntries(Object.entries(agent).filter(([key]) => key !== 'model' && key !== 'effort')), path);
+    rejectSnapshotKeys(agent, ['adapter', 'model', 'effort', 'fastMode', 'instruction', 'permissions'], path);
+    const fixed = snapshotFixedAgent(Object.fromEntries(Object.entries(agent).filter(([key]) => key !== 'model' && key !== 'effort' && key !== 'fastMode')), path);
     return {
         adapter: fixed.adapter,
         ...(fixed.instruction === undefined
@@ -1393,6 +1399,9 @@ function snapshotSessionAgent(value, path) {
             : { permissions: livePermissions(fixed.permissions) }),
         model: snapshotTuningSelection(agent.model, `${path}.model`),
         effort: snapshotEffortSelection(agent.effort, `${path}.effort`),
+        ...(agent.fastMode === undefined
+            ? {}
+            : { fastMode: snapshotFastMode(agent.fastMode, `${path}.fastMode`) }),
     };
 }
 function fixedAgent(agent) {
@@ -1403,9 +1412,13 @@ function fixedAgent(agent) {
     };
 }
 function callSettings(agent, tuning = agent) {
+    // cligent treats supplied call settings as a complete replacement, so an
+    // omitted fastMode here is a request for the provider default, never an
+    // inheritance of whatever the previous call left behind.
     return {
         model: tuning.model,
         effort: tuning.effort,
+        ...(tuning.fastMode === undefined ? {} : { fastMode: tuning.fastMode }),
         ...(agent.instruction === undefined ? {} : { instruction: agent.instruction }),
         ...(agent.permissions === undefined ? {} : { permissions: agent.permissions }),
     };
@@ -1533,7 +1546,7 @@ async function buildEnablements(options, loadModule, hostCapabilities) {
         for (const role of entry.requiredRoleIds) {
             const path = `captain.options.playbooks.${id}.roles.${role}`;
             const rawBinding = snapshotRecord(roleRecord[role], path);
-            rejectSnapshotKeys(rawBinding, ['playerId', 'model', 'effort'], path);
+            rejectSnapshotKeys(rawBinding, ['playerId', 'model', 'effort', 'fastMode'], path);
             const playerId = snapshotString(rawBinding.playerId, `${path}.playerId`);
             if (!PLAYER_ID_PATTERN.test(playerId) || playerId === INTERNAL_CAPTAIN_ID) {
                 throw new Error(`${path}.playerId is not a canonical player id`);
@@ -1546,6 +1559,11 @@ async function buildEnablements(options, loadModule, hostCapabilities) {
                 playerId,
                 model: snapshotTuningSelection(rawBinding.model, `${path}.model`),
                 effort: snapshotEffortSelection(rawBinding.effort, `${path}.effort`),
+                ...(rawBinding.fastMode === undefined
+                    ? {}
+                    : {
+                        fastMode: snapshotFastMode(rawBinding.fastMode, `${path}.fastMode`),
+                    }),
                 agent,
             });
         }

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

@@ -55,6 +55,9 @@ interface SessionAgent {
   readonly adapter: string;
   readonly model: TuningSelection;
   readonly effort: TuningSelection<Effort>;
+  /** Adapter-scoped fast mode. Absence is the provider default; `false` is a
+   * literal request, so this carries no provider-default sentinel. */
+  readonly fastMode?: boolean;
   readonly instruction?: string;
   readonly permissions?: PermissionPolicy;
 }
@@ -94,7 +97,7 @@ interface PlaybookCaptainUnresolvedEffectSettlementInput {
 }
 
 type SnapshotAgentEnvelope = DeepReadonly<
-  Omit<SessionAgent, 'model' | 'effort'>
+  Omit<SessionAgent, 'model' | 'effort' | 'fastMode'>
 >;
 
 type PlayerLedgerSnapshotEntry = DeepReadonly<PlayerLedgerEntry>;
@@ -377,6 +380,7 @@ interface EffectivePlayerBinding {
   readonly playerId: string;
   readonly model: TuningSelection;
   readonly effort: TuningSelection<Effort>;
+  readonly fastMode?: boolean;
   readonly agent: SessionAgent;
 }
 
@@ -2562,6 +2566,16 @@ function snapshotEffortSelection(
   return selection as TuningSelection<Effort>;
 }
 
+function snapshotFastMode(
+  value: JsonValue | undefined,
+  path: string,
+): boolean | undefined {
+  if (value !== undefined && typeof value !== 'boolean') {
+    throw new TypeError(`${path} must be a boolean`);
+  }
+  return value;
+}
+
 function snapshotSessionAgent(
   value: JsonValue | undefined,
   path: string,
@@ -2569,13 +2583,14 @@ function snapshotSessionAgent(
   const agent = snapshotRecord(value, path);
   rejectSnapshotKeys(
     agent,
-    ['adapter', 'model', 'effort', 'instruction', 'permissions'],
+    ['adapter', 'model', 'effort', 'fastMode', 'instruction', 'permissions'],
     path,
   );
   const fixed = snapshotFixedAgent(
     Object.fromEntries(
       Object.entries(agent).filter(
-        ([key]) => key !== 'model' && key !== 'effort',
+        ([key]) =>
+          key !== 'model' && key !== 'effort' && key !== 'fastMode',
       ),
     ) as JsonValue,
     path,
@@ -2590,10 +2605,15 @@ function snapshotSessionAgent(
       : { permissions: livePermissions(fixed.permissions) }),
     model: snapshotTuningSelection(agent.model, `${path}.model`),
     effort: snapshotEffortSelection(agent.effort, `${path}.effort`),
+    ...(agent.fastMode === undefined
+      ? {}
+      : { fastMode: snapshotFastMode(agent.fastMode, `${path}.fastMode`) }),
   };
 }
 
-function fixedAgent(agent: SessionAgent): Omit<SessionAgent, 'model' | 'effort'> {
+function fixedAgent(
+  agent: SessionAgent,
+): Omit<SessionAgent, 'model' | 'effort' | 'fastMode'> {
   return {
     adapter: agent.adapter,
     ...(agent.instruction === undefined ? {} : { instruction: agent.instruction }),
@@ -2603,11 +2623,15 @@ function fixedAgent(agent: SessionAgent): Omit<SessionAgent, 'model' | 'effort'>
 
 function callSettings(
   agent: SessionAgent,
-  tuning: Pick<SessionAgent, 'model' | 'effort'> = agent,
+  tuning: Pick<SessionAgent, 'model' | 'effort' | 'fastMode'> = agent,
 ): AgentCallSettings {
+  // cligent treats supplied call settings as a complete replacement, so an
+  // omitted fastMode here is a request for the provider default, never an
+  // inheritance of whatever the previous call left behind.
   return {
     model: tuning.model,
     effort: tuning.effort,
+    ...(tuning.fastMode === undefined ? {} : { fastMode: tuning.fastMode }),
     ...(agent.instruction === undefined ? {} : { instruction: agent.instruction }),
     ...(agent.permissions === undefined ? {} : { permissions: agent.permissions }),
   };
@@ -2833,7 +2857,11 @@ async function buildEnablements(
     for (const role of entry.requiredRoleIds) {
       const path = `captain.options.playbooks.${id}.roles.${role}`;
       const rawBinding = snapshotRecord(roleRecord[role], path);
-      rejectSnapshotKeys(rawBinding, ['playerId', 'model', 'effort'], path);
+      rejectSnapshotKeys(
+        rawBinding,
+        ['playerId', 'model', 'effort', 'fastMode'],
+        path,
+      );
       const playerId = snapshotString(rawBinding.playerId, `${path}.playerId`);
       if (!PLAYER_ID_PATTERN.test(playerId) || playerId === INTERNAL_CAPTAIN_ID) {
         throw new Error(`${path}.playerId is not a canonical player id`);
@@ -2848,6 +2876,14 @@ async function buildEnablements(
         playerId,
         model: snapshotTuningSelection(rawBinding.model, `${path}.model`),
         effort: snapshotEffortSelection(rawBinding.effort, `${path}.effort`),
+        ...(rawBinding.fastMode === undefined
+          ? {}
+          : {
+              fastMode: snapshotFastMode(
+                rawBinding.fastMode,
+                `${path}.fastMode`,
+              ),
+            }),
         agent,
       });
     }

package/reference/sdlc/code.playbook/playbook.config.template.yaml

@@ -8,9 +8,10 @@
 
 # The Captain and each stable session player carries its own defaults inline:
 # an adapter shorthand (claude, codex) or a block with
-# adapter/model/effort/permissions. A role may override only model or effort.
-# Omit an override to inherit the player default; set it to false to select
-# that provider's current default explicitly.
+# adapter/model/effort/fastMode/permissions. A role may override only model,
+# effort, or fastMode.
+# Omit an override to inherit the player default. For model and effort, false
+# selects the provider default; fastMode false is a literal disabled request.
 
 # Each adapter needs its vendor SDK installed as its own top-level
 # install root — they are optional peer dependencies, so you pay only
@@ -29,7 +30,7 @@
 # list, so those captains degrade to a prompt-level restriction (DR-013 A1).
 captain:
   adapter: claude
-  model: claude-opus-4-8
+  model: claude-opus-5
   effort: high
   permissions:
     mode: auto
@@ -45,27 +46,41 @@ notifications:
 # shares one provider conversation across those playbooks.
 players:
   dev.coder:
+    adapter: codex
+    model: gpt-5.6-sol
+    effort: ultra
+    # Adapter-scoped fast mode is validated by the installed Cligent contract;
+    # omitting it takes the provider default.
+    fastMode: true
+    permissions:
+      mode: auto
+      writablePaths: ['.git']
+
+  dev.reviewer:
     adapter: claude
-    model: claude-opus-4-8[1m]
+    model: claude-opus-5
     effort: xhigh
     permissions:
       mode: auto
 
-  dev.reviewer:
-    adapter: codex
-    model: gpt-5.5
+  # DEV's planner stays a distinct player: equal ids deliberately share one
+  # provider conversation, and planning context must not bleed into review
+  # conversations (DR-044).
+  dev.analyst:
+    adapter: claude
+    model: claude-opus-5
     effort: xhigh
     permissions:
       mode: auto
-      writablePaths: ['.git']
 
 # Enabled playbooks. Each is loaded from its explicit `from` module; the
 # `<id>` key must equal that module's manifest id. `from`, `command`, and
 # `roles` are launcher-owned; every other key is that playbook's option
 # slice.
 #
-# Every manifest role is bound explicitly. These three playbooks intentionally
-# reuse the same two stable players; change an id to isolate its conversation.
+# Every manifest role is bound explicitly. CODE, REVIEW, and DECIDE
+# intentionally reuse the same two stable players, while DEV keeps its own
+# Analyst; change an id to isolate its conversation.
 playbooks:
   code:
     from: "@sublang/playbook/code/registry"
@@ -83,3 +98,8 @@ playbooks:
     roles:
       coder: dev.coder
       reviewer: dev.reviewer
+
+  dev:
+    from: "@sublang/playbook/dev/registry"
+    roles:
+      analyst: dev.analyst

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

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+
+export declare const RECORDS_STREAM_VERSION: 1;
+export declare function defaultSessionsDir(): string;
+export declare function openSessionStore(
+  sessionsDir: string,
+): PlaybookSessionStore;
+
+export type ReplayJsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | readonly ReplayJsonValue[]
+  | ReplayRecord;
+export type ReplayRecord = {
+  readonly [key: string]: ReplayJsonValue;
+};
+export interface ReplayStreamEntry {
+  readonly v: 1;
+  readonly seq: number;
+  readonly role?: string;
+  readonly record: ReplayRecord;
+}
+export interface ReplayStreamReadOptions {
+  readonly afterSeq?: number;
+}
+export interface ReplayStreamReadResult {
+  readonly entries: readonly ReplayStreamEntry[];
+  readonly lastReadableSeq: number;
+}
+export interface LeaseReplayStreamReadResult extends ReplayStreamReadResult {
+  readonly lastDurableSeq: number;
+  readonly incomplete: boolean;
+}
+export type ReplayStreamStatus =
+  | {
+      readonly lastReadableSeq: number;
+      readonly lastDurableSeq: number;
+      readonly incomplete: boolean;
+    }
+  | {
+      readonly lastReadableSeq: null;
+      readonly lastDurableSeq: null;
+      readonly incomplete: true;
+    };
+export interface PlaybookSessionSummary {
+  readonly schemaVersion: number;
+  readonly sessionId: string;
+  readonly state: 'settled' | 'uncertain';
+  readonly cwd: string;
+  readonly updatedAt: string;
+}
+export interface SkippedPlaybookSession {
+  readonly sessionId: string;
+  readonly reason: string;
+}
+export interface PlaybookSessionListResult {
+  readonly sessions: readonly PlaybookSessionSummary[];
+  readonly skipped: readonly SkippedPlaybookSession[];
+}
+export interface PlaybookSessionStore {
+  readonly sessionsDir: string;
+  list(): Promise<PlaybookSessionListResult>;
+  read(sessionId: string): Promise<PlaybookSessionSummary>;
+  readStream(
+    sessionId: string,
+    options?: ReplayStreamReadOptions,
+  ): Promise<ReplayStreamReadResult>;
+  acquire(sessionId: string): Promise<PlaybookSessionLease>;
+}
+export interface PlaybookSessionLease {
+  readonly sessionId: string;
+  readonly ownerToken: string;
+  append(record: object, role?: string): Promise<void>;
+  readStream(
+    options?: ReplayStreamReadOptions,
+  ): Promise<LeaseReplayStreamReadResult>;
+  streamStatus(): ReplayStreamStatus;
+  release(): Promise<ReplayStreamStatus>;
+}

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

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+
+import {
+  RECORDS_STREAM_VERSION,
+  createCaptainSessionStore,
+  defaultCaptainSessionsDir,
+} from './bin/session-store.js';
+
+export { RECORDS_STREAM_VERSION };
+
+export function defaultSessionsDir() {
+  return defaultCaptainSessionsDir();
+}
+
+export function openSessionStore(sessionsDir) {
+  if (typeof sessionsDir !== 'string') {
+    throw new TypeError('session store path must be a string');
+  }
+  return wrapStore(createCaptainSessionStore({ sessionsDir }));
+}
+
+function wrapStore(store) {
+  return Object.freeze({
+    sessionsDir: store.sessionsDir,
+    list: async () => projectListResult(await store.listSummaries()),
+    read: async (sessionId) =>
+      projectSummary(await store.readSummary(sessionId)),
+    readStream: async (sessionId, options) =>
+      projectReadResult(await store.readStream(sessionId, options)),
+    acquire: async (sessionId) => wrapLease(await store.acquire(sessionId)),
+  });
+}
+
+function wrapLease(lease) {
+  let finalStatus;
+  let releaseInFlight;
+
+  const release = () => {
+    if (finalStatus !== undefined) return Promise.resolve(finalStatus);
+    if (releaseInFlight !== undefined) return releaseInFlight;
+    const operation = lease.release();
+    releaseInFlight = operation.then(
+      (status) => {
+        finalStatus = projectStatus(status);
+        return finalStatus;
+      },
+      (cause) => {
+        releaseInFlight = undefined;
+        throw cause;
+      },
+    );
+    return releaseInFlight;
+  };
+
+  return Object.freeze({
+    sessionId: lease.sessionId,
+    ownerToken: lease.ownerToken,
+    append: (record, role) => lease.append(record, role),
+    readStream: async (options) => {
+      if (finalStatus !== undefined) {
+        throw new Error('released session lease has no live replay reader');
+      }
+      return projectLeaseReadResult(await lease.readStream(options));
+    },
+    streamStatus: () => finalStatus ?? projectStatus(lease.streamStatus()),
+    release,
+  });
+}
+
+function projectListResult(result) {
+  return Object.freeze({
+    sessions: Object.freeze(result.sessions.map(projectSummary)),
+    skipped: Object.freeze(
+      result.skipped.map(({ sessionId, reason }) =>
+        Object.freeze({ sessionId, reason }),
+      ),
+    ),
+  });
+}
+
+function projectSummary(summary) {
+  return Object.freeze({
+    schemaVersion: summary.schemaVersion,
+    sessionId: summary.sessionId,
+    state: summary.state,
+    cwd: summary.cwd,
+    updatedAt: summary.updatedAt,
+  });
+}
+
+function projectReadResult(result) {
+  return Object.freeze({
+    entries: Object.freeze([...result.entries]),
+    lastReadableSeq: result.lastReadableSeq,
+  });
+}
+
+function projectLeaseReadResult(result) {
+  return Object.freeze({
+    ...projectReadResult(result),
+    lastDurableSeq: result.lastDurableSeq,
+    incomplete: result.incomplete,
+  });
+}
+
+function projectStatus(status) {
+  return Object.freeze({
+    lastReadableSeq: status.lastReadableSeq,
+    lastDurableSeq: status.lastDurableSeq,
+    incomplete: status.incomplete,
+  });
+}

package/reference/sdlc/decide.md

@@ -23,31 +23,40 @@ Consult @specs/map.md for relevant context and @specs/meta.md for spec requireme
 Do not change any files.
 ```
 
-Neither role's player shall receive the other role's proposal until both proposals are complete and Coder has committed Coder's own proposal.
+Neither role's player shall receive the other role's proposal until both proposals are complete.
+Each proposal is complete only when its player affirmatively provides a complete design proposal.
+A progress report, status update, or promise of a later proposal supports no proposal outcome.
 A Boss interrupt during the parallel proposal pair shall restart the whole pair so both players receive the same new topic and remain independent.
 
-When both proposals are complete, Captain shall then give Coder the following instruction:
+When both proposals are complete, Captain shall give Coder the following instruction, with the complete topic and Reviewer's complete proposal inserted under their own labels in quotes (`>`):
 
 ```markdown
-Turn your proposal into the necessary spec items or DRs.
+Synthesize your independent proposal with Reviewer's proposal below.
+Keep to the original topic below and follow what it asks.
+Keep the best, essential parts of either proposal and reject any point that is unsound, unnecessary, or outside the topic.
+Turn the resulting design into the necessary DRs and/or spec items.
 Follow @specs/meta.md and update @specs/map.md when needed.
-Do not inspect or incorporate Reviewer's proposal before this commit.
-Do not change code or implement the proposal.
+Do not change code or implement the design.
 
 Commit the result as one new commit, following @specs/packages/git.md.
 Make the commit message explain concisely what changed and why.
-Coder is <coder-llm>; format the model token in conventional human form.
+Identify every new commit you make.
+Coder is <coder-llm> and Reviewer is <reviewer-llm>.
+
+> Original topic: \<caller-topic\>
+> Reviewer's independent proposal: \<reviewer-proposal\>
 ```
 
-After Coder commits, Captain shall call playbook `review`:
+No transition shall depend on a fixed presentation format of either player's reply.
+Captain shall use the repository-effect receipt as the authoritative identity of Coder's new `decide`-owned commit.
+
+After Coder commits, Captain shall call playbook `review` with the following input in quotes (`>`):
 
-> Review the latest commit as a spec-design change against the initial intent.
-> Compare it with your independent proposal and take the best of both.
-> Make your suggestions.
->
-> Initial intent: \<caller-topic\>.
-> Coder's independent proposal: \<coder-proposal\>.
+> Original intent: \<caller-topic\>
+> Review scope: the `decide`-owned commit \<decide-commit\> and its resulting repository state.
+> Coder output: \<coder-output\>
 
-`decide` is complete when `review` returns the approved latest commit and the fact that no unsettled findings remain.
-When `review` returns an authored abort or failure, or a terminal result that does not prove exact approval, `decide` shall report the failure and the last `decide`-owned commit to its caller.
+`decide` is complete only when `review` returns a result that applies to the supplied review scope, gives the exact evaluated repository revision, and affirmatively establishes that no unsettled findings remain.
+It then returns the `decide`-owned commit and that evaluated revision to its caller.
+When `review` returns an authored abort or failure, or a terminal result that does not establish those facts, `decide` shall report the failure and the last `decide`-owned commit to its caller.
 When the nested `review` call fails outside that authored result contract, `decide` shall park as failed and retain the control-plane error instead of reporting an authored review outcome.

package/reference/sdlc/decide.playbook/decide.fsm.d.ts

@@ -19,7 +19,12 @@ type PendingBossQuestions = Partial<Record<ResumableStateId, PendingBossQuestion
 type BossReplies = Partial<Record<ResumableStateId, string>>;
 type PendingBossQuestionParams = Omit<PendingBossQuestion, 'questionId'>;
 export interface ReviewSuccessOutput {
-    approvedCommit: 'latest';
+    evaluatedRevision: string;
+    noUnsettledFindings: true;
+}
+export interface DecideSuccessOutput {
+    decideCommit: string;
+    evaluatedRevision: string;
     noUnsettledFindings: true;
 }
 export interface DecideFailureOutput {
@@ -31,7 +36,7 @@ export interface DecideFailureOutput {
         message: string;
     };
 }
-export type DecideOutput = ReviewSuccessOutput | DecideFailureOutput;
+export type DecideOutput = DecideSuccessOutput | DecideFailureOutput;
 interface ChildFailure {
     status: 'aborted' | 'error';
     playbookId: 'review';
@@ -45,6 +50,7 @@ export interface DecideContext {
     coderProposal?: string;
     reviewerProposal?: string;
     latestCommit?: string;
+    coderOutput?: string;
     reviewResult?: ReviewSuccessOutput;
     reviewFailure?: ChildFailure;
     lastResult?: PlayerOutput;
@@ -74,6 +80,7 @@ export interface PlayerInput {
     result: Record<string, string>;
     role: Role;
     callerTopic?: string;
+    reviewerProposal?: string;
     pendingBossQuestion?: PendingBossQuestion;
     bossReply?: string;
 }
@@ -139,9 +146,6 @@ export declare const decideMachine: import("xstate").StateMachine<DecideContext,
 } | {
     type: "rememberBossReply";
     params: import("xstate").NonReducibleUnknown;
-} | {
-    type: "clearBossReplyContext";
-    params: import("xstate").NonReducibleUnknown;
 } | {
     type: "copyInterruptedTopic";
     params: import("xstate").NonReducibleUnknown;
@@ -186,6 +190,9 @@ export declare const decideMachine: import("xstate").StateMachine<DecideContext,
 } | {
     type: "clearProposalRoundContext";
     params: import("xstate").NonReducibleUnknown;
+} | {
+    type: "clearBossReplyContext";
+    params: import("xstate").NonReducibleUnknown;
 }, {
     type: "authoredReviewFailure";
     params: unknown;
@@ -212,7 +219,7 @@ export declare const decideMachine: import("xstate").StateMachine<DecideContext,
         coder: "complete" | "working" | "waiting";
         reviewer: "complete" | "working" | "waiting";
     };
-}, string, Readonly<Record<string, never>>, ReviewSuccessOutput | DecideFailureOutput, import("xstate").EventObject, import("xstate").MetaObject, {
+}, string, Readonly<Record<string, never>>, DecideSuccessOutput | DecideFailureOutput, import("xstate").EventObject, import("xstate").MetaObject, {
     id: "decide";
     states: {
         readonly ready: {