karajan-code 1.59.0 → 2.0.0

package/src/orchestrator/direct-actions.js

@@ -0,0 +1,186 @@
+// Direct actions: commands Karajan Brain can execute without invoking a full role.
+// Keeps the action catalog small, auditable, and safe.
+
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * @typedef {Object} DirectAction
+ * @property {string} type - action type identifier
+ * @property {Object} params - action-specific parameters
+ */
+
+/**
+ * @typedef {Object} ActionResult
+ * @property {boolean} ok
+ * @property {string} [output]
+ * @property {string} [error]
+ * @property {string} action
+ */
+
+const ALLOWED_COMMANDS = [
+  "npm install", "npm ci", "pnpm install", "yarn install",
+  "pip install -r requirements.txt", "poetry install",
+  "go mod download", "cargo fetch",
+  "bundle install", "composer install", "dotnet restore"
+];
+
+/**
+ * Validate that a shell command is in the allow-list.
+ * Prevents arbitrary command execution.
+ */
+function isCommandAllowed(cmd) {
+  if (!cmd || typeof cmd !== "string") return false;
+  return ALLOWED_COMMANDS.some(allowed => cmd.trim().startsWith(allowed));
+}
+
+/**
+ * Execute an allowed shell command (install deps, etc.).
+ */
+async function runCommand({ cmd, cwd }) {
+  if (!isCommandAllowed(cmd)) {
+    return { ok: false, error: `Command not in allow-list: ${cmd}`, action: "run_command" };
+  }
+
+  try {
+    const output = execSync(cmd, {
+      cwd: cwd || process.cwd(),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 120_000
+    });
+    return { ok: true, output: output.trim(), action: "run_command" };
+  } catch (err) {
+    return { ok: false, error: err.message, action: "run_command" };
+  }
+}
+
+/**
+ * Create a file with given content (only if it doesn't exist).
+ */
+async function createFile({ filePath, content, cwd, overwrite = false }) {
+  try {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd || process.cwd(), filePath);
+
+    // Path traversal guard
+    const resolved = path.resolve(fullPath);
+    const base = path.resolve(cwd || process.cwd());
+    if (!resolved.startsWith(base)) {
+      return { ok: false, error: "Path traversal denied", action: "create_file" };
+    }
+
+    try {
+      await fs.access(fullPath);
+      if (!overwrite) {
+        return { ok: false, error: `File already exists: ${filePath}`, action: "create_file" };
+      }
+    } catch { /* file doesn't exist, proceed */ }
+
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content || "", "utf8");
+    return { ok: true, output: `Created ${filePath}`, action: "create_file" };
+  } catch (err) {
+    return { ok: false, error: err.message, action: "create_file" };
+  }
+}
+
+/**
+ * Append entries to .gitignore (creates if missing, skips duplicates).
+ */
+async function updateGitignore({ entries, cwd }) {
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return { ok: false, error: "No entries provided", action: "update_gitignore" };
+  }
+
+  try {
+    const gitignorePath = path.join(cwd || process.cwd(), ".gitignore");
+    let content = "";
+    try {
+      content = await fs.readFile(gitignorePath, "utf8");
+    } catch { /* will create */ }
+
+    const missing = entries.filter(e => !content.includes(e));
+    if (missing.length === 0) {
+      return { ok: true, output: "All entries already present", action: "update_gitignore" };
+    }
+
+    const append = (content && !content.endsWith("\n") ? "\n" : "") + missing.join("\n") + "\n";
+    await fs.appendFile(gitignorePath, append, "utf8");
+    return { ok: true, output: `Added: ${missing.join(", ")}`, action: "update_gitignore" };
+  } catch (err) {
+    return { ok: false, error: err.message, action: "update_gitignore" };
+  }
+}
+
+/**
+ * Stage files with git add.
+ */
+async function gitAdd({ files, cwd }) {
+  if (!Array.isArray(files) || files.length === 0) {
+    return { ok: false, error: "No files to add", action: "git_add" };
+  }
+
+  try {
+    // Only allow relative paths (no absolute paths, no shell metacharacters)
+    for (const f of files) {
+      if (typeof f !== "string" || f.includes("..") || /[;&|`$]/.test(f)) {
+        return { ok: false, error: `Invalid file path: ${f}`, action: "git_add" };
+      }
+    }
+    const args = files.map(f => `"${f}"`).join(" ");
+    execSync(`git add ${args}`, {
+      cwd: cwd || process.cwd(),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { ok: true, output: `Staged ${files.length} file(s)`, action: "git_add" };
+  } catch (err) {
+    return { ok: false, error: err.message, action: "git_add" };
+  }
+}
+
+const ACTION_HANDLERS = {
+  run_command: runCommand,
+  create_file: createFile,
+  update_gitignore: updateGitignore,
+  git_add: gitAdd
+};
+
+/**
+ * Execute a single direct action.
+ */
+export async function executeAction(action, { cwd } = {}) {
+  if (!action || typeof action !== "object") {
+    return { ok: false, error: "Invalid action", action: "unknown" };
+  }
+
+  const handler = ACTION_HANDLERS[action.type];
+  if (!handler) {
+    return { ok: false, error: `Unknown action type: ${action.type}`, action: action.type };
+  }
+
+  return handler({ ...action.params, cwd: cwd || action.params?.cwd });
+}
+
+/**
+ * Execute a list of actions in sequence. Stops on first failure unless continueOnError.
+ */
+export async function executeActions(actions, { cwd, continueOnError = false } = {}) {
+  const results = [];
+  for (const action of actions || []) {
+    const result = await executeAction(action, { cwd });
+    results.push(result);
+    if (!result.ok && !continueOnError) break;
+  }
+  return results;
+}
+
+/**
+ * Get list of allowed action types.
+ */
+export function getAllowedActionTypes() {
+  return Object.keys(ACTION_HANDLERS);
+}
+
+export { ALLOWED_COMMANDS, isCommandAllowed };

package/src/orchestrator/feedback-enrichment.js

@@ -0,0 +1,140 @@
+// Feedback enrichment: transform vague feedback into actionable instructions.
+// Extracts file hints, line hints, and suggests fixes from feedback text.
+
+/**
+ * Extract file path hints from feedback description.
+ * Matches patterns like: packages/server/auth.js, src/routes/*, auth/middleware.ts
+ */
+export function extractFileHints(description) {
+  if (!description) return [];
+  const hints = new Set();
+
+  // Explicit paths with extensions (supports bare filenames too)
+  const pathRe = /\b([\w./_-]+\.(?:js|ts|jsx|tsx|py|go|rs|java|rb|php|cs|swift|dart|html|css|vue|svelte|astro|json|yml|yaml|md|sql))\b/gi;
+  const paths = description.match(pathRe) || [];
+  for (const p of paths) hints.add(p);
+
+  // Directory references
+  const dirRe = /\b(packages\/[\w-]+|src\/[\w/-]+|tests?\/[\w/-]+|lib\/[\w/-]+)/gi;
+  const dirs = description.match(dirRe) || [];
+  for (const d of dirs) hints.add(d);
+
+  return [...hints];
+}
+
+/**
+ * Detect the category of feedback from description keywords.
+ */
+export function detectCategory(description) {
+  const text = (description || "").toLowerCase();
+  if (/\b(injection|xss|csrf|httponly|sql\s*injection|exposed\s*secret|auth(?:entication)?\s*bypass|authoriza(?:tion)?\s*bypass|cryptograph|token\s*expos)/i.test(text)) return "security";
+  if (/\btest|coverage|assert|spec|mock\b/.test(text)) return "tests";
+  if (/\bperf(ormance)?|slow|optimize|bottleneck|latency\b/.test(text)) return "performance";
+  if (/\b(style|format(?:ting)?|naming|rename|indent|whitespace|comment|jsdoc|cosmetic)\b/.test(text)) return "style";
+  if (/\b(bug|incorrect|wrong|fails?|error|crash|broken)\b/.test(text)) return "correctness";
+  return "other";
+}
+
+/**
+ * Detect severity from description keywords and existing severity field.
+ */
+export function detectSeverity(description, existingSeverity) {
+  if (existingSeverity) return existingSeverity;
+  const text = (description || "").toLowerCase();
+  if (/\bcritical|blocker|severe|production\s*risk\b/.test(text)) return "critical";
+  if (/\b(high|security|vulnerab|breaking|regression|injection|xss|csrf)\b/.test(text)) return "high";
+  if (/\blow|minor|cosmetic|nitpick\b/.test(text)) return "low";
+  return "medium";
+}
+
+/**
+ * Generate actionable instructions from a feedback entry.
+ * Adds concrete steps the coder can follow.
+ */
+export function generateActionPlan(entry) {
+  const steps = [];
+  const cat = entry.category || detectCategory(entry.description);
+
+  // Always start with locating the problem
+  if (entry.file) {
+    steps.push(`Open ${entry.file}${entry.line ? ` at line ${entry.line}` : ""}`);
+  } else {
+    const hints = extractFileHints(entry.description);
+    if (hints.length > 0) {
+      steps.push(`Look in: ${hints.join(", ")}`);
+    } else {
+      steps.push("Identify the relevant file(s) using grep/search");
+    }
+  }
+
+  // Category-specific actions
+  if (cat === "security") {
+    steps.push("Apply the security fix (validate input, escape output, use parameterized queries, etc.)");
+  } else if (cat === "tests") {
+    steps.push("Write the missing test cases covering the scenario described");
+    steps.push("Run tests to verify they pass: npm test or equivalent");
+  } else if (cat === "correctness") {
+    steps.push("Fix the bug described");
+    steps.push("Add a regression test");
+  } else if (cat === "performance") {
+    steps.push("Optimize the identified bottleneck");
+    steps.push("Verify improvement with measurements");
+  } else if (cat === "style") {
+    steps.push("Apply the style fix (run linter if available)");
+  }
+
+  // Include suggested fix if provided
+  if (entry.suggestedFix) {
+    steps.push(`Suggested approach: ${entry.suggestedFix}`);
+  }
+
+  return steps;
+}
+
+/**
+ * Enrich a single feedback entry with file hints, category, severity, and action plan.
+ */
+export function enrichEntry(entry) {
+  const description = entry.description || "";
+  // Re-detect category when missing or set to default "other"
+  const category = (!entry.category || entry.category === "other")
+    ? detectCategory(description)
+    : entry.category;
+  const severity = detectSeverity(description, entry.severity);
+  const fileHints = entry.file ? [entry.file] : extractFileHints(description);
+
+  return {
+    ...entry,
+    category,
+    severity,
+    fileHints,
+    actionPlan: generateActionPlan({ ...entry, category })
+  };
+}
+
+/**
+ * Enrich all entries in a queue in-place.
+ */
+export function enrichQueue(queue) {
+  queue.entries = queue.entries.map(enrichEntry);
+  return queue;
+}
+
+/**
+ * Format enriched entries as actionable coder prompt sections.
+ */
+export function formatEnrichedForCoder(enrichedEntries) {
+  if (!enrichedEntries?.length) return "";
+
+  const sections = [];
+  enrichedEntries.forEach((e, i) => {
+    const header = `### Issue ${i + 1}: [${e.severity}] ${e.category} — ${e.description}`;
+    const location = e.fileHints?.length
+      ? `**Location hints:** ${e.fileHints.join(", ")}`
+      : "**Location:** search the project for relevant files";
+    const plan = `**Action plan:**\n${e.actionPlan.map(s => `- ${s}`).join("\n")}`;
+    sections.push([header, location, plan].join("\n"));
+  });
+
+  return sections.join("\n\n");
+}

package/src/orchestrator/feedback-queue.js

@@ -0,0 +1,152 @@
+// Structured feedback queue for inter-role communication.
+// Replaces the flat session.last_reviewer_feedback string with typed messages.
+
+/**
+ * @typedef {Object} FeedbackEntry
+ * @property {string} source - "reviewer" | "tester" | "security" | "sonar" | "audit" | "brain"
+ * @property {string} severity - "critical" | "high" | "medium" | "low"
+ * @property {string} category - "security" | "correctness" | "tests" | "style" | "performance" | "other"
+ * @property {string} description
+ * @property {string} [file]
+ * @property {number} [line]
+ * @property {string} [suggestedFix]
+ * @property {string} [id]
+ * @property {number} [iteration] - when this feedback was added
+ */
+
+const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+const CATEGORY_ORDER = { security: 0, correctness: 1, tests: 2, performance: 3, style: 4, other: 5 };
+
+/**
+ * Create a new empty feedback queue.
+ */
+export function createQueue() {
+  return { entries: [] };
+}
+
+/**
+ * Add a feedback entry to the queue.
+ */
+export function addEntry(queue, entry) {
+  if (!entry || !entry.description) return queue;
+  const normalized = {
+    source: entry.source || "unknown",
+    severity: entry.severity || "medium",
+    category: entry.category || "other",
+    description: entry.description,
+    file: entry.file || null,
+    line: entry.line || null,
+    suggestedFix: entry.suggestedFix || null,
+    id: entry.id || null,
+    iteration: entry.iteration || 0
+  };
+  queue.entries.push(normalized);
+  return queue;
+}
+
+/**
+ * Add multiple entries at once.
+ */
+export function addEntries(queue, entries) {
+  for (const e of entries || []) addEntry(queue, e);
+  return queue;
+}
+
+/**
+ * Deduplicate entries with the same description + source (keep the most severe).
+ */
+export function deduplicate(queue) {
+  const seen = new Map();
+  for (const e of queue.entries) {
+    const key = `${e.source}::${e.description}`;
+    const existing = seen.get(key);
+    if (!existing || SEVERITY_ORDER[e.severity] < SEVERITY_ORDER[existing.severity]) {
+      seen.set(key, e);
+    }
+  }
+  queue.entries = [...seen.values()];
+  return queue;
+}
+
+/**
+ * Sort entries by priority: category first (security > correctness > ...), then severity.
+ */
+export function prioritize(queue) {
+  queue.entries.sort((a, b) => {
+    const catDiff = (CATEGORY_ORDER[a.category] ?? 5) - (CATEGORY_ORDER[b.category] ?? 5);
+    if (catDiff !== 0) return catDiff;
+    return (SEVERITY_ORDER[a.severity] ?? 2) - (SEVERITY_ORDER[b.severity] ?? 2);
+  });
+  return queue;
+}
+
+/**
+ * Format queue as a numbered list for the coder prompt.
+ */
+export function formatForCoder(queue) {
+  if (!queue.entries.length) return "";
+
+  const lines = [];
+  queue.entries.forEach((e, i) => {
+    const loc = e.file ? ` (${e.file}${e.line ? `:${e.line}` : ""})` : "";
+    const tag = `[${e.source}:${e.severity}:${e.category}]`;
+    lines.push(`${i + 1}. ${tag}${loc} ${e.description}`);
+    if (e.suggestedFix) lines.push(`   Fix: ${e.suggestedFix}`);
+  });
+  return lines.join("\n");
+}
+
+/**
+ * Filter entries by category.
+ */
+export function filterByCategory(queue, category) {
+  return { entries: queue.entries.filter(e => e.category === category) };
+}
+
+/**
+ * Check if queue has any critical/high severity entries.
+ */
+export function hasBlockingIssues(queue) {
+  return queue.entries.some(e => e.severity === "critical" || e.severity === "high");
+}
+
+/**
+ * Get count of entries by category.
+ */
+export function countByCategory(queue) {
+  const counts = {};
+  for (const e of queue.entries) {
+    counts[e.category] = (counts[e.category] || 0) + 1;
+  }
+  return counts;
+}
+
+/**
+ * Clear the queue (after coder addresses the feedback).
+ */
+export function clear(queue) {
+  queue.entries = [];
+  return queue;
+}
+
+/**
+ * Serialize queue for persistence in session.
+ */
+export function serialize(queue) {
+  return JSON.stringify(queue);
+}
+
+/**
+ * Deserialize queue from session.
+ */
+export function deserialize(str) {
+  if (!str) return createQueue();
+  try {
+    const parsed = JSON.parse(str);
+    return { entries: Array.isArray(parsed.entries) ? parsed.entries : [] };
+  } catch {
+    return createQueue();
+  }
+}
+
+export { SEVERITY_ORDER, CATEGORY_ORDER };

package/src/orchestrator/flow-control.js

@@ -0,0 +1,159 @@
+/**
+ * Session flow control — checkpoints, timeouts, budget checks.
+ * Extracted from orchestrator.js — session management, not orchestration.
+ */
+import { markSessionStatus, addCheckpoint } from "../session-store.js";
+import { emitProgress, makeEvent } from "../utils/events.js";
+import { msg, getLang } from "../utils/messages.js";
+
+function detectCheckpointProgress(session, lastCheckpointSnapshot) {
+  if (!lastCheckpointSnapshot) return true; // First checkpoint — assume progress
+  const currentIteration = session.reviewer_retry_count ?? 0;
+  const currentStages = Object.keys(session.resolved_policies || {}).length;
+  const currentCheckpoints = (session.checkpoints || []).length;
+
+  const iterationAdvanced = currentIteration !== lastCheckpointSnapshot.iteration;
+  const stagesChanged = currentStages !== lastCheckpointSnapshot.stagesCount;
+  const checkpointsChanged = currentCheckpoints !== lastCheckpointSnapshot.checkpointsCount;
+
+  return iterationAdvanced || stagesChanged || checkpointsChanged;
+}
+
+export function takeCheckpointSnapshot(session) {
+  return {
+    iteration: session.reviewer_retry_count ?? 0,
+    stagesCount: Object.keys(session.resolved_policies || {}).length,
+    checkpointsCount: (session.checkpoints || []).length
+  };
+}
+
+/**
+ * Determine if checkpoint should auto-continue without asking the user.
+ * Exported for testing.
+ */
+export function shouldAutoContinueCheckpoint(session, hasProgress) {
+  if (hasProgress) {
+    session._checkpoint_stall_count = 0;
+    return { autoContinue: true, reason: "progress_detected" };
+  }
+  const wasRateLimited = (session.standby_retry_count || 0) > 0;
+  const consecutiveStalls = (session._checkpoint_stall_count || 0) + 1;
+  session._checkpoint_stall_count = consecutiveStalls;
+  if (wasRateLimited && consecutiveStalls < 3) {
+    return { autoContinue: true, reason: "recoverable_stall" };
+  }
+  return { autoContinue: false, reason: consecutiveStalls >= 3 ? "max_stalls_reached" : "no_progress" };
+}
+
+export async function handleCheckpoint({ checkpointDisabled, askQuestion, lastCheckpointAt, checkpointIntervalMs, elapsedMinutes, i, config, budgetTracker, stageResults, emitter, eventBase, session, budgetSummary, lastCheckpointSnapshot }) {
+  if (checkpointDisabled || !askQuestion || (Date.now() - lastCheckpointAt) < checkpointIntervalMs) {
+    return { action: "continue_loop", checkpointDisabled, lastCheckpointAt, lastCheckpointSnapshot };
+  }
+
+  const elapsedStr = elapsedMinutes.toFixed(1);
+  const stagesCompleted = Object.keys(stageResults).join(", ") || "none";
+
+  const hasProgress = detectCheckpointProgress(session, lastCheckpointSnapshot);
+  const newSnapshot = takeCheckpointSnapshot(session);
+  const decision = shouldAutoContinueCheckpoint(session, hasProgress);
+
+  if (decision.autoContinue) {
+    emitProgress(
+      emitter,
+      makeEvent("session:checkpoint", { ...eventBase, iteration: i, stage: "checkpoint" }, {
+        message: `Checkpoint: ${decision.reason === "progress_detected" ? "progress detected" : "stall caused by rate limit/cooldown"}, auto-continuing (${elapsedStr} min elapsed)`,
+        detail: { elapsed_minutes: Number(elapsedStr), iterations_done: i - 1, stages: stagesCompleted, auto_continued: true, reason: decision.reason }
+      })
+    );
+    return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now(), lastCheckpointSnapshot: newSnapshot };
+  }
+
+  const iterInfo = `${i - 1}/${config.max_iterations} iterations completed`;
+  const budgetInfo = budgetTracker.total().cost_usd > 0 ? ` | Budget: $${budgetTracker.total().cost_usd.toFixed(2)}` : "";
+  const checkpointMsg = `Checkpoint — ${elapsedStr} min elapsed | ${iterInfo}${budgetInfo} | Stages completed: ${stagesCompleted}. No progress since last checkpoint. What would you like to do?`;
+
+  emitProgress(
+    emitter,
+    makeEvent("session:checkpoint", { ...eventBase, iteration: i, stage: "checkpoint" }, {
+      message: `Interactive checkpoint at ${elapsedStr} min (stalled)`,
+      detail: { elapsed_minutes: Number(elapsedStr), iterations_done: i - 1, stages: stagesCompleted, auto_continued: false }
+    })
+  );
+
+  const lang = getLang(config);
+  const answer = await askQuestion(
+    `${checkpointMsg}\n\n${msg("checkpoint_options", lang)}`
+  );
+
+  await addCheckpoint(session, { stage: "interactive-checkpoint", elapsed_minutes: Number(elapsedStr), answer });
+
+  const trimmedAnswer = (answer || "").trim();
+  const isExplicitStop = trimmedAnswer === "4" || trimmedAnswer.toLowerCase().startsWith("stop");
+
+  if (isExplicitStop) {
+    await markSessionStatus(session, "stopped");
+    emitProgress(
+      emitter,
+      makeEvent("session:end", { ...eventBase, iteration: i, stage: "user-stop" }, {
+        status: "stopped",
+        message: "Session stopped by user at checkpoint",
+        detail: { approved: false, reason: "user_stopped", elapsed_minutes: Number(elapsedStr), budget: budgetSummary() }
+      })
+    );
+    return { action: "stop", result: { approved: false, sessionId: session.id, reason: "user_stopped", elapsed_minutes: Number(elapsedStr) } };
+  }
+
+  const parsed = parseCheckpointAnswer({ trimmedAnswer, checkpointDisabled, config });
+  parsed.lastCheckpointSnapshot = newSnapshot;
+  return parsed;
+}
+
+export function parseCheckpointAnswer({ trimmedAnswer, checkpointDisabled, config }) {
+  if (!trimmedAnswer) {
+    return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now() };
+  }
+  if (trimmedAnswer === "2" || trimmedAnswer.toLowerCase().startsWith("continue until")) {
+    return { action: "continue_loop", checkpointDisabled: true, lastCheckpointAt: Date.now() };
+  }
+  if (trimmedAnswer === "1" || trimmedAnswer.toLowerCase().includes("5 m")) {
+    return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now() };
+  }
+  const customMinutes = Number.parseInt(trimmedAnswer.replaceAll(/\D/g, ""), 10);
+  if (customMinutes > 0) {
+    config.session.checkpoint_interval_minutes = customMinutes;
+    return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now() };
+  }
+  return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now() };
+}
+
+export async function checkSessionTimeout({ askQuestion, elapsedMinutes, config, session, emitter, eventBase, i, budgetSummary }) {
+  if (askQuestion || elapsedMinutes <= config.session.max_total_minutes) return;
+
+  await markSessionStatus(session, "failed");
+  emitProgress(
+    emitter,
+    makeEvent("session:end", { ...eventBase, iteration: i, stage: "timeout" }, {
+      status: "fail",
+      message: "Session timed out",
+      detail: { approved: false, reason: "timeout", budget: budgetSummary() }
+    })
+  );
+  throw new Error("Session timed out");
+}
+
+export async function checkBudgetExceeded({ budgetTracker, config, session, emitter, eventBase, i, budgetLimit, budgetSummary }) {
+  if (!budgetTracker.isOverBudget(config?.max_budget_usd)) return;
+
+  await markSessionStatus(session, "failed");
+  const totalCost = budgetTracker.total().cost_usd;
+  const message = `Budget exceeded: $${totalCost.toFixed(2)} > $${budgetLimit.toFixed(2)}`;
+  emitProgress(
+    emitter,
+    makeEvent("session:end", { ...eventBase, iteration: i, stage: "budget" }, {
+      status: "fail",
+      message,
+      detail: { approved: false, reason: "budget_exceeded", budget: budgetSummary(), max_budget_usd: budgetLimit }
+    })
+  );
+  throw new Error(message);
+}

