atom-agent 1.1.0 → 1.2.0

package/dist/ui/live-tail.js

@@ -1,9 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Live-tail leaf: the dynamic zone between the committed <Static>
+// transcript and the modals — empty-state hints, the streaming answer
+// draft, the transient thinking block, and the tool-call hint. Re-renders
+// every tick by design (unlike TranscriptView/InputBox); all paint comes
+// from ui/theme tokens. The streaming-markdown chunk owns this file next.
+import React from "react";
 import { Box, Text } from "ink";
 import { activityText } from "./activity.js";
 import { MarkdownStream } from "./markdown.js";
 import { theme } from "./theme.js";
-export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, toolHint, toolElapsedSecs, elapsedSecs, showThinking = true }) {
+export const LiveTail = React.memo(function LiveTail({ isEmpty, sessionHint, emptySessionTitle, draft, thinking, busy, held, toolHint, toolElapsedSecs, elapsedSecs, showThinking = true }) {
     // Held view (user scrolled up mid-turn): the growing draft/thinking blocks
     // are replaced by one static line so the frame stops gaining terminal
     // lines — the terminal stops yanking and scrollback stays readable. The
@@ -11,5 +17,5 @@ export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, to
     // status (tool hint, thinking tick) keeps updating in place: same line,
     // no growth, no yank.
     const freezeLive = held === true && busy;
-    return (_jsxs(Box, { flexDirection: "column", marginY: theme.spacing.liveTailMarginY, children: [isEmpty ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, sessionHint && isEmpty ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, freezeLive ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 turn running \u00B7 End to follow"] })) : null, !freezeLive && draft ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownStream, { text: draft })] })) : null, !freezeLive && thinking && showThinking ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " ", thinking, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })] })) : null, busy && toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " ", activityText(toolHint), toolElapsedSecs !== null && toolElapsedSecs >= 2 ? (_jsxs(_Fragment, { children: [" ", theme.symbol.separator, " ", toolElapsedSecs, "s"] })) : (theme.symbol.ellipsis)] })) : null, !freezeLive && busy && !draft && !thinking && !toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workThinking, " Thinking", theme.symbol.ellipsis, " ", theme.symbol.separator, " ", elapsedSecs, "s"] })) : null] }));
-}
+    return (_jsxs(Box, { flexDirection: "column", marginY: theme.spacing.liveTailMarginY, children: [isEmpty ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, isEmpty && emptySessionTitle && emptySessionTitle.trim() ? (_jsxs(Text, { dimColor: true, children: ["Session: ", emptySessionTitle.trim()] })) : null, sessionHint && isEmpty ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, freezeLive ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 turn running \u00B7 End to follow"] })) : null, !freezeLive && draft ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownStream, { text: draft })] })) : null, !freezeLive && thinking && showThinking ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " ", thinking, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })] })) : null, busy && toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " ", activityText(toolHint), toolElapsedSecs !== null && toolElapsedSecs >= 2 ? (_jsxs(_Fragment, { children: [" ", theme.symbol.separator, " ", toolElapsedSecs, "s"] })) : (theme.symbol.ellipsis)] })) : null, !freezeLive && busy && !draft && !thinking && !toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workThinking, " Thinking", theme.symbol.ellipsis, " ", theme.symbol.separator, " ", elapsedSecs, "s"] })) : null] }));
+});

package/dist/ui/markdown.js

@@ -1,4 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Zero-dependency markdown renderer for assistant transcript turns.
+//
+// Terminal-native hierarchy, no boxes: headings are bold, lists use one
+// consistent bullet (nesting as 2-space indents, task lists as ballot
+// boxes), code blocks are indentation + a dim language label (```/~~~
+// fences, unclosed runs to end of input), tables are aligned columns with
+// one dim separator row, links read as `text (url)`. Soft line breaks join
+// (true markdown); blank lines separate paragraphs. Raw fences/bold-markers
+// never leak: when the model emits plain text, it paints back byte-identical.
+// Long code lines are never pre-wrapped or truncated — Ink wraps them and
+// the source line stays intact for copy/paste; long table cells truncate
+// with `…` so one cell never blows out the grid.
+//
+// Performance: parsed blocks are cached per exact input (bounded FIFO), so
+// re-renders and long sessions never re-parse. Parsing is linear in input
+// size; rendering stays one <Text> per run (no per-character nodes).
+import React from "react";
 import { Box, Text } from "ink";
 import { theme } from "./theme.js";
 // Split `s` on inline-code spans first (code content is never formatted),
@@ -481,10 +498,17 @@ export function closeStreamingMarkers(s) {
 // block cursor riding the final run. Converges to MarkdownText byte-for-
 // byte once the stream completes (cursor aside), so commit never visually
 // jumps.
-export function MarkdownStream({ text }) {
+//
+// Memoized on `text` — the ONLY parse input (TABLE_MAX_COL is a fixed
+// const, wrapping is Ink's job, the cursor glyph is a module const). A 1s
+// busy tick re-renders the parent with identical text and must NOT reparse:
+// same text bails here, changed text re-parses (one linear pass).
+export const streamParseProbe = { count: 0 };
+export const MarkdownStream = React.memo(function MarkdownStream({ text }) {
+    streamParseProbe.count += 1;
     const blocks = parseMarkdown(closeStreamingMarkers(text) + theme.symbol.cursorBar);
     return (_jsx(Box, { flexDirection: "column", children: blocks.map((b, k) => (_jsx(BlockView, { block: b, gap: k > 0 }, k))) }));
-}
+});
 // Assistant body: full markdown when the text parses into structure,
 // byte-identical plain text otherwise (a single paragraph paints its runs;
 // with no formatting syntax those runs are the input verbatim).

package/dist/ui/palette.js

@@ -18,6 +18,8 @@ const PALETTE_CATEGORIES = {
     "/clear": "Session",
     "/new": "Session",
     "/resume": "Session",
+    "/rename": "Session",
+    "/session": "Session",
     "/rewind": "Session",
     "/context": "Session",
     "/telemetry": "Session",

package/dist/ui/side-by-side.js

@@ -9,8 +9,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 //   lines align; changed regions pop via the existing word-background +
 //   add/del line-number treatment; syntax colors reused per cell.
 // - hunks only (configurable context in the engine) — never whole files.
-// - width-aware: panes split the measured terminal (useStdout, same
-//   pattern as App's termColumns); long lines truncate per pane with …
+// - width-aware: panes split the measured terminal (local useStdout, same
+//   pattern as StatusBarHost); long lines truncate per pane with …
 //   (code-point safe); below NARROW_COLUMNS the view degrades to the
 //   stacked unified DiffView instead of destroying the layout.
 // - computed once per mount (useMemo, keyed on inputs + pane width) and

package/dist/ui/status-host.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Status-bar host: keeps the terminal-width subscription out of App.
+//
+// App used to call useStdout() in its own body to measure columns for the
+// bar's fit-or-drop logic, coupling the whole App render to stdout changes.
+// This memoized host owns that read instead: resizes re-render the bar
+// alone. StatusBar itself is untouched (same props API); `columns` becomes
+// an optional override (tests keep passing explicit widths, production
+// measures). The 100 fallback matches StatusBar's own default.
+import React from "react";
+import { useStdout } from "ink";
+import { StatusBar } from "./status-bar.js";
+export const StatusBarHost = React.memo(function StatusBarHost(props) {
+    let measured;
+    try {
+        measured = useStdout()?.stdout?.columns;
+    }
+    catch {
+        measured = undefined;
+    }
+    return _jsx(StatusBar, { ...props, columns: props.columns ?? measured ?? 100 });
+});

package/dist/ui/stream-store.js

@@ -0,0 +1,48 @@
+const EMPTY = { draft: null, thinking: null };
+export function createStreamStore() {
+    let snapshot = EMPTY;
+    const listeners = new Set();
+    function emit() {
+        for (const cb of [...listeners]) {
+            try {
+                cb();
+            }
+            catch {
+                // A throwing listener must not break the remaining subscribers.
+            }
+        }
+    }
+    function assign(next) {
+        if (next.draft === snapshot.draft && next.thinking === snapshot.thinking)
+            return;
+        snapshot = next;
+        emit();
+    }
+    return {
+        getSnapshot: () => snapshot,
+        subscribe: (cb) => {
+            listeners.add(cb);
+            return () => {
+                listeners.delete(cb);
+            };
+        },
+        setDraft: (text) => {
+            if (text === snapshot.draft)
+                return;
+            assign({ draft: text, thinking: snapshot.thinking });
+        },
+        setThinking: (text) => {
+            if (text === snapshot.thinking)
+                return;
+            assign({ draft: snapshot.draft, thinking: text });
+        },
+        getDraft: () => snapshot.draft,
+        getThinking: () => snapshot.thinking,
+        clear: () => {
+            if (snapshot !== EMPTY) {
+                snapshot = EMPTY;
+                emit();
+            }
+        },
+    };
+}

package/dist/ui/tool-inspector.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { truncateHead } from "../tools/shared.js";
 import { theme } from "./theme.js";
 export const MAX_TOOL_RECORDS = 50;
 export const STORE_CHARS = 32768;
@@ -8,7 +9,12 @@ export const LIST_WINDOW = 15;
 export function createToolRecord(id, label, result, isError, ms) {
     const text = result ?? "";
     const truncated = text.length > STORE_CHARS;
-    const stored = truncated ? text.slice(0, STORE_CHARS) : text;
+    // Line-aware store cap (issue 04): the stored head never ends mid-line.
+    // Single-giant-line inputs keep the hard cut (documented tail edge case),
+    // so over-cap single-line results still store exactly STORE_CHARS.
+    const stored = truncated
+        ? truncateHead(text, STORE_CHARS, "\n[truncated: stored output exceeded 32KB]").head
+        : text;
     return {
         id,
         label,

package/dist/ui/transcript.js

@@ -1,39 +1,37 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // Transcript leaves: the committed <Static> scrollback, its item renderer,
 // and the startup banner. Prop-driven + memoized (see comments) so App state
 // churn never repaints them. Turn is the display-transcript entry shape.
 // All paint comes from ui/theme tokens — no literal colors or glyphs here.
 import React from "react";
-import { Box, Text } from "ink";
+import { Box, Static, Text } from "ink";
 import { SideBySideDiffView, TRANSCRIPT_DIFF_MAX_LINES } from "./side-by-side.js";
 import { ErrorCard, classifyToolError } from "./errors.js";
 import { MarkdownText, ToolLine } from "./markdown.js";
 import { theme } from "./theme.js";
-// Scrollback viewport: the committed transcript renders as a windowed
-// slice of turns in a live Box (NOT <Static> — Static is append-only with
-// no scroll API, so PgUp/Home/follow modes are impossible on it).
+// Commit frontier model: the committed transcript prints to terminal
+// scrollback ONCE via <Static> and is never rewritten (this is what keeps
+// a full-page transcript from flashing on every keystroke — Ink takes a
+// clearTerminal + full-reprint path for fullscreen dynamic frames).
 //
-// Model: E = viewed end index (items visible: (E-WIN, E]). E === turns.length
-// means follow mode — new turns extend the view automatically. Any E < len
-// is manual mode: the view freezes while new turns accumulate below, and a
-// `↓ N new` indicator offers the jump back. Clamping makes list replacement
-// (/clear, /resume, /new) re-follow for free (E > len collapses to len).
-// Banner shows only when the window touches the top.
+// Model: E = committed end index (null = follow: commit everything). Any
+// E < len is manual mode — new turns accumulate below the frontier and a
+// `↓ N new` indicator offers the jump back. Printed output can never
+// retract, so E below the committed count holds back future commits only;
+// deep history lives in terminal scrollback. Banner shows on fresh mounts.
+// List replacement (/clear, /resume, /new, /rewind) bumps clearGen, which
+// resets the Static buffer via the identity below.
 export const SCROLLBACK_WINDOW = 300;
 export const SCROLL_PAGE_ITEMS = 10;
-export function resolveViewport(len, end, win = SCROLLBACK_WINDOW) {
-    const e = Math.max(0, Math.min(end ?? len, len));
-    const follow = e >= len;
-    return { start: Math.max(0, e - win), end: e, pending: len - e, follow };
-}
 export function applyScrollAction(end, len, action) {
     const e = end ?? len;
     switch (action.kind) {
         case "pageUp":
-            // Short sessions (everything fits the window) have no window to move:
-            // freeze at the bottom instead of no-op-ing, so PgUp always engages
-            // the held view (live output stops growing; the terminal stops
-            // yanking). Long sessions move the window up a page, as before.
+            // Freeze the commit frontier instead of no-op-ing, so PgUp always
+            // engages the held view (new output stops printing below; the live
+            // tail stops growing; the terminal stops yanking). Values below the
+            // already-committed count hold back future commits only — printed
+            // output lives in terminal scrollback and can never retract.
             if (len <= SCROLLBACK_WINDOW)
                 return len;
             return Math.max(Math.min(len, SCROLLBACK_WINDOW), e - SCROLL_PAGE_ITEMS);
@@ -84,30 +82,86 @@ export function renderTranscriptItem(item) {
 // Render-count probe for the timer-isolation test: incremented on every
 // TranscriptView render (a 1s timer tick must leave it unchanged).
 export const transcriptRenderProbe = { count: 0 };
-export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, windowSize, held, showThinking = true, }) {
-    transcriptRenderProbe.count += 1;
-    const render = renderItem ?? renderTranscriptItem;
-    const win = windowSize ?? SCROLLBACK_WINDOW;
-    const vp = resolveViewport(turns.length, end, win);
-    // Pairing ([audit label, error detail] → one card) runs over the VISIBLE
-    // slice only — pairing is positional, and off-window turns never mount.
-    // Keys stay global (`turn-${idx}`) so scrolling never remounts rows.
-    // Hidden thinking turns are skipped in place (same index stability).
-    const body = [];
-    for (let idx = vp.start; idx < vp.end; idx++) {
+// Render-count probe for row isolation: incremented per mounted row paint
+// (appending one turn must paint exactly one new row, never the window).
+export const transcriptRowRenderProbe = { count: 0 };
+// Committed turns are immutable once appended (diffs attach pre-commit in
+// onToolActivity, never post-append), and keys stay global (`turn-${idx}`),
+// so a row whose item identity is unchanged can skip rendering entirely.
+// Custom compare: the body array is rebuilt per TranscriptView render with
+// fresh wrappers around the SAME turn refs — shallow compare would always
+// miss, hence id + turn/label identity. An unstable render fn falls back to
+// today's behavior (re-render) rather than going stale.
+function transcriptRowEqual(a, b) {
+    return (a.render === b.render &&
+        a.item.id === b.item.id &&
+        a.item.turn === b.item.turn &&
+        a.item.label === b.item.label);
+}
+const TranscriptRow = React.memo(function TranscriptRow({ item, render }) {
+    transcriptRowRenderProbe.count += 1;
+    return _jsx(React.Fragment, { children: render(item) });
+}, transcriptRowEqual);
+// Monotonic static admission: convert record turns [from, to) into Static
+// items, pairing adjacent [audit label, error detail] within the batch and
+// permanently skipping hidden thinking turns. ALWAYS returns next ===
+// clamped `to` (even when everything skips) so the frontier only moves
+// forward — shrinking or reordering same-identity items would misalign
+// Ink's append-only Static buffer and duplicate terminal scrollback.
+// List replacements (/clear, /resume, /rewind) bump clearGen instead, which
+// resets the buffer via the Static identity below.
+export function admitStaticBatch(turns, from, to, showThinking) {
+    const end = Math.max(from, Math.min(to, turns.length));
+    const items = [];
+    let idx = from;
+    while (idx < end) {
         const turn = turns[idx];
-        if (turn.thinking === true && !showThinking)
+        if (turn.thinking === true && !showThinking) {
+            idx += 1;
             continue;
-        const next = idx + 1 < vp.end ? turns[idx + 1] : undefined;
+        }
+        const next = idx + 1 < end ? turns[idx + 1] : undefined;
         if (isAuditLabel(turn) && next !== undefined && next.role === "tool" && next.error === true) {
-            body.push({ id: `turn-${idx}`, turn: next, label: turn });
-            idx += 1;
+            items.push({ id: `turn-${idx}`, turn: next, label: turn });
+            idx += 2;
             continue;
         }
-        body.push({ id: `turn-${idx}`, turn });
+        items.push({ id: `turn-${idx}`, turn });
+        idx += 1;
+    }
+    return { items, next: end };
+}
+export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, held, showThinking = true, }) {
+    transcriptRenderProbe.count += 1;
+    const render = renderItem ?? renderTranscriptItem;
+    const frontier = end ?? turns.length;
+    // Committed static state: full reset on clearGen (list replacements bump
+    // it — replacements must never reuse the buffer), suffix-only advance
+    // otherwise (setState-during-render derived-state pattern; the extra pass
+    // runs only when genuinely new items commit, never on ticks/keystrokes).
+    const [committed, setCommitted] = React.useState(() => {
+        const base = clearGen === 0 ? [{ id: "banner" }] : [];
+        const batch = admitStaticBatch(turns, 0, frontier, showThinking);
+        return { gen: clearGen, items: [...base, ...batch.items], next: batch.next };
+    });
+    if (committed.gen !== clearGen) {
+        const base = clearGen === 0 ? [{ id: "banner" }] : [];
+        const batch = admitStaticBatch(turns, 0, end ?? turns.length, showThinking);
+        setCommitted({ gen: clearGen, items: [...base, ...batch.items], next: batch.next });
+    }
+    else {
+        const batch = admitStaticBatch(turns, committed.next, frontier, showThinking);
+        if (batch.items.length > 0 || batch.next !== committed.next) {
+            setCommitted({
+                gen: clearGen,
+                items: [...committed.items, ...batch.items],
+                next: batch.next,
+            });
+        }
     }
-    const items = clearGen === 0 && vp.start === 0 ? [{ id: "banner" }, ...body] : body;
-    return (_jsxs(Box, { flexDirection: "column", children: [items.map((item) => (_jsx(React.Fragment, { children: render(item) }, item.id))), vp.pending > 0 ? (_jsxs(Text, { dimColor: true, children: ["\u2193 ", vp.pending, " new \u2014 End for latest"] })) : held ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 End to follow"] })) : null] }));
+    // Backlog below the committed frontier (frozen appends, not yet printed).
+    const pending = turns.length - committed.next;
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: committed.items, children: (item) => _jsx(TranscriptRow, { item: item, render: render }, item.id) }, clearGen), pending > 0 ? (_jsxs(Text, { dimColor: true, children: ["\u2193 ", pending, " new \u2014 End for latest"] })) : held ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 End to follow"] })) : null] }));
 });
 // Startup banner: the ATOM block-letter art, rendered once at launch inside
 // <Static> (scrollback, so it scrolls away naturally). FIGlet "ANSI Shadow"

package/dist/zen.js

@@ -8,7 +8,7 @@ import * as path from "node:path";
 import { MAX_TOOL_STEPS, TOOL_DEFINITIONS, } from "./tools.js";
 import { chatEndpointFor, getProvider, isLocalProviderId, modelsUrlForProvider, providerLabel, } from "./providers.js";
 import { discoverLocalProvider } from "./local-discovery.js";
-import { ANTHROPIC_VERSION, anthropicHeaders, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, isStallError, readWithStall, } from "./adapters.js";
+import { ANTHROPIC_VERSION, anthropicHeaders, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, isStallError, readWithStall, sseStallTimeoutMs, } from "./adapters.js";
 export { isStallError, readWithStall, sseStallTimeoutMs } from "./adapters.js";
 import { KILO_FALLBACK_MODELS, fetchKiloModelsWithStatus, normalizeKiloChatError, } from "./kilo.js";
 import { splitSystemHead } from "./prompt-cache.js";
@@ -337,11 +337,20 @@ export async function fetchModels(endpoint, apiKey) {
 // - Slots with an id but no name at [DONE] are dropped with an onWarning
 //   message and never returned (keeps assistant/tool pairing valid).
 // - A stream that ends without [DONE] throws a truncation error.
+// - A response flagged `finish_reason: "length"` (output limit cut the
+//   response off, so tool arguments are incomplete) does NOT throw: it
+//   returns normally with `truncated: true` so the loop can fail each carried
+//   tool call inline and continue the turn. Transport failures (aborted
+//   connections, stalls, empty replies) keep throwing.
 // - A stream silent longer than the stall budget (env ATOM_STALL_TIMEOUT_MS,
 //   default 60s; the clock resets on every received chunk) throws a
 //   Truncated-stream stall error — permanent, never retried, same contract
 //   as a dead connection (verified live: free-tier routers can stall a
 //   200-OK stream mid-generation for minutes).
+// - Queue comments (`: ...`) and keep-alives carry bytes but no model output:
+//   only `data:` payload lines refresh the data-silence clock, so minutes of
+//   `: KILO PROCESSING` while queued fail fast instead of hanging the turn
+//   (same budget, same permanent contract).
 // - A stream with zero "data:" lines is treated as a non-SSE JSON payload
 //   (tolerance for bodies that are really single-shot JSON) and parsed as
 //   choices[0].message like the non-streaming fallback.
@@ -361,9 +370,29 @@ export async function readSSEMessage(res, opts) {
     // reasoning label seen in any delta.
     let streamUsage;
     let streamReasoning;
+    // Output-limit flag (see contract above): set when any streamed choice
+    // reports `finish_reason: "length"`. Returned on the result — never thrown.
+    let lengthTruncated = false;
     // Accumulated thinking text (see onThinking): kept apart from fullText so
     // reasoning never leaks into the answer, history, or tool arguments.
     let fullThinking = "";
+    // Data-silence tracking (see throwIfDataStalled): timestamp of the last
+    // `data:` payload line. Queue comments (`: KILO PROCESSING`) and keep-alive
+    // comments carry bytes but no model output — they advance the raw stream
+    // but must NOT extend the stall budget (live-proven: minutes of comments
+    // while a free-tier request sits queued).
+    let lastDataAt = Date.now();
+    // Fail fast when the stream flows (or idles) with no model output: same
+    // permanent Truncated contract as a dead connection (passes through every
+    // catch below untouched), same env knob as the per-read byte race. Checked
+    // after each drained chunk — legitimately slow generations keep emitting
+    // `data:` lines, so only true silence trips it.
+    function throwIfDataStalled() {
+        const budget = sseStallTimeoutMs();
+        if (Date.now() - lastDataAt > budget) {
+            throw new Error(`Truncated stream from model (stall: no output for ${budget}ms — queued or stalled upstream; resend to retry).`);
+        }
+    }
     function announceStreaming() {
         if (!streamingAnnounced) {
             streamingAnnounced = true;
@@ -386,6 +415,7 @@ export async function readSSEMessage(res, opts) {
         if (!line.startsWith("data:"))
             return; // event:/id:/retry: ignored
         sawData = true;
+        lastDataAt = Date.now();
         let payload = line.slice("data:".length);
         if (payload.startsWith(" "))
             payload = payload.slice(1);
@@ -410,6 +440,10 @@ export async function readSSEMessage(res, opts) {
         }
         const choice = evt
             ?.choices?.[0];
+        // Output-limit marker rides on the choice, beside the delta — any chunk
+        // reporting it means the tool arguments below are incomplete.
+        if (choice?.finish_reason === "length")
+            lengthTruncated = true;
         const delta = (choice?.delta ?? choice?.message);
         if (typeof delta !== "object" || delta === null)
             return;
@@ -533,6 +567,7 @@ export async function readSSEMessage(res, opts) {
                     rawText += text;
                     buffer += text;
                     drainBuffer();
+                    throwIfDataStalled();
                     if (sawDone) {
                         try {
                             await reader.cancel?.();
@@ -569,6 +604,7 @@ export async function readSSEMessage(res, opts) {
                     rawText += text;
                     buffer += text;
                     drainBuffer();
+                    throwIfDataStalled();
                     if (sawDone)
                         break;
                 }
@@ -612,6 +648,10 @@ export async function readSSEMessage(res, opts) {
         throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
     }
     // Tolerance: a body with no SSE data lines is really single-shot JSON.
+    // (The data-silence bound applies only once real SSE traffic exists, so
+    // whole-body JSON payloads are never false-tripped by it.)
+    if (sawData)
+        throwIfDataStalled();
     if (!sawData) {
         const candidate = rawText.trim();
         if (candidate.length > 0) {
@@ -628,6 +668,8 @@ export async function readSSEMessage(res, opts) {
                         content,
                         tool_calls: calls.length > 0 ? calls : undefined,
                     };
+                    if (data?.choices?.[0]?.finish_reason === "length")
+                        result.truncated = true;
                     const usage = parseUsage(data?.usage);
                     if (usage !== undefined)
                         result.usage = usage;
@@ -675,6 +717,8 @@ export async function readSSEMessage(res, opts) {
         content: fullText.length > 0 ? fullText : null,
         tool_calls: calls.length > 0 ? calls : undefined,
     };
+    if (lengthTruncated)
+        result.truncated = true;
     if (streamUsage !== undefined)
         result.usage = streamUsage;
     if (streamReasoning !== undefined)
@@ -692,7 +736,10 @@ export async function readSSEMessage(res, opts) {
 // tool_calls the caller must execute, plus `usage`/`reasoning` only when
 // the response actually carried them (usage: top-level `usage` on JSON or
 // SSE final chunks; reasoning: message/delta reasoning metadata).
-// Throws on HTTP error, empty reply, or a truncated stream.
+// Throws on HTTP error, empty reply, or a truncated stream (aborted
+// connection / stall / missing [DONE]). A response flagged
+// `finish_reason: "length"` instead returns normally with `truncated: true`
+// (the loop fails its tool calls inline and continues).
 // - Network throws and HTTP 429/500/502/503/504 are retried up to
 //   MAX_RETRIES (10) with 1s→2s→4s… backoff, honoring Retry-After capped
 //   at 30s.
@@ -811,6 +858,8 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
                     content,
                     tool_calls: calls.length > 0 ? calls : undefined,
                 };
+                if (data?.choices?.[0]?.finish_reason === "length")
+                    result.truncated = true;
                 const usage = parseUsage(data?.usage);
                 if (usage !== undefined)
                     result.usage = usage;
@@ -861,16 +910,19 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
 }
 // Agentic loop for one user turn: thin wrapper over the shared runLoopWithChat
 // core below (single loop implementation). Send → while the response carries
-// tool_calls (max MAX_TOOL_STEPS tool rounds), append the assistant message,
-// execute each tool locally, append {role:'tool'} results, resend.
+// tool_calls (uncapped by default; explicit opts.maxSteps still caps), append
+// the assistant message, execute each tool locally, append {role:'tool'}
+// results, resend.
 // Streaming: each POST streams SSE tokens (onToken gets the growing text,
 // onPhase reports thinking|streaming|tool|retry|done, onToolDelta fires when
 // a tool name first appears mid-stream). A model that returns no tool_calls
 // ends the loop (graceful fallback for models without tool support). Tool
 // errors are results the model sees — NOTHING is rolled back here; only a
-// POST failure (HTTP/network/empty/truncated) throws (and the caller rolls
+// POST failure (HTTP/network/empty/stalled-stream) throws (and the caller rolls
 // back the user turn, as before; the caller preserves any streamed partial
-// on display).
+// on display). A length-truncated response (`finish_reason: "length"`) does
+// not throw: the loop fails each carried tool call inline with a repair
+// error and continues to the next model round.
 export async function runAgenticLoop(endpoint, apiKey, model, history, opts) {
     return runLoopWithChat((h, o) => chatCompletion(endpoint, apiKey, model, h, {
         onToken: o?.onToken,
@@ -1166,16 +1218,17 @@ export async function chatCompletionForProvider(provider, apiKey, model, history
     }
     return chatCompletion(endpoint, apiKey, model, history, chatOpts, providerLabel(provider));
 }
-export { evaluateTurnEnd, isCodePath, MAX_VERIFY_ROUNDS, todoCompletionGate, TURN_END_GATES, verificationGate, } from "./agent/gates.js";
+export { evaluateTurnEnd, isCodePath, MAX_TODO_ROUNDS, MAX_VERIFY_ROUNDS, todoCompletionGate, TURN_END_GATES, verificationGate, } from "./agent/gates.js";
 // Parallel independent tool calls: batch PLANNING lives in src/scheduler.ts
 // (effect metadata + conflict rules, no per-tool branches); this module only
 // plans via planToolBatches below and executes (serial singletons in program
-// order, read batches concurrently, results committed in call order).
+// order, disjoint batches concurrently, results committed in call order).
 //
-// Parallel-safe = batchable reads only (see TOOL_EFFECTS in scheduler.ts).
-// Excluded on purpose:
-// - write/edit/bash mutate or spawn with an unbounded footprint (bash can
-//   touch anything, so no footprint check could clear it) — always singletons;
+// Parallel-safe = batchable reads plus disjoint-file writes (see TOOL_EFFECTS
+// and canonicalFileKey in scheduler.ts). Approvals for batched writes resolve
+// serially in call order before any member executes. Excluded on purpose:
+// - bash mutates/spawns with an unbounded footprint (it can touch anything,
+//   so no footprint check could clear it) — always a singleton;
 // - ask_question blocks on a UI modal (parallel prompts make no sense);
 // - todowrite/todo_update share module-global todo state (read-modify-write
 //   races); todo_get is pure but sub-millisecond, so batching it buys
@@ -1190,7 +1243,7 @@ export function planToolBatches(calls) {
 }
 import { runLoopWithChat } from "./agent/loop.js";
 export { runLoopWithChat } from "./agent/loop.js";
-export { DEFAULT_MAX_TOTAL_TOOL_CALLS, DEFAULT_TOOL_TIMEOUT_MS, executeWithTimeout, resolveMaxTotalToolCalls, resolveToolTimeoutMs, } from "./agent/loop.js";
+export { DEFAULT_MAX_TOTAL_TOOL_CALLS, DEFAULT_TOOL_TIMEOUT_MS, executeWithTimeout, emptyResponseFollowUp, isEmptyReplyError, MAX_EMPTY_ROUNDS, resolveMaxTotalToolCalls, resolveToolTimeoutMs, } from "./agent/loop.js";
 export async function runAgenticLoopForProvider(provider, apiKey, model, history, opts) {
     return runLoopWithChat((h, o) => chatCompletionForProvider(provider, apiKey, model, h, {
         onToken: o?.onToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom-agent",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Agentic terminal coding assistant: multi-provider LLM loop with local file/shell/web tools in an Ink (React) TUI.",
   "type": "module",
   "license": "MIT",