ralphctl 0.10.0 → 0.11.0

package/dist/cli.mjs

@@ -399,7 +399,10 @@ import { z } from "zod";
 var CLAUDE_MODELS = [
   "claude-haiku-4-5",
   "claude-sonnet-4-6",
-  "claude-opus-4-8"
+  "claude-opus-4-8",
+  "claude-opus-4-8[1m]",
+  "claude-fable-5",
+  "claude-fable-5[1m]"
 ];
 var isClaudeModel = (s) => CLAUDE_MODELS.includes(s);
 
@@ -408,6 +411,7 @@ var CODEX_MODELS = [
   "gpt-5.5",
   "gpt-5.4",
   "gpt-5.4-mini",
+  "gpt-5.3-codex-spark",
   "gpt-5.3-codex",
   "gpt-5.2",
   "codex-auto-review"
@@ -420,6 +424,7 @@ var COPILOT_MODELS = [
   "gpt-5.4-mini",
   "gpt-5.1",
   "gpt-5.4",
+  "gpt-5.5",
   "gpt-5.3-codex",
   "gpt-5.2-codex",
   "gpt-5.2",
@@ -431,10 +436,18 @@ var COPILOT_MODELS = [
   "claude-sonnet-4.6",
   "claude-sonnet-4.5",
   "claude-sonnet-4",
+  "claude-opus-4.8",
+  "claude-opus-4.7",
   "claude-opus-4.6",
   "claude-opus-4.6-fast",
   "claude-opus-4.5",
-  "gemini-3-pro-preview"
+  "gemini-3.1-pro-preview",
+  "gemini-3-pro-preview",
+  "gemini-3-flash-preview",
+  "gemini-3.5-flash",
+  "gemini-2.5-pro",
+  "mai-code-1-flash",
+  "raptor-mini-preview"
 ];
 var isCopilotModel = (s) => COPILOT_MODELS.includes(s);
 
@@ -522,6 +535,18 @@ var migrateRetiredClaudeOpus = (ai) => {
   return next;
 };
 var promoteLegacyAiRows = (ai) => migrateRetiredClaudeOpus(seedLegacyCreatePrRow(promoteLegacyImplementRow(ai)));
+var healHarnessCrossKnobs = (harness) => {
+  if (typeof harness !== "object" || harness === null) return harness;
+  const h = harness;
+  const turns = h["maxTurns"];
+  if (typeof turns !== "number" || !Number.isInteger(turns)) return harness;
+  const rawThreshold = h["plateauThreshold"];
+  const threshold = typeof rawThreshold === "number" && Number.isInteger(rawThreshold) ? rawThreshold : 3;
+  if (turns >= threshold) return harness;
+  const healedThreshold = Math.max(2, Math.min(threshold, turns));
+  const healedTurns = Math.max(turns, healedThreshold);
+  return { ...h, maxTurns: healedTurns, plateauThreshold: healedThreshold };
+};
 var AiSettingsSchema = z.preprocess(
   promoteLegacyAiRows,
   z.object({
@@ -542,40 +567,64 @@ var SettingsSchema = z.object({
    */
   schemaVersion: z.literal(CURRENT_SCHEMA_VERSION).default(CURRENT_SCHEMA_VERSION),
   ai: AiSettingsSchema,
-  harness: z.object({
-    /** Generator–evaluator turns budgeted per `Attempt` (1–10). */
-    maxTurns: z.number().int().min(1).max(10),
-    /** Default cap on attempts per task before transitioning to `blocked` (1–10). */
-    maxAttempts: z.number().int().min(1).max(10),
-    /** Adapter-side retries on `RateLimitError` before surfacing the failure (0–10). */
-    rateLimitRetries: z.number().int().min(0).max(10),
-    /**
-     * Consecutive evaluator turns flagging the same failed-dimension set before the loop
-     * exits with a `plateau` warning (2–5). Setting to 3+ gives the AI extra retries before
-     * the harness gives up. See `business/task/plateau-detection.ts` for the exemption rules
-     * (score improvement / commit-message change / critique-prose shift) that can soften or
-     * skip the plateau even when the threshold is met.
-     */
-    plateauThreshold: z.number().int().min(2).max(5).default(2),
-    /**
-     * When the gen-eval loop exits on a plateau, grant one more attempt instead of settling
-     * immediately: escalate the generator one rung up the ladder ({@link escalationMap} merged
-     * with the built-in `DEFAULT_ESCALATION_MAP`) when a stronger model exists, and ALWAYS inject
-     * a "change your approach" directive into that attempt's generator turn (so a top-of-ladder
-     * model — e.g. the default Opus generator — still acts differently rather than re-iterating).
-     * A plateau never blocks: after the one retry, or when no attempt budget remains, the work is
-     * preserved (done-with-warning). Defaults `true`.
-     */
-    escalateOnPlateau: z.boolean().default(true),
-    /**
-     * User overrides for the built-in `DEFAULT_ESCALATION_MAP` (in
-     * `business/task/escalation-map.ts`). Keys are the current model id, values the model id
-     * to escalate to. Empty by default; merged at read time with user keys winning on
-     * conflict and extending the default ladder. Non-string entries fail schema validation
-     * with a typed Zod error naming the offending field.
-     */
-    escalationMap: z.record(z.string(), z.string()).default({})
-  }),
+  harness: z.preprocess(
+    healHarnessCrossKnobs,
+    z.object({
+      /** Generator–evaluator turns budgeted per `Attempt` (1–10). */
+      maxTurns: z.number().int().min(1).max(10),
+      /** Default cap on attempts per task before transitioning to `blocked` (1–10). */
+      maxAttempts: z.number().int().min(1).max(10),
+      /** Adapter-side retries on `RateLimitError` before surfacing the failure (0–10). */
+      rateLimitRetries: z.number().int().min(0).max(10),
+      /**
+       * Consecutive evaluator turns flagging the same failed-dimension set before the loop
+       * exits with a `plateau` warning (2–5, default 3 — patient: the graduated remedy ladder
+       * climbs cheapest-first across plateaus, so a slightly higher threshold avoids spending an
+       * escalation rung on a stall the generator would have broken on its own). See
+       * `business/task/plateau-detection.ts` for the exemption rules (score improvement /
+       * commit-message change / critique-prose shift) that can soften or skip the plateau even
+       * when the threshold is met.
+       */
+      plateauThreshold: z.number().int().min(2).max(5).default(3),
+      /**
+       * Master switch for failure-driven generator-model escalation. The flag name is retained for
+       * backward compatibility, but it now gates ALL failure-driven escalation — not only plateau:
+       * `plateau` AND `budget-exhausted` (the turn budget ran out without a terminal verdict) exits
+       * both climb the ladder, and `malformed` exits (the evaluator emitted no parseable verdict) get
+       * a plain same-model fresh-attempt retry — instead of settling immediately.
+       *
+       * On an escalatable exit the generator climbs one rung up the merged ladder ({@link
+       * escalationMap} over the built-in `DEFAULT_ESCALATION_MAP`) across successive failures, bounded
+       * by `maxAttempts`; each climb hands the targeted prior critique to the stronger model. The
+       * "change your approach" directive is NOT injected on a model bump — it fires only once the
+       * generator reaches the top of the ladder, as a same-model nudge (one more attempt on the same
+       * model, where no fresh capability remains so a change of approach is the only lever). A
+       * malformed exit never burns a ladder rung (it is the evaluator's failure, not the generator's)
+       * — it retries on the same model while budget remains.
+       *
+       * A failure-driven retry never blocks: after the ladder tops out (a further failure on the
+       * nudged top-tier model) or the attempt budget is exhausted, the work is preserved
+       * (done-with-warning). Defaults `true`.
+       */
+      escalateOnPlateau: z.boolean().default(true),
+      /**
+       * User overrides for the built-in `DEFAULT_ESCALATION_MAP` (in
+       * `business/task/escalation-map.ts`). Keys are the current model id, values the model id
+       * to escalate to. Empty by default; merged at read time with user keys winning on
+       * conflict and extending the default ladder. Non-string entries fail schema validation
+       * with a typed Zod error naming the offending field.
+       */
+      escalationMap: z.record(z.string(), z.string()).default({})
+    }).superRefine((harness, ctx) => {
+      if (harness.maxTurns < harness.plateauThreshold) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["maxTurns"],
+          message: `maxTurns (${String(harness.maxTurns)}) must be \u2265 plateauThreshold (${String(harness.plateauThreshold)}); when maxTurns < plateauThreshold the plateau window can never fill within a single attempt and escalation becomes unreachable. Increase maxTurns or lower plateauThreshold.`
+        });
+      }
+    })
+  ),
   logging: z.object({
     level: LogLevelSchema
   }),
@@ -674,7 +723,10 @@ var DEFAULT_MODELS_BY_PROVIDER = {
   "openai-codex": {
     refine: "gpt-5.4-mini",
     plan: "gpt-5.5",
-    implement: "gpt-5.3-codex",
+    // `gpt-5.3-codex` is deprecated for ChatGPT sign-in — the "reset implement to Codex" path
+    // rides the frontier default `gpt-5.5` instead, matching the CODEX_ONLY preset decision so
+    // the everyday autonomous loop works under ChatGPT auth and sits at the top of the ladder.
+    implement: "gpt-5.5",
     readiness: "gpt-5.4-mini",
     ideate: "gpt-5.5",
     createPr: "gpt-5.4-mini"
@@ -705,7 +757,7 @@ var DEFAULT_SETTINGS = {
     maxTurns: 5,
     maxAttempts: 3,
     rateLimitRetries: 3,
-    plateauThreshold: 2,
+    plateauThreshold: 3,
     escalateOnPlateau: true,
     escalationMap: {}
   },
@@ -902,13 +954,24 @@ var createGitRunner = (deps = {}) => {
         );
         return;
       }
-      finish(
-        Result.ok({
-          stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf8"),
-          exitCode: code ?? -1
-        })
-      );
+      try {
+        finish(
+          Result.ok({
+            stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+            stderr: Buffer.concat(stderrChunks).toString("utf8"),
+            exitCode: code ?? -1
+          })
+        );
+      } catch (cause) {
+        finish(
+          Result.error(
+            new StorageError({
+              subCode: "io",
+              message: `git output too large to materialize: git ${args.join(" ")} \u2014 ${stringifyError(cause)}`
+            })
+          )
+        );
+      }
     });
   });
   return { run };
@@ -1892,10 +1955,18 @@ var markTaskBlocked = (task, reason, blockKind) => {
 var unblockTask = (task) => {
   const guard2 = requireStatus("task", task, ["blocked"], "unblock");
   if (!guard2.ok) return Result.error(guard2.error);
-  const { blockedReason: _reason, blockKind: _kind, ...rest } = guard2.value;
+  const {
+    blockedReason: _reason,
+    blockKind: _kind,
+    escalatedFromModel: _from,
+    escalatedToModel: _to,
+    ...rest
+  } = guard2.value;
   void _reason;
   void _kind;
-  return Result.ok({ ...rest, status: "todo" });
+  void _from;
+  void _to;
+  return Result.ok({ ...rest, status: "todo", attempts: [] });
 };
 var resetTaskToTodo = (task) => {
   if (task.status === "todo") return Result.ok(task);
@@ -2661,7 +2732,10 @@ var CONTEXT_WINDOW = {
   // Claude (claude-code adapter — direct from Anthropic)
   "claude-haiku-4-5": 2e5,
   "claude-sonnet-4-6": 2e5,
-  "claude-opus-4-8": 2e5
+  "claude-opus-4-8": 2e5,
+  // `[1m]` is Claude Code's 1M-token long-context selector — the window is part of the id.
+  "claude-opus-4-8[1m]": 1e6,
+  "claude-fable-5[1m]": 1e6
 };
 var contextWindowFor = (model) => {
   if (model === void 0) return void 0;
@@ -4305,22 +4379,24 @@ var parseIssueUrl = (url) => {
       const repo = segments[1];
       const num = Number(segments[3]);
       if (owner && repo && Number.isInteger(num) && num > 0) {
-        return { host: "github", owner, repo, number: num };
+        return { host: "github", hostname: parsed.hostname, owner, repo, number: num };
       }
     }
     return null;
   }
   const dashIdx = segments.indexOf("-");
-  if (dashIdx >= 2 && segments[dashIdx + 1] === "issues") {
+  const kind = dashIdx >= 0 ? segments[dashIdx + 1] : void 0;
+  if (dashIdx >= 2 && (kind === "issues" || kind === "work_items")) {
     const num = Number(segments[dashIdx + 2]);
     const repo = segments[dashIdx - 1];
     if (repo && Number.isInteger(num) && num > 0) {
       const owner = segments.slice(0, dashIdx - 1).join("/");
-      return { host: "gitlab", owner, repo, number: num };
+      return { host: "gitlab", hostname: parsed.hostname, owner, repo, number: num };
     }
   }
   return null;
 };
+var glabRepoArg = (parsed) => `${parsed.hostname}/${parsed.owner}/${parsed.repo}`;
 var looksLikeNotFound = (stderr) => {
   const s = stderr.toLowerCase();
   return s.includes("not found") || s.includes("404") || s.includes("could not resolve") || s.includes("does not exist");
@@ -4378,7 +4454,7 @@ var fetchGitLabNotes = async (spawn3, parsed) => {
   const result = await runCli(
     spawn3,
     "glab",
-    ["issue", "note", "list", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--output", "json"],
+    ["issue", "note", "list", String(parsed.number), "--repo", glabRepoArg(parsed), "--output", "json"],
     { timeoutMs: CLI_TIMEOUT_MS }
   );
   if (!result.ok) return { comments: [], failure: result.error.message };
@@ -4409,7 +4485,7 @@ var fetchGitLab = async (spawn3, parsed, url, logger) => {
   const result = await runCli(
     spawn3,
     "glab",
-    ["issue", "view", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--output", "json"],
+    ["issue", "view", String(parsed.number), "--repo", glabRepoArg(parsed), "--output", "json"],
     { timeoutMs: CLI_TIMEOUT_MS }
   );
   if (!result.ok) return Result.error(result.error);
@@ -4477,7 +4553,15 @@ var commentGitLab = async (spawn3, url, body, parsed) => {
   const r = await runCli(
     spawn3,
     "glab",
-    ["issue", "comment", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--body", body],
+    [
+      "issue",
+      "comment",
+      String(parsed.number),
+      "--repo",
+      `${parsed.hostname}/${parsed.owner}/${parsed.repo}`,
+      "--body",
+      body
+    ],
     { timeoutMs: CLI_TIMEOUT_MS2 }
   );
   if (!r.ok) return Result.error(r.error);
@@ -5075,7 +5159,7 @@ var createNpmVersionChecker = (deps) => {
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.10.0",
+  version: "0.11.0",
   description: "Agent harness for long-running AI coding tasks \u2014 orchestrates Claude Code, GitHub Copilot, and OpenAI Codex across repositories",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -5185,12 +5269,17 @@ var CLI_METADATA = {
 
 // src/business/task/escalation-map.ts
 var DEFAULT_ESCALATION_MAP = {
-  // Claude — Sonnet escalates to Opus; Haiku escalates to Sonnet.
+  // Claude (Claude-Code / Codex dash-form) — Haiku → Sonnet → Opus.
   "claude-haiku-4-5": "claude-sonnet-4-6",
   "claude-sonnet-4-6": "claude-opus-4-8",
-  // Copilot/Codex — mini variants step up to their full-tier frontier.
+  // Claude (Copilot dot-form) — Haiku → Sonnet → Opus.
+  "claude-haiku-4.5": "claude-sonnet-4.6",
+  "claude-sonnet-4.6": "claude-opus-4.8",
+  // Copilot/Codex GPT — mini variants step up to their full-tier frontier, and the
+  // economic full tier (`gpt-5.4`) climbs to the flagship.
   "gpt-5-mini": "gpt-5.5",
-  "gpt-5.4-mini": "gpt-5.5"
+  "gpt-5.4-mini": "gpt-5.5",
+  "gpt-5.4": "gpt-5.5"
 };
 var mergeEscalationMap = (user) => ({
   ...DEFAULT_ESCALATION_MAP,
@@ -5203,6 +5292,16 @@ var warnEscalationMapSelfLoops = (escalationMap, logger) => {
     }
   }
 };
+var escalationLadderCyclicFrom = (map, start) => {
+  const seen = /* @__PURE__ */ new Set([start]);
+  let cur = map[start];
+  while (cur !== void 0) {
+    if (seen.has(cur)) return true;
+    seen.add(cur);
+    cur = map[cur];
+  }
+  return false;
+};
 
 // src/integration/ai/skills/_engine/filesystem-skills-adapter.ts
 import { existsSync } from "fs";
@@ -10212,7 +10311,8 @@ var TaskBlock = ({
   cardExpanded,
   cardFocused,
   nowMs,
-  blockedReason
+  blockedReason,
+  warningSummary
 }) => {
   const presentation = STATUS_PRESENTATION[task.status];
   const isSpinning = task.status === "running";
@@ -10224,6 +10324,7 @@ var TaskBlock = ({
   const evalElided = task.evaluations.length - evalRows.length;
   const criteriaBullets = taskCriteria;
   const blockedReasonText = blockedReason?.trim() ?? "";
+  const warningSummaryText = task.status === "completed" ? warningSummary?.trim() ?? "" : "";
   const latestCommitSha = useMemo8(() => {
     const sha = taskProjection?.lastAttempt?.commitSha;
     return sha !== void 0 ? String(sha).slice(0, 7) : void 0;
@@ -10313,6 +10414,14 @@ var TaskBlock = ({
       " ",
       collapseWhitespace(blockedReasonText)
     ] }) }) }),
+    warningSummaryText.length > 0 && // A done card that carries a final-attempt warning — surfaced collapsed OR expanded so the
+    // operator never reads a flagged completion as a clean pass. Same warning glyph as the
+    // attempt-card / blocked line; the tasks list previously showed it only for blockedReason.
+    /* @__PURE__ */ jsx33(Box22, { paddingLeft: 2, children: /* @__PURE__ */ jsx33(Box22, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs23(Text23, { color: inkColors.warning, wrap: "truncate-end", children: [
+      glyphs.warningGlyph,
+      " ",
+      collapseWhitespace(warningSummaryText)
+    ] }) }) }),
     cardExpanded && idleSnippets.length > 0 && /* @__PURE__ */ jsx33(Box22, { paddingLeft: 2, children: /* @__PURE__ */ jsx33(Box22, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs23(Text23, { dimColor: true, wrap: "truncate-end", children: [
       glyphs.activityArrow,
       " ",
@@ -10531,6 +10640,7 @@ var TasksPanel = ({
   inputActive = false,
   taskCriteriaById,
   blockedReasonById,
+  warningSummaryById,
   showEvaluatorFailureUI = false,
   sprintState,
   nowMs
@@ -10634,6 +10744,7 @@ var TasksPanel = ({
       const taskCriteria = criteriaBullets !== void 0 && criteriaBullets.length > 0 ? criteriaBullets : void 0;
       const taskProjection = sprintState?.tasks.find((t) => t.id === task.id);
       const blockedReason = blockedReasonById?.get(task.id);
+      const warningSummary = warningSummaryById?.get(task.id);
       const isActive = idx === activeTaskIdx;
       return /* @__PURE__ */ jsx34(
         TaskBlock,
@@ -10658,7 +10769,8 @@ var TasksPanel = ({
           ...recovering !== void 0 ? { recovering } : {},
           ...taskCriteria !== void 0 ? { taskCriteria } : {},
           ...taskProjection !== void 0 ? { taskProjection } : {},
-          ...blockedReason !== void 0 ? { blockedReason } : {}
+          ...blockedReason !== void 0 ? { blockedReason } : {},
+          ...warningSummary !== void 0 ? { warningSummary } : {}
         },
         task.id
       );
@@ -11670,11 +11782,13 @@ var formatDuration = (ms) => {
   return minutes > 0 ? `${String(hours)}h ${String(minutes)}m` : `${String(hours)}h`;
 };
 var SHA_DISPLAY_LENGTH = 7;
+var sanitizeInline = (text) => text.replace(/[\r\n\t\v\f]+/g, " ").trim();
+var neutralizeProseHeadings = (text) => text.split("\n").map((line) => line.startsWith("#") ? `  ${line}` : line).join("\n");
 var appendSubsection = (lines, heading, entries) => {
   if (entries.length === 0) return;
   lines.push(`### ${heading}`);
   for (const entry of entries) {
-    lines.push(`- ${entry}`);
+    lines.push(`- ${entry.split("\n").join("\n  ")}`);
   }
   lines.push("");
 };
@@ -11682,22 +11796,64 @@ var appendLearningsSubsection = (lines, entries) => {
   if (entries.length === 0) return;
   lines.push("### Learnings");
   for (const entry of entries) {
-    lines.push(`- **${entry.text}**`);
+    lines.push(`- **${entry.text.split("\n").join("\n  ")}**`);
     if (entry.context !== void 0 && entry.context.trim().length > 0) {
-      lines.push(`  - Context: ${entry.context.trim()}`);
+      lines.push(`  - Context: ${entry.context.trim().split("\n").join("\n    ")}`);
     }
     if (entry.appliesTo !== void 0 && entry.appliesTo.trim().length > 0) {
-      lines.push(`  - Applies to: ${entry.appliesTo.trim()}`);
+      lines.push(`  - Applies to: ${entry.appliesTo.trim().split("\n").join("\n    ")}`);
+    }
+  }
+  lines.push("");
+};
+var warningSentence = (warning) => {
+  switch (warning.kind) {
+    case "budget-exhausted": {
+      const turns = warning.turnsUsed !== void 0 && warning.turnBudget !== void 0 ? ` after exhausting the turn budget (${String(warning.turnsUsed)} of ${String(warning.turnBudget)} turns used)` : " after exhausting the turn budget";
+      return `The evaluator did not pass${turns}.`;
+    }
+    case "plateau": {
+      const dims = warning.dimensions !== void 0 && warning.dimensions.length > 0 ? ` on the same failed dimension${warning.dimensions.length === 1 ? "" : "s"}: ${warning.dimensions.join(", ")}` : "";
+      return `The evaluator plateaued \u2014 two consecutive evaluations flagged the identical failure${dims}.`;
     }
+    case "malformed": {
+      const detail = warning.detail !== void 0 && warning.detail.trim().length > 0 ? ` (${warning.detail.trim()})` : "";
+      return `The evaluator output could not be parsed${detail}.`;
+    }
+    case "verify-failed": {
+      const detail = warning.detail !== void 0 && warning.detail.trim().length > 0 ? `: ${warning.detail.trim()}` : "";
+      return `The post-task verify script ran red after the commit${detail}.`;
+    }
+  }
+};
+var remedySentence = (verdict, escalation, warning) => {
+  if (escalation !== void 0) {
+    return escalation.from === escalation.to ? `Remedy: retried the same model (${escalation.to}) \u2014 already at the top of the escalation ladder.` : `Remedy: escalated the generator model from ${escalation.from} to ${escalation.to}.`;
+  }
+  if (verdict === "escalated" && warning?.kind === "malformed") {
+    return "Remedy: retried on the same model \u2014 the evaluator failed to produce a verdict, so no escalation rung was spent.";
   }
+  if (verdict === "pass-with-warning") {
+    return "Remedy: kept the attempt with the warning attached for operator review.";
+  }
+  return void 0;
+};
+var appendOutcomeDetail = (lines, input) => {
+  const bullets = [];
+  if (input.warning !== void 0) bullets.push(warningSentence(input.warning));
+  const remedy = remedySentence(input.verdict, input.escalation, input.warning);
+  if (remedy !== void 0) bullets.push(remedy);
+  if (bullets.length === 0) return;
+  lines.push("### Outcome detail");
+  for (const b of bullets) lines.push(`- ${b}`);
   lines.push("");
 };
 var renderJournalEntry = (input) => {
   const sha = input.commitSha !== void 0 ? input.commitSha.slice(0, SHA_DISPLAY_LENGTH) : EM_DASH;
-  const outcome = input.outcome.trim().length > 0 ? input.outcome.trim() : "_(no outcome paragraph)_";
+  const outcome = input.outcome.trim().length > 0 ? neutralizeProseHeadings(input.outcome.trim()) : "_(no outcome paragraph)_";
   const lines = [];
   lines.push("");
-  lines.push(`## Task: ${input.taskName} \u2014 Attempt ${String(input.attemptN)}`);
+  lines.push(`## Task: ${sanitizeInline(input.taskName)} \u2014 Attempt ${String(input.attemptN)}`);
   lines.push("");
   lines.push(`_${String(input.timestamp)}_`);
   lines.push("");
@@ -11708,6 +11864,7 @@ var renderJournalEntry = (input) => {
   lines.push(`- Duration: ${formatDuration(input.durationMs)}`);
   lines.push(`- Commit: ${sha}`);
   lines.push("");
+  appendOutcomeDetail(lines, input);
   appendSubsection(lines, "Changes", input.changes);
   appendSubsection(lines, "Decisions", input.decisions);
   appendLearningsSubsection(lines, input.learnings);
@@ -12756,6 +12913,22 @@ var refineTicketInteractiveLeaf = (deps, ticket) => leaf(`refine-ticket-${String
   }
 });
 
+// src/integration/ai/prompts/_engine/extract-placeholders.ts
+var extractPlaceholders = (template) => {
+  const PATTERN = /\{\{([A-Z][A-Z0-9_]*)\}\}/g;
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  let m;
+  while ((m = PATTERN.exec(template)) !== null) {
+    const name = m[1];
+    if (name !== void 0 && !seen.has(name)) {
+      seen.add(name);
+      ordered.push(name);
+    }
+  }
+  return ordered;
+};
+
 // src/integration/ai/prompts/_engine/substitute.ts
 var PLACEHOLDER_PATTERN = /\{\{([A-Z][A-Z0-9_]*)\}\}/g;
 var substitute = (template, values) => template.replace(PLACEHOLDER_PATTERN, (match, key) => {
@@ -12763,14 +12936,17 @@ var substitute = (template, values) => template.replace(PLACEHOLDER_PATTERN, (ma
   const value = values[key];
   return value !== void 0 ? value : match;
 });
-var assertFullySubstituted = (rendered, where) => {
-  const matches = rendered.match(PLACEHOLDER_PATTERN);
-  if (matches === null) return Result.ok(rendered);
-  const unique = Array.from(new Set(matches));
+var assertTemplateKeysFilled = (rendered, template, partialBodies, values, where) => {
+  const required = new Set(extractPlaceholders(template));
+  for (const body of partialBodies) {
+    for (const key of extractPlaceholders(body)) required.add(key);
+  }
+  const missing = Array.from(required).filter((key) => values[key] === void 0);
+  if (missing.length === 0) return Result.ok(rendered);
   return Result.error(
     new ParseError({
       subCode: "schema-mismatch",
-      message: `${where}: rendered prompt has ${String(unique.length)} unresolved placeholder(s): ${unique.join(", ")}. Either fill the slot in the builder's substitution map or remove the placeholder from the template.`
+      message: `${where}: template declares ${String(missing.length)} unfilled placeholder(s): ${missing.map((k) => `{{${k}}}`).join(", ")}. Either fill the slot in the builder's substitution map or remove the placeholder from the template.`
     })
   );
 };
@@ -12780,11 +12956,13 @@ var buildPrompt = async (loader, def, input) => {
   const template = await loader.load(def.templateName);
   if (!template.ok) return Result.error(template.error);
   const values = {};
+  const partialBodies = [];
   if (def.partials !== void 0) {
     for (const [placeholder, name] of Object.entries(def.partials)) {
       const partial = await loader.load(name);
       if (!partial.ok) return Result.error(partial.error);
       values[placeholder] = partial.value.trim();
+      partialBodies.push(partial.value);
     }
   }
   for (const [field, rawSpec] of Object.entries(def.parameters)) {
@@ -12808,7 +12986,7 @@ var buildPrompt = async (loader, def, input) => {
     values[spec.placeholder] = String(validated.value);
   }
   const rendered = substitute(template.value, values);
-  return assertFullySubstituted(rendered, `buildPrompt(${def.templateName})`);
+  return assertTemplateKeysFilled(rendered, template.value, partialBodies, values, `buildPrompt(${def.templateName})`);
 };
 
 // src/integration/ai/prompts/refine/definition.ts
@@ -13883,7 +14061,10 @@ var parseTaskList = (rawTasks, input) => {
     const normalisedExtras = t.extraDimensions !== void 0 ? t.extraDimensions.map((d) => d.trim().toLowerCase()).filter((d) => d.length > 0) : void 0;
     const created = createTask({
       ...mappedId !== void 0 ? { id: mappedId } : {},
-      name: t.name,
+      // Single-line names everywhere: the name is interpolated into the journal's structural
+      // `## Task: <name> — Attempt <N>` header line that cap-progress splits and attributes on —
+      // a planner-emitted newline would break the task's own section boundary.
+      name: t.name.replace(/[\r\n\t\v\f]+/g, " ").trim(),
       ...t.description !== void 0 && t.description.trim().length > 0 ? { description: t.description } : {},
       steps: t.steps,
       verificationCriteria: t.verificationCriteria.map((c) => ({
@@ -13897,7 +14078,8 @@ var parseTaskList = (rawTasks, input) => {
       repositoryId: repoId,
       ...dependsOn.length > 0 ? { dependsOn } : {},
       ...normalisedExtras !== void 0 && normalisedExtras.length > 0 ? { extraDimensions: normalisedExtras } : {},
-      ...externalRefs !== void 0 ? { externalRefs } : {}
+      ...externalRefs !== void 0 ? { externalRefs } : {},
+      ...input.defaultMaxAttempts !== void 0 ? { maxAttempts: input.defaultMaxAttempts } : {}
     });
     if (!created.ok) {
       return Result.error(
@@ -14022,7 +14204,8 @@ var parsePlanOutput = (raw, ctx) => {
   return parseTaskList(json, {
     project: ctx.project,
     mode: { kind: "lookup", tickets: approvedTickets },
-    ...ctx.logger !== void 0 ? { logger: ctx.logger } : {}
+    ...ctx.logger !== void 0 ? { logger: ctx.logger } : {},
+    ...ctx.defaultMaxAttempts !== void 0 ? { defaultMaxAttempts: ctx.defaultMaxAttempts } : {}
   });
 };
 
@@ -14068,7 +14251,8 @@ var callPlannerInteractiveLeaf = (deps) => leaf("call-planner-interactive", {
       const parsed = parsePlanOutput(planSignal.tasksJson, {
         project: input.project,
         sprint: input.sprint,
-        logger: deps.logger
+        logger: deps.logger,
+        defaultMaxAttempts: deps.maxAttempts
       });
       if (!parsed.ok) return Result.error(parsed.error);
       return planSprintUseCase({
@@ -14246,6 +14430,7 @@ var createPlanFlow = (deps, opts) => {
       eventBus: deps.eventBus,
       clock: deps.clock,
       model: opts.model,
+      maxAttempts: opts.maxAttempts,
       ...opts.effort !== void 0 ? { effort: opts.effort } : {},
       ...opts.additionalRoots !== void 0 && opts.additionalRoots.length > 0 ? { additionalRoots: opts.additionalRoots } : {},
       ...deps.reviewBeforeApprove !== void 0 ? { reviewBeforeApprove: deps.reviewBeforeApprove } : {}
@@ -14327,6 +14512,7 @@ var launchPlan = async (ctx) => {
       additionalRoots: snapshot.project.repositories.map((r) => r.path),
       providerId: settings.ai.plan.provider,
       model: settings.ai.plan.model,
+      maxAttempts: settings.harness.maxAttempts,
       ...effort !== void 0 ? { effort } : {},
       planRoot: planRoot.value
     }
@@ -15495,6 +15681,15 @@ var recordRunningAttemptWarning = (task, warning) => {
   if (!guard2.ok) return Result.error(guard2.error);
   return Result.ok(replaceLastAttempt(task, recordAttemptWarning(guard2.value.running, warning)));
 };
+var clearRunningAttemptPlateauWarning = (task) => {
+  const guard2 = requireRunningAttempt(task);
+  if (!guard2.ok) return task;
+  const running = guard2.value.running;
+  if (running.warning?.kind !== "plateau") return task;
+  const { warning: _cleared, ...rest } = running;
+  void _cleared;
+  return replaceLastAttempt(task, rest);
+};
 var appendAttemptVerifyRun = (task, run) => {
   const guard2 = requireRunningAttempt(task);
   if (!guard2.ok) return Result.error(guard2.error);
@@ -15743,17 +15938,6 @@ var failCurrentAttempt = (task, now, reason, abortMeta) => {
   return Result.ok(inProgressNext);
 };
 var recordTaskEscalation = (task, fromModel, toModel) => {
-  if (task.escalatedFromModel !== void 0 || task.escalatedToModel !== void 0) {
-    return Result.error(
-      new InvalidStateError({
-        entity: "task",
-        currentState: "in_progress",
-        attemptedAction: "record-escalation",
-        message: `task '${task.id}' already escalated (${String(task.escalatedFromModel)} \u2192 ${String(task.escalatedToModel)})`,
-        hint: "The once-per-task cap blocks a second escalation; transition to blocked instead."
-      })
-    );
-  }
   const from = parseRequiredString("task.escalatedFromModel", fromModel);
   if (!from.ok) return Result.error(from.error);
   const to = parseRequiredString("task.escalatedToModel", toModel);
@@ -15762,35 +15946,33 @@ var recordTaskEscalation = (task, fromModel, toModel) => {
 };
 
 // src/business/task/escalation-policy.ts
+var triggerLabel = (trigger) => trigger === "plateau" ? "plateau" : "turn budget exhausted";
 var decideEscalation = (props) => {
   if (!props.flagOn) return { kind: "flag-off" };
-  if (props.task.escalatedFromModel !== void 0 && props.task.escalatedToModel !== void 0) {
-    return {
-      kind: "already-escalated",
-      from: props.task.escalatedFromModel,
-      to: props.task.escalatedToModel
-    };
-  }
-  if (props.task.maxAttempts !== void 0 && props.task.attempts.length >= props.task.maxAttempts) {
+  const effectiveMaxAttempts = props.task.maxAttempts ?? props.fallbackMaxAttempts;
+  if (props.task.attempts.length >= effectiveMaxAttempts) {
     return {
       kind: "budget-exhausted",
       attemptsUsed: props.task.attempts.length,
-      maxAttempts: props.task.maxAttempts
+      maxAttempts: effectiveMaxAttempts
     };
   }
-  const effective = mergeEscalationMap(props.userMap);
-  const to = effective[props.generatorModel];
-  if (to === void 0 || to === props.generatorModel) {
-    return { kind: "nudge", currentModel: props.generatorModel };
+  const merged = mergeEscalationMap(props.userMap);
+  const next = merged[props.generatorModel];
+  if (next !== void 0 && next !== props.generatorModel && !escalationLadderCyclicFrom(merged, props.generatorModel)) {
+    return { kind: "escalate", from: props.generatorModel, to: next };
   }
-  return { kind: "escalate", from: props.generatorModel, to };
+  const nudgedAtTop = props.task.escalatedFromModel !== void 0 && props.task.escalatedFromModel === props.task.escalatedToModel && props.task.escalatedToModel === props.generatorModel;
+  if (nudgedAtTop) return { kind: "topped-out", model: props.generatorModel };
+  return { kind: "nudge", currentModel: props.generatorModel };
 };
 var escalationBannerId = (taskId) => `model-escalation-${taskId}`;
 var applyEscalation = (props) => {
-  const { task, decision, eventBus, clock } = props;
+  const { task, decision, trigger, eventBus, clock } = props;
   const log = props.logger.named("task.escalation-policy");
   const bannerId = escalationBannerId(String(task.id));
   const now = clock();
+  const cause = triggerLabel(trigger);
   switch (decision.kind) {
     case "flag-off":
       return Result.ok({ task });
@@ -15803,7 +15985,7 @@ var applyEscalation = (props) => {
         attemptN: task.attempts.length,
         from: decision.from,
         to: decision.to,
-        reason: "plateau",
+        reason: trigger,
         at: now
       });
       eventBus.publish({
@@ -15811,7 +15993,7 @@ var applyEscalation = (props) => {
         id: bannerId,
         tier: "info",
         message: `escalated generator model: ${decision.from} \u2192 ${decision.to}`,
-        cause: "plateau",
+        cause,
         at: now
       });
       log.info(`escalating generator model: ${decision.from} \u2192 ${decision.to}`, {
@@ -15819,7 +16001,7 @@ var applyEscalation = (props) => {
         attemptN: task.attempts.length,
         from: decision.from,
         to: decision.to,
-        reason: "plateau"
+        reason: trigger
       });
       return Result.ok({ task: stamped.value });
     }
@@ -15830,46 +16012,49 @@ var applyEscalation = (props) => {
         type: "banner-show",
         id: bannerId,
         tier: "info",
-        message: `plateau on '${decision.currentModel}' (top of ladder) \u2014 retrying with a change-of-approach directive`,
-        cause: "plateau",
+        message: `${cause} on '${decision.currentModel}' (top of ladder) \u2014 retrying with a change-of-approach directive`,
+        cause,
         at: now
       });
-      log.info("plateau nudge: retrying on the same model with a change-of-approach directive", {
+      log.info("top-of-ladder nudge: retrying on the same model with a change-of-approach directive", {
         taskId: String(task.id),
-        currentModel: decision.currentModel
+        currentModel: decision.currentModel,
+        reason: trigger
       });
       return Result.ok({ task: stamped.value });
     }
-    case "already-escalated": {
-      const message = `plateau persists after the retry; keeping the work`;
+    case "topped-out": {
+      const message = `ladder exhausted on '${decision.model}' (${cause}); keeping the work`;
       eventBus.publish({
         type: "banner-show",
         id: bannerId,
         tier: "warn",
-        message: "plateau persists after retry \u2014 keeping the work",
+        message: "ladder exhausted \u2014 keeping the work",
+        cause,
         at: now
       });
       log.warn(message, {
         taskId: String(task.id),
-        from: decision.from,
-        to: decision.to
+        model: decision.model,
+        reason: trigger
       });
       return Result.ok({ task });
     }
     case "budget-exhausted": {
-      const message = `plateau with attempt budget exhausted (attempts=${String(decision.attemptsUsed)}, maxAttempts=${String(decision.maxAttempts)}); keeping the work`;
+      const message = `${cause} with attempt budget exhausted (attempts=${String(decision.attemptsUsed)}, maxAttempts=${String(decision.maxAttempts)}); keeping the work`;
       eventBus.publish({
         type: "banner-show",
         id: bannerId,
         tier: "warn",
-        message: "plateau, attempt budget exhausted \u2014 keeping the work",
+        message: `${cause}, attempt budget exhausted \u2014 keeping the work`,
         cause: `attempts=${String(decision.attemptsUsed)}/${String(decision.maxAttempts)}`,
         at: now
       });
       log.warn(message, {
         taskId: String(task.id),
         attemptsUsed: decision.attemptsUsed,
-        maxAttempts: decision.maxAttempts
+        maxAttempts: decision.maxAttempts,
+        reason: trigger
       });
       return Result.ok({ task });
     }
@@ -15886,7 +16071,7 @@ var mapExit = (exit) => {
     case "malformed":
       return { verdict: "malformed", warning: { kind: "malformed", detail: exit.detail } };
     case "plateau":
-      return { verdict: "failed", warning: { kind: "plateau", dimensions: exit.dimensions } };
+      return { verdict: "failed" };
     case "budget-exhausted":
       return {
         verdict: "failed",
@@ -15894,6 +16079,47 @@ var mapExit = (exit) => {
       };
   }
 };
+var isEscalatableExit = (exit) => exit.kind === "plateau" || exit.kind === "budget-exhausted";
+var resolveEscalatableRemedy = (exit, props, cfg) => {
+  const trigger = exit.kind;
+  const decision = decideEscalation({
+    task: props.task,
+    generatorModel: props.generatorModel,
+    flagOn: cfg.escalateOnPlateau,
+    userMap: cfg.escalationMap,
+    fallbackMaxAttempts: cfg.maxAttempts
+  });
+  const applied = applyEscalation({
+    task: props.task,
+    decision,
+    trigger,
+    eventBus: props.eventBus,
+    logger: props.logger,
+    clock: props.clock
+  });
+  if (!applied.ok) return Result.error(applied.error);
+  const shouldFailAttempt = decision.kind === "escalate" || decision.kind === "nudge";
+  return Result.ok({
+    task: applied.value.task,
+    ...applied.value.blockedReason !== void 0 ? { blockedReason: applied.value.blockedReason } : {},
+    shouldFailAttempt
+  });
+};
+var resolveMalformedRemedy = (props, cfg, log) => {
+  const effectiveMaxAttempts = props.task.maxAttempts ?? cfg.maxAttempts;
+  const budgetRemains = props.task.attempts.length < effectiveMaxAttempts;
+  const shouldFailAttempt = cfg.escalateOnPlateau && budgetRemains;
+  log.info(
+    shouldFailAttempt ? "malformed exit: retrying on the same model (no escalation)" : "malformed exit: keeping the work (done-with-warning)",
+    {
+      taskId: props.task.id,
+      attemptsUsed: props.task.attempts.length,
+      maxAttempts: effectiveMaxAttempts,
+      flagOn: cfg.escalateOnPlateau
+    }
+  );
+  return { task: props.task, shouldFailAttempt };
+};
 var finalizeGenEvalUseCase = async (props) => {
   const log = props.logger.named("task.finalize-gen-eval");
   const cfg = await props.readConfig();
@@ -15905,28 +16131,21 @@ var finalizeGenEvalUseCase = async (props) => {
   }
   log.debug(`finalizing gen-eval (${exit.kind})`, { taskId: props.task.id, exitKind: exit.kind });
   const mapped = mapExit(exit);
-  let taskForPersist = props.task;
-  let blockedReason = mapped.blockedReason;
-  let shouldFailAttempt = false;
-  if (exit.kind === "plateau") {
-    const decision = decideEscalation({
-      task: props.task,
-      generatorModel: props.generatorModel,
-      flagOn: cfg.escalateOnPlateau,
-      userMap: cfg.escalationMap
-    });
-    const applied = applyEscalation({
-      task: props.task,
-      decision,
-      eventBus: props.eventBus,
-      logger: props.logger,
-      clock: props.clock
-    });
-    if (!applied.ok) return Result.error(applied.error);
-    taskForPersist = applied.value.task;
-    if (applied.value.blockedReason !== void 0) blockedReason = applied.value.blockedReason;
-    if (decision.kind === "escalate" || decision.kind === "nudge") shouldFailAttempt = true;
-  }
+  let remedy = {
+    task: exit.kind === "passed" ? clearRunningAttemptPlateauWarning(props.task) : props.task,
+    ...mapped.blockedReason !== void 0 ? { blockedReason: mapped.blockedReason } : {},
+    shouldFailAttempt: false
+  };
+  if (isEscalatableExit(exit)) {
+    const resolved = resolveEscalatableRemedy(exit, props, cfg);
+    if (!resolved.ok) return Result.error(resolved.error);
+    remedy = resolved.value;
+  } else if (exit.kind === "malformed") {
+    remedy = resolveMalformedRemedy(props, cfg, log);
+  }
+  const taskForPersist = remedy.task;
+  const blockedReason = remedy.blockedReason ?? mapped.blockedReason;
+  const shouldFailAttempt = remedy.shouldFailAttempt;
   const persisted = await props.taskRepo.update(props.sprintId, taskForPersist);
   if (!persisted.ok) {
     log.error("persist failed", { taskId: taskForPersist.id, error: persisted.error.message });
@@ -16020,14 +16239,6 @@ var failedDimensions = (signal) => {
   }
   return names;
 };
-var setsEqual = (a, b) => {
-  if (a.size === 0 || b.size === 0) return false;
-  if (a.size !== b.size) return false;
-  for (const name of a) {
-    if (!b.has(name)) return false;
-  }
-  return true;
-};
 var trigrams = (text) => {
   const normalised = text.trim().toLowerCase().replace(/\s+/g, " ");
   if (normalised.length < 3) return /* @__PURE__ */ new Set([normalised]);
@@ -16050,27 +16261,71 @@ var trigramJaccard = (a, b) => {
   return intersection / union;
 };
 var CRITIQUE_SHIFT_SIMILARITY = 0.5;
+var WARNING_SOFTEN_CAP = 2;
+var countNeverDecreased = (turns) => {
+  let prev = -1;
+  for (const t of turns) {
+    const n = failedDimensions(t.evaluation).size;
+    if (prev !== -1 && n < prev) return false;
+    prev = n;
+  }
+  return true;
+};
+var trailingWarningStreak = (priorTurns) => {
+  let streak = 0;
+  for (let i = priorTurns.length - 1; i >= 0; i--) {
+    if (priorTurns[i]?.verdict === "warning") streak += 1;
+    else break;
+  }
+  return streak;
+};
+var critiqueShiftedFromAll = (window, current) => {
+  const currentCritique = current.critique;
+  if (currentCritique === void 0 || currentCritique.trim().length === 0) return false;
+  let maxSimilarity = 0;
+  let comparedAny = false;
+  for (const prior of window) {
+    const priorCritique = prior.critique;
+    if (priorCritique === void 0 || priorCritique.trim().length === 0) continue;
+    comparedAny = true;
+    const sim = trigramJaccard(priorCritique, currentCritique);
+    if (sim > maxSimilarity) maxSimilarity = sim;
+  }
+  return comparedAny && maxSimilarity < CRITIQUE_SHIFT_SIMILARITY;
+};
+var hasHash = (r) => r.changedFilesHash !== void 0 && r.changedFilesHash.length > 0;
+var workProductChanged = (window, current) => {
+  const anyPriorHash = window.some(hasHash);
+  if (hasHash(current)) {
+    let comparedAny = false;
+    for (const prior of window) {
+      if (!hasHash(prior)) continue;
+      comparedAny = true;
+      if (prior.changedFilesHash === current.changedFilesHash) return false;
+    }
+    return comparedAny;
+  }
+  if (anyPriorHash) {
+    return false;
+  }
+  const lastPrior = window[window.length - 1];
+  const priorSubject = lastPrior?.commitSubject;
+  const currentSubject = current.commitSubject;
+  return priorSubject !== void 0 && priorSubject.trim().length > 0 && currentSubject !== void 0 && currentSubject.trim().length > 0 && priorSubject.trim() !== currentSubject.trim();
+};
 var computePlateauVerdict = (priorTurns, current, options) => {
   const threshold = Math.max(2, Math.min(5, Math.trunc(options.threshold)));
   if (priorTurns.length < threshold - 1) return { kind: "none" };
   const window = priorTurns.slice(-(threshold - 1));
   const currentFailed = failedDimensions(current.evaluation);
   if (currentFailed.size === 0) return { kind: "none" };
-  for (const turn of window) {
-    if (!setsEqual(failedDimensions(turn.evaluation), currentFailed)) return { kind: "none" };
-  }
-  const lastPrior = window[window.length - 1];
-  if (lastPrior === void 0) return { kind: "none" };
-  const priorCritique = lastPrior.critique;
-  const currentCritique = current.critique;
-  if (priorCritique !== void 0 && priorCritique.trim().length > 0 && currentCritique !== void 0 && currentCritique.trim().length > 0 && trigramJaccard(priorCritique, currentCritique) < CRITIQUE_SHIFT_SIMILARITY) {
+  if (!countNeverDecreased([...window, current])) return { kind: "none" };
+  const dimensions = [...currentFailed];
+  if (critiqueShiftedFromAll(window, current)) {
     return { kind: "progress", reason: "critique-shifted" };
   }
-  const dimensions = [...currentFailed];
-  const priorSubject = lastPrior.commitSubject;
-  const currentSubject = current.commitSubject;
-  if (priorSubject !== void 0 && priorSubject.trim().length > 0 && currentSubject !== void 0 && currentSubject.trim().length > 0 && priorSubject.trim() !== currentSubject.trim()) {
-    return { kind: "warning", dimensions, reason: "commit-progress" };
+  if (workProductChanged(window, current) && trailingWarningStreak(priorTurns) < WARNING_SOFTEN_CAP) {
+    return { kind: "warning", dimensions, reason: "work-product-changed" };
   }
   return { kind: "plateau", dimensions };
 };
@@ -16080,6 +16335,12 @@ var isRecoverableTurnError = (err) => err.code !== ErrorCode.Aborted && err.code
 
 // src/business/task/run-evaluator-turn.ts
 var findEvaluation = (signals) => signals.find((s) => s.type === "evaluation");
+var resolveCritique = (evaluation) => {
+  const explicit = evaluation.critique;
+  if (explicit !== void 0 && explicit.trim().length > 0) return explicit;
+  const synthesized = evaluation.dimensions.filter((d) => !d.passed && d.finding.trim().length > 0).map((d) => `[${d.dimension}] ${d.finding.trim()}`).join("\n");
+  return synthesized.length > 0 ? synthesized : void 0;
+};
 var runEvaluatorTurnUseCase = async (props) => {
   const log = props.logger.named("task.evaluator-turn");
   log.debug("running evaluator turn", { taskId: props.task.id });
@@ -16130,17 +16391,19 @@ var runEvaluatorTurnUseCase = async (props) => {
       exit: { kind: "malformed", detail: "evaluator emitted dimension scores but no terminal verdict" }
     });
   }
-  const critique = evaluation.critique;
-  const currentRecord = {
+  const critique = resolveCritique(evaluation);
+  const baseRecord = {
     evaluation,
     ...critique !== void 0 && critique.trim().length > 0 ? { critique } : {},
-    ...props.currentCommitSubject !== void 0 && props.currentCommitSubject.trim().length > 0 ? { commitSubject: props.currentCommitSubject } : {}
+    ...props.currentCommitSubject !== void 0 && props.currentCommitSubject.trim().length > 0 ? { commitSubject: props.currentCommitSubject } : {},
+    ...props.changedFilesHash !== void 0 && props.changedFilesHash.length > 0 ? { changedFilesHash: props.changedFilesHash } : {}
   };
-  const verdict = computePlateauVerdict(props.priorTurns ?? [], currentRecord, {
+  const verdict = computePlateauVerdict(props.priorTurns ?? [], baseRecord, {
     threshold: props.plateauThreshold
   });
+  const currentRecord = { ...baseRecord, verdict: verdict.kind };
   if (verdict.kind === "plateau") {
-    log.warn("evaluator plateaued on the same failed dimensions", {
+    log.warn("evaluator plateaued \u2014 no net progress across the window", {
       taskId: recorded.value.id,
       dimensions: verdict.dimensions,
       threshold: props.plateauThreshold
@@ -16164,7 +16427,7 @@ var runEvaluatorTurnUseCase = async (props) => {
       });
       return Result.error(warned.error);
     }
-    log.info("plateau softened to warning \u2014 commit-message changed; continuing", {
+    log.info("plateau softened to warning \u2014 work product changed; continuing", {
       taskId: warned.value.id,
       dimensions: verdict.dimensions,
       reason: verdict.reason
@@ -16288,6 +16551,150 @@ var buildEvaluatePrompt = async (deps, input) => buildPrompt(deps, evaluatePromp
   priorProgress: input.priorProgress ?? ""
 });
 
+// src/integration/ai/prompts/evaluate-continuation/definition.ts
+var requireNonEmpty3 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var evaluateContinuationPromptDef = {
+  templateName: "evaluate-continuation",
+  description: "Resumed evaluator turn (round 2+ of a session thread). Carries only the per-round delta \u2014 round number, recent journal \u2014 because the specification and rubric are already in the conversation.",
+  parameters: {
+    roundNumber: {
+      placeholder: "ROUND_NUMBER",
+      description: "Current gen-eval round number rendered as a string.",
+      validate: requireNonEmpty3("roundNumber", "round number must not be empty")
+    },
+    contractPath: {
+      placeholder: "CONTRACT_PATH",
+      description: "Absolute path to the per-task contract.md sidecar \u2014 re-read hedge for a context-free resume.",
+      validate: requireNonEmpty3("contractPath", "contract path must not be empty")
+    },
+    progressFile: {
+      placeholder: "PROGRESS_FILE",
+      description: "Absolute path to the sprint progress.md journal \u2014 full history when the inline excerpt is short.",
+      validate: requireNonEmpty3("progressFile", "progress file path must not be empty")
+    },
+    priorProgress: {
+      placeholder: "PRIOR_PROGRESS",
+      description: "Capped recent slice of progress.md inlined into the prior-progress block \u2014 empty when none yet."
+    },
+    outputContractSection: {
+      placeholder: "OUTPUT_CONTRACT_SECTION",
+      description: "Audit-[09] output contract block rendered for THIS round's evaluator output directory \u2014 names the current signals.json path.",
+      validate: requireNonEmpty3(
+        "outputContractSection",
+        "output-contract section must not be empty (renderContractSectionFor always emits a body)"
+      )
+    }
+  },
+  partials: {
+    HARNESS_CONTEXT: "harness-context"
+  },
+  // Same single-signal contract as the full evaluate prompt — a continuation turn still emits
+  // exactly one `evaluation` verdict.
+  expectedSignals: ["evaluation"]
+};
+var buildEvaluateContinuationPrompt = async (deps, input) => buildPrompt(deps, evaluateContinuationPromptDef, {
+  roundNumber: String(input.roundNumber),
+  contractPath: input.contractPath,
+  progressFile: input.progressFile,
+  priorProgress: input.priorProgress,
+  outputContractSection: input.outputContractSection
+});
+
+// src/integration/ai/contract/_engine/corrective-retry.ts
+import { ZodError } from "zod";
+var isCorrectableContractError = (err) => err.code !== ErrorCode.Aborted && err.code !== ErrorCode.RateLimit && err.code !== ErrorCode.MigrationGap;
+var MAX_ENUMERATED_ISSUES = 10;
+var correctiveBody = (err, signalsPath, selfContainedContext) => {
+  const lines = [];
+  lines.push("Your previous `signals.json` did not satisfy the output contract, so the harness could");
+  lines.push("not read a verdict. Fix it now in ONE follow-up \u2014 re-read the output-contract section");
+  lines.push("below and re-write the file. Do not change anything else.");
+  lines.push("");
+  if (err instanceof ParseError && err.subCode === "schema-mismatch" && err.cause instanceof ZodError) {
+    lines.push("The shape failed schema validation. Each line below is one problem \u2014 fix every one:");
+    lines.push("");
+    const issues = err.cause.issues;
+    for (const issue of issues.slice(0, MAX_ENUMERATED_ISSUES)) {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+      lines.push(`- at \`${path}\`: ${issue.message}`);
+    }
+    if (issues.length > MAX_ENUMERATED_ISSUES) {
+      lines.push(
+        `- \u2026plus ${String(issues.length - MAX_ENUMERATED_ISSUES)} more of the same kinds \u2014 fix the pattern, not just the listed lines.`
+      );
+    }
+    lines.push("");
+    lines.push("Common cause: a terminal `evaluation` verdict (`passed` / `failed`) MUST grade all four");
+    lines.push("floor dimensions \u2014 correctness, completeness, safety, consistency \u2014 each with a finding.");
+  } else if (err instanceof ParseError && err.subCode === "invalid-json") {
+    lines.push(`The file at \`${signalsPath}\` existed but was not valid JSON. Re-write it as a single`);
+    lines.push("valid JSON object matching the `{ schemaVersion, signals }` shape. Check for trailing");
+    lines.push("commas, unescaped quotes inside string fields, and truncated output.");
+  } else {
+    lines.push(`You did not write \`${signalsPath}\`. Write that exact absolute path now with your`);
+    lines.push("`Write` tool, matching the `{ schemaVersion, signals }` shape from the contract above.");
+  }
+  lines.push("");
+  lines.push(`Write the corrected file to the exact absolute path \`${signalsPath}\` and stop.`);
+  lines.push("");
+  lines.push("If this session does not already hold the task context (fresh session), re-read the");
+  lines.push("referenced on-disk files before acting \u2014 do NOT invent a verdict or content from this");
+  lines.push("message alone.");
+  lines.push("");
+  lines.push(selfContainedContext);
+  return lines.join("\n");
+};
+var validateSignalsFileWithCorrectiveRetry = async (deps, contract) => {
+  const first = await validateSignalsFile(deps.outputDir, contract);
+  if (first.ok) return first;
+  const err = first.error;
+  if (!isCorrectableContractError(err)) return Result.error(err);
+  const log = deps.logger.named("ai.contract.corrective-retry");
+  const signalsPath = `${String(deps.outputDir)}/signals.json`;
+  log.warn("signals.json failed the contract \u2014 issuing one corrective retry", {
+    outputDir: String(deps.outputDir),
+    error: err.message
+  });
+  const corrective = correctiveBody(err, signalsPath, deps.selfContainedContext);
+  const respawn = await deps.reinvoke(corrective);
+  if (!respawn.ok) {
+    log.warn("corrective retry spawn failed \u2014 self-blocking on the spawn error", {
+      outputDir: String(deps.outputDir),
+      error: respawn.error.message
+    });
+    return Result.error(respawn.error);
+  }
+  const second = await validateSignalsFile(deps.outputDir, contract);
+  if (second.ok) {
+    log.info("corrective retry produced a valid signals.json", { outputDir: String(deps.outputDir) });
+    return second;
+  }
+  log.warn("corrective retry still failed the contract \u2014 self-blocking", {
+    outputDir: String(deps.outputDir),
+    error: second.error.message
+  });
+  return Result.error(second.error);
+};
+
+// src/application/flows/implement/leaves/work-product-fingerprint.ts
+import { createHash as createHash2 } from "crypto";
+var computeWorkProductFingerprint = async (gitRunner, cwd) => {
+  const status = await gitRunner.run(cwd, ["status", "--porcelain"]);
+  if (!status.ok || status.value.exitCode !== 0) return void 0;
+  const diff = await gitRunner.run(cwd, ["diff", "HEAD"]);
+  if (!diff.ok || diff.value.exitCode !== 0) return void 0;
+  const hash = createHash2("sha1").update(status.value.stdout).update("\0").update(diff.value.stdout);
+  const untracked = await gitRunner.run(cwd, ["ls-files", "--others", "--exclude-standard"]);
+  if (!untracked.ok || untracked.value.exitCode !== 0) return void 0;
+  const paths = untracked.value.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  if (paths.length > 0) {
+    const blobs = await gitRunner.run(cwd, ["hash-object", "--", ...paths]);
+    if (!blobs.ok || blobs.value.exitCode !== 0) return void 0;
+    hash.update("\0").update(blobs.value.stdout);
+  }
+  return hash.digest("hex");
+};
+
 // src/application/flows/implement/leaves/implement-session.ts
 import { dirname as dirname14 } from "path";
 
@@ -16336,6 +16743,11 @@ import { z as z33 } from "zod";
 
 // src/integration/ai/contract/_engine/signals/evaluation/schema.ts
 import { z as z32 } from "zod";
+
+// src/domain/signal.ts
+var FLOOR_DIMENSIONS = ["correctness", "completeness", "safety", "consistency"];
+
+// src/integration/ai/contract/_engine/signals/evaluation/schema.ts
 var dimensionScoreSchema = z32.object({
   dimension: z32.string(),
   passed: z32.boolean(),
@@ -16357,6 +16769,16 @@ var evaluationSignalSchema = z32.object({
   critique: z32.string().optional(),
   timestamp: IsoTimestampSchema
 }).superRefine((s, ctx) => {
+  if (s.status === "malformed") return;
+  const present = new Set(s.dimensions.map((d) => d.dimension.trim().toLowerCase()));
+  const missing = FLOOR_DIMENSIONS.filter((name) => !present.has(name));
+  if (missing.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: `status is "${s.status}" but the required floor dimension(s) ${missing.join(", ")} are missing \u2014 every terminal verdict must grade correctness, completeness, safety, and consistency`,
+      path: ["dimensions"]
+    });
+  }
   if (s.status === "passed") {
     const failedIndex = s.dimensions.findIndex((d) => !d.passed);
     if (failedIndex !== -1) {
@@ -16366,7 +16788,7 @@ var evaluationSignalSchema = z32.object({
         path: ["dimensions", failedIndex, "passed"]
       });
     }
-  } else if (s.status === "failed") {
+  } else {
     const anyFailed = s.dimensions.some((d) => !d.passed);
     if (!anyFailed) {
       ctx.addIssue({
@@ -16502,14 +16924,68 @@ var writeRoundPrompt = async (workspaceRoot, round, role, prompt, logger) => {
   }
 };
 
+// src/application/flows/implement/leaves/_shared/cap-progress.ts
+var RECENT_ATTEMPT_SECTIONS = 3;
+var ATTEMPT_DELIMITER = /^(?=## Task: )/m;
+var elisionNote = (droppedCount) => `_${String(droppedCount)} earlier attempt section${droppedCount === 1 ? "" : "s"} omitted from this inline excerpt \u2014 read the full \`progress.md\` on disk for the complete history._
+
+`;
+var capProgressBody = (body, recentSections = RECENT_ATTEMPT_SECTIONS, currentTaskName) => {
+  if (body.trim().length === 0) return "";
+  const pieces = body.split(ATTEMPT_DELIMITER);
+  if (pieces.length <= 1) return body;
+  const [header, ...sections] = pieces;
+  const isCurrentTask = (section) => currentTaskName !== void 0 && section.startsWith(`## Task: ${currentTaskName} \u2014 Attempt`);
+  const otherIndexes = sections.flatMap((s, i) => isCurrentTask(s) ? [] : [i]);
+  const keptOtherIndexes = new Set(otherIndexes.slice(Math.max(0, otherIndexes.length - recentSections)));
+  const keep = (i) => isCurrentTask(sections[i] ?? "") || keptOtherIndexes.has(i);
+  if (sections.every((_s, i) => keep(i))) return body;
+  const parts = [header ?? ""];
+  let droppedRun = 0;
+  for (let i = 0; i < sections.length; i += 1) {
+    if (keep(i)) {
+      if (droppedRun > 0) {
+        parts.push(elisionNote(droppedRun));
+        droppedRun = 0;
+      }
+      parts.push(sections[i] ?? "");
+    } else {
+      droppedRun += 1;
+    }
+  }
+  if (droppedRun > 0) parts.push(elisionNote(droppedRun));
+  return parts.join("");
+};
+
 // src/application/flows/implement/leaves/evaluator.ts
-var readProgressFile = async (path) => {
+var readCappedProgress = async (path, currentTaskName) => {
   try {
-    return await fs22.readFile(path, "utf8");
+    return capProgressBody(await fs22.readFile(path, "utf8"), RECENT_ATTEMPT_SECTIONS, currentTaskName);
   } catch {
     return "";
   }
 };
+var buildEvaluatorPrompt = async (deps, args) => {
+  const priorProgress = await readCappedProgress(String(deps.progressFile), args.task.name);
+  const contractPath = join30(String(args.workspaceRoot), "contract.md");
+  if (args.priorEvaluatorSessionId === void 0) {
+    return buildEvaluatePrompt(deps.templateLoader, {
+      task: args.task,
+      projectPath: String(deps.cwd),
+      contractPath,
+      outputContractSection: args.outputContractSection,
+      priorProgress,
+      ...deps.verifyScript !== void 0 ? { verifyScript: deps.verifyScript } : {}
+    });
+  }
+  return buildEvaluateContinuationPrompt(deps.templateLoader, {
+    roundNumber: args.roundNum,
+    contractPath,
+    progressFile: String(deps.progressFile),
+    priorProgress,
+    outputContractSection: args.outputContractSection
+  });
+};
 var evaluatorLeaf = (deps, taskId) => leaf(`evaluator-${String(taskId)}`, {
   useCase: {
     execute: async (input, signal) => {
@@ -16520,14 +16996,13 @@ var evaluatorLeaf = (deps, taskId) => leaf(`evaluator-${String(taskId)}`, {
       if (!outputDirPath.ok) return Result.error(outputDirPath.error);
       const outputDir = outputDirPath.value;
       const callEvaluate = async (task) => {
-        const priorProgress = await readProgressFile(String(deps.progressFile));
-        const prompt = await buildEvaluatePrompt(deps.templateLoader, {
+        const outputContractSection = renderContractSectionFor(evaluatorOutputContract, outputDir);
+        const prompt = await buildEvaluatorPrompt(deps, {
           task,
-          projectPath: String(deps.cwd),
-          contractPath: join30(String(input.workspaceRoot), "contract.md"),
-          outputContractSection: renderContractSectionFor(evaluatorOutputContract, outputDir),
-          priorProgress,
-          ...deps.verifyScript !== void 0 ? { verifyScript: deps.verifyScript } : {}
+          workspaceRoot: input.workspaceRoot,
+          roundNum: input.roundNum,
+          outputContractSection,
+          priorEvaluatorSessionId: input.priorEvaluatorSessionId
         });
         if (!prompt.ok) return Result.error(prompt.error);
         await writeRoundPrompt(input.workspaceRoot, input.roundNum, "evaluator", String(prompt.value), deps.logger);
@@ -16546,7 +17021,43 @@ var evaluatorLeaf = (deps, taskId) => leaf(`evaluator-${String(taskId)}`, {
           )
         );
         if (!spawn3.ok) return Result.error(spawn3.error);
-        const validated = await validateSignalsFile(outputDir, evaluatorOutputContract);
+        const validated = await validateSignalsFileWithCorrectiveRetry(
+          {
+            outputDir,
+            logger: deps.logger,
+            // Self-containment for a COLD corrective spawn (no resumable id / codex stale-resume
+            // fallback): the per-round output contract plus the reviewer's grounding — without
+            // this, a context-free retry's whole prompt is the error text, which is exactly
+            // enough scaffolding to fabricate a schema-valid verdict for unseen work.
+            selfContainedContext: [
+              `Task spec (read it): \`${join30(String(input.workspaceRoot), "contract.md")}\``,
+              "Your PRIMARY INPUT is the uncommitted working-tree diff \u2014 inspect it via shell",
+              "(`git status` / `git diff HEAD`) before grading. A verdict must reflect the actual",
+              "work, never this message.",
+              "",
+              outputContractSection
+            ].join("\n"),
+            reinvoke: async (corrective) => {
+              const resume = await readRoundSessionId(input.workspaceRoot, input.roundNum, "evaluator") ?? input.priorEvaluatorSessionId;
+              const respawn = await deps.provider.generate(
+                implementSession(
+                  input.workspaceRoot,
+                  deps.cwd,
+                  deps.sprintDir,
+                  corrective,
+                  deps.model,
+                  signalsFile,
+                  "evaluator",
+                  resume,
+                  deps.effort,
+                  signal
+                )
+              );
+              return respawn.ok ? Result.ok(void 0) : Result.error(respawn.error);
+            }
+          },
+          evaluatorOutputContract
+        );
         if (!validated.ok) return Result.error(validated.error);
         const signals = validated.value;
         for (const sig of signals) {
@@ -16556,11 +17067,13 @@ var evaluatorLeaf = (deps, taskId) => leaf(`evaluator-${String(taskId)}`, {
         await renderSidecars(deps.writeFile, outputDir, signals, evaluatorOutputContract.sidecars, deps.logger);
         return Result.ok(signals);
       };
+      const changedFilesHash = await computeWorkProductFingerprint(deps.gitRunner, deps.cwd);
       const result = await runEvaluatorTurnUseCase({
         task: input.task,
         priorTurns: input.priorTurns,
         plateauThreshold: deps.plateauThreshold,
         ...input.currentCommitSubject !== void 0 ? { currentCommitSubject: input.currentCommitSubject } : {},
+        ...changedFilesHash !== void 0 ? { changedFilesHash } : {},
         callEvaluate,
         evaluationFile: roundEvaluationRelativePath(input.roundNum),
         logger: deps.logger
@@ -16685,14 +17198,112 @@ var runGeneratorTurnUseCase = async (props) => {
   });
 };
 
+// src/integration/ai/prompts/implement-continuation/definition.ts
+var requireNonEmpty4 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var implementContinuationPromptDef = {
+  templateName: "implement-continuation",
+  description: "Resumed generator turn (round 2+ of a session thread). Carries only the per-round delta \u2014 critique, round number, plateau directive \u2014 because the full brief is already in the conversation.",
+  parameters: {
+    roundNumber: {
+      placeholder: "ROUND_NUMBER",
+      description: "Current gen-eval round number rendered as a string.",
+      validate: requireNonEmpty4("roundNumber", "round number must not be empty")
+    },
+    contractPath: {
+      placeholder: "CONTRACT_PATH",
+      description: "Absolute path to the per-task contract.md sidecar \u2014 re-read hedge for a context-free resume.",
+      validate: requireNonEmpty4("contractPath", "contract path must not be empty")
+    },
+    progressFile: {
+      placeholder: "PROGRESS_FILE",
+      description: "Absolute path to the sprint progress.md journal \u2014 full history when the inline excerpt is short.",
+      validate: requireNonEmpty4("progressFile", "progress file path must not be empty")
+    },
+    priorProgress: {
+      placeholder: "PRIOR_PROGRESS",
+      description: "Capped recent slice of progress.md inlined into the prior-progress block \u2014 empty when none yet."
+    },
+    priorCritiqueSection: {
+      placeholder: "PRIOR_CRITIQUE_SECTION",
+      description: `"## Prior Critique" markdown block \u2014 the prior round's failed evaluator critique, verbatim.`
+    },
+    plateauDirectiveSection: {
+      placeholder: "PLATEAU_DIRECTIVE_SECTION",
+      description: '"## \u26A0 You have plateaued \u2014 change your approach" block \u2014 empty unless this round is a plateau-break attempt.'
+    },
+    outputContractSection: {
+      placeholder: "OUTPUT_CONTRACT_SECTION",
+      description: "Audit-[09] output contract block rendered for THIS round's output directory \u2014 names the current signals.json path.",
+      validate: requireNonEmpty4(
+        "outputContractSection",
+        "output-contract section must not be empty (renderContractSectionFor always emits a body)"
+      )
+    }
+  },
+  partials: {
+    HARNESS_CONTEXT: "harness-context"
+  },
+  // Same accepted signal union as the full implement prompt — a continuation turn is still a
+  // generator turn and may emit the full narrative + lifecycle set.
+  expectedSignals: [
+    "change",
+    "decision",
+    "learning",
+    "note",
+    "task-verified",
+    "task-complete",
+    "task-blocked",
+    "commit-message"
+  ]
+};
+var buildImplementContinuationPrompt = async (deps, input) => buildPrompt(deps, implementContinuationPromptDef, {
+  roundNumber: String(input.roundNumber),
+  contractPath: input.contractPath,
+  progressFile: input.progressFile,
+  priorProgress: input.priorProgress,
+  priorCritiqueSection: renderPriorCritiqueSection(input.priorCritique),
+  plateauDirectiveSection: renderPlateauDirectiveSection(input.plateauBreak ?? false),
+  outputContractSection: input.outputContractSection
+});
+
 // src/application/flows/implement/leaves/generator.ts
-var readProgressFile2 = async (path) => {
+var readCappedProgress2 = async (path, currentTaskName) => {
   try {
-    return await fs23.readFile(path, "utf8");
+    return capProgressBody(await fs23.readFile(path, "utf8"), RECENT_ATTEMPT_SECTIONS, currentTaskName);
   } catch {
     return "";
   }
 };
+var buildGeneratorPrompt = async (deps, args) => {
+  const priorCritique = latestCritique(args.task);
+  const priorProgress = await readCappedProgress2(String(deps.progressFile), args.task.name);
+  const contractPath = join31(String(args.workspaceRoot), "contract.md");
+  const lastSettled = [...args.task.attempts].reverse().find((a) => a.status !== "running");
+  const stallDriven = lastSettled?.warning?.kind === "plateau" || lastSettled?.warning?.kind === "budget-exhausted";
+  const plateauBreak = args.task.escalatedFromModel !== void 0 && args.task.escalatedFromModel === args.task.escalatedToModel && stallDriven;
+  if (args.priorGeneratorSessionId === void 0) {
+    return buildImplementPrompt(deps.templateLoader, {
+      task: args.task,
+      projectPath: String(deps.cwd),
+      contractPath,
+      progressFile: String(deps.progressFile),
+      priorProgress,
+      outputContractSection: args.outputContractSection,
+      ...deps.verifyScript !== void 0 ? { verifyScript: deps.verifyScript } : {},
+      ...priorCritique !== void 0 ? { priorCritique } : {},
+      ...plateauBreak ? { plateauBreak: true } : {}
+    });
+  }
+  return buildImplementContinuationPrompt(deps.templateLoader, {
+    roundNumber: args.roundNum,
+    contractPath,
+    progressFile: String(deps.progressFile),
+    priorProgress,
+    outputContractSection: args.outputContractSection,
+    ...priorCritique !== void 0 ? { priorCritique } : {},
+    ...plateauBreak ? { plateauBreak: true } : {}
+  });
+};
 var generatorLeaf = (deps, taskId) => leaf(`generator-${String(taskId)}`, {
   useCase: {
     execute: async (input, signal) => {
@@ -16727,21 +17338,13 @@ var generatorLeaf = (deps, taskId) => leaf(`generator-${String(taskId)}`, {
       const learningsEmitted = [];
       const notesEmitted = [];
       const callImplement = async (task) => {
-        const priorCritique = latestCritique(task);
-        const priorProgress = await readProgressFile2(String(deps.progressFile));
-        const prompt = await buildImplementPrompt(deps.templateLoader, {
+        const outputContractSection = renderContractSectionFor(generatorOutputContract, outputDir);
+        const prompt = await buildGeneratorPrompt(deps, {
           task,
-          projectPath: String(deps.cwd),
-          contractPath: join31(String(input.workspaceRoot), "contract.md"),
-          progressFile: String(deps.progressFile),
-          priorProgress,
-          outputContractSection: renderContractSectionFor(generatorOutputContract, outputDir),
-          ...deps.verifyScript !== void 0 ? { verifyScript: deps.verifyScript } : {},
-          ...priorCritique !== void 0 ? { priorCritique } : {},
-          // Plateau-break attempt: the escalation policy stamped the task (model bump and/or a
-          // change-of-approach nudge) after the gen-eval loop stalled. Surface the "change your
-          // approach" directive so the generator abandons the non-converging path.
-          ...task.escalatedFromModel !== void 0 ? { plateauBreak: true } : {}
+          workspaceRoot: input.workspaceRoot,
+          roundNum,
+          outputContractSection,
+          priorGeneratorSessionId: input.priorGeneratorSessionId
         });
         if (!prompt.ok) return Result.error(prompt.error);
         await writeRoundPrompt(input.workspaceRoot, roundNum, "generator", String(prompt.value), deps.logger);
@@ -16761,7 +17364,39 @@ var generatorLeaf = (deps, taskId) => leaf(`generator-${String(taskId)}`, {
           )
         );
         if (!spawn3.ok) return Result.error(spawn3.error);
-        const validated = await validateSignalsFile(outputDir, generatorOutputContract);
+        const validated = await validateSignalsFileWithCorrectiveRetry(
+          {
+            outputDir,
+            logger: deps.logger,
+            // Self-containment for a COLD corrective spawn (no resumable id / codex stale-resume
+            // fallback): the per-round output contract + the on-disk task spec, so a fresh
+            // session re-reads its grounding instead of emitting signals from the error text.
+            selfContainedContext: [
+              `Task spec (read it): \`${join31(String(input.workspaceRoot), "contract.md")}\``,
+              "",
+              outputContractSection
+            ].join("\n"),
+            reinvoke: async (corrective) => {
+              const resume = await readRoundSessionId(input.workspaceRoot, roundNum, "generator") ?? input.priorGeneratorSessionId;
+              const respawn = await deps.provider.generate(
+                implementSession(
+                  input.workspaceRoot,
+                  deps.cwd,
+                  deps.sprintDir,
+                  corrective,
+                  effectiveModel,
+                  signalsFile,
+                  "generator",
+                  resume,
+                  deps.effort,
+                  signal
+                )
+              );
+              return respawn.ok ? Result.ok(void 0) : Result.error(respawn.error);
+            }
+          },
+          generatorOutputContract
+        );
         if (!validated.ok) return Result.error(validated.error);
         const signals = validated.value;
         for (const sig of signals) {
@@ -17076,6 +17711,9 @@ var createGenEvalLoop = (deps, opts, taskId) => {
   };
   const evaluatorLeafDeps = {
     ...sharedLeafDeps,
+    // Evaluator-only: the work-product fingerprint for the plateau predicate. The generator
+    // leaf neither needs nor accepts the git runner.
+    gitRunner: deps.gitRunner,
     provider: deps.evaluatorProvider,
     model: opts.evaluator.model,
     ...opts.evaluator.effort !== void 0 ? { effort: opts.evaluator.effort } : {}
@@ -17130,9 +17768,16 @@ var createGenEvalLoop = (deps, opts, taskId) => {
       )
     ]),
     {
-      shouldContinue: async (_ctx, i) => {
+      // Loop-entry guard. Refuse to enter a turn when a terminal exit is ALREADY on ctx — the
+      // only way `lastExit` is set at loop entry is a pre-task-verify block/skip (start-attempt
+      // runs before pre-verify and settle-attempt clears `lastExit` at the end of every attempt,
+      // so no stale exit can leak across attempts/tasks; the parallel merge-wave classifies
+      // `lastExit` PER_TASK). Without this check a pre-blocked task would still claim a
+      // `rounds/<N>/` dir, stamp two meta sidecars, and spawn one full generator session on the
+      // exact broken tree the gate refused — the most expensive unit in the system.
+      shouldContinue: async (ctx, i) => {
         const cfg = await deps.readConfig();
-        return i <= Math.max(1, cfg.maxTurns);
+        return ctx.lastExit === void 0 && i <= Math.max(1, cfg.maxTurns);
       },
       shouldStop: (ctx) => ctx.lastExit !== void 0
     }
@@ -17484,6 +18129,17 @@ var legacyVerifyResult = (run, rawOutput, spawnErrorMessage) => {
 var postTaskVerifyLeaf = (deps, opts, taskId) => leaf(`post-task-verify-${String(taskId)}`, {
   useCase: {
     execute: async (input, signal) => {
+      if (input.preVerifyBlockedZeroTurn) {
+        const skipped = {
+          phase: "post",
+          ranAt: deps.clock(),
+          command: "",
+          exitCode: 0,
+          durationMs: 0,
+          outcome: "skipped"
+        };
+        return Result.ok({ task: input.task, run: skipped, rawOutput: "" });
+      }
       const { run, rawOutput, spawnErrorMessage } = await runVerifyScriptUseCase({
         cwd: opts.cwd,
         phase: "post",
@@ -17599,9 +18255,11 @@ var postTaskVerifyLeaf = (deps, opts, taskId) => leaf(`post-task-verify-${String
         message: `post-task-verify-${String(taskId)}: expected in_progress task \u2014 got '${ctx.currentTask.status}'`
       });
     }
+    const preVerifyBlockedZeroTurn = ctx.lastBlockReason !== void 0 && ctx.genEvalTurn === void 0;
     return {
       task: ctx.currentTask,
       sprintId: ctx.sprintId,
+      preVerifyBlockedZeroTurn,
       ...ctx.lastPreVerifyOutcome !== void 0 ? { preOutcome: ctx.lastPreVerifyOutcome } : {}
     };
   },
@@ -17627,6 +18285,148 @@ var postTaskVerifyLeaf = (deps, opts, taskId) => leaf(`post-task-verify-${String
   }
 });
 
+// src/business/task/record-quarantine.ts
+var QUARANTINE_LINE_PREFIX = "Rejected diff quarantined to git stash";
+var buildReason = (current, stashMessage) => {
+  const line = `${QUARANTINE_LINE_PREFIX} (recover via \`git stash list\`): ${stashMessage}`;
+  if (current.includes(line)) return current;
+  return `${current}
+${line}`;
+};
+var recordQuarantineUseCase = async (props) => {
+  const log = props.logger.named("task.record-quarantine");
+  if (props.task.status !== "blocked") {
+    return Result.error(
+      new InvalidStateError({
+        entity: "task",
+        currentState: props.task.status,
+        attemptedAction: "record-quarantine",
+        message: `record-quarantine: expected a blocked task \u2014 got '${props.task.status}'`
+      })
+    );
+  }
+  const nextReason = buildReason(props.task.blockedReason, props.stashMessage);
+  if (nextReason === props.task.blockedReason) {
+    log.debug("quarantine pointer already recorded; skipping re-write", {
+      taskId: props.task.id,
+      sprintId: props.sprintId
+    });
+    return Result.ok(props.task);
+  }
+  const updated = { ...props.task, blockedReason: nextReason };
+  const persisted = await props.taskRepo.update(props.sprintId, updated);
+  if (!persisted.ok) {
+    log.error("persist failed", { taskId: updated.id, error: persisted.error.message });
+    return Result.error(persisted.error);
+  }
+  log.info("recorded quarantine pointer on blocked task", {
+    taskId: updated.id,
+    sprintId: props.sprintId,
+    stashMessage: props.stashMessage
+  });
+  return Result.ok(updated);
+};
+
+// src/application/flows/implement/leaves/quarantine-blocked-diff.ts
+var quarantineStashMessage = (sprintId, taskId) => `ralphctl/${String(sprintId)}/${String(taskId)}/blocked-diff`;
+var quarantineBlockedDiffLeaf = (deps, opts, taskId) => leaf(`quarantine-blocked-diff-${String(taskId)}`, {
+  useCase: {
+    execute: async (input) => {
+      const log = deps.logger.named("task.quarantine-blocked-diff");
+      const message = quarantineStashMessage(input.sprintId, taskId);
+      const stashed = await gitStashPush(deps.gitRunner, opts.cwd, message);
+      if (!stashed.ok) {
+        log.warn("quarantine stash failed \u2014 proceeding without cleaning the tree", {
+          taskId: String(taskId),
+          cwd: String(opts.cwd),
+          error: stashed.error.message
+        });
+        return Result.ok(void 0);
+      }
+      if (!stashed.value.stashed) return Result.ok(void 0);
+      const recorded = await recordQuarantineUseCase({
+        task: input.task,
+        sprintId: input.sprintId,
+        stashMessage: message,
+        taskRepo: deps.taskRepo,
+        logger: deps.logger
+      });
+      if (!recorded.ok) {
+        log.warn("quarantine stash succeeded but recording the pointer failed", {
+          taskId: String(taskId),
+          stashMessage: message,
+          error: recorded.error.message
+        });
+        return Result.ok(void 0);
+      }
+      const journalLine = `
+_Task ${recorded.value.name}: rejected diff quarantined to git stash \u2014 recover via \`git stash list\` (message: \`${message}\`)._
+`;
+      const appended = await deps.appendFile(opts.progressFile, journalLine);
+      if (!appended.ok) {
+        log.warn("quarantine pointer journal append failed", {
+          taskId: String(taskId),
+          error: appended.error.message
+        });
+      }
+      return Result.ok(recorded.value);
+    }
+  },
+  input: (ctx) => {
+    const task = ctx.tasks?.find((t) => t.id === taskId);
+    if (task === void 0 || task.status !== "blocked") {
+      throw new InvalidStateError({
+        entity: "chain",
+        currentState: task === void 0 ? "missing" : task.status,
+        attemptedAction: `quarantine-blocked-diff-${String(taskId)}`,
+        message: `quarantine-blocked-diff-${String(taskId)}: expected a settled blocked task on ctx.tasks`
+      });
+    }
+    return { task, sprintId: ctx.sprintId };
+  },
+  output: (ctx, out) => {
+    if (out === void 0) return ctx;
+    return {
+      ...ctx,
+      tasks: (ctx.tasks ?? []).map((t) => t.id === out.id ? out : t)
+    };
+  }
+});
+var isSettledBlocked = (ctx, taskId) => ctx.tasks?.find((t) => t.id === taskId)?.status === "blocked" && ctx.genEvalTurn !== void 0;
+
+// src/application/flows/implement/leaves/quarantine-retry-diff.ts
+var retryStashMessage = (sprintId, taskId, attemptN) => `ralphctl/${String(sprintId)}/${String(taskId)}/attempt-${String(attemptN)}-rejected-diff`;
+var quarantineRetryDiffLeaf = (deps, opts, taskId) => leaf(`quarantine-retry-diff-${String(taskId)}`, {
+  useCase: {
+    execute: async (input) => {
+      const log = deps.logger.named("task.quarantine-retry-diff");
+      const message = retryStashMessage(input.sprintId, taskId, input.attemptN);
+      const stashed = await gitStashPush(deps.gitRunner, opts.cwd, message);
+      if (!stashed.ok) {
+        log.warn("retry-diff stash failed \u2014 the retried attempt will see the red tree", {
+          taskId: String(taskId),
+          cwd: String(opts.cwd),
+          error: stashed.error.message
+        });
+        return Result.ok(void 0);
+      }
+      if (stashed.value.stashed) {
+        log.info("rejected red diff quarantined before retry", {
+          taskId: String(taskId),
+          stashMessage: message
+        });
+      }
+      return Result.ok(void 0);
+    }
+  },
+  input: (ctx) => ({
+    sprintId: ctx.sprintId,
+    attemptN: ctx.currentTask?.attempts.length ?? 0
+  }),
+  output: (ctx) => ctx
+});
+var isRedVerifyRetry = (ctx) => ctx.lastShouldFailAttempt === true && ctx.lastBlockReason !== void 0;
+
 // src/application/flows/implement/leaves/progress-journal.ts
 var dedupeTexts = (texts) => {
   if (texts === void 0 || texts.length === 0) return [];
@@ -17646,14 +18446,43 @@ var renderOutcomeParagraph = (task, attempt) => {
     return task.blockedReason.trim().length > 0 ? `Blocked: ${task.blockedReason.trim()}` : "Blocked \u2014 no reason recorded.";
   }
   if (task.status === "done") {
+    if (attempt?.evaluation?.status === "passed") {
+      return attempt.warning !== void 0 ? "Task settled as done with a warning attached." : "Task completed successfully.";
+    }
     const critique = attempt?.critique?.trim();
     if (critique !== void 0 && critique.length > 0) {
       return critique;
     }
-    return "Task completed successfully.";
+    return attempt?.warning !== void 0 ? "Task settled as done with a warning attached." : "Task completed successfully.";
+  }
+  if (task.status === "in_progress") {
+    const critique = attempt?.critique?.trim();
+    return critique !== void 0 && critique.length > 0 ? `Attempt did not pass; the harness is retrying. ${critique}` : "Attempt did not pass; the harness is retrying.";
   }
   return `Settled with task status \`${task.status}\`.`;
 };
+var deriveVerdict = (task, attempt) => {
+  if (task.status === "blocked") return "blocked";
+  if (task.status === "in_progress") return "escalated";
+  if (task.status === "done" && attempt?.warning !== void 0) return "pass-with-warning";
+  return "pass";
+};
+var toJournalWarning = (warning) => {
+  switch (warning.kind) {
+    case "budget-exhausted":
+      return { kind: "budget-exhausted", turnsUsed: warning.turnsUsed, turnBudget: warning.turnBudget };
+    case "plateau":
+      return { kind: "plateau", dimensions: warning.dimensions };
+    case "malformed":
+      return { kind: "malformed", detail: warning.detail };
+    case "verify-failed": {
+      const exit = warning.exitCode !== null ? `exit ${String(warning.exitCode)}` : "no exit code";
+      const detail = warning.stderr.trim().length > 0 ? `${exit} \u2014 ${warning.stderr.trim()}` : exit;
+      return { kind: "verify-failed", detail };
+    }
+  }
+};
+var toJournalEscalation = (task) => task.escalatedFromModel !== void 0 && task.escalatedToModel !== void 0 ? { from: task.escalatedFromModel, to: task.escalatedToModel } : void 0;
 var latestAttempt = (task) => task.attempts[task.attempts.length - 1];
 var attemptDurationMs = (attempt) => {
   if (attempt === void 0 || attempt.status === "running") return void 0;
@@ -17663,7 +18492,9 @@ var progressJournalLeaf = (deps, opts, taskId) => leaf(`progress-journal-${Strin
   useCase: {
     execute: async (input) => {
       const attempt = latestAttempt(input.task);
-      const verdict = input.task.status === "blocked" ? "blocked" : "pass";
+      const verdict = deriveVerdict(input.task, attempt);
+      const warning = attempt?.warning !== void 0 ? toJournalWarning(attempt.warning) : void 0;
+      const escalation = (verdict === "escalated" || verdict === "pass-with-warning") && attempt?.warning?.kind !== "malformed" ? toJournalEscalation(input.task) : void 0;
       const text = renderJournalEntry({
         taskName: input.task.name,
         attemptN: input.task.attempts.length,
@@ -17672,6 +18503,8 @@ var progressJournalLeaf = (deps, opts, taskId) => leaf(`progress-journal-${Strin
         roundN: input.roundN,
         totalRounds: opts.totalRounds,
         ...attemptDurationMs(attempt) !== void 0 ? { durationMs: attemptDurationMs(attempt) } : {},
+        ...warning !== void 0 ? { warning } : {},
+        ...escalation !== void 0 ? { escalation } : {},
         changes: input.changes,
         decisions: input.decisions,
         learnings: input.learnings,
@@ -17732,6 +18565,9 @@ var settleTask = (props, now) => {
     if (!stamped.ok) return Result.error(stamped.error);
     task = stamped.value;
   }
+  if (props.shouldFailAttempt === true) {
+    return failCurrentAttempt(task, now, props.verdict === "malformed" ? "malformed" : "failed");
+  }
   if (props.blockedReason !== void 0) {
     const aborted = failCurrentAttempt(task, now, "aborted");
     if (!aborted.ok) return Result.error(aborted.error);
@@ -17740,9 +18576,6 @@ var settleTask = (props, now) => {
     }
     return markTaskBlocked(aborted.value, props.blockedReason, "own");
   }
-  if (props.shouldFailAttempt === true) {
-    return failCurrentAttempt(task, now, "failed");
-  }
   return markTaskDone(task, now);
 };
 var settleAttemptUseCase = async (props) => {
@@ -18262,6 +19095,7 @@ var createPerTaskSubchain = (deps, opts, task, repo, readConfig) => {
                 templateLoader: deps.templateLoader,
                 signals: deps.signals,
                 writeFile: deps.writeFile,
+                gitRunner: deps.gitRunner,
                 clock: deps.clock,
                 logger: deps.logger,
                 eventBus: deps.eventBus,
@@ -18325,6 +19159,17 @@ var createPerTaskSubchain = (deps, opts, task, repo, readConfig) => {
                 taskId
               )
             ),
+            // Composed-case cleanup: a granted retry (escalate / nudge / malformed) whose work ALSO
+            // failed post-verify red. The commit guard above skipped the red work; this stashes it
+            // so the RETRIED attempt's pre-verify starts from the last good commit instead of
+            // hard-blocking on its own predecessor's rejected diff. Must run BEFORE settle-attempt —
+            // settle's output projection clears both flags the guard reads. Green-verify retries
+            // commit normally and the stash no-ops on their clean tree.
+            guard(
+              `quarantine-retry-diff-guard-${String(taskId)}`,
+              isRedVerifyRetry,
+              quarantineRetryDiffLeaf({ gitRunner: deps.gitRunner, logger: deps.logger }, { cwd: repo.path }, taskId)
+            ),
             settleAttemptLeaf(
               { taskRepo: deps.taskRepo, clock: deps.clock, logger: deps.logger, gitRunner: deps.gitRunner },
               { cwd: repo.path },
@@ -18349,15 +19194,46 @@ var createPerTaskSubchain = (deps, opts, task, repo, readConfig) => {
             )
           ]),
           {
-            // The attempt count is bounded by the task's own `maxAttempts` (validated 1–10). When
-            // unset, the `loop` primitive's 1000 ceiling is the backstop and `shouldStop` (terminal
-            // status) is the real bound. The domain's `failCurrentAttempt` still transitions the
-            // task to `blocked` once attempts hit the cap, so a budget-exhausted task is never
-            // silently dropped — `shouldStop` just recognises that terminal status and exits.
-            ...task.maxAttempts !== void 0 ? { maxIterations: task.maxAttempts } : {},
+            // The attempt count is bounded by the task's own `maxAttempts` (validated 1–10), or the
+            // configured `settings.harness.maxAttempts` fallback for legacy tasks planned before the
+            // field existed (mirrors the budget fallback in `finalize-gen-eval`/`decideEscalation`,
+            // so a legacy task's loop cap and its escalation budget agree). The domain's
+            // `failCurrentAttempt` still transitions the task to `blocked` once attempts hit the
+            // cap, so a budget-exhausted task is never silently dropped — `shouldStop` just
+            // recognises that terminal status and exits.
+            maxIterations: task.maxAttempts ?? deps.config.harness.maxAttempts,
             shouldStop: (ctx) => terminalTaskStatus(ctx, taskId)
           }
         ),
+        // SERIAL-PATH ONLY. A task that settled `blocked` (self-block / budget-exhausted) leaves its
+        // rejected diff in the SHARED worktree — `settle-attempt`'s dirty-tree guardrail exempts the
+        // block path so the operator can inspect it. On the serial path that contaminates the next
+        // task (its `git add -A` sweeps the leftovers into its commit; the dirt flips its pre-verify
+        // red and the red post-verify is mis-attributed `baseline-broken`, landing a corrupt commit).
+        // This guarded leaf stashes the rejected diff so the tree is clean again before the next task
+        // runs, restoring the invariant the prologue's one-shot preflight assumes. The guard is
+        // synchronous (status === 'blocked' read from the settled `ctx.tasks` copy — `settle-attempt`
+        // cleared `ctx.currentTask`); the splice itself is gated on the serial-path proxy
+        // `includeBranchPreflight` so the parallel launcher (per-task worktrees, already isolated)
+        // never includes it. Stays INSIDE the body guard + AFTER the loop so it runs once per task,
+        // and BEFORE `uninstall-skills` so that leaf remains the subchain's terminal element (the
+        // TUI's task-completion detector keys on it).
+        ...includeBranchPreflight ? [
+          guard(
+            `quarantine-blocked-diff-guard-${String(taskId)}`,
+            (ctx) => isSettledBlocked(ctx, taskId),
+            quarantineBlockedDiffLeaf(
+              {
+                gitRunner: deps.gitRunner,
+                taskRepo: deps.taskRepo,
+                appendFile: deps.appendFile,
+                logger: deps.logger
+              },
+              { cwd: repo.path, progressFile: opts.progressFile },
+              taskId
+            )
+          )
+        ] : [],
         uninstallSkillsLeaf(
           { skillsAdapter: deps.skillsAdapter },
           { name: `${opts.terminalLeafName}-${String(taskId)}`, cwdPicker: repoCwdPicker(repo.path) }
@@ -19060,10 +19936,10 @@ var transitionSprintToReviewLeaf = (deps) => leaf("transition-sprint-to-review",
 var combineAbortSignals = (host, secondary) => host === void 0 ? secondary : AbortSignal.any([host, secondary]);
 
 // src/integration/io/lock-paths.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { join as join37 } from "path";
 var repoLockFile = (locksRoot, worktreePath) => {
-  const hash = createHash2("sha1").update(String(worktreePath)).digest("hex").slice(0, 16);
+  const hash = createHash3("sha1").update(String(worktreePath)).digest("hex").slice(0, 16);
   return AbsolutePath.parse(join37(String(locksRoot), `repo-${hash}.lock`));
 };
 
@@ -19218,7 +20094,8 @@ var createImplementFlow = (deps, opts) => {
   const readConfig = () => Promise.resolve({
     maxTurns: deps.config.harness.maxTurns,
     escalateOnPlateau: deps.config.harness.escalateOnPlateau,
-    escalationMap: deps.config.harness.escalationMap
+    escalationMap: deps.config.harness.escalationMap,
+    maxAttempts: deps.config.harness.maxAttempts
   });
   const perTaskChains = opts.todoTasks.map(
     (task) => createPerTaskSubchain(
@@ -19372,7 +20249,11 @@ var runWorktreeSetupScript = async (deps, worktreePath, setupScript, taskId, ctx
   const name = `worktree-setup-script-${String(taskId)}`;
   if (signal?.aborted) return abortedStep(name, 0, onTrace);
   const start = performance.now();
-  const ran = await deps.implement.shellScriptRunner.run(worktreePath, setupScript);
+  const ran = await deps.implement.shellScriptRunner.run(
+    worktreePath,
+    setupScript,
+    signal !== void 0 ? { signal } : {}
+  );
   const durationMs = performance.now() - start;
   if (ran.ok && ran.value.passed) {
     onTrace?.({ elementName: name, status: "completed", durationMs });
@@ -19811,7 +20692,8 @@ var buildParallelElement = (implementDeps, implementOpts, appSignals, maxParalle
   const readConfig = () => Promise.resolve({
     maxTurns: implementDeps.config.harness.maxTurns,
     escalateOnPlateau: implementDeps.config.harness.escalateOnPlateau,
-    escalationMap: implementDeps.config.harness.escalationMap
+    escalationMap: implementDeps.config.harness.escalationMap,
+    maxAttempts: implementDeps.config.harness.maxAttempts
   });
   const parallelDeps = { ...implementDeps, appendFile: serializeAppendFile(implementDeps.appendFile) };
   const branchDeps = {
@@ -20179,7 +21061,7 @@ var runReviewRoundUseCase = async (props) => {
 };
 
 // src/integration/ai/prompts/apply-feedback/definition.ts
-var requireNonEmpty3 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var requireNonEmpty5 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
 var applyFeedbackPromptDef = {
   templateName: "apply-feedback",
   description: "Apply one round of human feedback to an already-implemented sprint. Review-time work, not initial implementation.",
@@ -20187,12 +21069,12 @@ var applyFeedbackPromptDef = {
     repositories: {
       placeholder: "REPOSITORIES",
       description: "Markdown list of every sprint-affected repository (absolute path + display name). The AI picks which to touch based on the latest round.",
-      validate: requireNonEmpty3("repositories", "repositories block must not be empty")
+      validate: requireNonEmpty5("repositories", "repositories block must not be empty")
     },
     sprintContext: {
       placeholder: "SPRINT_CONTEXT",
       description: "Sprint metadata block (slug, name, ticket count).",
-      validate: requireNonEmpty3("sprintContext", "sprint context must not be empty")
+      validate: requireNonEmpty5("sprintContext", "sprint context must not be empty")
     },
     feedbackLog: {
       placeholder: "FEEDBACK_LOG",
@@ -20201,7 +21083,7 @@ var applyFeedbackPromptDef = {
     latestRound: {
       placeholder: "LATEST_ROUND",
       description: "The round body the AI must act on now.",
-      validate: requireNonEmpty3("latestRound", "latest round body must not be empty")
+      validate: requireNonEmpty5("latestRound", "latest round body must not be empty")
     },
     progress: {
       placeholder: "PROGRESS",
@@ -20210,7 +21092,7 @@ var applyFeedbackPromptDef = {
     outputContractSection: {
       placeholder: "OUTPUT_CONTRACT_SECTION",
       description: "Audit-[09] output contract block rendered from the review-round contract \u2014 instructs the AI to write `signals.json` directly with exactly one terminal signal.",
-      validate: requireNonEmpty3("outputContractSection", "output-contract section must not be empty")
+      validate: requireNonEmpty5("outputContractSection", "output-contract section must not be empty")
     }
   },
   partials: {
@@ -20623,7 +21505,7 @@ import { promises as fs28 } from "fs";
 import { join as join42 } from "path";
 
 // src/integration/ai/prompts/distill-learnings/definition.ts
-var requireNonEmpty4 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var requireNonEmpty6 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
 var distillLearningsPromptDef = {
   templateName: "distill-learnings",
   description: "One-shot documentation edit that folds curated learnings into an existing project context file\u2019s own idempotent `## Learnings (ralphctl)` section.",
@@ -20635,12 +21517,12 @@ var distillLearningsPromptDef = {
     candidateLearnings: {
       placeholder: "CANDIDATE_LEARNINGS",
       description: "Markdown list of the curated learnings to fold into the context file.",
-      validate: requireNonEmpty4("candidateLearnings", "candidate learnings must not be empty")
+      validate: requireNonEmpty6("candidateLearnings", "candidate learnings must not be empty")
     },
     targetFilename: {
       placeholder: "TARGET_FILENAME",
       description: "Native context-file name for the target provider (CLAUDE.md / .github/copilot-instructions.md / AGENTS.md).",
-      validate: requireNonEmpty4("targetFilename", "target filename must not be empty")
+      validate: requireNonEmpty6("targetFilename", "target filename must not be empty")
     },
     projectTooling: {
       placeholder: "PROJECT_TOOLING",
@@ -22554,7 +23436,7 @@ var launchReadiness = async (ctx) => {
 import { join as join48 } from "path";
 
 // src/integration/ai/prompts/detect-skills/definition.ts
-var requireNonEmpty5 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var requireNonEmpty7 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
 var detectSkillsPromptDef = {
   templateName: "detect-skills",
   description: "Read-only repo inventory that authors two short coding-agent skills: setup (sprint-start prep) and verify (post-task gate interpretation).",
@@ -22562,17 +23444,17 @@ var detectSkillsPromptDef = {
     repositoryPath: {
       placeholder: "REPOSITORY_PATH",
       description: "Absolute path to the repository the AI is inventorying.",
-      validate: requireNonEmpty5("repositoryPath", "repository path must not be empty")
+      validate: requireNonEmpty7("repositoryPath", "repository path must not be empty")
     },
     skillsConvention: {
       placeholder: "SKILLS_CONVENTION",
       description: "Provider-specific guidance on where to find existing skills in this repository.",
-      validate: requireNonEmpty5("skillsConvention", "skills convention snippet must not be empty")
+      validate: requireNonEmpty7("skillsConvention", "skills convention snippet must not be empty")
     },
     outputContractSection: {
       placeholder: "OUTPUT_CONTRACT_SECTION",
       description: "Audit-[09] output contract block rendered from the detect-skills contract \u2014 instructs the AI to write `signals.json` directly.",
-      validate: requireNonEmpty5("outputContractSection", "output-contract section must not be empty")
+      validate: requireNonEmpty7("outputContractSection", "output-contract section must not be empty")
     }
   },
   partials: {
@@ -23007,7 +23889,7 @@ var launchDetectSkills = (ctx) => {
 import { join as join49 } from "path";
 
 // src/integration/ai/prompts/detect-scripts/definition.ts
-var requireNonEmpty6 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
+var requireNonEmpty8 = (field, message) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message })) : Result.ok(v);
 var detectScriptsPromptDef = {
   templateName: "detect-scripts",
   description: "Read-only repo inventory that proposes a single-line setup script and a single-line verify script.",
@@ -23015,12 +23897,12 @@ var detectScriptsPromptDef = {
     repositoryPath: {
       placeholder: "REPOSITORY_PATH",
       description: "Absolute path to the repository the AI is inventorying.",
-      validate: requireNonEmpty6("repositoryPath", "repository path must not be empty")
+      validate: requireNonEmpty8("repositoryPath", "repository path must not be empty")
     },
     outputContractSection: {
       placeholder: "OUTPUT_CONTRACT_SECTION",
       description: "Audit-[09] output contract block rendered from the detect-scripts contract \u2014 instructs the AI to write `signals.json` directly.",
-      validate: requireNonEmpty6("outputContractSection", "output-contract section must not be empty")
+      validate: requireNonEmpty8("outputContractSection", "output-contract section must not be empty")
     }
   },
   partials: {
@@ -23652,7 +24534,8 @@ var parseIdeateOutput = (raw, ctx) => {
   const tasks = parseTaskList(parsed.data.tasks, {
     project: ctx.project,
     mode: { kind: "fixed", ticketId: ctx.ticketId, ...ctx.ticket !== void 0 ? { ticket: ctx.ticket } : {} },
-    ...ctx.logger !== void 0 ? { logger: ctx.logger } : {}
+    ...ctx.logger !== void 0 ? { logger: ctx.logger } : {},
+    ...ctx.defaultMaxAttempts !== void 0 ? { defaultMaxAttempts: ctx.defaultMaxAttempts } : {}
   });
   if (!tasks.ok) return Result.error(tasks.error);
   void ctx.sprintId;
@@ -23707,7 +24590,8 @@ var ideateAndPlanLeaf = (deps) => leaf("ideate-and-plan", {
         // Pass the freshly minted ticket so any `externalRef` on it (currently unused by the
         // ideate input surface, but ready when added) propagates to every generated task.
         ticket: pending.value,
-        logger: deps.logger
+        logger: deps.logger,
+        defaultMaxAttempts: deps.maxAttempts
       });
       if (!parsed.ok) return Result.error(parsed.error);
       const added = addApprovedTicketUseCase({
@@ -23874,6 +24758,7 @@ var createIdeateFlow = (deps, opts) => {
       writeFile: deps.writeFile,
       eventBus: deps.eventBus,
       model: opts.model,
+      maxAttempts: opts.maxAttempts,
       ...opts.effort !== void 0 ? { effort: opts.effort } : {}
     }),
     uninstallSkillsLeaf({ skillsAdapter: deps.skillsAdapter }, { cwdPicker: () => opts.cwd }),
@@ -23922,6 +24807,7 @@ var launchIdeate = async (ctx) => {
       cwd,
       providerId: settings.ai.ideate.provider,
       model: settings.ai.ideate.model,
+      maxAttempts: settings.harness.maxAttempts,
       ...effort !== void 0 ? { effort } : {},
       ideateRoot: ideateRoot.value
     }
@@ -24811,18 +25697,9 @@ var settingsManifest = {
   triggers: {}
 };
 
-// src/application/flows/ticket-add/manifest.ts
-var ticketAddManifest = {
-  id: "ticket-add",
-  title: "Add ticket",
-  description: "Append a pending ticket to a draft sprint.",
-  canBackground: false,
-  triggers: { currentSprintStatus: ["draft"] }
-};
-
-// src/application/flows/ticket-remove/manifest.ts
+// src/application/flows/remove-ticket/manifest.ts
 var ticketRemoveManifest = {
-  id: "ticket-remove",
+  id: "remove-ticket",
   title: "Remove ticket",
   description: "Drop a ticket from a draft sprint.",
   canBackground: false,
@@ -24847,7 +25724,6 @@ var flowRegistry = [
   { manifest: createPrManifest },
   { manifest: doctorManifest },
   { manifest: settingsManifest },
-  { manifest: ticketAddManifest },
   { manifest: ticketRemoveManifest }
 ];
 
@@ -25085,8 +25961,7 @@ var SPRINT_SCOPED_FLOW_IDS = [
   "review",
   "close-sprint",
   "create-pr",
-  "ticket-add",
-  "ticket-remove"
+  "remove-ticket"
 ];
 var PROJECT_SCOPED_FLOW_IDS = [
   "create-sprint",
@@ -25101,9 +25976,9 @@ var SPRINT_SCOPED_SET = new Set(SPRINT_SCOPED_FLOW_IDS);
 var PROJECT_SCOPED_SET = new Set(PROJECT_SCOPED_FLOW_IDS);
 var HIDDEN_SET = new Set(HIDDEN_BY_DEFAULT_FLOW_IDS);
 var ALLOWED_BY_STATUS = {
-  draft: /* @__PURE__ */ new Set(["refine", "add-tickets", "plan", "ticket-add", "ticket-remove"]),
-  planned: /* @__PURE__ */ new Set(["implement", "ticket-add", "ticket-remove"]),
-  active: /* @__PURE__ */ new Set(["implement", "ticket-add"]),
+  draft: /* @__PURE__ */ new Set(["refine", "add-tickets", "plan", "remove-ticket"]),
+  planned: /* @__PURE__ */ new Set(["implement", "remove-ticket"]),
+  active: /* @__PURE__ */ new Set(["implement"]),
   review: /* @__PURE__ */ new Set(["review", "close-sprint"]),
   done: /* @__PURE__ */ new Set(["create-pr"])
 };
@@ -25143,8 +26018,7 @@ var viewRouteFor = (flowId, snapshot) => {
       return { id: "doctor" };
     case "settings":
       return { id: "settings" };
-    case "ticket-add":
-    case "ticket-remove":
+    case "remove-ticket":
       return snapshot.sprint ? { id: "sprint-detail", props: { sprintId: snapshot.sprint.id } } : void 0;
     case "export-context":
       return { id: "export-context" };
@@ -26380,8 +27254,8 @@ var SprintsView = () => {
 import { useEffect as useEffect22, useMemo as useMemo14, useState as useState31 } from "react";
 import { Box as Box44, Text as Text45 } from "ink";
 
-// src/application/flows/ticket-remove/flow.ts
-var createTicketRemoveFlow = (deps) => leaf("ticket-remove", {
+// src/application/flows/remove-ticket/flow.ts
+var createTicketRemoveFlow = (deps) => leaf("remove-ticket", {
   useCase: {
     async execute(input) {
       const sprint = await deps.sprintRepo.findById(input.sprintId);
@@ -26943,8 +27817,8 @@ var TaskCard = ({
   expanded,
   index
 }) => {
-  const lastAttempt2 = task.attempts[task.attempts.length - 1];
-  const lastAttemptElapsed = lastAttempt2 !== void 0 ? attemptElapsedMs(lastAttempt2) : void 0;
+  const lastAttempt3 = task.attempts[task.attempts.length - 1];
+  const lastAttemptElapsed = lastAttempt3 !== void 0 ? attemptElapsedMs(lastAttempt3) : void 0;
   const { atLeast } = useBreakpoint();
   const singleLineMetadata = atLeast("md");
   const metadataParts = buildTaskMetadataParts({
@@ -28717,6 +29591,18 @@ var ExecuteBody = ({
 // src/application/ui/tui/views/execute-view-internals/tasks-panel-host.tsx
 import { useMemo as useMemo17 } from "react";
 import { jsx as jsx71 } from "react/jsx-runtime";
+var warningSummaryFor = (w) => {
+  switch (w.kind) {
+    case "budget-exhausted":
+      return `done with warning: turn budget exhausted (${String(w.turnsUsed)}/${String(w.turnBudget)} turns)`;
+    case "plateau":
+      return w.dimensions.length > 0 ? `done with warning: evaluator plateaued on ${w.dimensions.join(", ")}` : "done with warning: evaluator plateaued";
+    case "malformed":
+      return "done with warning: evaluator output malformed";
+    case "verify-failed":
+      return `done with warning: post-task verify red (${w.exitCode !== null ? `exit ${String(w.exitCode)}` : "no exit code"})`;
+  }
+};
 var TasksPanelHost = ({
   bucketed,
   descriptor,
@@ -28746,6 +29632,16 @@ var TasksPanelHost = ({
     }
     return m.size > 0 ? m : void 0;
   }, [taskState]);
+  const warningSummaryById = useMemo17(() => {
+    if (taskState === void 0) return void 0;
+    const m = /* @__PURE__ */ new Map();
+    for (const t of taskState) {
+      if (t.status !== "done") continue;
+      const warning = t.attempts[t.attempts.length - 1]?.warning;
+      if (warning !== void 0) m.set(String(t.id), warningSummaryFor(warning));
+    }
+    return m.size > 0 ? m : void 0;
+  }, [taskState]);
   if (bucketed === void 0) return null;
   return /* @__PURE__ */ jsx71(
     TasksPanel,
@@ -28759,7 +29655,8 @@ var TasksPanelHost = ({
       ...descriptor.taskNames !== void 0 ? { nameById: descriptor.taskNames } : {},
       ...descriptor.taskRecovering !== void 0 ? { recoveringByTaskId: descriptor.taskRecovering } : {},
       ...taskCriteriaById !== void 0 ? { taskCriteriaById } : {},
-      ...blockedReasonById !== void 0 ? { blockedReasonById } : {}
+      ...blockedReasonById !== void 0 ? { blockedReasonById } : {},
+      ...warningSummaryById !== void 0 ? { warningSummaryById } : {}
     }
   );
 };
@@ -29184,9 +30081,9 @@ var flowIdToTitle = (flowId) => {
       return "Close Sprint";
     case "add-tickets":
       return "Add Tickets";
-    case "ticket-add":
+    case "add-ticket":
       return "Add Ticket";
-    case "ticket-remove":
+    case "remove-ticket":
       return "Remove Ticket";
     case "export-context":
       return "Export Context";
@@ -29496,7 +30393,16 @@ var createSettingsShowFlow = (deps) => leaf("settings-show", {
 import "react";
 
 // src/business/settings/presets.ts
-var PRESET_NAMES = ["mixed", "claude-only", "copilot-only", "codex-only"];
+var PRESET_NAMES = [
+  "mixed",
+  "claude-only",
+  "copilot-only",
+  "codex-only",
+  "mixed-economic",
+  "claude-economic",
+  "copilot-economic",
+  "codex-economic"
+];
 var isPresetName = (raw) => PRESET_NAMES.includes(raw);
 var MIXED = {
   effort: "high",
@@ -29527,13 +30433,13 @@ var CLAUDE_ONLY = {
 var COPILOT_ONLY = {
   effort: "high",
   refine: { provider: "github-copilot", model: "claude-sonnet-4.6" },
-  plan: { provider: "github-copilot", model: "claude-opus-4.6", effort: "xhigh" },
+  plan: { provider: "github-copilot", model: "claude-opus-4.8", effort: "xhigh" },
   implement: {
-    generator: { provider: "github-copilot", model: "claude-opus-4.6", effort: "xhigh" },
-    evaluator: { provider: "github-copilot", model: "claude-opus-4.6", effort: "xhigh" }
+    generator: { provider: "github-copilot", model: "claude-opus-4.8", effort: "xhigh" },
+    evaluator: { provider: "github-copilot", model: "claude-opus-4.8", effort: "xhigh" }
   },
   readiness: { provider: "github-copilot", model: "gpt-5-mini", effort: "medium" },
-  ideate: { provider: "github-copilot", model: "claude-opus-4.6" },
+  ideate: { provider: "github-copilot", model: "claude-opus-4.8" },
   createPr: { provider: "github-copilot", model: "gpt-5-mini" }
 };
 var CODEX_ONLY = {
@@ -29541,8 +30447,58 @@ var CODEX_ONLY = {
   refine: { provider: "openai-codex", model: "gpt-5.4" },
   plan: { provider: "openai-codex", model: "gpt-5.5", effort: "high" },
   implement: {
-    generator: { provider: "openai-codex", model: "gpt-5.3-codex", effort: "high" },
-    evaluator: { provider: "openai-codex", model: "gpt-5.3-codex", effort: "high" }
+    // gpt-5.3-codex is deprecated for ChatGPT sign-in — implement now rides the frontier
+    // default so the everyday autonomous loop keeps working under ChatGPT auth.
+    generator: { provider: "openai-codex", model: "gpt-5.5", effort: "high" },
+    evaluator: { provider: "openai-codex", model: "gpt-5.5", effort: "high" }
+  },
+  readiness: { provider: "openai-codex", model: "gpt-5.4-mini", effort: "medium" },
+  ideate: { provider: "openai-codex", model: "gpt-5.5" },
+  createPr: { provider: "openai-codex", model: "gpt-5.4-mini" }
+};
+var MIXED_ECONOMIC = {
+  effort: "high",
+  refine: { provider: "openai-codex", model: "gpt-5.4-mini" },
+  plan: { provider: "github-copilot", model: "claude-sonnet-4.6", effort: "high" },
+  implement: {
+    generator: { provider: "claude-code", model: "claude-sonnet-4-6", effort: "high" },
+    evaluator: { provider: "claude-code", model: "claude-sonnet-4-6", effort: "high" }
+  },
+  readiness: { provider: "github-copilot", model: "gpt-5-mini", effort: "medium" },
+  ideate: { provider: "claude-code", model: "claude-sonnet-4-6" },
+  createPr: { provider: "openai-codex", model: "gpt-5.4-mini" }
+};
+var CLAUDE_ECONOMIC = {
+  effort: "high",
+  refine: { provider: "claude-code", model: "claude-haiku-4-5" },
+  plan: { provider: "claude-code", model: "claude-sonnet-4-6", effort: "high" },
+  implement: {
+    generator: { provider: "claude-code", model: "claude-sonnet-4-6", effort: "high" },
+    evaluator: { provider: "claude-code", model: "claude-sonnet-4-6", effort: "high" }
+  },
+  readiness: { provider: "claude-code", model: "claude-haiku-4-5", effort: "medium" },
+  ideate: { provider: "claude-code", model: "claude-sonnet-4-6" },
+  createPr: { provider: "claude-code", model: "claude-haiku-4-5" }
+};
+var COPILOT_ECONOMIC = {
+  effort: "high",
+  refine: { provider: "github-copilot", model: "gpt-5.4-mini" },
+  plan: { provider: "github-copilot", model: "claude-sonnet-4.6", effort: "high" },
+  implement: {
+    generator: { provider: "github-copilot", model: "claude-sonnet-4.6", effort: "high" },
+    evaluator: { provider: "github-copilot", model: "claude-sonnet-4.6", effort: "high" }
+  },
+  readiness: { provider: "github-copilot", model: "gpt-5-mini", effort: "medium" },
+  ideate: { provider: "github-copilot", model: "claude-sonnet-4.6" },
+  createPr: { provider: "github-copilot", model: "gpt-5-mini" }
+};
+var CODEX_ECONOMIC = {
+  effort: "high",
+  refine: { provider: "openai-codex", model: "gpt-5.4-mini" },
+  plan: { provider: "openai-codex", model: "gpt-5.4", effort: "high" },
+  implement: {
+    generator: { provider: "openai-codex", model: "gpt-5.4", effort: "high" },
+    evaluator: { provider: "openai-codex", model: "gpt-5.4", effort: "high" }
   },
   readiness: { provider: "openai-codex", model: "gpt-5.4-mini", effort: "medium" },
   ideate: { provider: "openai-codex", model: "gpt-5.5" },
@@ -29552,7 +30508,11 @@ var PRESETS = {
   mixed: MIXED,
   "claude-only": CLAUDE_ONLY,
   "copilot-only": COPILOT_ONLY,
-  "codex-only": CODEX_ONLY
+  "codex-only": CODEX_ONLY,
+  "mixed-economic": MIXED_ECONOMIC,
+  "claude-economic": CLAUDE_ECONOMIC,
+  "copilot-economic": COPILOT_ECONOMIC,
+  "codex-economic": CODEX_ECONOMIC
 };
 var applyPreset = (name, current) => ({
   ...current,
@@ -29565,7 +30525,11 @@ var PRESET_LABEL = {
   mixed: "Apply: Mixed",
   "claude-only": "Apply: Claude only",
   "copilot-only": "Apply: Copilot only",
-  "codex-only": "Apply: Codex only"
+  "codex-only": "Apply: Codex only",
+  "mixed-economic": "Apply: Mixed (economic)",
+  "claude-economic": "Apply: Claude (economic)",
+  "copilot-economic": "Apply: Copilot (economic)",
+  "codex-economic": "Apply: Codex (economic)"
 };
 var LOG_LEVELS = ["silent", "debug", "info", "warn", "error"];
 var DEFAULT_TOKEN = "Default";
@@ -30846,6 +31810,28 @@ var createPushBranchLeaf = (deps) => leaf(
 );
 
 // src/business/sprint/views/pr-content.ts
+var warningDetail = (w) => {
+  switch (w.kind) {
+    case "budget-exhausted":
+      return `turn budget exhausted (${String(w.turnsUsed)}/${String(w.turnBudget)} turns)`;
+    case "plateau":
+      return w.dimensions.length > 0 ? `evaluator plateaued on: ${w.dimensions.join(", ")}` : "evaluator plateaued";
+    case "malformed":
+      return w.detail.trim().length > 0 ? `evaluator output malformed (${w.detail.trim()})` : "evaluator output malformed";
+    case "verify-failed": {
+      const exit = w.exitCode !== null ? `exit ${String(w.exitCode)}` : "no exit code";
+      return w.stderr.trim().length > 0 ? `post-task verify red (${exit}: ${w.stderr.trim()})` : `post-task verify red (${exit})`;
+    }
+  }
+};
+var lastAttempt2 = (task) => task.attempts[task.attempts.length - 1];
+var renderWarningsSection = (tasks) => {
+  const flagged = tasks.map((t) => ({ name: t.name, warning: t.status === "done" ? lastAttempt2(t)?.warning : void 0 })).filter((e) => e.warning !== void 0);
+  if (flagged.length === 0) return "";
+  const lines = flagged.map((e) => `- ${e.name} \u2014 ${warningDetail(e.warning)}`).join("\n");
+  return `## Completed with warnings
+${lines}`;
+};
 var derivePrContent = (sprint, tasks) => {
   const sections = [`# ${sprint.name}`];
   if (sprint.tickets.length > 0) {
@@ -30859,6 +31845,8 @@ ${ticketLines}`);
     sections.push(`## Tasks
 ${taskLines}`);
   }
+  const warnings = renderWarningsSection(tasks);
+  if (warnings.length > 0) sections.push(warnings);
   const orderedRefs = normalizeRefs([
     ...sprint.tickets.map((t) => t.externalRef ?? ""),
     ...tasks.flatMap((t) => t.externalRefs ?? [])
@@ -30909,7 +31897,12 @@ var createCreatePrLeaf = (deps) => leaf("create-pr", {
       }
       const derived = derivePrContent(sprint.value, tasks);
       const title = input.title ?? input.aiContent?.title ?? derived.title;
-      const body = input.body ?? input.aiContent?.body ?? derived.body;
+      const resolvedBody = input.body ?? input.aiContent?.body ?? derived.body;
+      const usingDerivedBody = input.body === void 0 && input.aiContent?.body === void 0;
+      const warningsSection = usingDerivedBody ? "" : renderWarningsSection(tasks);
+      const body = warningsSection.length > 0 ? `${resolvedBody}
+
+${warningsSection}` : resolvedBody;
       deps.eventBus.publish({
         type: "log",
         level: "info",
@@ -31463,7 +32456,11 @@ var PRESET_LABEL2 = {
   mixed: "mixed",
   "claude-only": "claude-only",
   "copilot-only": "copilot-only",
-  "codex-only": "codex-only"
+  "codex-only": "codex-only",
+  "mixed-economic": "mixed-economic",
+  "claude-economic": "claude-economic",
+  "copilot-economic": "copilot-economic",
+  "codex-economic": "codex-economic"
 };
 var pickPresetForDetected = (installed) => {
   if (installed.size === 1) {
@@ -32085,8 +33082,8 @@ var StepView2 = ({ step, onChange, onCancel, onSubmit }) => {
 import { useEffect as useEffect40, useState as useState46 } from "react";
 import { Box as Box75 } from "ink";
 
-// src/application/flows/ticket-add/flow.ts
-var createTicketAddFlow = (deps) => leaf("ticket-add", {
+// src/application/flows/add-ticket/flow.ts
+var createTicketAddFlow = (deps) => leaf("add-ticket", {
   useCase: {
     async execute(input) {
       const sprint = await deps.sprintRepo.findById(input.sprintId);