agent-from-zero 0.35.1 → 0.35.3

package/dist/ink/skills-panel.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { nextSkillMode, nextSkillSort, setSkillMode, skillListingTokens, skillLocked, skillMode, skillPanelRows, skillSource } from "../skills.js";
+// /skills — Claude Code's skill manager. One row per skill on disk:
+//   ❯ ✔ on         grill-me · user · ~20 tok
+//     🔒 user-only  deploy · project · ~30 tok · locked by author
+// Enter/space cycles on → user-only → off (saved at once, live on the next
+// model call), "/" searches, "t" changes the sort, Esc closes. The panel owns
+// its keys while it is open; the app's main handler stands aside.
+const LAVENDER = "#B1B9F9";
+const SORT_LABEL = { name: "name", tokens: "tokens", source: "source" };
+function ModeCell({ mode, locked }) {
+    if (locked)
+        return _jsx(Text, { dimColor: true, children: "🔒 user-only " });
+    if (mode === "on")
+        return _jsx(Text, { color: "green", children: "✔ on        " });
+    if (mode === "user-only")
+        return _jsx(Text, { color: "yellow", children: "◐ user-only " });
+    return _jsx(Text, { dimColor: true, children: "○ off       " });
+}
+export function SkillsPanel({ skills, maxRows, onClose }) {
+    const [cursor, setCursor] = useState(0);
+    const [query, setQuery] = useState("");
+    const [searching, setSearching] = useState(false);
+    const [sort, setSort] = useState("name");
+    const [, setVersion] = useState(0); // re-render after a mode change (modes live in CONFIG)
+    const initial = useRef(new Map(skills.map((s) => [s.name, skillMode(s)]))).current; // for the summary on close
+    const rows = skillPanelRows(skills, query, sort);
+    const at = Math.min(cursor, Math.max(0, rows.length - 1));
+    useInput((char, key) => {
+        if (searching) {
+            if (key.escape || key.return) {
+                setSearching(false);
+                if (key.escape)
+                    setQuery("");
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setQuery((q) => q.slice(0, -1));
+                setCursor(0);
+                return;
+            }
+            if (key.upArrow || key.downArrow) {
+                setSearching(false);
+            } // fall through to navigation
+            else if (char === "/")
+                return; // skill names never contain "/": a second "/" press must not become the query
+            else if (char && !key.ctrl && !key.meta) {
+                setQuery((q) => q + char);
+                setCursor(0);
+                return;
+            }
+            else
+                return;
+        }
+        if (key.escape) {
+            const changes = skills.filter((s) => initial.get(s.name) !== skillMode(s)).map((s) => `${s.name} → ${skillMode(s)}`);
+            return onClose(changes.length ? `Skills updated: ${changes.join(", ")}` : "No changes");
+        }
+        if (key.upArrow)
+            return setCursor((c) => (rows.length ? (Math.min(c, rows.length - 1) - 1 + rows.length) % rows.length : 0));
+        if (key.downArrow)
+            return setCursor((c) => (rows.length ? (Math.min(c, rows.length - 1) + 1) % rows.length : 0));
+        if (char === "/")
+            return setSearching(true);
+        if (char === "t")
+            return setSort((s) => nextSkillSort(s));
+        if (key.return || char === " ") {
+            const s = rows[at];
+            if (!s || skillLocked(s))
+                return; // the author pinned it — nothing to cycle
+            setSkillMode(s.name, nextSkillMode(skillMode(s)));
+            setVersion((v) => v + 1);
+        }
+    });
+    // A window of rows around the cursor, so a long list never outgrows the terminal.
+    const count = Math.max(3, Math.min(rows.length, maxRows));
+    const start = Math.max(0, Math.min(at - Math.floor(count / 2), rows.length - count));
+    const shown = rows.slice(start, start + count);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: LAVENDER, children: "Skills" }), _jsxs(Text, { dimColor: true, children: [skills.length, " skill", skills.length === 1 ? "" : "s", " \u00B7 ", searching ? "type to filter, ↑↓ to pick, Enter/Esc when done" : `enter/space to cycle, / to search, t to sort (${SORT_LABEL[sort]}), Esc to close`] }), _jsxs(Box, { borderStyle: "round", borderColor: searching ? LAVENDER : "gray", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: searching ? LAVENDER : undefined, dimColor: !searching, children: "Search: " }), _jsx(Text, { dimColor: !query && !searching, children: query || (searching ? "" : "press / to search skills…") }), searching && _jsx(Text, { inverse: true, children: " " })] }), start > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", start, " more above"] }), shown.map((s, i) => {
+                const selected = start + i === at;
+                const locked = skillLocked(s);
+                return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: LAVENDER, children: selected ? "❯ " : "  " }), _jsx(ModeCell, { mode: skillMode(s), locked: locked }), _jsxs(Text, { bold: !selected, color: selected ? LAVENDER : undefined, children: [" ", s.name] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", skillSource(s), " \u00B7 ~", skillListingTokens(s), " tok", locked ? " · locked by author" : ""] })] }, s.path || s.name));
+            }), !rows.length && _jsxs(Text, { dimColor: true, children: ["  ", skills.length ? `No skills match "${query}"` : "No skills — add one at .mini-agent/skills/<name>/SKILL.md or ~/.config/mini-agent/skills/"] }), start + count < rows.length && _jsxs(Text, { dimColor: true, children: ["  \u2193 ", rows.length - start - count, " more below"] })] }));
+}

