agent-from-zero 0.32.4 → 0.34.0

package/dist/ink/app.js

@@ -16,14 +16,18 @@ import { resetBoard } from "../board.js";
 import { clearReasoning, clearToolCalls, getReasoning, getToolCalls, cleanup as tuiCleanup } from "../tui.js";
 import { expandMentions } from "../mentions.js"; // @file mentions → attach file contents
 import { normalizeDroppedPaths } from "../drop.js"; // drag-and-drop a file → its absolute path in the input
-import { newSessionId, saveSession, listSessions, loadSession } from "../session.js";
+import { cronItemsPending, consumeCronQueue, cronTriggerContent } from "../cron.js"; // cron scheduler (Day s14): fire scheduled jobs autonomously while idle
+import { newSessionId, saveSession, listSessions, loadSession, setSessionTitle } from "../session.js";
+import { generateSessionTitle } from "../title.js"; // concise session name, generated after the first message
 import { isPlanMode, setPlanMode } from "../permissions.js";
 import { findSkill, skillInstructions } from "../skills.js";
 import { extractMemories } from "../memory.js";
+import { displayWidth } from "../editor.js"; // display-width measurement (CJK-aware)
 import { runHooks } from "../hooks.js";
 import { emit } from "../telemetry.js";
 import { makeInkSink } from "./sink.js"; // turns the loop's output into React state
