agent-from-zero 0.32.3 → 0.33.1

package/dist/agent.js

@@ -31,6 +31,7 @@ import { launchInk } from "./ink/launch.js"; // the Ink REPL — the default fro
 import { listBackground, hasRunningBackground, killAllBackground } from "./background.js"; // background tasks: /bg view + kill-on-exit (Day 37)
 import { listTeam, resetTeam } from "./team.js"; // agent teams: /team view + reset on clear/resume (Day 38)
 import { boardSummary, resetBoard } from "./board.js"; // task board: /tasks view + reset on clear/resume (Day 40)
+import { loadDurableJobs, startCronScheduler, stopCronScheduler, listJobs } from "./cron.js"; // cron scheduler (Day s14)
 // package.json sits one level above both src/ (dev) and dist/ (built) — same path either way.
 const pkg = createRequire(import.meta.url)("../package.json");
 // ---- CLI arguments --------------------------------------------------------------
@@ -75,6 +76,7 @@ const SESSION_HELP = `commands:
   /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
@@ -156,6 +158,13 @@ async function main() {
     process.on("exit", disconnectMcp); // best-effort cleanup of server subprocesses
     process.on("exit", killAllBackground); // Day 37: SIGKILL any background job (dev server, slow install) so it never outlives the agent as an orphan
     process.on("exit", killAllSubAgents); // mark any still-running sub-agents as killed so they don't leave pending promises
+    process.on("exit", stopCronScheduler); // Day s14: stop the setInterval on exit
+    // Cron scheduler (Day s14): restore durable jobs from disk, start the 1s poll.
+    loadDurableJobs();
+    const cronCount = listJobs().length;
+    if (cronCount)
+        console.log(chalk.dim(`(cron: ${cronCount} durable job${cronCount !== 1 ? "s" : ""} loaded)`));
+    startCronScheduler();
     // The optional LLM permission judge, built once if a settings file enabled it.
     const judge = CONFIG.judge.enabled ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
     if (judge)
@@ -505,6 +514,20 @@ async function main() {
                 console.log(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}`));
                 return true;
             }
+            case "/cron": {
+                // Scheduled cron jobs (schedule_cron): list all currently registered.
+                const jobs = listJobs();
+                if (!jobs.length) {
+                    console.log(chalk.dim("(no cron jobs scheduled)"));
+                }
+                else {
+                    console.log(chalk.dim(`cron jobs (${jobs.length}):`));
+                    for (const j of jobs) {
+                        console.log(chalk.dim(`  ${j.id}  "${j.cron}"  → "${j.prompt}"${j.recurring ? " (recurring)" : " (one-shot)"}${j.durable ? " (durable)" : " (session-only)"}`));
+                    }
+                }
+                return true;
+            }
             case "/stats":
                 console.log(chalk.dim(statsReport())); // local counters, busiest first
                 return true;

package/dist/cron.js

