@sublang/playbook 3.1.0 → 5.0.0

package/reference/sdlc/code.playbook/bin/adapter-sdk.js

@@ -0,0 +1,247 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+
+// PBCLI-39/40 (DR-027): the agent runtimes are cligent's to know. This
+// module keeps only cligent module-path knowledge — which subpath exports
+// which adapter class — and derives every runtime identity, supported
+// floor, and repair from cligent's shipped descriptor, so a cligent
+// upgrade alone moves the compatibility policy. A runtime's absence or
+// staleness has to be a named gate failure rather than a mid-turn adapter
+// error, which is what this probe provides for both the interactive
+// launcher and `run`.
+
+import { readFileSync } from 'node:fs';
+import { sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { classifyRuntime } from '@sublang/cligent';
+import { AGENT_RUNTIME_TARGETS } from '@sublang/cligent/runtime-targets';
+
+// PBCLI-39: adapter shorthand -> the cligent module that constructs it.
+// This is API-shape knowledge, not version knowledge; versions, floors,
+// and repairs come from the descriptor. Adapters absent from cligent's
+// descriptor are excluded from the gate and stay covered by PBCLI-12's
+// unknown-adapter warning.
+export const ADAPTER_MODULES = {
+  claude: {
+    module: '@sublang/cligent/adapters/claude-code',
+    export: 'ClaudeCodeAdapter',
+  },
+  codex: {
+    module: '@sublang/cligent/adapters/codex',
+    export: 'CodexAdapter',
+  },
+  // DR-027 ends gemini's exemption: its missing-SDK rationale was true but
+  // incomplete — the CLI can be absent or below cligent's floor, and the
+  // descriptor names both.
+  gemini: {
+    module: '@sublang/cligent/adapters/gemini',
+    export: 'GeminiAdapter',
+  },
+  kimi: {
+    module: '@sublang/cligent/adapters/kimi',
+    export: 'KimiAdapter',
+  },
+  opencode: {
+    module: '@sublang/cligent/adapters/opencode',
+    export: 'OpenCodeAdapter',
+  },
+};
+
+// PBCLI-39: probe through cligent's own adapter rather than by resolution.
+// `isAvailable()` performs the same load the adapter performs at run time,
+// from cligent's installed module scope — and since cligent enforces its
+// version floors inside that same loader, a passing probe cannot disagree
+// with a failing run, for absence and for staleness alike.
+export async function probeAdapterSdk(adapter) {
+  const entry = ADAPTER_MODULES[adapter];
+  if (entry === undefined) return true;
+  try {
+    const AdapterClass = (await import(entry.module))[entry.export];
+    return await new AdapterClass().isAvailable();
+  } catch {
+    // An adapter module that cannot be imported at all is unavailable,
+    // not an internal error — the remedy is the same install line.
+    return false;
+  }
+}
+
+// The descriptor rows for one adapter shorthand, in declaration order.
+function runtimeTargetsFor(adapter) {
+  return adapter in ADAPTER_MODULES
+    ? (AGENT_RUNTIME_TARGETS[adapter] ?? [])
+    : [];
+}
+
+// PBCLI-39: probe each distinct gated adapter at most once, and classify
+// an unavailable adapter's runtimes through cligent's structured verdict.
+// Only the runtimes at fault are reported: an `opencode` whose CLI is
+// present and in range names the SDK alone, because the two halves have
+// different repairs and naming a healthy one sends the user to install
+// what is already there.
+export async function checkAdapterSdks(
+  adapters,
+  probe = probeAdapterSdk,
+  classify = classifyRuntime,
+) {
+  const known = [...new Set(adapters)].filter(
+    (a) => runtimeTargetsFor(a).length > 0,
+  );
+  const results = await Promise.all(known.map((a) => probe(a)));
+  const unusableAdapters = [];
+  known.forEach((adapter, i) => {
+    if (results[i]) return;
+    const verdicts = runtimeTargetsFor(adapter).map((target) =>
+      classify(target, false),
+    );
+    const unsupported = verdicts.filter((v) => v.state === 'unsupported');
+    const missing = verdicts.filter(
+      (v) => v.state === 'missing' && v.installed === undefined,
+    );
+    // When neither explains the failure (e.g. the cligent module itself
+    // failed to import), fall back to every runtime so the gate still
+    // blocks with a usable remedy.
+    const culprits =
+      unsupported.length > 0 || missing.length > 0
+        ? [...unsupported, ...missing]
+        : verdicts;
+    unusableAdapters.push({ adapter, verdicts: culprits });
+  });
+  return { unusableAdapters };
+}
+
+// PBCLI-40: a run under `npx` / `npm exec` lives in npm's ephemeral cache
+// tree. No `npm install` invocation reaches that tree — a global SDK install
+// is not on its directory-ancestor walk — so the only honest remedy is to
+// re-run with each SDK named as a sibling package of the same exec.
+export function detectEphemeralNpxInstall(moduleUrl = import.meta.url) {
+  return fileURLToPath(moduleUrl).split(sep).includes('_npx');
+}
+
+// PBCLI-39: the pinned repair specifiers of every descriptor-backed peer
+// SDK in a lineup, deduplicated in descriptor order. The ephemeral re-run
+// must be built from this full set: a fresh exec tree starts empty, so a
+// re-run named after only the currently missing SDKs drops the ones this
+// tree does have and alternates between vendors forever. Pinned specs also
+// mean the re-run installs versions the gate accepts.
+export function mappedSdksFor(adapters) {
+  const distinct = new Set(adapters);
+  const specs = [];
+  for (const [adapter, targets] of Object.entries(AGENT_RUNTIME_TARGETS)) {
+    if (!distinct.has(adapter) || !(adapter in ADAPTER_MODULES)) continue;
+    for (const target of targets) {
+      if (target.kind === 'peer' && !specs.includes(target.repairSpec)) {
+        specs.push(target.repairSpec);
+      }
+    }
+  }
+  return specs;
+}
+
+// Minimal POSIX quoting so a preserved argument survives copy-paste; matches
+// cligent's shared shellQuote. tmux-play is POSIX-only, so no cmd.exe form.
+export function shellQuote(value) {
+  if (/^[a-zA-Z0-9_./:=@-]+$/.test(value)) {
+    return value;
+  }
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+
+// The running package's own spec, so the re-run reinstalls exactly this
+// version rather than whatever dist-tag `npx` would resolve today.
+function selfPackageSpec() {
+  try {
+    const manifest = JSON.parse(
+      readFileSync(new URL('../../../../package.json', import.meta.url), 'utf8'),
+    );
+    if (typeof manifest.name === 'string' && typeof manifest.version === 'string') {
+      return `${manifest.name}@${manifest.version}`;
+    }
+  } catch {
+    // Fall through to the unpinned name.
+  }
+  return '@sublang/playbook';
+}
+
+// One clause describing a runtime verdict. `unsupported` carries versions,
+// because "not installed" for a runtime that is installed sends the user
+// hunting for something already present (PBCLI-40).
+function describeVerdict(verdict) {
+  const named = verdict.target.bundles ?? verdict.target.package;
+  if (verdict.state === 'unsupported') {
+    return `${named} ${verdict.installed} installed, >=${verdict.target.supportedFrom} required`;
+  }
+  return `${named} not installed`;
+}
+
+// PBCLI-40: name every unusable adapter with its per-runtime verdicts and,
+// for each runtime at fault, the exact pinned command that supplies it.
+// External CLIs are found through PATH, which an exec tree inherits, so
+// their global install lines hold in both cases.
+//
+// options.requiredSdks: the full mapped-spec set of the lineup (see
+// mappedSdksFor) — the ephemeral re-run is built from it, not from the
+// missing subset. options.invocation: the original CLI arguments, preserved
+// on the re-run so the printed command is executable as printed.
+export function adapterSdkFailureLines(unusableAdapters, options = {}) {
+  if (unusableAdapters.length === 0) return [];
+  const ephemeralNpx = options.ephemeralNpx ?? detectEphemeralNpxInstall();
+  const lines = [
+    `Adapter runtimes not usable: ${unusableAdapters
+      .map(
+        ({ adapter, verdicts }) =>
+          `${adapter} (${verdicts.map(describeVerdict).join('; ')})`,
+      )
+      .join(', ')}`,
+  ];
+  // External CLIs are found through PATH, which persists across exec trees
+  // and installed prefixes alike, so their pinned global installs are keyed
+  // to the runtimes actually at fault and hold in both branches. A CLI's
+  // one-time steps (e.g. a login) follow its install.
+  const cliInstalls = unusableAdapters.flatMap(({ verdicts }) =>
+    verdicts
+      .filter((v) => v.target.kind === 'cli')
+      .flatMap((v) => [`npm install -g ${v.repair.spec}`, ...v.repair.steps]),
+  );
+  const peerInstalls = unusableAdapters.flatMap(({ verdicts }) =>
+    verdicts
+      .filter((v) => v.target.kind === 'peer')
+      .map((v) => `npm install -g ${v.repair.spec}`),
+  );
+  if (ephemeralNpx) {
+    const sdks =
+      options.requiredSdks ??
+      unusableAdapters.flatMap(({ verdicts }) =>
+        verdicts
+          .filter((v) => v.target.kind === 'peer')
+          .map((v) => v.repair.spec),
+      );
+    const args = (options.invocation ?? [])
+      .map((arg) => ` ${shellQuote(arg)}`)
+      .join('');
+    lines.push(
+      '  This npx / npm exec run is ephemeral: no npm install reaches its tree.',
+    );
+    if (cliInstalls.length > 0) {
+      // Prerequisites first: the re-run probes the CLI again, so following
+      // the output top-to-bottom must install it before re-running.
+      lines.push(
+        '  First install the required CLI (it persists on PATH):',
+        ...cliInstalls.map((command) => `    ${command}`),
+      );
+    }
+    lines.push(
+      `  ${cliInstalls.length > 0 ? 'Then re-run' : 'Re-run'} with every SDK your config needs named alongside the package:`,
+      `    npx -y -p ${selfPackageSpec()}${sdks
+        .map((sdk) => ` -p ${sdk}`)
+        .join('')} playbook${args}`,
+    );
+  } else {
+    lines.push(
+      ...peerInstalls.map((command) => `  ${command}`),
+      ...cliInstalls.map((command) => `  ${command}`),
+    );
+  }
+  lines.push('');
+  return lines;
+}

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

@@ -22,6 +22,12 @@ import {
   parseDocument as parseYamlDocument,
   stringify as stringifyYaml,
 } from 'yaml';
+import {
+  adapterSdkFailureLines,
+  checkAdapterSdks,
+  mappedSdksFor,
+  probeAdapterSdk,
+} from './adapter-sdk.js';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const templatePath = resolve(here, '..', 'playbook.config.template.yaml');
@@ -68,6 +74,16 @@ export async function runPlaybookCli(options = {}) {
       ...(options.readStdin ? { readStdin: options.readStdin } : {}),
       ...(options.sessionsDir ? { sessionsDir: options.sessionsDir } : {}),
       ...(options.hostRoots ? { hostRoots: options.hostRoots } : {}),
+      // PBCLI-39: the run path gates on SDK availability too.
+      ...(options.probeAdapterSdk
+        ? { probeAdapterSdk: options.probeAdapterSdk }
+        : {}),
+      ...(options.classifyRuntime
+        ? { classifyRuntime: options.classifyRuntime }
+        : {}),
+      ...(options.ephemeralNpx !== undefined
+        ? { ephemeralNpx: options.ephemeralNpx }
+        : {}),
     });
   }
 
