atom-agent 1.0.0 → 1.2.0

package/dist/ui/transcript.js

@@ -1,38 +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);
@@ -54,6 +53,11 @@ export function renderTranscriptItem(item) {
         return _jsx(StartupBanner, {}, item.id);
     const t = item.turn;
     const i = item.id;
+    // Committed thinking blocks read as quiet annotations (never confused
+    // with answers): dim label plus the raw reasoning text, verbatim.
+    if (t.thinking === true) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " thinking"] }), _jsx(Text, { dimColor: true, children: t.content })] }, i));
+    }
     // Conversation turns (user/assistant) breathe: one blank line after each,
     // so the eye lands on the next turn. Tool/status lines stay dense — they
     // read as lightweight annotations woven between turns, not blocks.
@@ -65,37 +69,99 @@ export function renderTranscriptItem(item) {
         if (classified) {
             // Paired cards keep the verbatim audit line above the card (pinned
             // `⚙ name target` text for tests/scanning) and name the failure in
-            // the card title. Lone details render the card alone.
-            return (_jsxs(React.Fragment, { children: [item.label ? _jsx(ToolLine, { content: item.label.content, ms: item.label.ms }) : null, _jsx(ErrorCard, { classified: classified })] }, i));
+            // the card title. Lone details render the card alone. A successful
+            // write/edit label swallowed by pairing (success line immediately
+            // followed by an error line) keeps its committed diff above the card.
+            const labelDiff = item.label?.diff;
+            return (_jsxs(React.Fragment, { children: [item.label ? _jsx(ToolLine, { content: item.label.content, ms: item.label.ms }) : null, labelDiff && !item.label?.error ? (_jsx(SideBySideDiffView, { oldText: labelDiff.oldText, newText: labelDiff.newText, lang: labelDiff.lang, maxRows: TRANSCRIPT_DIFF_MAX_LINES })) : null, _jsx(ErrorCard, { classified: classified })] }, i));
         }
-        return _jsx(ToolLine, { content: t.content, error: t.error, ms: t.ms }, i);
+        return (_jsxs(React.Fragment, { children: [_jsx(ToolLine, { content: t.content, error: t.error, ms: t.ms }), t.diff && !t.error ? (_jsx(SideBySideDiffView, { oldText: t.diff.oldText, newText: t.diff.newText, lang: t.diff.lang, maxRows: TRANSCRIPT_DIFF_MAX_LINES })) : null] }, i));
     }
     return (_jsxs(Box, { flexDirection: "column", marginBottom: theme.spacing.turnGap, children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownText, { text: t.content })] }, i));
 }
 // 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, }) {
-    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.
-    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];
-        const next = idx + 1 < vp.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 });
+        if (turn.thinking === true && !showThinking) {
             idx += 1;
             continue;
         }
-        body.push({ id: `turn-${idx}`, turn });
+        const next = idx + 1 < end ? turns[idx + 1] : undefined;
+        if (isAuditLabel(turn) && next !== undefined && next.role === "tool" && next.error === true) {
+            items.push({ id: `turn-${idx}`, turn: next, label: turn });
+            idx += 2;
+            continue;
+        }
+        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,8 @@ 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, } 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";
 import { SYSTEM_PROMPT } from "./system.js";
@@ -336,6 +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.
@@ -355,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;
@@ -380,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);
@@ -404,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;
@@ -513,9 +553,11 @@ export async function readSSEMessage(res, opts) {
                 for (;;) {
                     let chunk;
                     try {
-                        chunk = await reader.read();
+                        chunk = await readWithStall(() => reader.read());
                     }
                     catch (e) {
+                        if (isStallError(e))
+                            throw e;
                         throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
                     }
                     if (chunk.done)
@@ -525,6 +567,7 @@ export async function readSSEMessage(res, opts) {
                     rawText += text;
                     buffer += text;
                     drainBuffer();
+                    throwIfDataStalled();
                     if (sawDone) {
                         try {
                             await reader.cancel?.();
@@ -550,13 +593,29 @@ export async function readSSEMessage(res, opts) {
             }
         }
         else if (typeof body[Symbol.asyncIterator] === "function") {
-            for await (const v of body) {
-                const text = typeof v === "string" ? v : decoder.decode(v, { stream: true });
-                rawText += text;
-                buffer += text;
-                drainBuffer();
-                if (sawDone)
-                    break;
+            const it = body[Symbol.asyncIterator]();
+            try {
+                for (;;) {
+                    const step = await readWithStall(() => it.next());
+                    if (step.done)
+                        break;
+                    const v = step.value;
+                    const text = typeof v === "string" ? v : decoder.decode(v, { stream: true });
+                    rawText += text;
+                    buffer += text;
+                    drainBuffer();
+                    throwIfDataStalled();
+                    if (sawDone)
+                        break;
+                }
+            }
+            finally {
+                try {
+                    await it.return?.();
+                }
+                catch {
+                    // ignore — the stream is over either way
+                }
             }
             if (!sawDone && buffer.length > 0) {
                 processLine(buffer);
@@ -589,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) {
@@ -605,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;
@@ -652,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)
@@ -669,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.
@@ -788,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;
@@ -838,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,
@@ -1143,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
@@ -1167,6 +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, 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.0.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",