@sublang/playbook 10.0.0 → 11.0.0

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,19 +46,22 @@ notifications:
 # shares one provider conversation across those playbooks.
 players:
   dev.coder:
-    adapter: claude
-    model: claude-opus-4-8[1m]
-    effort: xhigh
+    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: codex
-    model: gpt-5.5
+    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

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/review.md

@@ -9,45 +9,55 @@ Roles:
 - Coder
 - Reviewer
 
-The caller supplies the initial intent or any specific context and relevant run results.
+The caller supplies:
 
-`review` examines committed work only.
-Every review round begins with a new or existing commit.
+- the original intent;
+- the review scope in the caller's own words;
+- optional relevant context and run results.
 
-At the first review round, Captain shall relay to Reviewer the complete initial review request in quotes (`>`).
+The caller's review scope is the baseline for every round, and each review-fix commit joins that scope as it lands, so every later round reviews the cumulative committed state.
+`review` examines committed work only.
+Captain shall take the evaluated repository revision from repository authority, not from either player's prose.
 
 At the first review round, Captain shall give Reviewer the following instruction:
 
 ```markdown
-A new review begins on the latest commit.
-Review the latest commit and resulting repository state; read the commit message first for its intent, scope, and rationale.
+A new review begins for the review scope.
+Keep to the original intent and follow what it asks.
+When the scope names commits, read each commit message for its context and rationale; otherwise use repository history and commit messages wherever they help establish that context.
 ```
 
 After every review-fix commit, Captain shall give Reviewer the following instruction:
 
 ```markdown
-Review the latest commit and resulting repository state; read the commit message first for its intent, scope, and rationale.
+A new review round begins for the review scope in the cumulative committed state, with particular attention to the latest review-fix commit.
+Keep to the original intent and follow what it asks.
+Read the latest review-fix commit's message and see Coder's feedback below.
 ```
 
 When Coder rejects every finding and makes no commit, Captain shall give Reviewer the following instruction:
 
 ```markdown
 No new commit was made because Coder rejected every finding.
+See Coder's feedback below.
 ```
 
-At the start of *every* review round, Captain shall relay to Reviewer any Coder feedback from the preceding round and any relevant run results, in quotes (`>`) after the instruction.
+At the start of *every* review round, Captain shall relay to Reviewer the original intent, the review scope and context, the exact repository revision being evaluated, any Coder feedback from the preceding round, and any relevant run results, in quotes (`>`) after the instruction.
 
 At the start of *every* review round, Captain shall append the following instruction to the end of the prompt:
 
 ```markdown
 Understand the full picture and think systematically about the underlying design.
-Continue to identify issues or improvements, if any (numbered; no duplication).
-For any rebuttal, accept or challenge it.
-Treat as settled, and do not raise again, any finding in this review rejected twice with reasoning.
+Continue to identify issues or improvements, if any, without duplication.
+Number the findings consistently across rounds.
 Flag only what materially affects correctness, behavior, or spec quality — not style, equally valid alternatives, or theoretical threats.
-For specs, flag stale, missing, over-specified, or under-specified ones.
+For specs, flag stale, missing, over-specified, or under-specified ones, if any.
 Avoid unnecessary complexity in code or tests, but flag any fundamental design flaw when leaving it would cost more in later patches than fixing it now.
 
+If an issue represents a class of defect, find every instance within the review scope worth fixing rather than surfacing one or two per round, which drags out the review.
+For any rebuttal, accept or challenge it.
+Treat as settled, and do not raise again, any finding in this review rejected twice with reasoning.
+
 Do not re-run tests or builds whose inputs have not changed since any previous reported run.
 Do not edit files or commit; report findings only.
 
@@ -55,26 +65,34 @@ Consult @specs/map.md for context if needed; verify it remains accurate.
 Consult @specs/meta.md for spec requirements if needed; verify affected specs follow it.
 ```
 
-When Reviewer raises or keeps any finding, Captain shall relay the Reviewer's findings and any relevant run results to Coder, in quotes (`>`), along with the following prompt:
+Finding numbers are references within this review only.
+No review transition shall depend on numbering or any fixed presentation format of either player's reply.
+
+When Reviewer raises or keeps any finding, Captain shall relay the original intent, the review scope and context, the exact repository revision being evaluated, the Reviewer's findings, and any relevant run results to Coder, in quotes (`>`), along with the following prompt:
 
 ```markdown
 For each review item, accept or reject it.
 Before deciding, understand the full picture and think systematically about the underlying design.
+Keep to the original intent and follow what it asks.
 Reject anything that is not essential or is not worth fixing now.
-If you accept an item, fix its root cause, including any fundamental design flaw - do not patch around it.
+If you accept an item, fix its root cause, including any fundamental design flaw — do not patch around it; if it represents a class of defect, find every instance within the review scope worth fixing rather than addressing one or two per round, which drags out the review.
 If you reject an item, give the reasoning and cite code or test output that supports it.
 Do not re-run tests or builds whose inputs have not changed since any previous reported run.
 
-If you accept any item, make minimal changes and commit them as one new commit; never amend the reviewed commit.
+If you accept any item, make minimal changes and add one new review-fix commit; never rewrite any existing commit.
 Follow @specs/packages/git.md.
 Make the commit message explain concisely what changed and why, including relevant verification.
-Coder is <coder-llm>; Reviewer is <reviewer-llm>; format model tokens in conventional human form.
+Identify every new commit you make.
+Coder is <coder-llm>; Reviewer is <reviewer-llm>.
 
 If you reject every item, change nothing and make no commit.
 Report every disposition, all relevant run results, and every rebuttal.
 ```
 
+Captain shall use the repository-effect receipt as the authoritative identity of any review-fix commit.
+
 When Coder makes a new commit or decides to reject all findings, Captain shall relay the above required context to Reviewer and begin the next review round.
 Reviewer shall read the context information and follow the corresponding instructions.
-Rounds continue until Reviewer raises no unsettled findings.
-`review` then returns the approved latest commit and the fact that no findings remain to its caller.
+Rounds continue until Reviewer affirmatively reports that the requested review is complete and no unsettled findings remain.
+A progress report, status update, or promise of a later result supports no review outcome.
+`review` then returns the exact repository revision at which the review scope was evaluated and the fact that no unsettled findings remain within that scope.