@@ -144,19 +160,37 @@ export async function runPlaybookCli(options = {}) {
   }
 
   // PBCLI-12: readiness reads the adapters of the composed config.
-  const readiness = checkReadiness(
-    adaptersFromComposedConfig(composed.config),
-    env,
-    home,
+  const declaredAdapters = adaptersFromComposedConfig(composed.config);
+  const readiness = checkReadiness(declaredAdapters, env, home);
+  // PBCLI-39/40: SDK availability is an independent check with its own
+  // remedy — a credential and an SDK can be missing at once, and reporting
+  // only the first would send the user round the loop twice.
+  const { unusableAdapters } = await checkAdapterSdks(
+    declaredAdapters,
+    options.probeAdapterSdk ?? probeAdapterSdk,
+    ...(options.classifyRuntime ? [options.classifyRuntime] : []),
   );
   for (const adapter of readiness.unknownAdapters) {
     stderr.write(
       `playbook: warning: no readiness check for adapter "${adapter}"\n`,
     );
   }
-  if (readiness.failingAdapters.length > 0) {
+  if (readiness.failingAdapters.length > 0 || unusableAdapters.length > 0) {
     stderr.write(
-      helpText({ userConfigPath, failingAdapters: readiness.failingAdapters }),
+      helpText({
+        userConfigPath,
+        failingAdapters: readiness.failingAdapters,
+        // PBCLI-40: the ephemeral re-run must carry the lineup's full mapped
+        // SDK set and the user's own arguments, so it completes in one hop
+        // and is executable exactly as printed.
+        sdkFailureLines: adapterSdkFailureLines(unusableAdapters, {
+          requiredSdks: mappedSdksFor(declaredAdapters),
+          invocation: argv,
+          ...(options.ephemeralNpx !== undefined
+            ? { ephemeralNpx: options.ephemeralNpx }
+            : {}),
+        }),
+      }),
     );
     return { code: READINESS_FAILURE_EXIT_CODE };
   }
@@ -678,12 +712,19 @@ function hasExplicitConfig(argv) {
   return argv.some((arg) => arg === '--config' || arg.startsWith('--config='));
 }
 
-function helpText({ userConfigPath, failingAdapters = [] }) {
+function helpText({
+  userConfigPath,
+  failingAdapters = [],
+  sdkFailureLines = [],
+}) {
   const failures =
     failingAdapters.length > 0
       ? [`Adapters not ready: ${failingAdapters.join(', ')}`, '']
       : [];
   return [
+    // PBCLI-40: the SDK remedy leads, because an unusable adapter cannot be
+    // fixed by the credential advice further down.
+    ...sdkFailureLines,
     ...failures,
     'Usage:',
     '  playbook [--list] [--with <path>]... [--config <path>] [tmux-play options]',
@@ -699,8 +740,12 @@ function helpText({ userConfigPath, failingAdapters = [] }) {
     '  default config file is never modified.',
     '',
     'Adapter setup:',
-    '  claude: run Claude Code once or set ANTHROPIC_API_KEY.',
-    '  codex: run Codex CLI once or set OPENAI_API_KEY.',
+    '  claude: npm install -g @anthropic-ai/claude-agent-sdk, then run',
+    '    Claude Code once or set ANTHROPIC_API_KEY.',
+    '  codex: npm install -g @openai/codex-sdk, then run Codex CLI once',
+    '    or set OPENAI_API_KEY.',
+    '  Each SDK is an optional peer dependency, so you install only the',
+    '  vendors your config actually names.',
     '',
     'Agent swap recipe:',
     '  - set each agent inline: the top-level captain and every',

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

@@ -29,6 +29,12 @@ import {
 } from '@sublang/cligent';
 import { parse as parseYaml } from 'yaml';
 import { hiddenControlEnvelope } from '../../../../src/xstate-runtime.js';
+import {
+  adapterSdkFailureLines,
+  checkAdapterSdks,
+  mappedSdksFor,
+  probeAdapterSdk,
+} from './adapter-sdk.js';
 import { provisionEngine } from './provision.js';
 
 // PBCLI-19: adapter shorthands the run host can construct.
@@ -77,6 +83,15 @@ export async function runPlaybookRun(options = {}) {
     readStdin,
     sessionsDir,
     userConfigPath,
+    // PBCLI-39: the adapter SDK probe and the runtime classifier, injectable
+    // like createAgent so tests can drive an unavailable or below-floor
+    // runtime without uninstalling or downgrading one.
+    probeAdapterSdk: options.probeAdapterSdk ?? probeAdapterSdk,
+    classifyRuntime: options.classifyRuntime,
+    // PBCLI-40: the original invocation, preserved on the ephemeral re-run;
+    // this module receives argv with the leading `run` already consumed.
+    rawArgv: ['run', ...argv],
+    ephemeralNpx: options.ephemeralNpx,
     // PBCLI-37: injected host package roots let tests provision against
     // synthetic trees, like the injected session store.
     hostRoots: options.hostRoots,
@@ -159,6 +174,18 @@ async function runFirst(args, ctx) {
     return { code: EXIT.arg };
   }
 
+  // PBCLI-39/40: an optional-peer SDK that is not installed fails here,
+  // before the runtime exists and before any agent call — never mid-turn.
+  const sdkError = await adapterSdksDiagnostic(
+    [...roleSpecs.values(), captainSpec],
+    ctx,
+    stdinReplayArgs(args, task),
+  );
+  if (sdkError !== undefined) {
+    stderr.write(sdkError);
+    return { code: EXIT.arg };
+  }
+
   let runtime;
   try {
     runtime = entry.createRuntime({
@@ -290,6 +317,18 @@ async function runResume(args, ctx) {
     return { code: EXIT.arg };
   }
 
+  // PBCLI-39: a resume rebuilds the stored lineup, so it needs the same
+  // SDKs — an install that lost one must not resume into a mid-turn error.
+  const sdkError = await adapterSdksDiagnostic(
+    [...roleSpecs.values(), record.captain],
+    ctx,
+    stdinReplayArgs(args, reply),
+  );
+  if (sdkError !== undefined) {
+    stderr.write(sdkError);
+    return { code: EXIT.arg };
+  }
+
   let runtime;
   try {
     runtime = entry.createRuntime({
@@ -639,6 +678,50 @@ function specsDiagnostic(specs) {
   return undefined;
 }
 
+// PBCLI-40: the replay tail for input the command consumed from stdin —
+// the pipe that carried it will not exist when the printed command runs.
+// The value rides behind a `--` end-of-options terminator, because quoting
+// alone cannot keep a flag-shaped value (`--json`, `--last`, a `-`-leading
+// bullet) from being read as an option; where the original invocation
+// already activated a terminator of its own, that one is reused — a second
+// `--` after the first would itself be positional data on the replay,
+// turning a `--json` task into `-- --json`.
+function stdinReplayArgs(args, resolved) {
+  if (args.task !== undefined) return [];
+  return args.terminated ? [resolved] : ['--', resolved];
+}
+
+// PBCLI-39/40: returns the ready-to-write stderr block naming every bound
+// adapter whose optional-peer SDK is not installed, or undefined when every
+// one of them loads. Runs only after specsDiagnostic has accepted the
+// adapter names, so every spec here carries a known adapter.
+async function adapterSdksDiagnostic(specs, ctx, stdinArgs = []) {
+  const adapters = specs.map((spec) => spec.adapter);
+  const { unusableAdapters } = await checkAdapterSdks(
+    adapters,
+    ctx.probeAdapterSdk,
+    ...(ctx.classifyRuntime ? [ctx.classifyRuntime] : []),
+  );
+  if (unusableAdapters.length === 0) return undefined;
+  const [header, ...commands] = adapterSdkFailureLines(unusableAdapters, {
+    // PBCLI-40: the ephemeral re-run carries the lineup's full mapped SDK
+    // set and the original arguments, so it completes in one hop and runs
+    // exactly as printed. stdinArgs arrive terminator-ready from
+    // stdinReplayArgs — appended verbatim here, because whether a `--` is
+    // needed depends on the original invocation's own parse state.
+    requiredSdks: mappedSdksFor(adapters),
+    invocation: [...ctx.rawArgv, ...stdinArgs],
+    ...(ctx.ephemeralNpx !== undefined
+      ? { ephemeralNpx: ctx.ephemeralNpx }
+      : {}),
+  }).filter((line) => line !== '');
+  // Only the header takes the command prefix; the install lines stay
+  // copy-pasteable.
+  return [`playbook run: ${header}`, ...commands]
+    .map((line) => `${line}\n`)
+    .join('');
+}
+
 function isAgentSpec(spec) {
   return (
     typeof spec === 'object' &&
@@ -892,10 +975,23 @@ export function parseRunArgs(argv) {
     verbose: false,
     noProvision: false,
     help: false,
+    terminated: false,
   };
   const positionals = [];
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
+    // PBCLI-40: end-of-options — everything after `--` is positional, so a
+    // flag-shaped task or reply (a stdin-derived `--json`, a `- bullet`
+    // line) survives the ephemeral re-run round trip instead of being
+    // reinterpreted as an option. `terminated` records that this branch
+    // fired — only a `--` the walk itself treats as the terminator counts,
+    // never one consumed as an option's value (`--cwd --`) — so the re-run
+    // builder can reuse an active terminator instead of doubling it.
+    if (arg === '--') {
+      args.terminated = true;
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
     if (arg === '--help' || arg === '-h') args.help = true;
     else if (arg === '--json') args.json = true;
     else if (arg === '--verbose') args.verbose = true;
@@ -1036,6 +1132,7 @@ function runHelpText() {
     '  <from>   registry module specifier (package subpath, path, or file: URL)',
     '  [task]   Boss intent; read from stdin when omitted',
     '  [reply]  Boss reply to a parked session; read from stdin when omitted',
+    '  --       end of options; use before a task or reply that starts with -',
     '',
     'Options:',
     '  --player <role>=<agent>   bind a required role (repeatable)',

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

@@ -665,6 +665,23 @@ const runtimeSpec = {
     extractRequiredFields,
     verbatimPayloadFields: VERBATIM_PAYLOAD_FIELDS,
     resumableStateIds: registeredResumableStateIds,
+    // PBRT-52: CODE's own ControlView context projection. Exactly the four
+    // closed-vocabulary classification members the FSM assigns itself, which
+    // are what a controller needs to see to describe or steer a CODE
+    // engagement. Everything else in `CodingContext` is deliberately absent:
+    // `coderPlayer` / `reviewerPlayer` / `committerPlayer` are the resolved
+    // host player roster, `intent` is an option value, and `irNumber`,
+    // `taskDescription`, `reviews`, `challenges`, and `lastResult` all carry
+    // player-authored text — all of which a session-Captain prompt must
+    // exclude, or may carry only as fenced quotes
+    // (CAPTAIN-9). A member added to `CodingContext`
+    // later stays private until it is named here.
+    controlContextFields: [
+        'workflow',
+        'changeOrigin',
+        'reviewSubject',
+        'afterReview',
+    ],
     classifyBossText: (text, ports, signal, snapshotOrState, boundary) => classifyBossText(text, ports, signal, snapshotOrState, boundary),
     classificationStatus: (event) => formatClassification(event.type),
     statusesForState,

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

@@ -936,6 +936,23 @@ const runtimeSpec: XStatePlaybookRuntimeSpec<CodePlaybookOptions> = {
   extractRequiredFields,
   verbatimPayloadFields: VERBATIM_PAYLOAD_FIELDS,
   resumableStateIds: registeredResumableStateIds,
+  // PBRT-52: CODE's own ControlView context projection. Exactly the four
+  // closed-vocabulary classification members the FSM assigns itself, which
+  // are what a controller needs to see to describe or steer a CODE
+  // engagement. Everything else in `CodingContext` is deliberately absent:
+  // `coderPlayer` / `reviewerPlayer` / `committerPlayer` are the resolved
+  // host player roster, `intent` is an option value, and `irNumber`,
+  // `taskDescription`, `reviews`, `challenges`, and `lastResult` all carry
+  // player-authored text — all of which a session-Captain prompt must
+  // exclude, or may carry only as fenced quotes
+  // (CAPTAIN-9). A member added to `CodingContext`
+  // later stays private until it is named here.
+  controlContextFields: [
+    'workflow',
+    'changeOrigin',
+    'reviewSubject',
+    'afterReview',
+  ],
   classifyBossText: (text, ports, signal, snapshotOrState, boundary) =>
     classifyBossText(text, ports, signal, snapshotOrState, boundary),
   classificationStatus: (event) => formatClassification(event.type),

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

@@ -1,5 +1,6 @@
 import type { Captain } from '@sublang/cligent/tmux-play';
 import type { PlaybookRuntime } from '@sublang/playbook/runtime';
+import { type CaptainControllerPort } from '../captain.playbook/captain.playbook.js';
 import type { PlaybookSummaryPolicy, RegistryPlayer } from './code.registry.js';
 export interface CreatePlaybookRuntimeOptions {
     captainOptions: unknown;
@@ -14,6 +15,7 @@ export interface PlaybookCaptainDeps {
             readonly command: string;
             readonly intent: string;
         }[];
+        readonly controller: CaptainControllerPort;
     }) => PlaybookRuntime;
 }
 export interface PlaybookCaptainRegistryEntry {