package/src/orchestrator/post-loop-stages.js

@@ -138,18 +138,20 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
   );
 
   if (!testerOutput.ok) {
-    // Tester findings are advisory when reviewer already approved.
-    // Auto-continue with a warning — no human escalation needed.
-    logger.warn(`Tester failed (advisory): ${testerOutput.summary}`);
+    // Tester failed — blocking, return to coder for correction
+    logger.warn(`Tester failed (blocking): ${testerOutput.summary}`);
     emitProgress(
       emitter,
-      makeEvent("tester:auto-continue", { ...eventBase, stage: "tester" }, {
-        status: "warn",
-        message: `Tester issues are advisory (reviewer approved), continuing: ${testerOutput.summary}`,
-        detail: { summary: testerOutput.summary, auto_continued: true, provider: testerProvider, executorType: "agent" }
+      makeEvent("tester:blocking", { ...eventBase, stage: "tester" }, {
+        status: "fail",
+        message: `Tester failed — sending back to coder for correction: ${testerOutput.summary}`,
+        detail: { summary: testerOutput.summary, blocking: true, provider: testerProvider, executorType: "agent" }
       })
     );
-    return { action: "ok", stageResult: { ok: false, summary: testerOutput.summary || "Tester issues (advisory)", auto_continued: true } };
+    return {
+      action: "continue",
+      stageResult: { ...testerOutput.result, summary: testerOutput.summary, provider: testerProvider }
+    };
   }
 
   session.tester_retry_count = 0;
@@ -230,17 +232,20 @@ export async function runSecurityStage({ config, logger, emitter, eventBase, ses
       return { action: "ok" };
     }
 
-    // Non-critical security findings are advisory when reviewer already approved.
-    logger.warn(`Security failed (advisory): ${securityOutput.summary}`);
+    // Non-critical security findings — blocking, return to coder for correction
+    logger.warn(`Security failed (blocking): ${securityOutput.summary}`);
     emitProgress(
       emitter,
-      makeEvent("security:auto-continue", { ...eventBase, stage: "security" }, {
-        status: "warn",
-        message: `Security issues are advisory (reviewer approved), continuing: ${securityOutput.summary}`,
-        detail: { summary: securityOutput.summary, auto_continued: true }
+      makeEvent("security:blocking", { ...eventBase, stage: "security" }, {
+        status: "fail",
+        message: `Security failed — sending back to coder for correction: ${securityOutput.summary}`,
+        detail: { summary: securityOutput.summary, blocking: true, provider: securityProvider, executorType: "agent" }
       })
     );
-    return { action: "ok", stageResult: { ok: false, summary: securityOutput.summary || "Security issues (advisory)", auto_continued: true } };
+    return {
+      action: "continue",
+      stageResult: { ...securityOutput.result, summary: securityOutput.summary, provider: securityProvider }
+    };
   }
 
   session.security_retry_count = 0;