agent-from-zero 0.35.5 → 0.35.7

package/dist/ink/commands.js

@@ -35,6 +35,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
+  /goal <objective> [--check <cmd>]  keep working, turn after turn, until the goal is verified done (/goal alone shows it; pause | resume | clear)
   /cron      list scheduled cron jobs (schedule_cron) and their expressions
   /peers     pick another mini-agent session on this machine: talk to it from this box (Esc to come back), or make it flash its tab so you know which window it is
   /rename <name>  rename this session — the name other sessions use to reach it

package/dist/ink/launch.js

@@ -9,7 +9,7 @@ import { App } from "./app.js"; // the Ink REPL
 // `npm run ink` entry (main.tsx) and agent.ts (the default `mini-agent` entry,
 // once it hands interactive sessions to Ink) can start it.
 export async function launchInk(opts = {}) {
-    const session = await buildInkSession({ resume: opts.resume });
+    const session = await buildInkSession(opts);
     const { waitUntilExit } = render(_jsx(App, { session: session, runTurn: makeRunTurn(session.client, session.messages) }));
     await waitUntilExit(); // keep the process alive until the user quits
     // Then leave for real. The cron poll, the settings watcher and friends keep

package/dist/ink/setup.js

@@ -7,9 +7,10 @@ import { contextPercent } from "../context.js";
 import { initCostMeter, DEFAULT_PRICING } from "../cost.js";
 import { gitBranch } from "../tui.js";
 import { listPeers, registerSession, unregisterSession } from "../peers.js"; // peer sessions: other mini-agent processes on this machine
-import { newSessionId, latestSession } from "../session.js";
+import { newSessionId, latestSession, loadSession, sessionPath } from "../session.js";
+import { getGoal, restoreGoal } from "../goal.js"; // /goal (Day 41): a resumed session keeps working toward its goal
 import { initTelemetry, emit } from "../telemetry.js";
-import { runHooks } from "../hooks.js";
+import { runHooks, setHookContext } from "../hooks.js";
 import { connectMcpServers, watchMcpConfig } from "../mcp.js";
 import { Judge } from "../judge.js";
 import { AutoMode } from "../auto.js";
@@ -39,19 +40,34 @@ export async function buildInkSession(opts = {}) {
     let sessionId = newSessionId();
     let initialTitle; // only a resumed session has one already
     const startedAt = Date.now();
-    if (opts.resume) {
+    // --session-id: an id chosen by whoever started us (an orchestrator picks it
+    // up front so it knows the session before the first turn). Resume it if it
+    // exists, otherwise it names the new session.
+    if (opts.sessionId) {
+        const prev = loadSession(opts.sessionId);
+        sessionId = opts.sessionId;
+        if (prev) {
+            messages.push(...prev.messages);
+            initialTitle = prev.title;
+            notices.push(`(resumed session ${prev.id} — ${prev.messages.length} messages; files must be re-read before editing)`);
+            restoreGoal(prev.goal);
+        }
+    }
+    else if (opts.resume) {
         const prev = latestSession();
         if (prev) {
             messages.push(...prev.messages);
             sessionId = prev.id; // keep appending to the same file
             initialTitle = prev.title;
             notices.push(`(resumed session ${prev.id} — ${prev.messages.length} messages; files must be re-read before editing)`);
+            restoreGoal(prev.goal);
         }
         else {
             notices.push("(no previous session here — starting fresh)");
         }
     }
     initTelemetry(sessionId);
+    setHookContext({ session_id: sessionId, transcript_path: sessionPath(sessionId) });
     emit("agent_session_start", { mode: "repl" });
     // MCP servers connect in the BACKGROUND, like Claude Code: the prompt is
     // ready at once, each server's tools join the next model call the moment it
@@ -71,6 +87,16 @@ export async function buildInkSession(opts = {}) {
     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());
+    // A restored ACTIVE goal starts running as soon as the prompt is up — no
+    // keystroke — so say so loudly. Its /goal line was a genuine human request,
+    // so auto mode re-learns it (a paused goal is re-learned on /goal resume).
+    const goal = getGoal();
+    if (goal?.status === "active") {
+        autoMode.recordRequest(`/goal ${goal.objective}`);
+        notices.push(`(◎ resumed an ACTIVE goal — the agent continues it now; Esc pauses: ${goal.objective.slice(0, 80)})`);
+    }
+    else if (goal)
+        notices.push(`(◎ goal restored [${goal.status}] — /goal to see it, /goal resume to continue)`);
     if (judge)
         notices.push(`(permission judge on — ${autoMode.backend})`);
     // The remember tool flows through the same permission gate as any tool.

package/dist/loop.js

@@ -11,7 +11,7 @@ import { currentSession, describePeers, peerMessageContent, readPeerInbox, sendP
 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
 import { emit } from "./telemetry.js"; // local-only event log (no-op unless the CLI armed it)
-import { runHooks } from "./hooks.js"; // user lifecycle hooks (PreToolUse / PostToolUse / Stop)
+import { runHooks, runPermissionHooks } from "./hooks.js"; // user lifecycle hooks (PreToolUse / PostToolUse / Stop / PermissionRequest)
 import { reviewHistory } from "./auto-context.js";
 import { AgentProgress } from "./agent-progress.js";
 import { recordUsage } from "./cost.js"; // meter token usage from the stream
@@ -22,6 +22,7 @@ import { todoNag, getTodos, renderTodos } from "./todos.js"; // the agent's plan
 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
+import { getGoal, updateGoalTool, runUpdateGoal, countGoalToolCall } from "./goal.js"; // /goal (Day 41): the model ends a durable goal with update_goal
 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
@@ -54,6 +55,16 @@ function rememberTools(opts, tools) {
         lastTopLevelTools = tools;
     return tools;
 }
+// Append a model turn or tool result to history AND tell the observer (stream-json).
+// Only these two kinds are streamed: injected user notes are the agent's own
+// plumbing, and compaction rewrites the array wholesale (context.ts) — tapping
+// messages.push itself would replay the entire history mid-stream. Sub-agents
+// inherit opts by spread, so they are filtered here: their turns are not ours.
+function record(messages, opts, message) {
+    messages.push(message);
+    if (!opts.subAgent && !opts.teammate)
+        opts.onMessage?.(message);
+}
 // Resolve the output sink for a loop: the caller's sink, or stdout (the old
 // behaviour) when none was passed. Centralised so every site reads the same way.
 function sink(opts) {
@@ -305,8 +316,13 @@ function toolsFor(opts) {
         return builtins.filter((t) => !(t.type === "function" && t.function.name === "todo_write"));
     }
     // The Lead can do everything: orchestration, the protocols, and authoring +
-    // watching the board (it lays out tasks; teammates pull from it).
-    return [...builtins, taskTool, askUserTool, spawnTeammateTool, sendMessageTool, requestShutdownTool, requestPlanTool, reviewPlanTool, createTaskTool, listTasksTool, ...(currentSession() ? [listPeersTool] : [])];
+    // watching the board (it lays out tasks; teammates pull from it). update_goal
+    // (Day 41) appears only once the user has set a /goal — no goal, nothing to end.
+    return [...builtins, taskTool, askUserTool, spawnTeammateTool, sendMessageTool, requestShutdownTool, requestPlanTool, reviewPlanTool, createTaskTool, listTasksTool, ...(currentSession() ? [listPeersTool] : []), ...(getGoal() ? [updateGoalTool] : [])];
+}
+// The names the top-level agent would be offered right now — stream-json's init line.
+export function topLevelToolNames() {
+    return toolsFor({}).flatMap((t) => (t.type === "function" ? [t.function.name] : []));
 }
 const pendingSubAgents = new Map();
 let subAgentSeq = 0;
@@ -581,6 +597,8 @@ async function runOneCall(call, opts) {
     const spinner = !opts.quiet && !opts.subAgent ? sink(opts).spinner(status()) : null;
     const timer = spinner ? setInterval(() => spinner.set(status()), 1000) : undefined;
     emit("agent_tool_call", { tool: call.name });
+    if (!opts.subAgent)
+        countGoalToolCall(); // a goal turn with zero tool calls pauses the goal (Day 41)
     try {
         const refusal = await authorizeCall(call, opts);
         const content = refusal ?? await runWithHooks(call, opts);
@@ -682,6 +700,29 @@ async function authorizeCall(call, opts) {
         }
         if (opts.signal.aborted || opts.isInterrupted())
             return "[permission] Interrupted before execution.";
+        // Before the human is asked, a PermissionRequest hook may decide (this is
+        // how an orchestrator approves on the human's behalf). A deny is always
+        // honoured. An allow is not when a rule says a human must decide: then the
+        // question still goes to the human. Sub-agents skip hooks, as everywhere.
+        if (!autoAllowed && !opts.subAgent) {
+            const decision = await runPermissionHooks({ tool: call.name, args: call.args, reason: v.reason, summary: v.summary });
+            if (opts.signal.aborted || opts.isInterrupted())
+                return "[permission] Interrupted before execution.";
+            if (decision?.behavior === "deny") {
+                emit("agent_tool_declined", { tool: call.name });
+                if (!opts.quiet)
+                    sink(opts).note(mark.declined);
+                return `[permission] Action not approved: ${decision.message}. Ask the user how to proceed, or choose a safer alternative.`;
+            }
+            if (decision?.behavior === "allow" && !v.requiresHuman) {
+                autoAllowed = true;
+                if (!opts.quiet)
+                    recordToolDetail(call.id, "Approved by a PermissionRequest hook");
+            }
+            else {
+                await runHooks("Notification", { notification_type: "permission_prompt", message: `approval needed: ${call.name}`, tool: call.name, args: call.args });
+            }
+        }
         // An unattended callback may contain the old blanket auto-approve policy.
         // Auto mode never uses that policy as a fallback when Jev did not approve.
         // A diff is needed when the human is deciding; automatic edits stay in
@@ -791,6 +832,14 @@ async function execute(call, opts) {
         return runClaimTask(call, opts);
     if (call.name === "complete_task")
         return runCompleteTask(call, opts);
+    // /goal (Day 41): loop-level because the verifier is a model call (needs the
+    // client) and reads the conversation. The goal is the user's — top-level only.
+    if (call.name === "update_goal") {
+        if (opts.subAgent || !opts.transcript)
+            return "[error] Only the top-level agent can end the goal.";
+        return runUpdateGoal(call.args, { client: opts.client, model: subAgentModelFor(opts), signal: opts.signal, transcript: opts.transcript, note: (line) => { if (!opts.quiet)
+                sink(opts).note(chalk.cyan(`  ${line}`)); } });
+    }
     if (call.name !== "task")
         return dispatch(call.name, call.args, opts.signal); // ordinary tools go through the registry (signal lets Ctrl+C kill run_bash)
     if (opts.subAgent)
@@ -1316,7 +1365,7 @@ export async function runLoop(messages, // conversation history (mutated in plac
 opts) {
     // Children inherit this snapshot. Later human turns cannot silently grant
     // broader authorization to already-running background work.
-    opts = { ...opts, reviewBudget: opts.reviewBudget ?? new AutoReviewBudget(), autoRequests: opts.autoRequests ?? opts.autoMode?.snapshot(), followUps: opts.subAgent ? undefined : opts.followUps };
+    opts = { ...opts, reviewBudget: opts.reviewBudget ?? new AutoReviewBudget(), autoRequests: opts.autoRequests ?? opts.autoMode?.snapshot(), followUps: opts.subAgent ? undefined : opts.followUps, transcript: opts.subAgent ? undefined : messages };
     const recordHumanInput = (text) => {
         opts.autoMode?.recordRequest(text);
         opts.autoRequests = [...(opts.autoRequests ?? []), text];
@@ -1438,13 +1487,13 @@ opts) {
             // partial text in history (clearly marked) so the next turn makes sense.
             if (opts.isInterrupted()) {
                 if (out.content)
-                    messages.push({ role: "assistant", content: out.content + "\n[interrupted by user]" }); // text only — partial tool calls must NOT go in (they would need paired results)
+                    record(messages, opts, { role: "assistant", content: out.content + "\n[interrupted by user]" }); // text only — partial tool calls must NOT go in (they would need paired results)
                 return { reason: TerminateReason.UserInterrupt };
             }
             attempts.consecutive = 0; // success resets the breaker — but never the total budget
             // Rebuild the assistant message from the assembled stream and add it to
             // history — tool results must stay paired with their calls.
-            messages.push({
+            record(messages, opts, {
                 role: "assistant", // the model's turn
                 content: out.content || null, // null when the turn was tool calls only
                 ...(out.reasoning !== undefined ? { reasoning_content: out.reasoning } : {}),
@@ -1463,7 +1512,7 @@ opts) {
                 // runs the tests, blocks while they fail, and the agent keeps fixing.
                 // Sub-agents are exempt — Stop hooks are the human's project policy.
                 if (!opts.subAgent) {
-                    const stop = await runHooks("Stop", { finalText: out.content }); // give hooks the last word
+                    const stop = await runHooks("Stop", { finalText: out.content, last_assistant_message: out.content, stop_hook_active: false }); // give hooks the last word
                     if (stop.block) {
                         emit("agent_hook_block", { event: "Stop" }); // the agent was sent back to work
                         if (!opts.quiet)
@@ -1508,7 +1557,7 @@ opts) {
                     // Resolve every outstanding tool ID BEFORE adding a user message.
                     // Unstarted actions came from the old intent and must be replanned.
                     for (const call of out.toolCalls.slice(i))
-                        messages.push({ role: "tool", tool_call_id: call.id, content: "[follow-up] Not executed: new user input arrived. Reconsider this action using the latest instructions." });
+                        record(messages, opts, { role: "tool", tool_call_id: call.id, content: "[follow-up] Not executed: new user input arrived. Reconsider this action using the latest instructions." });
                     receiveFollowUps();
                     break;
                 }
@@ -1519,12 +1568,12 @@ opts) {
                     // Run the whole read-only batch at once, preserving result order.
                     const results = await Promise.all(batch.map((c) => runOneCall(c, { ...opts, autoHistory: reviewHistory(messages, opts.autoHistory) })));
                     for (const r of results)
-                        messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
+                        record(messages, opts, { role: "tool", tool_call_id: r.id, content: r.content });
                     continue; // back to the top — the next call is non-read-only
                 }
                 // A single non-read-only call: gate, maybe ask, execute — all serial.
                 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 });
+                record(messages, opts, { 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

package/dist/permissions.js

@@ -617,6 +617,10 @@ function basePermission(toolName, argsJson, auto) {
             // Task board (Day 40) — bookkeeping on the internal board, not the user's
             // project. The actual work a claimed task drives still passes this gate.
             return { decision: "allow", reason: "task board, no project side effects", summary: toolName };
+        case "update_goal":
+            // /goal (Day 41) — ends the user's goal. Bookkeeping; the only command it
+            // runs is the user's own /goal --check, which the model cannot change.
+            return { decision: "allow", reason: "goal bookkeeping, runs only the user's own --check", summary: toolName };
         case "ask_user":
             // Asking the user a question has no side effects — it's the safest thing
             // the model can do. Never gate it behind an approval prompt.

package/dist/print.js

@@ -1,11 +1,79 @@
+import { randomUUID } from "node:crypto";
 export function formatPrintResult(format, data) {
     if (format === "text")
         return data.result.finalText ? `${data.result.finalText}\n` : "";
+    if (format === "stream-json")
+        return streamJsonResult(data);
     return JSON.stringify({ type: "result", is_error: data.result.reason !== "done", reason: data.result.reason,
         result: data.result.finalText ?? "", session_id: data.sessionId, model: data.model, effort: data.effort,
         usage: { input_tokens: data.usage.inputUncached + data.usage.inputCached, cached_input_tokens: data.usage.inputCached,
             output_tokens: data.usage.output, model_calls: data.usage.calls }, estimated_cost_usd: data.usage.cost }) + "\n";
 }
+// ---- stream-json: Claude Code's NDJSON event protocol -----------------------------
+// `claude -p --output-format stream-json` prints one JSON object per line:
+//   system/init  →  assistant / user (tool_result)  …  →  result
+// Tools that parse Claude's stream (SDK wrappers, CI dashboards, log viewers)
+// can read ours unchanged. Our history is OpenAI-shaped, so each message is
+// translated at the boundary: tool_calls become tool_use blocks, role:"tool"
+// becomes a user message carrying a tool_result, reasoning_content becomes a
+// thinking block. Tool NAMES stay ours (run_bash, not Bash) — they are what the
+// model actually called. Sub-agent turns are not streamed, so every event has
+// parent_tool_use_id: null.
+// Every line carries a fresh uuid and the session id, like Claude's.
+const event = (sessionId, body) => JSON.stringify({ ...body, session_id: sessionId, uuid: randomUUID() }) + "\n";
+// The first line: what this run is equipped with, before any model call.
+export function streamJsonInit(data) {
+    return event(data.sessionId, { type: "system", subtype: "init", cwd: process.cwd(), tools: data.tools,
+        mcp_servers: data.mcpServers, model: data.model, permissionMode: data.permissionMode });
+}
+// Our tool results mark failure with a bracketed prefix, not a flag.
+const TOOL_ERROR = /^\[(?:error|permission|hook|follow-up)\]/;
+// One history message → zero or more events. Claude emits one assistant event
+// per content block (sharing the message id), so consumers can render each
+// block as it lands; we do the same.
+export function streamJsonMessage(sessionId, model, message) {
+    if (message.role === "tool") {
+        const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        return event(sessionId, { type: "user", parent_tool_use_id: null, message: { role: "user",
+                content: [{ type: "tool_result", tool_use_id: message.tool_call_id, content, is_error: TOOL_ERROR.test(content) }] } });
+    }
+    if (message.role !== "assistant")
+        return "";
+    const blocks = [];
+    const reasoning = message.reasoning_content;
+    if (reasoning)
+        blocks.push({ type: "thinking", thinking: reasoning });
+    if (typeof message.content === "string" && message.content)
+        blocks.push({ type: "text", text: message.content });
+    for (const call of message.tool_calls ?? []) {
+        if (call.type !== "function")
+            continue;
+        // The model can emit malformed arguments; the stream must never throw over it.
+        let input;
+        try {
+            input = JSON.parse(call.function.arguments || "{}");
+        }
+        catch {
+            input = call.function.arguments;
+        }
+        blocks.push({ type: "tool_use", id: call.id, name: call.function.name, input });
+    }
+    const id = `msg_${randomUUID()}`;
+    const stopReason = message.tool_calls?.length ? "tool_use" : "end_turn";
+    return blocks.map((block) => event(sessionId, { type: "assistant", parent_tool_use_id: null, message: {
+            id, type: "message", role: "assistant", model, content: [block], stop_reason: stopReason, stop_sequence: null
+        } })).join("");
+}
+// The last line. Usage follows Anthropic's split (uncached input vs cache
+// reads), which differs from our `json` format's input_tokens (the total).
+function streamJsonResult(data) {
+    const ok = data.result.reason === "done";
+    return event(data.sessionId, { type: "result", subtype: ok ? "success" : "error_during_execution", is_error: !ok,
+        duration_ms: data.durationMs ?? 0, num_turns: data.numTurns ?? 0, result: data.result.finalText ?? "",
+        total_cost_usd: data.usage.cost, usage: { input_tokens: data.usage.inputUncached, cache_creation_input_tokens: 0,
+            cache_read_input_tokens: data.usage.inputCached, output_tokens: data.usage.output },
+        permission_denials: [], reason: data.result.reason });
+}
 // stdout is a protocol in print mode, even when an MCP startup or hook helper
 // logs directly. Reserve the original writer for the result and route all
 // incidental output to stderr. Only the CLI entry point installs this guard.

package/dist/session.js

@@ -1,5 +1,6 @@
 import fs from "node:fs"; // session files live on disk
 import path from "node:path"; // path joining
+import { getGoal } from "./goal.js"; // the /goal rides along in the session file (Day 41)
 // Sessions are project-local: .mini-agent/sessions/<id>.json under the cwd.
 // Project-local (not global) because a conversation is about a codebase —
 // resuming a refactor of project A from inside project B makes no sense.
@@ -7,6 +8,15 @@ import path from "node:path"; // path joining
 // working directory — and so tests can chdir into a scratch dir.
 const sessionsDir = () => path.resolve(".mini-agent", "sessions");
 const KEEP_SESSIONS = 20; // how many session files survive pruning
+// Where a session's file lives — absolute, so it can be handed to hooks.
+export function sessionPath(id) {
+    return path.join(sessionsDir(), `${id}.json`);
+}
+// A session id becomes a file name, so one chosen from outside (--session-id)
+// must not be able to name a path.
+export function isValidSessionId(id) {
+    return /^[A-Za-z0-9._-]+$/.test(id) && id !== "." && id !== "..";
+}
 // A fresh, filename-safe session id derived from the wall clock.
 export function newSessionId() {
     return new Date().toISOString().replace(/[:.]/g, "-"); // 2026-06-12T10-30-00-000Z
@@ -27,6 +37,7 @@ export function saveSession(id, model, messages, title) {
         model, // informational — resume does not force the same model
         title: title ?? existing?.title, // a generated title sticks across saves
         messages: messages.filter((m) => m.role !== "system"), // the constitution is rebuilt fresh on resume (AGENT.md may have changed)
+        goal: getGoal() ?? undefined, // the live goal, snapshotted with the conversation it belongs to
     };
     const tmp = `${file}.tmp`; // write next to the destination (same filesystem → rename is atomic)
     fs.writeFileSync(tmp, JSON.stringify(data)); // the new snapshot
@@ -93,6 +104,7 @@ export function sessionTitle(messages) {
     const firstUser = messages.find((m) => m.role === "user");
     let text = typeof firstUser?.content === "string" ? firstUser.content : "";
     text = text.split("\n\n[Referenced files")[0]; // drop the @file attachment the REPL appended (Day 26)
+    text = text.match(/^\[goal\][^\n]*\nObjective: ([^\n]*)/)?.[1] ?? text; // a session started with /goal is named after its objective (Day 41)
     const line = text.replace(/\s+/g, " ").trim(); // flatten to one line
     return line || "(no prompt)";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-from-zero",
-  "version": "0.35.5",
+  "version": "0.35.7",
   "type": "module",
   "bin": {
     "mini-agent": "dist/agent.js"
@@ -17,7 +17,7 @@
     "auto:report": "tsx eval/auto-report.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "npm run build",
-    "test": "export MINI_AGENT_REVIEW_DEBUG=0 && 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/auto.test.ts && tsx tests/auto-context.test.ts && tsx tests/auto-providers.test.ts && tsx tests/auto-cascade.test.ts && tsx tests/auto-rules.test.ts && tsx tests/auto-rule-cascade.test.ts && tsx tests/auto-debug.test.ts && tsx tests/auto-report.test.ts && tsx tests/auto-clarification.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/cli.test.ts && tsx tests/print.test.ts && tsx tests/status.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/mcp-oauth.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/title.test.ts && tsx tests/ui.test.ts && tsx tests/activity.test.ts && tsx tests/follow-up.test.ts && tsx tests/follow-up-ui.test.tsx && tsx tests/agents.test.ts && tsx tests/images.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/effort.test.ts && tsx tests/completion.test.ts && tsx tests/pasted-text.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/peers.test.ts && tsx tests/suggestion.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts && tsx tests/cron.test.ts"
+    "test": "export MINI_AGENT_REVIEW_DEBUG=0 && 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/auto.test.ts && tsx tests/auto-context.test.ts && tsx tests/auto-providers.test.ts && tsx tests/auto-cascade.test.ts && tsx tests/auto-rules.test.ts && tsx tests/auto-rule-cascade.test.ts && tsx tests/auto-debug.test.ts && tsx tests/auto-report.test.ts && tsx tests/auto-clarification.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/cli.test.ts && tsx tests/print.test.ts && tsx tests/status.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/mcp-oauth.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/title.test.ts && tsx tests/ui.test.ts && tsx tests/activity.test.ts && tsx tests/follow-up.test.ts && tsx tests/follow-up-ui.test.tsx && tsx tests/agents.test.ts && tsx tests/images.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/effort.test.ts && tsx tests/completion.test.ts && tsx tests/pasted-text.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/peers.test.ts && tsx tests/suggestion.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts && tsx tests/cron.test.ts && tsx tests/goal.test.ts"
   },
   "engines": {
     "node": ">=20.6"