squad-kit 0.9.1 → 0.10.0

package/dist/cli.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { Command } from "commander";
+import { Command, Option } from "commander";
 
 // src/ui/banner.ts
 import boxen from "boxen";
@@ -349,6 +349,20 @@ function mergePlanner(base, override) {
     validation: {
       enabled: override.validation?.enabled ?? base?.validation?.enabled ?? true,
       strict: override.validation?.strict ?? base?.validation?.strict ?? false
+    },
+    runtime: {
+      anthropic: override.runtime?.anthropic ?? base?.runtime?.anthropic ?? "agent-sdk"
+    },
+    providerOptions: {
+      anthropic: {
+        thinking: override.providerOptions?.anthropic?.thinking ?? base?.providerOptions?.anthropic?.thinking ?? "adaptive",
+        effort: override.providerOptions?.anthropic?.effort ?? base?.providerOptions?.anthropic?.effort ?? "medium",
+        effortByPhase: {
+          scout: override.providerOptions?.anthropic?.effortByPhase?.scout ?? base?.providerOptions?.anthropic?.effortByPhase?.scout ?? "minimal",
+          draft: override.providerOptions?.anthropic?.effortByPhase?.draft ?? base?.providerOptions?.anthropic?.effortByPhase?.draft ?? "medium"
+        },
+        thinkingBudget: override.providerOptions?.anthropic?.thinkingBudget ?? base?.providerOptions?.anthropic?.thinkingBudget
+      }
     }
   };
   if (merged.modelOverride) {
@@ -427,6 +441,12 @@ function parseConfig(raw, configFile) {
         "planner.budget.maxDurationSeconds must be > 0. Run `squad config set planner` to fix planner.budget values."
       );
     }
+    const ar = merged.planner.runtime?.anthropic;
+    if (ar !== void 0 && ar !== "agent-sdk" && ar !== "vercel") {
+      throw new Error(
+        "planner.runtime.anthropic must be agent-sdk or vercel. Run `squad config set planner` to fix it."
+      );
+    }
   }
   return merged;
 }
@@ -1025,6 +1045,14 @@ async function runConfigUnsetPlanner(opts = {}) {
   info("Re-enable any time with `squad config set planner`.");
 }
 
