@runtypelabs/cli 2.18.0 → 2.19.0

package/README.md

@@ -211,7 +211,7 @@ milestones:
 EOF
 ```
 
-**Search order**: Exact path → `.runtype/marathons/playbooks/<name>.yaml|yml|json` (repo) → `~/.runtype/marathons/playbooks/<name>.yaml|yml|json` (user).
+**Search order**: Exact path → `.runtype/marathons/playbooks/<name>.yaml|yml|json|ts|mts` (repo) → `~/.runtype/marathons/playbooks/<name>.yaml|yml|json|ts|mts` (user).
 
 **Completion criteria types**:
 
@@ -248,6 +248,33 @@ milestones:
 | `requireVerification`    | `boolean`  | Require verification before `TASK_COMPLETE`.                                                                                  |
 | `outputRoot`             | `string`   | For creation tasks: confine writes to this directory (e.g. `"public/"`).                                                      |
 
+#### TypeScript playbooks
+
+Playbooks can also be TypeScript modules (`.ts`/`.mts`), loaded at runtime via jiti — no build step or special Node version required. Every behavior slot (`instructions`, `completionCriteria`, `recovery`, `intercept`, ...) then accepts a plain function in addition to inline data and hook references:
+
+```ts
+// .runtype/marathons/playbooks/my-task.ts
+import { definePlaybook, type RunTaskStateSlice } from '@runtypelabs/sdk'
+
+export default definePlaybook({
+  name: 'my-task',
+  stallPolicy: { nudgeAfter: 1, stopAfter: 4 },
+  milestones: [
+    {
+      name: 'build',
+      instructions: (state: RunTaskStateSlice) => `Build it. Plan: ${state.planPath}`,
+      recovery: (state) =>
+        `You went ${state.consecutiveEmptySessions ?? 0} sessions without a tool call. Write a file now.`,
+      canAcceptCompletion: true,
+    },
+  ],
+})
+```
+
+`definePlaybook` (from `@runtypelabs/sdk`, install as a devDependency for editor types) is optional sugar — a plain object export with the same shape works without the package installed. To register named hooks (reusable from YAML playbooks too), export a factory instead: `export default ({ registerWorkflowHook }) => ({ ... })`. A complete example lives at [`examples/playbooks/release-notes.ts`](./examples/playbooks/release-notes.ts).
+
+**Hook references**: any slot can reference a registered behavior by name instead of carrying data — `builtin:*` names expose the default workflow's behaviors (e.g. `instructions: builtin:research-instructions`, `completionCriteria: { type: builtin:research-complete }`), and YAML playbooks can load custom hooks from JS modules listed under `plugins:` (paths relative to the playbook file). See the comments in [`examples/playbooks/design-library.yaml`](./examples/playbooks/design-library.yaml).
+
 #### Marathon Anatomy
 
 ```

package/dist/index.js