@@ -0,0 +1,280 @@
+// ============ Cron Scheduler (Day s14) ============
+// The problem: the agent only acts when the user says something. "Run tests every
+// morning at 9" or "Check CI every 30 minutes" shouldn't need a human to push.
+//
+// Solution, mirroring Claude Code: an independent scheduler that checks cron
+// expressions every second, a queue that holds triggered jobs, and a queue
+// processor that delivers them when the agent is idle. Four layers:
+//
+//   Scheduler    — setInterval, 1s poll, writes to cron_queue
+//   Queue        — cron_queue, the handoff from scheduler to processor
+//   Queue Proc.  — watches cron_queue; when non-empty + agent idle, triggers a turn
+//   Consumer     — runLoop consumes cron_queue, injects "[Scheduled] ..." messages
+//
+// Durable jobs are written to .mini-agent/scheduled_tasks.json and survive
+// restarts (the scheduler re-loads them next time). Session-only jobs live only
+// in memory — when the process exits, they are gone.
+import fs from "node:fs";
+import path from "node:path";
+const SCHEDULED_TASKS_FILE = ".mini-agent/scheduled_tasks.json";
+const MAX_JOBS = 50;
+// In-memory registry: all jobs scheduled this session.
+const scheduledJobs = new Map();
+// The handoff: scheduler writes here, consumer drains.
+const cronQueue = [];
+// Prevent the scheduler from firing the same job twice in the same minute.
+const lastFired = new Map(); // job id → "YYYY-MM-DD HH:MM"
+// Lock for the cron queue and scheduled jobs map.
+let cronLock = false;
+function withCronLock(fn) {
+    // Node is single-threaded, so this lock is simpler than a real mutex.
+    // It's here for correctness compatibility with the Python reference.
+    cronLock = true;
+    try {
+        return fn();
+    }
+    finally {
+        cronLock = false;
+    }
+}
+// ============ Cron expression matching ============
+// Standard 5-field cron: minute hour day-of-month month day-of-week.
+// Day-of-month AND day-of-week both constrained → OR semantics (either matches).
+function cronFieldMatches(field, value) {
+    if (field === "*")
+        return true;
+    // Comma-separated list: "1,3,5"
+    const parts = field.split(",");
+    for (const part of parts) {
+        if (part.includes("/")) {
+            // Step: "*/5" or "0/5"
+            const [base, stepStr] = part.split("/");
+            const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step < 1)
+                continue;
+            if (base === "*") {
+                if (value % step === 0)
+                    return true;
+            }
+            else {
+                const start = parseInt(base, 10);
+                if (!isNaN(start) && value >= start && (value - start) % step === 0)
+                    return true;
+            }
+        }
+        else if (part.includes("-")) {
+            // Range: "1-5"
+            const [lo, hi] = part.split("-").map(Number);
+            if (!isNaN(lo) && !isNaN(hi) && value >= lo && value <= hi)
+                return true;
+        }
+        else {
+            // Exact: "5"
+            if (parseInt(part, 10) === value)
+                return true;
+        }
+    }
+    return false;
+}
+export function cronMatches(cronExpr, dt) {
+    const fields = cronExpr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return false;
+    const [minute, hour, dom, month, dow] = fields;
+    // Python Monday=0 → cron Sunday=0. Node: getDay() Sunday=0 Monday=1 …
+    // So weekday() + 1 in Python where Monday=0, but Node getDay() already
+    // has Sunday=0. So Node's getDay() IS cron DOW. No conversion needed.
+    const dowVal = dt.getDay();
+    const m = cronFieldMatches(minute, dt.getMinutes());
+    const h = cronFieldMatches(hour, dt.getHours());
+    const monthOk = cronFieldMatches(month, dt.getMonth() + 1); // cron months are 1-based
+    if (!m || !h || !monthOk)
+        return false;
+    const domOk = cronFieldMatches(dom, dt.getDate());
+    const dowOk = cronFieldMatches(dow, dowVal);
+    const domUnconstrained = dom === "*";
+    const dowUnconstrained = dow === "*";
+    if (domUnconstrained && dowUnconstrained)
+        return true;
+    if (domUnconstrained)
+        return dowOk;
+    if (dowUnconstrained)
+        return domOk;
+    return domOk || dowOk; // OR semantics
+}
+// ============ Validation ============
+export function validateCron(cronExpr) {
+    const fields = cronExpr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return `Cron expression must have 5 fields (min hour dom month dow), got ${fields.length}`;
+    for (const field of fields) {
+        if (!/^[*\d,\-\/]+$/.test(field))
+            return `Invalid cron field: "${field}"`;
+    }
+    // Try matching against a known time to catch structural errors.
+    try {
+        cronMatches(cronExpr, new Date());
+    }
+    catch {
+        return `Could not parse cron expression: "${cronExpr}"`;
+    }
+    return null; // valid
+}
+// ============ Job management ============
+let jobSeq = 0;
+export function scheduleJob(cron, prompt, recurring = true, durable = true) {
+    const err = validateCron(cron);
+    if (err)
+        return { error: err };
+    if (scheduledJobs.size >= MAX_JOBS)
+        return { error: `Too many scheduled jobs (max ${MAX_JOBS}). Cancel one first.` };
+    const id = `cron_${++jobSeq}`;
+    const job = {
+        id,
+        cron: cron.trim(),
+        prompt,
+        recurring,
+        durable,
+        createdAt: Date.now(),
+    };
+    withCronLock(() => {
+        scheduledJobs.set(id, job);
+        if (durable)
+            saveDurableJobs();
+    });
+    return id;
+}
+export function cancelJob(id) {
+    let found = false;
+    withCronLock(() => {
+        found = scheduledJobs.delete(id);
+        lastFired.delete(id);
+        if (found)
+            saveDurableJobs();
+    });
+    return found;
+}
+export function listJobs() {
+    return [...scheduledJobs.values()].sort((a, b) => a.createdAt - b.createdAt);
+}
+// The turn content a fired job injects: the job's own prompt, wrapped with the
+// instruction to DO it now and report the result visibly, then go back to idle.
+// Shared by both consumers — the in-turn one (injectCronMessages in loop.ts, for
+// a job that fires mid-task) and the idle one (the REPL's idle processor, for a
+// job that fires while the user is at the prompt) — so they behave identically.
+export function cronTriggerContent(job) {
+    return [
+        `[Cron job "${job.id}" triggered — ${job.cron}]`,
+        ``,
+        `${job.prompt}`,
+        ``,
+        `Execute this now. When done, report the result directly to the user — make it visible and clear.`,
+        `If the task produces output (e.g. a shell command result, a file change, a value), show it.`,
+        `If there's nothing to show, confirm success with one line.`,
+        ``,
+        `After this, return to idle — do NOT start additional work unless the user asked for a chain of follow-ups.`,
+    ].join("\n");
+}
+// ============ Cron queue ============
+export function hasCronQueue() {
+    return cronQueue.length > 0;
+}
+export function consumeCronQueue() {
+    const fired = [];
+    withCronLock(() => {
+        while (cronQueue.length > 0) {
+            const job = cronQueue.shift();
+            fired.push(job);
+        }
+    });
+    return fired;
+}
+// ============ Durable storage ============
+function durableJobsPath() {
+    return path.resolve(SCHEDULED_TASKS_FILE);
+}
+function saveDurableJobs() {
+    const durable = [...scheduledJobs.values()].filter((j) => j.durable);
+    const payload = { tasks: durable };
+    try {
+        fs.mkdirSync(path.dirname(durableJobsPath()), { recursive: true });
+        fs.writeFileSync(durableJobsPath(), JSON.stringify(payload, null, 2), "utf8");
+    }
+    catch {
+        // Non-fatal: disk writes can fail; the in-memory state is still correct.
+    }
+}
+export function loadDurableJobs() {
+    const p = durableJobsPath();
+    if (!fs.existsSync(p))
+        return;
+    let data;
+    try {
+        data = JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return; // corrupt file → ignore (the model can re-schedule)
+    }
+    if (!data.tasks || !Array.isArray(data.tasks))
+        return;
+    for (const raw of data.tasks) {
+        const err = validateCron(raw.cron);
+        if (err)
+            continue; // skip bad expressions so one bad job doesn't block startup
+        const job = {
+            id: raw.id,
+            cron: raw.cron.trim(),
+            prompt: raw.prompt,
+            recurring: raw.recurring ?? true,
+            durable: raw.durable ?? true,
+            createdAt: raw.createdAt || Date.now(),
+        };
+        scheduledJobs.set(job.id, job);
+        // Track the highest seq so new ids don't collide with loaded ones.
+        const match = job.id.match(/^cron_(\d+)$/);
+        if (match)
+            jobSeq = Math.max(jobSeq, parseInt(match[1], 10));
+    }
+}
+// ============ Scheduler loop ============
+let schedulerInterval = null;
+export function startCronScheduler() {
+    if (schedulerInterval)
+        return; // already running
+    schedulerInterval = setInterval(() => {
+        const now = new Date();
+        const minuteMarker = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+        withCronLock(() => {
+            for (const job of [...scheduledJobs.values()]) {
+                try {
+                    if (cronMatches(job.cron, now)) {
+                        if (lastFired.get(job.id) !== minuteMarker) {
+                            cronQueue.push(job);
+                            lastFired.set(job.id, minuteMarker);
+                            if (!job.recurring) {
+                                scheduledJobs.delete(job.id);
+                            }
+                            if (job.durable) {
+                                saveDurableJobs();
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // A single bad job must never kill the scheduler.
+                }
+            }
+        });
+    }, 1000);
+}
+export function stopCronScheduler() {
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+        schedulerInterval = null;
+    }
+}
+// Called by the queue processor — returns true if the agent was idle and we
+// consumed cron items (meaning: the caller should trigger a new turn).
+export function cronItemsPending() {
+    return cronQueue.length > 0;
+}

package/dist/ink/app.js

@@ -16,10 +16,12 @@ 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 { cronItemsPending, consumeCronQueue, cronTriggerContent } from "../cron.js"; // cron scheduler (Day s14): fire scheduled jobs autonomously while idle
 import { newSessionId, saveSession, listSessions, loadSession } from "../session.js";
 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
@@ -98,6 +100,7 @@ export function App({ session, runTurn }) {
     const [status, setStatus] = useState(null); // the live spinner line
     const [live, setLive] = useState(null); // the streaming answer
     const [input, setInput] = useState(""); // the current input buffer
+    const [cursor, setCursor] = useState(0); // caret position WITHIN `input` (0..input.length), for ←/→ editing
     const [busy, setBusy] = useState(false); // a turn is in flight
     const [pending, setPending] = useState(null); // a prompt/menu blocking input
     const [menuSel, setMenuSel] = useState(0); // the select menu's cursor
@@ -181,6 +184,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) => {
@@ -465,6 +491,7 @@ export function App({ session, runTurn }) {
             setSubAgentFocus(null);
             const text = input.trim();
             setInput("");
+            setCursor(0);
             setHistIdx(null);
             if (!text)
                 return;
@@ -472,13 +499,26 @@ export function App({ session, runTurn }) {
                 history.push(text); // remember non-empty entries for ↑/↓
             void submitLine(text);
         }
+        else if (key.leftArrow) {
+            setCursor((c) => Math.max(0, c - 1)); // move the caret left within the line
+        }
+        else if (key.rightArrow) {
+            setCursor((c) => Math.min(input.length, c + 1)); // ...and right
+        }
+        else if (key.ctrl && char === "a") {
+            setCursor(0); // Home — jump to the start of the line
+        }
+        else if (key.ctrl && char === "e") {
+            setCursor(input.length); // End — jump to the end of the line
+        }
         else if (key.upArrow) {
-            // ↑ recall an earlier prompt (newest-first), like a shell.
+            // ↑ recall an earlier prompt (newest-first), like a shell; caret to its end.
             if (!history.length)
                 return;
             const idx = histIdx === null ? history.length - 1 : Math.max(0, histIdx - 1);
             setHistIdx(idx);
             setInput(history[idx]);
+            setCursor(history[idx].length);
         }
         else if (key.downArrow) {
             // ↓ walk back toward the fresh line.
@@ -488,24 +528,96 @@ export function App({ session, runTurn }) {
             if (idx >= history.length) {
                 setHistIdx(null);
                 setInput("");
+                setCursor(0);
             }
             else {
                 setHistIdx(idx);
                 setInput(history[idx]);
+                setCursor(history[idx].length);
             }
         }
         else if (key.backspace || key.delete) {
-            setInput((s) => s.slice(0, -1));
+            // Delete the char BEFORE the caret. Both Backspace and macOS DEL land here,
+            // so this is always a backward delete (forward-delete is rare; we skip it).
+            if (cursor > 0) {
+                setInput(input.slice(0, cursor - 1) + input.slice(cursor));
+                setCursor(cursor - 1);
+            }
         }
         else if (char && !key.ctrl && !key.meta) {
-            // A bulk chunk (a paste / a dropped file path) is normalized: a dropped
-            // file becomes a clean absolute path; ordinary pasted prose is unchanged.
+            // Insert at the caret (a bulk chunk — paste / dropped file path — is
+            // normalized: a dropped file becomes a clean absolute path; prose unchanged).
             const add = char.length > 1 ? normalizeDroppedPaths(char) : char;
             setHistIdx(null);
-            setInput((s) => s + add);
+            setInput(input.slice(0, cursor) + add + input.slice(cursor));
+            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 }), _jsx(Text, { inverse: true, children: " " })] }), (() => {
+    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
@@ -28,6 +29,7 @@ export const SESSION_HELP = `commands:
   /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
@@ -77,6 +79,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

package/dist/permissions.js

@@ -111,6 +111,7 @@ function planSafe(toolName, verdict) {
         case "skill": // loading a skill's instructions is read-only; what it does is gated per-call
         case "todo_write": // planning is exactly what plan mode is FOR — never block it
         case "bash_output": // reading a background task's output observes, never mutates
+        case "list_crons": // listing cron jobs is read-only
         case "exit_plan_mode": // the way OUT of plan mode must never be blocked by plan mode
             return true;
         case "run_bash":
@@ -231,6 +232,16 @@ function basePermission(toolName, argsJson) {
             // Polling a background task only reads its captured output and status —
             // it touches nothing on the user's filesystem. Always safe.
             return { decision: "allow", reason: "reads background task output, no side effects", summary: args.task_id ?? "bash_output" };
+        case "schedule_cron":
+            // Scheduling a cron job writes to .mini-agent/scheduled_tasks.json and
+            // drives future work — worth a confirmation prompt.
+            return { decision: "ask", reason: "schedules a recurring task", summary: `${args.cron ?? ""} → ${args.prompt ?? ""}` };
+        case "list_crons":
+            // Listing cron jobs reads in-memory state only — no side effects.
+            return { decision: "allow", reason: "read-only, no side effects", summary: "list_crons" };
+        case "cancel_cron":
+            // Cancelling a cron job modifies internal state and may write to disk.
+            return { decision: "ask", reason: "cancels a scheduled task", summary: args.id ?? "cancel_cron" };
         case "exit_plan_mode": {
             // Outside plan mode this tool does nothing — let it through silently. In
             // plan mode it is the approval gate: ask the human, showing the plan, and

package/dist/tools.js

@@ -7,6 +7,7 @@ import { setPlanMode } from "./permissions.js"; // plan mode (Day 20): exit_plan
 import { recordMutation } from "./undo.js"; // capture the before-state so /undo (Day 22) can restore it
 import { parseTodos, setTodos, summarizeTodos } from "./todos.js"; // the agent's own checklist (Day 36)
 import { startBackground, readBackground } from "./background.js"; // long-running commands that outlive the turn (Day 37)
+import { scheduleJob, cancelJob, listJobs } from "./cron.js"; // cron scheduler (Day s14): scheduled, recurring work
 // ============ Session state ============
 // The foundation of "read before edit": which files has this session actually read?
 // Files that were never read must not be edited — otherwise the model edits from
@@ -264,6 +265,59 @@ Boundaries & permissions are identical to run_bash (dangerous commands are still
 // runs forever (npm run dev) never "finishes", so the only way to see "ready on
 // :3000" is to read its output. Reading advances a per-task cursor, so repeated
 // polls show only what's new, not the whole log every time.
+// ============ schedule_cron (Day s14) ============
+const scheduleCron = {
+    definition: def("schedule_cron", `Schedule a recurring or one-shot task using a 5-field cron expression. When it fires, YOU are woken with the prompt below, you do the task, and you report the result to the user — even while they're idle. This is the RIGHT tool for "every morning at 9 run the tests", "every 5 minutes check CI", "every minute print X" — anything that should run on a schedule AND report back. Prefer it over run_bash_background for such requests: a background job's output is captured, not shown, so the user won't see it.
+Boundaries: max 50 jobs; the scheduler checks every second and delivers the prompt when the cron matches.
+GRANULARITY: cron's finest interval is ONE MINUTE. Sub-minute schedules ("every 10 seconds") are NOT possible — tell the user that, and offer the nearest option (every minute) or, if they truly need higher frequency to watch live, suggest they run a foreground loop in their own shell.
+Cron format: minute hour day-of-month month day-of-week. Supports *, */N, N, N-M, N,M,….
+Examples: "* * * * *" = every minute; "0 9 * * *" = every day at 9:00; "*/5 * * * *" = every 5 minutes; "0 9 * * 1-5" = weekdays at 9:00.
+
+IMPORTANT — the "prompt" parameter is what you (the agent) will receive when the job fires.
+Put the user's FULL INTENT here — a complete self-contained instruction that tells you what to do.
+Do NOT just repeat the cron expression — describe the actual task in natural language, as if the user
+was saying it to you directly. Include what to execute, what to check, and how to report back.
+
+Examples of good prompts:
+  "Print 'ftfw' to the terminal by running echo ftfw, then report the output."
+  "Run 'npm test' and report how many tests passed/failed."
+  "Check if the dev server on :3000 is reachable via curl, report UP or DOWN."
+  "Check disk usage with df -h, report the / partition usage percentage."`, {
+        cron: { type: "string", description: '5-field cron expression: "0 9 * * *" = daily at 9am, "*/5 * * * *" = every 5 min' },
+        prompt: { type: "string", description: "The FULL task instruction you will receive when this fires — a self-contained description of what to do and how to report results" },
+        recurring: { type: "string", description: '"true" (default) = repeat, "false" = one-shot' },
+        durable: { type: "string", description: '"true" (default) = persist to disk, "false" = session-only' },
+    }, ["cron", "prompt"]),
+    run: (args) => {
+        const recurring = args.recurring !== "false";
+        const durable = args.durable !== "false";
+        const result = scheduleJob(args.cron, args.prompt, recurring, durable);
+        if (typeof result === "string") {
+            return `Scheduled cron job ${result}: "${args.cron}" → "${args.prompt}"${recurring ? " (recurring)" : " (one-shot)"}${durable ? " (durable)" : " (session-only)"}`;
+        }
+        return fail(result.error);
+    },
+};
+// ============ list_crons (Day s14) ============
+const listCrons = {
+    definition: def("list_crons", "List all currently scheduled cron jobs (both durable and session-only). Returns id, cron expression, prompt, and flags.", {}, []),
+    run: () => {
+        const jobs = listJobs();
+        if (!jobs.length)
+            return "No cron jobs scheduled.";
+        return jobs
+            .map((j) => `${j.id}: "${j.cron}" → "${j.prompt}"${j.recurring ? " (recurring)" : " (one-shot)"}${j.durable ? " (durable)" : " (session-only)"}`)
+            .join("\n");
+    },
+};
+// ============ cancel_cron (Day s14) ============
+const cancelCron = {
+    definition: def("cancel_cron", "Cancel a scheduled cron job by its id (from list_crons). Returns whether the job was found and removed.", { id: { type: "string", description: "The cron job id to cancel, e.g. 'cron_1'" } }, ["id"]),
+    run: (args) => {
+        const ok = cancelJob(args.id);
+        return ok ? `Cancelled cron job ${args.id}.` : fail(`Cron job not found: ${args.id}. Use list_crons to see scheduled jobs.`);
+    },
+};
 const bashOutput = {
     definition: def("bash_output", `Check on a background task started with run_bash_background: returns its status and any NEW output since you last checked.
 When to use: to see if a long job is done, or to read a long-running server's output (e.g. confirm "listening on :3000"). A finished task also sends you a <task_notification> automatically — you don't need to poll just to learn it ended.
@@ -346,6 +400,9 @@ export const tools = {
     run_bash: runBash,
     run_bash_background: runBashBackground,
     bash_output: bashOutput,
+    schedule_cron: scheduleCron,
+    list_crons: listCrons,
+    cancel_cron: cancelCron,
     exit_plan_mode: exitPlanMode,
     todo_write: todoWrite,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-from-zero",
-  "version": "0.32.3",
+  "version": "0.33.1",
   "description": "Build a Claude Code-style CLI agent from scratch, with AI as your pair programmer — companion code for a 10-day tutorial (DeepSeek by default, any OpenAI-compatible model)",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
     "eval": "tsx --env-file=.env eval/run.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "npm run build",
-    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts"
+    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts && tsx tests/cron.test.ts"
   },
   "engines": {
     "node": ">=20.6"