@kimbho/kimbho-cli 0.1.26 → 0.1.30

package/dist/index.cjs

@@ -12718,7 +12718,7 @@ function createCompletionRuntimeCommand(program2) {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.26",
+  version: "0.1.30",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -13080,11 +13080,11 @@ var AGENT_CATALOG = {
       "Design-system mismatch",
       "Frontend contract drift"
     ],
-    maxConcurrentTasks: 2,
+    maxConcurrentTasks: 3,
     policy: {
       sandboxMode: "workspace-write",
       canSpawnSubagents: true,
-      maxSubagentDepth: 1
+      maxSubagentDepth: 2
     }
   },
   "backend-specialist": {
@@ -13110,11 +13110,11 @@ var AGENT_CATALOG = {
       "Schema drift",
       "Unclear domain contract"
     ],
-    maxConcurrentTasks: 2,
+    maxConcurrentTasks: 3,
     policy: {
       sandboxMode: "workspace-write",
       canSpawnSubagents: true,
-      maxSubagentDepth: 1
+      maxSubagentDepth: 2
     }
   },
   "database-specialist": {
@@ -13140,7 +13140,7 @@ var AGENT_CATALOG = {
       "Data-destructive migration",
       "Unclear persistence requirements"
     ],
-    maxConcurrentTasks: 1,
+    maxConcurrentTasks: 2,
     policy: {
       sandboxMode: "workspace-write",
       requireApprovalPatterns: [
@@ -13149,7 +13149,7 @@ var AGENT_CATALOG = {
         "\\bdrop\\s+database\\b"
       ],
       canSpawnSubagents: true,
-      maxSubagentDepth: 1
+      maxSubagentDepth: 2
     }
   },
   "infra-specialist": {
@@ -13180,7 +13180,7 @@ var AGENT_CATALOG = {
       "Dependency installation",
       "External environment changes"
     ],
-    maxConcurrentTasks: 1,
+    maxConcurrentTasks: 2,
     policy: {
       sandboxMode: "workspace-write",
       requireApprovalPatterns: [
@@ -13192,7 +13192,7 @@ var AGENT_CATALOG = {
         "\\bapt(-get)?\\s+install\\b"
       ],
       canSpawnSubagents: true,
-      maxSubagentDepth: 1
+      maxSubagentDepth: 2
     }
   },
   "test-debugger": {
@@ -17627,6 +17627,44 @@ var RepoStrategySchema = external_exports.object({
   ]),
   reasoning: external_exports.string().min(1)
 });
+var TaskExecutionPhaseSchema = external_exports.enum([
+  "survey",
+  "plan-edit",
+  "implement",
+  "verify",
+  "repair",
+  "finalize",
+  "escalate"
+]);
+var TaskVerifierStateSchema = external_exports.object({
+  availableCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  preferredCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  attemptedCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  disabledCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  successfulCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  currentCommand: external_exports.string().min(1).optional(),
+  latestFailureSummary: external_exports.string().min(1).optional(),
+  latestFailureCommand: external_exports.string().min(1).optional(),
+  latestSuccessfulCommand: external_exports.string().min(1).optional(),
+  requiresInteractiveSetup: external_exports.boolean().default(false)
+});
+var TaskWorldModelSchema = external_exports.object({
+  phase: TaskExecutionPhaseSchema.default("survey"),
+  targetFiles: external_exports.array(external_exports.string().min(1)).default([]),
+  inspectedFiles: external_exports.array(external_exports.string().min(1)).default([]),
+  changedFiles: external_exports.array(external_exports.string().min(1)).default([]),
+  hypotheses: external_exports.array(external_exports.string().min(1)).default([]),
+  blockers: external_exports.array(external_exports.string().min(1)).default([]),
+  proofPending: external_exports.array(external_exports.string().min(1)).default([]),
+  proofSatisfied: external_exports.array(external_exports.string().min(1)).default([]),
+  recentActions: external_exports.array(external_exports.string().min(1)).default([]),
+  recentCommands: external_exports.array(external_exports.string().min(1)).default([]),
+  nextFocus: external_exports.string().min(1).optional(),
+  sourceEditCount: external_exports.number().int().nonnegative().default(0),
+  validationLoopCount: external_exports.number().int().nonnegative().default(0),
+  verifier: TaskVerifierStateSchema.default({}),
+  lastUpdatedAt: external_exports.string().datetime().optional()
+});
 var PlanTaskSchema = external_exports.object({
   id: external_exports.string().min(1),
   title: external_exports.string().min(1),
@@ -17662,7 +17700,8 @@ var PlanTaskSchema = external_exports.object({
   teamId: external_exports.string().min(1).optional(),
   teamMemberIds: external_exports.array(external_exports.string()).optional(),
   subagentLabel: external_exports.string().min(1).optional(),
-  subagentInstructions: external_exports.string().min(1).optional()
+  subagentInstructions: external_exports.string().min(1).optional(),
+  executionState: TaskWorldModelSchema.optional()
 });
 var PlanMilestoneSchema = external_exports.object({
   id: external_exports.string().min(1),
@@ -18150,6 +18189,103 @@ var LegacyKimbhoConfigSchema = external_exports.object({
     "next-prisma-postgres"
   ])
 });
+function uniqueModelIds(models) {
+  return Array.from(new Set(models.map((model) => model?.trim()).filter((model) => Boolean(model))));
+}
+function providerCandidateModels(provider) {
+  if (!provider) {
+    return [];
+  }
+  return uniqueModelIds([
+    provider.defaultModel,
+    ...provider.models
+  ]);
+}
+function estimateModelScale(model) {
+  const matches = Array.from(model.matchAll(/(\d+(?:\.\d+)?)b/gi));
+  if (matches.length === 0) {
+    return 0;
+  }
+  return Math.max(...matches.map((match) => Number.parseFloat(match[1] ?? "0")).filter((value) => Number.isFinite(value)));
+}
+function scoreModelForRole(model, role) {
+  const normalized = model.toLowerCase();
+  const scale = estimateModelScale(normalized);
+  let score = 0;
+  if (/gpt-5(?!.*mini)(?!.*nano)/i.test(normalized) || /\bgpt5\b/i.test(normalized)) {
+    score += 160;
+  }
+  if (/\bo3\b|\bo4\b|o4-mini-high/i.test(normalized)) {
+    score += 145;
+  }
+  if (/opus|sonnet|claude-4|claude-3\.7/i.test(normalized)) {
+    score += /opus|claude-4/i.test(normalized) ? 150 : 132;
+  }
+  if (/gpt-4\.1|gpt-4o|deepseek-r1|deepseek-v3|qwq/i.test(normalized)) {
+    score += 122;
+  }
+  if (/qwen.*(?:32b|35b|72b|110b|235b)|llama.*(?:70b|90b|405b)|mixtral/i.test(normalized)) {
+    score += 110;
+  }
+  if (/reason|thinking|r1|o[34]/i.test(normalized)) {
+    score += 20;
+  }
+  if (scale > 0) {
+    score += Math.min(scale, 120) * 0.8;
+  }
+  if (/mini|nano|flash|haiku|small|fast|instant|lite/i.test(normalized)) {
+    score -= 55;
+  }
+  if (/\b(?:3|7|8|9|14)b\b/i.test(normalized)) {
+    score -= 35;
+  }
+  if (/preview|experimental|beta/i.test(normalized)) {
+    score -= 6;
+  }
+  if (role === "fast") {
+    let fastBias = 0;
+    if (/mini|nano|flash|haiku|small|fast|instant|lite/i.test(normalized)) {
+      fastBias += 95;
+    }
+    if (/sonnet|gpt-4o-mini|gpt-5-mini|claude.*haiku/i.test(normalized)) {
+      fastBias += 60;
+    }
+    if (scale >= 32) {
+      fastBias -= 40;
+    } else if (scale > 0 && scale <= 16) {
+      fastBias += 24;
+    }
+    return fastBias + score * 0.2;
+  }
+  if (role === "reviewer") {
+    if (/reason|thinking|r1|\bo3\b|\bo4\b|opus/i.test(normalized)) {
+      score += 24;
+    }
+    if (/mini|flash|haiku/i.test(normalized)) {
+      score -= 10;
+    }
+  }
+  if (role === "planner") {
+    if (/reason|thinking|r1|\bo3\b|\bo4\b|sonnet|opus/i.test(normalized)) {
+      score += 18;
+    }
+  }
+  if (role === "coder") {
+    if (/sonnet|gpt-5|gpt-4\.1|deepseek|qwen|llama/i.test(normalized)) {
+      score += 16;
+    }
+  }
+  return score;
+}
+function pickPreferredProviderModel(provider, role) {
+  const candidates = providerCandidateModels(provider);
+  if (candidates.length === 0) {
+    return null;
+  }
+  return [
+    ...candidates
+  ].sort((left, right) => scoreModelForRole(right, role) - scoreModelForRole(left, role))[0] ?? null;
+}
 function createBrainCatalog(providerId, defaultModel, fastModel) {
   return {
     planner: {
@@ -18229,12 +18365,13 @@ function normalizeConfigInput(raw) {
   const legacy = LegacyKimbhoConfigSchema.safeParse(raw);
   if (legacy.success) {
     const provider = mapLegacyProviderToDefinition(legacy.data.provider);
-    const defaultModel = provider.defaultModel ?? "gpt-5";
+    const defaultModel = pickPreferredProviderModel(provider, "planner") ?? provider.defaultModel ?? "gpt-5";
+    const fastModel = pickPreferredProviderModel(provider, "fast") ?? defaultModel;
     return {
       providers: [
         provider
       ],
-      brains: createBrainCatalog(provider.id, defaultModel, defaultModel),
+      brains: createBrainCatalog(provider.id, defaultModel, fastModel),
       approvalMode: legacy.data.approvalMode,
       sandboxMode: legacy.data.sandboxMode,
       stackPresets: legacy.data.stackPresets,
@@ -18285,8 +18422,8 @@ function createDefaultConfig(options = {}) {
     baseUrl: "https://api.openai.com/v1",
     defaultModel: "gpt-5"
   });
-  const defaultModel = options.defaultModel ?? provider.defaultModel;
-  const fastModel = options.fastModel ?? defaultModel;
+  const defaultModel = options.defaultModel ?? pickPreferredProviderModel(provider, "planner") ?? provider.defaultModel;
+  const fastModel = options.fastModel ?? pickPreferredProviderModel(provider, "fast") ?? defaultModel;
   return KimbhoConfigSchema.parse({
     providers: [
       provider
@@ -18765,7 +18902,10 @@ function resolveBrainSettings(config2, role) {
 function resolveBrainModel(config2, role) {
   const settings = resolveBrainSettings(config2, role);
   const provider = findProviderById(config2, settings.providerId);
-  return settings.model ?? provider?.defaultModel ?? null;
+  if (settings.model) {
+    return settings.model;
+  }
+  return pickPreferredProviderModel(provider, role) ?? provider?.defaultModel ?? null;
 }
 
 // ../core/dist/session/store.js
@@ -32988,6 +33128,9 @@ function combinePositiveLimit(...values) {
   }
   return Math.min(...filtered);
 }
+function uniqueStrings2(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
 function truncateForModel(value) {
   if (!value) {
     return value;
@@ -33077,6 +33220,18 @@ function isReadOnlyShellCommand2(command) {
     "git diff"
   ].some((prefix) => normalized === prefix || normalized.startsWith(prefix));
 }
+function isShellFileInspectionCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  return [
+    "cat ",
+    "head ",
+    "tail ",
+    "wc ",
+    "sed ",
+    "more ",
+    "less "
+  ].some((prefix) => normalized === prefix || normalized.startsWith(prefix));
+}
 function isVerificationCommand(command) {
   const normalized = command.trim().toLowerCase();
   return [
@@ -33121,6 +33276,310 @@ function isVerificationAction(action) {
   const command = typeof action.input.command === "string" ? action.input.command : "";
   return command.length > 0 && isVerificationCommand(command);
 }
+function isRuntimeValidationAction(action) {
+  if (action.type !== "tool") {
+    return false;
+  }
+  if (isVerificationAction(action)) {
+    return true;
+  }
+  return [
+    "process.start",
+    "process.logs",
+    "process.stop",
+    "browser.open",
+    "browser.inspect",
+    "browser.click",
+    "browser.fill",
+    "browser.close",
+    "http.fetch"
+  ].includes(action.tool);
+}
+function isShellFileInspectionAction(action) {
+  if (action.type !== "tool" || action.tool !== "shell.exec") {
+    return false;
+  }
+  const command = typeof action.input.command === "string" ? action.input.command : "";
+  return isShellFileInspectionCommand(command);
+}
+function isRepoInspectionAction(action) {
+  if (action.type !== "tool") {
+    return false;
+  }
+  return [
+    "file.read",
+    "file.search",
+    "file.list",
+    "repo.index",
+    "repo.query",
+    "git.diff"
+  ].includes(action.tool);
+}
+function normalizeWorkspacePath(cwd, value) {
+  const normalized = value.replace(/\\/g, "/").trim();
+  if (normalized.length === 0) {
+    return normalized;
+  }
+  if (!import_node_path14.default.isAbsolute(normalized)) {
+    return normalized.replace(/^\.\//, "");
+  }
+  const relative = import_node_path14.default.relative(cwd, normalized).replace(/\\/g, "/");
+  return relative.length > 0 && !relative.startsWith("..") ? relative : normalized;
+}
+async function detectVerificationCommands(cwd) {
+  const commands = [];
+  const packagePath = import_node_path14.default.join(cwd, "package.json");
+  try {
+    await (0, import_promises14.access)(packagePath);
+    const raw = await (0, import_promises14.readFile)(packagePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts ?? {};
+    const packageManager = parsed.packageManager?.startsWith("pnpm") ? "pnpm" : parsed.packageManager?.startsWith("yarn") ? "yarn" : parsed.packageManager?.startsWith("bun") ? "bun" : "npm";
+    const renderRun = (script) => {
+      if (packageManager === "yarn") {
+        return `yarn ${script}`;
+      }
+      return `${packageManager} run ${script}`;
+    };
+    if (scripts.typecheck) {
+      commands.push(renderRun("typecheck"));
+    }
+    if (scripts.build) {
+      commands.push(renderRun("build"));
+    }
+    if (scripts.test) {
+      commands.push(renderRun("test"));
+    }
+    if (scripts.lint) {
+      commands.push(renderRun("lint"));
+    }
+  } catch {
+  }
+  if (commands.length === 0) {
+    try {
+      await (0, import_promises14.access)(import_node_path14.default.join(cwd, "tsconfig.json"));
+      commands.push("npx tsc --noEmit");
+    } catch {
+    }
+  }
+  const unique = uniqueStrings2(commands);
+  const preferred = [
+    ...unique.filter((command) => /typecheck|build|test/i.test(command)),
+    ...unique.filter((command) => /lint/i.test(command) && !/typecheck|build|test/i.test(command))
+  ];
+  return {
+    availableCommands: unique,
+    preferredCommands: uniqueStrings2(preferred)
+  };
+}
+function createInitialWorldModel(task, request, verifier) {
+  const phase = task.type === "verification" ? "verify" : task.type === "integration" || task.type === "documentation" ? "finalize" : request.workspaceState === "existing" ? "survey" : "implement";
+  return {
+    phase,
+    targetFiles: uniqueStrings2(task.filesLikelyTouched.map((filePath) => normalizeWorkspacePath(request.cwd, filePath))),
+    inspectedFiles: [],
+    changedFiles: [],
+    hypotheses: uniqueStrings2([
+      `Satisfy task acceptance criteria for ${task.id}.`,
+      task.description
+    ]),
+    blockers: [],
+    proofPending: uniqueStrings2(task.acceptanceCriteria),
+    proofSatisfied: [],
+    recentActions: [],
+    recentCommands: [],
+    nextFocus: phase === "verify" ? "Run the preferred verification path and capture proof." : "Inspect the likely source files and determine the minimal safe change.",
+    sourceEditCount: 0,
+    validationLoopCount: 0,
+    verifier: {
+      availableCommands: verifier.availableCommands,
+      preferredCommands: verifier.preferredCommands,
+      attemptedCommands: [],
+      disabledCommands: [],
+      successfulCommands: [],
+      requiresInteractiveSetup: false
+    },
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function summarizeWorldModel(worldModel) {
+  return [
+    `phase: ${worldModel.phase}`,
+    `next focus: ${worldModel.nextFocus ?? "(unset)"}`,
+    `target files: ${worldModel.targetFiles.join(", ") || "(none)"}`,
+    `inspected files: ${worldModel.inspectedFiles.join(", ") || "(none)"}`,
+    `changed files: ${worldModel.changedFiles.join(", ") || "(none)"}`,
+    `hypotheses: ${worldModel.hypotheses.join(" | ") || "(none)"}`,
+    `blockers: ${worldModel.blockers.join(" | ") || "(none)"}`,
+    `proof pending: ${worldModel.proofPending.join(" | ") || "(none)"}`,
+    `proof satisfied: ${worldModel.proofSatisfied.join(" | ") || "(none)"}`,
+    `verifier preferred commands: ${worldModel.verifier.preferredCommands.join(", ") || "(none)"}`,
+    `verifier disabled commands: ${worldModel.verifier.disabledCommands.join(", ") || "(none)"}`,
+    `latest verifier failure: ${worldModel.verifier.latestFailureSummary ?? "(none)"}`,
+    `recent actions: ${worldModel.recentActions.join(" | ") || "(none)"}`
+  ].join("\n");
+}
+function recordWorldModelAction(worldModel, label, command) {
+  return {
+    ...worldModel,
+    recentActions: uniqueStrings2([
+      ...worldModel.recentActions.slice(-5),
+      label
+    ]).slice(-6),
+    recentCommands: command ? uniqueStrings2([
+      ...worldModel.recentCommands.slice(-5),
+      command
+    ]).slice(-6) : worldModel.recentCommands,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function scoreVerificationCommand(command, worldModel) {
+  const normalized = command.trim().toLowerCase();
+  let score = 0;
+  if (worldModel.phase === "repair" && worldModel.verifier.latestFailureCommand && normalized === worldModel.verifier.latestFailureCommand.trim().toLowerCase()) {
+    score += 80;
+  }
+  if (/typecheck|tsc --noemit|tsc\b/i.test(normalized)) {
+    score += worldModel.proofPending.some((item) => /typescript|compile|type/i.test(item)) ? 70 : 32;
+  }
+  if (/build/i.test(normalized)) {
+    score += worldModel.proofPending.some((item) => /build|compile|render|page|layout|responsive/i.test(item)) ? 68 : 34;
+  }
+  if (/test|vitest|jest/i.test(normalized)) {
+    score += worldModel.proofPending.some((item) => /test|behavior|logic|regression/i.test(item)) ? 74 : 38;
+  }
+  if (/lint|eslint/i.test(normalized)) {
+    score += worldModel.proofPending.some((item) => /lint|style|quality/i.test(item)) ? 54 : 18;
+  }
+  if (/dev|serve|start/i.test(normalized)) {
+    score -= 18;
+  }
+  if (worldModel.verifier.successfulCommands.includes(command)) {
+    score -= 12;
+  }
+  if (worldModel.verifier.disabledCommands.includes(command)) {
+    score -= 1e3;
+  }
+  return score;
+}
+function determineNextVerificationCommand(worldModel) {
+  const candidates = uniqueStrings2([
+    ...worldModel.phase === "repair" && worldModel.verifier.latestFailureCommand ? [
+      worldModel.verifier.latestFailureCommand
+    ] : [],
+    ...worldModel.verifier.preferredCommands,
+    ...worldModel.verifier.availableCommands
+  ]).filter((command) => !worldModel.verifier.disabledCommands.includes(command));
+  if (candidates.length === 0) {
+    return null;
+  }
+  return [
+    ...candidates
+  ].sort((left, right) => scoreVerificationCommand(right, worldModel) - scoreVerificationCommand(left, worldModel))[0] ?? null;
+}
+function updateProofStateForVerification(worldModel, command, success2) {
+  if (!command || !success2) {
+    return {
+      proofPending: worldModel.proofPending,
+      proofSatisfied: worldModel.proofSatisfied
+    };
+  }
+  const normalized = command.toLowerCase();
+  const satisfiedLabels = [];
+  let proofPending = [
+    ...worldModel.proofPending
+  ];
+  const satisfyMatching = (pattern, fallback) => {
+    const matching = proofPending.filter((item) => pattern.test(item));
+    if (matching.length > 0) {
+      satisfiedLabels.push(...matching);
+      proofPending = proofPending.filter((item) => !pattern.test(item));
+      return;
+    }
+    satisfiedLabels.push(fallback);
+  };
+  if (/typecheck|tsc --noemit|tsc\b/.test(normalized)) {
+    satisfyMatching(/typescript|compile|type/i, `Type safety verified via ${command}`);
+  }
+  if (/build/.test(normalized)) {
+    satisfyMatching(/build|compile|render|page|layout|responsive/i, `Build/render verification passed via ${command}`);
+  }
+  if (/test|vitest|jest/.test(normalized)) {
+    satisfyMatching(/test|behavior|logic|regression/i, `Behavior verified via ${command}`);
+  }
+  if (/lint|eslint/.test(normalized)) {
+    satisfyMatching(/lint|style|quality/i, `Code quality verified via ${command}`);
+  }
+  if (satisfiedLabels.length === 0) {
+    satisfiedLabels.push(`Verified via ${command}`);
+  }
+  return {
+    proofPending: uniqueStrings2(proofPending),
+    proofSatisfied: uniqueStrings2([
+      ...worldModel.proofSatisfied,
+      ...satisfiedLabels
+    ])
+  };
+}
+function derivePhaseGuidance(worldModel) {
+  switch (worldModel.phase) {
+    case "survey":
+      return [
+        "Survey likely source files and constraints before making a change.",
+        "Do not spend more than one baseline validation action before a real source edit lands."
+      ];
+    case "plan-edit":
+    case "implement":
+      return [
+        "Make the concrete source change now.",
+        "Use file.patch or file.write against the likely target files before further runtime validation."
+      ];
+    case "verify":
+      return [
+        `Use the strategic verifier next: ${determineNextVerificationCommand(worldModel) ?? "(choose the best non-interactive verifier)"}.`,
+        "Capture proof for the changed behavior before finishing."
+      ];
+    case "repair":
+      return [
+        `Repair the latest failing verifier before rerunning it: ${worldModel.verifier.latestFailureSummary ?? "(missing failure summary)"}.`,
+        "Inspect failure output, edit the relevant source, then rerun the strategic verifier."
+      ];
+    case "finalize":
+      return [
+        "Only finish once the key proof is captured and no blocker remains.",
+        "Use git.diff or one final verifier if you still need confirmation."
+      ];
+    case "escalate":
+      return [
+        "Summarize blockers precisely so the supervisor can reassign or replan."
+      ];
+  }
+}
+function deriveSupervisorHints(status, task, worldModel) {
+  const delegatedTask = Boolean(task.parentTaskId);
+  if (status === "completed" && delegatedTask) {
+    return {
+      shouldMergeDelegatedWork: true,
+      shouldReprioritize: true,
+      reason: `Delegated task ${task.id} completed; parent flow may be ready to merge or reprioritize.`
+    };
+  }
+  if (status === "blocked" || status === "handoff" || worldModel.phase === "escalate") {
+    return {
+      shouldReplan: true,
+      shouldReprioritize: delegatedTask,
+      reason: worldModel.blockers[0] ?? `Task ${task.id} needs supervisor intervention.`
+    };
+  }
+  if (delegatedTask && worldModel.phase === "repair") {
+    return {
+      shouldReplan: true,
+      shouldReprioritize: true,
+      reason: `Delegated task ${task.id} is in repair mode and may need reassignment or dependency changes.`
+    };
+  }
+  return void 0;
+}
 function extractShellCommand(action) {
   if (action.type !== "tool" || action.tool !== "shell.exec") {
     return "";
@@ -33139,7 +33598,7 @@ function isInteractiveVerificationSetupFailure(action, result) {
   ].join("\n").toLowerCase();
   return combined.includes("interactive eslint setup required") || combined.includes("command requires interactive input before it can continue") || command.includes("lint") && combined.includes("how would you like to configure eslint");
 }
-function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstructions) {
+function buildSystemPrompt(agent, task, request, allowedTools, worldModel, plan, extraInstructions) {
   const toolShape = allowedTools.join("|");
   const dependencyTasks = plan ? flattenPlanTasks(plan).filter((candidate) => task.dependsOn.includes(candidate.id)) : [];
   const completedTasks = plan ? flattenPlanTasks(plan).filter((candidate) => candidate.status === "completed" && candidate.id !== task.id) : [];
@@ -33153,6 +33612,7 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
     `Goal: ${request.goal}`,
     `Current task: ${task.id} - ${task.title}`,
     `Task description: ${task.description}`,
+    `Execution phase: ${worldModel.phase}`,
     `Acceptance criteria:`,
     ...task.acceptanceCriteria.map((item) => `- ${item}`),
     `Likely files: ${task.filesLikelyTouched.join(", ") || "(not specified)"}`,
@@ -33162,6 +33622,8 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
     `Completed tasks in this run: ${completedTasks.length > 0 ? completedTasks.slice(-4).map((candidate) => `${candidate.id}:${candidate.title}`).join(", ") : "(none yet)"}`,
     `Downstream tasks depending on this task: ${downstreamTasks.length > 0 ? downstreamTasks.slice(0, 4).map((candidate) => `${candidate.id}:${candidate.title}`).join(", ") : "(none)"}`,
     `Allowed tools: ${allowedTools.join(", ")}`,
+    `Task world-model:`,
+    summarizeWorldModel(worldModel),
     `Respond with exactly one JSON object and no markdown.`,
     `Tool action shape: {"type":"tool","tool":"${toolShape}","input":{...},"reason":"why this step matters"}`,
     `Finish shape: {"type":"finish","summary":"what was completed and verified"}`,
@@ -33170,6 +33632,7 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
     `- Use one action per response.`,
     `- Use file.list, file.search, repo.index, and repo.query to explore the workspace before editing.`,
     `- Prefer file.read before editing existing files.`,
+    `- For repo file inspection, prefer file.read, file.search, file.list, repo.query, and git.diff instead of shell.exec cat/head/tail/wc/sed.`,
     `- Use scaffold.generate when the task is clearly greenfield and a known preset fits better than improvising every file by hand.`,
     `- Use file.patch for existing files when possible; use file.write for new files or full replacements.`,
     `- Use git.diff to inspect the current patch after changes when helpful.`,
@@ -33184,6 +33647,7 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
     `- If a verification command asks for interactive setup or operator input, do not rerun it unchanged. Choose a different non-interactive verifier, or configure that verifier only if the task explicitly requires it.`,
     `- Do not claim success unless the task acceptance criteria are satisfied.`,
     `- If the task is underspecified, make a pragmatic implementation choice and continue.`,
+    ...derivePhaseGuidance(worldModel).map((rule) => `- ${rule}`),
     ...task.subagentInstructions ? [
       `Delegation instructions:`,
       task.subagentInstructions
@@ -33341,17 +33805,6 @@ function inferFallbackActionFromResponse(raw, task, request, allowedTools) {
       };
     }
   }
-  if (allowedTools.includes("scaffold.generate") && looksLikeStaticLandingGoal(request.goal) && task.filesLikelyTouched.some((filePath) => filePath === "src/app/page.tsx" || filePath === "src/app/layout.tsx" || filePath === "src/pages/index.tsx" || filePath === "index.html" || filePath === "styles.css")) {
-    return {
-      type: "tool",
-      tool: "scaffold.generate",
-      input: {
-        goal: request.goal,
-        preset: "static-landing"
-      },
-      reason: "Use the deterministic static-site adapter because the model stayed out of structured mode."
-    };
-  }
   if (!allowedTools.includes("file.write")) {
     return null;
   }
@@ -33484,6 +33937,8 @@ var AutonomousTaskExecutor = class {
     const brain = await this.resolver.resolve(effectiveBrainRole);
     const allowedTools = resolvedExecutionPolicy.allowedTools;
     const actionSchema = createAgentActionSchema(allowedTools);
+    const verificationCommands = await detectVerificationCommands(request.cwd);
+    let worldModel = task.executionState ?? createInitialWorldModel(task, request, verificationCommands);
     const messages = [
       {
         role: "user",
@@ -33510,11 +33965,13 @@ var AutonomousTaskExecutor = class {
       }
     };
     let changedWorkspace = false;
+    let appliedSourceEdit = false;
     let verifiedAfterLatestChange = false;
     let repairRequiredBeforeVerification = false;
     let repairAppliedSinceFailure = false;
     let verificationFailures = 0;
     let lastVerificationFailure = null;
+    let preEditValidationActions = 0;
     let preservedMessageCount = messages.length;
     let compactedTranscriptEntries = 0;
     let compactionSummary = null;
@@ -33525,6 +33982,26 @@ var AutonomousTaskExecutor = class {
       inputTokens: 0,
       outputTokens: 0
     };
+    const snapshotWorldModel = () => ({
+      ...worldModel,
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const makeOutcome = (status, summary, extra = {}) => {
+      const currentWorldModel = snapshotWorldModel();
+      const supervisorHints = deriveSupervisorHints(status, task, currentWorldModel);
+      return {
+        status,
+        summary,
+        toolResults,
+        artifacts: Array.from(artifacts),
+        usage: usageTotals,
+        worldModel: currentWorldModel,
+        ...supervisorHints ? {
+          supervisorHints
+        } : {},
+        ...extra
+      };
+    };
     const createToolExecutionContext = (step, approvalReason, operatorApproved = false) => ({
       cwd: request.cwd,
       ...options.signal ? {
@@ -33598,13 +34075,17 @@ var AutonomousTaskExecutor = class {
       });
       const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
       artifacts.add(transcriptPath2);
-      return {
-        status: "blocked",
-        summary,
-        toolResults,
-        artifacts: Array.from(artifacts),
-        usage: usageTotals
+      worldModel = {
+        ...worldModel,
+        phase: "escalate",
+        blockers: uniqueStrings2([
+          ...worldModel.blockers,
+          summary
+        ]),
+        nextFocus: "Supervisor should replan or reassign this task because a budget was exhausted.",
+        lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      return makeOutcome("blocked", summary);
     };
     await emitProgress({
       type: "task-note",
@@ -33633,24 +34114,32 @@ var AutonomousTaskExecutor = class {
       });
       const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
       artifacts.add(transcriptPath2);
-      return {
-        status: "blocked",
-        summary,
-        toolResults,
-        artifacts: Array.from(artifacts),
-        usage: usageTotals
+      worldModel = {
+        ...worldModel,
+        phase: "escalate",
+        blockers: uniqueStrings2([
+          ...worldModel.blockers,
+          summary
+        ]),
+        nextFocus: "Supervisor should inspect why this task has no executable tools.",
+        lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      return makeOutcome("blocked", summary);
     }
     if (resolvedApproval?.decision === "deny") {
       const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
       artifacts.add(transcriptPath2);
-      return {
-        status: "blocked",
-        summary: `Operator denied approval for ${resolvedApproval.approval.toolId} in ${task.id}.`,
-        toolResults,
-        artifacts: Array.from(artifacts),
-        usage: usageTotals
+      worldModel = {
+        ...worldModel,
+        phase: "escalate",
+        blockers: uniqueStrings2([
+          ...worldModel.blockers,
+          `Operator denied ${resolvedApproval.approval.toolId}.`
+        ]),
+        nextFocus: "Choose a safer path or wait for supervisor replanning after the denied action.",
+        lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      return makeOutcome("blocked", `Operator denied approval for ${resolvedApproval.approval.toolId} in ${task.id}.`);
     }
     if (request.workspaceState === "existing") {
       const preflightResults = [];
@@ -33692,6 +34181,18 @@ var AutonomousTaskExecutor = class {
         for (const artifact of result.artifacts) {
           artifacts.add(artifact);
         }
+        if (toolId === "file.read" && result.success && typeof input.path === "string") {
+          worldModel = {
+            ...worldModel,
+            inspectedFiles: uniqueStrings2([
+              ...worldModel.inspectedFiles,
+              normalizeWorkspacePath(request.cwd, input.path)
+            ]),
+            phase: worldModel.phase === "survey" ? "plan-edit" : worldModel.phase,
+            nextFocus: worldModel.phase === "survey" ? "Make the concrete source change in the inspected target files." : worldModel.nextFocus,
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
         transcript.push({
           step: 0,
           response: JSON.stringify({
@@ -33791,6 +34292,14 @@ ${truncateForModel(customAgentMemory)}`);
           ].join("\n\n")
         });
       }
+      if (request.workspaceState === "existing" && (task.type === "scaffold" || task.type === "implementation") && worldModel.phase === "survey") {
+        worldModel = {
+          ...worldModel,
+          phase: "plan-edit",
+          nextFocus: "Edit the likely source files before using more verification or browser/runtime checks.",
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
     }
     preservedMessageCount = messages.length;
     const runToolAction = async (parsedAction, step, operatorApproved = false) => {
@@ -33852,7 +34361,10 @@ ${truncateForModel(customAgentMemory)}`);
     const applyToolResult = async (parsedAction, result, step, transcriptEntry) => {
       const mutatingAction = isMutatingAction(parsedAction);
       const verificationAction = isVerificationAction(parsedAction);
+      const runtimeValidationAction = isRuntimeValidationAction(parsedAction);
+      const shellCommand = extractShellCommand(parsedAction);
       const interactiveVerificationSetupFailure = verificationAction && !result.success && isInteractiveVerificationSetupFailure(parsedAction, result);
+      worldModel = recordWorldModelAction(worldModel, parsedAction.type === "tool" ? `${parsedAction.tool}${shellCommand ? ` ${shellCommand}` : ""}` : parsedAction.type === "finish" ? "finish" : "block", shellCommand || void 0);
       if (mutatingAction && result.success) {
         changedWorkspace = true;
         verifiedAfterLatestChange = false;
@@ -33860,22 +34372,121 @@ ${truncateForModel(customAgentMemory)}`);
           repairAppliedSinceFailure = true;
         }
       }
+      if (parsedAction.tool === "file.write" || parsedAction.tool === "file.patch") {
+        if (result.success) {
+          appliedSourceEdit = true;
+          preEditValidationActions = 0;
+          worldModel = {
+            ...worldModel,
+            phase: "verify",
+            changedFiles: uniqueStrings2([
+              ...worldModel.changedFiles,
+              ...result.artifacts.map((artifact) => normalizeWorkspacePath(request.cwd, artifact)),
+              ...typeof parsedAction.input.path === "string" ? [
+                normalizeWorkspacePath(request.cwd, parsedAction.input.path)
+              ] : []
+            ]),
+            blockers: [],
+            sourceEditCount: worldModel.sourceEditCount + 1,
+            nextFocus: `Run the strategic verifier next: ${determineNextVerificationCommand(worldModel) ?? "choose the best non-interactive verifier"}.`,
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+      if (!appliedSourceEdit && runtimeValidationAction) {
+        preEditValidationActions += 1;
+        worldModel = {
+          ...worldModel,
+          validationLoopCount: worldModel.validationLoopCount + 1,
+          nextFocus: "Make a source edit before spending more time on runtime validation.",
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (parsedAction.tool === "file.read" && result.success && typeof parsedAction.input.path === "string") {
+        worldModel = {
+          ...worldModel,
+          inspectedFiles: uniqueStrings2([
+            ...worldModel.inspectedFiles,
+            normalizeWorkspacePath(request.cwd, parsedAction.input.path)
+          ]),
+          phase: worldModel.phase === "survey" ? "plan-edit" : worldModel.phase,
+          nextFocus: worldModel.phase === "survey" ? "Use the inspected files to make the concrete implementation change." : worldModel.nextFocus,
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
       if (verificationAction) {
         verifiedAfterLatestChange = result.success;
+        const attemptedCommand = shellCommand || (parsedAction.tool === "tests.run" ? "tests.run" : "");
+        const proofUpdate = updateProofStateForVerification(worldModel, attemptedCommand || void 0, result.success);
+        const verifier = {
+          ...worldModel.verifier,
+          attemptedCommands: attemptedCommand ? uniqueStrings2([
+            ...worldModel.verifier.attemptedCommands,
+            attemptedCommand
+          ]) : worldModel.verifier.attemptedCommands,
+          currentCommand: attemptedCommand || worldModel.verifier.currentCommand,
+          latestFailureSummary: result.success ? void 0 : result.summary,
+          latestFailureCommand: result.success ? void 0 : attemptedCommand || void 0,
+          latestSuccessfulCommand: result.success ? attemptedCommand || worldModel.verifier.latestSuccessfulCommand : worldModel.verifier.latestSuccessfulCommand,
+          successfulCommands: result.success && attemptedCommand ? uniqueStrings2([
+            ...worldModel.verifier.successfulCommands,
+            attemptedCommand
+          ]) : worldModel.verifier.successfulCommands,
+          disabledCommands: interactiveVerificationSetupFailure && attemptedCommand ? uniqueStrings2([
+            ...worldModel.verifier.disabledCommands,
+            attemptedCommand
+          ]) : worldModel.verifier.disabledCommands,
+          requiresInteractiveSetup: interactiveVerificationSetupFailure
+        };
+        worldModel = {
+          ...worldModel,
+          verifier,
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
         if (result.success) {
           verificationFailures = 0;
           repairRequiredBeforeVerification = false;
           repairAppliedSinceFailure = false;
           lastVerificationFailure = null;
+          worldModel = {
+            ...worldModel,
+            phase: "finalize",
+            validationLoopCount: 0,
+            proofPending: proofUpdate.proofPending,
+            proofSatisfied: proofUpdate.proofSatisfied,
+            nextFocus: "Review the diff and finish if the task acceptance criteria are satisfied.",
+            blockers: [],
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
         } else if (interactiveVerificationSetupFailure) {
           repairRequiredBeforeVerification = false;
           repairAppliedSinceFailure = false;
           lastVerificationFailure = result;
+          worldModel = {
+            ...worldModel,
+            phase: appliedSourceEdit ? "verify" : "implement",
+            blockers: uniqueStrings2([
+              ...worldModel.blockers.filter((blocker) => !blocker.includes("interactive")),
+              result.summary
+            ]),
+            nextFocus: "Choose a different non-interactive verifier or configure the verifier only if the task truly requires it.",
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
         } else {
           verificationFailures += 1;
           repairRequiredBeforeVerification = true;
           repairAppliedSinceFailure = false;
           lastVerificationFailure = result;
+          worldModel = {
+            ...worldModel,
+            phase: "repair",
+            blockers: uniqueStrings2([
+              ...worldModel.blockers,
+              result.summary
+            ]),
+            nextFocus: "Repair the latest failing verifier output before running verification again.",
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
         }
       }
       transcriptEntry.toolResult = result;
@@ -33936,21 +34547,21 @@ ${truncateForModel(customAgentMemory)}`);
           const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
           artifacts.add(transcriptPath2);
           if (task.agentRole !== "test-debugger") {
-            return {
-              status: "handoff",
-              summary: `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; handing off to test-debugger.`,
-              toolResults,
-              artifacts: Array.from(artifacts),
-              usage: usageTotals
+            worldModel = {
+              ...worldModel,
+              phase: "escalate",
+              nextFocus: "Escalate to test-debugger with the latest failing verifier context.",
+              lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
             };
+            return makeOutcome("handoff", `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; handing off to test-debugger.`);
           }
-          return {
-            status: "blocked",
-            summary: `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; repair budget exhausted.`,
-            toolResults,
-            artifacts: Array.from(artifacts),
-            usage: usageTotals
+          worldModel = {
+            ...worldModel,
+            phase: "escalate",
+            nextFocus: "Debugger repair budget is exhausted; supervisor must replan or accept the blocker.",
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
+          return makeOutcome("blocked", `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; repair budget exhausted.`);
         }
       }
       messages.push({
@@ -33994,14 +34605,9 @@ ${truncateForModel(customAgentMemory)}`);
       if (execution.approvalRequest) {
         const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
         artifacts.add(transcriptPath2);
-        return {
-          status: "awaiting-approval",
-          summary: execution.approvalRequest.reason,
-          toolResults,
-          artifacts: Array.from(artifacts),
-          approvalRequest: execution.approvalRequest,
-          usage: usageTotals
-        };
+        return makeOutcome("awaiting-approval", execution.approvalRequest.reason, {
+          approvalRequest: execution.approvalRequest
+        });
       }
       if (!execution.result) {
         throw new Error("Approved action did not produce a tool result.");
@@ -34018,13 +34624,12 @@ ${truncateForModel(customAgentMemory)}`);
       } catch (error2) {
         const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
         artifacts.add(transcriptPath2);
-        return {
-          status: "paused",
-          summary: `Execution interrupted by operator during ${task.id}.`,
-          toolResults,
-          artifacts: Array.from(artifacts),
-          usage: usageTotals
+        worldModel = {
+          ...worldModel,
+          nextFocus: "Resume from the current execution state without redoing completed inspection or verification.",
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
+        return makeOutcome("paused", `Execution interrupted by operator during ${task.id}.`);
       }
       await compactExecutionContextIfNeeded(step);
       if (typeof maxModelCalls === "number" && usageTotals.modelCalls >= maxModelCalls) {
@@ -34047,7 +34652,7 @@ ${truncateForModel(customAgentMemory)}`);
         try {
           response = await brain.client.generateText({
             model: brain.model,
-            systemPrompt: buildSystemPrompt(effectiveAgent, task, request, allowedTools, options.plan, task.agentPromptPreamble ?? customOverlay?.promptPreamble),
+            systemPrompt: buildSystemPrompt(effectiveAgent, task, request, allowedTools, snapshotWorldModel(), options.plan, task.agentPromptPreamble ?? customOverlay?.promptPreamble),
             messages,
             responseFormat: "json_object",
             ...typeof brain.settings.temperature === "number" ? {
@@ -34065,24 +34670,27 @@ ${truncateForModel(customAgentMemory)}`);
           });
           const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
           artifacts.add(transcriptPath2);
-          return {
-            status: "blocked",
-            summary: `Model request failed before ${task.id} could choose a safe action: ${error2 instanceof Error ? error2.message : String(error2)}`,
-            toolResults,
-            artifacts: Array.from(artifacts),
-            usage: usageTotals
+          worldModel = {
+            ...worldModel,
+            phase: "escalate",
+            blockers: uniqueStrings2([
+              ...worldModel.blockers,
+              error2 instanceof Error ? error2.message : String(error2)
+            ]),
+            nextFocus: "Supervisor should inspect the model failure or switch to a healthier provider/model.",
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
+          return makeOutcome("blocked", `Model request failed before ${task.id} could choose a safe action: ${error2 instanceof Error ? error2.message : String(error2)}`);
         }
         if (options.signal?.aborted) {
           const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
           artifacts.add(transcriptPath2);
-          return {
-            status: "paused",
-            summary: `Execution interrupted by operator during ${task.id}.`,
-            toolResults,
-            artifacts: Array.from(artifacts),
-            usage: usageTotals
+          worldModel = {
+            ...worldModel,
+            nextFocus: "Resume from the current execution state without redoing completed inspection or verification.",
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
+          return makeOutcome("paused", `Execution interrupted by operator during ${task.id}.`);
         }
         responseText = response.text;
         usageTotals.modelCalls += 1;
@@ -34145,13 +34753,17 @@ ${truncateForModel(customAgentMemory)}`);
               step,
               message: "Model stayed out of structured mode after multiple retries."
             });
-            return {
-              status: "blocked",
-              summary: `${parseSummary} The task stopped before a safe tool action could be chosen.`,
-              toolResults,
-              artifacts: Array.from(artifacts),
-              usage: usageTotals
+            worldModel = {
+              ...worldModel,
+              phase: "escalate",
+              blockers: uniqueStrings2([
+                ...worldModel.blockers,
+                parseSummary
+              ]),
+              nextFocus: "Supervisor should inspect the unstructured model output and replan or switch models.",
+              lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
             };
+            return makeOutcome("blocked", `${parseSummary} The task stopped before a safe tool action could be chosen.`);
           }
           await emitProgress({
             type: "task-note",
@@ -34185,10 +34797,53 @@ ${truncateForModel(customAgentMemory)}`);
         response: responseText,
         parsedAction
       };
+      const strategicVerifier = determineNextVerificationCommand(worldModel);
       messages.push({
         role: "assistant",
         content: JSON.stringify(parsedAction)
       });
+      if (worldModel.phase === "survey" && parsedAction.type === "tool" && !isRepoInspectionAction(parsedAction)) {
+        transcriptEntry.runtimeNote = "Rejected phase-inconsistent action because survey phase still requires repo inspection.";
+        transcript.push(transcriptEntry);
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          taskId: task.id,
+          agentRole: task.agentRole,
+          step,
+          message: "Survey phase requires file/repo inspection before implementation or verification."
+        });
+        messages.push({
+          role: "user",
+          content: [
+            "The current execution phase is survey.",
+            "Inspect likely source files and repository context first with file.read, file.search, file.list, repo.index, repo.query, or git.diff.",
+            "Do not jump to runtime validation or edits before you understand the target files."
+          ].join("\n")
+        });
+        continue;
+      }
+      if (worldModel.phase === "verify" && parsedAction.type === "tool" && !isVerificationAction(parsedAction) && !isRepoInspectionAction(parsedAction)) {
+        transcriptEntry.runtimeNote = "Rejected phase-inconsistent action because verify phase requires proof or diff review.";
+        transcript.push(transcriptEntry);
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          taskId: task.id,
+          agentRole: task.agentRole,
+          step,
+          message: strategicVerifier ? `Verify phase requires proof. Run ${strategicVerifier} or inspect the diff.` : "Verify phase requires proof. Use a non-interactive verifier or inspect the diff."
+        });
+        messages.push({
+          role: "user",
+          content: [
+            "The current execution phase is verify.",
+            strategicVerifier ? `Run the strategic verifier next: ${strategicVerifier}.` : "Run the best non-interactive verifier next.",
+            "Only use diff/inspection actions here if you still need proof context before finishing."
+          ].join("\n")
+        });
+        continue;
+      }
       if (parsedAction.type === "finish") {
         if (changedWorkspace && !verifiedAfterLatestChange) {
           transcriptEntry.runtimeNote = "Finish rejected because code changed without a successful verification step.";
@@ -34205,31 +34860,77 @@ ${truncateForModel(customAgentMemory)}`);
             role: "user",
             content: [
               "You tried to finish after making code changes without a successful verification step.",
-              "Run tests.run or a build/lint/test shell command, inspect failures, and only finish after verification passes."
+              strategicVerifier ? `Run the strategic verifier next: ${strategicVerifier}.` : "Run tests.run or a build/lint/test shell command, inspect failures, and only finish after verification passes."
+            ].join("\n")
+          });
+          continue;
+        }
+        if (worldModel.phase !== "finalize") {
+          transcriptEntry.runtimeNote = `Finish rejected because the task is still in ${worldModel.phase} phase.`;
+          transcript.push(transcriptEntry);
+          await emitProgress({
+            type: "task-note",
+            sessionId,
+            taskId: task.id,
+            agentRole: task.agentRole,
+            step,
+            message: `Finish rejected because the task is still in ${worldModel.phase} phase.`
+          });
+          messages.push({
+            role: "user",
+            content: [
+              `The task is still in ${worldModel.phase} phase.`,
+              ...derivePhaseGuidance(worldModel),
+              "Do the next strategic action instead of finishing early."
+            ].join("\n")
+          });
+          continue;
+        }
+        if (worldModel.proofPending.length > 0 && worldModel.proofSatisfied.length === 0) {
+          transcriptEntry.runtimeNote = "Finish rejected because the task still has pending proof and no satisfied verifier evidence.";
+          transcript.push(transcriptEntry);
+          await emitProgress({
+            type: "task-note",
+            sessionId,
+            taskId: task.id,
+            agentRole: task.agentRole,
+            step,
+            message: "Finish rejected because the task still has pending proof requirements."
+          });
+          messages.push({
+            role: "user",
+            content: [
+              "You still owe proof for this task before finishing.",
+              `Pending proof: ${worldModel.proofPending.join(" | ")}`,
+              strategicVerifier ? `Run the strategic verifier next: ${strategicVerifier}.` : "Run the best non-interactive verifier, then finish only after the proof is captured."
             ].join("\n")
           });
           continue;
         }
         const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
         artifacts.add(transcriptPath2);
-        return {
-          status: "completed",
-          summary: parsedAction.summary,
-          toolResults,
-          artifacts: Array.from(artifacts),
-          usage: usageTotals
+        worldModel = {
+          ...worldModel,
+          phase: "finalize",
+          nextFocus: "Task completed.",
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
+        return makeOutcome("completed", parsedAction.summary);
       }
       if (parsedAction.type === "block") {
         const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
         artifacts.add(transcriptPath2);
-        return {
-          status: "blocked",
-          summary: parsedAction.reason,
-          toolResults,
-          artifacts: Array.from(artifacts),
-          usage: usageTotals
+        worldModel = {
+          ...worldModel,
+          phase: "escalate",
+          blockers: uniqueStrings2([
+            ...worldModel.blockers,
+            parsedAction.reason
+          ]),
+          nextFocus: "Supervisor should inspect the reported blocker and adjust the task graph.",
+          lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
+        return makeOutcome("blocked", parsedAction.reason);
       }
       if (!allowedTools.includes(parsedAction.tool)) {
         transcriptEntry.runtimeNote = `Rejected disallowed tool "${parsedAction.tool}" for ${agent.role}.`;
@@ -34274,6 +34975,67 @@ ${truncateForModel(customAgentMemory)}`);
         });
         continue;
       }
+      if (isVerificationAction(parsedAction) && strategicVerifier && extractShellCommand(parsedAction) && extractShellCommand(parsedAction) !== strategicVerifier) {
+        transcriptEntry.runtimeNote = "Verification command rejected because it does not match the current strategic verifier.";
+        transcript.push(transcriptEntry);
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          taskId: task.id,
+          agentRole: task.agentRole,
+          step,
+          message: `Verification should follow the strategic order. Prefer ${strategicVerifier} next.`
+        });
+        messages.push({
+          role: "user",
+          content: [
+            "Use the strategic verification path instead of picking a random verifier.",
+            `Preferred next verifier: ${strategicVerifier}`
+          ].join("\n")
+        });
+        continue;
+      }
+      if (allowedTools.includes("file.read") && isShellFileInspectionAction(parsedAction)) {
+        transcriptEntry.runtimeNote = "Rejected shell-based file inspection because file.read is available.";
+        transcript.push(transcriptEntry);
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          taskId: task.id,
+          agentRole: task.agentRole,
+          step,
+          message: "Use file.read or repo/file tools instead of cat/head/wc/sed shell commands for source inspection."
+        });
+        messages.push({
+          role: "user",
+          content: [
+            "Do not use shell.exec for simple repo file inspection when file.read is available.",
+            "Use file.read, file.search, file.list, repo.query, or git.diff instead."
+          ].join("\n")
+        });
+        continue;
+      }
+      if (request.workspaceState === "existing" && (task.type === "scaffold" || task.type === "implementation") && !appliedSourceEdit && isRuntimeValidationAction(parsedAction) && preEditValidationActions >= 1) {
+        transcriptEntry.runtimeNote = "Rejected repeated validation/runtime loop before any source edit.";
+        transcript.push(transcriptEntry);
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          taskId: task.id,
+          agentRole: task.agentRole,
+          step,
+          message: "Repeated build/dev/browser verification was stopped because no source edit has landed yet."
+        });
+        messages.push({
+          role: "user",
+          content: [
+            "You already used one baseline verification/runtime check before making a source edit.",
+            "Do not keep rerunning build, lint, dev server, browser, or HTTP checks unchanged.",
+            "Inspect likely source files, make a concrete edit with file.patch or file.write, and then validate again."
+          ].join("\n")
+        });
+        continue;
+      }
       const execution = await runToolAction(parsedAction, step);
       if (execution.budgetExceeded) {
         transcriptEntry.runtimeNote = execution.budgetExceeded;
@@ -34284,14 +35046,9 @@ ${truncateForModel(customAgentMemory)}`);
         transcriptEntry.runtimeNote = execution.approvalRequest.reason;
         const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
         artifacts.add(transcriptPath2);
-        return {
-          status: "awaiting-approval",
-          summary: execution.approvalRequest.reason,
-          toolResults,
-          artifacts: Array.from(artifacts),
-          approvalRequest: execution.approvalRequest,
-          usage: usageTotals
-        };
+        return makeOutcome("awaiting-approval", execution.approvalRequest.reason, {
+          approvalRequest: execution.approvalRequest
+        });
       }
       if (!execution.result) {
         throw new Error(`Tool ${parsedAction.tool} did not return a result.`);
@@ -34311,21 +35068,21 @@ ${truncateForModel(customAgentMemory)}`);
       message: task.agentRole !== "test-debugger" ? `Step budget exhausted after ${maxSteps} steps; handing task to test-debugger.` : `Step budget exhausted after ${maxSteps} steps; debugger escalation exhausted.`
     });
     if (task.agentRole !== "test-debugger") {
-      return {
-        status: "handoff",
-        summary: `Autonomous executor reached the step limit (${maxSteps}) for ${task.id}; handing off to test-debugger.`,
-        toolResults,
-        artifacts: Array.from(artifacts),
-        usage: usageTotals
+      worldModel = {
+        ...worldModel,
+        phase: "escalate",
+        nextFocus: "Hand off the task to test-debugger with the current world-model and transcript.",
+        lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      return makeOutcome("handoff", `Autonomous executor reached the step limit (${maxSteps}) for ${task.id}; handing off to test-debugger.`);
     }
-    return {
-      status: "blocked",
-      summary: `Autonomous executor reached the step limit (${maxSteps}) for ${task.id}; debugger escalation exhausted.`,
-      toolResults,
-      artifacts: Array.from(artifacts),
-      usage: usageTotals
+    worldModel = {
+      ...worldModel,
+      phase: "escalate",
+      nextFocus: "Debugger escalation is exhausted; supervisor must replan or accept the blocker.",
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
+    return makeOutcome("blocked", `Autonomous executor reached the step limit (${maxSteps}) for ${task.id}; debugger escalation exhausted.`);
   }
 };
 
@@ -35036,6 +35793,26 @@ function buildSummary(shape, goal) {
   }
   return `Deliver "${goal}" through structured analysis, implementation, and verification milestones.`;
 }
+function buildPlanningSeedSummary(goal) {
+  return `Create the best executable task graph for "${goal}" with dynamically chosen milestones, task count, and verification.`;
+}
+function planningSeedMilestone() {
+  return {
+    id: "m1-planning-seed",
+    title: "Planning Seed",
+    objective: "Schema-valid placeholder context for the planner model. Replace this seed with a real executable plan.",
+    tasks: [
+      buildTask("seed-plan-task", "Replace this planning seed with the real task graph", "This placeholder exists only so the planner model receives a schema-valid example. The final plan should replace it with concrete milestones and executable tasks tailored to the goal.", "planner", "documentation", [], [
+        "The final plan removes the placeholder task.",
+        "The final plan contains executable tasks with explicit dependencies and verification."
+      ], [
+        "Executable task graph"
+      ], [
+        "."
+      ], "low")
+    ]
+  };
+}
 function createPlan(input) {
   const request = PlanRequestSchema.parse({
     ...input,
@@ -35065,6 +35842,33 @@ function createPlan(input) {
     ]
   });
 }
+function createPlanningSeed(input) {
+  const request = PlanRequestSchema.parse({
+    ...input,
+    goal: normalizeGoal(input.goal)
+  });
+  const shape = inferProjectShape(request.goal);
+  return KimbhoPlanSchema.parse({
+    goal: request.goal,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: buildPlanningSeedSummary(request.goal),
+    repoStrategy: {
+      mode: request.workspaceState === "empty" ? "greenfield" : "existing-repo",
+      reasoning: request.workspaceState === "empty" ? "No meaningful workspace contents were detected, so the planner can choose an opinionated greenfield graph." : "Existing workspace state should be analyzed and preserved while the planner chooses the execution graph."
+    },
+    assumptions: deriveAssumptions(shape, request),
+    openQuestions: deriveOpenQuestions(shape),
+    milestones: [
+      planningSeedMilestone()
+    ],
+    verificationChecklist: deriveVerificationChecklist(shape),
+    executionNotes: [
+      "Replace the placeholder seed milestone with the real execution graph.",
+      "Choose milestone count, task count, and dependencies dynamically from the goal.",
+      "Keep deterministic fallback available only if model planning fails."
+    ]
+  });
+}
 
 // ../planner/dist/model-planner.js
 var DEFAULT_PLANNER_TEMPERATURE = 0.1;
@@ -35148,8 +35952,8 @@ function buildPlannerSystemPrompt() {
     "You are Kimbho's planner brain.",
     "Return one JSON object only. Do not use markdown fences or prose outside the JSON.",
     "The JSON must satisfy the KimbhoPlan schema used by Kimbho's runtime.",
-    "Prefer refining the provided seed plan instead of inventing a totally different graph.",
-    "Keep task ids stable and machine-friendly.",
+    "For initial planning, choose the milestone count, task count, and task graph shape that best fits the request instead of mirroring the fallback plan.",
+    "Keep task ids machine-friendly and stable within the returned plan.",
     "Use only these agent roles:",
     "- session-orchestrator",
     "- repo-analyst",
@@ -35180,8 +35984,9 @@ ${request.constraints.map((constraint) => `- ${constraint}`).join("\n")}` : "",
     "Seed plan JSON:",
     JSON.stringify(seedPlan, null, 2),
     "Instructions:",
-    "- Refine the seed plan into the best executable plan for this goal.",
-    "- Preserve the seed task ids unless there is a compelling execution reason not to.",
+    "- Use the seed plan only as a fallback reference, not as a task-count template.",
+    "- Produce the best executable plan for this goal, choosing milestone count and task count dynamically.",
+    "- You may replace the seed task ids for the initial plan if a different graph is materially better.",
     "- Keep the plan concise, practical, and tool-executable."
   ].filter(Boolean).join("\n\n");
 }
@@ -35205,7 +36010,7 @@ ${request.constraints.map((constraint) => `- ${constraint}`).join("\n")}` : "",
     "- Adjust milestone wording, task descriptions, acceptance criteria, files, and dependencies only when the repo evidence justifies it."
   ].filter(Boolean).join("\n\n");
 }
-async function generatePlannerPlan(request, seedPlan, invocation, userPrompt, preserveStatusesFrom) {
+async function generatePlannerPlan(request, seedPlan, fallbackPlan, invocation, userPrompt, preserveStatusesFrom, requireStableTaskIds = true) {
   try {
     const response = await invocation.generate({
       systemPrompt: buildPlannerSystemPrompt(),
@@ -35215,7 +36020,7 @@ async function generatePlannerPlan(request, seedPlan, invocation, userPrompt, pr
     });
     const parsed = extractJsonObjectish(response.text, "planner response");
     const candidatePlan = KimbhoPlanSchema.parse(parsed);
-    const normalized = normalizeCandidatePlan(request, seedPlan, candidatePlan, true, preserveStatusesFrom);
+    const normalized = normalizeCandidatePlan(request, fallbackPlan, candidatePlan, requireStableTaskIds, preserveStatusesFrom);
     return {
       plan: normalized,
       source: "model",
@@ -35229,7 +36034,7 @@ async function generatePlannerPlan(request, seedPlan, invocation, userPrompt, pr
     };
   } catch (error2) {
     return {
-      plan: preserveStatusesFrom ? preserveTaskStatuses(preserveStatusesFrom, seedPlan) : seedPlan,
+      plan: preserveStatusesFrom ? preserveTaskStatuses(preserveStatusesFrom, fallbackPlan) : fallbackPlan,
       source: "fallback",
       warning: summarizeStructuredOutputError("Planner", error2),
       ...invocation.modelLabel ? {
@@ -35239,18 +36044,19 @@ async function generatePlannerPlan(request, seedPlan, invocation, userPrompt, pr
   }
 }
 async function createPlanWithModel(request, invocation) {
-  const seedPlan = createPlan(request);
-  return generatePlannerPlan(request, seedPlan, invocation, buildInitialPlannerPrompt(request, seedPlan));
+  const fallbackPlan = createPlan(request);
+  const seedPlan = createPlanningSeed(request);
+  return generatePlannerPlan(request, seedPlan, fallbackPlan, invocation, buildInitialPlannerPrompt(request, seedPlan), void 0, false);
 }
 async function revisePlanWithModel(request, currentPlan, repoSummary, invocation) {
-  return generatePlannerPlan(request, currentPlan, invocation, buildReplanPrompt(request, currentPlan, repoSummary), currentPlan);
+  return generatePlannerPlan(request, currentPlan, currentPlan, invocation, buildReplanPrompt(request, currentPlan, repoSummary), currentPlan);
 }
 
 // ../planner/dist/task-expander.js
 var DEFAULT_EXPANDER_TEMPERATURE = 0.1;
 var DEFAULT_EXPANDER_MAX_TOKENS = 1600;
 var MAX_EXPANSION_CONTEXT_CHARS = 6e3;
-var MAX_EXPANDED_SUBTASKS = 4;
+var MAX_EXPANDED_SUBTASKS = 6;
 var ExpansionCandidateTaskSchema = external_exports.object({
   id: external_exports.string().min(1).optional(),
   title: external_exports.string().min(1),
@@ -35310,7 +36116,7 @@ function createEntrySubtask(task, suffix, title, description) {
   };
 }
 function fallbackExpandedTasks(task) {
-  if ((task.swarmDepth ?? 0) >= 1) {
+  if ((task.swarmDepth ?? 0) >= 2) {
     return null;
   }
   if (task.agentRole === "frontend-specialist" && task.type === "implementation") {
@@ -35326,10 +36132,24 @@ function fallbackExpandedTasks(task) {
         ]
       },
       {
-        ...createEntrySubtask(task, "polish", `Polish ${task.title.toLowerCase()} visuals and responsiveness`, `Refine styling, responsiveness, and interaction details after the content structure is in place.`),
+        ...createEntrySubtask(task, "interaction", `Design ${task.title.toLowerCase()} interaction and motion`, `Define animation, scroll behavior, and interaction states once the content structure is clear.`),
         dependsOn: [
           `${task.id}-content`
         ],
+        acceptanceCriteria: [
+          "Interaction patterns and motion direction are explicit.",
+          "Primary calls to action and navigation states feel intentional."
+        ],
+        outputs: [
+          "Interaction and motion direction"
+        ]
+      },
+      {
+        ...createEntrySubtask(task, "polish", `Polish ${task.title.toLowerCase()} visuals and responsiveness`, `Refine styling, responsiveness, and interaction details after the content structure is in place.`),
+        dependsOn: [
+          `${task.id}-content`,
+          `${task.id}-interaction`
+        ],
         acceptanceCriteria: [
           ...task.acceptanceCriteria,
           "Responsive behavior and visual polish are verified."
@@ -35532,9 +36352,10 @@ function buildExpansionPrompt(request, plan, task, repoSummary) {
     "Repo context:",
     truncate2(repoSummary),
     "Instructions:",
-    "- Replace the target task with 2-4 narrower subtasks.",
+    `- Replace the target task with 2-${MAX_EXPANDED_SUBTASKS} narrower subtasks.`,
     "- Preserve the target task's overall intent, but make execution more parallel-friendly when safe.",
     "- Keep dependencies explicit and machine-valid.",
+    "- Prefer at least 3 subtasks for broad frontend or product-surface work when the task can be split safely.",
     "- Prefer roles like frontend-specialist, backend-specialist, database-specialist, infra-specialist, reviewer, and test-debugger when they fit."
   ].join("\n\n");
 }
@@ -35551,7 +36372,7 @@ ${task.acceptanceCriteria.map((criterion) => `- ${criterion}`).join("\n") || "-
   ].filter(Boolean).join("\n\n");
 }
 function shouldExpandTask(task) {
-  if ((task.swarmDepth ?? 0) >= 1) {
+  if ((task.swarmDepth ?? 0) >= 2) {
     return false;
   }
   if (task.type !== "implementation") {
@@ -36625,6 +37446,15 @@ function updateTaskStatus(plan, taskId, status) {
     milestones
   };
 }
+function updateTaskExecutionState(plan, taskId, executionState) {
+  if (!executionState) {
+    return plan;
+  }
+  return replaceTask(plan, taskId, (task) => ({
+    ...task,
+    executionState
+  }));
+}
 function replaceTask(plan, taskId, mapper) {
   const milestones = plan.milestones.map((milestone) => ({
     ...milestone,
@@ -36673,9 +37503,6 @@ function shouldDelegateTask(task, request) {
   if (!canSpawnSubagents) {
     return false;
   }
-  if ((looksLikeVisualAdjustmentGoal(request.goal) || looksLikePageExpansionGoal(request.goal)) && isStaticSiteTask(task, request)) {
-    return false;
-  }
   return (task.swarmDepth ?? 0) < maxSubagentDepth && task.type === "implementation" && ![
     "repo-analyst",
     "planner",
@@ -36714,6 +37541,20 @@ function createDefaultDelegationPlan(task, request) {
             "Structured page/content update"
           ]
         },
+        {
+          id: "interaction-designer",
+          label: "interaction-designer",
+          agentRole: "frontend-specialist",
+          description: "Own motion design, interaction states, scroll behavior, and narrative pacing.",
+          instructions: "Focus on animation, interaction states, scroll rhythm, and motion hierarchy. Keep motion purposeful and aligned with the requested design direction.",
+          acceptanceCriteria: [
+            "Interaction patterns and motion choices are explicit.",
+            "The page has a coherent motion system without distracting from the content."
+          ],
+          outputs: [
+            "Interaction and motion design update"
+          ]
+        },
         {
           id: "visual-polisher",
           label: "visual-polisher",
@@ -37048,6 +37889,44 @@ ${result.stderr.slice(0, 1e3)}`);
     return lines.join("\n");
   }).join("\n\n");
 }
+function renderTaskWorldModelContext(task, outcome) {
+  const worldModel = outcome.worldModel;
+  if (!worldModel) {
+    return [
+      `task: ${task.id}`,
+      `status: ${outcome.status}`,
+      `summary: ${outcome.summary}`
+    ].join("\n");
+  }
+  return [
+    `task: ${task.id}`,
+    `status: ${outcome.status}`,
+    `summary: ${outcome.summary}`,
+    `phase: ${worldModel.phase}`,
+    `next focus: ${worldModel.nextFocus ?? "(unset)"}`,
+    `target files: ${worldModel.targetFiles.join(", ") || "(none)"}`,
+    `inspected files: ${worldModel.inspectedFiles.join(", ") || "(none)"}`,
+    `changed files: ${worldModel.changedFiles.join(", ") || "(none)"}`,
+    `blockers: ${worldModel.blockers.join(" | ") || "(none)"}`,
+    `proof pending: ${worldModel.proofPending.join(" | ") || "(none)"}`,
+    `proof satisfied: ${worldModel.proofSatisfied.join(" | ") || "(none)"}`,
+    `recent actions: ${worldModel.recentActions.join(" | ") || "(none)"}`,
+    `preferred verifiers: ${worldModel.verifier.preferredCommands.join(", ") || "(none)"}`,
+    `latest verifier failure: ${worldModel.verifier.latestFailureSummary ?? "(none)"}`
+  ].join("\n");
+}
+function shouldRevisePlanAfterTaskOutcome(task, outcome) {
+  if (task.agentRole === "repo-analyst" || task.agentRole === "planner") {
+    return false;
+  }
+  if (outcome.supervisorHints?.shouldReplan || outcome.supervisorHints?.shouldReprioritize || outcome.supervisorHints?.shouldMergeDelegatedWork) {
+    return true;
+  }
+  if (outcome.status === "blocked" || outcome.status === "handoff") {
+    return true;
+  }
+  return Boolean(task.parentTaskId && outcome.worldModel && (outcome.worldModel.phase === "repair" || outcome.worldModel.phase === "finalize" || outcome.worldModel.blockers.length > 0));
+}
 function latestRepoAnalysisContext(events) {
   const event = [
     ...events
@@ -37323,8 +38202,8 @@ var ExecutionOrchestrator = class {
     let pendingApprovals = [
       ...session.pendingApprovals
     ];
-    const maxAutoTasks = options.maxAutoTasks ?? 2;
-    const maxParallelTasks = Math.max(1, options.maxParallelTasks ?? 2);
+    const maxAutoTasks = options.maxAutoTasks ?? 4;
+    const maxParallelTasks = Math.max(1, options.maxParallelTasks ?? 4);
     let executedTasks = 0;
     for (const approval of session.pendingApprovals) {
       const decision = decisionByApprovalId.get(approval.id);
@@ -37485,7 +38364,13 @@ var ExecutionOrchestrator = class {
       let sawApprovalRequest = false;
       for (const batchResult of batchResults) {
         const { task: autoTask, outcome } = batchResult;
-        workingPlan = outcome.status === "handoff" ? replaceTask(workingPlan, autoTask.id, () => outcome.handoffTask ?? createDebuggerHandoffTask(autoTask, outcome, this.toolsForAgent("test-debugger").map((tool) => tool.id))) : updateTaskStatus(workingPlan, autoTask.id, outcome.status === "completed" ? "completed" : outcome.status === "blocked" ? "blocked" : "pending");
+        workingPlan = updateTaskExecutionState(workingPlan, autoTask.id, outcome.worldModel);
+        workingPlan = outcome.status === "handoff" ? replaceTask(workingPlan, autoTask.id, () => ({
+          ...outcome.handoffTask ?? createDebuggerHandoffTask(autoTask, outcome, this.toolsForAgent("test-debugger").map((tool) => tool.id)),
+          ...outcome.worldModel ? {
+            executionState: outcome.worldModel
+          } : {}
+        })) : updateTaskStatus(workingPlan, autoTask.id, outcome.status === "completed" ? "completed" : outcome.status === "blocked" ? "blocked" : "pending");
         if (autoTask.agentRole === "repo-analyst" && outcome.status === "completed") {
           const replanned = await this.maybeRevisePlanAfterRepoAnalysis(session.id, session.request, workingPlan, outcome, emitProgress);
           workingPlan = replanned.plan;
@@ -37498,6 +38383,16 @@ var ExecutionOrchestrator = class {
             });
           }
         }
+        const adapted = await this.maybeRevisePlanAfterTaskOutcome(session.id, session.request, workingPlan, autoTask, outcome, emitProgress);
+        workingPlan = adapted.plan;
+        if (adapted.note) {
+          notes = maybeAppendNote(notes, adapted.note);
+          await emitProgress({
+            type: "task-note",
+            sessionId: session.id,
+            message: adapted.note
+          });
+        }
         notes = maybeAppendNote(notes, outcome.summary);
         if (outcome.status === "awaiting-approval" && outcome.approvalRequest) {
           pendingApprovals.push(outcome.approvalRequest);
@@ -37640,7 +38535,8 @@ var ExecutionOrchestrator = class {
       }
       const profile = AGENT_CATALOG[task.agentRole];
       const currentRoleCount = roleCounts.get(task.agentRole) ?? 0;
-      if (currentRoleCount >= profile.maxConcurrentTasks) {
+      const effectiveConcurrency = Math.max(profile.maxConcurrentTasks, task.agentRole === "frontend-specialist" || task.agentRole === "backend-specialist" ? 3 : profile.maxConcurrentTasks);
+      if (currentRoleCount >= effectiveConcurrency) {
         continue;
       }
       selected.push(task);
@@ -37660,9 +38556,6 @@ var ExecutionOrchestrator = class {
     if (task.agentRole === "planner") {
       return this.executePlannerTask(sessionId, task, request, plan, emitProgress);
     }
-    if (request.workspaceState === "existing" && isStaticSiteTask(task, request) && (task.type === "scaffold" || task.type === "implementation")) {
-      return this.executeDeterministicStaticSiteTask(sessionId, task, request, resolvedApproval, options, emitProgress);
-    }
     if (request.workspaceState === "existing" && looksLikeStaticLandingGoal(request.goal) && task.type === "verification") {
       return this.executeDeterministicVerificationTask(sessionId, task, request, emitProgress, options.signal);
     }
@@ -38079,6 +38972,12 @@ var ExecutionOrchestrator = class {
       ...outcome.usage ? {
         usage: outcome.usage
       } : {},
+      ...outcome.worldModel ? {
+        worldModel: outcome.worldModel
+      } : {},
+      ...outcome.supervisorHints ? {
+        supervisorHints: outcome.supervisorHints
+      } : {},
       ...integrated.integrationFailed && integrated.conflict && task.agentRole !== "integrator" ? {
         handoffTask: createIntegratorHandoffTask(task, outcome, this.toolsForAgent("integrator").map((tool) => tool.id), integrated.conflict)
       } : {}
@@ -38259,6 +39158,89 @@ var ExecutionOrchestrator = class {
       };
     }
   }
+  async maybeRevisePlanAfterTaskOutcome(sessionId, request, plan, task, outcome, emitProgress) {
+    if (!shouldRevisePlanAfterTaskOutcome(task, outcome)) {
+      return {
+        plan
+      };
+    }
+    const config2 = await loadConfig(request.cwd);
+    if (!config2) {
+      return {
+        plan
+      };
+    }
+    const revisionContext = [
+      "Task outcome context:",
+      renderTaskWorldModelContext(task, outcome),
+      "",
+      "Supervisor hints:",
+      outcome.supervisorHints ? [
+        `- should replan: ${outcome.supervisorHints.shouldReplan ? "yes" : "no"}`,
+        `- should reprioritize: ${outcome.supervisorHints.shouldReprioritize ? "yes" : "no"}`,
+        `- should merge delegated work: ${outcome.supervisorHints.shouldMergeDelegatedWork ? "yes" : "no"}`,
+        `- reason: ${outcome.supervisorHints.reason ?? "(none)"}`
+      ].join("\n") : "- none",
+      "",
+      "Tool evidence:",
+      renderPlannerReplanContext(outcome.toolResults),
+      "",
+      "Planner instructions:",
+      "- Reassign, merge, reorder, or split follow-up tasks if the task outcome suggests the current graph is suboptimal.",
+      "- Preserve completed work, but feel free to adapt pending task order, dependencies, agent roles, or milestone shape.",
+      "- Prefer making parallel work possible when blockers or delegated-worker outcomes reveal an opportunity."
+    ].join("\n");
+    try {
+      const brain = await new BrainResolver(config2, createDefaultBrainProviderRegistry(request.cwd)).resolve("planner");
+      const result = await revisePlanWithModel(request, plan, revisionContext, {
+        modelLabel: `${brain.provider.id}/${brain.model}`,
+        ...typeof brain.settings.temperature === "number" ? {
+          temperature: brain.settings.temperature
+        } : {},
+        ...typeof brain.settings.maxTokens === "number" ? {
+          maxTokens: brain.settings.maxTokens
+        } : {},
+        generate: async (input) => brain.client.generateText({
+          model: brain.model,
+          systemPrompt: [
+            brain.settings.promptPreamble,
+            input.systemPrompt
+          ].filter(Boolean).join("\n\n"),
+          userPrompt: input.userPrompt,
+          responseFormat: "json_object",
+          ...typeof input.temperature === "number" ? {
+            temperature: input.temperature
+          } : {},
+          ...typeof input.maxTokens === "number" ? {
+            maxTokens: input.maxTokens
+          } : {}
+        })
+      });
+      if (result.source === "model") {
+        return {
+          plan: result.plan,
+          note: `Planner brain adapted the active task graph after ${task.id} via ${brain.provider.id}/${brain.model}.`
+        };
+      }
+      return {
+        plan,
+        ...result.warning ? {
+          note: `${result.warning} Keeping the current task graph.`
+        } : {}
+      };
+    } catch (error2) {
+      if (emitProgress) {
+        await emitProgress({
+          type: "task-note",
+          sessionId,
+          message: `Planner task adaptation skipped: ${error2 instanceof Error ? error2.message : String(error2)}`
+        });
+      }
+      return {
+        plan
+      };
+    }
+  }
   async maybeExpandReadyTaskGraph(sessionId, request, plan, events, emitProgress) {
     const envelope = this.buildEnvelope(request, plan, sessionId);
     const candidate = envelope.readyTasks.find((task) => shouldDelegateTask(task, request));
@@ -39693,7 +40675,7 @@ async function executePromptByIntent(cwd, input, options = {}) {
   }
   return executeRunPrompt(cwd, input, options.outputFormat ?? "json", {
     ephemeral: options.ephemeral ?? false,
-    maxAutoTasks: options.maxAutoTasks ?? 3,
+    maxAutoTasks: options.maxAutoTasks ?? 4,
     maxAgentSteps: options.maxAgentSteps ?? 8,
     maxRepairAttempts: options.maxRepairAttempts ?? 2,
     ...options.sessionId ? {
@@ -39714,7 +40696,7 @@ function createExecCommand() {
   ], []).option("--image <pathOrUrl>", "Attach an image to the prompt", (value, previous = []) => [
     ...previous,
     value
-  ], []).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount, 2).action(async (rawPrompt, options) => {
+  ], []).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount, 4).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount, 2).action(async (rawPrompt, options) => {
     const cwd = import_node_process5.default.cwd();
     const format = options.json ? "json" : options.outputFormat;
     const agentSelection = await resolveAgentSelection(cwd, {
@@ -42190,7 +43172,7 @@ async function resolveSourceSession(cwd, sessionId, last = false, search) {
   return loadSessionById(sessionId, cwd);
 }
 function createForkCommand() {
-  return new Command("fork").description("Fork a saved session into a new session snapshot.").argument("[sessionId]", "Optional session id; defaults to the latest session").option("--last", "Fork the most recent session", false).option("--list", "List recent sessions and exit", false).option("--search <query>", "Filter sessions by id, goal, cwd, or labels").option("--json", "Print the forked snapshot as JSON", false).option("--execute", "Continue auto-executing the forked session", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount3, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount3, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount3, 2).action(async (sessionId, options) => {
+  return new Command("fork").description("Fork a saved session into a new session snapshot.").argument("[sessionId]", "Optional session id; defaults to the latest session").option("--last", "Fork the most recent session", false).option("--list", "List recent sessions and exit", false).option("--search <query>", "Filter sessions by id, goal, cwd, or labels").option("--json", "Print the forked snapshot as JSON", false).option("--execute", "Continue auto-executing the forked session", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount3, 4).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount3, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount3, 2).action(async (sessionId, options) => {
     const cwd = import_node_process12.default.cwd();
     if (options.list) {
       const sessions = options.search ? await searchSessions(options.search, cwd) : await listSessions(cwd);
@@ -43360,7 +44342,7 @@ function parseCount4(value) {
   return parsed;
 }
 function createResumeCommand() {
-  return new Command("resume").alias("continue").description("Resume the latest saved Kimbho session snapshot.").argument("[sessionId]", "Optional session id; defaults to the latest session").option("--json", "Print the latest session as JSON", false).option("--last", "Resume the most recent session", false).option("--list", "List recent sessions and exit", false).option("--search <query>", "Filter sessions by id, goal, cwd, or labels").option("--execute", "Continue auto-executing the ready-task frontier", false).option("--approve <approvalId>", "Approve a pending action before continuing").option("--deny <approvalId>", "Deny a pending action before continuing").option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount4, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount4, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount4, 2).action(async (sessionId, options) => {
+  return new Command("resume").alias("continue").description("Resume the latest saved Kimbho session snapshot.").argument("[sessionId]", "Optional session id; defaults to the latest session").option("--json", "Print the latest session as JSON", false).option("--last", "Resume the most recent session", false).option("--list", "List recent sessions and exit", false).option("--search <query>", "Filter sessions by id, goal, cwd, or labels").option("--execute", "Continue auto-executing the ready-task frontier", false).option("--approve <approvalId>", "Approve a pending action before continuing").option("--deny <approvalId>", "Deny a pending action before continuing").option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount4, 4).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount4, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount4, 2).action(async (sessionId, options) => {
     const cwd = import_node_process23.default.cwd();
     const firstSearchMatch = options.search ? (await searchSessions(options.search, cwd, 1)).at(0) ?? null : null;
     if (options.list) {
@@ -43439,7 +44421,7 @@ function createRunCommand() {
     "Explicit execution constraint; can be provided multiple times",
     (value, previous = []) => [...previous, value],
     []
-  ).option("--json", "Print the session snapshot as JSON", false).option("--snapshot-only", "Create the session without auto-executing ready tasks", false).option("--agent <id>", "Prefer one custom or plugin agent id for this session").option("--agents <jsonOrPath>", "Inline agent definitions as JSON or a path to a JSON file").option("--session-id <id>", "Use an explicit session id").option("--ephemeral", "Do not persist plans or sessions for this invocation", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount5, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount5, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount5, 2).action(async (goal, options) => {
+  ).option("--json", "Print the session snapshot as JSON", false).option("--snapshot-only", "Create the session without auto-executing ready tasks", false).option("--agent <id>", "Prefer one custom or plugin agent id for this session").option("--agents <jsonOrPath>", "Inline agent definitions as JSON or a path to a JSON file").option("--session-id <id>", "Use an explicit session id").option("--ephemeral", "Do not persist plans or sessions for this invocation", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount5, 4).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount5, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount5, 2).action(async (goal, options) => {
     const cwd = import_node_process24.default.cwd();
     const orchestrator = new ExecutionOrchestrator();
     const agentSelection = await resolveAgentSelection(cwd, {