@@ -7,8 +7,13 @@ var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? requir
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x2 + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -33515,7 +33520,11 @@ var userProfileFeaturesSchema = external_exports.object({
   enableDashboardAssistant: external_exports.boolean(),
   // Routed model id the dashboard assistant dispatches with. Driven by the
   // `dashboard-assistant-model` string flag.
-  dashboardAssistantModel: external_exports.string()
+  dashboardAssistantModel: external_exports.string(),
+  // Gates the chrome_extension surface type in the dashboard (surface picker
+  // and downstream config/ship UI). Driven by the `CHROME_SURFACE` boolean
+  // flag.
+  enableChromeSurface: external_exports.boolean()
 });
 var MODEL_FAMILY_PROVIDER_IDS = {
   "claude-fable-5": {
@@ -36482,7 +36491,8 @@ var surfaceSchema = external_exports.object({
     "messaging",
     "telegram",
     "a2a",
-    "hosted-page"
+    "hosted-page",
+    "chrome_extension"
   ]),
   config: external_exports.record(external_exports.string(), external_exports.any()),
   createPolicy: createPolicySchema,
@@ -37946,7 +37956,8 @@ var PLATFORM_CATALOG = {
     "whatsapp",
     "messaging",
     "telegram",
-    "a2a"
+    "a2a",
+    "chrome_extension"
   ],
   availableFlowPrimitives: FLOW_STEP_TYPES.map((stepType) => {
     const meta3 = FLOW_STEP_TYPE_METADATA[stepType];
@@ -38336,6 +38347,37 @@ var SURFACE_TYPE_METADATA = {
       maxResponseLength: null,
       executionHint: null
     }
+  },
+  // @snake-case-ok: surface type identifier
+  chrome_extension: {
+    description: "Downloadable Manifest V3 Chrome extension embedding the agent in the browser side panel, with packaged browser tools (read page, fill forms, navigate tabs) executed locally via the WebMCP client-tool loop.",
+    useCases: [
+      "browser copilots",
+      "page-aware assistants",
+      "form filling and data extraction",
+      "internal browser tooling"
+    ],
+    examples: [
+      "CRM sidekick that reads and updates records on the page",
+      "Research assistant that summarizes and compares open tabs",
+      "Support agent that drafts replies inside a ticketing UI"
+    ],
+    traits: {
+      streaming: "required",
+      messagesMutable: false,
+      deliveryModel: "real_time",
+      mediaSupport: "images",
+      interactiveUI: "generative",
+      inboundMediaSupport: true,
+      consumerType: "human",
+      reasoningVisibility: "pass_through",
+      markdownDialect: "mdx",
+      threadModel: "flat",
+      senderIdentity: "anonymous",
+      maxResponseLength: null,
+      executionHint: "You are running inside a Chrome extension side panel. You may have browser tools (chrome:*) to read the current page, interact with forms, and manage tabs \u2014 use them when the user asks about or wants to act on the page they are viewing. Mutating actions (clicking, filling, navigating) ask the user for confirmation before running."
+    },
+    behaviorTypeRef: "runtype://types/surface-configs"
   }
 };
 var SURFACE_TYPE_GUIDE = (() => {
@@ -55751,14 +55793,17 @@ function resolveErrorHandlingForPhase(phase, cliFallbackModel, milestoneFallback
 import * as fs14 from "fs";
 import * as path15 from "path";
 import * as os5 from "os";
+import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
 import micromatch from "micromatch";
 import { parse as parseYaml } from "yaml";
-var DISCOVERY_TOOLS = /* @__PURE__ */ new Set([
-  "search_repo",
-  "glob_files",
-  "tree_directory",
-  "list_directory"
-]);
+import {
+  DEFAULT_STALL_STOP_AFTER,
+  compileWorkflowConfig,
+  ensureDefaultWorkflowHooks,
+  isWorkflowHookRef,
+  registerWorkflowHook
+} from "@runtypelabs/sdk";
 var PLAYBOOKS_DIR = ".runtype/marathons/playbooks";
 function getCandidatePaths(nameOrPath, cwd) {
   const home = os5.homedir();
@@ -55769,12 +55814,43 @@ function getCandidatePaths(nameOrPath, cwd) {
     path15.resolve(cwd, PLAYBOOKS_DIR, `${nameOrPath}.yaml`),
     path15.resolve(cwd, PLAYBOOKS_DIR, `${nameOrPath}.yml`),
     path15.resolve(cwd, PLAYBOOKS_DIR, `${nameOrPath}.json`),
+    path15.resolve(cwd, PLAYBOOKS_DIR, `${nameOrPath}.ts`),
+    path15.resolve(cwd, PLAYBOOKS_DIR, `${nameOrPath}.mts`),
     // User-level
     path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.yaml`),
     path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.yml`),
-    path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.json`)
+    path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.json`),
+    path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.ts`),
+    path15.resolve(home, PLAYBOOKS_DIR, `${nameOrPath}.mts`)
   ];
 }
+var MODULE_PLAYBOOK_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts"]);
+var jitiLoader;
+async function loadModulePlaybook(filePath) {
+  jitiLoader ??= createJiti(import.meta.url, { interopDefault: false });
+  let mod;
+  try {
+    mod = await jitiLoader.import(filePath);
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    throw new Error(`Failed to load TypeScript playbook at ${filePath}: ${message}`, {
+      cause: error51
+    });
+  }
+  const exported = mod.default;
+  if (exported === void 0 || exported === null) {
+    throw new Error(
+      `TypeScript playbook at ${filePath} must have a default export: a playbook config object, or a factory function receiving { registerWorkflowHook }. Wrap it in definePlaybook(...) from @runtypelabs/sdk for type inference.`
+    );
+  }
+  const config3 = typeof exported === "function" ? await exported({ registerWorkflowHook }) : exported;
+  if (!config3 || typeof config3 !== "object" || Array.isArray(config3)) {
+    throw new Error(
+      `TypeScript playbook at ${filePath} did not produce a playbook config object.`
+    );
+  }
+  return config3;
+}
 function parsePlaybookFile(filePath) {
   const raw = fs14.readFileSync(filePath, "utf-8");
   const ext = path15.extname(filePath).toLowerCase();
@@ -55783,6 +55859,12 @@ function parsePlaybookFile(filePath) {
   }
   return parseYaml(raw);
 }
+function assertPositiveInteger(value, label, playbookName) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(`Playbook '${playbookName}': ${label} must be a positive integer`);
+  }
+}
 function validatePlaybook(config3, filePath) {
   if (!config3.name) {
     throw new Error(`Playbook at ${filePath} is missing required 'name' field`);
@@ -55797,131 +55879,140 @@ function validatePlaybook(config3, filePath) {
     if (!milestone.instructions) {
       throw new Error(`Playbook '${config3.name}': milestone '${milestone.name}' is missing 'instructions'`);
     }
+    if (milestone.recovery !== void 0 && typeof milestone.recovery !== "function" && !isWorkflowHookRef(milestone.recovery)) {
+      const recovery = milestone.recovery;
+      if (typeof recovery.message !== "string" || !recovery.message.trim()) {
+        throw new Error(
+          `Playbook '${config3.name}': milestone '${milestone.name}' recovery is missing 'message'`
+        );
+      }
+      assertPositiveInteger(
+        recovery.afterEmptySessions,
+        `milestone '${milestone.name}' recovery.afterEmptySessions`,
+        config3.name
+      );
+    }
   }
-}
-function interpolate(template, state) {
-  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
-    const value = state[key];
-    if (value === void 0 || value === null) return `{{${key}}}`;
-    return String(value);
-  });
-}
-function buildIsComplete(criteria) {
-  if (!criteria) return () => false;
-  switch (criteria.type) {
-    case "evidence":
-      return (ctx) => {
-        const minFiles = criteria.minReadFiles ?? 1;
-        return (ctx.state.recentReadPaths?.length ?? 0) >= minFiles;
-      };
-    case "sessions": {
-      let baselineSessionCount;
-      return (ctx) => {
-        const minSessions = criteria.minSessions ?? 1;
-        if (baselineSessionCount === void 0) {
-          baselineSessionCount = ctx.state.sessions.length;
-        }
-        return ctx.state.sessions.length - baselineSessionCount >= minSessions;
-      };
+  if (config3.stallPolicy) {
+    assertPositiveInteger(config3.stallPolicy.nudgeAfter, "stallPolicy.nudgeAfter", config3.name);
+    assertPositiveInteger(
+      config3.stallPolicy.escalateModelAfter,
+      "stallPolicy.escalateModelAfter",
+      config3.name
+    );
+    assertPositiveInteger(config3.stallPolicy.stopAfter, "stallPolicy.stopAfter", config3.name);
+  }
+  if (config3.plugins !== void 0) {
+    if (!Array.isArray(config3.plugins)) {
+      throw new Error(`Playbook '${config3.name}': 'plugins' must be a list of relative module paths`);
+    }
+    for (const plugin of config3.plugins) {
+      if (typeof plugin !== "string" || !plugin.trim()) {
+        throw new Error(`Playbook '${config3.name}': each plugins entry must be a relative module path`);
+      }
     }
-    case "planWritten":
-      return (ctx) => {
-        return ctx.trace.planWritten;
-      };
-    case "never":
-    default:
-      return () => false;
   }
 }
-function buildPolicyIntercept(policy) {
-  if (!policy.blockedTools?.length && !policy.blockDiscoveryTools && !policy.allowedReadGlobs?.length && !policy.allowedWriteGlobs?.length && !policy.requirePlanBeforeWrite) {
-    return void 0;
-  }
-  const blockedSet = new Set(
-    (policy.blockedTools ?? []).map((t) => t.trim()).filter(Boolean)
+function collectPlaybookWarnings(config3) {
+  const warnings = [];
+  const anyCompletable = config3.milestones.some(
+    (m2) => m2.canAcceptCompletion === true || typeof m2.canAcceptCompletion === "function" || isWorkflowHookRef(m2.canAcceptCompletion)
   );
-  const readGlobs = policy.allowedReadGlobs ?? [];
-  const writeGlobs = policy.allowedWriteGlobs ?? [];
-  return (toolName, args, ctx) => {
-    if (blockedSet.has(toolName)) {
-      return `Blocked by playbook policy: ${toolName} is not allowed for this task.`;
-    }
-    if (policy.blockDiscoveryTools && DISCOVERY_TOOLS.has(toolName)) {
-      return `Blocked by playbook policy: discovery tools are disabled for this task.`;
-    }
-    const pathArg = typeof args.path === "string" && args.path.trim() ? ctx.normalizePath(String(args.path)) : void 0;
-    if (pathArg) {
-      const isWrite = toolName === "write_file" || toolName === "restore_file_checkpoint";
-      const isRead = toolName === "read_file";
-      if (isRead && readGlobs.length > 0) {
-        const allowed = micromatch.some(pathArg, readGlobs, { dot: true });
-        if (!allowed) {
-          return `Blocked by playbook policy: ${toolName} path "${pathArg}" is outside allowed read globs: ${readGlobs.join(", ")}`;
-        }
-      }
-      if (isWrite && writeGlobs.length > 0) {
-        const planPath = ctx.state.planPath ? ctx.normalizePath(ctx.state.planPath) : void 0;
-        if (planPath && pathArg === planPath) {
-        } else {
-          const allowed = micromatch.some(pathArg, writeGlobs, { dot: true });
-          if (!allowed) {
-            return `Blocked by playbook policy: ${toolName} path "${pathArg}" is outside allowed write globs: ${writeGlobs.join(", ")}`;
-          }
-        }
-      }
-      if (isWrite && policy.requirePlanBeforeWrite && !ctx.state.planWritten && !ctx.trace.planWritten) {
-        const planPath = ctx.state.planPath ? ctx.normalizePath(ctx.state.planPath) : void 0;
-        if (!planPath || pathArg !== planPath) {
-          return `Blocked by playbook policy: write the plan before creating other files.`;
-        }
-      }
+  if (!anyCompletable) {
+    warnings.push(
+      `Playbook '${config3.name}': no milestone sets canAcceptCompletion: true \u2014 TASK_COMPLETE will never be accepted and the run can only end by stalling or exhausting its budget. Set it on the final milestone.`
+    );
+  }
+  const escalateAfter = config3.stallPolicy?.escalateModelAfter;
+  if (escalateAfter !== void 0) {
+    const anyFallbacks = config3.milestones.some((m2) => m2.fallbackModels?.length);
+    if (!anyFallbacks) {
+      warnings.push(
+        `Playbook '${config3.name}': stallPolicy.escalateModelAfter is set but no milestone defines fallbackModels \u2014 the escalation signal will have no model to switch to.`
+      );
     }
-    return void 0;
-  };
+    const stopAfter = config3.stallPolicy?.stopAfter ?? DEFAULT_STALL_STOP_AFTER;
+    if (escalateAfter >= stopAfter) {
+      warnings.push(
+        `Playbook '${config3.name}': stallPolicy.escalateModelAfter (${escalateAfter}) is not below stopAfter (${stopAfter}) \u2014 the run will stall before model escalation can fire.`
+      );
+    }
+  }
+  return warnings;
 }
-function convertToWorkflow(config3) {
-  const policyIntercept = config3.policy ? buildPolicyIntercept(config3.policy) : void 0;
-  const phases = config3.milestones.map((milestone) => ({
+var PLUGIN_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs"]);
+async function loadPlaybookPlugins(plugins, playbookFilePath, playbookName) {
+  if (!plugins?.length) return;
+  const baseDir = path15.dirname(playbookFilePath);
+  for (const plugin of plugins) {
+    if (path15.isAbsolute(plugin)) {
+      throw new Error(
+        `Playbook '${playbookName}': plugin "${plugin}" must be a relative path (resolved against the playbook's directory).`
+      );
+    }
+    const resolved = path15.resolve(baseDir, plugin);
+    if (resolved !== baseDir && !resolved.startsWith(baseDir + path15.sep)) {
+      throw new Error(
+        `Playbook '${playbookName}': plugin "${plugin}" resolves outside the playbook's directory. Keep plugin modules next to the playbook.`
+      );
+    }
+    if (!PLUGIN_EXTENSIONS.has(path15.extname(resolved).toLowerCase())) {
+      throw new Error(
+        `Playbook '${playbookName}': plugin "${plugin}" must be a .js, .mjs, or .cjs module.`
+      );
+    }
+    if (!fs14.existsSync(resolved)) {
+      throw new Error(`Playbook '${playbookName}': plugin "${plugin}" not found at ${resolved}.`);
+    }
+    const mod = await import(pathToFileURL(resolved).href);
+    if (typeof mod.default !== "function") {
+      throw new Error(
+        `Playbook '${playbookName}': plugin "${plugin}" must export a default function: export default ({ registerWorkflowHook }) => { ... }`
+      );
+    }
+    await mod.default({ registerWorkflowHook });
+  }
+}
+function toWorkflowConfig(config3) {
+  const milestones = config3.milestones.map((milestone) => ({
     name: milestone.name,
-    description: milestone.description,
-    buildInstructions(state) {
-      const header = `--- Workflow Phase: ${milestone.name} ---`;
-      const desc = milestone.description ? `
-${milestone.description}` : "";
-      const instructions = interpolate(milestone.instructions, state);
-      return `${header}${desc}
-${instructions}`;
-    },
-    buildToolGuidance(_state) {
-      return milestone.toolGuidance ?? [];
-    },
-    isComplete: buildIsComplete(milestone.completionCriteria),
-    interceptToolCall: policyIntercept,
-    // Default to rejecting TASK_COMPLETE unless the playbook explicitly allows it.
-    // The SDK accepts completion by default when canAcceptCompletion is undefined,
-    // which would let the model end the marathon prematurely in early phases.
-    canAcceptCompletion: milestone.canAcceptCompletion !== void 0 ? () => milestone.canAcceptCompletion : () => false
+    ...milestone.description !== void 0 ? { description: milestone.description } : {},
+    instructions: milestone.instructions,
+    ...milestone.toolGuidance !== void 0 ? { toolGuidance: milestone.toolGuidance } : {},
+    ...milestone.completionCriteria ? { completionCriteria: milestone.completionCriteria } : {},
+    ...milestone.recovery !== void 0 ? { recovery: milestone.recovery } : {},
+    ...milestone.transitionSummary !== void 0 ? { transitionSummary: milestone.transitionSummary } : {},
+    ...milestone.intercept ? { intercept: milestone.intercept } : {},
+    ...milestone.forceEndTurn ? { forceEndTurn: milestone.forceEndTurn } : {},
+    // Playbooks reject TASK_COMPLETE unless explicitly allowed — the SDK
+    // accepts completion when the slot is absent, which would let the model
+    // end the marathon prematurely in early milestones.
+    canAcceptCompletion: milestone.canAcceptCompletion ?? false
   }));
   return {
     name: config3.name,
-    phases
-  };
-}
-function normalizeFallbackModel(input) {
-  if (typeof input === "string") return { model: input };
-  return {
-    model: input.model,
-    ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
-    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+    ...config3.description !== void 0 ? { description: config3.description } : {},
+    ...config3.stallPolicy ? { stallPolicy: config3.stallPolicy } : {},
+    ...config3.policy ? { policy: config3.policy } : {},
+    ...config3.classifyVariant ? { classifyVariant: config3.classifyVariant } : {},
+    ...config3.bootstrap ? { bootstrap: config3.bootstrap } : {},
+    ...config3.candidateBlock ? { candidateBlock: config3.candidateBlock } : {},
+    milestones
   };
 }
-function loadPlaybook(nameOrPath, cwd) {
+async function loadPlaybook(nameOrPath, cwd) {
   const baseCwd = cwd || process.cwd();
   const candidates = getCandidatePaths(nameOrPath, baseCwd);
   for (const candidate of candidates) {
     if (!fs14.existsSync(candidate) || fs14.statSync(candidate).isDirectory()) continue;
-    const config3 = parsePlaybookFile(candidate);
+    const ext = path15.extname(candidate).toLowerCase();
+    const config3 = MODULE_PLAYBOOK_EXTENSIONS.has(ext) ? await loadModulePlaybook(candidate) : parsePlaybookFile(candidate);
     validatePlaybook(config3, candidate);
+    await loadPlaybookPlugins(config3.plugins, candidate, config3.name);
+    ensureDefaultWorkflowHooks();
+    const workflow = compileWorkflowConfig(toWorkflowConfig(config3), {
+      matchPathGlobs: (filePath, globs) => micromatch.some(filePath, globs, { dot: true })
+    });
     const milestoneModels = {};
     const milestoneFallbackModels = {};
     for (const m2 of config3.milestones) {
@@ -55931,13 +56022,14 @@ function loadPlaybook(nameOrPath, cwd) {
       }
     }
     return {
-      workflow: convertToWorkflow(config3),
+      workflow,
       milestones: config3.milestones.map((m2) => m2.name),
       milestoneModels: Object.keys(milestoneModels).length > 0 ? milestoneModels : void 0,
       milestoneFallbackModels: Object.keys(milestoneFallbackModels).length > 0 ? milestoneFallbackModels : void 0,
       verification: config3.verification,
       rules: config3.rules,
-      policy: config3.policy
+      policy: config3.policy,
+      warnings: collectPlaybookWarnings(config3)
     };
   }
   throw new Error(
@@ -55945,6 +56037,14 @@ function loadPlaybook(nameOrPath, cwd) {
 ${candidates.map((c2) => `  ${c2}`).join("\n")}`
   );
 }
+function normalizeFallbackModel(input) {
+  if (typeof input === "string") return { model: input };
+  return {
+    model: input.model,
+    ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+  };
+}
 
 // src/commands/agents-task.ts
 function shouldRequestResumeCheckpoint(status, resumeMessage, noCheckpoint, originalMessage, continuations) {
@@ -56485,12 +56585,19 @@ async function taskAction(agent, options) {
   let playbookMilestoneFallbackModels;
   let playbookPolicy;
   if (options.playbook) {
-    const result = loadPlaybook(options.playbook);
+    const result = await loadPlaybook(options.playbook);
     playbookWorkflow = result.workflow;
     playbookMilestones = result.milestones;
     playbookMilestoneModels = result.milestoneModels;
     playbookMilestoneFallbackModels = result.milestoneFallbackModels;
     playbookPolicy = result.policy;
+    for (const warning of result.warnings) {
+      if (useStartupShell) {
+        setStartupStatus(`playbook warning: ${warning}`);
+      } else {
+        console.log(chalk23.yellow(`Playbook warning: ${warning}`));
+      }
+    }
   } else {
     playbookPolicy = void 0;
   }
@@ -56866,6 +56973,20 @@ Saving state... done. Session saved to ${filePath}`);
           break;
       }
     }
+    const stallEscalationUsedModels = /* @__PURE__ */ new Map();
+    const pickNextStallFallbackModel = (phase, currentModel) => {
+      if (!phase) return void 0;
+      const chain = [
+        ...playbookMilestoneFallbackModels?.[phase]?.map((fb) => fb.model) ?? [],
+        ...options.fallbackModel ? [options.fallbackModel] : []
+      ];
+      const used = stallEscalationUsedModels.get(phase) ?? /* @__PURE__ */ new Set();
+      const next = chain.find((model) => model !== currentModel && !used.has(model));
+      if (!next) return void 0;
+      used.add(next);
+      stallEscalationUsedModels.set(phase, used);
+      return next;
+    };
     let shouldContinue = true;
     let accumulatedSessions = 0;
     let accumulatedCost = 0;
@@ -57081,6 +57202,20 @@ Saving state... done. Session saved to ${filePath}`);
               });
             }
           }
+          if (state.stallEscalationRequested && state.status === "running") {
+            const escalationPhase = state.workflowPhase;
+            const activeModel = phaseModel || options.model;
+            const nextModel = pickNextStallFallbackModel(escalationPhase, activeModel);
+            if (escalationPhase && nextModel) {
+              playbookMilestoneModels = {
+                ...playbookMilestoneModels ?? {},
+                [escalationPhase]: nextModel
+              };
+              options.model = nextModel;
+              shouldContinue = true;
+              return false;
+            }
+          }
           if (state.recentActionKeys && state.recentActionKeys.length > 0) {
             for (const key of state.recentActionKeys) {
               loopDetector.recordAction(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/cli",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "Command-line interface for Runtype AI platform",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,7 @@
     "ink": "6.7.0",
     "ink-select-input": "^6.2.0",
     "ink-text-input": "^6.0.0",
+    "jiti": "^2.7.0",
     "micromatch": "^4.0.8",
     "oauth4webapi": "^3.8.5",
     "open": "^10.1.0",
@@ -23,7 +24,7 @@
     "rosie-skills": "0.8.1",
     "yaml": "^2.9.0",
     "@runtypelabs/ink-components": "0.3.2",
-    "@runtypelabs/sdk": "4.10.0",
+    "@runtypelabs/sdk": "4.11.0",
     "@runtypelabs/terminal-animations": "0.2.1"
   },
   "devDependencies": {
@@ -38,7 +39,7 @@
     "tsx": "^4.7.1",
     "typescript": "^5.3.3",
     "vitest": "^4.1.0",
-    "@runtypelabs/shared": "1.23.0"
+    "@runtypelabs/shared": "1.24.0"
   },
   "engines": {
     "node": ">=22.0.0"