+// src/core/ci-env.ts
+function skipExternalProbesInAutomation() {
+  const c = process.env.CI;
+  if (c === "true" || c === "1") return true;
+  if (process.env.GITHUB_ACTIONS) return true;
+  return false;
+}
+
 // src/commands/config/set-planner.ts
 function parseProvider(arg) {
   if (!["anthropic", "openai", "google"].includes(arg)) {
@@ -1153,20 +1181,27 @@ async function runConfigSetPlanner(opts = {}) {
     kv("model (execute)", execModel, 10);
     kv("credential", `${cred.source} (${sourceText})`, 10);
   }
-  if (process.env.CI === "true" || !cred) {
+  if (skipExternalProbesInAutomation() || !cred) {
     printPlannerNextSteps(Boolean(cred));
     return;
   }
-  const listed = await fetchProviderModelIds(provider, cred.value);
-  if (!listed.ok) {
-    const st = listed.status;
-    if (st === 401 || st === 403) {
-      warning(`Could not list models (HTTP ${st}); check your key.`);
+  try {
+    const listed = await fetchProviderModelIds(provider, cred.value);
+    if (!listed.ok) {
+      const st = listed.status;
+      if (st === 401 || st === 403) {
+        warning(`Could not list models (HTTP ${st}); check your key.`);
+      } else {
+        warning(`Model list probe failed (HTTP ${st}): ${listed.body.slice(0, 120)}`);
+      }
     } else {
-      warning(`Model list probe failed (HTTP ${st}): ${listed.body.slice(0, 120)}`);
+      info("Credential check: models API responded OK for this key.");
     }
-  } else {
-    info("Credential check: models API responded OK for this key.");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    warning(
+      `Could not reach provider model list (${msg.slice(0, 160)}). Key was saved; run \`squad doctor\` to verify.`
+    );
   }
   printPlannerNextSteps(true);
 }
@@ -2010,7 +2045,7 @@ async function runConfigSetTracker(opts = {}) {
   if (next.tracker.project) {
     kv("project", next.tracker.project, 10);
   }
-  if (process.env.CI === "true") {
+  if (skipExternalProbesInAutomation()) {
     printTrackerNextSteps(next.tracker.type);
     return;
   }
@@ -3296,17 +3331,32 @@ function noCandidateReason() {
 // src/planner/loop.ts
 import path19 from "path";
 import fs27 from "fs";
-import { APICallError as APICallError2 } from "ai";
+import { APICallError as APICallError3 } from "ai";
+
+// src/planner/tools/index.ts
+import { randomUUID } from "crypto";
 
 // src/planner/tools/read-file.ts
 import fs21 from "fs";
 import path13 from "path";
 import { tool } from "ai";
 import { z } from "zod";
-var READ_FILE_TOOL_NAME = "read_file";
 var MAX_BYTES_PER_FULL_READ = 32e3;
 var MAX_LINES_PER_RANGED_READ = 400;
 var MAX_BYTES_FOR_SYNC_LINE_SPLIT = 2e6;
+var rangedReadFileSchema = z.object({
+  path: z.string().min(1).describe("Repo-relative POSIX path."),
+  offset: z.number().int().min(1).optional().describe("1-indexed line number to start reading at (use with limit)."),
+  limit: z.number().int().min(1).max(MAX_LINES_PER_RANGED_READ).optional().describe(`Line count from offset (max ${MAX_LINES_PER_RANGED_READ}).`)
+}).refine(
+  (o) => o.offset === void 0 && o.limit === void 0 || o.offset !== void 0 && o.limit !== void 0,
+  { message: "Provide both offset and limit for a ranged read, or neither for a full read." }
+);
+var fullReadFileSchema = z.object({
+  path: z.string().min(1).describe("Repo-relative POSIX path.")
+});
+var READ_FILE_TOOL_DESCRIPTION = "Read a UTF-8 text file from the project, returning its contents so you can plan against real code. Pass `offset` and `limit` together to read a line range (preferred when you know the region). Without them the whole file is read, capped at 32 KB. Paths must be relative to the project root. Binary files are refused. You have a bounded context budget; prefer small, targeted reads.";
+var READ_FILE_TOOL_DESCRIPTION_WHOLE_ONLY = "Read a UTF-8 text file from the project, returning its contents so you can plan against real code. Whole-file reads only; capped at 32 KB. Paths must be relative to the project root. Binary files are refused. You have a bounded context budget; prefer small, targeted reads.";
 function readFileTool(root, budget, input5) {
   const raw = typeof input5.path === "string" ? input5.path : "";
   if (!raw.length) {
@@ -3392,66 +3442,6 @@ function readFileRanged(resolved, rawRel, budget, fileSize, offset, limit) {
   budget.recordRead(bytes);
   return { content: out, isError: false };
 }
-function readFileToolFactory(root, budget, hooks, opts) {
-  const ranged = opts?.ranged ?? true;
-  const params = ranged ? z.object({
-    path: z.string().min(1).describe("Repo-relative POSIX path."),
-    offset: z.number().int().min(1).optional().describe("1-indexed line number to start reading at (use with limit)."),
-    limit: z.number().int().min(1).max(MAX_LINES_PER_RANGED_READ).optional().describe(`Line count from offset (max ${MAX_LINES_PER_RANGED_READ}).`)
-  }).refine(
-    (o) => o.offset === void 0 && o.limit === void 0 || o.offset !== void 0 && o.limit !== void 0,
-    { message: "Provide both offset and limit for a ranged read, or neither for a full read." }
-  ) : z.object({
-    path: z.string().min(1).describe("Repo-relative POSIX path.")
-  });
-  return tool({
-    description: "Read a UTF-8 text file from the project, returning its contents so you can plan against real code. " + (ranged ? "Pass `offset` and `limit` together to read a line range (preferred when you know the region). Without them the whole file is read, capped at 32 KB. " : "Whole-file reads only; capped at 32 KB. ") + "Paths must be relative to the project root. Binary files are refused. You have a bounded context budget; prefer small, targeted reads.",
-    parameters: params,
-    execute: async (args, { toolCallId }) => {
-      const tc = {
-        id: toolCallId,
-        name: READ_FILE_TOOL_NAME,
-        input: { path: args.path, offset: args.offset, limit: args.limit }
-      };
-      const before = budget.snapshot().bytes;
-      let result = readFileTool(root, budget, args);
-      let after = budget.snapshot().bytes;
-      let bytesLoaded = after - before;
-      hooks.onToolCall?.(tc, bytesLoaded, after);
-      hooks.bus.emit({
-        kind: "tool_call",
-        runId: hooks.runId,
-        turn: hooks.turn,
-        toolCall: tc,
-        bytesLoaded,
-        totalBytes: after
-      });
-      if (readBudgetishError(result)) {
-        const decide = hooks.decideOnLimit;
-        if (decide) {
-          const d = await decide(hooks.getLimitCtx());
-          if (d === "cancel") {
-            throw new PlannerUserCancelledError(
-              hooks.getAccumulatedText(),
-              hooks.runId,
-              hooks.turn,
-              "budget_reads",
-              tc,
-              result
-            );
-          }
-          hooks.extendSessionLimits();
-          result = readFileTool(root, budget, args);
-          after = budget.snapshot().bytes;
-          bytesLoaded = after - before;
-        } else {
-          hooks.setBudgetExhausted(true);
-        }
-      }
-      return { content: result.content, isError: result.isError };
-    }
-  });
-}
 var PlannerUserCancelledError = class _PlannerUserCancelledError extends Error {
   constructor(planText, runId, turn, incompleteKind, toolCall, pendingResult) {
     super("PlannerUserCancelledError");
@@ -3630,38 +3620,13 @@ function walkFlat(root, dir, ig, out, max, includeHidden) {
 var MAX_GREP_MATCHES = 200;
 var MAX_GREP_FILE_SIZE_BYTES = 1e6;
 var GREP_TOOL_NAME = "grep";
-function grepToolFactory(root, budget, hooks) {
-  return tool2({
-    description: "Search the project for a literal string or regex pattern. Returns up to 200 matches across files, each shown as `path:line:match`. Use this BEFORE `read_file` to locate symbols or call sites; it is much cheaper than reading whole files.",
-    parameters: z2.object({
-      pattern: z2.string().min(1).describe("Literal string or regex (default literal)."),
-      regex: z2.boolean().optional().default(false),
-      path: z2.string().optional().describe("Optional sub-path to scope the search to (relative)."),
-      caseInsensitive: z2.boolean().optional().default(false)
-    }),
-    execute: async (args, { toolCallId }) => {
-      const tc = {
-        id: toolCallId,
-        name: GREP_TOOL_NAME,
-        input: { ...args }
-      };
-      const before = budget.snapshot().bytes;
-      const out = runGrep(root, budget, args);
-      const after = budget.snapshot().bytes;
-      const bytesLoaded = after - before;
-      hooks.onToolCall?.(tc, bytesLoaded, after);
-      hooks.bus.emit({
-        kind: "tool_call",
-        runId: hooks.runId,
-        turn: hooks.turn,
-        toolCall: tc,
-        bytesLoaded,
-        totalBytes: after
-      });
-      return out;
-    }
-  });
-}
+var grepSchema = z2.object({
+  pattern: z2.string().min(1).describe("Literal string or regex (default literal)."),
+  regex: z2.boolean().optional().default(false),
+  path: z2.string().optional().describe("Optional sub-path to scope the search to (relative)."),
+  caseInsensitive: z2.boolean().optional().default(false)
+});
+var GREP_TOOL_DESCRIPTION = "Search the project for a literal string or regex pattern. Returns up to 200 matches across files, each shown as `path:line:match`. Use this BEFORE `read_file` to locate symbols or call sites; it is much cheaper than reading whole files.";
 function runGrep(root, budget, args) {
   const exec = budget.canExecuteTool();
   if (!exec.ok) {
@@ -3791,34 +3756,10 @@ import { tool as tool3 } from "ai";
 import { z as z3 } from "zod";
 var MAX_ENTRIES_PER_LIST = 200;
 var LIST_DIR_TOOL_NAME = "list_dir";
-function listDirToolFactory(root, budget, hooks) {
-  return tool3({
-    description: "List the contents of a directory in the project (one level deep). Returns up to 200 entries with type (file/dir) and size. Cheap; use this to discover sibling files before reading them.",
-    parameters: z3.object({
-      path: z3.string().describe('Repo-relative directory path. Use "." for the project root.')
-    }),
-    execute: async (args, { toolCallId }) => {
-      const tc = {
-        id: toolCallId,
-        name: LIST_DIR_TOOL_NAME,
-        input: { path: args.path }
-      };
-      const before = budget.snapshot().bytes;
-      const out = runListDir(root, budget, args.path);
-      const after = budget.snapshot().bytes;
-      hooks.onToolCall?.(tc, after - before, after);
-      hooks.bus.emit({
-        kind: "tool_call",
-        runId: hooks.runId,
-        turn: hooks.turn,
-        toolCall: tc,
-        bytesLoaded: after - before,
-        totalBytes: after
-      });
-      return out;
-    }
-  });
-}
+var listDirSchema = z3.object({
+  path: z3.string().describe('Repo-relative directory path. Use "." for the project root.')
+});
+var LIST_DIR_TOOL_DESCRIPTION = "List the contents of a directory in the project (one level deep). Returns up to 200 entries with type (file/dir) and size. Cheap; use this to discover sibling files before reading them.";
 function runListDir(root, budget, rawPath) {
   const exec = budget.canExecuteTool();
   if (!exec.ok) {
@@ -3895,26 +3836,132 @@ ${lines.join("\n")}` : "(empty directory)";
 }
 
 // src/planner/tools/index.ts
-function buildPlannerTools(opts) {
+import { tool as tool4 } from "ai";
+function buildPlannerToolDefinitions(opts) {
   const enabled = opts.enabled ?? { rangedRead: true, grep: true, listDir: true };
-  const gh = opts.grepHooks ?? {
-    runId: opts.readHooks.runId,
-    turn: opts.readHooks.turn,
-    bus: opts.readHooks.bus,
-    onToolCall: opts.readHooks.onToolCall
-  };
-  const lh = opts.listDirHooks ?? {
-    runId: opts.readHooks.runId,
-    turn: opts.readHooks.turn,
-    bus: opts.readHooks.bus,
-    onToolCall: opts.readHooks.onToolCall
-  };
-  const readOpts = { ranged: enabled.rangedRead ?? true };
-  return {
-    read_file: readFileToolFactory(opts.root, opts.budget, opts.readHooks, readOpts),
-    ...enabled.grep ? { grep: grepToolFactory(opts.root, opts.budget, gh) } : {},
-    ...enabled.listDir ? { list_dir: listDirToolFactory(opts.root, opts.budget, lh) } : {}
-  };
+  const ranged = enabled.rangedRead ?? true;
+  const defs = [];
+  const readParams = ranged ? rangedReadFileSchema : fullReadFileSchema;
+  const readDesc = ranged ? READ_FILE_TOOL_DESCRIPTION : READ_FILE_TOOL_DESCRIPTION_WHOLE_ONLY;
+  defs.push({
+    name: "read_file",
+    description: readDesc,
+    parameters: readParams,
+    execute: async (args) => {
+      const turn = opts.getTurn();
+      const tc = {
+        id: randomUUID(),
+        name: "read_file",
+        input: { path: args.path, offset: args.offset, limit: args.limit }
+      };
+      const before = opts.budget.snapshot().bytes;
+      let result = readFileTool(opts.root, opts.budget, args);
+      let after = opts.budget.snapshot().bytes;
+      let bytesLoaded = after - before;
+      opts.onToolCall?.(tc, bytesLoaded, after);
+      opts.bus.emit({
+        kind: "tool_call",
+        runId: opts.runId,
+        turn,
+        toolCall: tc,
+        bytesLoaded,
+        totalBytes: after
+      });
+      if (readBudgetishError(result)) {
+        const decide = opts.decideOnLimit;
+        if (decide) {
+          const d = await decide(opts.getLimitCtx());
+          if (d === "cancel") {
+            throw new PlannerUserCancelledError(opts.getAccumulatedText(), opts.runId, turn, "budget_reads", tc, result);
+          }
+          opts.extendSessionLimits();
+          result = readFileTool(opts.root, opts.budget, args);
+          after = opts.budget.snapshot().bytes;
+          bytesLoaded = after - before;
+        } else {
+          opts.setBudgetExhausted(true);
+        }
+      }
+      return { content: result.content, isError: result.isError };
+    }
+  });
+  if (enabled.grep) {
+    defs.push({
+      name: GREP_TOOL_NAME,
+      description: GREP_TOOL_DESCRIPTION,
+      parameters: grepSchema,
+      execute: async (args) => {
+        const turn = opts.getTurn();
+        const tc = {
+          id: randomUUID(),
+          name: GREP_TOOL_NAME,
+          input: { ...args }
+        };
+        const before = opts.budget.snapshot().bytes;
+        const out = runGrep(opts.root, opts.budget, {
+          pattern: args.pattern,
+          regex: args.regex ?? false,
+          path: args.path,
+          caseInsensitive: args.caseInsensitive ?? false
+        });
+        const after = opts.budget.snapshot().bytes;
+        const bytesLoaded = after - before;
+        opts.onToolCall?.(tc, bytesLoaded, after);
+        opts.bus.emit({
+          kind: "tool_call",
+          runId: opts.runId,
+          turn,
+          toolCall: tc,
+          bytesLoaded,
+          totalBytes: after
+        });
+        return { content: out.content, isError: out.isError };
+      }
+    });
+  }
+  if (enabled.listDir) {
+    defs.push({
+      name: LIST_DIR_TOOL_NAME,
+      description: LIST_DIR_TOOL_DESCRIPTION,
+      parameters: listDirSchema,
+      execute: async (args) => {
+        const turn = opts.getTurn();
+        const tc = {
+          id: randomUUID(),
+          name: LIST_DIR_TOOL_NAME,
+          input: { path: args.path }
+        };
+        const before = opts.budget.snapshot().bytes;
+        const out = runListDir(opts.root, opts.budget, args.path);
+        const after = opts.budget.snapshot().bytes;
+        opts.onToolCall?.(tc, after - before, after);
+        opts.bus.emit({
+          kind: "tool_call",
+          runId: opts.runId,
+          turn,
+          toolCall: tc,
+          bytesLoaded: after - before,
+          totalBytes: after
+        });
+        return { content: out.content, isError: out.isError };
+      }
+    });
+  }
+  return defs;
+}
+function vercelToolsFromDefinitions(defs) {
+  const out = {};
+  for (const def of defs) {
+    out[def.name] = tool4({
+      description: def.description,
+      parameters: def.parameters,
+      execute: async (args) => {
+        const r = await def.execute(args);
+        return typeof r === "string" ? r : r;
+      }
+    });
+  }
+  return out;
 }
 
 // src/planner/provider-errors.ts
@@ -4004,7 +4051,87 @@ function rateLimitMessage(err2) {
   ].join("\n");
 }
 
+// src/core/runs.ts
+import fs25 from "fs/promises";
+import path17 from "path";
+import { randomBytes } from "crypto";
+var RING_SIZE = 20;
+function newRunId() {
+  const ts = Date.now().toString(36).padStart(9, "0");
+  const rnd = randomBytes(8).toString("hex");
+  return `${ts}-${rnd}`;
+}
+async function appendRun(paths, rec) {
+  const dir = path17.join(paths.squadDir, "runs");
+  await fs25.mkdir(dir, { recursive: true });
+  const file = path17.join(dir, `${rec.runId}.json`);
+  await fs25.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
+  await pruneOldRuns(dir);
+}
+async function pruneOldRuns(dir) {
+  const entries = (await fs25.readdir(dir)).filter((n) => n.endsWith(".json"));
+  if (entries.length <= RING_SIZE) return;
+  entries.sort();
+  const drop = entries.slice(0, entries.length - RING_SIZE);
+  await Promise.all(drop.map((n) => fs25.rm(path17.join(dir, n), { force: true })));
+}
+async function listRuns(paths) {
+  const dir = path17.join(paths.squadDir, "runs");
+  let entries;
+  try {
+    entries = await fs25.readdir(dir);
+  } catch {
+    return [];
+  }
+  const files = entries.filter((n) => n.endsWith(".json")).sort().reverse();
+  const out = [];
+  for (const f of files) {
+    try {
+      const raw = await fs25.readFile(path17.join(dir, f), "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === 1) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/planner/session-limits.ts
+var DEFAULT_PLANNER_MAX_ITERATIONS = 40;
+var PLANNER_MARKDOWN_CONTINUATION_USER = "Your previous reply was cut off because it hit the per-response output token limit for this request. Continue the Markdown plan from the exact cut-off only: write the remainder, do not repeat headings or paragraphs already sent. When the plan is complete, use end_turn without unnecessary tool calls.";
+
+// src/planner/runtimes/vercel-runtime.ts
+import { APICallError, generateObject, NoObjectGeneratedError } from "ai";
+
+// src/planner/providers/index.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+function resolveModel(provider, modelId, apiKey) {
+  switch (provider) {
+    case "anthropic":
+      return { provider, model: createAnthropic({ apiKey })(modelId), modelId };
+    case "openai":
+      return { provider, model: createOpenAI({ apiKey })(modelId), modelId };
+    case "google":
+      return { provider, model: createGoogleGenerativeAI({ apiKey })(modelId), modelId };
+  }
+}
+
 // src/planner/usage-map.ts
+function usageFromAgentSdkResult(usage) {
+  const inTok = usage?.input_tokens ?? 0;
+  const outTok = usage?.output_tokens ?? 0;
+  const out = {
+    inputTokens: inTok ?? 0,
+    outputTokens: outTok ?? 0
+  };
+  const cc = usage?.cache_creation_input_tokens;
+  const cr = usage?.cache_read_input_tokens;
+  if (cc != null && cc > 0) out.cacheCreationTokens = cc;
+  if (cr != null && cr > 0) out.cacheReadTokens = cr;
+  return out;
+}
 function usageFromLanguageModelStep(usage, providerMetadata) {
   const out = {
     inputTokens: usage.promptTokens,
@@ -4135,74 +4262,558 @@ function turnsToCoreMessages(systemPrompt, turns, opts) {
   return messages;
 }
 
-// src/core/runs.ts
-import fs25 from "fs/promises";
-import path17 from "path";
-import { randomBytes } from "crypto";
-var RING_SIZE = 20;
-function newRunId() {
-  const ts = Date.now().toString(36).padStart(9, "0");
-  const rnd = randomBytes(8).toString("hex");
-  return `${ts}-${rnd}`;
-}
-async function appendRun(paths, rec) {
-  const dir = path17.join(paths.squadDir, "runs");
-  await fs25.mkdir(dir, { recursive: true });
-  const file = path17.join(dir, `${rec.runId}.json`);
-  await fs25.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
-  await pruneOldRuns(dir);
+// src/planner/runtimes/vercel-runtime.ts
+var MAX_RATE_LIMIT_RETRY_SEC = 90;
+function isAbortError(e) {
+  return e instanceof Error && e.name === "AbortError";
 }
-async function pruneOldRuns(dir) {
-  const entries = (await fs25.readdir(dir)).filter((n) => n.endsWith(".json"));
-  if (entries.length <= RING_SIZE) return;
-  entries.sort();
-  const drop = entries.slice(0, entries.length - RING_SIZE);
-  await Promise.all(drop.map((n) => fs25.rm(path17.join(dir, n), { force: true })));
+async function defaultSleep(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function listRuns(paths) {
-  const dir = path17.join(paths.squadDir, "runs");
-  let entries;
-  try {
-    entries = await fs25.readdir(dir);
-  } catch {
-    return [];
+async function sleepWithAbort(ms, sleepFn, abort) {
+  if (!abort) {
+    await sleepFn(ms);
+    return;
   }
-  const files = entries.filter((n) => n.endsWith(".json")).sort().reverse();
-  const out = [];
-  for (const f of files) {
+  if (abort.aborted) throw new DOMException("Aborted", "AbortError");
+  await Promise.race([
+    sleepFn(ms),
+    new Promise((_, reject) => {
+      abort.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true });
+    })
+  ]);
+}
+function asToolInput(args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) return args;
+  if (typeof args === "string") {
     try {
-      const raw = await fs25.readFile(path17.join(dir, f), "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed.version === 1) out.push(parsed);
+      return JSON.parse(args);
     } catch {
+      return {};
     }
   }
-  return out;
+  return {};
 }
-
-// src/planner/session-limits.ts
-var DEFAULT_PLANNER_MAX_ITERATIONS = 40;
-var PLANNER_MARKDOWN_CONTINUATION_USER = "Your previous reply was cut off because it hit the per-response output token limit for this request. Continue the Markdown plan from the exact cut-off only: write the remainder, do not repeat headings or paragraphs already sent. When the plan is complete, use end_turn without unnecessary tool calls.";
-
-// src/planner/events.ts
-var PlannerEventBus = class {
-  listeners = /* @__PURE__ */ new Set();
-  emit(e) {
-    for (const fn of this.listeners) {
-      try {
-        fn(e);
-      } catch {
-      }
-    }
-  }
-  subscribe(fn) {
+function normalizeToolExecutionResult(result) {
+  if (typeof result === "string") {
+    try {
+      const j = JSON.parse(result);
+      if (j && typeof j === "object" && !Array.isArray(j) && "content" in j) {
+        const o = j;
+        return {
+          content: typeof o.content === "string" ? o.content : JSON.stringify(o.content ?? ""),
+          isError: o.isError === true
+        };
+      }
+    } catch {
+    }
+    return { content: result, isError: false };
+  }
+  if (result && typeof result === "object" && !Array.isArray(result) && "content" in result) {
+    const o = result;
+    return {
+      content: typeof o.content === "string" ? o.content : JSON.stringify(o.content ?? ""),
+      isError: o.isError === true
+    };
+  }
+  return { content: typeof result === "undefined" ? "" : JSON.stringify(result), isError: false };
+}
+function applyStepToTurns(turns, step2) {
+  const callsById = /* @__PURE__ */ new Map();
+  const toolCalls = step2.toolCalls.map((tc) => {
+    callsById.set(tc.toolCallId, tc.toolName);
+    return { id: tc.toolCallId, name: tc.toolName, input: asToolInput(tc.args) };
+  });
+  turns.push({
+    role: "assistant",
+    ...step2.text ? { text: step2.text } : {},
+    ...toolCalls.length ? { toolCalls } : {}
+  });
+  if (step2.toolResults.length) {
+    const toolResults = step2.toolResults.map((tr) => {
+      const norm = normalizeToolExecutionResult(tr.result);
+      return {
+        toolCallId: tr.toolCallId,
+        name: callsById.get(tr.toolCallId) ?? "read_file",
+        content: norm.content,
+        ...norm.isError ? { isError: true } : {}
+      };
+    });
+    turns.push({ role: "user", toolResults });
+  }
+}
+function recordUsageAndEmit(bus, onUsage, budget, runId, turn, usage) {
+  budget.recordUsage(usage);
+  onUsage?.(usage);
+  bus.emit({ kind: "usage", runId, turn, usage });
+  const u = budget.snapshot().usage;
+  const cacheRead = u.cacheReadTokens ?? 0;
+  const cacheCreate = u.cacheCreationTokens ?? 0;
+  if (cacheRead > 0 || cacheCreate > 0) {
+    const inTok = u.inputTokens;
+    const totalInput = inTok + cacheRead;
+    const cacheHitRatio = totalInput === 0 ? 0 : Math.round(cacheRead / totalInput * 100) / 100;
+    bus.emit({
+      kind: "cache_summary",
+      runId,
+      turn,
+      cacheHitRatio,
+      cacheReadTokens: cacheRead,
+      cacheCreationTokens: cacheCreate
+    });
+  }
+}
+function providerResponseFromApiError(provider, modelId, err2) {
+  const body = err2.responseBody ?? "";
+  const nf = detectModelNotFound(provider, modelId, err2.statusCode ?? 0, body);
+  if (nf) {
+    return {
+      stopReason: "error",
+      errorKind: "model_not_found",
+      rawError: modelNotFoundMessage(nf)
+    };
+  }
+  const rl = detectRateLimit(provider, err2.statusCode ?? 0, err2.responseHeaders ?? {}, body);
+  if (rl) {
+    return {
+      stopReason: "error",
+      errorKind: "rate_limit",
+      retryAfterSec: rl.retryAfterSec,
+      rawError: `${provider} ${err2.statusCode ?? "error"}: ${body.slice(0, 500)}`
+    };
+  }
+  return {
+    stopReason: "error",
+    rawError: `${provider} ${err2.statusCode ?? "error"}: ${body.slice(0, 500)}`
+  };
+}
+function composePlannerError(providerName, response, retriedRateLimit, retrySkippedReason) {
+  if (response.errorKind === "rate_limit") {
+    return new Error(
+      rateLimitMessage({
+        provider: providerName,
+        retryAfterSec: response.retryAfterSec,
+        rawBody: response.rawError ?? "",
+        retryAlreadyAttempted: retriedRateLimit,
+        retrySkippedReason,
+        maxRetrySec: MAX_RATE_LIMIT_RETRY_SEC
+      })
+    );
+  }
+  if (response.errorKind === "model_not_found") {
+    return new Error(response.rawError ?? "planner: model not found");
+  }
+  const base = response.rawError ?? "planner: provider error";
+  return new Error(`${base} Run \`squad doctor\` to diagnose, or retry \u2014 most 5xx errors are transient.`);
+}
+var VercelRuntime = class {
+  kind = "vercel";
+  providerName;
+  modelId;
+  languageModel;
+  constructor(provider, modelId, apiKeyOrModel, injectModel) {
+    this.providerName = provider;
+    this.modelId = modelId;
+    if (injectModel === true) {
+      if (typeof apiKeyOrModel === "string") {
+        throw new Error("VercelRuntime: injectModel mode expects a LanguageModelV1 as third argument");
+      }
+      this.languageModel = apiKeyOrModel;
+      return;
+    }
+    if (typeof apiKeyOrModel !== "string") {
+      throw new Error("VercelRuntime: apiKey must be a string unless injectModel is true");
+    }
+    this.languageModel = resolveModel(provider, modelId, apiKeyOrModel).model;
+  }
+  async runScout(input5) {
+    let attempt = 0;
+    while (true) {
+      try {
+        const { object, usage, providerMetadata } = await generateObject({
+          model: this.languageModel,
+          system: input5.systemPrompt,
+          prompt: input5.userMessage,
+          schema: input5.schema,
+          maxTokens: input5.maxOutputTokens,
+          abortSignal: input5.abort
+        });
+        const u = usageFromLanguageModelStep(usage, providerMetadata);
+        return {
+          output: object,
+          usage: u
+        };
+      } catch (e) {
+        if (NoObjectGeneratedError.isInstance(e)) {
+          return null;
+        }
+        if (APICallError.isInstance(e) && attempt === 0) {
+          const status = e.statusCode ?? 0;
+          if (status === 429) {
+            const ra = parseRetryAfterSec(e.responseHeaders ?? {});
+            if (ra !== void 0 && ra <= 90) {
+              await new Promise((r) => setTimeout(r, ra * 1e3));
+              attempt += 1;
+              continue;
+            }
+          }
+        }
+        throw e;
+      }
+    }
+  }
+  async runDraft(input5) {
+    const vl = input5.vercelLoop;
+    if (!vl) {
+      throw new Error("planner: Vercel runtime requires vercelLoop context");
+    }
+    const bus = input5.bus;
+    const runId = input5.runId;
+    const sleepFn = vl.sleep ?? defaultSleep;
+    const baseMaxIter = input5.maxSteps ?? DEFAULT_PLANNER_MAX_ITERATIONS;
+    const maxIter = { current: baseMaxIter };
+    const baseMaxOut = input5.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS;
+    const maxOut = { current: baseMaxOut };
+    const turns = [{ role: "user", text: vl.userPrompt }];
+    if (vl.scoutedSection?.trim()) {
+      turns.push({ role: "user", text: composeScoutedUserMessage({ scoutedSection: vl.scoutedSection }) });
+    }
+    let accumulatedText = "";
+    let iterations = 0;
+    let budgetExhausted = false;
+    let finishedNormally = false;
+    const decide = vl.decideOnLimit;
+    const limitCtx = (kind) => ({
+      kind,
+      budgetSnapshot: input5.budget.snapshot(),
+      iterations,
+      maxIterations: maxIter.current,
+      maxOutputTokens: maxOut.current
+    });
+    const extendAllSessionLimits = () => {
+      input5.budget.extendSession();
+      maxIter.current += baseMaxIter;
+      maxOut.current += baseMaxOut;
+    };
+    for (; ; ) {
+      if (input5.abort?.aborted) {
+        bus.emit({ kind: "cancelled", runId });
+        return {
+          text: accumulatedText,
+          finishedNormally: false,
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted,
+          userCancelled: true
+        };
+      }
+      if (iterations >= maxIter.current) {
+        if (decide) {
+          const d = await decide(limitCtx("max_iterations"));
+          if (d === "cancel") {
+            return {
+              text: accumulatedText,
+              finishedNormally: false,
+              incompleteKind: "max_iterations",
+              iterations,
+              finalUsage: input5.budget.snapshot().usage,
+              budgetExhausted,
+              userCancelled: true
+            };
+          }
+          extendAllSessionLimits();
+          continue;
+        }
+        return {
+          text: accumulatedText,
+          finishedNormally: false,
+          incompleteKind: "max_iterations",
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted
+        };
+      }
+      iterations += 1;
+      if (input5.budget.timedOut()) {
+        if (decide) {
+          const d = await decide(limitCtx("wall_clock"));
+          if (d === "cancel") {
+            return {
+              text: accumulatedText,
+              finishedNormally: false,
+              incompleteKind: "wall_clock",
+              iterations,
+              finalUsage: input5.budget.snapshot().usage,
+              budgetExhausted,
+              timedOut: true,
+              userCancelled: true
+            };
+          }
+          extendAllSessionLimits();
+          iterations -= 1;
+          continue;
+        }
+        return {
+          text: accumulatedText,
+          finishedNormally: false,
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted,
+          timedOut: true
+        };
+      }
+      if (iterations >= 2) {
+        bus.emit({ kind: "turn_started", runId, turn: iterations });
+      }
+      const toolDefs = buildPlannerToolDefinitions({
+        root: vl.root,
+        budget: input5.budget,
+        enabled: vl.toolsEnabled,
+        getTurn: () => iterations,
+        runId,
+        bus,
+        onToolCall: input5.onToolCall,
+        decideOnLimit: vl.decideOnLimit,
+        getLimitCtx: () => limitCtx("file_or_context_reads"),
+        extendSessionLimits: extendAllSessionLimits,
+        getAccumulatedText: () => accumulatedText,
+        setBudgetExhausted: (v) => {
+          budgetExhausted = v;
+        }
+      });
+      const tools = vercelToolsFromDefinitions(toolDefs);
+      const messages = turnsToCoreMessages(input5.systemPrompt, turns, {
+        cacheEnabled: vl.cacheEnabled,
+        provider: vl.provider
+      });
+      bus.emit({ kind: "request_sent", runId, turn: iterations });
+      let attempt = 0;
+      let stepResult;
+      let retrySkippedReason;
+      let retriedRateLimit = false;
+      const callStream = async () => {
+        const { streamText } = await import("ai");
+        const stream = streamText({
+          model: this.languageModel,
+          messages,
+          tools,
+          toolChoice: "auto",
+          maxSteps: 1,
+          maxRetries: 0,
+          maxTokens: maxOut.current,
+          abortSignal: input5.abort,
+          onChunk: ({ chunk }) => {
+            if (chunk.type === "text-delta") {
+              accumulatedText += chunk.textDelta;
+              input5.onAssistantText?.(chunk.textDelta);
+              bus.emit({ kind: "assistant_text", runId, turn: iterations, delta: chunk.textDelta });
+            }
+          },
+          onStepFinish: (step2) => {
+            const u = usageFromLanguageModelStep(step2.usage, step2.providerMetadata);
+            recordUsageAndEmit(bus, input5.onUsage, input5.budget, runId, iterations, u);
+          }
+        });
+        for await (const part of stream.fullStream) {
+          const p = part;
+          if (p.type === "error") {
+            throw p.error;
+          }
+        }
+        const steps = await stream.steps;
+        const last = steps[steps.length - 1];
+        if (!last) throw new Error("planner: empty model step");
+        stepResult = {
+          text: last.text,
+          finishReason: last.finishReason,
+          toolCalls: last.toolCalls.flatMap(
+            (tc) => tc ? [
+              {
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args
+              }
+            ] : []
+          ),
+          toolResults: last.toolResults.flatMap(
+            (tr) => tr ? [{ toolCallId: tr.toolCallId, result: tr.result }] : []
+          ),
+          usage: last.usage,
+          providerMetadata: last.providerMetadata
+        };
+      };
+      try {
+        while (true) {
+          try {
+            await callStream();
+            break;
+          } catch (e) {
+            if (PlannerUserCancelledError.is(e)) {
+              return {
+                text: e.planText,
+                finishedNormally: false,
+                iterations,
+                finalUsage: input5.budget.snapshot().usage,
+                budgetExhausted: false,
+                userCancelled: true,
+                incompleteKind: "budget_reads"
+              };
+            }
+            if (isAbortError(e)) {
+              bus.emit({ kind: "cancelled", runId });
+              return {
+                text: accumulatedText,
+                finishedNormally: false,
+                iterations,
+                finalUsage: input5.budget.snapshot().usage,
+                budgetExhausted,
+                userCancelled: true
+              };
+            }
+            if (APICallError.isInstance(e)) {
+              const synthetic = providerResponseFromApiError(vl.provider, vl.modelId, e);
+              if (synthetic.errorKind === "rate_limit") {
+                const asked = synthetic.retryAfterSec;
+                const emitRateLimit = (phase, waitSec) => {
+                  bus.emit({
+                    kind: "rate_limit",
+                    runId,
+                    turn: iterations,
+                    retryAfterSec: synthetic.retryAfterSec,
+                    waitSec,
+                    capSec: MAX_RATE_LIMIT_RETRY_SEC,
+                    phase,
+                    provider: vl.provider,
+                    rawBody: (synthetic.rawError ?? "").slice(0, 200)
+                  });
+                };
+                if (asked !== void 0 && asked > MAX_RATE_LIMIT_RETRY_SEC) {
+                  emitRateLimit("aborted", asked);
+                  retrySkippedReason = "retry_after_too_long";
+                  throw composePlannerError(vl.provider, synthetic, false, retrySkippedReason);
+                }
+                if (attempt === 0) {
+                  const waitSec = Math.min(asked ?? 10, MAX_RATE_LIMIT_RETRY_SEC);
+                  emitRateLimit("retrying", waitSec);
+                  vl.onRateLimit?.(waitSec);
+                  await sleepWithAbort(waitSec * 1e3, sleepFn, input5.abort);
+                  attempt += 1;
+                  retriedRateLimit = true;
+                  continue;
+                }
+                throw composePlannerError(vl.provider, synthetic, true, retrySkippedReason);
+              }
+              throw composePlannerError(vl.provider, synthetic, retriedRateLimit, retrySkippedReason);
+            }
+            throw e;
+          }
+        }
+      } catch (e) {
+        if (isAbortError(e)) {
+          bus.emit({ kind: "cancelled", runId });
+          return {
+            text: accumulatedText,
+            finishedNormally: false,
+            iterations,
+            finalUsage: input5.budget.snapshot().usage,
+            budgetExhausted,
+            userCancelled: true
+          };
+        }
+        throw e;
+      }
+      const finishReason = stepResult.finishReason;
+      const toolCallsLen = stepResult.toolCalls.length;
+      if (finishReason === "length" && toolCallsLen === 0) {
+        bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: "max_tokens" });
+        if (decide) {
+          const d = await decide(limitCtx("max_output_tokens"));
+          if (d === "cancel") {
+            return {
+              text: accumulatedText,
+              finishedNormally: false,
+              incompleteKind: "max_output_tokens",
+              iterations,
+              finalUsage: input5.budget.snapshot().usage,
+              budgetExhausted,
+              userCancelled: true
+            };
+          }
+          extendAllSessionLimits();
+          applyStepToTurns(turns, stepResult);
+          turns.push({ role: "user", text: PLANNER_MARKDOWN_CONTINUATION_USER });
+          iterations -= 1;
+          continue;
+        }
+        return {
+          text: accumulatedText,
+          finishedNormally: false,
+          incompleteKind: "max_output_tokens",
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted
+        };
+      }
+      if (finishReason === "error" || finishReason === "content-filter") {
+        throw new Error(
+          stepResult.text || `planner: model reported ${finishReason}. Run \`squad doctor\` to diagnose, or retry \u2014 most 5xx errors are transient.`
+        );
+      }
+      if ((finishReason === "stop" || finishReason === "unknown") && toolCallsLen === 0) {
+        bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
+        finishedNormally = true;
+        return {
+          text: accumulatedText,
+          finishedNormally,
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted
+        };
+      }
+      if (toolCallsLen === 0) {
+        bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
+        finishedNormally = true;
+        return {
+          text: accumulatedText,
+          finishedNormally,
+          iterations,
+          finalUsage: input5.budget.snapshot().usage,
+          budgetExhausted
+        };
+      }
+      applyStepToTurns(turns, stepResult);
+      if (budgetExhausted) {
+        turns.push({
+          role: "user",
+          text: "Budget is exhausted. Finalise the plan with the information you already have. Do not call any more tools. Output the complete plan markdown now."
+        });
+      }
+      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
+    }
+  }
+};
+
+// src/planner/events.ts
+var PlannerEventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  emit(e) {
+    for (const fn of this.listeners) {
+      try {
+        fn(e);
+      } catch {
+      }
+    }
+  }
+  subscribe(fn) {
     this.listeners.add(fn);
     return () => this.listeners.delete(fn);
   }
 };
 
 // src/planner/stages/scout.ts
-import { APICallError, generateObject, NoObjectGeneratedError } from "ai";
+import { APICallError as APICallError2, NoObjectGeneratedError as NoObjectGeneratedError2 } from "ai";
+
+// src/planner/stages/scout-schema.ts
 import { z as z4 } from "zod";
 var ScoutOutputSchema = z4.object({
   selectedFiles: z4.array(z4.string()).min(1).max(25),
@@ -4216,32 +4827,34 @@ var ScoutOutputSchema = z4.object({
     })
   ).optional()
 });
+
+// src/planner/stages/scout.ts
 async function runScout(input5) {
   const maxTokens = input5.maxTokens ?? 2048;
-  const anthropicThinking = input5.provider === "anthropic" ? { anthropic: { thinking: { type: "enabled", budgetTokens: 1024 } } } : void 0;
   let attempt = 0;
   while (true) {
     try {
-      const { object, usage, providerMetadata } = await generateObject({
-        model: input5.model,
-        system: input5.systemPrompt,
-        prompt: input5.userPrompt,
+      const result = await input5.runtime.runScout({
+        systemPrompt: input5.systemPrompt,
+        userMessage: input5.userPrompt,
         schema: ScoutOutputSchema,
-        maxTokens,
-        abortSignal: input5.abort,
-        ...anthropicThinking ? { providerOptions: anthropicThinking } : {}
+        bus: input5.bus,
+        runId: input5.runId,
+        abort: input5.abort,
+        maxOutputTokens: maxTokens,
+        providerSpecific: input5.providerSpecific
       });
-      const u = usageFromLanguageModelStep(usage, providerMetadata);
-      input5.budget.recordUsage(u);
+      if (!result) return null;
+      input5.budget.recordUsage(result.usage);
       return {
-        output: object,
-        usage: { inputTokens: u.inputTokens, outputTokens: u.outputTokens }
+        output: result.output,
+        usage: { inputTokens: result.usage.inputTokens, outputTokens: result.usage.outputTokens }
       };
     } catch (e) {
-      if (NoObjectGeneratedError.isInstance(e)) {
+      if (NoObjectGeneratedError2.isInstance(e)) {
         return null;
       }
-      if (APICallError.isInstance(e) && attempt === 0) {
+      if (APICallError2.isInstance(e) && attempt === 0) {
         const status = e.statusCode ?? 0;
         if (status === 429) {
           const ra = parseRetryAfterSec(e.responseHeaders ?? {});
@@ -4553,24 +5166,6 @@ function validatePlan(input5) {
 }
 
 // src/planner/loop.ts
-var MAX_RATE_LIMIT_RETRY_SEC = 90;
-var defaultSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
-function isAbortError(e) {
-  return e instanceof Error && e.name === "AbortError";
-}
-async function sleepWithAbort(ms, sleepFn, abort) {
-  if (!abort) {
-    await sleepFn(ms);
-    return;
-  }
-  if (abort.aborted) throw new DOMException("Aborted", "AbortError");
-  await Promise.race([
-    sleepFn(ms),
-    new Promise((_, reject) => {
-      abort.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true });
-    })
-  ]);
-}
 function buildPlannerRunStats(budget, turns, runStartedAt) {
   const u = budget.snapshot().usage;
   const cacheRead = u.cacheReadTokens ?? 0;
@@ -4726,450 +5321,81 @@ function scoutStageStats(usage, durationMs) {
     inputTokens: usage.inputTokens,
     outputTokens: usage.outputTokens,
     cacheCreationTokens: 0,
-    cacheReadTokens: 0,
-    cacheHitRatio: 0,
-    durationMs
-  };
-}
-function extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut) {
-  input5.budget.extendSession();
-  maxIter.current += baseMaxIter;
-  maxOut.current += baseMaxOut;
-}
-function recordUsageAndEmit(bus, input5, runId, turn, usage) {
-  input5.budget.recordUsage(usage);
-  input5.onUsage?.(usage);
-  bus.emit({ kind: "usage", runId, turn, usage });
-  const u = input5.budget.snapshot().usage;
-  const cacheRead = u.cacheReadTokens ?? 0;
-  const cacheCreate = u.cacheCreationTokens ?? 0;
-  if (cacheRead > 0 || cacheCreate > 0) {
-    const inTok = u.inputTokens;
-    const totalInput = inTok + cacheRead;
-    const cacheHitRatio = totalInput === 0 ? 0 : Math.round(cacheRead / totalInput * 100) / 100;
-    bus.emit({
-      kind: "cache_summary",
-      runId,
-      turn,
-      cacheHitRatio,
-      cacheReadTokens: cacheRead,
-      cacheCreationTokens: cacheCreate
-    });
-  }
-}
-function cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt) {
-  bus.emit({ kind: "cancelled", runId });
-  return {
-    planText: accumulatedText,
-    budgetExhausted,
-    timedOut: false,
-    finishedNormally: false,
-    iterations,
-    stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-    userCancelled: true
-  };
-}
-function asToolInput(args) {
-  if (args && typeof args === "object" && !Array.isArray(args)) return args;
-  if (typeof args === "string") {
-    try {
-      return JSON.parse(args);
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-function normalizeToolExecutionResult(result) {
-  if (typeof result === "string") {
-    try {
-      const j = JSON.parse(result);
-      if (j && typeof j === "object" && !Array.isArray(j) && "content" in j) {
-        const o = j;
-        return {
-          content: typeof o.content === "string" ? o.content : JSON.stringify(o.content ?? ""),
-          isError: o.isError === true
-        };
-      }
-    } catch {
-    }
-    return { content: result, isError: false };
-  }
-  if (result && typeof result === "object" && !Array.isArray(result) && "content" in result) {
-    const o = result;
-    return {
-      content: typeof o.content === "string" ? o.content : JSON.stringify(o.content ?? ""),
-      isError: o.isError === true
-    };
-  }
-  return { content: typeof result === "undefined" ? "" : JSON.stringify(result), isError: false };
-}
-function applyStepToTurns(turns, step2) {
-  const callsById = /* @__PURE__ */ new Map();
-  const toolCalls = step2.toolCalls.map((tc) => {
-    callsById.set(tc.toolCallId, tc.toolName);
-    return { id: tc.toolCallId, name: tc.toolName, input: asToolInput(tc.args) };
-  });
-  turns.push({
-    role: "assistant",
-    ...step2.text ? { text: step2.text } : {},
-    ...toolCalls.length ? { toolCalls } : {}
-  });
-  if (step2.toolResults.length) {
-    const toolResults = step2.toolResults.map((tr) => {
-      const norm = normalizeToolExecutionResult(tr.result);
-      return {
-        toolCallId: tr.toolCallId,
-        name: callsById.get(tr.toolCallId) ?? "read_file",
-        content: norm.content,
-        ...norm.isError ? { isError: true } : {}
-      };
-    });
-    turns.push({ role: "user", toolResults });
-  }
-}
-function providerResponseFromApiError(provider, modelId, err2) {
-  const body = err2.responseBody ?? "";
-  const nf = detectModelNotFound(provider, modelId, err2.statusCode ?? 0, body);
-  if (nf) {
-    return {
-      stopReason: "error",
-      errorKind: "model_not_found",
-      rawError: modelNotFoundMessage(nf)
-    };
-  }
-  const rl = detectRateLimit(provider, err2.statusCode ?? 0, err2.responseHeaders ?? {}, body);
-  if (rl) {
-    return {
-      stopReason: "error",
-      errorKind: "rate_limit",
-      retryAfterSec: rl.retryAfterSec,
-      rawError: `${provider} ${err2.statusCode ?? "error"}: ${body.slice(0, 500)}`
-    };
-  }
-  return {
-    stopReason: "error",
-    rawError: `${provider} ${err2.statusCode ?? "error"}: ${body.slice(0, 500)}`
+    cacheReadTokens: 0,
+    cacheHitRatio: 0,
+    durationMs
   };
 }
 async function runDraftStage(input5) {
   const runStartedAt = Date.now();
   const bus = input5.events ?? new PlannerEventBus();
   const runId = input5.runId ?? newRunId();
-  const cacheEnabled = input5.cacheEnabled ?? true;
-  const baseMaxIter = input5.maxIterations ?? DEFAULT_PLANNER_MAX_ITERATIONS;
-  const maxIter = { current: baseMaxIter };
-  const baseMaxOut = input5.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS;
-  const maxOut = { current: baseMaxOut };
-  const turns = [{ role: "user", text: input5.userPrompt }];
-  if (input5.scoutedSection?.trim()) {
-    turns.push({ role: "user", text: composeScoutedUserMessage({ scoutedSection: input5.scoutedSection }) });
-  }
-  let accumulatedText = "";
-  let iterations = 0;
-  let budgetExhausted = false;
-  let finishedNormally = false;
-  const decide = input5.decideOnLimit;
-  const sleepFn = input5.sleep ?? defaultSleep;
+  const iterProxy = { current: 0 };
   const limitCtx = (kind) => ({
     kind,
     budgetSnapshot: input5.budget.snapshot(),
-    iterations,
-    maxIterations: maxIter.current,
-    maxOutputTokens: maxOut.current
+    iterations: iterProxy.current,
+    maxIterations: input5.maxIterations ?? DEFAULT_PLANNER_MAX_ITERATIONS,
+    maxOutputTokens: input5.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS
   });
-  for (; ; ) {
-    if (input5.abort?.aborted) {
-      return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
-    }
-    if (iterations >= maxIter.current) {
-      if (decide) {
-        const d = await decide(limitCtx("max_iterations"));
-        if (d === "cancel") {
-          return {
-            planText: accumulatedText,
-            budgetExhausted,
-            timedOut: false,
-            finishedNormally: false,
-            iterations,
-            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-            incompleteKind: "max_iterations",
-            userCancelled: true
-          };
-        }
-        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
-        continue;
-      }
-      return {
-        planText: accumulatedText,
-        budgetExhausted,
-        timedOut: false,
-        finishedNormally: false,
-        iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-        incompleteKind: "max_iterations"
-      };
-    }
-    iterations += 1;
-    if (input5.budget.timedOut()) {
-      if (decide) {
-        const d = await decide(limitCtx("wall_clock"));
-        if (d === "cancel") {
-          return {
-            planText: accumulatedText,
-            budgetExhausted,
-            timedOut: true,
-            finishedNormally: false,
-            iterations,
-            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-            incompleteKind: "wall_clock",
-            userCancelled: true
-          };
-        }
-        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
-        iterations -= 1;
-        continue;
-      }
-      return {
-        planText: accumulatedText,
-        budgetExhausted,
-        timedOut: true,
-        finishedNormally: false,
-        iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
-      };
-    }
-    if (iterations >= 2) {
-      bus.emit({ kind: "turn_started", runId, turn: iterations });
-    }
-    const tools = buildPlannerTools({
+  let budgetExhausted = false;
+  const toolDefs = input5.runtime.kind === "agent-sdk" ? buildPlannerToolDefinitions({
+    root: input5.root,
+    budget: input5.budget,
+    enabled: input5.toolsEnabled,
+    getTurn: () => Math.max(1, iterProxy.current),
+    runId,
+    bus,
+    onToolCall: input5.onToolCall,
+    decideOnLimit: input5.decideOnLimit,
+    getLimitCtx: () => limitCtx("file_or_context_reads"),
+    extendSessionLimits: () => {
+      input5.budget.extendSession();
+    },
+    getAccumulatedText: () => "",
+    setBudgetExhausted: (v) => {
+      budgetExhausted = v;
+    }
+  }) : [];
+  const draft = await input5.runtime.runDraft({
+    systemPrompt: input5.systemPrompt,
+    userMessage: input5.userPrompt,
+    tools: toolDefs,
+    bus,
+    runId,
+    budget: input5.budget,
+    abort: input5.abort,
+    maxSteps: input5.maxIterations ?? DEFAULT_PLANNER_MAX_ITERATIONS,
+    maxOutputTokens: input5.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS,
+    providerSpecific: input5.anthropicProviderSpecific?.draft,
+    onAssistantText: input5.onAssistantText,
+    onToolCall: input5.onToolCall,
+    onUsage: input5.onUsage,
+    vercelLoop: input5.runtime instanceof VercelRuntime ? {
+      model: input5.runtime.languageModel,
+      provider: input5.provider,
+      modelId: input5.modelId,
       root: input5.root,
-      budget: input5.budget,
-      enabled: {
-        grep: input5.toolsEnabled?.grep ?? true,
-        listDir: input5.toolsEnabled?.listDir ?? true,
-        rangedRead: input5.toolsEnabled?.rangedRead ?? true
-      },
-      readHooks: {
-        runId,
-        turn: iterations,
-        bus,
-        onToolCall: input5.onToolCall,
-        decideOnLimit: input5.decideOnLimit,
-        getLimitCtx: () => limitCtx("file_or_context_reads"),
-        extendSessionLimits: () => extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut),
-        getAccumulatedText: () => accumulatedText,
-        setBudgetExhausted: (v) => {
-          budgetExhausted = v;
-        }
-      }
-    });
-    const messages = turnsToCoreMessages(input5.systemPrompt, turns, {
-      cacheEnabled,
-      provider: input5.provider
-    });
-    bus.emit({ kind: "request_sent", runId, turn: iterations });
-    let attempt = 0;
-    let stepResult;
-    let retrySkippedReason;
-    let retriedRateLimit = false;
-    const callStream = async () => {
-      const { streamText } = await import("ai");
-      const stream = streamText({
-        model: input5.model,
-        messages,
-        tools,
-        toolChoice: "auto",
-        maxSteps: 1,
-        maxRetries: 0,
-        maxTokens: maxOut.current,
-        abortSignal: input5.abort,
-        // ai@4.x defaults `temperature: 0` (prepareCallSettings) and @ai-sdk/anthropic@1.x
-        // always passes it to the wire unless extended thinking is on. Anthropic Opus 4.7+
-        // rejects temperature entirely. Enabling thinking on Anthropic strips temperature
-        // via the adapter and gives the planner reasoning budget for free.
-        ...input5.provider === "anthropic" && {
-          providerOptions: {
-            anthropic: { thinking: { type: "enabled", budgetTokens: 2048 } }
-          }
-        },
-        onChunk: ({ chunk }) => {
-          if (chunk.type === "text-delta") {
-            accumulatedText += chunk.textDelta;
-            input5.onAssistantText?.(chunk.textDelta);
-            bus.emit({ kind: "assistant_text", runId, turn: iterations, delta: chunk.textDelta });
-          }
-        },
-        onStepFinish: (step2) => {
-          const u = usageFromLanguageModelStep(step2.usage, step2.providerMetadata);
-          recordUsageAndEmit(bus, input5, runId, iterations, u);
-        }
-      });
-      for await (const part of stream.fullStream) {
-        const p = part;
-        if (p.type === "error") {
-          throw p.error;
-        }
-      }
-      const steps = await stream.steps;
-      const last = steps[steps.length - 1];
-      if (!last) throw new Error("planner: empty model step");
-      stepResult = {
-        text: last.text,
-        finishReason: last.finishReason,
-        toolCalls: last.toolCalls.flatMap(
-          (tc) => tc ? [
-            {
-              toolCallId: tc.toolCallId,
-              toolName: tc.toolName,
-              args: tc.args
-            }
-          ] : []
-        ),
-        toolResults: last.toolResults.flatMap(
-          (tr) => tr ? [{ toolCallId: tr.toolCallId, result: tr.result }] : []
-        ),
-        usage: last.usage,
-        providerMetadata: last.providerMetadata
-      };
-    };
-    try {
-      while (true) {
-        try {
-          await callStream();
-          break;
-        } catch (e) {
-          if (PlannerUserCancelledError.is(e)) {
-            return {
-              planText: e.planText,
-              budgetExhausted: false,
-              timedOut: false,
-              finishedNormally: false,
-              iterations,
-              stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-              incompleteKind: "budget_reads",
-              userCancelled: true
-            };
-          }
-          if (isAbortError(e)) {
-            return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
-          }
-          if (APICallError2.isInstance(e)) {
-            const synthetic = providerResponseFromApiError(input5.provider, input5.modelId, e);
-            if (synthetic.errorKind === "rate_limit") {
-              const asked = synthetic.retryAfterSec;
-              const emitRateLimit = (phase, waitSec) => {
-                bus.emit({
-                  kind: "rate_limit",
-                  runId,
-                  turn: iterations,
-                  retryAfterSec: synthetic.retryAfterSec,
-                  waitSec,
-                  capSec: MAX_RATE_LIMIT_RETRY_SEC,
-                  phase,
-                  provider: input5.provider,
-                  rawBody: (synthetic.rawError ?? "").slice(0, 200)
-                });
-              };
-              if (asked !== void 0 && asked > MAX_RATE_LIMIT_RETRY_SEC) {
-                emitRateLimit("aborted", asked);
-                retrySkippedReason = "retry_after_too_long";
-                throw composePlannerError(input5.provider, synthetic, false, retrySkippedReason);
-              }
-              if (attempt === 0) {
-                const waitSec = Math.min(asked ?? 10, MAX_RATE_LIMIT_RETRY_SEC);
-                emitRateLimit("retrying", waitSec);
-                input5.onRateLimit?.(waitSec);
-                await sleepWithAbort(waitSec * 1e3, sleepFn, input5.abort);
-                attempt += 1;
-                retriedRateLimit = true;
-                continue;
-              }
-              throw composePlannerError(input5.provider, synthetic, true, retrySkippedReason);
-            }
-            throw composePlannerError(input5.provider, synthetic, retriedRateLimit, retrySkippedReason);
-          }
-          throw e;
-        }
-      }
-    } catch (e) {
-      if (isAbortError(e)) {
-        return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
-      }
-      throw e;
-    }
-    const finishReason = stepResult.finishReason;
-    const toolCallsLen = stepResult.toolCalls.length;
-    if (finishReason === "length" && toolCallsLen === 0) {
-      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: "max_tokens" });
-      if (decide) {
-        const d = await decide(limitCtx("max_output_tokens"));
-        if (d === "cancel") {
-          return {
-            planText: accumulatedText,
-            budgetExhausted,
-            timedOut: false,
-            finishedNormally: false,
-            iterations,
-            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-            incompleteKind: "max_output_tokens",
-            userCancelled: true
-          };
-        }
-        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
-        applyStepToTurns(turns, stepResult);
-        turns.push({ role: "user", text: PLANNER_MARKDOWN_CONTINUATION_USER });
-        iterations -= 1;
-        continue;
-      }
-      return {
-        planText: accumulatedText,
-        budgetExhausted,
-        timedOut: false,
-        finishedNormally: false,
-        iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
-        incompleteKind: "max_output_tokens"
-      };
-    }
-    if (finishReason === "error" || finishReason === "content-filter") {
-      throw new Error(
-        stepResult.text || `planner: model reported ${finishReason}. Run \`squad doctor\` to diagnose, or retry \u2014 most 5xx errors are transient.`
-      );
-    }
-    if ((finishReason === "stop" || finishReason === "unknown") && toolCallsLen === 0) {
-      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
-      finishedNormally = true;
-      return {
-        planText: accumulatedText,
-        budgetExhausted,
-        timedOut: false,
-        finishedNormally,
-        iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
-      };
-    }
-    if (toolCallsLen === 0) {
-      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
-      finishedNormally = true;
-      return {
-        planText: accumulatedText,
-        budgetExhausted,
-        timedOut: false,
-        finishedNormally,
-        iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
-      };
-    }
-    applyStepToTurns(turns, stepResult);
-    if (budgetExhausted) {
-      turns.push({
-        role: "user",
-        text: "Budget is exhausted. Finalise the plan with the information you already have. Do not call any more tools. Output the complete plan markdown now."
-      });
-    }
-    bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: finishReason });
-  }
+      userPrompt: input5.userPrompt,
+      scoutedSection: input5.scoutedSection,
+      cacheEnabled: input5.cacheEnabled ?? true,
+      toolsEnabled: input5.toolsEnabled,
+      decideOnLimit: input5.decideOnLimit,
+      sleep: input5.sleep,
+      onRateLimit: input5.onRateLimit
+    } : void 0
+  });
+  const incompleteKind = draft.incompleteKind;
+  return {
+    planText: draft.text,
+    budgetExhausted: draft.budgetExhausted ?? budgetExhausted,
+    timedOut: draft.timedOut ?? false,
+    finishedNormally: draft.finishedNormally,
+    iterations: draft.iterations,
+    incompleteKind,
+    stats: buildPlannerRunStats(input5.budget, draft.iterations, runStartedAt),
+    userCancelled: draft.userCancelled
+  };
 }
 async function runPlanner(input5) {
   const bus = input5.events ?? new PlannerEventBus();
@@ -5180,7 +5406,8 @@ async function runPlanner(input5) {
     runId,
     provider: input5.provider,
     model: input5.modelId,
-    cacheEnabled
+    cacheEnabled,
+    plannerRuntime: input5.runtime.kind
   });
   const merged = { ...input5, events: bus, runId };
   const systemPrompt = input5.systemPrompt;
@@ -5188,11 +5415,11 @@ async function runPlanner(input5) {
   let scoutStats;
   let scoutedSection;
   const scoutOn = input5.stages?.scout?.enabled !== false;
-  const scoutModel = input5.stages?.scout?.model;
+  const scoutRuntime = input5.stages?.scout?.runtime;
   const maxScoutFiles = input5.stages?.scout?.maxFiles ?? 12;
   const scoutMaxOut = input5.stages?.scout?.maxOutputTokens ?? 2048;
   const scoutModelIdStr = input5.stages?.scout?.modelId ?? "";
-  if (scoutOn && scoutModel) {
+  if (scoutOn && scoutRuntime) {
     if (!input5.scoutSystemPrompt?.trim()) {
       throw new Error(
         "planner: scout enabled but `scoutSystemPrompt` was not provided. Compose it via composeScoutSystemPrompt() or set stages.scout.enabled = false."
@@ -5202,13 +5429,15 @@ async function runPlanner(input5) {
     bus.emit({ kind: "stage_started", runId, stage: "scout" });
     try {
       const scoutRes = await runScout({
-        model: scoutModel,
-        provider: input5.provider,
+        runtime: scoutRuntime,
         systemPrompt: input5.scoutSystemPrompt,
         userPrompt: input5.userPrompt,
         budget: input5.budget,
+        bus,
+        runId,
         abort: input5.abort,
-        maxTokens: scoutMaxOut
+        maxTokens: scoutMaxOut,
+        providerSpecific: input5.anthropicProviderSpecific?.scout
       });
       const durationMs = Date.now() - t0;
       if (scoutRes) {
@@ -5254,7 +5483,7 @@ async function runPlanner(input5) {
       }
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      if (APICallError2.isInstance(err2)) {
+      if (APICallError3.isInstance(err2)) {
         const status = err2.statusCode ?? 0;
         if (status === 401 || status === 403) {
           throw err2;
@@ -5318,25 +5547,6 @@ async function runPlanner(input5) {
     validation: validationOn ? { issues, durationMs: validationDurationMs } : { issues: [], durationMs: 0 }
   };
 }
-function composePlannerError(providerName, response, retriedRateLimit, retrySkippedReason) {
-  if (response.errorKind === "rate_limit") {
-    return new Error(
-      rateLimitMessage({
-        provider: providerName,
-        retryAfterSec: response.retryAfterSec,
-        rawBody: response.rawError ?? "",
-        retryAlreadyAttempted: retriedRateLimit,
-        retrySkippedReason,
-        maxRetrySec: MAX_RATE_LIMIT_RETRY_SEC
-      })
-    );
-  }
-  if (response.errorKind === "model_not_found") {
-    return new Error(response.rawError ?? "planner: model not found");
-  }
-  const base = response.rawError ?? "planner: provider error";
-  return new Error(`${base} Run \`squad doctor\` to diagnose, or retry \u2014 most 5xx errors are transient.`);
-}
 
 // src/planner/planner-limit-messages.ts
 function printPlannerApiCostNotice() {
@@ -5410,19 +5620,260 @@ function printPlannerLimitNextSteps() {
   blank();
 }
 
-// src/planner/providers/index.ts
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-function resolveModel(provider, modelId, apiKey) {
-  switch (provider) {
-    case "anthropic":
-      return { provider, model: createAnthropic({ apiKey })(modelId), modelId };
-    case "openai":
-      return { provider, model: createOpenAI({ apiKey })(modelId), modelId };
-    case "google":
-      return { provider, model: createGoogleGenerativeAI({ apiKey })(modelId), modelId };
+// src/planner/runtimes/agent-sdk-runtime.ts
+import { z as z5 } from "zod";
+
+// src/planner/runtimes/anthropic-options.ts
+function extractAnthropicProviderSpecific(cfg, phase, cliOverrides) {
+  const opts = cfg.providerOptions?.anthropic;
+  const phaseEffort = opts?.effortByPhase?.[phase];
+  const baseEffort = opts?.effort ?? "medium";
+  const effort = cliOverrides?.effort ?? phaseEffort ?? baseEffort;
+  return {
+    thinking: cliOverrides?.thinking === "off" ? "off" : opts?.thinking ?? "adaptive",
+    thinkingBudget: opts?.thinkingBudget,
+    effort
+  };
+}
+function sdkEffortFromPlanner(effort) {
+  if (effort === "minimal") return "low";
+  if (effort === "high") return "high";
+  return "medium";
+}
+function thinkingConfigFromProviderSpecific(ps) {
+  if (!ps || ps.thinking === "off") {
+    return { type: "disabled" };
+  }
+  if (ps.thinking === "disabled") {
+    return { type: "disabled" };
+  }
+  if (ps.thinking === "enabled") {
+    return { type: "enabled", budgetTokens: ps.thinkingBudget ?? 2048 };
+  }
+  return { type: ps.thinking ?? "adaptive" };
+}
+
+// src/planner/runtimes/agent-sdk-runtime.ts
+var BUILTIN_TOOL_DENY = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "NotebookEdit",
+  "WebFetch",
+  "WebSearch"
+];
+function streamEventTextDelta(ev) {
+  if (!ev || typeof ev !== "object") return "";
+  const o = ev;
+  if (o.type === "content_block_delta") {
+    const d = o.delta;
+    if (d && d.type === "text_delta" && typeof d.text === "string") return d.text;
+  }
+  return "";
+}
+var AgentSdkRuntime = class {
+  constructor(modelId, apiKey) {
+    this.modelId = modelId;
+    this.apiKey = apiKey;
+  }
+  modelId;
+  apiKey;
+  kind = "agent-sdk";
+  providerName = "anthropic";
+  async runDraft(input5) {
+    const { query, createSdkMcpServer, tool: tool5 } = await import("@anthropic-ai/claude-agent-sdk");
+    const sdkTools = input5.tools.map(
+      (t) => tool5(t.name, t.description, this.zodToFieldsObject(t.parameters), async (args) => {
+        const r = await t.execute(args);
+        if (typeof r === "string") return { content: [{ type: "text", text: r }] };
+        return { content: [{ type: "text", text: r.content }], isError: r.isError };
+      })
+    );
+    const mcpServer = createSdkMcpServer({
+      name: "squad-kit-planner",
+      version: "1.0.0",
+      tools: sdkTools
+    });
+    const ps = input5.providerSpecific;
+    const thinking = thinkingConfigFromProviderSpecific(ps);
+    const effort = ps?.effort !== void 0 ? sdkEffortFromPlanner(ps.effort) : sdkEffortFromPlanner("medium");
+    const ac = new AbortController();
+    const onAbort = () => ac.abort();
+    if (input5.abort) {
+      if (input5.abort.aborted) ac.abort();
+      else input5.abort.addEventListener("abort", onAbort, { once: true });
+    }
+    const queryOptions = {
+      model: this.modelId,
+      tools: [],
+      disallowedTools: [...BUILTIN_TOOL_DENY],
+      mcpServers: { "squad-kit-planner": mcpServer },
+      systemPrompt: input5.systemPrompt,
+      maxTurns: input5.maxSteps,
+      includePartialMessages: true,
+      persistSession: false,
+      settingSources: [],
+      abortController: ac,
+      env: { ...process.env, ANTHROPIC_API_KEY: this.apiKey },
+      thinking,
+      effort
+    };
+    let text = "";
+    let assistantTurns = 0;
+    let finalUsage = { inputTokens: 0, outputTokens: 0 };
+    let finishedNormally = false;
+    let incompleteKind;
+    let userCancelled = false;
+    try {
+      const q = query({
+        prompt: input5.userMessage,
+        options: queryOptions
+      });
+      for await (const message of q) {
+        const m = message;
+        switch (m.type) {
+          case "stream_event": {
+            const delta = streamEventTextDelta(m.event);
+            if (delta) {
+              text += delta;
+              input5.onAssistantText?.(delta);
+              input5.bus.emit({ kind: "assistant_text", runId: input5.runId, turn: assistantTurns, delta });
+            }
+            break;
+          }
+          case "assistant": {
+            assistantTurns += 1;
+            input5.bus.emit({
+              kind: "turn_complete",
+              runId: input5.runId,
+              turn: assistantTurns,
+              stopReason: "tool_use_or_text"
+            });
+            break;
+          }
+          case "result": {
+            if (typeof m.result === "string" && m.result && !text) text = m.result;
+            finalUsage = usageFromAgentSdkResult(
+              m.usage
+            );
+            const sub = m.subtype;
+            if (sub === "success") {
+              finishedNormally = true;
+            } else if (sub === "error_max_turns") {
+              incompleteKind = "max_iterations";
+              finishedNormally = false;
+            } else if (typeof sub === "string" && sub.startsWith("error")) {
+              finishedNormally = false;
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    } catch (e) {
+      if (e instanceof Error && (e.name === "AbortError" || ac.signal.aborted)) {
+        userCancelled = true;
+        input5.bus.emit({ kind: "cancelled", runId: input5.runId });
+      } else {
+        throw e;
+      }
+    } finally {
+      if (input5.abort) input5.abort.removeEventListener("abort", onAbort);
+    }
+    input5.budget.recordUsage(finalUsage);
+    input5.onUsage?.(finalUsage);
+    input5.bus.emit({ kind: "usage", runId: input5.runId, turn: assistantTurns, usage: finalUsage });
+    return {
+      text,
+      finishedNormally: userCancelled ? false : finishedNormally,
+      iterations: assistantTurns,
+      incompleteKind,
+      finalUsage,
+      userCancelled: userCancelled || void 0
+    };
+  }
+  async runScout(input5) {
+    const { query, createSdkMcpServer, tool: tool5 } = await import("@anthropic-ai/claude-agent-sdk");
+    let scoutOutput = null;
+    const schemaFields = this.zodToFieldsObject(input5.schema);
+    const respondTool = tool5(
+      "respond_with_scout_result",
+      "Respond with the scout selection by calling this tool exactly once. Do not call any other tool.",
+      schemaFields,
+      async (args) => {
+        scoutOutput = args;
+        return { content: [{ type: "text", text: "OK \u2014 scout result captured." }] };
+      }
+    );
+    const mcpServer = createSdkMcpServer({
+      name: "squad-kit-scout",
+      version: "1.0.0",
+      tools: [respondTool]
+    });
+    const ps = input5.providerSpecific;
+    const thinking = thinkingConfigFromProviderSpecific(ps);
+    const effort = ps?.effort !== void 0 ? sdkEffortFromPlanner(ps.effort) : sdkEffortFromPlanner("minimal");
+    const queryOptions = {
+      model: this.modelId,
+      tools: [],
+      disallowedTools: [...BUILTIN_TOOL_DENY],
+      mcpServers: { "squad-kit-scout": mcpServer },
+      systemPrompt: input5.systemPrompt + "\n\nIMPORTANT: respond by calling the `respond_with_scout_result` tool with the JSON object \u2014 do not write the JSON as text.",
+      maxTurns: 2,
+      persistSession: false,
+      settingSources: [],
+      env: { ...process.env, ANTHROPIC_API_KEY: this.apiKey },
+      thinking,
+      effort
+    };
+    let usage = { inputTokens: 0, outputTokens: 0 };
+    const ac = new AbortController();
+    const onAbort = () => ac.abort();
+    if (input5.abort) {
+      if (input5.abort.aborted) ac.abort();
+      else input5.abort.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const q = query({
+        prompt: input5.userMessage,
+        options: { ...queryOptions, abortController: ac }
+      });
+      for await (const message of q) {
+        const m = message;
+        if (m.type === "result") {
+          usage = usageFromAgentSdkResult(
+            m.usage
+          );
+        }
+      }
+    } finally {
+      if (input5.abort) input5.abort.removeEventListener("abort", onAbort);
+    }
+    if (!scoutOutput) return null;
+    const parsed = input5.schema.safeParse(scoutOutput);
+    if (!parsed.success) return null;
+    return { output: parsed.data, usage };
+  }
+  zodToFieldsObject(schema) {
+    if (schema instanceof z5.ZodObject) {
+      return schema.shape;
+    }
+    return { payload: schema };
+  }
+};
+
+// src/planner/runtimes/index.ts
+function resolveRuntime(input5) {
+  if (input5.provider === "anthropic") {
+    const choice = input5.anthropicRuntime ?? "agent-sdk";
+    if (choice === "agent-sdk") return new AgentSdkRuntime(input5.modelId, input5.apiKey);
+    return new VercelRuntime("anthropic", input5.modelId, input5.apiKey);
   }
+  return new VercelRuntime(input5.provider, input5.modelId, input5.apiKey);
 }
 
 // src/planner/budget.ts
@@ -5672,6 +6123,9 @@ function formatPlannerCacheLine(opts) {
   if (!opts.cacheEnabled) {
     return "cache disabled";
   }
+  if (opts.plannerRuntimeKind === "agent-sdk") {
+    return "(agent-sdk: not exposed)";
+  }
   const { stats } = opts;
   if (stats.cacheReadTokens > 0) {
     const pct = Math.round(stats.cacheHitRatio * 100);
@@ -5859,12 +6313,33 @@ async function emitViaApi(story, paths, config2, opts) {
     );
   }
   const modelId = modelFor(planner.provider, "plan", planner.modelOverride);
-  const { model } = resolveModel(planner.provider, modelId, apiKey);
+  const anthropicRuntimeChoice = opts.anthropicRuntime ?? planner.runtime?.anthropic ?? "agent-sdk";
+  const draftRuntime = resolveRuntime({
+    provider: planner.provider,
+    modelId,
+    apiKey,
+    anthropicRuntime: planner.provider === "anthropic" ? anthropicRuntimeChoice : void 0
+  });
+  const thinkingCli = opts.noThinking ? "off" : void 0;
+  const anthropicProviderSpecific = planner.provider === "anthropic" ? {
+    draft: extractAnthropicProviderSpecific(planner, "draft", {
+      effort: opts.effort,
+      thinking: thinkingCli
+    }),
+    scout: extractAnthropicProviderSpecific(planner, "scout", {
+      effort: opts.scoutEffort,
+      thinking: thinkingCli
+    })
+  } : void 0;
   const budget = new Budget(planner.budget);
   banner();
   step(`planning   ${story.feature} / ${story.id}`);
   kv("provider", planner.provider);
   kv("model", modelId);
+  kv(
+    "runtime",
+    `${draftRuntime.kind} \xB7 ${draftRuntime.providerName}` + (planner.provider === "anthropic" ? ` (${anthropicRuntimeChoice})` : "")
+  );
   kv(
     "budget",
     `${planner.budget.maxFileReads} reads \xB7 ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB \xB7 ${planner.budget.maxDurationSeconds}s`
@@ -5892,7 +6367,7 @@ async function emitViaApi(story, paths, config2, opts) {
   const strictValidation = !!opts.strictValidation || planner.validation?.strict === true;
   const maxScoutFiles = opts.maxScoutFiles ?? planner.stages?.scout?.maxFiles ?? 12;
   let scoutModelId = "";
-  let scoutModelHandle;
+  let scoutRuntime;
   let scoutSystemPrompt;
   if (scoutEnabled) {
     scoutModelId = modelFor(
@@ -5901,7 +6376,12 @@ async function emitViaApi(story, paths, config2, opts) {
       planner.modelOverride,
       opts.scoutModel ?? planner.stages?.scout?.modelOverride
     );
-    scoutModelHandle = resolveModel(planner.provider, scoutModelId, apiKey).model;
+    scoutRuntime = resolveRuntime({
+      provider: planner.provider,
+      modelId: scoutModelId,
+      apiKey,
+      anthropicRuntime: planner.provider === "anthropic" ? anthropicRuntimeChoice : void 0
+    });
     scoutSystemPrompt = composeScoutSystemPrompt({
       projectRoots: config2.project.projectRoots ?? ["."],
       primaryLanguage: config2.project.primaryLanguage ?? "",
@@ -5990,9 +6470,10 @@ async function emitViaApi(story, paths, config2, opts) {
   try {
     result = await runPlanner({
       root: paths.root,
-      model,
+      runtime: draftRuntime,
       provider: planner.provider,
       modelId,
+      anthropicProviderSpecific,
       systemPrompt,
       userPrompt,
       budget,
@@ -6004,7 +6485,7 @@ async function emitViaApi(story, paths, config2, opts) {
       stages: {
         scout: {
           enabled: scoutEnabled,
-          model: scoutModelHandle,
+          runtime: scoutRuntime,
           modelId: scoutModelId,
           maxFiles: maxScoutFiles,
           maxOutputTokens: planner.stages?.scout?.maxOutputTokens ?? 2048
@@ -6083,7 +6564,9 @@ async function emitViaApi(story, paths, config2, opts) {
         issuesCount: issueCount,
         issuesByKind,
         durationMs: result.validation?.durationMs
-      }
+      },
+      plannerRuntime: { kind: draftRuntime.kind, provider: planner.provider },
+      providerOptionsSnapshot: anthropicProviderSpecific ? { anthropic: anthropicProviderSpecific } : void 0
     });
   } catch {
   }
@@ -6103,9 +6586,16 @@ async function emitViaApi(story, paths, config2, opts) {
     { key: "reads", value: `${snap.reads} files \xB7 ${(snap.bytes / 1024).toFixed(1)} KB` },
     {
       key: "tokens",
-      value: `${snap.usage.inputTokens} in \xB7 ${snap.usage.outputTokens} out`
+      value: `${snap.usage.inputTokens} in \xB7 ${snap.usage.outputTokens} out` + (draftRuntime.kind === "agent-sdk" ? " (agent-sdk: aggregate-only)" : "")
+    },
+    {
+      key: "cache",
+      value: formatPlannerCacheLine({
+        cacheEnabled,
+        stats: result.stats,
+        plannerRuntimeKind: draftRuntime.kind
+      })
     },
-    { key: "cache", value: formatPlannerCacheLine({ cacheEnabled, stats: result.stats }) },
     {
       key: "max out",
       value: `${planner.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS} tok/req`
@@ -6772,6 +7262,71 @@ async function checkPlannerCache(paths, ctx) {
     detail: `caching active \u2014 last run ${hitPct}% hit (${formatTokenK(stats.cacheReadTokens)} read, ${lastRun.provider}/${lastRun.model})`
   };
 }
+async function checkPlannerRuntimeInfo(_paths, ctx) {
+  if (!ctx.config?.planner?.enabled) {
+    return {
+      id: "planner-runtime-info",
+      name: "planner runtime (resolved)",
+      status: "skip",
+      detail: "planner disabled"
+    };
+  }
+  const p = ctx.config.planner;
+  const anth = p.provider === "anthropic" ? p.runtime?.anthropic ?? "agent-sdk" : "vercel (openai/google use Vercel AI SDK)";
+  return {
+    id: "planner-runtime-info",
+    name: "planner runtime (resolved)",
+    status: "ok",
+    detail: `${p.provider} \u2192 ${String(anth)}`
+  };
+}
+function anthropicPlanModelLooksPost47(modelId) {
+  return /opus[-_]4[-._]?7/i.test(modelId) || /claude-opus-4-7/i.test(modelId);
+}
+async function checkPlannerAnthropicRuntimeModelFit(_paths, ctx) {
+  const id = "planner-anthropic-runtime-model-fit";
+  const name = "Anthropic Opus 4.7+ vs Vercel runtime";
+  if (!ctx.config?.planner?.enabled || ctx.config.planner.provider !== "anthropic") {
+    return { id, name, status: "skip", detail: "not applicable" };
+  }
+  const p = ctx.config.planner;
+  if ((p.runtime?.anthropic ?? "agent-sdk") !== "vercel") {
+    return { id, name, status: "ok", detail: "using Agent SDK or default" };
+  }
+  const planModel = modelFor("anthropic", "plan", p.modelOverride);
+  if (!anthropicPlanModelLooksPost47(planModel)) {
+    return { id, name, status: "ok", detail: `${planModel} is fine on the Vercel runtime` };
+  }
+  return {
+    id,
+    name,
+    status: "warn",
+    detail: `Plan model ${planModel} needs the Agent SDK request shape; config uses Vercel runtime.`,
+    fixHint: "Remove planner.runtime.anthropic: vercel (default is agent-sdk), or set planner.modelOverride.anthropic to a pre-4.7 id (e.g. claude-sonnet-4-5-20250929)."
+  };
+}
+async function checkAgentSdkBinaryPresent(_paths, ctx) {
+  const id = "agent-sdk-binary-present";
+  const name = "Anthropic Agent SDK install";
+  if (!ctx.config?.planner?.enabled || ctx.config.planner.provider !== "anthropic") {
+    return { id, name, status: "skip", detail: "not applicable" };
+  }
+  if ((ctx.config.planner.runtime?.anthropic ?? "agent-sdk") === "vercel") {
+    return { id, name, status: "skip", detail: "vercel runtime selected" };
+  }
+  try {
+    await import("@anthropic-ai/claude-agent-sdk");
+    return { id, name, status: "ok", detail: "package resolves" };
+  } catch (e) {
+    return {
+      id,
+      name,
+      status: "warn",
+      detail: e.message.slice(0, 160),
+      fixHint: "Run pnpm install / npm install in the squad-kit package so the Agent SDK (and its platform binary) is present."
+    };
+  }
+}
 async function checkTrackerConfig(_paths, ctx) {
   if (!ctx.config) {
     return { id: "tracker-config", name: "tracker configuration", status: "skip", detail: "config unavailable" };
@@ -6913,6 +7468,9 @@ async function runAllChecks(paths, ctx, fix) {
   await add("planner model resolves at provider", () => checkPlannerModel(paths, ctx));
   await add("planner tier vs. model", () => checkPlannerTierAwareness(paths, ctx));
   await add("planner cache effectiveness", () => checkPlannerCache(paths, ctx));
+  await add("planner runtime (resolved)", () => checkPlannerRuntimeInfo(paths, ctx));
+  await add("Anthropic Opus 4.7+ vs Vercel runtime", () => checkPlannerAnthropicRuntimeModelFit(paths, ctx));
+  await add("Anthropic Agent SDK install", () => checkAgentSdkBinaryPresent(paths, ctx));
   await add("tracker configuration", () => checkTrackerConfig(paths, ctx));
   await add("tracker credential resolves", () => checkTrackerCredential(paths, ctx));
   await add("tracker connectivity", () => checkTrackerConnectivity(paths, ctx));
@@ -7367,7 +7925,7 @@ import { secureHeaders } from "hono/secure-headers";
 
 // src/console/api/stories.ts
 import fs37 from "fs";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/utils/path-safety.ts
 import path30 from "path";
@@ -7378,13 +7936,13 @@ function isInside(abs, parent) {
 }
 
 // src/console/api/stories.ts
-var CreateBody = z5.object({
-  feature: z5.string().min(1).max(80),
-  title: z5.string().max(200).optional(),
-  trackerId: z5.string().max(80).optional()
+var CreateBody = z6.object({
+  feature: z6.string().min(1).max(80),
+  title: z6.string().max(200).optional(),
+  trackerId: z6.string().max(80).optional()
 });
-var PatchBody = z5.object({
-  intakeContent: z5.string().min(1).max(1e6)
+var PatchBody = z6.object({
+  intakeContent: z6.string().min(1).max(1e6)
 });
 function safeFeatureParam(feature) {
   return feature.length > 0 && !feature.includes("/") && !feature.includes("..") && slugify(feature) === feature;
@@ -7476,12 +8034,12 @@ function mountStoriesApi(app, opts) {
 // src/console/api/plans.ts
 import fs38 from "fs";
 import path31 from "path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { diffLines } from "diff";
-var DiffQuery = z6.object({
-  feature: z6.string().min(1).max(80),
-  a: z6.string().min(1).max(200),
-  b: z6.string().min(1).max(200)
+var DiffQuery = z7.object({
+  feature: z7.string().min(1).max(80),
+  a: z7.string().min(1).max(200),
+  b: z7.string().min(1).max(200)
 });
 function safeFeatureParam2(feature) {
   return feature.length > 0 && !feature.includes("/") && !feature.includes("..") && slugify(feature) === feature;
@@ -7555,8 +8113,8 @@ function mountPlansApi(app, opts) {
 }
 
 // src/console/api/config.ts
-import { z as z7 } from "zod";
-var ConfigBody = z7.object({}).passthrough();
+import { z as z8 } from "zod";
+var ConfigBody = z8.object({}).passthrough();
 function mountConfigApi(app, opts) {
   app.get("/api/config", (c) => {
     const config2 = loadConfig(opts.paths.configFile);
@@ -7596,14 +8154,14 @@ function mountMetaApi(app, opts) {
 
 // src/console/api/runs.ts
 import { streamSSE } from "hono/streaming";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import path32 from "path";
 import fs39 from "fs";
 var active = /* @__PURE__ */ new Map();
 var EVENT_BUF_CAP = 512;
-var StartBody = z8.object({
-  feature: z8.string().min(1),
-  storyId: z8.string().min(1)
+var StartBody = z9.object({
+  feature: z9.string().min(1),
+  storyId: z9.string().min(1)
 });
 function emptyStats(durationMs) {
   return {
@@ -7660,7 +8218,17 @@ function mountRunsApi(app, opts) {
       const cfgFresh = loadConfig(opts.paths.configFile);
       const planner = cfgFresh.planner;
       const modelId = modelFor(planner.provider, "plan", planner.modelOverride);
-      const { model } = resolveModel(planner.provider, modelId, apiKey);
+      const anthropicRuntimeChoice = planner.runtime?.anthropic ?? "agent-sdk";
+      const draftRuntime = resolveRuntime({
+        provider: planner.provider,
+        modelId,
+        apiKey,
+        anthropicRuntime: planner.provider === "anthropic" ? anthropicRuntimeChoice : void 0
+      });
+      const anthropicProviderSpecific = planner.provider === "anthropic" ? {
+        draft: extractAnthropicProviderSpecific(planner, "draft"),
+        scout: extractAnthropicProviderSpecific(planner, "scout")
+      } : void 0;
       const budget = new Budget(planner.budget);
       const cacheEnabled = planner.cache?.enabled ?? true;
       const scoutEnabled = planner.stages?.scout?.enabled !== false;
@@ -7668,7 +8236,7 @@ function mountRunsApi(app, opts) {
       const strictValidation = planner.validation?.strict === true;
       const maxScoutFiles = planner.stages?.scout?.maxFiles ?? 12;
       let scoutModelId = "";
-      let scoutModelHandle;
+      let scoutRuntime;
       let scoutSystemPrompt;
       if (scoutEnabled) {
         scoutModelId = modelFor(
@@ -7677,7 +8245,12 @@ function mountRunsApi(app, opts) {
           planner.modelOverride,
           planner.stages?.scout?.modelOverride
         );
-        scoutModelHandle = resolveModel(planner.provider, scoutModelId, apiKey).model;
+        scoutRuntime = resolveRuntime({
+          provider: planner.provider,
+          modelId: scoutModelId,
+          apiKey,
+          anthropicRuntime: planner.provider === "anthropic" ? anthropicRuntimeChoice : void 0
+        });
       }
       const repoMap = buildRepoMap(opts.paths.root, { format: "tree" });
       if (scoutEnabled) {
@@ -7702,9 +8275,10 @@ function mountRunsApi(app, opts) {
       try {
         result = await runPlanner({
           root: opts.paths.root,
-          model,
+          runtime: draftRuntime,
           provider: planner.provider,
           modelId,
+          anthropicProviderSpecific,
           systemPrompt,
           userPrompt,
           budget,
@@ -7716,7 +8290,7 @@ function mountRunsApi(app, opts) {
           stages: {
             scout: {
               enabled: scoutEnabled,
-              model: scoutModelHandle,
+              runtime: scoutRuntime,
               modelId: scoutModelId,
               maxFiles: maxScoutFiles,
               maxOutputTokens: planner.stages?.scout?.maxOutputTokens ?? 2048
@@ -7806,7 +8380,9 @@ function mountRunsApi(app, opts) {
             issuesCount: issueCount,
             issuesByKind,
             durationMs: result.validation?.durationMs
-          }
+          },
+          plannerRuntime: { kind: draftRuntime.kind, provider: planner.provider },
+          providerOptionsSnapshot: anthropicProviderSpecific ? { anthropic: anthropicProviderSpecific } : void 0
         });
       } catch {
       }
@@ -7879,7 +8455,7 @@ function mountRunsApi(app, opts) {
 }
 
 // src/console/api/secrets.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/core/mask-token.ts
 function maskToken(t) {
@@ -7917,26 +8493,26 @@ function mountSecretsApi(app, opts) {
       }
     });
   });
-  const PutBody = z9.object({
-    planner: z9.object({
-      anthropic: z9.string().optional(),
-      openai: z9.string().optional(),
-      google: z9.string().optional()
+  const PutBody = z10.object({
+    planner: z10.object({
+      anthropic: z10.string().optional(),
+      openai: z10.string().optional(),
+      google: z10.string().optional()
     }).optional(),
-    tracker: z9.object({
-      jira: z9.object({
-        host: z9.string().optional(),
-        email: z9.string().optional(),
-        token: z9.string().optional()
+    tracker: z10.object({
+      jira: z10.object({
+        host: z10.string().optional(),
+        email: z10.string().optional(),
+        token: z10.string().optional()
       }).optional(),
-      azure: z9.object({
-        organization: z9.string().optional(),
-        project: z9.string().optional(),
-        pat: z9.string().optional()
+      azure: z10.object({
+        organization: z10.string().optional(),
+        project: z10.string().optional(),
+        pat: z10.string().optional()
       }).optional(),
-      github: z9.object({
-        host: z9.string().optional(),
-        pat: z9.string().optional()
+      github: z10.object({
+        host: z10.string().optional(),
+        pat: z10.string().optional()
       }).optional()
     }).optional()
   });
@@ -7976,12 +8552,12 @@ function mountSecretsApi(app, opts) {
 }
 
 // src/console/api/tracker.ts
-import { z as z10 } from "zod";
-var SearchQuery = z10.object({ q: z10.string().max(500) });
-var ImportBody = z10.object({
-  issueId: z10.string().min(1),
-  feature: z10.string().min(1).max(80),
-  withAttachments: z10.boolean().optional()
+import { z as z11 } from "zod";
+var SearchQuery = z11.object({ q: z11.string().max(500) });
+var ImportBody = z11.object({
+  issueId: z11.string().min(1),
+  feature: z11.string().min(1).max(80),
+  withAttachments: z11.boolean().optional()
 });
 function mountTrackerApi(app, opts) {
   app.get("/api/tracker/search", async (c) => {
@@ -8738,7 +9314,24 @@ program.command("new-plan [intake-path]").description("Generate a plan (via dire
   "--max-scout-files <n>",
   "Maximum files the scout can pre-select (default from config or 12)",
   (v) => parseInt(v, 10)
-).option("--no-validation", "Disable post-write validation", false).option("--strict-validation", "Write partial plan when validation finds issues", false).action(wrapArgs(runNewPlan));
+).option("--no-validation", "Disable post-write validation", false).option("--strict-validation", "Write partial plan when validation finds issues", false).addOption(
+  new Option("--anthropic-runtime <mode>", "Anthropic only: agent-sdk or legacy vercel AI SDK").choices([
+    "agent-sdk",
+    "vercel"
+  ])
+).addOption(
+  new Option("--effort <name>", "Anthropic Agent SDK: draft-stage effort").choices([
+    "minimal",
+    "medium",
+    "high"
+  ])
+).addOption(
+  new Option("--scout-effort <name>", "Anthropic Agent SDK: scout-stage effort").choices([
+    "minimal",
+    "medium",
+    "high"
+  ])
+).option("--no-thinking", "Anthropic Agent SDK: disable extended thinking for this run", false).action(wrapArgs(runNewPlan));
 program.command("status").description("Show squad-kit workspace status").action(wrap(runStatus));
 program.command("doctor").description("Run a health check on the local .squad/ workspace and its external integrations").option("--fix", "Apply non-destructive repairs (gitignore, permissions, missing dirs)", false).option("--json", "Emit results as JSON to stdout (for scripting)", false).action(wrap(runDoctor));
 program.command("migrate").description("Apply one-shot structural migrations to bring .squad/ to the latest version").option("--dry-run", "Show what would change without touching the filesystem", false).option("-y, --yes", "Skip the confirmation prompt", false).action(wrap(runMigrate));
@@ -8804,4 +9397,3 @@ function wrapArgs(fn) {
     }
   };
 }
-//# sourceMappingURL=cli.js.map