@runtypelabs/cli 2.0.2 → 2.1.0

package/README.md

@@ -220,15 +220,44 @@ EOF
 - `planWritten` — advances when the agent writes its plan artifact
 - `never` — only the agent's `TASK_COMPLETE` signal can advance (if `canAcceptCompletion: true`)
 
+**Playbook policies**:
+
+The optional `policy` block lets you restrict what the agent can do at runtime. Policies are additive restrictions — they can only narrow behavior, never override global safety denies (e.g. `.env` files and private keys are always blocked).
+
+```yaml
+name: blog-writer
+policy:
+  allowedReadGlobs: ['content/**', 'templates/**']
+  allowedWriteGlobs: ['content/**']
+  blockedTools: ['search_repo']
+  blockDiscoveryTools: true
+  requirePlanBeforeWrite: true
+  requireVerification: true
+  outputRoot: 'content/'
+milestones:
+  - ...
+```
+
+| Field                    | Type       | Description                                                                                                                   |
+| ------------------------ | ---------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `allowedReadGlobs`       | `string[]` | Glob patterns for allowed read paths. If set, reads outside these are blocked.                                                |
+| `allowedWriteGlobs`      | `string[]` | Glob patterns for allowed write paths. If set, writes outside these are blocked. The plan file is always writable regardless. |
+| `blockedTools`           | `string[]` | Tool names to block entirely (e.g. `["write_file", "search_repo"]`).                                                          |
+| `blockDiscoveryTools`    | `boolean`  | Block `search_repo`, `glob_files`, `tree_directory`, and `list_directory`.                                                    |
+| `requirePlanBeforeWrite` | `boolean`  | Require the agent to write its plan before any other file writes.                                                             |
+| `requireVerification`    | `boolean`  | Require verification before `TASK_COMPLETE`.                                                                                  |
+| `outputRoot`             | `string`   | For creation tasks: confine writes to this directory (e.g. `"public/"`).                                                      |
+
 #### Marathon Anatomy
 
 ```
 ┌─ marathon ──────────────────────────────────────────────────────┐
 │                                                                 │
-│  ┌─ playbook (optional) ─────────────────────────────┐          │
-│  │  Defines milestones, models, verification, rules  │          │
-│  │  .runtype/marathons/playbooks/tdd.yaml            │          │
-│  └───────────────────────────────────────────────────┘          │
+│  ┌─ playbook (optional) ──────────────────────────────────┐     │
+│  │  Defines milestones, models, verification, rules,     │     │
+│  │  and policy constraints                               │     │
+│  │  .runtype/marathons/playbooks/tdd.yaml                │     │
+│  └────────────────────────────────────────────────────────┘     │
 │           │                                                     │
 │           ▼                                                     │
 │  ┌─ milestone 1 ──┐  ┌─ milestone 2 ──┐  ┌─ milestone 3 ─────┐  |
@@ -261,6 +290,7 @@ What's optional:
   ✓ Rules       Without them, agent follows only playbook/milestone instructions
   ✓ Models      Without overrides, uses CLI --model flag or default
   ✓ Verification Without it, no verification gate between milestones
+  ✓ Policy      Without one, only global safety denies apply
 ```
 
 #### Reasoning / Thinking
