backpass 0.1.7 → 0.1.8

package/src/subprocess.js

@@ -8,21 +8,35 @@ import { spawn } from "node:child_process";
  *
  * @param {string} bin
  * @param {string[]} args
- * @param {{ timeoutMs?: number, cwd?: string, input?: string }} [options]
+ * @param {{ timeoutMs?: number, cwd?: string, input?: string, env?: NodeJS.ProcessEnv }} [options]
  * @returns {Promise<{ code: number | null, stdout: string, stderr: string, timedOut?: boolean, spawnError?: NodeJS.ErrnoException }>}
  */
-export function runCapture(bin, args, { timeoutMs, cwd, input } = {}) {
+export function runCapture(bin, args, { timeoutMs, cwd, input, env } = {}) {
   return new Promise((resolve) => {
-    const child = spawn(bin, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+    const child = spawn(bin, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: env ? { ...process.env, ...env } : undefined,
+      // Give a timed command its own POSIX process group. acpx launches adapter
+      // wrappers and harnesses below itself, and killing acpx alone leaves those
+      // descendants running with our capture pipes open.
+      detached: process.platform !== "win32" && Boolean(timeoutMs),
+    });
     let stdout = "";
     let stderr = "";
     let timedOut = false;
+    let escalationTimer = null;
 
     const timer = timeoutMs
       ? setTimeout(() => {
           timedOut = true;
-          child.kill("SIGTERM");
-          setTimeout(() => child.kill("SIGKILL"), 5000).unref();
+          if (process.platform === "win32") {
+            killWindowsTree(child.pid);
+            return;
+          }
+          killPosixGroup(child, "SIGTERM");
+          escalationTimer = setTimeout(() => killPosixGroup(child, "SIGKILL"), 5000);
+          escalationTimer.unref();
         }, timeoutMs)
       : null;
 
@@ -34,10 +48,13 @@ export function runCapture(bin, args, { timeoutMs, cwd, input } = {}) {
     });
     child.on("error", (err) => {
       if (timer) clearTimeout(timer);
+      if (escalationTimer) clearTimeout(escalationTimer);
       resolve({ code: null, stdout, stderr: `${stderr}${err.message}`, spawnError: err });
     });
     child.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      if (timedOut && process.platform !== "win32") killPosixGroup(child, "SIGKILL");
+      if (escalationTimer) clearTimeout(escalationTimer);
       resolve({ code, stdout, stderr, timedOut });
     });
 
@@ -45,3 +62,34 @@ export function runCapture(bin, args, { timeoutMs, cwd, input } = {}) {
     else child.stdin.end();
   });
 }
+
+function killPosixGroup(child, signal) {
+  if (!child.pid) return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    // Preserve direct-child cleanup if a platform cannot address the group.
+    try {
+      child.kill(signal);
+    } catch {
+      // The child already closed.
+    }
+  }
+}
+
+function killWindowsTree(pid) {
+  if (!pid) return;
+  const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  killer.on("error", () => {
+    // taskkill is part of Windows, but retain direct-child cleanup if it cannot start.
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      // The child already closed.
+    }
+  });
+  killer.unref();
+}

package/src/synthesize.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { extractJson, openSession, usageRecord } from "./acpx.js";
 import { renderEvidenceForPrompt } from "./fold.js";
 import { renderInstructionIndex } from "./memory.js";
-import { renderPrompt } from "./prompts.js";
+import { renderPrompt, render, loadPrompt } from "./prompts.js";
 import { buildProposal, effectiveMaxEdits, ProposalViolation, renderChangesForPrompt } from "./proposal.js";
 import { loadSkills, renderSkillIndex, resolveOverflowTarget } from "./skills.js";
 import { isSuppressedByRejection } from "./state.js";