-import { runInfoCommand } from "./commands.js"; // the non-interactive slash commands
+import { runInfoCommand, mcpStatusText } from "./commands.js"; // the non-interactive slash commands + /mcp status
+import { listMcpServers, mcpActionsFor, runMcpAction } from "../mcp.js"; // /mcp: list + per-server actions
 // Injected when plan mode turns on, so the model knows the rules it now lives in.
 const PLAN_MODE_NOTICE = `[plan mode ON] Investigate this request using only read-only tools — read_file, search, and safe read-only shell (ls, cat, git status). Do NOT write files, edit, or run mutating commands; the permission gate will block them. When you have a concrete, ordered plan, call the exit_plan_mode tool with that plan. The user reviews and approves it before you make any change.`;
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]; // the braille spinner ora uses, hand-rolled for Ink
@@ -115,6 +119,8 @@ export function App({ session, runTurn }) {
     const sink = useRef(makeInkSink({ setStatus, setLive, pushItem })).current;
     const history = useRef([]).current; // past prompts, for ↑/↓ recall
     const turn = useRef(null); // the in-flight turn, for Esc-interrupt
+    const titleAttempted = useRef(false); // one-shot: name the session once, after the first real message
+    const pendingTitle = useRef(undefined); // the generated title, passed into the next save
     useEffect(() => {
         const id = setInterval(() => setTick((t) => t + 1), 1000);
         return () => clearInterval(id);
@@ -162,7 +168,7 @@ export function App({ session, runTurn }) {
             .then(async (result) => {
             if (result.reason !== TerminateReason.Done)
                 note(chalk.yellow(`⚠️ ${EXIT_NOTES[result.reason] ?? result.reason}`));
-            saveSession(sessionId, model, messages); // snapshot after every turn — crash-safe by construction
+            saveSession(sessionId, model, messages, pendingTitle.current); // snapshot after every turn — crash-safe by construction
             if (CONFIG.memory.autoExtract && result.reason === TerminateReason.Done) {
                 try {
                     const got = await extractMemories(client, CONFIG.subAgentModel || model, messages);
@@ -182,6 +188,29 @@ export function App({ session, runTurn }) {
             setLive(null);
         });
     };
+    // The cron IDLE PROCESSOR (Day s14): the scheduler fires jobs into a queue, but
+    // injectCronMessages only drains it mid-turn — so a job that fires while you're
+    // at the prompt would never run on its own. Here, while idle (no turn, no menu),
+    // we poll the queue and start a turn for any fired job: the agent does the work
+    // and reports the result into the conversation, autonomously — like Claude Code.
+    // Effect re-subscribes on busy/pending changes so the closure always sees the
+    // current `runConversationTurn`; it only installs the poll when truly idle.
+    useEffect(() => {
+        if (busy || pending)
+            return; // only fire scheduled work when the agent is idle
+        const id = setInterval(() => {
+            if (!cronItemsPending())
+                return;
+            const fired = consumeCronQueue();
+            if (!fired.length)
+                return;
+            const content = fired.map(cronTriggerContent).join("\n\n---\n\n");
+            const label = fired.length === 1 ? `⏰ cron ${fired[0].id} fired (${fired[0].cron})` : `⏰ ${fired.length} cron jobs fired`;
+            runConversationTurn(content, { kind: "note", text: chalk.cyan(label) }); // a cron NOTE (not a user bar); the agent runs it + reports
+        }, 2000);
+        return () => clearInterval(id);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [busy, pending]);
     // A normal (non-command) prompt: run UserPromptSubmit hooks, expand @file
     // mentions, then start the turn. Mirrors agent.ts's submit path.
     const submitLine = async (text) => {
@@ -200,15 +229,80 @@ export function App({ session, runTurn }) {
             note(chalk.dim(`(attached ${attached.length} file${attached.length === 1 ? "" : "s"}: ${attached.join(", ")})`));
         if (refused.length)
             note(chalk.yellow(`(refused secret file${refused.length === 1 ? "" : "s"}: ${refused.join(", ")})`));
+        // Name the session once, after the first real user message. A cheap model
+        // call distills the prompt into a 3-7 word title (like Claude Code's aiTitle);
+        // it runs fire-and-forget so it never delays the turn, and a failure just
+        // leaves the raw first prompt as the title. Resumed sessions that already
+        // have a title are left alone.
+        if (!titleAttempted.current) {
+            titleAttempted.current = true;
+            if (!loadSession(sessionId)?.title) {
+                void generateSessionTitle(client, CONFIG.subAgentModel || CONFIG.model, text)
+                    .then((title) => {
+                    if (title) {
+                        pendingTitle.current = title;
+                        setSessionTitle(sessionId, title);
+                    }
+                })
+                    .catch(() => { });
+            }
+        }
         runConversationTurn(augmented + injected, { kind: "user", text }); // show the original line; send the augmented content
     };
     // Handle a /slash command. Returns true if the line was a command (handled).
+    // /mcp — list configured servers + status, then pick one to manage it.
+    const handleMcpCommand = async (arg) => {
+        const parts = arg.trim().split(/\s+/).filter(Boolean);
+        // Direct subcommands (scriptable, matching Claude Code): /mcp reconnect|auth|enable|disable <name>
+        if (parts.length >= 2 && ["reconnect", "auth", "authenticate", "enable", "disable"].includes(parts[0])) {
+            const name = parts.slice(1).join(" ");
+            setBusy(true);
+            try {
+                const action = parts[0] === "auth" || parts[0] === "authenticate" ? "authenticate" : parts[0];
+                const msg = await runMcpAction(name, action, (url) => note(chalk.dim(`authenticate in your browser: ${url}`)));
+                note(chalk.dim(msg));
+            }
+            catch (err) {
+                note(chalk.yellow(err.message));
+            }
+            finally {
+                setBusy(false);
+            }
+            return;
+        }
+        const servers = listMcpServers();
+        if (!servers.length) {
+            note(chalk.dim("(no MCP servers configured — add an mcpServers map to .mini-agent/settings.json or ~/.config/mini-agent/settings.json)"));
+            return;
+        }
+        const labels = servers.map((s) => `${s.name}  ·  ${mcpStatusText(s)}${s.tools ? `  ·  ${s.tools} tool${s.tools === 1 ? "" : "s"}` : ""}${s.transport === "http" ? "  ·  http" : "  ·  stdio"}`);
+        openSelect("MCP servers (pick one to manage):", labels, (i) => {
+            if (i < 0)
+                return note(chalk.dim("(cancelled)"));
+            const server = servers[i];
+            const actions = mcpActionsFor(server);
+            openSelect(`${server.name} — ${mcpStatusText(server)}`, actions.map((a) => a.label), (j) => {
+                if (j < 0)
+                    return note(chalk.dim("(cancelled)"));
+                setBusy(true);
+                runMcpAction(server.name, actions[j].action, (url) => note(chalk.dim(`authenticate in your browser: ${url}`)))
+                    .then((msg) => note(chalk.dim(msg)))
+                    .catch((err) => note(chalk.yellow(err.message)))
+                    .finally(() => setBusy(false));
+            });
+        });
+    };
     const handleCommand = async (line) => {
         const info = runInfoCommand(line, { skills, costMeter }); // /help /cost /memory /stats /todos /bg /team /tasks /skills /undo /diff
         if (info !== null) {
             note(info);
             return true;
         }
+        // /mcp [reconnect|auth|enable|disable <name>]
+        if (line === "/mcp" || line.startsWith("/mcp ")) {
+            await handleMcpCommand(line.slice("/mcp".length).trim());
+            return true;
+        }
         // /model [name|save <name>]
         if (line === "/model" || line.startsWith("/model ")) {
             const arg = line.slice("/model".length).trim();
@@ -276,6 +370,8 @@ export function App({ session, runTurn }) {
                 clearReasoning();
                 clearToolCalls();
                 setSessionId(newSessionId());
+                titleAttempted.current = false; // a fresh session gets its own title on its first message
+                pendingTitle.current = undefined;
                 note(chalk.dim("(history cleared)"));
                 return true;
             case "/plan":
@@ -324,6 +420,8 @@ export function App({ session, runTurn }) {
                     messages.length = 0;
                     messages.push({ role: "system", content: systemMessage }, ...chosen.messages);
                     setSessionId(chosen.id);
+                    titleAttempted.current = false; // a resumed session without a title gets one on its next message
+                    pendingTitle.current = chosen.title;
                     forgetFilesExcept([]);
                     clearUndo();
                     clearTodos();
@@ -528,7 +626,71 @@ export function App({ session, runTurn }) {
             setCursor(cursor + add.length);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item, i) => _jsx(ItemView, { item: item }, i) }), live !== null && (_jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: "green", children: "\u23FA " }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: live === "" ? chalk.dim("…") : liveTail(live) }) })] })), (status !== null || (busy && live === null)) && (_jsxs(Box, { marginTop: live === null ? 1 : 0, children: [_jsx(Spinner, {}), _jsxs(Text, { children: [" ", status ?? chalk.dim("working…")] })] })), pending?.kind === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: pending.header }), _jsx(Text, { children: renderMenu(pending.options, menuSel) }), _jsx(Text, { children: MENU_HINT })] })), pending?.kind === "form" && formState && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: renderForm(pending.questions, formState) }) })), _jsxs(Box, { borderStyle: "round", borderColor: planMode ? "magenta" : "cyan", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: planMode ? "magenta" : "cyan", children: planMode ? "plan ❯ " : "❯ " }), _jsx(Text, { children: input.slice(0, cursor) }), _jsx(Text, { inverse: true, children: input.slice(cursor, cursor + 1) || " " }), _jsx(Text, { children: input.slice(cursor + 1) })] }), (() => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item, i) => _jsx(ItemView, { item: item }, i) }), live !== null && (_jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: "green", children: "\u23FA " }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: live === "" ? chalk.dim("…") : liveTail(live) }) })] })), (status !== null || (busy && live === null)) && (_jsxs(Box, { marginTop: live === null ? 1 : 0, children: [_jsx(Spinner, {}), _jsxs(Text, { children: [" ", status ?? chalk.dim("working…")] })] })), pending?.kind === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: pending.header }), _jsx(Text, { children: renderMenu(pending.options, menuSel) }), _jsx(Text, { children: MENU_HINT })] })), pending?.kind === "form" && formState && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: renderForm(pending.questions, formState) }) })), _jsx(Box, { borderStyle: "round", borderColor: planMode ? "magenta" : "cyan", paddingX: 1, marginTop: 1, flexDirection: "column", children: (() => {
+                    const prompt = planMode ? "plan ❯ " : "❯ ";
+                    const promptColor = planMode ? "magenta" : "cyan";
+                    const cols = process.stdout.columns || 80;
+                    const innerWidth = Math.max(10, cols - 4); // border(2) + paddingX(2)
+                    const promptW = displayWidth(prompt);
+                    const firstW = Math.max(1, innerWidth - promptW);
+                    // Build visual lines display-width-aware (CJK, emoji = 2 cols).
+                    const lines = [""];
+                    let row = 0;
+                    let col = 0;
+                    // Cursor tracking: map code-unit offset → (line, display-column).
+                    let cursorLine = 0;
+                    let cursorCol = 0;
+                    let set = false;
+                    let cu = 0; // code-unit offset, for matching `cursor`
+                    for (const ch of input) {
+                        if (!set && cu === cursor) {
+                            cursorLine = row;
+                            cursorCol = col;
+                            set = true;
+                        }
+                        const cw = displayWidth(ch);
+                        const limit = row === 0 ? firstW : innerWidth;
+                        if (col + cw > limit) {
+                            row++;
+                            col = 0;
+                            lines[row] = "";
+                        }
+                        lines[row] += ch;
+                        col += cw;
+                        cu += ch.length;
+                    }
+                    if (!set) {
+                        cursorLine = row;
+                        cursorCol = col;
+                    } // cursor at end
+                    // Cursor exactly at edge → wrap to start of next line for visibility
+                    const edge = cursorLine === 0 ? firstW : innerWidth;
+                    if (cursorCol >= edge) {
+                        cursorLine++;
+                        cursorCol = 0;
+                        if (lines.length <= cursorLine)
+                            lines.push("");
+                    }
+                    // Map display-column back to code-unit offset within the target line.
+                    const cursorLineText = lines[cursorLine] ?? "";
+                    let cuOff = 0; // code-unit offset into cursorLineText that matches cursorCol
+                    let dcol = 0;
+                    for (const ch of cursorLineText) {
+                        if (dcol >= cursorCol)
+                            break;
+                        dcol += displayWidth(ch);
+                        cuOff += ch.length;
+                    }
+                    return lines.map((line, i) => {
+                        if (i === cursorLine) {
+                            const before = line.slice(0, cuOff);
+                            const at = line.slice(cuOff, cuOff + 1) || " ";
+                            const after = line.slice(cuOff + 1);
+                            return (_jsxs(Box, { children: [i === 0 && _jsx(Text, { color: promptColor, children: prompt }), _jsx(Text, { children: before }), _jsx(Text, { inverse: true, children: at }), _jsx(Text, { children: after })] }, i));
+                        }
+                        return (_jsxs(Box, { children: [i === 0 && _jsx(Text, { color: promptColor, children: prompt }), _jsx(Text, { children: line })] }, i));
+                    });
+                })() }), (() => {
                 const agents = listSubAgents();
                 if (!agents.length)
                     return null;

package/dist/ink/commands.js

@@ -7,6 +7,7 @@ import { getTodos, renderTodos } from "../todos.js";
 import { listBackground } from "../background.js";
 import { listTeam } from "../team.js";
 import { boardSummary } from "../board.js";
+import { listJobs } from "../cron.js"; // cron scheduler (Day s14)
 import { undoLast, sessionChanges } from "../undo.js";
 import { renderDiff } from "../diff.js";
 // The non-interactive slash commands: each produces a block of text to commit as
@@ -23,11 +24,13 @@ export const SESSION_HELP = `commands:
   /stats     event counts for this session (local telemetry — nothing leaves this machine)
   /memory    show the durable facts the agent remembers about this project
   /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
   /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
   /tasks     show the shared task board (create_task/claim_task): each task's status, owner, and dependencies
+  /cron      list scheduled cron jobs (schedule_cron) and their expressions
   /undo      revert the most recent file write (write_file / edit_file) this session
   /diff      show every file changed this session, as a diff from where it started
   /resume    list recent sessions in this project and continue one of them
@@ -38,6 +41,19 @@ export const SESSION_HELP = `commands:
 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`;
+// Colored status word for an MCP server (shared by the Ink + readline /mcp UIs).
+export function mcpStatusText(info) {
+    switch (info.status) {
+        case "connected":
+            return chalk.green("connected");
+        case "needs-auth":
+            return chalk.yellow("needs auth");
+        case "failed":
+            return chalk.red("failed");
+        case "disabled":
+            return chalk.dim("disabled");
+    }
+}
 // Run a non-interactive command. Returns the note text to display, or null if
 // `line` isn't one of these (the App handles the rest).
 export function runInfoCommand(line, ctx) {
@@ -77,6 +93,12 @@ export function runInfoCommand(line, ctx) {
             const summary = boardSummary();
             return summary === "(the task board is empty)" ? chalk.dim("(no tasks — the lead adds them with create_task; teammates claim them autonomously)") : chalk.dim(`task board:\n${summary}`);
         }
+        case "/cron": {
+            const jobs = listJobs();
+            if (!jobs.length)
+                return chalk.dim("(no cron jobs scheduled)");
+            return chalk.dim(`cron jobs (${jobs.length}):\n`) + jobs.map((j) => chalk.dim(`  ${j.id}  "${j.cron}"  → "${j.prompt}"${j.recurring ? " (recurring)" : " (one-shot)"}${j.durable ? " (durable)" : " (session-only)"}`)).join("\n");
+        }
         case "/skills": {
             if (!ctx.skills.length)
                 return chalk.dim("(no skills — add one at .mini-agent/skills/<name>/SKILL.md or ~/.config/mini-agent/skills/)");

package/dist/ink/setup.js

@@ -16,6 +16,7 @@ import { rememberTool, readMemory } from "../memory.js";
 import { loadSkills, buildSkillTool } from "../skills.js";
 import { killAllBackground } from "../background.js";
 import { killAllSubAgents } from "../loop.js";
+import { loadDurableJobs, startCronScheduler, stopCronScheduler, listJobs } from "../cron.js"; // cron scheduler (Day s14)
 import { banner } from "../ui.js";
 // The Ink REPL's session bootstrap — the same wiring agent.ts (the readline REPL)
 // does before the prompt loop, but front-end-agnostic: it touches none of
@@ -53,6 +54,13 @@ export async function buildInkSession(opts = {}) {
     process.on("exit", disconnectMcp);
     process.on("exit", killAllBackground); // SIGKILL any background job so it never outlives the agent
     process.on("exit", killAllSubAgents); // mark any still-running sub-agents as killed
+    process.on("exit", stopCronScheduler); // Day s14: stop the setInterval on exit
+    // Cron scheduler (Day s14): restore durable jobs, start polling.
+    loadDurableJobs();
+    const cronCount = listJobs().length;
+    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;
     if (judge)
         notices.push(`(permission judge on — model ${CONFIG.judge.model || CONFIG.model})`);

package/dist/loop.js

@@ -15,6 +15,7 @@ import { recordToolCall, recordReasoning } from "./tui.js"; // folded tool-call
 import { STDOUT_OUTPUT } from "./output.js"; // where the loop's screen output goes (stdout by default, Ink REPL passes its own)
 import { todoNag, getTodos, renderTodos } from "./todos.js"; // the agent's plan: show it on screen + nag when it goes stale
 import { pendingNotifications } from "./background.js"; // background tasks (Day 37): surface finished jobs as a turn
+import { consumeCronQueue, cronItemsPending, cronTriggerContent } from "./cron.js"; // cron scheduler (Day s14): scheduled, recurring work
 export const MAX_RETRIES = 10; // total failed API calls per query, across all rounds
 export const MAX_RATE_LIMIT_RETRIES = 3; // 429s get their own, much smaller budget
 export const MAX_CONSECUTIVE_FAILURES = 3; // the circuit breaker
@@ -1003,6 +1004,24 @@ compaction) {
 // Top-level only: a sub-agent has no separate turn loop to inject into, and the
 // notification belongs to the agent that started the job. Returns true if it
 // injected something. Each finished task notifies exactly once (background.ts).
+// Cron queue consumer: drain triggered cron jobs into the messages array.
+// The scheduler thread writes to cron_queue independently; we drain it here
+// before each round. Sub-agents do not process cron — the top-level does.
+function injectCronMessages(messages, opts) {
+    if (opts.subAgent)
+        return false; // sub-agents don't process cron
+    if (!cronItemsPending())
+        return false;
+    const fired = consumeCronQueue();
+    let count = 0;
+    for (const job of fired) {
+        messages.push({ role: "user", content: cronTriggerContent(job) }); // shared with the REPL's idle processor
+        count++;
+    }
+    if (count && !opts.quiet)
+        sink(opts).note(chalk.cyan(`⏰ cron: ${count} job${count > 1 ? "s" : ""} fired`));
+    return count > 0;
+}
 function injectBackgroundNotifications(messages, opts) {
     if (opts.subAgent)
         return false; // notifications belong to the top-level conversation
@@ -1252,6 +1271,8 @@ opts) {
                 // model decided to stop. Don't return with an unread result on the table:
                 // surface it and run one more round so the model can react. Each notifies
                 // once, so this adds at most one round per finished job — never infinite.
+                if (injectCronMessages(messages, opts))
+                    break; // cron triggered → run another round
                 if (injectBackgroundNotifications(messages, opts))
                     break; // exit the inner while → advance the round counter
                 if (injectSubAgentResults(messages, opts))
@@ -1295,6 +1316,9 @@ opts) {
             if (!opts.quiet && out.toolCalls.length) {
                 sink(opts).note(agentIndent(opts) + mark.toolTally(out.toolCalls.map((c) => c.name)) + chalk.dim(" · Ctrl+T"));
             }
+            // Cron (Day s14): deliver any triggered scheduled jobs right after this
+            // round's results so the model sees them on the next round.
+            injectCronMessages(messages, opts);
             // Background tasks (Day 37): if a job the model started has finished, slip
             // its <task_notification> in here, right after this round's tool results —
             // the model sees the outcome on the next round without ever having blocked