@sublang/playbook 17.2.0 → 17.4.0

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

@@ -226,6 +226,9 @@ function readDecisionReply(reply, options, selfPlaybookId, declaredActions) {
     const nonEmpty = (key) => typeof parsed[key] === 'string' && parsed[key].trim().length > 0
         ? undefined
         : `the ${action} selection's \`${key}\` must be a non-empty string`;
+    const attachments = parsed.attachmentIds;
+    if (attachments !== undefined && (!Array.isArray(attachments) || attachments.some((id) => typeof id !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(id)) || new Set(attachments).size !== attachments.length))
+        return { reason: 'attachmentIds must be unique supplied asset identifiers' };
     switch (action) {
         case 'respond': {
             const shape = requireKeys(['text']) ?? nonEmpty('text');
@@ -252,7 +255,7 @@ function readDecisionReply(reply, options, selfPlaybookId, declaredActions) {
         }
         case 'start':
         case 'switch': {
-            const shape = requireKeys(['playbookId', 'input']) ??
+            const shape = requireKeys(['playbookId', 'input'], ['attachmentIds']) ??
                 nonEmpty('playbookId') ??
                 nonEmpty('input');
             if (shape !== undefined)
@@ -273,6 +276,7 @@ function readDecisionReply(reply, options, selfPlaybookId, declaredActions) {
                     action,
                     playbookId,
                     input: parsed.input,
+                    ...(attachments === undefined ? {} : { attachmentIds: attachments }),
                 },
             };
         }
@@ -287,10 +291,10 @@ function readDecisionReply(reply, options, selfPlaybookId, declaredActions) {
             // A deliver selection carries no text payload: the host is
             // authoritative for the delivered text, so a carried `text` is
             // ignored and never delivered (CAPPLAY-9).
-            const shape = requireKeys([], ['text']);
+            const shape = requireKeys([], ['text', 'attachmentIds']);
             if (shape !== undefined)
                 return { reason: shape };
-            return { selection: { action } };
+            return { selection: { action, ...(attachments === undefined ? {} : { attachmentIds: attachments }) } };
         }
         case 'runtime': {
             const shape = requireKeys(['actionId']) ?? nonEmpty('actionId');

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

@@ -135,9 +135,10 @@ export type CaptainControllerSelection =
       readonly playbookId: string;
       /** Complete standalone request synthesized from the remembered Boss conversation. */
       readonly input: CaptainControllerInput;
+      readonly attachmentIds?: readonly string[];
     }
   | { readonly action: 'dismiss' | 'recover' }
-  | { readonly action: 'deliver' }
+  | { readonly action: 'deliver'; readonly attachmentIds?: readonly string[] }
   | { readonly action: 'runtime'; readonly actionId: string };
 
 /**
@@ -444,6 +445,8 @@ function readDecisionReply(
     typeof parsed[key] === 'string' && parsed[key].trim().length > 0
       ? undefined
       : `the ${action} selection's \`${key}\` must be a non-empty string`;
+  const attachments = parsed.attachmentIds;
+  if (attachments !== undefined && (!Array.isArray(attachments) || attachments.some((id) => typeof id !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(id)) || new Set(attachments).size !== attachments.length)) return { reason: 'attachmentIds must be unique supplied asset identifiers' };
   switch (action) {
     case 'respond': {
       const shape = requireKeys(['text']) ?? nonEmpty('text');
@@ -471,7 +474,7 @@ function readDecisionReply(
     case 'start':
     case 'switch': {
       const shape =
-        requireKeys(['playbookId', 'input']) ??
+        requireKeys(['playbookId', 'input'], ['attachmentIds']) ??
         nonEmpty('playbookId') ??
         nonEmpty('input');
       if (shape !== undefined) return { reason: shape };
@@ -493,6 +496,7 @@ function readDecisionReply(
           action,
           playbookId,
           input: parsed.input as string,
+          ...(attachments === undefined ? {} : { attachmentIds: attachments as string[] }),
         },
       };
     }
@@ -506,9 +510,9 @@ function readDecisionReply(
       // A deliver selection carries no text payload: the host is
       // authoritative for the delivered text, so a carried `text` is
       // ignored and never delivered (CAPPLAY-9).
-      const shape = requireKeys([], ['text']);
+      const shape = requireKeys([], ['text', 'attachmentIds']);
       if (shape !== undefined) return { reason: shape };
-      return { selection: { action } };
+      return { selection: { action, ...(attachments === undefined ? {} : { attachmentIds: attachments as string[] }) } };
     }
     case 'runtime': {
       const shape = requireKeys(['actionId']) ?? nonEmpty('actionId');

package/reference/sdlc/code.playbook/asset-types.d.ts

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+
+/** Cancellation only needs the standard synchronous abort check. */
+export interface AssetAbortSignal { throwIfAborted(): void; }
+export type AssetId = `sha256:${string}`;
+export interface SessionAssetRef {
+  readonly assetId: AssetId;
+  readonly byteLength: number;
+  readonly mimeType: string;
+  readonly name?: string;
+}
+export type AssetImport = (
+  | { readonly bytes: Uint8Array; readonly path?: never }
+  | { readonly path: string; readonly bytes?: never }
+) & { readonly mimeType: string; readonly name?: string; readonly signal?: AssetAbortSignal };
+export interface AssetFile {
+  readonly assetId: AssetId;
+  /** Relative filename within this owner's asset directory. */
+  readonly path: string;
+  readonly byteLength: number;
+  readonly metadataPath: string;
+}
+export interface AssetReader {
+  readonly reference: SessionAssetRef;
+  read(options: { readonly offset: number; readonly length: number; readonly signal?: AssetAbortSignal }): Promise<Uint8Array>;
+  close(): Promise<void>;
+}
+export interface SessionTurnInput {
+  readonly text: string;
+  readonly attachments?: readonly SessionAssetRef[];
+}

package/reference/sdlc/code.playbook/bin/launch-config.js

@@ -28,6 +28,7 @@ import {
   parseDocument as parseYamlDocument,
   stringify as stringifyYaml,
 } from "yaml";
+import { isSubagentModelSupported } from "@sublang/cligent";
 import { loadTmuxPlayConfig } from "@sublang/cligent/tmux-play";
 import {
   defaultCaptainSessionsDir,
@@ -379,12 +380,14 @@ export async function normalizeSelectedLaunchPlanDataOnly(
   const configuredAgents = new Map();
   for (const playerId of expectedMembers.playerIds) {
     assertPlayerId(playerId, `players.${playerId}`);
-    const agent = resolveAgent(playersCfg[playerId], `players.${playerId}`, [
-      "id",
-    ]);
+    const agent = resolveDelegationDefault(
+      resolveAgent(playersCfg[playerId], `players.${playerId}`, ["id"]),
+    );
     configuredAgents.set(playerId, agent);
   }
-  let captain = resolveAgent(top.captain, "captain", ["from", "options"]);
+  let captain = resolveDelegationDefault(
+    resolveAgent(top.captain, "captain", ["from", "options"]),
+  );
 
   const playbooksCfg = requireObject(top.playbooks, "playbooks");
   const tuningChecks = [];
@@ -443,7 +446,8 @@ export async function normalizeSelectedLaunchPlanDataOnly(
         binding.model !== undefined ||
         binding.effort !== undefined ||
         binding.fastMode !== undefined ||
-        binding.subagentModel !== undefined
+        binding.subagentModel !== undefined ||
+        binding.subagentEffort !== undefined
       ) {
         let checkId;
         do {
@@ -559,7 +563,8 @@ export async function normalizeSelectedLaunchPlanDataOnly(
                       ? {}
                       : { fastMode: agent.fastMode }
                     : { fastMode: binding.fastMode }),
-                  ...effectiveSubagentModel(binding, agent),
+                  ...effectiveOptionalTuning(binding, agent, "subagentModel"),
+                  ...effectiveOptionalTuning(binding, agent, "subagentEffort"),
                 },
               ];
             }),
@@ -689,9 +694,9 @@ export async function normalizeLaunchPlan(
   const configuredAgents = new Map();
   for (const playerId of allPlayerIds) {
     assertPlayerId(playerId, `players.${playerId}`);
-    const agent = resolveAgent(playersCfg[playerId], `players.${playerId}`, [
-      "id",
-    ]);
+    const agent = resolveDelegationDefault(
+      resolveAgent(playersCfg[playerId], `players.${playerId}`, ["id"]),
+    );
     if (
       typeof agent.adapter !== "string" ||
       agent.adapter.trim().length === 0
@@ -710,7 +715,9 @@ export async function normalizeLaunchPlan(
     throw new Error("playbooks keys must be canonical trimmed nonblank ids");
   }
 
-  let captain = resolveAgent(top.captain, "captain", ["from", "options"]);
+  let captain = resolveDelegationDefault(
+    resolveAgent(top.captain, "captain", ["from", "options"]),
+  );
   if (
     typeof captain.adapter !== "string" ||
     captain.adapter.trim().length === 0
@@ -790,7 +797,8 @@ export async function normalizeLaunchPlan(
         binding.model !== undefined ||
         binding.effort !== undefined ||
         binding.fastMode !== undefined ||
-        binding.subagentModel !== undefined
+        binding.subagentModel !== undefined ||
+        binding.subagentEffort !== undefined
       ) {
         let checkId;
         do {
@@ -1002,7 +1010,8 @@ export async function normalizeLaunchPlan(
                 ? {}
                 : { fastMode: agent.fastMode }
               : { fastMode: binding.fastMode }),
-            ...effectiveSubagentModel(binding, agent),
+            ...effectiveOptionalTuning(binding, agent, "subagentModel"),
+            ...effectiveOptionalTuning(binding, agent, "subagentEffort"),
           },
         ];
       }),
@@ -1488,7 +1497,8 @@ function migrateUserConfigIfRetired(userConfigPath, onNotice) {
     throw new Error(
       `cannot migrate the retired profiles config at ${userConfigPath}: ` +
         `${errorMessage(error)} — edit it by hand: each agent takes its own ` +
-        "adapter, model, effort, fast mode, subagent model, and permissions",
+        "adapter, model, effort, fast mode, subagent model, subagent effort, " +
+        "and permissions",
     );
   }
   if (migrated === undefined) return;
@@ -1624,7 +1634,8 @@ function assertNoRetiredProfiles(top, configPath) {
     throw new Error(
       `top-level "profiles" was removed${where}: write each agent's settings ` +
         "inline under captain and each top-level players.<player-id> " +
-        "(adapter, model, effort, fast mode, subagent model, permissions)",
+        "(adapter, model, effort, fast mode, subagent model, subagent effort, " +
+        "permissions)",
     );
   }
   const legacyPath = findLegacyPlayersPath(top);
@@ -1640,7 +1651,7 @@ function assertNoRetiredProfiles(top, configPath) {
       throw new Error(
         `${path}.profile was removed${where}: write the agent's settings ` +
           "inline in that block (adapter, model, effort, fast mode, " +
-          "subagent model, permissions)",
+          "subagent model, subagent effort, permissions)",
       );
     }
   }
@@ -2040,13 +2051,20 @@ function resolveRoleBinding(value, path) {
   const block = requireObject(value, path);
   const unknown = Object.keys(block).filter(
     (key) =>
-      !["player", "model", "effort", "fastMode", "subagentModel"].includes(key),
+      ![
+        "player",
+        "model",
+        "effort",
+        "fastMode",
+        "subagentModel",
+        "subagentEffort",
+      ].includes(key),
   );
   if (unknown.length > 0) {
     throw new Error(`${path} has unknown ${formatKeyList(unknown)}`);
   }
   assertPlayerId(block.player, `${path}.player`);
-  for (const field of ["model", "effort", "subagentModel"]) {
+  for (const field of ["model", "effort", "subagentModel", "subagentEffort"]) {
     if (
       block[field] !== undefined &&
       block[field] !== false &&
@@ -2071,19 +2089,41 @@ function resolveRoleBinding(value, path) {
     ...(block.subagentModel === undefined
       ? {}
       : { subagentModel: block.subagentModel }),
+    ...(block.subagentEffort === undefined
+      ? {}
+      : { subagentEffort: block.subagentEffort }),
   };
 }
 
-// A binding's subagent model overrides the player's; `false` selects the
-// provider default, which a complete call expresses by omission.
-function effectiveSubagentModel(binding, agent) {
-  if (binding.subagentModel === false) return {};
-  if (binding.subagentModel !== undefined) {
-    return { subagentModel: binding.subagentModel };
+// A binding's subagent model or subagent effort overrides the player's;
+// `false` selects the provider default, which a complete call expresses by
+// omission (for the effort: the agent chooses per task).
+function effectiveOptionalTuning(binding, agent, field) {
+  if (binding[field] === false) return {};
+  if (binding[field] !== undefined) return { [field]: binding[field] };
+  return agent[field] === undefined ? {} : { [field]: agent[field] };
+}
+
+// DR-076: an agent whose adapter serves a subagent model delegates by
+// default. Resolved on the launcher's detached copy of a Captain or player
+// block — never the user's file — before cligent normalization, so cligent
+// validates a subagent effort against the resolved model, and both front
+// ends and the headless run share the result. A block's `false` opts out:
+// nothing is sent and no delegation directive is composed.
+function resolveDelegationDefault(agent) {
+  if (!isObject(agent)) return agent;
+  if (agent.subagentModel === false) {
+    const { subagentModel: _off, ...rest } = agent;
+    return rest;
   }
-  return agent.subagentModel === undefined
-    ? {}
-    : { subagentModel: agent.subagentModel };
+  if (
+    agent.subagentModel === undefined &&
+    typeof agent.adapter === "string" &&
+    isSubagentModelSupported(agent.adapter)
+  ) {
+    return { ...agent, subagentModel: "inherit" };
+  }
+  return agent;
 }
 
 function applyTuningOverrides(agent, binding) {
@@ -2096,9 +2136,9 @@ function applyTuningOverrides(agent, binding) {
     else effective.effort = binding.effort;
   }
   if (binding.fastMode !== undefined) effective.fastMode = binding.fastMode;
-  if (binding.subagentModel === false) delete effective.subagentModel;
-  else if (binding.subagentModel !== undefined) {
-    effective.subagentModel = binding.subagentModel;
+  for (const field of ["subagentModel", "subagentEffort"]) {
+    if (binding[field] === false) delete effective[field];
+    else if (binding[field] !== undefined) effective[field] = binding[field];
   }
   return effective;
 }
@@ -2109,6 +2149,7 @@ function sessionAgentFromHostAgent(agent, path) {
   }
   return {
     adapter: agent.adapter,
+    ...(agent.browser === undefined ? {} : { browser: fastModeSelection(agent.browser, `${path}.browser`) }),
     model: tuningSelection(agent.model, `${path}.model`),
     effort: tuningSelection(agent.effort, `${path}.effort`),
     ...(agent.fastMode === undefined
@@ -2117,11 +2158,19 @@ function sessionAgentFromHostAgent(agent, path) {
     ...(agent.subagentModel === undefined
       ? {}
       : {
-          subagentModel: subagentModelSelection(
+          subagentModel: nonblankSelection(
             agent.subagentModel,
             `${path}.subagentModel`,
           ),
         }),
+    ...(agent.subagentEffort === undefined
+      ? {}
+      : {
+          subagentEffort: nonblankSelection(
+            agent.subagentEffort,
+            `${path}.subagentEffort`,
+          ),
+        }),
     ...(agent.instruction === undefined
       ? {}
       : { instruction: agent.instruction }),
@@ -2138,6 +2187,7 @@ export function projectHostAgent(agent, path = "agent") {
   const normalized = cloneJson(agent, path);
   return {
     adapter: normalized.adapter,
+    ...(normalized.browser === undefined ? {} : { browser: fastModeSelection(normalized.browser, `${path}.browser`) }),
     ...(normalized.model?.kind === "value"
       ? { model: normalized.model.value }
       : {}),
@@ -2150,6 +2200,9 @@ export function projectHostAgent(agent, path = "agent") {
     ...(normalized.subagentModel === undefined
       ? {}
       : { subagentModel: normalized.subagentModel }),
+    ...(normalized.subagentEffort === undefined
+      ? {}
+      : { subagentEffort: normalized.subagentEffort }),
     ...(normalized.instruction === undefined
       ? {}
       : { instruction: normalized.instruction }),
@@ -2166,7 +2219,7 @@ function fastModeSelection(value, path) {
   return value;
 }
 
-function subagentModelSelection(value, path) {
+function nonblankSelection(value, path) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new Error(`${path} must be a nonblank string`);
   }

package/reference/sdlc/code.playbook/bin/playbook.js

@@ -967,9 +967,11 @@ function helpText({
     "    adapter shorthand (claude, codex) or an inline agent block",
     "  - bind every playbooks.<id>.roles.<role> explicitly to a player id;",
     "    a scalar names the id, while { player, model?, effort?, fastMode?,",
-    "    subagentModel? } may retune one role;",
-    "    false selects provider-default model/effort/subagentModel,",
-    "    while fastMode false is a literal disabled request",
+    "    subagentModel?, subagentEffort? } may retune one role;",
+    "    false selects provider-default model/effort/subagentModel/",
+    "    subagentEffort, while fastMode false is a literal disabled request",
+    "  - a Claude agent delegates by default: subagentModel resolves to",
+    "    inherit (its own model) unless the block sets false",
     "  - reusing one id deliberately shares that provider conversation;",
     "    distinct ids stay isolated even when their agent blocks are equal",
     "  - the launcher injects captain.from and retains referenced player ids",

package/reference/sdlc/code.playbook/bin/portable-codec.js

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 
 import { createHash } from 'node:crypto';
+import { validateAssetRef } from '../session-assets.js';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import {
@@ -16,7 +17,7 @@ export const EMPTY_REPLAY_SHA256 = createHash('sha256').digest('hex');
 export const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
 const COMMON = ['schemaVersion', 'kind', 'sessionId', 'cwd', 'createdAt', 'updatedAt', 'state', 'replay', 'contextSeq'];
 const RECOVERY = ['structuralProjection', 'lastAppliedExecutionProjection', 'snapshot', 'effectLedger', 'unresolvedEffects'];
-const OPTIONAL = ['retainedGenerations', 'settledAbandonment'];
+const OPTIONAL = ['retainedGenerations', 'settledAbandonment', 'assets'];
 const HEX = /^[0-9a-f]{64}$/;
 const clone = (value) => structuredClone(value);
 const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -44,11 +45,17 @@ export function validateReplayCheckpoint(value) {
 export function validateSessionManifest(value) {
   if (!object(value) || value.schemaVersion !== 7) throw new Error(`unsupported session manifest schema ${value?.schemaVersion}`);
   const history = value.state === 'history-only';
-  exact(value, [...COMMON, ...(history ? ['reason'] : RECOVERY), ...(value.state === 'uncertain' ? ['uncertain'] : [])], history ? [] : OPTIONAL);
+  exact(value, [...COMMON, ...(history ? ['reason'] : RECOVERY), ...(value.state === 'uncertain' ? ['uncertain'] : [])], history ? ['assets'] : OPTIONAL);
   if (value.kind !== 'captain-session' || !SESSION_ID_PATTERN.test(value.sessionId) || !isRecordedAbsolutePath(value.cwd)) throw new Error('invalid session manifest identity');
   iso(value.createdAt); iso(value.updatedAt);
   if (Date.parse(value.updatedAt) < Date.parse(value.createdAt)) throw new Error('session update precedes creation');
   validateReplayCheckpoint(value.replay);
+  if (value.assets !== undefined) {
+    exact(value.assets, ['version', 'entries']);
+    if (value.assets.version !== 1 || !Array.isArray(value.assets.entries)) throw new Error('unsupported session asset manifest');
+    const ids = new Set();
+    for (const item of value.assets.entries) { const reference = validateAssetRef(item); if (ids.has(reference.assetId)) throw new Error('duplicate session asset reference'); ids.add(reference.assetId); }
+  }
   if (!(history && value.contextSeq === null) && (!Number.isSafeInteger(value.contextSeq) || value.contextSeq <= 0 || value.contextSeq > value.replay.seq)) throw new Error('invalid session context reference');
   if (history) {
     if (!nonempty(value.reason)) throw new Error('history-only session needs a reason');
@@ -60,7 +67,7 @@ export function validateSessionManifest(value) {
   return clone(value);
 }
 function recoveryFromManifestUnchecked(value) {
-  const { replay, contextSeq, ...recovery } = value;
+  const { replay, contextSeq, assets, ...recovery } = value;
   return { ...recovery, schemaVersion: 6 };
 }
 export function recoveryFromManifest(value) {
@@ -68,9 +75,9 @@ export function recoveryFromManifest(value) {
   if (manifest.state === 'history-only') throw new Error(manifest.reason);
   return validateCaptainSessionRecord(recoveryFromManifestUnchecked(manifest));
 }
-export function manifestFromRecovery(value, replay, contextSeq) {
+export function manifestFromRecovery(value, replay, contextSeq, assets) {
   const recovery = projectRecovery(validateCaptainSessionRecord(value));
-  return validateSessionManifest({ ...recovery, schemaVersion: 7, replay, contextSeq });
+  return validateSessionManifest({ ...recovery, schemaVersion: 7, replay, contextSeq, ...(assets === undefined ? {} : { assets }) });
 }
 export function projectRecovery(value) {
   const source = clone(value);

package/reference/sdlc/code.playbook/bin/run.js

@@ -7,6 +7,8 @@
 // presenter; it does not construct a registry runtime or PlaybookPorts itself.
 
 import { randomUUID } from "node:crypto";
+import { workerReportExcerpt, workerRecoveryReportBlock } from "../worker-evidence.js";
+import { createSessionMediaProjector } from "./session-media.js";
 import { attachSessionHints, validateSessionContext } from "./portable-codec.js";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
@@ -995,6 +997,13 @@ export function restoreInterruptedProgress(record, ledger) {
       : `Captain preparation for ${name}: ${step.result.summary}`;
     return `${name} ${step.kind} call: ${step.result === undefined ? 'started; no result was saved' : step.result?.status === undefined ? 'result saved' : `returned ${step.result.status}`}.`;
   });
+  const workerReports = changedBoundaries.flatMap((boundary) => {
+    const completedStep = steps.find((step) => step.kind === 'player' &&
+      step.workerEvidence?.boundaryId === boundary.boundaryId);
+    if (!completedStep) return [];
+    const report = workerReportExcerpt(boundary, completedStep.workerEvidence.playerId, completedStep.result.guard);
+    return report === undefined ? [] : [report];
+  });
   const completedRoots = steps.filter((step) => step.kind === 'completion' && step.result.retention !== 'keep').map((step) => ({ kind: 'clear', rootPlaybookId: step.playbookId }));
   const report = {
     retentionUpdates: completedRoots,
@@ -1008,7 +1017,7 @@ export function restoreInterruptedProgress(record, ledger) {
         ? completion && !saved.frames?.length
           ? 'The completed run is restored; no work was repeated.'
           : 'The run stopped. Its saved position is restored; no work was repeated. Choose how to continue. Before repeating unfinished work, confirm that the earlier worker has stopped and check any outside actions it may have taken.'
-        : 'The exact stopping point was not saved. Files and repository evidence are preserved; no work was repeated. Check the saved work and stop any earlier worker before starting another attempt.', ...facts].join('\n\n'),
+        : 'The exact stopping point was not saved. Files and repository evidence are preserved; no work was repeated. Check the saved work and stop any earlier worker before starting another attempt.', ...facts, ...(workerReports.length ? [workerRecoveryReportBlock(workerReports)] : [])].join('\n\n'),
   };
   if (noWork) return { snapshot: base, report };
   if (saved) {
@@ -1068,6 +1077,7 @@ export async function createCaptainSessionHost({
   signal,
   graphs = [],
   initialVisible = [],
+  approvalHandler,
 }) {
   if (restoreSnapshot !== undefined) await sessionLease.assertContinuable({ cwd, executionProjection: config });
   const hostCapabilities = await createRepositoryEffectCapabilities({
@@ -1115,23 +1125,30 @@ export async function createCaptainSessionHost({
   if (sourceSnapshot !== undefined && !interrupted && typeof sessionLease.consumeHints === "function") {
     sourceSnapshot = attachSessionHints(sourceSnapshot, await sessionLease.consumeHints());
   }
+  let presentationAttachments = [];
+  const mediaProjector = createSessionMediaProjector({ lease: sessionLease, onEvidence: (asset, origin) => shell.recordMediaEvidence(asset, origin.runtimeSessionId) });
   const bufferedRecords = [];
   let presentationReady = false;
   const presentationTurnOffset = restoreSnapshot?.sequences.turn ?? 0;
+  const approvals = createHostApprovalScope(approvalHandler, presentationTurnOffset);
   const forwardRecord = async (record) => {
+    if (record.type === 'turn_started' && presentationAttachments.length) record = { ...record, turn: { ...record.turn, attachments: presentationAttachments } };
     const projected = presentationTurnOffset > 0 && typeof record.turnId === "number"
       ? { ...record, turnId: record.turnId + presentationTurnOffset, ...(record.type === "turn_started" ? { turn: { ...record.turn, id: record.turn.id + presentationTurnOffset } } : {}) }
       : record;
-    for (const observer of observers ?? []) await observer.onRecord?.(projected);
+    for (const value of await mediaProjector.project(projected)) for (const observer of observers ?? []) await observer.onRecord?.(value);
   };
   const bufferedObservers = [{ async onRecord(record) {
     if (!presentationReady) bufferedRecords.push(record);
     else await forwardRecord(record);
   } }];
   const shell = createPlaybookCaptainShell(captainOptionsFromConfig(config), {
+    onTurnAttachments: (references) => { presentationAttachments = references; },
+    beginPreparationMedia: (runtimeSessionId) => mediaProjector.beginPreparation(runtimeSessionId),
     abortPreparation: (reason) => host?.abortActiveTurn(typeof reason === 'string' ? reason : 'Captain preparation exceeded its 150-second limit'),
     loadModule,
     hostCapabilities,
+    ...(typeof sessionLease.resolveAttachments === 'function' ? { resolveAttachments: (references, signal) => sessionLease.resolveAttachments(references, { signal }) } : {}),
     ...(typeof sessionLease.recordProgress === 'function' ? {
       recordProgress: (change) => sessionLease.recordProgress(change),
     } : {}),
@@ -1166,6 +1183,7 @@ export async function createCaptainSessionHost({
       })),
       cwd,
       observers: bufferedObservers,
+      ...(approvals.handler ? { approvalHandler: approvals.handler } : {}),
       ...(signal ? { signal } : {}),
       ...(adapterImports ? { adapterImports } : {}),
     });
@@ -1193,9 +1211,13 @@ export async function createCaptainSessionHost({
     }
     presentationReady = true;
     for (const record of bufferedRecords) await forwardRecord(record);
-    if (interruptedReport) shell.selectInterruptedReport(interrupted.uncertain.input, interruptedReport);
-    return { shell, host, snapshot, reconcileRepositoryEffects, getInterruptedSettlement: (attemptId) => attemptId !== undefined && interruptedSettlement?.attemptId === attemptId ? interruptedSettlement.record : undefined };
+    if (interruptedReport) {
+      shell.setTurnAttachments(interrupted.uncertain.attachments ?? []);
+      shell.selectInterruptedReport(interrupted.uncertain.input, interruptedReport);
+    }
+    return { shell, host, snapshot, reconcileRepositoryEffects, cancelPendingApprovals: approvals.close, getInterruptedSettlement: (attemptId) => attemptId !== undefined && interruptedSettlement?.attemptId === attemptId ? interruptedSettlement.record : undefined };
   } catch (error) {
+    approvals.close();
     let cleanupError;
     try {
       if (host !== undefined) await host.dispose();
@@ -1213,6 +1235,48 @@ export async function createCaptainSessionHost({
   }
 }
 
+// Callback liveness belongs to the host, independently of durable turn state.
+// Closing this scope denies waits without cancelling ordinary graceful work.
+function createHostApprovalScope(handler, turnOffset) {
+  const lifetime = new AbortController();
+  return {
+    close: () => lifetime.abort('session host closing'),
+    handler: typeof handler !== 'function' ? undefined : (envelope, { signal }) => {
+      if (lifetime.signal.aborted || signal.aborted) return Promise.resolve('deny');
+      const controller = new AbortController();
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (decision) => {
+          if (settled) return;
+          settled = true;
+          signal.removeEventListener('abort', cancel);
+          lifetime.signal.removeEventListener('abort', cancel);
+          if (!envelope.request.choices.includes(decision)) controller.abort('Invalid approval decision');
+          resolve(decision);
+        };
+        const fail = (error) => {
+          if (settled) return;
+          settled = true;
+          signal.removeEventListener('abort', cancel);
+          lifetime.signal.removeEventListener('abort', cancel);
+          controller.abort(error);
+          reject(error);
+        };
+        const cancel = () => {
+          controller.abort(signal.aborted ? signal.reason : lifetime.signal.reason);
+          finish('deny');
+        };
+        signal.addEventListener('abort', cancel, { once: true });
+        lifetime.signal.addEventListener('abort', cancel, { once: true });
+        Promise.resolve().then(() => {
+          if (settled) return 'deny';
+          return handler({ ...envelope, turnId: envelope.turnId + turnOffset }, { signal: controller.signal });
+        }).then(finish, fail);
+      });
+    },
+  };
+}
+
 // PBCLI-55: both presentations install one authoritative retention map at the
 // same post-shell, pre-turn boundary. Fresh-session guarded initialization
 // publishes either the intentional empty boundary or the transferred map.
@@ -1367,11 +1431,14 @@ export async function validateFrozenExecutionConfig(
   return config;
 }
 
-// Fast mode and the subagent model are adapter-scoped tuning (DR-075): a
-// frozen record re-validates each present value against its adapter.
+// Fast mode, the subagent model and the subagent effort are adapter-scoped
+// tuning (DR-075, DR-076): a frozen record re-validates each present value
+// against its adapter. Cligent serves the subagent effort exactly where it
+// serves a subagent model, so one capability assertion covers both.
 const FROZEN_ADAPTER_SCOPED_TUNING = [
   ["fastMode", assertFastModeSupported],
   ["subagentModel", assertSubagentModelSupported],
+  ["subagentEffort", assertSubagentModelSupported],
 ];
 
 function assertFrozenTuningSupported(config) {
@@ -1887,7 +1954,7 @@ function runHelpText(userConfigPath) {
     "working directory and reports when it uses the global newest fallback.",
     "An ordinary continued run restores that stored structure and working",
     "directory, then reads current config and overlays for model, effort,",
-    "fast mode, and subagent model.",
+    "fast mode, subagent model, and subagent effort.",
     "Uncertain retry only restores and reports; later work uses current settings.",
     "",
     "Options:",