@@ -13,26 +13,55 @@ import { measureWorkspace, prepareWorkspace, repoFingerprint } from "./workspace
 import { UserError, color, info, warn } from "./logger.js";
 
 /**
- * Stage 3 of the pipeline (design section 3): one high-reasoning session that turns
- * folded evidence into concrete edits.
+ * Stage 3 of the pipeline (design section 3): high-reasoning synthesis that turns folded
+ * evidence into concrete edits.
  *
  * The agent never describes an edit for backpass to locate - it makes the edit, with its
  * harness's own file tools, in a staging copy of the memory file (`src/workspace.js`).
- * One session, two kinds of turn:
+ * A run starts in one session with two kinds of turn:
  *
  *   edit      the synthesis prompt; the agent edits `./AGENTS.md` in the staging copy
  *   annotate  backpass measures the copy against the original (`src/diff.js`) and shows
  *             the changes by id; the agent attaches kind, title, rationale, and evidence
  *
- * The annotation is what the mechanical gates validate (`buildProposal`); on a violation
- * the agent is re-prompted with the exact breaches, at most ANNOTATE_TURNS times in all,
- * then backpass fails loudly and saves the rejected proposal rather than quietly trimming
- * it (design section 6). The repo is fingerprinted before and checked after: a harness
- * that wrote past the staging copy is an error, never a silent apply.
+ * An empty annotation turn is retried once in a fresh session, as described below.
+ *
+ * The annotation is what the mechanical gates validate (`buildProposal`). A parseable
+ * gate-rejected answer is saved before the agent is re-prompted with the exact breaches;
+ * judged answers are bounded by ANNOTATE_TURNS, then backpass fails loudly rather than
+ * quietly trimming the result (design section 6). The repo is fingerprinted around each
+ * turn; a harness that wrote past the staging copy is an error, never a silent apply.
+ *
+ * Three things an annotate turn can be are deliberately kept apart, because they call for
+ * different responses and produce different advice at the end of a failed run:
+ *
+ *   the files moved      the ids the agent was asked about no longer exist. It is shown the
+ *                        fresh measurement and answers again; this is not a failed
+ *                        annotation and never costs an annotation attempt (REMEASURE_TURNS
+ *                        bounds it instead).
+ *   the turn was empty   the adapter returned success with no text at all. The model never
+ *                        spoke, so there is nothing to correct - the annotation is retried
+ *                        once in a NEW session, since the accumulated context of the old
+ *                        one is the likeliest reason it collapsed.
+ *   the answer was judged the model spoke and the gates ruled. Only this consumes an
+ *                        annotation attempt, and only this writes a rejected proposal.
  */
 
-/** Annotation turns per run: the first answer plus re-prompts with the exact violations. */
+/** Annotation attempts per run: the first answer plus re-prompts with the exact violations. */
 export const ANNOTATE_TURNS = 3;
+/**
+ * Turns per run the agent may spend re-editing instead of answering. Counted for the whole
+ * run, not consecutively: an agent that alternates editing and answering is still an agent
+ * that never finishes, and the loop has to end.
+ */
+export const REMEASURE_TURNS = 3;
+/** Fresh-session retries for an adapter turn that produced no text at all. */
+export const EMPTY_TURN_RETRIES = 1;
+
+const EMPTY_TURN_VIOLATION =
+  "the synthesis harness ended its turn with no output at all - no JSON, no prose, no tool call";
+const UNPARSEABLE_VIOLATION = "synthesis answered with text, but not with a JSON object";
+const KEPT_EDITING_VIOLATION = "synthesis kept editing the staging copy instead of annotating the measured changes";
 
 function budgetRule(memoryFile, config, maxEdits) {
   const remaining = config.budgetTokens - memoryFile.tokens;
@@ -93,13 +122,16 @@ function assertRepoUntouched(repo, before, workspaceRoot) {
   );
 }
 
