agent-from-zero 0.34.2 → 0.35.1

package/dist/ink/chat.js

@@ -1,12 +1,18 @@
+import { AutoReviewBudget } from "../auto-budget.js";
 import { runLoop } from "../loop.js"; // the REAL agent loop — tools, permissions, retries, the lot
 import { CONFIG } from "../config.js"; // model + sub-agent tier
+import { userContent } from "../images.js";
 // Drive one real turn through the loop. The loop mutates `messages` in place
 // (appends the assistant reply + any tool messages), exactly as the readline
 // REPL relies on — so we only push the user turn here and let the loop do the
 // rest. All screen output flows through hooks.output (the Ink sink).
 export function makeRunTurn(client, messages) {
+    let reviewBudget = new AutoReviewBudget();
     return async (input, hooks) => {
-        messages.push({ role: "user", content: input });
+        if (input !== null)
+            reviewBudget = new AutoReviewBudget();
+        if (input !== null)
+            messages.push({ role: "user", content: userContent(input, hooks.images ?? []) });
         return runLoop(messages, {
             client,
             model: CONFIG.model,
@@ -15,6 +21,11 @@ export function makeRunTurn(client, messages) {
             confirm: hooks.confirm,
             askUser: hooks.askUser,
             judge: hooks.judge,
+            autoMode: hooks.autoMode,
+            reviewBudget,
+            followUps: hooks.followUps,
+            onFollowUp: hooks.onFollowUp,
+            canPrompt: !!process.stdin.isTTY,
             subAgentModel: CONFIG.subAgentModel,
             output: hooks.output,
         });

package/dist/ink/commands.js

@@ -23,9 +23,13 @@ export const SESSION_HELP = `commands:
   /model     switch model for THIS session: "/model" to pick from a list, "/model <name>" to set; "/model save <name>" to make it your default
   /stats     event counts for this session (local telemetry — nothing leaves this machine)
   /memory    show the durable facts the agent remembers about this project
+  /status    session usage and vendor account balance/cost
   /cost      tokens, cache hit rate and estimated spend this session (local)
   /mcp       list configured MCP servers + status; select one to authenticate / reconnect / disable
   /plan      toggle plan mode — research-only; the agent presents a plan you approve before any change
+  /effort [level]  list/select the current model’s supported reasoning effort
+  /auto      toggle auto mode — risky or uncertain actions still require approval
+  /auto debug [on|off|status]  inspect permission reviewer requests and replies
   /todos     show the agent's current task plan (it maintains one with todo_write on multi-step work)
   /bg        list background tasks this session (run_bash_background) and their status
   /team      list the agent team (spawn_teammate): each teammate's role, status, and pending inbox
@@ -38,9 +42,18 @@ export const SESSION_HELP = `commands:
   /skill <name>  run a skill yourself (works even for user-only skills)
   exit       leave (Ctrl+C does the same)
 
-keys (at the prompt):
-  Ctrl+R     reveal the model's thinking for the last answer (collapsed behind a spinner by default)
-  Ctrl+T     reveal the folded tool-call trace for the last answer`;
+keys (during or after a turn):
+  /          show command suggestions below the input (while idle)
+  ↑↓ / Tab   choose / complete a suggestion; Enter selects; Esc closes
+  Enter      while working, queue a follow-up for the next tool boundary
+  Ctrl+Enter interrupt and send now (Esc also sends already-queued messages)
+  Ctrl+V     paste an image as [Image #1], or paste text
+  Tab / ←    focus the agent list (← at the input boundary)
+  ↑ / ↓      select an agent; Enter views it; Esc returns to main
+  Ctrl+R     toggle thinking details
+  Ctrl+T     toggle tool arguments and results
+  ↑ / ↓      page through open details (PgUp/PgDn also work)
+  Esc        close details first; otherwise interrupt and process queued input`;
 // Colored status word for an MCP server (shared by the Ink + readline /mcp UIs).
 export function mcpStatusText(info) {
     switch (info.status) {

package/dist/ink/completion.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { slashCompletions } from "../completion.js";
+// Keep the full list in state, but render only a window around the selection.
+// Long lists must never grow Ink's redraw region beyond the terminal height.
+export function useSlashCompletion(input, enabled, context, maxRows) {
+    const [selection, setSelection] = useState({ input: "", index: 0 });
+    const [dismissed, setDismissed] = useState(null);
+    useEffect(() => { setDismissed(null); }, [input]);
+    const menu = enabled && dismissed !== input ? slashCompletions(input, context) : null;
+    const items = menu?.items ?? [];
+    const selected = Math.min(selection.input === input ? selection.index : 0, Math.max(0, items.length - 1));
+    const count = Math.max(1, Math.min(8, maxRows));
+    const start = Math.max(0, Math.min(selected - Math.floor(count / 2), items.length - count));
+    return {
+        visible: menu !== null,
+        handleKey: (key, replace) => {
+            if (!menu)
+                return { handled: false };
+            if (key.escape) {
+                setDismissed(input);
+                return { handled: true };
+            }
+            if (!items.length)
+                return { handled: false };
+            if (key.upArrow || key.downArrow) {
+                setSelection({ input, index: (selected + (key.upArrow ? -1 : 1) + items.length) % items.length });
+                return { handled: true };
+            }
+            if (key.tab || (key.return && !key.ctrl && !key.meta)) {
+                const item = items[selected];
+                if (key.tab || item.children)
+                    replace(item.value + (item.children ? " " : ""));
+                else
+                    return { handled: true, submit: item.value };
+                return { handled: true };
+            }
+            return { handled: false };
+        },
+        view: menu && (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [items.slice(start, start + count).map((item, i) => (_jsxs(Text, { color: start + i === selected ? "cyan" : undefined, bold: start + i === selected, wrap: "truncate-end", children: [start + i === selected ? "› " : "  ", item.value, "  ", _jsx(Text, { dimColor: true, children: item.description.replace(/\s+/g, " ") })] }, item.value))), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: items.length ? `↑↓ choose · Tab complete · Enter select · Esc close · ${selected + 1}/${items.length}` : menu.hint || "No matching commands" })] })),
+    };
+}

package/dist/ink/setup.js

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { CONFIG, requireApiKey } from "../config.js";
-import { buildSystemMessage } from "../prompt.js";
+import { buildSystemMessage, readProjectInstructions } from "../prompt.js";
 import { estimateHistoryTokens } from "../context.js";
 import { initCostMeter, DEFAULT_PRICING } from "../cost.js";
 import { gitBranch } from "../tui.js";
@@ -11,6 +11,7 @@ import { initTelemetry, emit } from "../telemetry.js";
 import { runHooks } from "../hooks.js";
 import { connectMcpServers } from "../mcp.js";
 import { Judge } from "../judge.js";
+import { AutoMode } from "../auto.js";
 import { registerExternalTool } from "../tools.js";
 import { rememberTool, readMemory } from "../memory.js";
 import { loadSkills, buildSkillTool } from "../skills.js";
@@ -30,7 +31,8 @@ const pkg = createRequire(import.meta.url)("../../package.json");
 export async function buildInkSession(opts = {}) {
     requireApiKey();
     const client = new OpenAI({ baseURL: CONFIG.baseURL, apiKey: CONFIG.apiKey, maxRetries: 0 });
-    const systemMessage = buildSystemMessage(); // stable prefix = cache hits every request
+    const projectInstructions = readProjectInstructions();
+    const systemMessage = buildSystemMessage(projectInstructions); // stable prefix = cache hits every request
     const messages = [{ role: "system", content: systemMessage }];
     const notices = [];
     let sessionId = newSessionId();
@@ -63,9 +65,11 @@ export async function buildInkSession(opts = {}) {
     if (cronCount)
         notices.push(`(cron: ${cronCount} durable job${cronCount !== 1 ? "s" : ""} loaded)`);
     startCronScheduler();
-    const judge = CONFIG.judge.enabled ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
+    const judge = CONFIG.judge.enabled && !CONFIG.bypassPermissions ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
+    const autoMode = new AutoMode(client, { projectInstructions });
+    notices.push(...autoMode.startupNotices());
     if (judge)
-        notices.push(`(permission judge on — model ${CONFIG.judge.model || CONFIG.model})`);
+        notices.push(`(permission judge on — ${autoMode.backend})`);
     // The remember tool flows through the same permission gate as any tool.
     registerExternalTool(rememberTool);
     const memCount = readMemory().length;
@@ -104,6 +108,7 @@ export async function buildInkSession(opts = {}) {
         costMeter,
         skills,
         judge,
+        autoMode,
         model: CONFIG.model,
         dir,
         branch,

package/dist/ink/sink.js

@@ -1,22 +1,32 @@
 // Build a LoopOutput backed by Ink state. Pure glue: every method maps a loop
 // event to a state change.
 export function makeInkSink(api) {
+    // Concurrent reads can finish out of order. Removing one handle must not
+    // clear another call's animation, and stopped handles cannot revive it.
+    const statuses = new Map();
+    const refresh = () => api.setStatus([...statuses.values()].at(-1) ?? null);
     return {
+        streamingStatus: true,
         // A spinner becomes the single "status" line below the conversation. A fresh
         // handle per model call (the loop makes one per round); `active` mirrors
         // ora's isSpinning so the loop's `spinner?.spinning` checks behave the same.
         spinner(text) {
-            api.setStatus(text);
+            const id = Symbol();
+            statuses.set(id, text);
+            refresh();
             let active = true;
             return {
                 set: (t) => {
-                    if (active)
-                        api.setStatus(t);
+                    if (active) {
+                        statuses.set(id, t);
+                        refresh();
+                    }
                 },
                 stop: () => {
                     if (active) {
                         active = false;
-                        api.setStatus(null);
+                        statuses.delete(id);
+                        refresh();
                     }
                 },
                 get spinning() {
@@ -24,8 +34,8 @@ export function makeInkSink(api) {
                 },
             };
         },
-        // The "💭 thought for Ns" indicator is just a committed line.
-        reasoning: (line) => api.pushItem({ kind: "note", text: line }),
+        // The trace is already stored for Ctrl+R; no per-round scrollback noise.
+        reasoning: () => { },
         // The streamed answer accumulates in the dynamic region as raw text (live,
         // "it's typing"), then commits as ONE markdown-rendered item when it ends —
         // partial markdown mid-stream renders badly, so we format only once it's whole.

package/dist/ink/viewport.js

@@ -0,0 +1,15 @@
+import { useEffect, useState } from "react";
+import { useStdout } from "ink";
+// Size the dynamic viewport against the SAME output stream Ink renders to.
+// Resize must trigger React too: Ink's Yoga relayout alone cannot repaginate text.
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const read = () => ({ rows: stdout.rows || 24, columns: stdout.columns || 80 });
+    const [size, setSize] = useState(read);
+    useEffect(() => {
+        const resize = () => setSize(read());
+        stdout.on("resize", resize);
+        return () => { stdout.off("resize", resize); };
+    }, [stdout]);
+    return size;
+}