agent-from-zero 0.35.5 → 0.35.7

package/dist/goal.js

@@ -0,0 +1,365 @@
+import crypto from "node:crypto"; // fingerprint the working tree between goal turns
+import fs from "node:fs"; // stat untracked files for the fingerprint
+import { execFileSync, spawn } from "node:child_process"; // git for the fingerprint, sh for the --check command
+import { sessionChanges } from "./undo.js"; // files the agent's own tools changed this session
+import { emit } from "./telemetry.js"; // observe goal lifecycle + verifier decisions
+export const MAX_STALLED_TURNS = 3; // goal turns in a row with an unchanged working tree → pause
+const CHECK_TIMEOUT_MS = 10 * 60_000; // a test suite may be slow — but not forever
+const CHECK_OUTPUT_TAIL = 4_000; // chars of check output fed back (the END is where failures are)
+const OBSERVATION_CHARS = 1_200; // per tool result shown to the verifier
+const OBSERVATIONS_BUDGET = 12_000; // total chars of recent tool results shown to the verifier
+const VERIFIER_MAX_TOKENS = 200; // one tag + one sentence
+// ---- session state ------------------------------------------------------------
+// One goal per session, in process memory like the todo list — but unlike the
+// todo list it is written into the session file (session.ts), so `--resume`
+// picks up a half-finished goal and keeps going.
+let current = null;
+let inFlight = null; // the goal turn now running
+let toolCalls = 0; // top-level tool calls this process (loop.ts counts them) — survives compaction, unlike message indexes
+export function getGoal() {
+    return current;
+}
+export function clearGoal() {
+    current = null;
+    inFlight = null;
+}
+// Adopt a goal loaded from a session file (or none). A malformed one is dropped.
+export function restoreGoal(goal) {
+    inFlight = null;
+    current = goal && typeof goal.objective === "string" && goal.objective.trim() ? { ...goal, stalls: goal.stalls ?? 0, continuations: goal.continuations ?? 0 } : null;
+}
+function setStatus(status, note) {
+    if (!current)
+        return;
+    current.status = status;
+    current.note = note;
+    emit("agent_goal_status", { status });
+}
+export function countGoalToolCall() {
+    toolCalls++;
+}
+export function parseGoalCommand(args) {
+    const text = args.trim();
+    if (!text)
+        return { kind: "show" };
+    if (text === "pause" || text === "resume" || text === "clear")
+        return { kind: text };
+    const m = text.match(/^([\s\S]*?)\s*--check\s+([\s\S]+)$/);
+    let objective = text;
+    let check;
+    if (m) {
+        objective = m[1].trim();
+        check = m[2].trim().replace(/^(["'])([\s\S]*)\1$/, "$2").trim(); // strip one pair of matching quotes
+        if (!check)
+            return { kind: "error", message: "--check needs a command, e.g. --check \"npm test\"" };
+    }
+    else if (/(^|\s)--check\s*$/.test(text)) {
+        return { kind: "error", message: "--check needs a command, e.g. --check \"npm test\"" };
+    }
+    if (!objective)
+        return { kind: "error", message: "usage: /goal <objective> [--check <command>]" };
+    return { kind: "set", objective, check };
+}
+// ---- pure: render the goal for /goal -------------------------------------------
+export function describeGoal(goal) {
+    if (!goal)
+        return "(no goal — set one with /goal <objective> [--check <command>])";
+    const lines = [
+        `goal [${goal.status}]: ${goal.objective}`,
+        goal.check ? `  check: ${goal.check}` : "  check: (none — the verifier judges from evidence alone)",
+        `  turns: ${goal.continuations}${goal.stalls ? ` · no progress in the last ${goal.stalls}` : ""}`,
+    ];
+    if (goal.note)
+        lines.push(`  note: ${goal.note}`);
+    if (goal.status === "paused" || goal.status === "blocked")
+        lines.push("  /goal resume to continue · /goal clear to drop it");
+    return lines.join("\n");
+}
+// ---- the /goal command (shared by both REPLs) ----------------------------------
+// Returns the line to show, plus `request`: the human text to record as a user
+// request for auto mode. Only the /goal line the human typed authorizes work —
+// the automatic continuation turns never do, or each one would widen what the
+// reviewer thinks was approved.
+export function goalCommand(args) {
+    const cmd = parseGoalCommand(args);
+    switch (cmd.kind) {
+        case "error":
+            return { message: cmd.message };
+        case "show":
+            return { message: describeGoal(current) };
+        case "clear":
+            if (!current)
+                return { message: "(no goal to clear)" };
+            clearGoal();
+            emit("agent_goal_status", { status: "cleared" });
+            return { message: "(goal cleared)" };
+        case "pause":
+            if (current?.status !== "active")
+                return { message: `(no active goal to pause${current ? ` — it is ${current.status}` : ""})` };
+            setStatus("paused", "paused by you");
+            return { message: "(goal paused — /goal resume to continue)" };
+        case "resume":
+            if (!current)
+                return { message: "(no goal to resume)" };
+            if (current.status === "complete")
+                return { message: "(that goal is already complete — set a new one with /goal <objective>)" };
+            if (current.status === "active")
+                return { message: "(the goal is already active)" };
+            setStatus("active");
+            current.stalls = 0; // a fresh start after you stepped in
+            return { message: `(goal resumed: ${current.objective})`, request: `/goal ${current.objective}` };
+        case "set": {
+            const replaced = current && current.status !== "complete";
+            current = { objective: cmd.objective, check: cmd.check, status: "active", continuations: 0, stalls: 0, setAt: new Date().toISOString() };
+            inFlight = null;
+            emit("agent_goal_status", { status: "set", check: cmd.check ? 1 : 0 });
+            return { message: `${replaced ? "(replaced the previous goal) " : ""}goal set: ${cmd.objective}${cmd.check ? `\n  check: ${cmd.check}` : ""}\n  the agent keeps working until it is verified done — Esc pauses, /goal clear drops it`, request: `/goal ${args.trim()}` };
+        }
+    }
+}
+// ---- turn bookkeeping -----------------------------------------------------------
+// The REPL calls startGoalTurn when it is idle. It returns the text of the next
+// goal turn (or null if there is nothing to do), and snapshots the working tree
+// so settleGoalTurn can tell whether the turn moved anything.
+export function startGoalTurn() {
+    if (current?.status !== "active" || inFlight)
+        return null;
+    inFlight = { fingerprint: workFingerprint(), toolCalls };
+    current.continuations++;
+    return goalTurnContent(current);
+}
+// The goal turn text. It restates the FULL objective every time: after a few
+// compactions the original /goal message may be long gone from history, and
+// this is what keeps the model aimed at the same target for hours.
+export function goalTurnContent(goal) {
+    const head = goal.continuations <= 1 ? "[goal] A goal was just set. Work toward it until it is verified done." : `[goal] Continuation #${goal.continuations} — the goal is not verified done yet. Pick up where you left off.`;
+    return [
+        head,
+        `Objective: ${goal.objective}`,
+        goal.check ? `Completion check: \`${goal.check}\` must exit 0 — the harness runs it when you claim completion.` : "",
+        "Inspect, change, run and verify. Each time you stop you will be sent back here, until you call update_goal:",
+        '  - update_goal({status: "complete", report}) — only after checking the objective against concrete evidence (commands you ran, their output, files you changed). An independent verifier re-checks against your recent tool results; an unsupported claim is rejected.',
+        '  - update_goal({status: "blocked", report}) — when no valid path remains or you need the user: what you tried, the blocker, and the input you need.',
+        "Do not stop just to summarize progress: a goal turn that makes no tool calls pauses the goal.",
+    ].filter(Boolean).join("\n");
+}
+// After ANY turn ends. Returns a line for the screen, or null. `goalTurn` says
+// whether this was a goal turn (vs. the user's own message); `reason` is the
+// loop's TerminateReason (or "error" if the turn threw); `followUp` is true when
+// the turn was interrupted only to deliver a queued message — that is the user
+// steering, not stopping, so it must not pause the goal.
+export function settleGoalTurn(reason, goalTurn, followUp = false) {
+    const turn = inFlight;
+    if (goalTurn)
+        inFlight = null;
+    if (current?.status !== "active")
+        return null; // update_goal finished it mid-turn (it announced that itself)
+    if (reason === "user_interrupt") {
+        if (followUp)
+            return null;
+        setStatus("paused", "interrupted by you");
+        return "◎ goal paused (interrupted) — /goal resume to continue";
+    }
+    if (!goalTurn || !turn)
+        return null; // your own message ended normally — the goal simply continues next
+    if (reason !== "done") {
+        setStatus("paused", `a goal turn ended with ${reason}`);
+        return `◎ goal paused — the turn ended with ${reason}. /goal resume to try again`;
+    }
+    if (toolCalls === turn.toolCalls) {
+        setStatus("paused", "a goal turn made no tool calls");
+        return "◎ goal paused — the agent stopped without doing anything. Reply to steer it, then /goal resume";
+    }
+    current.stalls = workFingerprint() === turn.fingerprint ? current.stalls + 1 : 0;
+    if (current.stalls >= MAX_STALLED_TURNS) {
+        setStatus("paused", `no file changes in ${current.stalls} goal turns in a row`);
+        return `◎ goal paused — no progress in ${current.stalls} turns in a row. Reply to steer it, then /goal resume`;
+    }
+    return null;
+}
+// Did anything change? The agent's own writes (undo.ts tracks their current
+// content, so rewriting the same file counts) plus git's view, which also sees
+// what run_bash changed (sed, codegen, npm install). `git diff` is blind to
+// untracked files, so their size + mtime go in too. Not in a git repo → the
+// agent's writes alone.
+const MAX_UNTRACKED = 2_000; // stat at most this many untracked files per fingerprint
+function workFingerprint() {
+    const h = crypto.createHash("sha1");
+    for (const c of sessionChanges())
+        h.update(c.path).update("\0").update(c.current).update("\0");
+    const git = (args) => execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
+    try {
+        // Our own bookkeeping (.mini-agent/: the session file, logs, spilled output)
+        // churns every turn and is rarely gitignored — counting it as "progress"
+        // would reset the stall count every turn and disarm the fuse.
+        const lines = git(["status", "--porcelain", "-uall"]).split("\n").filter((l) => l && !/^.. "?\.mini-agent\//.test(l));
+        h.update(lines.join("\n")).update(git(["diff"]));
+        const untracked = lines.filter((l) => l.startsWith("?? ")).slice(0, MAX_UNTRACKED);
+        for (const line of untracked) {
+            try {
+                const st = fs.statSync(line.slice(3));
+                h.update(`${line}\0${st.size}\0${st.mtimeMs}\0`);
+            }
+            catch {
+                /* vanished between status and stat — the next fingerprint sees it */
+            }
+        }
+    }
+    catch {
+        /* not a git repo, or git missing — the agent's own writes still count */
+    }
+    return h.digest("hex");
+}
+// ---- update_goal: the model's only way to END a goal ----------------------------
+export const updateGoalTool = {
+    type: "function",
+    function: {
+        name: "update_goal",
+        description: `End the active /goal, as "complete" or "blocked". While a goal is active you are sent back to work every time you stop, so this is how you finish.
+complete: only after you checked the objective against concrete evidence — tests you ran and their output, files you changed, results you saw. The user's completion check (if any) is run, then an independent verifier compares your report with your recent tool results. If either fails you get the reason back and the goal stays active.
+blocked: when no valid path remains or you need something only the user can give. Report what you tried, the blocker, and the exact input you need.`,
+        parameters: {
+            type: "object",
+            properties: {
+                status: { type: "string", enum: ["complete", "blocked"], description: "complete = the objective is achieved and evidenced; blocked = you need the user" },
+                report: { type: "string", description: "complete: the evidence (what you ran/changed and what it showed). blocked: what you tried, the blocker, the input you need." },
+            },
+            required: ["status", "report"],
+        },
+    },
+};
+// Run update_goal. Never throws; every outcome is text for the model.
+export async function runUpdateGoal(rawArgs, ctx) {
+    if (current?.status !== "active")
+        return "[error] There is no active goal. update_goal is only for ending a goal the user set with /goal.";
+    let status = "", report = "";
+    try {
+        const a = JSON.parse(rawArgs);
+        status = a.status ?? "";
+        report = (a.report ?? "").trim();
+    }
+    catch {
+        /* fall through */
+    }
+    if (status !== "complete" && status !== "blocked")
+        return '[error] update_goal needs status "complete" or "blocked".';
+    if (!report)
+        return "[error] update_goal needs a non-empty report — the evidence (complete) or the blocker (blocked).";
+    if (status === "blocked") {
+        setStatus("blocked", report.slice(0, 300));
+        ctx.note(`◎ goal blocked — ${report.slice(0, 160)}`);
+        return "Goal marked blocked; no more automatic turns. Stop now and tell the user what you tried, the blocker, and the input you need.";
+    }
+    // 1. The hard gate: the user's own --check command. It was typed by the human
+    //    in /goal, so it does not go through the permission gate — and the model
+    //    has no way to change it. Nonzero exit → not done, no verifier call.
+    let checkLine = "";
+    if (current.check) {
+        ctx.note(`◎ goal check: ${current.check}`);
+        const r = await runCheck(current.check, ctx.signal);
+        if (r.code !== 0) {
+            emit("agent_goal_claim", { accepted: 0, by: "check" });
+            ctx.note(`◎ goal check failed (${r.code === null ? "timed out / killed" : `exit ${r.code}`}) — not done`);
+            return `[goal] Not complete: the completion check \`${current.check}\` ${r.code === null ? "timed out or was killed" : `exited ${r.code}`}. The goal stays active — fix it and claim again.\nCheck output (tail):\n${r.output || "(no output)"}`;
+        }
+        checkLine = `The completion check \`${current.check}\` passed (exit 0). Output tail:\n${r.output || "(no output)"}`;
+    }
+    // 2. The independent verifier: a separate model call that sees what the tools
+    //    actually returned, not just what the model says about them.
+    ctx.note("◎ goal verifier: checking the claim against the evidence…");
+    const verdict = await verifyGoal(ctx, current, report, checkLine);
+    emit("agent_goal_claim", { accepted: verdict.done ? 1 : 0, by: "verifier" });
+    if (!verdict.done) {
+        ctx.note(`◎ goal verifier: not done — ${verdict.reason.slice(0, 160)}`);
+        return `[goal] Not complete — the verifier rejected the claim: ${verdict.reason}\nThe goal stays active. Close the gap (or gather the missing evidence), then claim again.`;
+    }
+    setStatus("complete", verdict.reason.slice(0, 300));
+    ctx.note(`◎ goal complete ✓ — ${verdict.reason.slice(0, 160)}`);
+    return "Goal verified complete. Give the user a short final report: what was done and the evidence.";
+}
+// Run the user's check command. Output is capped to its TAIL — test runners
+// print the failures (and the summary) last.
+function runCheck(command, signal) {
+    return new Promise((resolve) => {
+        let out = "";
+        const child = spawn(command, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+        const keep = (b) => {
+            out = (out + b.toString("utf8")).slice(-CHECK_OUTPUT_TAIL * 4); // bounded memory, trimmed properly below
+        };
+        child.stdout.on("data", keep);
+        child.stderr.on("data", keep);
+        const kill = () => child.kill("SIGKILL");
+        const timer = setTimeout(kill, CHECK_TIMEOUT_MS);
+        signal.addEventListener("abort", kill, { once: true });
+        const done = (code) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", kill);
+            resolve({ code, output: out.slice(-CHECK_OUTPUT_TAIL).trim() });
+        };
+        child.on("error", (e) => {
+            out += `\n${e.message}`;
+            done(null);
+        });
+        child.on("close", (code) => done(code));
+    });
+}
+// The verifier's prompt is blunt for the same reason as the permission judge's:
+// a rigid tag is unambiguous to parse, and "doubt → no" is the load-bearing line.
+const VERIFIER_SYSTEM = `You verify whether a coding agent has ACHIEVED a goal. You are given the goal's objective, the agent's completion report, the result of the user's completion check (if any), and the agent's most recent tool calls with what they actually returned.
+Judge from the tool results — they are observations. The agent's report is a claim, not evidence. Every part of the objective must be demonstrably satisfied by the observations; if something is missing, unverified, or contradicted, the goal is NOT done.
+Err on the side of NO.
+Respond with exactly two lines:
+<done>yes</done> or <done>no</done>
+one sentence: why — if no, what is missing.`;
+// PURE: parse the verifier reply. Fail closed — only a clean yes is done.
+export function interpretVerdict(text) {
+    const m = text.match(/<done>\s*(yes|no)\s*<\/done>/i);
+    const reason = text.replace(/<done>[\s\S]*?<\/done>/i, "").trim().replace(/\s+/g, " ") || "(no reason given)";
+    if (!m)
+        return { done: false, reason: `unparseable verifier reply: ${text.trim().slice(0, 120) || "(empty)"}` };
+    return { done: m[1].toLowerCase() === "yes", reason };
+}
+// PURE: the agent's most recent tool calls with their results, newest last,
+// each capped, within a total budget — the verifier's evidence.
+export function recentObservations(messages) {
+    const results = new Map();
+    for (const m of messages)
+        if (m.role === "tool")
+            results.set(m.tool_call_id, typeof m.content === "string" ? m.content : "");
+    const items = [];
+    let used = 0;
+    for (let i = messages.length - 1; i >= 0 && used < OBSERVATIONS_BUDGET; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant" || !m.tool_calls)
+            continue;
+        for (const call of [...m.tool_calls].reverse()) {
+            if (call.type !== "function" || call.function.name === "update_goal" || !results.has(call.id))
+                continue;
+            const result = results.get(call.id);
+            const item = `$ ${call.function.name} ${call.function.arguments.slice(0, 300)}\n${result.length > OBSERVATION_CHARS ? result.slice(0, OBSERVATION_CHARS) + " …(truncated)" : result}`;
+            if (used + item.length > OBSERVATIONS_BUDGET)
+                break;
+            items.unshift(item);
+            used += item.length;
+        }
+    }
+    return items.length ? items.join("\n\n") : "(no tool calls in the conversation)";
+}
+async function verifyGoal(ctx, goal, report, checkLine) {
+    try {
+        const res = await ctx.client.chat.completions.create({
+            model: ctx.model,
+            max_tokens: VERIFIER_MAX_TOKENS,
+            temperature: 0,
+            messages: [
+                { role: "system", content: VERIFIER_SYSTEM },
+                { role: "user", content: [`Objective:\n${goal.objective}`, `Agent's completion report:\n${report}`, checkLine || "No completion check was configured.", `Recent tool calls and results (oldest first):\n${recentObservations(ctx.transcript)}`].join("\n\n") },
+            ],
+        }, { signal: ctx.signal });
+        return interpretVerdict(res.choices[0]?.message?.content ?? "");
+    }
+    catch (e) {
+        // A verifier that errors must never accidentally complete a goal.
+        return { done: false, reason: `the verifier call failed (${e.message}) — claim again` };
+    }
+}

package/dist/hooks.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process"; // hooks are external programs
+import { randomUUID } from "node:crypto"; // turn ids
 import chalk from "chalk"; // status lines
 import { CONFIG } from "./config.js"; // user-configured hooks
 import { emit } from "./telemetry.js"; // count hook activity
@@ -23,6 +24,39 @@ const DEFAULT_HOOK_TIMEOUT_MS = 10_000; // most hooks get 10s, then we kill it
 // Differentiated timeouts: SessionEnd fires when the user is leaving (often via
 // Ctrl+C) — it MUST return almost instantly, so it gets a tiny budget.
 const EVENT_TIMEOUT_MS = { SessionEnd: 1_500 };
+// Fields every payload carries, in Claude Code's names, so one hook script can
+// serve both agents: which session, where its transcript is, the working
+// directory, and which turn. An orchestrator uses them to tell sessions and
+// turns apart (a hook from an interrupted turn arrives late and must be dropped).
+let hookContext = {};
+let currentTurnId;
+export function setHookContext(context) {
+    hookContext = { ...context, cwd: process.cwd() };
+}
+// Start a new turn id. Called when a prompt is submitted (before its
+// UserPromptSubmit hook) or when a turn starts without one (cron, goals, peers).
+export function beginTurn() {
+    currentTurnId = randomUUID();
+    return currentTurnId;
+}
+// Claude Code's names for the tool fields, next to this agent's own
+// (tool/args/result), so existing hooks keep working.
+function claudeToolFields(payload) {
+    if (typeof payload.tool !== "string")
+        return {};
+    let input = payload.args;
+    try {
+        if (typeof payload.args === "string")
+            input = JSON.parse(payload.args);
+    }
+    catch {
+        /* not JSON — pass the raw string */
+    }
+    return { tool_name: payload.tool, tool_input: input, ...(typeof payload.result === "string" ? { tool_response: payload.result } : {}) };
+}
+function fullPayload(event, payload) {
+    return { event, hook_event_name: event, ...hookContext, prompt_id: currentTurnId, ...claudeToolFields(payload), ...payload };
+}
 // Run one hook process, feeding it the event payload on stdin.
 function runOne(hook, payload, timeoutMs) {
     return new Promise((resolve) => {
@@ -58,7 +92,7 @@ export async function runHooks(event, payload) {
     let rewrite; // a PreToolUse hook's replacement args
     const timeout = EVENT_TIMEOUT_MS[event] ?? DEFAULT_HOOK_TIMEOUT_MS; // SessionEnd gets a tiny budget
     for (const hook of hooks) {
-        const { code, stdout: out, stderr: err } = await runOne(hook, { event, ...payload }, timeout); // run it
+        const { code, stdout: out, stderr: err } = await runOne(hook, fullPayload(event, payload), timeout); // run it
         emit("agent_hook_run", { event, code }); // observability for hooks themselves
         if (code === 0) {
             if (out) {
@@ -90,3 +124,26 @@ export async function runHooks(event, payload) {
     }
     return { block, feedback: feedback.join("\n"), stdout: stdout.join("\n"), rewrite };
 }
+export async function runPermissionHooks(payload) {
+    const hooks = (CONFIG.hooks.PermissionRequest ?? []).filter((h) => !h.match || h.match === payload.tool);
+    let allowed = false;
+    for (const hook of hooks) {
+        const { code, stdout, stderr } = await runOne(hook, fullPayload("PermissionRequest", payload), DEFAULT_HOOK_TIMEOUT_MS);
+        emit("agent_hook_run", { event: "PermissionRequest", code });
+        if (code === 2)
+            return { behavior: "deny", message: stderr || "denied by a PermissionRequest hook" };
+        if (code !== 0 || !stdout)
+            continue;
+        try {
+            const decision = JSON.parse(stdout).hookSpecificOutput?.decision;
+            if (decision?.behavior === "deny")
+                return { behavior: "deny", message: decision.message || "denied by a PermissionRequest hook" };
+            if (decision?.behavior === "allow")
+                allowed = true;
+        }
+        catch {
+            /* not a decision — ignore */
+        }
+    }
+    return allowed ? { behavior: "allow" } : null;
+}

package/dist/ink/app.js

@@ -20,19 +20,20 @@ import { clearUndo } from "../undo.js";
 import { clearTodos } from "../todos.js";
 import { resetTeam } from "../team.js";
 import { resetBoard } from "../board.js";
+import { goalCommand, getGoal, restoreGoal, clearGoal, startGoalTurn, settleGoalTurn } from "../goal.js"; // /goal (Day 41): keep starting turns until the goal is verified done
 import { clearReasoning, clearToolCalls, getReasoning, getToolCalls, getToolActivity, getToolCallCount, 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 { currentSession, peerInboxPending, readPeerInbox, peerMessageContent, peersCommand, setSessionState, setSessionInfo, listPeers, findPeer, peerRow, sendPeerMessage, SCREEN_KINDS, MAX_PEER_TURNS } from "../peers.js"; // peer sessions: messages from other mini-agent windows start a turn while idle
 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 { newSessionId, saveSession, listSessions, loadSession, setSessionTitle, sessionPath } from "../session.js";
 import { generateSessionTitle, setTerminalTitle, refreshTerminalTitle, flashTerminalTitle } from "../title.js"; // concise session name, generated after the first message + the terminal tab that shows it
 import { isPlanMode, setPlanMode } from "../permissions.js";
 import { findSkill, recordSkillUsage, skillSource, skillUsageScores, userSkillMessages } from "../skills.js";
 import { SkillsPanel } from "./skills-panel.js"; // /skills: Claude Code's on / user-only / off manager
 import { extractMemories } from "../memory.js";
 import { displayWidth } from "../editor.js"; // display-width measurement (CJK-aware)
-import { runHooks } from "../hooks.js";
+import { runHooks, setHookContext, beginTurn } from "../hooks.js";
 import { emit } from "../telemetry.js";
 import { reviewDebugCommand } from "../auto-debug.js";
 import { readClipboard, imageLabel, imagesInInput, userContent, MAX_IMAGES } from "../images.js";
@@ -196,6 +197,8 @@ export function App({ session, runTurn, clipboard }) {
     const [menuSel, setMenuSel] = useState(0); // the select menu's cursor
     const [formState, setFormState] = useState(null); // the ask_user form's state
     const [sessionId, setSessionId] = useState(session.initialSessionId); // changes on /clear, /resume
+    useEffect(() => setHookContext({ session_id: sessionId, transcript_path: sessionPath(sessionId) }), [sessionId]); // hooks always name the current session
+    const turnIdReady = useRef(false); // a submitted prompt already started this turn's id (before its UserPromptSubmit hook)
     const [planMode, setPlan] = useState(isPlanMode()); // mirrored into the prompt frame
     const [autoEnabled, setAutoEnabled] = useState(autoMode.enabled);
     const [histIdx, setHistIdx] = useState(null); // ↑/↓ recall position (null = editing a fresh line)
@@ -250,7 +253,7 @@ export function App({ session, runTurn, clipboard }) {
     // as the prompt (a user highlight bar, or a note for /skill); the loop appends
     // `content` to `messages` itself. The permission menu + ask_user form raise a
     // `pending` prompt that returns a promise the loop awaits.
-    const runConversationTurn = (content, display, attachments = []) => {
+    const runConversationTurn = (content, display, attachments = [], goalTurn = false) => {
         setDetails(null);
         setDetailOffset(0);
         if (display)
@@ -263,6 +266,10 @@ export function App({ session, runTurn, clipboard }) {
         // another agent's message, not your message relayed from another window.
         const suggestAfter = CONFIG.promptSuggestions && !senders.length && (content === null || display?.kind === "user");
         const seq = ++suggestionSeq.current;
+        if (!turnIdReady.current)
+            beginTurn(); // cron, goal and peer turns get their id here
+        turnIdReady.current = false;
+        let ending = { reason: "error", text: "" }; // what the TurnEnd hook reports
         setSuggestion(null);
         setBusy(true);
         setSessionState("busy", CONFIG.model); // other sessions see "busy" in list_peers
@@ -300,18 +307,22 @@ export function App({ session, runTurn, clipboard }) {
         runTurn(content, hooks)
             .then(async (result) => {
             // A turn started by the user from another window: show them the answer there.
+            ending = { reason: result.reason, text: result.finalText ?? "" };
             for (const to of senders)
                 sendPeerMessage(to, result.finalText?.trim() || `(finished: ${result.reason})`, "reply");
             if (result.reason !== TerminateReason.Done && !(result.reason === TerminateReason.UserInterrupt && followUps.size))
                 note(chalk.yellow(`⚠️ ${EXIT_NOTES[result.reason] ?? result.reason}`));
-            saveSession(sessionId, model, messages, pendingTitle.current); // snapshot after every turn — crash-safe by construction
+            const goalNote = settleGoalTurn(result.reason, goalTurn, result.reason === TerminateReason.UserInterrupt && followUps.size > 0); // Day 41: pause on Esc / failure / no progress
+            if (goalNote)
+                note(chalk.yellow(goalNote));
+            saveSession(sessionId, model, messages, pendingTitle.current); // snapshot after every turn — crash-safe by construction (the goal's state rides along)
             if (suggestAfter && result.reason === TerminateReason.Done) {
                 void generatePromptSuggestion(client, CONFIG.model, messages, lastRequestTools()).then((guess) => {
                     if (guess && seq === suggestionSeq.current)
                         setSuggestion(guess); // no newer turn started meanwhile (the box shows it only while idle)
                 });
             }
-            if (CONFIG.memory.autoExtract && result.reason === TerminateReason.Done) {
+            if (CONFIG.memory.autoExtract && result.reason === TerminateReason.Done && !goalTurn) { // not after every automatic goal turn — that would bill an extraction per continuation
                 try {
                     const got = await extractMemories(client, CONFIG.subAgentModel || model, messages);
                     if (got.length)
@@ -322,13 +333,22 @@ export function App({ session, runTurn, clipboard }) {
                 }
             }
         })
-            .catch((e) => note(chalk.red(`[error] ${e.message}`)))
+            .catch((e) => {
+            note(chalk.red(`[error] ${e.message}`));
+            const goalNote = settleGoalTurn("error", goalTurn); // a crashed goal turn pauses the goal instead of retrying forever
+            if (goalNote)
+                note(chalk.yellow(goalNote));
+        })
             .finally(() => {
             turn.current = null;
             setSessionState("idle");
             setBusy(false);
             setStatus(null);
             setLive(null);
+            // The one signal that fires at the end of EVERY turn, after the session
+            // is saved: Stop does not fire on an interrupt or an error, and fires
+            // before the save. An orchestrator reads this as "idle, transcript current".
+            void runHooks("TurnEnd", { reason: ending.reason, last_assistant_message: ending.text });
         });
     };
     // Covers immediate interruption and a message arriving as the turn finishes.
@@ -360,6 +380,27 @@ export function App({ session, runTurn, clipboard }) {
         return () => clearInterval(id);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [busy, pending]);
+    // The GOAL idle processor (Day 41): while a /goal is active and the REPL is
+    // idle — no turn, no menu, no queued message — start the next goal turn. This
+    // is the whole "keep going" mechanism: the model can stop as often as it
+    // likes, but it is sent straight back until update_goal ends the goal, or
+    // settleGoalTurn pauses it (Esc, a failed turn, no progress). Plan mode never
+    // continues: plan-only work can't move a goal forward.
+    useEffect(() => {
+        if (busy || pending || followUps.size || planMode)
+            return; // human input first; plan mode is read-only
+        const id = setInterval(() => {
+            if (turn.current || followUps.size)
+                return;
+            const content = startGoalTurn();
+            if (!content)
+                return;
+            const goal = getGoal();
+            runConversationTurn(content, { kind: "note", text: chalk.cyan(`◎ goal · turn ${goal.continuations}: ${goal.objective.slice(0, 70)}`) }, [], true); // a note, not a user bar — you didn't type it
+        }, 500);
+        return () => clearInterval(id);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [busy, pending, planMode]);
     // The PEER idle processor: another mini-agent session messaged this one while
     // it sat at the prompt. Like cron, start a turn so the agent answers on its
     // own. Two agents answering each other could run forever (and bill for every
@@ -490,7 +531,16 @@ export function App({ session, runTurn, clipboard }) {
         if (!pending && await handleCommand(draft))
             return;
         const text = pastedTexts.expand(draft);
+        // A prompt typed while a turn runs is a follow-up that belongs to that turn;
+        // only a prompt that starts a turn gets a new turn id.
+        const startsTurn = !pending && !turn.current && !followUps.size;
+        if (startsTurn) {
+            beginTurn();
+            turnIdReady.current = true;
+        }
         const hook = await runHooks("UserPromptSubmit", { prompt: text });
+        if (hook.block)
+            turnIdReady.current = false;
         if (hook.block)
             return note(chalk.yellow(`(prompt blocked by a UserPromptSubmit hook: ${hook.feedback.slice(0, 150)})`));
         const injected = hook.stdout ? `\n\n[context added by a UserPromptSubmit hook]\n${hook.stdout}` : "";
@@ -730,9 +780,17 @@ export function App({ session, runTurn, clipboard }) {
             runConversationTurn(userSkillMessages(s, args), { kind: "note", text: chalk.dim(`(running skill: ${s.name})`) });
             return true;
         }
+        if (line === "/goal" || line.startsWith("/goal ")) {
+            const { message, request } = goalCommand(line.slice(5));
+            if (request)
+                autoMode.recordRequest(request); // the /goal you typed is the authorization; automatic goal turns never are
+            note(chalk.cyan(message)); // setting or resuming a goal: the idle processor starts the turn
+            return true;
+        }
         switch (line) {
             case "/clear":
                 autoMode.clearRequests();
+                clearGoal(); // the goal belonged to the old conversation
                 messages.length = 0; // mutate in place — same array ref the loop holds
                 messages.push({ role: "system", content: systemMessage });
                 forgetFilesExcept([]);
@@ -804,6 +862,15 @@ export function App({ session, runTurn, clipboard }) {
                     resetTeam();
                     resetBoard();
                     note(chalk.dim(`(resumed ${chosen.id} — ${chosen.messages.length} messages; files must be re-read before editing)`));
+                    // Unlike the todos and the board, the goal comes BACK with its session (Day 41).
+                    restoreGoal(chosen.goal);
+                    const goal = getGoal();
+                    if (goal?.status === "active") {
+                        autoMode.recordRequest(`/goal ${goal.objective}`);
+                        note(chalk.cyan(`◎ resumed an ACTIVE goal — the agent continues it now (Esc pauses): ${goal.objective.slice(0, 80)}`));
+                    }
+                    else if (goal)
+                        note(chalk.dim(`(◎ goal restored [${goal.status}] — /goal to see it, /goal resume to continue)`));
                 });
                 return true;
             }
@@ -1064,6 +1131,23 @@ export function App({ session, runTurn, clipboard }) {
         else if (key.ctrl && char === "e") {
             setCursor(input.length); // End — jump to the end of the line
         }
+        else if ((key.ctrl && char === "u") || /^\x15+$/.test(char)) {
+            // ctrl+u deletes from the caret back to the start of its line, like a
+            // shell; at the start of a line it joins the line to the one above, so
+            // repeated presses clear a multi-line draft. Several presses can arrive
+            // as one chunk when a program types them.
+            let next = input;
+            let at = cursor;
+            for (let presses = key.ctrl ? 1 : char.length; presses > 0 && at > 0; presses--) {
+                const lineStart = next.lastIndexOf("\n", at - 1) + 1;
+                const from = lineStart === at ? at - 1 : lineStart;
+                next = next.slice(0, from) + next.slice(at);
+                at = from;
+            }
+            setInput(next);
+            setCursor(at);
+            setHistIdx(null);
+        }
         else if (key.upArrow) {
             // ↑ recall an earlier prompt (newest-first), like a shell; caret to its end.
             if (!history.length)