@saadnvd1/agent-os 0.3.738 → 0.3.742

package/lib/chat/drivers/edit-guard.ts

@@ -0,0 +1,311 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { agentosHome } from "../../agentos-home";
+
+// What a model needs after an edit goes wrong, for Pi and OpenCode alike
+// (their edit tools are theirs, so this runs beside them as an extension and
+// a plugin):
+//
+// - an edit whose old text isn't in the file is refused before it runs, with
+//   the file's current text around the closest match, and a repeat of an edit
+//   that already failed is called out;
+// - after an edit or write to a TypeScript or JavaScript file, new syntax
+//   errors and block-scoped names declared twice come back in the tool result.
+//
+// Plain ESM with no imports beyond node's, so Node (Pi) and Bun (OpenCode)
+// both run it. It never throws and never blocks on anything it can't read.
+// Written as a string, like the other extensions, and exported for its test.
+export const EDIT_GUARD_LIB = String.raw`import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, resolve } from "node:path";
+
+const SOURCE = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+const MAX_BYTES = 1048576;
+const MAX_REPORTED = 10;
+const EXCERPT_LINES = 40;
+const EXCERPT_CHARS = 3000;
+
+const norm = (s) => String(s).replace(/\r\n/g, "\n");
+const trimmed = (s) => norm(s).split("\n").map((l) => l.trim());
+const collapse = (s) => norm(s).replace(/\s+/g, " ").trim();
+
+export function readText(file) {
+  try {
+    if (statSync(file).size > MAX_BYTES) return null;
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export const absolute = (file, cwd) =>
+  resolve(cwd || process.cwd(), String(file).replace(/^@/, ""));
+
+function needLines(old) {
+  const need = trimmed(old);
+  while (need.length && need[need.length - 1] === "") need.pop();
+  while (need.length && need[0] === "") need.shift();
+  return need;
+}
+
+// Whether any of the harnesses' matchers could find this text: exact, line by
+// line without indentation, with whitespace collapsed, or by its first and
+// last lines. Only text none of them find is refused, so an edit a harness
+// would have accepted is never blocked here.
+export function isFound(text, old) {
+  if (typeof old !== "string" || !old.trim()) return true;
+  if (text.includes(old) || norm(text).includes(norm(old))) return true;
+  const hay = trimmed(text);
+  const need = needLines(old);
+  if (!need.length) return true;
+  for (let i = 0; i + need.length <= hay.length; i++) {
+    let same = true;
+    for (let j = 0; j < need.length && same; j++) same = hay[i + j] === need[j];
+    if (same) return true;
+  }
+  if (collapse(text).includes(collapse(old))) return true;
+  if (need.length >= 3) {
+    const last = need[need.length - 1];
+    for (let i = 0; i < hay.length; i++) {
+      if (hay[i] !== need[0]) continue;
+      const to = Math.min(hay.length, i + need.length + 10);
+      for (let k = i + 2; k < to; k++) if (hay[k] === last) return true;
+    }
+  }
+  return false;
+}
+
+// The file's lines around where the old text most likely was, numbered, or
+// null when nothing in the file resembles it.
+export function closestMatch(text, old) {
+  const lines = norm(text).split("\n");
+  const hay = lines.map((l) => l.trim());
+  const need = trimmed(old);
+  const real = need.filter((l) => l.length > 2);
+  if (!real.length) return null;
+  const anchor = real.reduce((a, b) => (b.length > a.length ? b : a));
+  const offset = need.indexOf(anchor);
+  let hits = [];
+  hay.forEach((l, i) => l === anchor && hits.push(i));
+  if (!hits.length) hay.forEach((l, i) => l.length > 2 && (l.includes(anchor) || anchor.includes(l)) && hits.push(i));
+  if (!hits.length) {
+    const words = (l) => new Set(l.toLowerCase().split(/[^a-z0-9_$]+/).filter(Boolean));
+    const want = words(anchor);
+    let top = 0.5;
+    hay.forEach((l, i) => {
+      const have = words(l);
+      let shared = 0;
+      for (const w of have) if (want.has(w)) shared++;
+      const dice = (2 * shared) / (want.size + have.size || 1);
+      if (dice > top) {
+        top = dice;
+        hits = [i];
+      }
+    });
+  }
+  if (!hits.length) return null;
+  let best = { score: -1, start: 0 };
+  for (const h of hits.slice(0, 200)) {
+    const start = Math.max(0, h - offset);
+    let score = 0;
+    for (let j = 0; j < need.length; j++) if (hay[start + j] === need[j] && need[j]) score++;
+    if (score > best.score) best = { score, start };
+  }
+  const from = Math.max(0, best.start - 3);
+  const to = Math.min(lines.length, best.start + need.length + 3);
+  let shown = lines.slice(from, to);
+  if (shown.length > EXCERPT_LINES) shown = shown.slice(0, EXCERPT_LINES);
+  let excerpt = shown.map((l, i) => (from + i + 1) + "\t" + l).join("\n");
+  if (excerpt.length > EXCERPT_CHARS) excerpt = excerpt.slice(0, EXCERPT_CHARS) + "\n…";
+  return { from: from + 1, to: from + shown.length, excerpt };
+}
+
+export function failureMessage(file, old, text, repeat) {
+  const near = closestMatch(text, old);
+  const out = [
+    "The old text was not found in " + file + ". The file is not what this edit assumes: it changed since you last read it, or the text is not exactly what is there.",
+  ];
+  if (repeat >= 2)
+    out.push("This is the same edit (same file, same old text) that has already failed " + (repeat - 1) + " time" + (repeat > 2 ? "s" : "") + ". Do not send it again unchanged.");
+  if (near) out.push("The file's current text near the closest match (lines " + near.from + "-" + near.to + "):", near.excerpt);
+  else out.push("Nothing in the file resembles that text (" + norm(text).split("\n").length + " lines).");
+  out.push("Read " + file + " again and build the edit from what is there now.");
+  return out.join("\n");
+}
+
+// Failed edits by file and old text, so a repeat can be named. A read, a
+// successful edit or a write of the file starts it over.
+export class FailureLog {
+  constructor() {
+    this.counts = new Map();
+  }
+  key(file, old) {
+    return file + "\0" + createHash("sha1").update(String(old)).digest("hex");
+  }
+  record(file, old) {
+    const key = this.key(file, old);
+    const n = (this.counts.get(key) || 0) + 1;
+    this.counts.set(key, n);
+    return n;
+  }
+  clear(file) {
+    for (const key of [...this.counts.keys()]) if (key.startsWith(file + "\0")) this.counts.delete(key);
+  }
+}
+
+// The refusal for an edit whose old text isn't in the file, or null to let
+// it run. Several edits to one file: the first missing one is named.
+export function guardEdit(log, file, oldTexts, cwd) {
+  try {
+    const path = absolute(file, cwd);
+    const text = readText(path);
+    if (text == null) return null;
+    const missing = oldTexts.find((o) => !isFound(text, o));
+    if (missing === undefined) return null;
+    return failureMessage(file, missing, text, log.record(path, missing));
+  } catch {
+    return null;
+  }
+}
+
+const tsByRoot = new Map();
+function loadTs(cwd) {
+  const root = resolve(cwd || process.cwd());
+  const cacheKey = root + "|" + (process.env.AGENTOS_TYPESCRIPT || "");
+  if (tsByRoot.has(cacheKey)) return tsByRoot.get(cacheKey);
+  let found = null;
+  const tries = [
+    () => createRequire(resolve(root, "package.json"))("typescript"),
+    () => (process.env.AGENTOS_TYPESCRIPT ? createRequire(import.meta.url)(process.env.AGENTOS_TYPESCRIPT) : null),
+  ];
+  for (const t of tries) {
+    try {
+      const m = t();
+      if (m && typeof m.createSourceFile === "function") {
+        found = m;
+        break;
+      }
+    } catch {}
+  }
+  tsByRoot.set(cacheKey, found);
+  return found;
+}
+
+function bindingNames(ts, name, out) {
+  if (ts.isIdentifier(name)) out.push(name);
+  else for (const el of name.elements) if (!ts.isOmittedExpression(el)) bindingNames(ts, el.name, out);
+}
+
+function duplicates(ts, sf) {
+  const found = [];
+  const check = (statements) => {
+    const lexical = new Map();
+    const hoisted = new Map();
+    const add = (map, id, kind) => {
+      const line = sf.getLineAndCharacterOfPosition(id.getStart(sf)).line + 1;
+      if (!map.has(id.text)) map.set(id.text, []);
+      map.get(id.text).push({ kind, line });
+    };
+    for (const st of statements) {
+      if (ts.isVariableStatement(st)) {
+        const flags = st.declarationList.flags;
+        const kind = flags & ts.NodeFlags.Const ? "const" : flags & ts.NodeFlags.Let ? "let" : "var";
+        const ids = [];
+        for (const d of st.declarationList.declarations) bindingNames(ts, d.name, ids);
+        for (const id of ids) add(kind === "var" ? hoisted : lexical, id, kind);
+      } else if (ts.isClassDeclaration(st) && st.name) add(lexical, st.name, "class");
+      else if (ts.isFunctionDeclaration(st) && st.name) add(hoisted, st.name, "function");
+    }
+    for (const [name, at] of lexical) {
+      const all = at.concat(hoisted.get(name) || []);
+      if (all.length > 1) found.push({ name, kind: at[0].kind, lines: all.map((a) => a.line).sort((a, b) => a - b) });
+    }
+  };
+  const visit = (node) => {
+    if (ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)) check(node.statements);
+    else if (ts.isCaseBlock(node)) check(node.clauses.flatMap((c) => [...c.statements]));
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return found;
+}
+
+function problems(ts, file, text) {
+  const out = [];
+  const t = ts.transpileModule(text, {
+    fileName: file,
+    reportDiagnostics: true,
+    compilerOptions: { jsx: ts.JsxEmit.Preserve, target: ts.ScriptTarget.Latest, isolatedModules: true },
+  });
+  for (const d of t.diagnostics || []) {
+    const at = d.file && d.start != null ? d.file.getLineAndCharacterOfPosition(d.start) : null;
+    const message = ts.flattenDiagnosticMessageText(d.messageText, " ");
+    out.push({ key: message, text: (at ? (at.line + 1) + ":" + (at.character + 1) + " " : "") + message });
+  }
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+  for (const d of duplicates(ts, sf))
+    out.push({
+      key: "duplicate " + d.name,
+      text: d.kind + " " + d.name + " is declared more than once in the same block (lines " + d.lines.join(", ") + ")",
+    });
+  return out;
+}
+
+// What an edit broke in a source file: the problems it has now that it didn't
+// before, as text for the tool result, or "" when there are none, the file
+// isn't source, or TypeScript can't be loaded. Syntax only, never types.
+export function syntaxReport(file, before, after, cwd) {
+  try {
+    if (!SOURCE.has(extname(file).toLowerCase()) || typeof after !== "string" || after.length > MAX_BYTES) return "";
+    const ts = loadTs(cwd);
+    if (!ts) return "";
+    const had = new Map();
+    for (const p of before == null || before.length > MAX_BYTES ? [] : problems(ts, file, before)) had.set(p.key, (had.get(p.key) || 0) + 1);
+    const fresh = [];
+    for (const p of problems(ts, file, after)) {
+      const n = had.get(p.key) || 0;
+      if (n > 0) had.set(p.key, n - 1);
+      else fresh.push(p);
+    }
+    if (!fresh.length) return "";
+    const shown = fresh.slice(0, MAX_REPORTED).map((p) => "- " + p.text);
+    if (fresh.length > shown.length) shown.push("- and " + (fresh.length - shown.length) + " more");
+    return "[AgentOS syntax check] This change left problems in " + file + " that were not there before. Fix them now:\n" + shown.join("\n");
+  } catch {
+    return "";
+  }
+}
+`;
+
+const dir = () => agentosHome("edit-guard");
+
+// Owner-only, like the other extension folders.
+export function writeEditGuard(
+  name: string,
+  source: string,
+  folder = dir()
+): string {
+  fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+  fs.chmodSync(folder, 0o700);
+  for (const [file, text] of [
+    ["agentos-edit-guard-lib.mjs", EDIT_GUARD_LIB],
+    [name, source],
+  ]) {
+    const target = path.join(folder, file);
+    if (!fs.existsSync(target) || fs.readFileSync(target, "utf8") !== text)
+      fs.writeFileSync(target, text);
+  }
+  return path.join(folder, name);
+}
+
+// The TypeScript this server runs on, for projects that have none of their
+// own, or undefined where there isn't one.
+export function typescriptPath(): string | undefined {
+  try {
+    return createRequire(import.meta.url).resolve("typescript");
+  } catch {
+    return undefined;
+  }
+}

