loom-agent 1.2.37 → 1.3.2

package/src/core/session-store.js

@@ -1,167 +1,245 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const SESSION_SCHEMA_VERSION = 2;
-
-const LOOM_DIR = path.join(os.homedir(), '.loom');
-const SESSIONS_DIR = path.join(LOOM_DIR, 'sessions');
-
-// Re-evaluated on every call so tests can isolate with LOOM_CONFIG_DIR.
-function sessionsDir() {
-  return path.join(process.env.LOOM_CONFIG_DIR || LOOM_DIR, 'sessions');
-}
-
-function ensureDir() {
-  const d = sessionsDir();
-  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
-}
-
-function convId() {
-  return Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6);
-}
-
-// Coerce whatever came off disk (hand-edited, corrupt, older schema) into the
-// guaranteed current shape: { id, createdAt, schemaVersion, messages } with
-// every message having { role, content } while preserving any extra fields.
-function normalizeSession(data) {
-  if (!data || typeof data !== 'object') return null;
-  const raw = Array.isArray(data.messages) ? data.messages : [];
-  const messages = raw.map((m) => {
-    if (!m || typeof m !== 'object') return { role: 'user', content: '' };
-    const { role, content, ...rest } = m;
-    return { role: role || 'user', content: typeof content === 'undefined' ? '' : content, ...rest };
-  });
-  return {
-    id: typeof data.id === 'string' ? data.id : null,
-    createdAt: typeof data.createdAt === 'string' ? data.createdAt : null,
-    schemaVersion: typeof data.schemaVersion === 'number' ? data.schemaVersion : 1,
-    messages,
-  };
-}
-
-// Session IDs become file names — keep them strictly alphanumeric to rule out
-// path traversal via loadSession/deleteSession (e.g. "../../secrets").
-const ID_RX = /^[a-zA-Z0-9_-]{3,128}$/;
-function isValidSessionId(id) {
-  return typeof id === 'string' && ID_RX.test(id);
-}
-
-function saveSession(session) {
-  ensureDir();
-  const id = isValidSessionId(session.conversationId) ? session.conversationId : convId();
-  const now = new Date().toISOString();
-  // Overwriting an existing session keeps its original createdAt (it is the
-  // same conversation); updatedAt always reflects this write.
-  let createdAt = now;
-  const existingFile = path.join(sessionsDir(), id + '.json');
-  if (fs.existsSync(existingFile)) {
-    try {
-      const prev = JSON.parse(fs.readFileSync(existingFile, 'utf8'));
-      if (prev && typeof prev.createdAt === 'string') createdAt = prev.createdAt;
-    } catch {}
-  }
-  const data = {
-    id,
-    schemaVersion: SESSION_SCHEMA_VERSION,
-    createdAt,
-    updatedAt: now,
-    messages: session.messages || [],
-    provider: session.config ? session.config.provider : null,
-    model: session.config && session.config.model ? session.config.model[session.config.provider] : null,
-  };
-  const f = path.join(sessionsDir(), id + '.json');
-  fs.writeFileSync(f, JSON.stringify(data, null, 2));
-  return { id, file: f };
-}
-
-function listSessions() {
-  ensureDir();
-  const files = fs.readdirSync(sessionsDir()).filter((f) => f.endsWith('.json'));
-  const list = files.map((f) => {
-    const p = path.join(sessionsDir(), f);
-    try {
-      const data = JSON.parse(fs.readFileSync(p, 'utf8'));
-      let mtime = null;
-      try { mtime = fs.statSync(p).mtime.toISOString(); } catch {}
-      return {
-        id: data.id || f.replace('.json', ''),
-        createdAt: data.createdAt,
-        updatedAt: data.updatedAt,
-        mtime,
-        messageCount: (data.messages || []).length,
-        provider: data.provider,
-        model: data.model,
-      };
-    } catch {
-      let mtime = null;
-      try { mtime = fs.statSync(p).mtime.toISOString(); } catch {}
-      return { id: f.replace('.json', ''), createdAt: null, updatedAt: null, mtime, messageCount: 0 };
-    }
-  });
-  // Newest first by the last write time (updatedAt, else createdAt, else the
-  // file's own mtime). Sorting by file NAME put legacy "share-*" exports on
-  // top forever ("s" > "m"), burying the real, recent conversations.
-  const stamp = (s) => s.updatedAt || s.createdAt || s.mtime || '';
-  return list.filter((s) => isValidSessionId(s.id)).sort((a, b) => (stamp(b) < stamp(a) ? -1 : stamp(b) > stamp(a) ? 1 : 0));
-}
-
-function loadSession(id) {
-  if (!isValidSessionId(id)) return null;
-  const f = path.join(sessionsDir(), id + '.json');
-  if (!fs.existsSync(f)) return null;
-  try {
-    const raw = JSON.parse(fs.readFileSync(f, 'utf8'));
-    const norm = normalizeSession(raw);
-    if (!norm) return null;
-    norm.id = norm.id || id;
-    norm.file = f;
-    return norm;
-  } catch {
-    return null;
-  }
-}
-
-function deleteSession(id) {
-  if (!isValidSessionId(id)) return false;
-  const f = path.join(sessionsDir(), id + '.json');
-  if (fs.existsSync(f)) {
-    fs.unlinkSync(f);
-    return true;
-  }
-  return false;
-}
-
-function exportChat(session, format) {
-  const type = format || 'md';
-  const msgs = session.messages || [];
-  const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  const file = path.join(process.cwd(), 'loom-chat-' + ts + '.' + type);
-  if (type === 'md') {
-    const lines = ['# Loom Code Chat Export', '', '**Date:** ' + new Date().toLocaleString(), ''];
-    for (const m of msgs) {
-      const role = m.role || 'unknown';
-      lines.push('### ' + role.charAt(0).toUpperCase() + role.slice(1));
-      lines.push('');
-      lines.push(m.content || '(empty)');
-      lines.push('');
-    }
-    fs.writeFileSync(file, lines.join('\n'));
-  } else {
-    const exportLines = msgs.map((m) => m.role + ': ' + (m.content || ''));
-    fs.writeFileSync(file, exportLines.join('\n'));
-  }
-  return file;
-}
-
-module.exports = {
-  saveSession,
-  listSessions,
-  loadSession,
-  deleteSession,
-  exportChat,
-  normalizeSession,
-  isValidSessionId,
-  SESSIONS_DIR,
-  SESSION_SCHEMA_VERSION,
-};
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SESSION_SCHEMA_VERSION = 3;
+
+const LOOM_DIR = path.join(os.homedir(), '.loom');
+
+// Re-evaluated on every call so tests can isolate with LOOM_CONFIG_DIR.
+// Layout is claude-code/opencode style: one folder per session inside the
+// PROJECT's .loom/ directory:
+//
+//   <project>/.loom/sessions/<id>/session.json    metadata
+//   <project>/.loom/sessions/<id>/messages.jsonl  one message per line
+//
+// Flat legacy files (~/.loom/sessions/<id>.json, schema v1/v2) stay
+// readable; the next saveSession migrates them into the project folder.
+function baseDir() {
+  if (process.env.LOOM_CONFIG_DIR) return path.join(process.env.LOOM_CONFIG_DIR, 'sessions');
+  return path.join(process.cwd(), '.loom', 'sessions');
+}
+
+// The pre-v3 global store. Same as baseDir() under LOOM_CONFIG_DIR (tests),
+// the user's old ~/.loom/sessions otherwise.
+function legacyDir() {
+  if (process.env.LOOM_CONFIG_DIR) return path.join(process.env.LOOM_CONFIG_DIR, 'sessions');
+  return path.join(LOOM_DIR, 'sessions');
+}
+
+function ensureDir() {
+  const d = baseDir();
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+}
+
+function convId() {
+  return Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6);
+}
+
+// Session IDs become folder names — keep them strictly alphanumeric to rule
+// out path traversal via loadSession/deleteSession (e.g. "../../secrets").
+const ID_RX = /^[a-zA-Z0-9_-]{3,128}$/;
+function isValidSessionId(id) {
+  return typeof id === 'string' && ID_RX.test(id);
+}
+
+// Coerce whatever came off disk (hand-edited, corrupt, older schema) into the
+// guaranteed current shape: { id, createdAt, schemaVersion, messages } with
+// every message having { role, content } while preserving any extra fields.
+// Snake-case tool fields from old saves are aliased to camelCase so a resumed
+// session can always rebuild a valid provider payload (toolCallId is sent as
+// tool_call_id / tool_use_id — losing it 400s on strict providers).
+function normalizeSession(data) {
+  if (!data || typeof data !== 'object') return null;
+  const raw = Array.isArray(data.messages) ? data.messages : [];
+  const messages = raw.map((m) => {
+    if (!m || typeof m !== 'object') return { role: 'user', content: '' };
+    const { role, content, ...rest } = m;
+    const out = { role: role || 'user', content: typeof content === 'undefined' ? '' : content, ...rest };
+    if (!out.toolCalls && Array.isArray(rest.tool_calls)) out.toolCalls = rest.tool_calls;
+    if (!out.toolCallId && rest.tool_call_id) out.toolCallId = rest.tool_call_id;
+    return out;
+  });
+  return {
+    id: typeof data.id === 'string' ? data.id : null,
+    createdAt: typeof data.createdAt === 'string' ? data.createdAt : null,
+    schemaVersion: typeof data.schemaVersion === 'number' ? data.schemaVersion : 1,
+    messages,
+  };
+}
+
+function sessionFolder(id) {
+  return path.join(baseDir(), id);
+}
+
+function readFolderSession(id) {
+  const dir = sessionFolder(id);
+  const metaFile = path.join(dir, 'session.json');
+  if (!fs.existsSync(metaFile)) return null;
+  try {
+    const meta = JSON.parse(fs.readFileSync(metaFile, 'utf8'));
+    const messages = [];
+    const msgFile = path.join(dir, 'messages.jsonl');
+    if (fs.existsSync(msgFile)) {
+      const lines = fs.readFileSync(msgFile, 'utf8').split('\n');
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t) continue;
+        try { messages.push(JSON.parse(t)); } catch {}
+      }
+    }
+    const norm = normalizeSession({ ...meta, messages });
+    if (!norm) return null;
+    norm.id = norm.id || id;
+    norm.file = metaFile;
+    norm.dir = dir;
+    return norm;
+  } catch {
+    return null;
+  }
+}
+
+function readFlatSession(dir, id) {
+  const f = path.join(dir, id + '.json');
+  if (!fs.existsSync(f)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(f, 'utf8'));
+    const norm = normalizeSession(raw);
+    if (!norm) return null;
+    norm.id = norm.id || id;
+    norm.file = f;
+    return norm;
+  } catch {
+    return null;
+  }
+}
+
+function saveSession(session) {
+  ensureDir();
+  const id = isValidSessionId(session.conversationId) ? session.conversationId : convId();
+  const now = new Date().toISOString();
+  // Overwriting an existing session keeps its original createdAt (it is the
+  // same conversation); updatedAt always reflects this write.
+  let createdAt = now;
+  const prev = readFolderSession(id) || readFlatSession(baseDir(), id) || readFlatSession(legacyDir(), id);
+  if (prev && typeof prev.createdAt === 'string') createdAt = prev.createdAt;
+  const messages = session.messages || [];
+  const data = {
+    id,
+    schemaVersion: SESSION_SCHEMA_VERSION,
+    createdAt,
+    updatedAt: now,
+    provider: session.config ? session.config.provider : null,
+    model: session.config && session.config.model ? session.config.model[session.config.provider] : null,
+    messageCount: messages.length,
+  };
+  const dir = sessionFolder(id);
+  fs.mkdirSync(dir, { recursive: true });
+  const metaFile = path.join(dir, 'session.json');
+  // Write messages first, metadata last: a crash mid-save leaves the old
+  // session.json pointing at a complete messages file, never the reverse.
+  const msgFile = path.join(dir, 'messages.jsonl');
+  const tmp = msgFile + '.tmp';
+  fs.writeFileSync(tmp, messages.map((m) => JSON.stringify(m)).join('\n') + (messages.length ? '\n' : ''));
+  fs.renameSync(tmp, msgFile);
+  fs.writeFileSync(metaFile, JSON.stringify(data, null, 2));
+  return { id, file: metaFile, dir };
+}
+
+function listDir(dir, fromFolder) {
+  let names;
+  try { names = fs.readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const name of names) {
+    if (fromFolder) {
+      const entry = readFolderSession(name);
+      if (entry && isValidSessionId(entry.id)) out.push(entry);
+    } else if (name.endsWith('.json')) {
+      const id = name.replace(/\.json$/, '');
+      const entry = readFlatSession(dir, id);
+      if (entry && isValidSessionId(entry.id)) out.push(entry);
+    }
+  }
+  return out;
+}
+
+function listSessions() {
+  ensureDir();
+  // Newest first by the last write time (updatedAt, else createdAt). Folder
+  // sessions shadow same-id flat files (a migrated session must not appear
+  // twice). Legacy ~/.loom/sessions files stay listed so old history remains
+  // reachable after upgrading to the per-project folder layout.
+  const byId = new Map();
+  for (const s of listDir(legacyDir(), false)) byId.set(s.id, s);
+  for (const s of listDir(baseDir(), false)) byId.set(s.id, s);
+  for (const s of listDir(baseDir(), true)) byId.set(s.id, s);
+  const list = [...byId.values()].map((data) => {
+    let mtime = null;
+    try { mtime = fs.statSync(data.file).mtime.toISOString(); } catch {}
+    return {
+      id: data.id,
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt,
+      mtime,
+      messageCount: data.messageCount || (data.messages || []).length,
+      provider: data.provider,
+      model: data.model,
+    };
+  });
+  const stamp = (s) => s.updatedAt || s.createdAt || s.mtime || '';
+  return list.sort((a, b) => (stamp(b) < stamp(a) ? -1 : stamp(b) > stamp(a) ? 1 : 0));
+}
+
+function loadSession(id) {
+  if (!isValidSessionId(id)) return null;
+  return readFolderSession(id) || readFlatSession(baseDir(), id) || readFlatSession(legacyDir(), id);
+}
+
+function deleteSession(id) {
+  if (!isValidSessionId(id)) return false;
+  let removed = false;
+  const dir = sessionFolder(id);
+  if (fs.existsSync(dir)) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); removed = true; } catch {}
+  }
+  for (const d of new Set([baseDir(), legacyDir()])) {
+    const f = path.join(d, id + '.json');
+    if (fs.existsSync(f)) {
+      try { fs.unlinkSync(f); removed = true; } catch {}
+    }
+  }
+  return removed;
+}
+
+function exportChat(session, format) {
+  const type = format || 'md';
+  const msgs = session.messages || [];
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = path.join(process.cwd(), 'loom-chat-' + ts + '.' + type);
+  if (type === 'md') {
+    const lines = ['# Loom Code Chat Export', '', '**Date:** ' + new Date().toLocaleString(), ''];
+    for (const m of msgs) {
+      const role = m.role || 'unknown';
+      lines.push('### ' + role.charAt(0).toUpperCase() + role.slice(1));
+      lines.push('');
+      lines.push(m.content || '(empty)');
+      lines.push('');
+    }
+    fs.writeFileSync(file, lines.join('\n'));
+  } else {
+    const exportLines = msgs.map((m) => m.role + ': ' + (m.content || ''));
+    fs.writeFileSync(file, exportLines.join('\n'));
+  }
+  return file;
+}
+
+module.exports = {
+  saveSession,
+  listSessions,
+  loadSession,
+  deleteSession,
+  exportChat,
+  normalizeSession,
+  isValidSessionId,
+  SESSION_SCHEMA_VERSION,
+};