-export async function synthesizeProposal({ memoryFile, summary, config, repo, transcripts, runNote = "" }) {
+/**
+ * Everything the edit and annotation turns need: prompt values, the `buildProposal`
+ * context, and the overflow target.
+ */
+function synthesisSetup({ memoryFile, summary, config, repo, harnessCounts }) {
   const state = config.state;
   const rejections = state.readRejections();
   const overflow = resolveOverflowTarget(repo.root, config.skillsDir);
   for (const w of overflow.warnings) warn(w);
   const skillFiles = loadSkills(repo.root, overflow.dir);
-  const harnessCounts = harnessCountsOf(transcripts);
   const maxEdits = effectiveMaxEdits(memoryFile, config);
 
   const common = {
@@ -108,6 +140,228 @@ export async function synthesizeProposal({ memoryFile, summary, config, repo, tr
     MAX_EDITS: String(maxEdits),
     MIN_GAP_EVIDENCE: String(config.minGapEvidence),
   };
+
+  const context = {
+    memoryFile,
+    config: { ...config, skillsDir: overflow.dir },
+    repo,
+    summary,
+    harnessCounts,
+    rejections,
+    isSuppressed: isSuppressedByRejection,
+    skillFiles,
+  };
+
+  const promptDir = path.join(state.root, "prompts");
+  fs.mkdirSync(promptDir, { recursive: true });
+
+  return { state, rejections, overflow, skillFiles, maxEdits, common, context, promptDir };
+}
+
+/**
+ * The header a fresh annotation session needs. An in-session annotate turn inherits the
+ * repository, the budget, and the evidence from the editing turn that preceded it; the
+ * fresh session used after an empty reply would otherwise be asked to quote evidence it
+ * has never been shown.
+ */
+function prefaceFor({ memoryFile, summary, config, repo, workspaceRoot }) {
+  return render(loadPrompt("annotate-preface"), {
+    MEMORY_PATH: memoryFile.path,
+    REPO_NAME: repo.name,
+    REPO_ROOT: repo.root,
+    WORKSPACE_ROOT: workspaceRoot,
+    CURRENT_TOKENS: String(memoryFile.tokens),
+    BUDGET_STATE: budgetState(memoryFile, config),
+    TRANSCRIPT_COUNT: String(summary.analyzedSessions),
+    EVIDENCE: renderEvidenceForPrompt(summary),
+  });
+}
+
+const REMEASURE_NOTICE =
+  `\n\n## The files moved after they were measured\n\nYou changed the files again during your last turn, so the ids you were given no longer ` +
+  `describe them. Nothing is wrong with the shape of your answer - annotate the re-measured ` +
+  `changes above instead. This did not use up an annotation attempt.\n`;
+
+const rejectionBlock = (violations) =>
+  `\n\n## Your previous answer was rejected\n\nIt violated these hard rules. Fix every one of them ` +
+  `(edit the files first if a change must go or move) and return the corrected JSON object only.\n\n` +
+  `${violations.map((v) => `- ${v}`).join("\n")}\n`;
+
+/** The headline of a failed run, named after the condition it actually ended on. */
+function terminalMessage(reason, attempts, violations) {
+  if (reason === "empty") {
+    return "synthesis ended its turn with no output, in the run's session and again in a fresh one";
+  }
+  if (reason === "editing") {
+    return `synthesis kept editing the staging copy instead of annotating it (${REMEASURE_TURNS} re-measurements)`;
+  }
+  return (
+    `synthesis could not produce a valid proposal after ${Math.max(attempts - 1, 0)} re-prompt(s) ` +
+    `(${violations.length} violation(s))`
+  );
+}
+
+/**
+ * Drive the annotate turns to a valid proposal, or throw a `ProposalViolation` describing
+ * the condition the run actually ended on.
+ *
+ * `holder.session` is the live session; the loop replaces it when it needs a fresh one and
+ * the caller closes whatever is in the holder at the end.
+ */
+async function annotateLoop({
+  holder,
+  freshSession,
+  workspace,
+  fingerprint,
+  repo,
+  context,
+  common,
+  promptDir,
+  timeoutSeconds,
+  promptRetries,
+  usage,
+  notes,
+  noteOnce,
+  overflow,
+  progress,
+  renderPreface,
+  startFresh = false,
+}) {
+  const { memoryFile, config } = context;
+  const state = config.state;
+
+  let attempts = 0;
+  let remeasures = 0;
+  let emptyTurns = 0;
+  let violationsToShow = [];
+  let justRemeasured = false;
+  let owePreface = startFresh;
+  /** @type {{ attempt: number, violations: string[] } | null} */
+  let saved = null;
+  /** @type {{ reason: string, violations: string[] }} */
+  let terminal;
+
+  for (let turn = 1; ; turn += 1) {
+    assertRepoUntouched(repo, fingerprint, workspace.root);
+    const measured = measureWorkspace(workspace);
+
+    let prompt = renderPrompt("annotate", {
+      ...common,
+      PREFACE: owePreface ? renderPreface() : "",
+      CHANGES: renderChangesForPrompt(measured, memoryFile),
+    });
+    owePreface = false;
+    if (justRemeasured) prompt += REMEASURE_NOTICE;
+    else if (violationsToShow.length) prompt += rejectionBlock(violationsToShow);
+
+    const promptFile = path.join(promptDir, `synthesis-annotate-${turn}.md`);
+    fs.writeFileSync(promptFile, prompt);
+    progress("annotate", { attempt: attempts + 1, turn, changes: measured.changes.length });
+
+    const result = await holder.prompt({
+      promptFile,
+      approveAll: true,
+      timeoutSeconds,
+      promptRetries,
+    });
+    usage.push(usageRecord(holder.ranWith, result));
+    for (const note of result.notes || []) noteOnce(note);
+
+    // The agent may keep editing during an annotate turn; the ids it was answering about
+    // are then stale, so the answer is dropped and the fresh measurement shown instead.
+    // That is a measurement problem, not a failed annotation: it costs no attempt.
+    assertRepoUntouched(repo, fingerprint, workspace.root);
+    if (measureWorkspace(workspace).signature !== measured.signature) {
+      remeasures += 1;
+      justRemeasured = true;
+      violationsToShow = [];
+      if (remeasures >= REMEASURE_TURNS) {
+        terminal = { reason: "editing", violations: [KEPT_EDITING_VIOLATION] };
+        break;
+      }
+      warn(
+        `synthesis edited the staging copy again; re-measuring and re-annotating ` +
+          `(annotation attempt ${attempts + 1} of ${ANNOTATE_TURNS} is still unspent)`,
+      );
+      emitProgress("synth:remeasure", { turn, attempt: attempts + 1, remeasures });
+      continue;
+    }
+    justRemeasured = false;
+
+    // An empty turn is not a bad answer; it is no answer. Retry it once in a new session,
+    // because the accumulated context of this one is the likeliest reason it collapsed.
+    if (!(result.text || "").trim()) {
+      emptyTurns += 1;
+      if (emptyTurns > EMPTY_TURN_RETRIES) {
+        terminal = { reason: "empty", violations: [EMPTY_TURN_VIOLATION] };
+        break;
+      }
+      warn("synthesis ended its turn with no output; retrying the annotation once in a fresh session");
+      emitProgress("synth:empty", { turn, attempt: attempts + 1, emptyTurns });
+      await holder.session.close();
+      holder.session = await freshSession();
+      // The new session knows nothing, so it is given the preface; `violationsToShow` is
+      // kept because those gates are still what the run's annotation has to satisfy.
+      owePreface = true;
+      continue;
+    }
+
+    attempts += 1;
+    const parsed = extractJson(result.text);
+    if (!parsed) {
+      violationsToShow = [UNPARSEABLE_VIOLATION];
+      if (attempts >= ANNOTATE_TURNS) {
+        terminal = { reason: "unparseable", violations: violationsToShow };
+        break;
+      }
+      warn(`synthesis violated 1 gate(s); re-prompting with the exact violations`);
+      emitProgress("synth:violations", { attempt: attempts, violations: violationsToShow });
+      continue;
+    }
+
+    const { proposal, violations } = buildProposal(parsed, { ...context, measured });
+    proposal.notes = [...proposal.notes, ...notes];
+    proposal.usage = usage;
+    proposal.overflowTarget = overflow;
+    proposal.attempt = attempts;
+    if (!violations.length) {
+      emitProgress("synth:done", { edits: proposal.edits.length, attempt: attempts });
+      return { proposal, violations: [] };
+    }
+
+    violationsToShow = violations;
+    proposal.violations = violations;
+    // Keep the rejected proposal so a loud failure is still inspectable. It records which
+    // attempt produced it, so a later empty turn cannot be reported as its author.
+    state.writeProposal(proposal);
+    saved = { attempt: attempts, violations };
+    if (attempts >= ANNOTATE_TURNS) {
+      terminal = { reason: "gates", violations };
+      break;
+    }
+    warn(`synthesis violated ${violations.length} gate(s); re-prompting with the exact violations`);
+    emitProgress("synth:violations", { attempt: attempts, violations });
+  }
+
+  throw new ProposalViolation(terminalMessage(terminal.reason, attempts, terminal.violations), terminal.violations, {
+    reason: terminal.reason,
+    attempts,
+    saved,
+    proposalPath: saved ? state.proposalPath : null,
+  });
+}
+
+export async function synthesizeProposal({ memoryFile, summary, config, repo, transcripts, runNote = "" }) {
+  config.state.clearProposal();
+  const harnessCounts = harnessCountsOf(transcripts);
+  const { state, rejections, overflow, skillFiles, maxEdits, common, context, promptDir } = synthesisSetup({
+    memoryFile,
+    summary,
+    config,
+    repo,
+    harnessCounts,
+  });
+
   const editValues = {
     ...common,
     REPO_NAME: repo.name,
@@ -128,19 +382,6 @@ export async function synthesizeProposal({ memoryFile, summary, config, repo, tr
     REJECTIONS: renderRejections(rejections),
   };
 
-  const context = {
-    memoryFile,
-    config: { ...config, skillsDir: overflow.dir },
-    repo,
-    summary,
-    harnessCounts,
-    rejections,
-    isSuppressed: isSuppressedByRejection,
-    skillFiles,
-  };
-
-  const promptDir = path.join(state.root, "prompts");
-  fs.mkdirSync(promptDir, { recursive: true });
   const editPromptFile = path.join(promptDir, "synthesis-edit.md");
   fs.writeFileSync(editPromptFile, renderPrompt("synthesis", editValues));
 
@@ -163,6 +404,7 @@ export async function synthesizeProposal({ memoryFile, summary, config, repo, tr
       `${pick.effort ? ` effort=${pick.effort}` : ""}`,
   );
   let ranWith = pick.agent;
+  let chosen = pick;
   const progress = (phase, extra = {}) =>
     emitProgress("synth:start", {
       agent: ranWith,
@@ -181,16 +423,25 @@ export async function synthesizeProposal({ memoryFile, summary, config, repo, tr
   // through to the next ladder candidate; the switch is recorded in the notes so the
   // proposal's provenance is visible. Once the editing turn has run, later turns stay
   // on the same candidate - a run never silently switches models after real work.
-  /** @type {Awaited<ReturnType<typeof openSession>> | null} */
-  let session = null;
+  /** @type {{ session: Awaited<ReturnType<typeof openSession>> | null, ranWith: string, prompt: Function }} */
+  const holder = {
+    session: null,
+    ranWith,
+    prompt(args) {
+      if (!this.session) throw new Error("synthesis session is not open");
+      return this.session.prompt(args);
+    },
+  };
   /** @type {ReturnType<typeof prepareWorkspace>} */
   let workspace = null;
   const editResult = await config.agents.withFallthrough("synthesis", async (current) => {
     ranWith = current.agent;
+    holder.ranWith = current.agent;
+    chosen = current;
     if (current !== pick) notes.push(`synthesis fell through to ${current.agent} (${current.model})`);
     workspace = prepareWorkspace({ state, repo, memoryFile, skillsDir: overflow.dir });
     progress("edit", { attempt: 1 });
-    session = await openSession({
+    holder.session = await openSession({
       agent: current.agent,
       model: current.model,
       effort: current.effort,
@@ -198,90 +449,51 @@ export async function synthesizeProposal({ memoryFile, summary, config, repo, tr
       cwd: workspace.root,
     });
     try {
-      return await session.prompt({
+      return await holder.session.prompt({
         promptFile: editPromptFile,
         approveAll: true,
         timeoutSeconds,
         promptRetries: config.promptRetries,
       });
     } catch (err) {
-      await session.close();
-      session = null;
+      await holder.session.close();
+      holder.session = null;
       throw err;
     }
   });
   usage.push(usageRecord(ranWith, editResult));
   for (const note of editResult.notes || []) noteOnce(note);
 
-  const turn = session;
-  try {
-    let lastViolations = [];
-    for (let attempt = 1; attempt <= ANNOTATE_TURNS; attempt += 1) {
-      assertRepoUntouched(repo, fingerprint, workspace.root);
-      const measured = measureWorkspace(workspace);
-
-      let prompt = renderPrompt("annotate", {
-        ...common,
-        CHANGES: renderChangesForPrompt(measured, memoryFile),
-      });
-      if (lastViolations.length) {
-        prompt +=
-          `\n\n## Your previous answer was rejected\n\nIt violated these hard rules. Fix every one of them ` +
-          `(edit the files first if a change must go or move) and return the corrected JSON object only.\n\n` +
-          `${lastViolations.map((v) => `- ${v}`).join("\n")}\n`;
-      }
-      const promptFile = path.join(promptDir, `synthesis-annotate-${attempt}.md`);
-      fs.writeFileSync(promptFile, prompt);
-      progress("annotate", { attempt, changes: measured.changes.length });
-
-      const result = await turn.prompt({
-        promptFile,
-        approveAll: true,
-        timeoutSeconds,
-        promptRetries: config.promptRetries,
-      });
-      usage.push(usageRecord(ranWith, result));
-      for (const note of result.notes || []) noteOnce(note);
-
-      // The agent may keep editing during an annotate turn; ids are then stale, so the
-      // answer is discarded and the fresh measurement is shown instead.
-      assertRepoUntouched(repo, fingerprint, workspace.root);
-      const remeasured = measureWorkspace(workspace);
-      if (remeasured.signature !== measured.signature) {
-        lastViolations = [
-          "the files changed after the changes were measured; annotate the re-measured changes shown above",
-        ];
-      } else {
-        const parsed = extractJson(result.text);
-        if (!parsed) {
-          lastViolations = ["synthesis returned no parseable JSON object"];
-        } else {
-          const { proposal, violations } = buildProposal(parsed, { ...context, measured });
-          proposal.notes = [...proposal.notes, ...notes];
-          proposal.usage = usage;
-          proposal.overflowTarget = overflow;
-          if (!violations.length) {
-            emitProgress("synth:done", { edits: proposal.edits.length, attempt });
-            return { proposal, violations: [] };
-          }
-          lastViolations = violations;
-          proposal.violations = violations;
-          // Keep the rejected proposal so a loud failure is still inspectable.
-          state.writeProposal(proposal);
-        }
-      }
-
-      if (attempt < ANNOTATE_TURNS) {
-        warn(`synthesis violated ${lastViolations.length} gate(s); re-prompting with the exact violations`);
-        emitProgress("synth:violations", { attempt, violations: lastViolations });
-      }
-    }
+  let serial = 1;
+  const freshSession = () =>
+    openSession({
+      agent: chosen.agent,
+      model: chosen.model,
+      effort: chosen.effort,
+      sessionName: `${sessionName}-r${(serial += 1)}`,
+      cwd: workspace.root,
+    });
 
-    throw new ProposalViolation(
-      `synthesis could not produce a valid proposal after ${ANNOTATE_TURNS - 1} re-prompt(s) (${lastViolations.length} violation(s))`,
-      lastViolations,
-    );
+  try {
+    return await annotateLoop({
+      holder,
+      freshSession,
+      workspace,
+      fingerprint,
+      repo,
+      context,
+      common,
+      promptDir,
+      timeoutSeconds,
+      promptRetries: config.promptRetries,
+      usage,
+      notes,
+      noteOnce,
+      overflow,
+      progress,
+      renderPreface: () => prefaceFor({ memoryFile, summary, config, repo, workspaceRoot: workspace.root }),
+    });
   } finally {
-    await turn.close();
+    await holder.session.close();
   }
 }

package/src/tui/index.js

@@ -103,6 +103,7 @@ export function initialState(meta) {
       instructions: 0,
       suppressed: 0,
       violations: [],
+      annotateCondition: null,
       edits: 0,
     },
   };
@@ -233,6 +234,17 @@ export function reduceEvent(state, event, data, now = Date.now()) {
       break;
     case "synth:violations":
       s.violations = data.violations || [];
+      s.annotateCondition = null;
+      break;
+    // Neither of these is a rejected answer, so neither clears into the violations list:
+    // the files moved under the ids, or the harness said nothing at all.
+    case "synth:remeasure":
+      s.annotateCondition = "remeasure";
+      s.violations = [];
+      break;
+    case "synth:empty":
+      s.annotateCondition = "empty";
+      s.violations = [];
       break;
     case "synth:done":
       s.status = "done";

package/src/tui/render.js

@@ -247,6 +247,9 @@ function synthSummary(theme, s) {
   const model = [s.agent, s.model].filter(Boolean).join(" · ");
   const effort = s.effort ? ` · effort ${s.effort}` : "";
   if (s.status === "done") return theme.paint(`${s.edits} edit(s) · passed validation`, "dim");
+  if (s.phase === "annotate" && s.annotateCondition === "empty") {
+    return theme.paint("fresh session after an empty turn · ", "dim") + theme.paint(`${model}${effort}`, "dim");
+  }
   if (s.phase === "annotate" && s.attempt > 1) {
     return (
       theme.paint("re-prompt ", "dim") +
@@ -384,6 +387,19 @@ function synthesizeDetail(state, theme, width, spin) {
     sectionRule(theme, STAGE_LABELS.synthesize, `aggregated gradients → at most ${state.meta.maxEdits} edits`, width),
   ];
 
+  // A re-measurement and an empty turn are named for what they are: neither spent one of
+  // the annotation attempts, and saying "violated 1 gate(s)" for either is how a run gets
+  // read as almost-passing when nothing was judged at all.
+  if (s.phase === "annotate" && s.annotateCondition === "remeasure") {
+    lines.push(
+      ` ${theme.paint("~", "yellow")} ${theme.paint("the files moved; re-annotating the new ids", "text")} ${theme.paint("· no annotation attempt spent", "dim")}`,
+    );
+  }
+  if (s.phase === "annotate" && s.annotateCondition === "empty") {
+    lines.push(
+      ` ${theme.paint("~", "yellow")} ${theme.paint("the harness returned an empty turn", "text")} ${theme.paint("· retrying in a fresh session", "dim")}`,
+    );
+  }
   if (s.phase === "annotate" && s.attempt > 1 && s.violations.length) {
     lines.push(
       ` ${theme.paint("!", "yellow")} ${theme.paint(`synthesis violated ${s.violations.length} gate(s)`, "text")} ${theme.paint("· re-prompting with the exact breaches", "dim")}`,