@@ -271,6 +301,44 @@ Marathon enables model reasoning by default for models that support it (Gemini 3
 runtype marathon "Code Builder" --goal "Fix the bug" --no-reasoning
 ```
 
+#### Fallback Models
+
+When an upstream model provider returns a transient error (e.g. overload, rate limit), marathon can automatically retry and then fall back to a different model instead of dying mid-run.
+
+**CLI flag** — applies to all phases:
+
+```bash
+# If claude-opus-4-6 fails, retry once then fall back to claude-sonnet-4-5
+runtype marathon "Code Builder" --goal "Refactor auth" \
+  --model claude-opus-4-6 \
+  --fallback-model claude-sonnet-4-5
+```
+
+**Playbook** — per-milestone fallback chains:
+
+```yaml
+milestones:
+  - name: research
+    model: claude-sonnet-4-5
+    fallbackModels:
+      - gpt-4o # string shorthand
+      - gemini-3-flash
+    instructions: |
+      Research the codebase...
+
+  - name: execution
+    model: claude-opus-4-6
+    fallbackModels:
+      - model: claude-sonnet-4-5 # object form with overrides
+        temperature: 0.5
+      - model: gpt-4o
+        maxTokens: 8192
+    instructions: |
+      Implement the changes...
+```
+
+Playbook per-milestone fallbacks take priority over the CLI `--fallback-model` flag. The fallback chain always starts with a retry (5s delay) before trying alternative models.
+
 #### Tool Context Modes
 
 When a marathon runs multiple sessions, tool call/result pairs from previous sessions are preserved in the conversation history. The `--tool-context` flag controls how older tool results are stored to balance cost and re-readability:

package/dist/index.js

@@ -12272,7 +12272,7 @@ import { theme as theme24 } from "@runtypelabs/ink-components";
 import { jsx as jsx25, jsxs as jsxs21 } from "react/jsx-runtime";
 var MENU_ITEMS = [
   { key: "c", label: "Copy session JSON" },
-  { key: "o", label: "Open session JSON in editor" },
+  { key: "e", label: "Open session JSON in editor" },
   { key: "f", label: "Open marathon folder in file manager" },
   { key: "d", label: "Open agent in Runtype dashboard" }
 ];
@@ -12294,7 +12294,7 @@ function SessionActionMenu({
       onCopySession();
       return;
     }
-    if (input === "o" && hasStateFile) {
+    if (input === "e" && hasStateFile) {
       onOpenStateFile();
       return;
     }
@@ -12320,7 +12320,7 @@ function SessionActionMenu({
       children: [
         /* @__PURE__ */ jsx25(Text24, { bold: true, color: theme24.accent, children: "Session" }),
         /* @__PURE__ */ jsx25(Box22, { flexDirection: "column", marginTop: 1, children: MENU_ITEMS.map((item) => {
-          const dimmed = item.key === "o" && !hasStateFile || item.key === "f" && !hasStateFile || item.key === "d" && !hasDashboard;
+          const dimmed = item.key === "e" && !hasStateFile || item.key === "f" && !hasStateFile || item.key === "d" && !hasDashboard;
           return /* @__PURE__ */ jsxs21(Text24, { children: [
             /* @__PURE__ */ jsx25(Text24, { color: dimmed ? theme24.textSubtle : theme24.accentActive, children: `  ${item.key}  ` }),
             /* @__PURE__ */ jsx25(Text24, { color: dimmed ? theme24.textSubtle : theme24.textMuted, children: item.label })
@@ -15311,7 +15311,9 @@ function extractRunTaskResumeState(state) {
     ...sanitized.bestCandidateNeedsVerification ? { bestCandidateNeedsVerification: sanitized.bestCandidateNeedsVerification } : {},
     ...sanitized.bestCandidateVerified ? { bestCandidateVerified: sanitized.bestCandidateVerified } : {},
     ...sanitized.verificationRequired !== void 0 ? { verificationRequired: sanitized.verificationRequired } : {},
-    ...sanitized.lastVerificationPassed ? { lastVerificationPassed: sanitized.lastVerificationPassed } : {}
+    ...sanitized.lastVerificationPassed ? { lastVerificationPassed: sanitized.lastVerificationPassed } : {},
+    ...sanitized.isCreationTask !== void 0 ? { isCreationTask: sanitized.isCreationTask } : {},
+    ...sanitized.outputRoot ? { outputRoot: sanitized.outputRoot } : {}
   };
 }
 function findStateFile(name, stateDir) {
@@ -15476,6 +15478,29 @@ var IGNORED_REPO_DIRS = /* @__PURE__ */ new Set([
   "dist",
   "node_modules"
 ]);
+var SENSITIVE_PATH_PATTERNS = [
+  { name: ".env", test: (n) => n === ".env" || n.endsWith("/.env") },
+  { name: ".env.*", test: (n) => /\.env\.?[^/]*$/.test(n) || /\/\.env\.?[^/]*$/.test(n) },
+  { name: "private keys", test: (n) => /(^|\/)(id_rsa|id_ed25519|id_ecdsa)(\.pub)?$/.test(n) },
+  { name: "known_hosts", test: (n) => n.endsWith("known_hosts") || n.endsWith("/known_hosts") },
+  { name: "authorized_keys", test: (n) => n.endsWith("authorized_keys") || n.endsWith("/authorized_keys") },
+  { name: "cert/key extensions", test: (n) => /\.(pem|key|p12|pfx)$/i.test(n) },
+  { name: "npm/pypi config", test: (n) => /(^|\/)(\.npmrc|\.pypirc|\.netrc)$/.test(n) },
+  { name: "docker config", test: (n) => /\.docker\/config\.json$/i.test(n) },
+  { name: "credentials", test: (n) => /(^|\/)(credentials\.json|secrets\.json)$/i.test(n) },
+  { name: "service account", test: (n) => /service-account.*\.json$/i.test(n) || /firebase-admin.*\.json$/i.test(n) },
+  { name: ".ssh", test: (n) => n === ".ssh" || n.startsWith(".ssh/") || n.includes("/.ssh/") },
+  { name: ".aws", test: (n) => n === ".aws" || n.startsWith(".aws/") || n.includes("/.aws/") },
+  { name: ".gnupg", test: (n) => n === ".gnupg" || n.startsWith(".gnupg/") || n.includes("/.gnupg/") },
+  { name: ".terraform", test: (n) => n === ".terraform" || n.startsWith(".terraform/") || n.includes("/.terraform/") },
+  { name: ".git", test: (n) => n === ".git" || n.startsWith(".git/") || n.includes("/.git/") },
+  { name: ".runtype", test: (n) => n === ".runtype" || n.startsWith(".runtype/") || n.includes("/.runtype/") }
+];
+function isSensitivePath(normalizedPath) {
+  const n = normalizedPath.replace(/\\/g, "/").trim();
+  if (!n) return false;
+  return SENSITIVE_PATH_PATTERNS.some(({ test }) => test(n));
+}
 var DEFAULT_DISCOVERY_MAX_RESULTS = 50;
 var MAX_FILE_BYTES_TO_SCAN = 1024 * 1024;
 var LOW_SIGNAL_FILE_NAMES = /* @__PURE__ */ new Set([
@@ -15564,12 +15589,15 @@ function scoreSearchPath(relativePath) {
   return score;
 }
 function shouldIgnoreRepoEntry(entryPath) {
-  const normalized = normalizeToolPath(entryPath);
+  const normalized = normalizeToolPath(entryPath).replace(/\\/g, "/");
   if (normalized === ".") return false;
+  if (isSensitivePath(normalized)) return true;
   return normalized.split(path8.sep).some((segment) => IGNORED_REPO_DIRS.has(segment));
 }
 function safeReadTextFile(filePath) {
   try {
+    const normalized = normalizeToolPath(filePath).replace(/\\/g, "/");
+    if (isSensitivePath(normalized)) return null;
     const stat = fs8.statSync(filePath);
     if (!stat.isFile() || stat.size > MAX_FILE_BYTES_TO_SCAN) return null;
     const buffer = fs8.readFileSync(filePath);
@@ -15700,9 +15728,10 @@ function resolveToolPath(toolPath, options = {}) {
     return { ok: false, error: `Path does not exist: ${requestedPath}` };
   }
   const workspaceRoot = fs9.realpathSync.native(process.cwd());
+  const extraRoots = (options.allowedRoots || []).map((rootPath) => canonicalizeAllowedRoot(rootPath));
   const allowedRoots = [
-    workspaceRoot,
-    ...(options.allowedRoots || []).map((rootPath) => canonicalizeAllowedRoot(rootPath))
+    ...extraRoots,
+    workspaceRoot
   ];
   const matchedRoot = allowedRoots.find(
     (rootPath) => isPathWithinRoot(resolved.canonicalPath, rootPath)
@@ -15721,6 +15750,13 @@ function resolveToolPath(toolPath, options = {}) {
         error: `Access denied: ${requestedPath} is inside restricted workspace state (${blockedSegment})`
       };
     }
+    const relativeFromWorkspace = path9.relative(workspaceRoot, resolved.canonicalPath).replace(/\\/g, "/");
+    if (isSensitivePath(relativeFromWorkspace)) {
+      return {
+        ok: false,
+        error: `Access denied: ${requestedPath} is a sensitive path and cannot be read or written`
+      };
+    }
   }
   if (resolved.exists) {
     const stat = fs9.statSync(resolved.canonicalPath);
@@ -15741,8 +15777,17 @@ function resolveToolPath(toolPath, options = {}) {
   }
   return { ok: true, resolvedPath: resolved.canonicalPath };
 }
+function getTaskStateRoot(taskName, stateDir) {
+  return path9.join(stateDir || getMarathonStateDir(), stateSafeName3(taskName));
+}
 function createDefaultLocalTools(context) {
-  const allowedReadRoots = context?.taskName ? [getOffloadedOutputDir(context.taskName, context.stateDir)] : [];
+  const taskStateRoot = context?.taskName ? getTaskStateRoot(context.taskName, context.stateDir) : void 0;
+  const planDir = context?.taskName ? path9.resolve(`.runtype/marathons/${stateSafeName3(context.taskName)}`) : void 0;
+  const allowedReadRoots = context?.taskName ? [
+    getOffloadedOutputDir(context.taskName, context.stateDir),
+    ...taskStateRoot ? [taskStateRoot] : [],
+    ...planDir ? [planDir] : []
+  ] : [];
   return {
     read_file: {
       description: "Read the contents of a file at the given path",
@@ -15944,6 +15989,8 @@ function createDefaultLocalTools(context) {
   };
 }
 function createCheckpointedWriteFileTool(taskName, stateDir) {
+  const taskStateRoot = getTaskStateRoot(taskName, stateDir);
+  const planDir = path9.resolve(`.runtype/marathons/${stateSafeName3(taskName)}`);
   return {
     description: "Write content to a file, creating directories as needed and checkpointing original repo files",
     parametersSchema: {
@@ -15956,7 +16003,8 @@ function createCheckpointedWriteFileTool(taskName, stateDir) {
     },
     execute: async (args) => {
       const resolvedPath = resolveToolPath(String(args.path || ""), {
-        allowMissing: true
+        allowMissing: true,
+        allowedRoots: [taskStateRoot, planDir]
       });
       if (!resolvedPath.ok) return `Error: ${resolvedPath.error}`;
       const content = String(args.content || "");
@@ -16047,6 +16095,7 @@ function createRunCheckTool() {
       if (!isSafeVerificationCommand(command)) {
         return JSON.stringify({
           success: false,
+          blocked: true,
           command,
           error: "Blocked unsafe verification command. Use a single non-destructive lint/test/typecheck/build command."
         });
@@ -16462,12 +16511,46 @@ function resolveModelForPhase(phase, cliOverrides, milestoneModels) {
   }
   return cliOverrides.defaultModel;
 }
+function resolveErrorHandlingForPhase(phase, cliFallbackModel, milestoneFallbackModels) {
+  const phaseFallbacks = phase ? milestoneFallbackModels?.[phase] : void 0;
+  if (phaseFallbacks?.length) {
+    return {
+      onError: "fallback",
+      fallbacks: [
+        { type: "retry", delay: 5e3 },
+        ...phaseFallbacks.map((fb) => ({
+          type: "model",
+          model: fb.model,
+          ...fb.temperature !== void 0 ? { temperature: fb.temperature } : {},
+          ...fb.maxTokens !== void 0 ? { maxTokens: fb.maxTokens } : {}
+        }))
+      ]
+    };
+  }
+  if (cliFallbackModel) {
+    return {
+      onError: "fallback",
+      fallbacks: [
+        { type: "retry", delay: 5e3 },
+        { type: "model", model: cliFallbackModel }
+      ]
+    };
+  }
+  return void 0;
+}
 
 // src/marathon/playbook-loader.ts
 import * as fs12 from "fs";
 import * as path12 from "path";
 import * as os4 from "os";
+import micromatch from "micromatch";
 import { parse as parseYaml } from "yaml";
+var DISCOVERY_TOOLS = /* @__PURE__ */ new Set([
+  "search_repo",
+  "glob_files",
+  "tree_directory",
+  "list_directory"
+]);
 var PLAYBOOKS_DIR = ".runtype/marathons/playbooks";
 function getCandidatePaths(nameOrPath, cwd) {
   const home = os4.homedir();
@@ -16542,7 +16625,54 @@ function buildIsComplete(criteria) {
       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)
+  );
+  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.`;
+        }
+      }
+    }
+    return void 0;
+  };
+}
 function convertToWorkflow(config2) {
+  const policyIntercept = config2.policy ? buildPolicyIntercept(config2.policy) : void 0;
   const phases = config2.milestones.map((milestone) => ({
     name: milestone.name,
     description: milestone.description,
@@ -16558,6 +16688,7 @@ ${instructions}`;
       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.
@@ -16568,23 +16699,37 @@ ${instructions}`;
     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 } : {}
+  };
+}
 function loadPlaybook(nameOrPath, cwd) {
   const baseCwd = cwd || process.cwd();
   const candidates = getCandidatePaths(nameOrPath, baseCwd);
   for (const candidate of candidates) {
-    if (!fs12.existsSync(candidate)) continue;
+    if (!fs12.existsSync(candidate) || fs12.statSync(candidate).isDirectory()) continue;
     const config2 = parsePlaybookFile(candidate);
     validatePlaybook(config2, candidate);
     const milestoneModels = {};
+    const milestoneFallbackModels = {};
     for (const m of config2.milestones) {
       if (m.model) milestoneModels[m.name] = m.model;
+      if (m.fallbackModels?.length) {
+        milestoneFallbackModels[m.name] = m.fallbackModels.map(normalizeFallbackModel);
+      }
     }
     return {
       workflow: convertToWorkflow(config2),
       milestones: config2.milestones.map((m) => m.name),
       milestoneModels: Object.keys(milestoneModels).length > 0 ? milestoneModels : void 0,
+      milestoneFallbackModels: Object.keys(milestoneFallbackModels).length > 0 ? milestoneFallbackModels : void 0,
       verification: config2.verification,
-      rules: config2.rules
+      rules: config2.rules,
+      policy: config2.policy
     };
   }
   throw new Error(
@@ -16749,13 +16894,22 @@ function normalizeMarathonAgentArgument(agent) {
 function buildMarathonAutoCreatedAgentBootstrap(agentName, options = {}) {
   const normalizedModel = options.model?.trim();
   const normalizedToolIds = [...new Set((options.toolIds || []).map((toolId) => toolId.trim()).filter(Boolean))];
-  const config2 = normalizedModel || normalizedToolIds.length > 0 ? {
+  const normalizedFallbackModel = options.fallbackModel?.trim();
+  const errorHandling = normalizedFallbackModel ? {
+    onError: "fallback",
+    fallbacks: [
+      { type: "retry", delay: 5e3 },
+      { type: "model", model: normalizedFallbackModel }
+    ]
+  } : void 0;
+  const config2 = normalizedModel || normalizedToolIds.length > 0 || errorHandling ? {
     ...normalizedModel ? { model: normalizedModel } : {},
     ...normalizedToolIds.length > 0 ? {
       tools: {
         toolIds: normalizedToolIds
       }
-    } : {}
+    } : {},
+    ...errorHandling ? { errorHandling } : {}
   } : void 0;
   return {
     description: `Powering a marathon for ${agentName}`,
@@ -17109,11 +17263,17 @@ async function taskAction(agent, options) {
   let playbookWorkflow;
   let playbookMilestones;
   let playbookMilestoneModels;
+  let playbookMilestoneFallbackModels;
+  let playbookPolicy;
   if (options.playbook) {
     const result = loadPlaybook(options.playbook);
     playbookWorkflow = result.workflow;
     playbookMilestones = result.milestones;
     playbookMilestoneModels = result.milestoneModels;
+    playbookMilestoneFallbackModels = result.milestoneFallbackModels;
+    playbookPolicy = result.policy;
+  } else {
+    playbookPolicy = void 0;
   }
   if (useStartupShell && !options.model?.trim()) {
     if (playbookMilestoneModels && Object.keys(playbookMilestoneModels).length > 0 && startupShellRef.current) {
@@ -17214,7 +17374,8 @@ ${rulesContext}`;
   if (autoCreatedAgent) {
     const bootstrapPayload = buildMarathonAutoCreatedAgentBootstrap(normalizedAgent, {
       model: options.model || agentConfigModel || defaultConfiguredModel,
-      toolIds: resolvedToolIds
+      toolIds: resolvedToolIds,
+      fallbackModel: options.fallbackModel
     });
     try {
       await client.agents.update(agentId, bootstrapPayload);
@@ -17230,6 +17391,16 @@ ${rulesContext}`;
         );
       }
     }
+  } else if (options.fallbackModel || playbookMilestoneFallbackModels) {
+    const initialErrorHandling = resolveErrorHandlingForPhase(
+      currentPhase,
+      options.fallbackModel,
+      playbookMilestoneFallbackModels
+    );
+    if (initialErrorHandling) {
+      await client.agents.update(agentId, { config: { errorHandling: initialErrorHandling } }).catch(() => {
+      });
+    }
   }
   let localTools = buildLocalTools(client, parsedSandbox, options, {
     taskName,
@@ -17532,7 +17703,13 @@ Saving state... done. Session saved to ${filePath}`);
             model: event.model || effectiveModelForContext
           });
         },
-        ...resumeState ? { resumeState } : {},
+        ...resumeState || playbookPolicy ? {
+          resumeState: {
+            ...resumeState ?? {},
+            ...playbookPolicy?.outputRoot ? { outputRoot: playbookPolicy.outputRoot } : {},
+            ...playbookPolicy?.requireVerification !== void 0 ? { verificationRequired: playbookPolicy.requireVerification } : {}
+          }
+        } : {},
         toolContextMode: options.toolContext || "hot-tail",
         toolWindow: options.toolWindow === "session" || !options.toolWindow ? "session" : parseInt(options.toolWindow, 10) || 10,
         onSession: async (state) => {
@@ -17594,6 +17771,17 @@ Saving state... done. Session saved to ${filePath}`);
               options.model = newPhaseModel;
               modelChangedOnPhaseTransition = true;
             }
+            if (options.fallbackModel || playbookMilestoneFallbackModels) {
+              const newErrorHandling = resolveErrorHandlingForPhase(
+                resumeState.workflowPhase,
+                options.fallbackModel,
+                playbookMilestoneFallbackModels
+              );
+              client.agents.update(agentId, {
+                config: { errorHandling: newErrorHandling ?? null }
+              }).catch(() => {
+              });
+            }
           }
           if (state.recentActionKeys && state.recentActionKeys.length > 0) {
             for (const key of state.recentActionKeys) {
@@ -17970,7 +18158,7 @@ function resolveSandboxWorkflowSelection(message, sandboxProvider, resumeState)
   };
 }
 function applyTaskOptions(cmd) {
-  return cmd.argument("<agent>", "Agent ID or name").option("-g, --goal <text>", "Goal message for the agent").option("--max-sessions <n>", "Maximum sessions", "50").option("--max-cost <n>", "Budget in USD").option("--model <modelId>", "Model ID to use (overrides agent config)").option("--name <name>", "Task name (used for state file, defaults to agent name)").option("--session <name>", "Resume a specific session by name").option("--state-dir <path>", "Directory for state files (default: ~/.runtype/projects/<hash>/marathons/)").option("--resume [message]", "Resume from existing local state, optionally with a new message").option("--fresh", "Start a new run and ignore any existing local state for this task").option("--compact", "Force compact-summary resume mode instead of replaying full history").option("--compact-strategy <strategy>", "Compaction strategy: auto (default), provider_native, or summary_fallback").option("--compact-threshold <value>", "Auto-compact when estimated context crosses this threshold (default: 80% fallback, 90% native; accepts percent like 90% or absolute token count like 120000)").option("--compact-instructions <text>", "Extra instructions for what a compact summary must preserve").option("--no-auto-compact", "Disable automatic context-aware history compaction").option("--track", "Sync progress to a Runtype record (visible in dashboard)").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").option("--sandbox <provider>", "Enable sandbox code execution tool (cloudflare-worker, quickjs, or daytona)").option("--no-local-tools", "Disable built-in local tool execution (read_file, write_file, list_directory)").option("-t, --tools <tools...>", "Enable built-in tools (e.g., exa, firecrawl, dalle, openai_web_search, anthropic_web_search)").option("--plain-text", "Disable markdown rendering in output").option("--no-reasoning", "Disable model reasoning/thinking (enabled by default for supported models)").option("--no-checkpoint", "Run all iterations without checkpoint pauses (fully autonomous)").option("--checkpoint-timeout <seconds>", "Auto-continue timeout in seconds (default: 10)", "10").option("--planning-model <modelId>", "Model to use during research/planning phases").option("--execution-model <modelId>", "Model to use during execution phase").option("--playbook <name>", "Load a playbook from .runtype/marathons/playbooks/").option("--offload-threshold <chars>", 'Offload tool outputs larger than this to files (default: 100000; use "off" or "0" to disable guardrails)').option("--tool-context <mode>", "Tool result storage: hot-tail (default), observation-mask, or full-inline").option("--tool-window <window>", 'Compaction window: "session" (default) or a number for last-N tool results (e.g. 10)').option("--runner-char <char>", "Custom runner emoji (default: \u{1F3C3})").option("--finish-char <char>", "Custom finish line emoji (default: \u{1F3C1})").option("--no-runner", "Hide the runner emoji from the header border").option("--no-finish", "Hide the finish line emoji from the header border").action(taskAction);
+  return cmd.argument("<agent>", "Agent ID or name").option("-g, --goal <text>", "Goal message for the agent").option("--max-sessions <n>", "Maximum sessions", "50").option("--max-cost <n>", "Budget in USD").option("--model <modelId>", "Model ID to use (overrides agent config)").option("--name <name>", "Task name (used for state file, defaults to agent name)").option("--session <name>", "Resume a specific session by name").option("--state-dir <path>", "Directory for state files (default: ~/.runtype/projects/<hash>/marathons/)").option("--resume [message]", "Resume from existing local state, optionally with a new message").option("--fresh", "Start a new run and ignore any existing local state for this task").option("--compact", "Force compact-summary resume mode instead of replaying full history").option("--compact-strategy <strategy>", "Compaction strategy: auto (default), provider_native, or summary_fallback").option("--compact-threshold <value>", "Auto-compact when estimated context crosses this threshold (default: 80% fallback, 90% native; accepts percent like 90% or absolute token count like 120000)").option("--compact-instructions <text>", "Extra instructions for what a compact summary must preserve").option("--no-auto-compact", "Disable automatic context-aware history compaction").option("--track", "Sync progress to a Runtype record (visible in dashboard)").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").option("--sandbox <provider>", "Enable sandbox code execution tool (cloudflare-worker, quickjs, or daytona)").option("--no-local-tools", "Disable built-in local tool execution (read_file, write_file, list_directory)").option("-t, --tools <tools...>", "Enable built-in tools (e.g., exa, firecrawl, dalle, openai_web_search, anthropic_web_search)").option("--plain-text", "Disable markdown rendering in output").option("--no-reasoning", "Disable model reasoning/thinking (enabled by default for supported models)").option("--no-checkpoint", "Run all iterations without checkpoint pauses (fully autonomous)").option("--checkpoint-timeout <seconds>", "Auto-continue timeout in seconds (default: 10)", "10").option("--planning-model <modelId>", "Model to use during research/planning phases").option("--execution-model <modelId>", "Model to use during execution phase").option("--fallback-model <modelId>", "Model to fall back to when primary model fails").option("--playbook <name>", "Load a playbook from .runtype/marathons/playbooks/").option("--offload-threshold <chars>", 'Offload tool outputs larger than this to files (default: 100000; use "off" or "0" to disable guardrails)').option("--tool-context <mode>", "Tool result storage: hot-tail (default), observation-mask, or full-inline").option("--tool-window <window>", 'Compaction window: "session" (default) or a number for last-N tool results (e.g. 10)').option("--runner-char <char>", "Custom runner emoji (default: \u{1F3C3})").option("--finish-char <char>", "Custom finish line emoji (default: \u{1F3C1})").option("--no-runner", "Hide the runner emoji from the header border").option("--no-finish", "Hide the finish line emoji from the header border").action(taskAction);
 }
 var taskCommand = applyTaskOptions(
   new Command10("task").description("Run a multi-session agent task")