package/src/core/session.js

@@ -26,11 +26,29 @@ const COMPACT_MIN_MESSAGES = 6;
 // Drive-to-completion: how many continuation nudges one turn may spend when
 // the model stops with todos still unfinished (the "stops between tasks"
 // failure). Capped so a model that refuses to update its todos cannot spin.
-const MAX_DRIVE_NUDGES = 5;
+const MAX_DRIVE_NUDGES = 8;
+// Empty-reply nudges per turn (provider hiccup / reasoning-only stop).
+const MAX_EMPTY_NUDGES = 3;
+// finish_reason=length (output budget exhausted) auto-continues the turn
+// this many times before surfacing the truncation placeholder. This is the
+// #1 cause of "stops in the middle" with reasoning models: thinking eats
+// the whole max_tokens budget and the answer never streams.
+const MAX_TRUNCATION_CONTINUES = 5;
 // Transient provider failures (network blip, 5xx, stream reset) retry the
 // model call this many times before the turn surfaces an error.
 const PROVIDER_RETRIES = 2;
 
+// Does this reply sound like the model stopped in the MIDDLE of working?
+// Used when todos exist but weren't touched this turn: a short reply, or a
+// long one that ends on a continuation promise ("Now I will…", "Next, …"),
+// an open colon, or an ellipsis is unfinished. A full explanation is not.
+function looksUnfinished(text) {
+  const t = String(text || '').trim();
+  if (!t) return true;
+  if (t.length < 320) return true;
+  return /(?:\b(?:now|next|then|let me|i'?ll|going to|proceeding)\b[^.!?]*[.!]?\s*$)|[:…]$|\.\.\.\s*$/i.test(t);
+}
+
 /**
  * @typedef {Object} SpeedStats
  * @property {number} _turnStart
@@ -405,6 +423,19 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
     this.messages.push(msg);
   }
 
+  // Remove a trailing empty assistant row (no text, no toolCalls). getResponse
+  // appends the assistant message even when the provider returned nothing —
+  // Anthropic rejects empty assistant content with a 400 on the next call, so
+  // continuation paths drop the row before adding their user nudge.
+  _dropTrailingEmptyAssistant() {
+    const last = this.messages[this.messages.length - 1];
+    if (last && last.role === 'assistant' && !(last.toolCalls || []).length && !String(last.content || '').trim()) {
+      this.messages.pop();
+      return true;
+    }
+    return false;
+  }
+
   // ─── Todo state ───
   // The todowrite tool persists into the session so the sidebar shows the
   // real, up-to-date task list instead of regex-scanning replies.
@@ -568,10 +599,11 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
     // No tool-use cap: the model decides when a turn is finished; the user can
     // always Esc-interrupt a runaway loop.
     let ranTools = false;
-    let nudged = false;
+    let emptyNudges = 0;
     let toolCallsThisTurn = 0;
     // Drive-to-completion state (see the no-toolCalls branch below).
     let driveNudges = 0;
+    let truncContinues = 0;
     let todowroteThisTurn = false;
     // Transient provider-error retry state.
     let providerRetries = 0;
@@ -644,30 +676,58 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
 
       if (!toolCalls.length) {
         const text = String(resp.content || '');
+
+        // Truncation auto-continue: finish_reason=length means the reply was
+        // CUT OFF by maxTokens — common with reasoning models (thinking eats
+        // the budget, the final answer never streams). Instead of dead-ending
+        // with a placeholder (the classic "stops in the middle"), continue the
+        // turn. Empty-content truncations also drop the empty assistant row
+        // from history — Anthropic 400s on empty assistant messages.
+        if (!this.interrupted && resp.finishReason === 'length' && truncContinues < MAX_TRUNCATION_CONTINUES) {
+          truncContinues++;
+          if (!text.trim()) this._dropTrailingEmptyAssistant();
+          const at = text.trim() ? text.replace(/\s+/g, ' ').trim().slice(-160) : null;
+          this.addMessage({
+            role: 'user',
+            content: '(your reply was cut off by the output-token limit' +
+              (at ? ' right after: \u2026' + at : ' before any text streamed') +
+              ' \u2014 continue exactly from there and finish the task. Keep the remaining reply compact so it fits.)',
+          });
+          continue;
+        }
+
         // Silent-stop guard: models occasionally end a turn with an EMPTY
-        // reply right after running tools (truncation / provider hiccup),
-        // which reads to the user like "the agent just stopped". One
-        // automatic continuation instead of dead-ending with a placeholder.
-        if (!text.trim() && ranTools && !nudged && !this.interrupted) {
-          nudged = true;
+        // reply — right after running tools (truncation / provider hiccup)
+        // or even on a plain first reply (reasoning-only stop, content
+        // filter). Automatic continuation instead of dead-ending with a
+        // placeholder — up to MAX_EMPTY_NUDGES per turn (hiccups repeat).
+        // finish_reason=length skips this: the truncation block above already
+        // spent its budget, and the placeholder below explains why.
+        if (!text.trim() && emptyNudges < MAX_EMPTY_NUDGES && !this.interrupted && resp.finishReason !== 'length') {
+          emptyNudges++;
+          this._dropTrailingEmptyAssistant();
           this.addMessage({
             role: 'user',
-            content: '(the model returned an empty reply after ' + toolCallsThisTurn +
-              ' tool call(s) — continue where you left off and finish the task)',
+            content: ranTools
+              ? '(the model returned an empty reply after ' + toolCallsThisTurn +
+                ' tool call(s) — continue where you left off and finish the task)'
+              : '(your last reply was empty — respond to the user with text, or use tools to do the work)',
           });
           continue;
         }
         // Drive-to-completion guard: the model stopped calling tools in the
-        // middle of tracked work (todos written this turn still
-        // pending/in_progress). Inject one continuation that quotes the
-        // model's ACTUAL last message and lists the unfinished items — up to
-        // MAX_DRIVE_NUDGES times — so a premature summary does not strand the
-        // task. The model can stop cleanly by completing or cancelling the
-        // items via todowrite. Plan/chat modes are excluded (plan drafts are
-        // meant to end with pending steps).
-        if (!this.interrupted && this.mode === 'build' && ranTools && todowroteThisTurn && driveNudges < MAX_DRIVE_NUDGES) {
+        // middle of tracked work. Two triggers:
+        //  1. todos written THIS turn are still pending/in_progress (the
+        //     strong signal — always nudge), or
+        //  2. tools ran this turn, todos exist, and the reply LOOKS
+        //     unfinished (short / ends on a promise) — catches premature
+        //     wrap-ups from models that never call todowrite.
+        // Up to MAX_DRIVE_NUDGES continuations. Plan/chat modes are excluded
+        // (plan drafts are meant to end with pending steps).
+        if (!this.interrupted && this.mode === 'build' && ranTools && driveNudges < MAX_DRIVE_NUDGES) {
           const unfinished = (this.todos || []).filter((t) => t.status === 'pending' || t.status === 'in_progress');
-          if (unfinished.length) {
+          const gated = todowroteThisTurn || looksUnfinished(text);
+          if (unfinished.length && gated) {
             driveNudges++;
             const list = unfinished.slice(0, 20).map((t) => '- [' + t.status + '] ' + t.content).join('\n');
             // Quote what the model actually said — a canned nudge alone gives
@@ -685,16 +745,21 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
             continue;
           }
         }
-        // Surface WHAT is still open when a build-mode turn that WROTE todos
-        // ends with work remaining (same signal as the nudge above), so the
-        // UI can show the real leftovers instead of a generic "stopped"
-        // placeholder. Stale todos from older turns stay silent.
-        const openTodos = (this.mode === 'build' && todowroteThisTurn)
+        // Surface WHAT is still open when a build-mode turn engaged the drive
+        // guard (or wrote todos) and ends with work remaining, so the UI can
+        // show the real leftovers instead of a generic "stopped" placeholder.
+        const openTodos = (this.mode === 'build' && (todowroteThisTurn || driveNudges > 0))
           ? (this.todos || []).filter((t) => t.status === 'pending' || t.status === 'in_progress')
           : [];
+        // Safety net: after all continuation budgets are spent, a
+        // finish_reason=length reply still gets the explanatory placeholder
+        // instead of mystery silence.
+        const truncHint = resp.finishReason === 'length'
+          ? '(the reply hit the max-tokens limit mid-stream — the model ran out of output budget before writing any text. Raise maxTokens in config, or /think off to free the thinking budget)'
+          : '(the model ended the turn without any text)';
         return {
           type: 'text',
-          content: text || '(the model ended the turn without any text)',
+          content: text || truncHint,
           openTodos: openTodos.length ? openTodos : undefined,
         };
       }

package/src/providers/anthropic.js

@@ -50,10 +50,15 @@ function buildBody(messages, options) {
       continue;
     }
     if (m.role === 'tool') {
-      out.push({
-        role: 'user',
-        content: [{ type: 'tool_result', tool_use_id: m.toolCallId, content: String(m.content) }],
-      });
+      // tool_use_id is required by the API — skip orphaned tool rows from
+      // resumed/hand-edited sessions rather than failing the whole turn.
+      const tcid = m.toolCallId || m.tool_call_id;
+      if (tcid) {
+        out.push({
+          role: 'user',
+          content: [{ type: 'tool_result', tool_use_id: tcid, content: String(m.content) }],
+        });
+      }
       continue;
     }
     if (m.role === 'assistant') {
@@ -70,7 +75,7 @@ function buildBody(messages, options) {
       } else if (m.content) {
         blocks.push({ type: 'text', text: m.content });
       }
-      for (const tc of m.toolCalls || []) {
+      for (const tc of (m.toolCalls || m.tool_calls) || []) {
         blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input || {} });
       }
       out.push({ role: 'assistant', content: blocks });