package/dist/loop.js

@@ -5,7 +5,7 @@ import { toolDefinitions, dispatch, snapshotFileState, restoreFileState, isReadO
 import { classifyError, ApiErrorKind } from "./errors.js"; // failure taxonomy
 import { checkPermission } from "./permissions.js"; // the allow/ask/deny gate
 import { previewChange } from "./diff.js"; // show the diff before a write so approval is informed
-import { estimateHistoryTokens, compactHistory, COMPACT_AT, MAX_COMPACTIONS_PER_QUERY, MAX_COMPACT_FAILURES } from "./context.js"; // context management
+import { contextTokens, compactHistory, compactThreshold, recordContextUsage, MAX_COMPACTIONS_PER_QUERY, MAX_COMPACT_FAILURES } from "./context.js"; // context management
 import { SUB_AGENT_PROMPT, TEAMMATE_PROMPT } from "./prompt.js"; // the sub-agent + teammate constitutions
 import { LEAD, MAX_TEAMMATES, sendMessage, sendProtocol, readInbox, inboxCount, registerTeammate, finishTeammate, teammateExists, teammateCount, createRequest, resolveResponse, setTeammateState, anyTeammateBusy, runningTeammates, markShutdown, shutdownRequestId, resetTeam, listTeammateViews } from "./team.js"; // agent teams (Day 38) + team protocols (Day 39): mailboxes, registry, request/response contracts
 import { createTask, claimTask, completeTask, claimNextAvailable, boardSummary, resetBoard } from "./board.js"; // the shared task board (Day 40): autonomous work claiming
@@ -18,6 +18,7 @@ import { mark, thinkingWord, spinnerText } from "./ui.js"; // centralized termin
 import { recordToolCall, recordToolResult, recordToolDetail, recordReasoning } from "./tui.js"; // folded tool-call trace (Ctrl+T) + the model's hidden thinking (Ctrl+R)
 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 { currentSkills, skillBodyMessages, skillListingReminder, syncSkillTool } from "./skills.js"; // skill listing reminders + launched skill bodies
 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
@@ -391,6 +392,7 @@ opts) {
     const idleAbort = new AbortController(); // the watchdog's own kill switch
     const signal = AbortSignal.any([opts.signal, idleAbort.signal]); // either the user or the watchdog can abort
     const word = thinkingWord(modelCallSeq++); // a rotating "thinking" word for this call
+    const sentCount = messages.length; // how much history this request carries — the usage anchor (context.ts)
     const startedAt = Date.now(); // for the spinner's live elapsed counter
     let reportedTokens;
     if (opts.progress) {
@@ -401,7 +403,9 @@ opts) {
     // Reasoning is COLLAPSED by default: while the model thinks, the spinner keeps
     // spinning (with a 💭 hint) instead of dumping the trace; we stash it for Ctrl+R.
     let reasoningBuf = ""; // the accumulated thinking, hidden behind the spinner
-    let reasoningActive = false; // true while reasoning tokens are arriving → spinner shows 💭
+    let reasoningActive = false; // true while reasoning tokens are arriving → spinner says "thinking"
+    let reasoningStartedAt = 0; // when the first reasoning token arrived (0 = no reasoning this call)
+    let reasoningEndedAt = 0; // when it stopped → "thought for Ns"
     let reasoningShown = false; // has this trace been stored for Ctrl+R?
     const spinner = opts.quiet || opts.subAgent
         ? null // the eval harness wants silence
@@ -414,10 +418,11 @@ opts) {
     // - stall (slow but alive for 30s) → log it and keep waiting
     // It also ticks the spinner: elapsed seconds + a live token estimate (~chars/4).
     const watchdog = setInterval(() => {
-        // While the model is reasoning, prefix the spinner with 💭 so "it's thinking"
-        // reads differently from "it's waiting on the first token".
+        // While the model is reasoning the spinner says "thinking", then "thought
+        // for Ns" — inside the parentheses, so the verb never shifts sideways.
+        const thinking = reasoningStartedAt ? { active: reasoningActive, ms: (reasoningActive ? Date.now() : reasoningEndedAt) - reasoningStartedAt } : undefined;
         if (spinner?.spinning)
-            spinner.set((reasoningActive ? chalk.dim("💭 ") : "") + spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, Math.round(streamedChars / 4)));
+            spinner.set(spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, Math.round(streamedChars / 4), thinking));
         const quietMs = Date.now() - lastEvent; // ms since the last event
         if (quietMs > IDLE_TIMEOUT_MS) {
             emit("agent_watchdog_idle"); // record the cut — these should be rare
@@ -449,6 +454,7 @@ opts) {
                 return;
             reasoningShown = true;
             reasoningActive = false;
+            reasoningEndedAt = Date.now();
             if (opts.quiet || opts.subAgent)
                 return; // no UI for silent / nested runs
             recordReasoning(reasoningBuf); // keep it for Ctrl+R (never goes into history)
@@ -458,6 +464,7 @@ opts) {
             stallWarned = false; // the stream spoke — reset the stall warning
             if (chunk.usage) {
                 recordUsage(chunk.usage);
+                recordContextUsage(messages, sentCount, chunk.usage); // the real size of what we just sent — anchors the context count
                 if (typeof chunk.usage.completion_tokens === "number")
                     reportedTokens = chunk.usage.completion_tokens;
             } // the final usage chunk — meter it
@@ -474,7 +481,9 @@ opts) {
                 if (opts.progress)
                     opts.progress.liveTokens = Math.ceil(streamedChars / 4);
                 reasoningBuf += reasoning; // stash it for Ctrl+R instead of streaming it
-                reasoningActive = true; // the spinner now shows 💭 (set by the watchdog)
+                reasoningActive = true; // the spinner now says "thinking" (set by the watchdog)
+                if (!reasoningStartedAt)
+                    reasoningStartedAt = Date.now();
             }
             if (delta.content) {
                 flushReasoning();
@@ -1315,14 +1324,26 @@ opts) {
                 return { reason: TerminateReason.ReviewLimit };
             receiveFollowUps();
             // Proactive compaction: act BEFORE the API rejects us. Waiting for the
-            // hard limit means the failure already happened.
-            if (estimateHistoryTokens(messages) > COMPACT_AT) {
+            // hard limit means the failure already happened. The count is the last
+            // response's real prompt_tokens + an estimate of what was added since, so
+            // the threshold can sit close to the window (see compactThreshold).
+            if (contextTokens(messages) > compactThreshold(opts.model)) {
                 if (compaction.count >= MAX_COMPACTIONS_PER_QUERY)
                     return { reason: TerminateReason.CompactionFailed, detail: `already compacted ${compaction.count}x this query — the task is too big for one session` };
                 const ok = await tryCompact(messages, opts, compaction); // shrink the history
                 if (!ok && compaction.failures >= MAX_COMPACT_FAILURES)
                     return { reason: TerminateReason.CompactionFailed, detail: `${compaction.failures} consecutive compaction failures` }; // the compaction circuit breaker
             }
+            // Skills: pick up any SKILL.md added or edited since the last call (no
+            // restart), then tell the model about skills it hasn't seen yet — a
+            // <system-reminder> user message with just the delta, as Claude Code does.
+            // Idempotent: a retry of this same call finds the reminder already sent.
+            // Teammates have no skill tool, so they get no listing.
+            const skills = currentSkills();
+            syncSkillTool(skills);
+            const listing = opts.teammate ? null : skillListingReminder(messages, skills);
+            if (listing)
+                messages.push({ role: "user", content: listing });
             let out;
             try {
                 out = await streamModelCall(messages, opts); // streaming call with spinner + watchdog
@@ -1461,6 +1482,11 @@ opts) {
                 const r = await runOneCall(out.toolCalls[i++], { ...opts, autoHistory: reviewHistory(messages, opts.autoHistory) });
                 messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
             }
+            // A launched skill's body arrives as its own user message, after ALL of
+            // this round's tool results (the tool result itself only says "Launching
+            // skill: <name>"). Same shape as Claude Code's skill invocation.
+            for (const body of skillBodyMessages(out.toolCalls, messages))
+                messages.push({ role: "user", content: body });
             // 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);