package/lib/chat/drivers/opencode-config.ts

@@ -0,0 +1,111 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { pathToFileURL } from "url";
+
+type P = Record<string, unknown>;
+
+// How long OpenCode waits for a model server's response headers (its default
+// is 5 minutes). A local model chewing through a long context sends nothing
+// until it has read all of it, and a retry at the same limit fails the same
+// way. The wait between chunks of a streamed reply keeps OpenCode's own 5
+// minute limit, so a stream that started is judged on idle time and a server
+// that never answers still ends the request.
+export const HEADER_TIMEOUT_MS = 1_200_000;
+
+const isObject = (v: unknown): v is P =>
+  !!v && typeof v === "object" && !Array.isArray(v);
+
+// JSON with comments and trailing commas (OpenCode's config allows both),
+// parsed without touching what is inside strings. Null when it isn't JSON.
+export function parseJsonc(text: string): P | null {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end < 0 ? text.length : end + 1;
+    } else out += c;
+  }
+  try {
+    const v: unknown = JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+    return isObject(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+function read(file: string): P | null {
+  try {
+    return parseJsonc(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function userConfigs(cwd: string, env: NodeJS.ProcessEnv): P[] {
+  const home = env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  const files = [
+    ...["opencode.json", "opencode.jsonc", "config.json"].map((f) =>
+      path.join(home, "opencode", f)
+    ),
+    ...(env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []),
+    ...["opencode.json", "opencode.jsonc"].flatMap((f) => [
+      path.join(cwd, f),
+      path.join(cwd, ".opencode", f),
+    ]),
+  ];
+  return files.map(read).filter((c): c is P => !!c);
+}
+
+// The OPENCODE_CONFIG_CONTENT for one conversation: the user's own value
+// (never replaced, their providers are in it) plus the edit guard plugin and
+// a longer header wait for each provider in their config and for the
+// conversation's model, unless they set one themselves.
+export function openCodeConfigContent(o: {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  // "provider/model", the conversation's.
+  model?: string;
+  pluginFile?: string;
+}): string {
+  const given = o.env.OPENCODE_CONFIG_CONTENT;
+  const base = given ? parseJsonc(given) : {};
+  if (!base) return given as string;
+
+  const own = new Set<string>();
+  const set = new Set<string>();
+  const slash = o.model?.indexOf("/") ?? -1;
+  if (o.model && slash > 0) set.add(o.model.slice(0, slash));
+  for (const c of [...userConfigs(o.cwd, o.env), base]) {
+    if (!isObject(c.provider)) continue;
+    for (const [id, p] of Object.entries(c.provider)) {
+      set.add(id);
+      const options = isObject(p) && isObject(p.options) ? p.options : {};
+      if (options.headerTimeout !== undefined) own.add(id);
+    }
+  }
+
+  const provider: P = isObject(base.provider) ? { ...base.provider } : {};
+  for (const id of set) {
+    if (own.has(id)) continue;
+    const p = isObject(provider[id]) ? (provider[id] as P) : {};
+    const options = isObject(p.options) ? p.options : {};
+    provider[id] = {
+      ...p,
+      options: { ...options, headerTimeout: HEADER_TIMEOUT_MS },
+    };
+  }
+
+  const plugin = Array.isArray(base.plugin) ? [...base.plugin] : [];
+  if (o.pluginFile) plugin.push(pathToFileURL(o.pluginFile).href);
+  return JSON.stringify({ ...base, provider, plugin });
+}

package/lib/chat/drivers/opencode-mapper.ts

@@ -2,12 +2,16 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { openCodeTool } from "./opencode-rules";
 import { TurnItems } from "./turn-items";
-import { logTurnEnd, turnOutcome } from "./turn-outcome";
+import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
+import { retryNotice, TurnRetry, type RetryDecision } from "./transient-retry";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
 const num = (v: unknown) => Number(v) || 0;
 
+// A prompt this big (tokens) is worth compacting before the last retry.
+const HEAVY_TOKENS = 16_000;
+
 const TODO = new Set(["pending", "in_progress", "completed"]);
 
 // OpenCode's event stream as chat items, for one session (its subagents'
@@ -37,6 +41,10 @@ export class OpenCodeMapper {
     calls: new Set<string>(),
   };
   private aborted = false;
+  // Tool calls this turn, kept through the nudged run that continues it.
+  private toolIds = new Set<string>();
+  private nudged = false;
+  private nudgeDue = false;
   // Idle from before the prompt is stale until the session goes busy.
   private admitted = false;
   totals: UsageTotals = {
@@ -47,15 +55,34 @@ export class OpenCodeMapper {
     cacheWriteTokens: 0,
   };
 
+  // Retrying a turn the model's server dropped.
+  readonly retry = new TurnRetry();
+  // OpenCode retried the failure itself: AgentOS adds nothing on top.
+  private agentRetried = false;
+  // The last answer's prompt size, to judge whether compacting would help.
+  lastInputTokens = 0;
+  // Compacting between retries makes the session busy and idle: not a turn.
+  private holding = false;
+
   constructor(
     private sessionId: () => string | null,
-    private emit: (e: DriverEvent) => void
+    private emit: (e: DriverEvent) => void,
+    // Called when a failed turn is to be tried again.
+    private onRetry: (
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string
+    ) => void = () => {}
   ) {
     this.items = new TurnItems(emit);
   }
 
-  // A prompt went out: its turn starts now.
-  prompted(): void {
+  // A prompt went out: its turn starts now. A retry is the same turn.
+  prompted(retried = false): void {
+    this.retrying = false;
+    if (!retried) {
+      this.retry.reset();
+      this.agentRetried = false;
+    }
     this.admitted = false;
     this.items.startTurn();
   }
@@ -66,9 +93,18 @@ export class OpenCodeMapper {
     switch (e.type) {
       case "session.status": {
         const type = str((p.status as P)?.type);
+        if (type === "retry") this.agentRetried = true;
         if (type === "busy" || type === "retry") {
           this.admitted = true;
           this.items.startTurn();
+          if (type === "retry") {
+            const st = p.status as P;
+            this.emit({
+              type: "model_retry",
+              attempt: num(st.attempt) || 1,
+              message: str(st.message) || undefined,
+            });
+          }
         } else if (type === "idle") this.idle();
         return;
       }
@@ -125,6 +161,12 @@ export class OpenCodeMapper {
     this.counted.add(id);
     const t = (info.tokens ?? {}) as P;
     const cache = (t.cache ?? {}) as P;
+    this.lastInputTokens = num(t.input) + num(cache.read);
+    if (this.lastInputTokens + num(cache.write) > 0)
+      this.emit({
+        type: "prompt_tokens",
+        tokens: this.lastInputTokens + num(cache.write),
+      });
     this.totals = {
       costUsd: this.totals.costUsd + num(info.cost),
       inputTokens: this.totals.inputTokens + num(t.input),
@@ -157,6 +199,7 @@ export class OpenCodeMapper {
       return;
     }
     if (part.type === "tool") {
+      this.toolIds.add(id);
       if (this.last.id === str(part.messageID)) this.last.calls.add(id);
       this.tool(id, part);
     }
@@ -183,7 +226,9 @@ export class OpenCodeMapper {
     if (tool === "todowrite" || status === "pending") return;
     const start = openCodeTool(tool, state.input);
     if (!this.items.hasTool(id)) this.items.tool(id, start);
-    if (status === "completed")
+    if (status === "running")
+      this.items.progress(id, str((state.metadata as P | undefined)?.output));
+    else if (status === "completed")
       this.items.toolDone(id, "done", str(state.output), start);
     else if (status === "error")
       this.items.toolDone(id, "error", str(state.error), start);
@@ -197,10 +242,72 @@ export class OpenCodeMapper {
         str((error.data as P)?.message) || str(error.name) || "OpenCode failed";
   }
 
+  // A turn that failed on a dropped request goes on in place: the notice,
+  // then the driver sends the prompt again. False when it should end.
+  private retryTurn(): boolean {
+    const error = this.error ?? "";
+    const d = this.retry.next({
+      error,
+      harnessRetried: this.agentRetried,
+      contextHeavy: this.lastInputTokens >= HEAVY_TOKENS,
+    });
+    if (!d.retry) return false;
+    this.items.note(retryNotice(d, error));
+    this.clearTurn();
+    this.retrying = true;
+    this.onRetry(d, error);
+    return true;
+  }
+
+  private clearTurn(): void {
+    this.error = null;
+    this.last.id = "";
+    this.toolIds.clear();
+    this.aborted = false;
+    this.admitted = false;
+    for (const id of this.current) this.past.add(id);
+    this.current.clear();
+    this.parts.clear();
+  }
+
+  // A failed turn is waiting for its retry to go out.
+  retrying = false;
+
+  // The reader stopped the turn while it waited to retry.
+  stopRetrying(): void {
+    this.retrying = false;
+    this.holding = false;
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    this.items.endTurn({ interrupted: true });
+  }
+
+  holdIdle(on: boolean): void {
+    this.holding = on;
+  }
+
   private idle(): void {
-    if (!this.admitted || !this.items.inTurn) return;
+    if (this.holding || !this.admitted || !this.items.inTurn) return;
+    if (this.error && !this.aborted && this.retryTurn()) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
     const text = [...this.last.text.values()].join("\n");
+    if (
+      !this.nudged &&
+      needsSummary({
+        toolsRun: this.toolIds.size,
+        text,
+        toolCalls: this.last.calls.size,
+        finishReason: this.last.finish,
+        error: this.error ?? undefined,
+        aborted: this.aborted,
+      })
+    ) {
+      // The turn stays open: the driver asks for the summary, once.
+      this.nudged = this.nudgeDue = true;
+      this.last.id = "";
+      this.admitted = false;
+      console.info("[chat] asked the model for its results summary");
+      return;
+    }
     const ended =
       this.aborted || !this.last.id
         ? undefined
@@ -209,6 +316,9 @@ export class OpenCodeMapper {
             text,
             toolCalls: this.last.calls.size,
             error: this.error ?? undefined,
+            retries: this.retry.tried,
+            agentRetried: this.agentRetried,
+            summary: this.items.summary(),
           });
     if (ended)
       logTurnEnd({
@@ -225,13 +335,15 @@ export class OpenCodeMapper {
       finishReason: this.last.finish || undefined,
       ended,
     });
-    this.error = null;
-    this.last.id = "";
-    this.aborted = false;
-    this.admitted = false;
-    for (const id of this.current) this.past.add(id);
-    this.current.clear();
-    this.parts.clear();
+    this.clearTurn();
+    this.nudged = this.nudgeDue = false;
+  }
+
+  // True once after a turn ended without its results: send SUMMARY_NUDGE.
+  takeNudge(): boolean {
+    const due = this.nudgeDue;
+    this.nudgeDue = false;
+    return due;
   }
 
   // The prompt never reached a busy session (it failed, or finished before