atom-agent 1.1.0 → 1.3.0

package/dist/agent/loop.js

@@ -9,20 +9,25 @@
 // call); everything else executes strictly serially in program order. A
 // failure in one call NEVER skips the remaining commits of its block when
 // the results are values; malformed calls yield their error result inline.
-// A thrown execution error (or cancel) aborts the turn exactly as the old
-// serial loop did — the caller rolls the partial turn back, so
-// assistant/tool pairing stays valid.
+// A length-truncated response (`truncated: true`: the output limit cut tool
+// arguments off) executes nothing — each carried call commits a
+// repair-oriented error result and the turn continues to the next model
+// round, bounded by the step/total-call budgets. A thrown execution error
+// (or cancel) aborts the turn exactly as the old serial loop did — the
+// caller rolls the partial turn back, so assistant/tool pairing stays valid.
 //
 // Dependency direction: agent/loop -> {tools, tools/read-cache,
 // scheduler, config, context-manager, agent/gates, agent/loop-guard,
 // agent/normalize, agent/types} and NOT zen (transports stay in
 // zen.ts; runAgenticLoopForProvider wraps this loop from there).
 import { loadAtomConfig } from "../config.js";
-import { createContextManager, historyCharBudget, historyChars, historyMessageBudget, truncateHistoryWithCaps, } from "../context-manager.js";
+import { historyChars } from "../context-manager.js";
 import { planBatches } from "../scheduler.js";
-import { describeToolCall, executeTool, invalidCall, MAX_TOOL_STEPS, needsApproval, toolNames, validateAskQuestionArgs, validateToolArgs, } from "../tools.js";
+import { describeToolCall, executeTool, invalidCall, needsApproval, toolNames, validateAskQuestionArgs, validateToolArgs, } from "../tools.js";
+import { afterToolInterceptors, applyAfterInterceptors, applyBeforeInterceptors, beforeToolInterceptors, blockedToolResult, } from "../tools/intercept.js";
 import { getReadCacheStats } from "../tools/read-cache.js";
-import { bashExitCode, evaluateTurnEnd, isCodePath, isVerificationCommand, openTodoNeedles, } from "./gates.js";
+import { emptyGoalProgress, GOAL_STALL_REPEATS, goalFollowUp, goalPausedNotice, goalReportAck, goalReportOutsideError, goalReportRejectedNotice, goalStallNudge, goalStallReached, goalVerdictNotice, noteGoalProgress, recentTurnsForJudge, resetGoalStall, sameGoalDisposition, updateGoalDisposition, validateUpdateGoalArgs, } from "../goal.js";
+import { bashExitCode, evaluateTurnEnd, isCodePath, isVerificationCommand, todoCompletionGate, verificationGate, } from "./gates.js";
 import { errorStreakFollowUp, ErrorStreakTracker, repetitionFollowUp, RepetitionGuard, repetitionStopNotice, } from "./loop-guard.js";
 import { normalizeChatResult, normalizeToolResult, toolSignature } from "./normalize.js";
 // Whole-turn cancellation: thrown when the user cancels (Ctrl+C) mid-loop.
@@ -53,9 +58,10 @@ export function throwIfCancelled(signal) {
     if (signal?.aborted)
         throw new LoopCancelledError();
 }
-// Tool-round budget for one agentic turn (env → atom.json → 30).
-// A real explore → implement → verify task needs 15–30 tool rounds, so the
-// default is 30; an explicit `opts.maxSteps` still wins (tests inject it).
+// Tool-round budget for one agentic turn (env → atom.json → unlimited).
+// No default cap: the turn runs until the model ends it, a gate stops it,
+// or the user cancels. An explicit `opts.maxSteps` (or env/file value) still
+// caps the turn (tests inject it).
 export function toolStepBudget() {
     const raw = process.env.ATOM_MAX_TOOL_STEPS;
     if (raw !== undefined) {
@@ -66,14 +72,25 @@ export function toolStepBudget() {
                 return Math.min(Math.max(Math.floor(n), 5), 100);
         }
     }
-    return loadAtomConfig().config.maxToolSteps ?? MAX_TOOL_STEPS;
+    return loadAtomConfig().config.maxToolSteps ?? Number.POSITIVE_INFINITY;
 }
-// Legacy trim entry: byte-identical contract (legacy env/config/default caps
-// + live todo pinning, same notice, same in-place splice). New code should
-// use a ContextManager (derived, window-aware caps); the loop core does when
-// it knows the model (see AgenticOpts.context).
-export function truncateHistory(history, notify, reserve) {
-    return truncateHistoryWithCaps(history, { maxMessages: historyMessageBudget(), maxChars: historyCharBudget() }, { notify, reserve, todoNeedles: openTodoNeedles() });
+// Empty-response recovery (live-proven on free-tier gateways: a 200-OK
+// stream can carry only queue comments and reasoning with zero answer text
+// and zero tool calls, which the transport reports as an `Empty reply`
+// error). A failed POST normally aborts the turn — EXCEPT this one: ending
+// the turn on model silence with no fallback makes flaky backends fatal, so
+// the loop spends a bounded number of extra POSTs asking the model to repair
+// (same assistant+user follow-up shape as the turn-end gates, so pairing
+// stays valid). When the budget is spent the original error throws, exactly
+// as before — the caller rolls back and the user sees it.
+export const MAX_EMPTY_ROUNDS = 2;
+export function isEmptyReplyError(e) {
+    return e instanceof Error && e.message.startsWith("Empty reply");
+}
+export function emptyResponseFollowUp(attempt) {
+    return (`(empty response: attempt ${attempt} returned no text and no tool calls — ` +
+        `the turn cannot end on silence. Continue with tool calls toward the goal, ` +
+        `or answer in text. If there is genuinely nothing to do, end by saying so explicitly.)`);
 }
 // Per-tool outer timeout (ms): undefined → default 60s (enabled); explicit
 // <=0/NaN → disabled (direct await, zero overhead). Clamped 1s–120s when
@@ -88,12 +105,13 @@ export function resolveToolTimeoutMs(raw) {
         return null;
     return Math.min(Math.max(Math.floor(raw), 1000), 120_000);
 }
-// Total tool-call budget per turn (default 200, min 1). Existing suites peak
-// near 30 calls/turn, so the default only caps parallel-batch explosions.
-export const DEFAULT_MAX_TOTAL_TOOL_CALLS = 200;
+// Total tool-call budget per turn (no default cap; explicit opts value only,
+// min 1). Previously defaulted to 200 as a parallel-batch explosion guard.
+// Deprecated alias kept for import compatibility; the loop no longer uses it.
+export const DEFAULT_MAX_TOTAL_TOOL_CALLS = Number.POSITIVE_INFINITY;
 export function resolveMaxTotalToolCalls(raw) {
     if (typeof raw !== "number" || !Number.isFinite(raw))
-        return DEFAULT_MAX_TOTAL_TOOL_CALLS;
+        return Number.POSITIVE_INFINITY;
     return Math.max(1, Math.floor(raw));
 }
 // Race one execution against the outer timeout. Timeout resolves to an
@@ -142,26 +160,100 @@ export async function executeWithTimeout(execute, name, parsed, timeoutMs, signa
             clearTimeout(timer);
     }
 }
-// Execute one parsed tool call through validation + permission +
-// ask_question gates. Model mistakes (unknown name, invalid args) return
-// repairs-oriented results WITHOUT executing; cancellations propagate as
-// LoopCancelledError (never a result, never retried). Everything else
-// returns a result string fed back to the model:
+// Permission-gate resolution shared by the serial path and the parallel
+// pre-pass: returns the hook's decision, or null when no approval applies
+// (no hook, or a tool that never needs it). A "no" (or a throwing hook)
+// denies without executing; cancellation always propagates.
+async function resolveApproval(name, parsed, opts) {
+    if (!opts?.approve || !needsApproval(name))
+        return null;
+    try {
+        const decision = await opts.approve(name, parsed);
+        // Abort that lands as a resolved denial still cancels the whole turn.
+        throwIfCancelled(opts?.signal);
+        return decision;
+    }
+    catch (e) {
+        // Whole-turn cancellation must propagate (Ctrl+C cancels the turn,
+        // not just deny one call). Anything else is a denial.
+        if (isCancelError(e) || opts?.signal?.aborted)
+            throw new LoopCancelledError();
+        return "no";
+    }
+}
+// Extension tool-call interception (ticket 03): global pre/post hooks
+// registered via ExtensionAPI.onBeforeToolCall/onAfterToolCall. Both
+// helpers snapshot the live handler list and never throw — a throwing
+// before handler fails closed (blocked outcome), a throwing after handler
+// fails open (original content). Cancellation checks stay where they are;
+// hooks are in-process policy, not executions, so they run even when the
+// signal is armed and the existing boundaries still stop the turn.
+async function runBeforeIntercept(name, parsed) {
+    try {
+        return await applyBeforeInterceptors(beforeToolInterceptors(), name, parsed);
+    }
+    catch {
+        return { args: parsed, blocked: blockedToolResult(name, "(unknown)", "interception failed") };
+    }
+}
+async function runAfterIntercept(name, parsed, result, isError) {
+    try {
+        return await applyAfterInterceptors(afterToolInterceptors(), { name, args: parsed, result, isError });
+    }
+    catch {
+        return { content: result, isError };
+    }
+}
+// Execute one parsed tool call through interception + validation +
+// permission + ask_question gates. Model mistakes (unknown name, invalid
+// args) return repairs-oriented results WITHOUT executing; cancellations
+// propagate as LoopCancelledError (never a result, never retried).
+// Everything else returns the result string plus the effective (post-
+// rewrite) args the commit funnel must use for gates, labels, and pairing:
+// - Hook-vs-approval ordering: pre-hooks run BEFORE validation and
+//   approval. The hook sees the call pre-approval and may rewrite args
+//   before the approval prompt shows them; a block short-circuits approval
+//   entirely (no prompt for a call that never runs). Rewrites always
+//   re-validate before execution, so a hook can never smuggle unvalidated
+//   args into an executor.
+// - Unknown names never reach hooks (model mistake — nothing would run).
+//   update_goal is the one exemption (ticket 03): a loop-intercepted tool
+//   like ask_question, resolved without an executor via onUpdateGoal.
 // - ask_question never needs approval; without an askUser hook it resolves
 //   to "Error: ask_question has no UI hook".
-// - write/edit/bash consult the approve hook when one is provided; a "no"
-//   resolves to "Error: denied by user: <tool>" (final, no retry/rollback).
-//   Without a hook every tool executes immediately.
-async function runOneTool(call, parsed, opts, execute) {
+// - update_goal never needs approval either; without the per-turn recorder
+//   (only runLoopWithChat supplies it) it resolves to the outside-turn error.
+// - write/edit/bash consult the approve hook when one is provided (or a
+//   pre-resolved batch decision); a "no" resolves to
+//   "Error: denied by user: <tool>" (final, no retry/rollback). Without a
+//   hook every tool executes immediately.
+async function runOneTool(call, parsed, opts, execute, preDecision, onUpdateGoal) {
     const name = call?.function?.name ?? "(unknown)";
-    // Unknown tool: model mistake — list actual names, never execute.
-    if (!toolNames().includes(name)) {
-        return `Error: unknown tool "${name}". Available: ${toolNames().join(", ")}`;
+    // update_goal bypasses the unknown-name gate (ticket 03): a
+    // loop-intercepted tool like ask_question — the registry owns builtins
+    // only, so the loop exempts it by name here; runOneToolWithArgs below
+    // validates it and resolves it without an executor (never needs approval).
+    if (name !== "update_goal" && !toolNames().includes(name)) {
+        return { result: `Error: unknown tool "${name}". Available: ${toolNames().join(", ")}`, args: parsed };
+    }
+    const pre = await runBeforeIntercept(name, parsed);
+    if (pre.blocked !== null) {
+        return { result: pre.blocked, args: pre.args };
     }
+    return runOneToolWithArgs(call, pre.args, opts, execute, preDecision, onUpdateGoal);
+}
+// Inner execution after pre-interception: validate (rewritten) args, then
+// permission + ask_question/update_goal gates, then the executor. Shared by
+// the serial path (via runOneTool) and the parallel batch (via the pre-pass
+// below, which resolves pre-hooks serially so prompts never run concurrently).
+async function runOneToolWithArgs(call, parsed, opts, execute, preDecision, onUpdateGoal) {
+    const name = call?.function?.name ?? "(unknown)";
     // Argument validation BEFORE approval/execution: model mistake, never runs.
+    // Pre-hook rewrites arrive here already applied, so they re-validate on
+    // exactly what would execute — invalid rewrites never reach an executor.
     const detail = validateToolArgs(name, parsed);
     if (detail) {
-        return invalidCall(detail);
+        return { result: invalidCall(detail), args: parsed };
     }
     if (name === "ask_question") {
         throwIfCancelled(opts?.signal);
@@ -169,28 +261,26 @@ async function runOneTool(call, parsed, opts, execute) {
         // LoopCancelledError (no result). If it resolves just as the signal
         // aborts, return the result — the loop records it, then stops before
         // the next POST (no new POSTs, pairing stays valid until rollback).
-        return runAskQuestion(parsed, opts?.askUser, opts?.signal);
+        return { result: await runAskQuestion(parsed, opts?.askUser, opts?.signal), args: parsed };
     }
-    if (opts?.approve && needsApproval(name)) {
-        let decision;
-        try {
-            decision = await opts.approve(name, parsed);
-        }
-        catch (e) {
-            // Whole-turn cancellation must propagate (Ctrl+C cancels the turn,
-            // not just deny one call). Anything else is a denial.
-            if (isCancelError(e) || opts?.signal?.aborted)
-                throw new LoopCancelledError();
-            decision = "no";
-        }
-        // Abort that lands as a resolved denial still cancels the whole turn.
+    if (name === "update_goal") {
         throwIfCancelled(opts?.signal);
-        if (decision === "no") {
-            return `Error: denied by user: ${name}`;
-        }
-        // "once" runs this call; "always" runs it too (the caller caches the
-        // always-allowed set session-wide so later calls skip the prompt).
+        // Goal-disposition report (ticket 03): ask_question-shaped — validated,
+        // never needs approval, resolved without an executor (the per-turn slot
+        // recorder owns the record; execute never sees this name, so plan-mode
+        // and approval policy are untouched). Without the recorder (never from
+        // runLoopWithChat — both call sites thread it) the call is outside any
+        // goal turn by construction.
+        if (!onUpdateGoal)
+            return { result: goalReportOutsideError(), args: parsed };
+        return { result: onUpdateGoal(parsed), args: parsed };
+    }
+    const decision = preDecision ?? (await resolveApproval(name, parsed, opts));
+    if (decision === "no") {
+        return { result: `Error: denied by user: ${name}`, args: parsed };
     }
+    // "once"/"always" run this call (the caller caches the always-allowed set
+    // session-wide so later calls skip the prompt).
     // No new executions after a cancel: stop after the current tool finishes.
     // The current tool (if already running) is awaited to completion and its
     // result IS recorded — the loop then stops before the next tool/POST, so
@@ -201,8 +291,8 @@ async function runOneTool(call, parsed, opts, execute) {
     try {
         const raw = await executeWithTimeout(execute, name, parsed, timeoutMs, opts?.signal);
         if (doNormalize)
-            return normalizeToolResult(raw);
-        return typeof raw === "string" ? raw : normalizeToolResult(raw);
+            return { result: normalizeToolResult(raw), args: parsed };
+        return { result: typeof raw === "string" ? raw : normalizeToolResult(raw), args: parsed };
     }
     catch (e) {
         if (isCancelError(e) || opts?.signal?.aborted)
@@ -210,6 +300,35 @@ async function runOneTool(call, parsed, opts, execute) {
         throw e;
     }
 }
+// After-tool-call result hook (issue 06): the single rewrite seam between
+// execution and commit. Absent hook (or null/undefined/void/non-object
+// return) → the original result, byte-identical. A string return replaces
+// content (error flag kept); an object may replace content, override
+// isError, or veto the commit. Hook failures degrade to the original — the
+// turn never breaks. Telemetry keeps the pre-hook execution result; only the
+// committed history/transcript/activity sees the rewrite.
+async function applyToolResultHook(hook, name, parsed, result, isError) {
+    if (!hook)
+        return { content: result, isError, veto: false };
+    try {
+        const decision = await hook({ name, args: parsed, result, isError });
+        if (decision === null || decision === undefined)
+            return { content: result, isError, veto: false };
+        if (typeof decision === "string")
+            return { content: decision, isError, veto: false };
+        if (typeof decision === "object") {
+            if (decision.veto === true)
+                return { content: result, isError, veto: true };
+            const content = typeof decision.content === "string" ? decision.content : result;
+            const nextIsError = typeof decision.isError === "boolean" ? decision.isError : isError;
+            return { content, isError: nextIsError, veto: false };
+        }
+        return { content: result, isError, veto: false };
+    }
+    catch {
+        return { content: result, isError, veto: false };
+    }
+}
 async function runAskQuestion(parsed, askUser, signal) {
     const invalid = validateAskQuestionArgs(parsed);
     if (invalid)
@@ -302,19 +421,104 @@ export async function runLoopWithChat(chatFn, history, opts) {
     let verifiedAfterWrite = false;
     let needsVerification = false;
     let unverifiedPaths = [];
-    // Verification-gate nag cycles spent (bounds the continue loop alongside
-    // the step budget — a model that never verifies still terminates).
+    // Verification-gate nag cycles spent (bounds the continue loop via
+    // MAX_VERIFY_ROUNDS — a model that never verifies still terminates).
     let verifyRounds = 0;
-    // At most one truncation notice per turn; silence when nothing dropped.
-    let truncationNoticed = false;
-    // Window-aware trimmer when the caller knows the model (App passes it);
-    // created once per turn — ceiling sources resolve once, history is
-    // re-measured every step. Absent → the legacy fixed caps below.
-    const contextManager = opts?.context
-        ? createContextManager({ model: opts.context.model, toolsChars: opts.context.toolsChars })
-        : null;
-    // ---- Hardened-loop state (additive; defaults preserve the pinned
-    // maxSteps contract — see AgenticOpts docs) ----
+    // Todo-guard cycles spent (bounds guard continues via MAX_TODO_ROUNDS —
+    // a model that never resolves open todos still terminates).
+    let todoRounds = 0;
+    // Goal engagement (ticket 02): set the first time a completed POST
+    // observes a live goal. A goal cleared mid-run still counts its final
+    // turn (the work happened); a run that never saw a goal counts nothing.
+    let goalEngaged = false;
+    // Disposition slot (ticket 03): the model-reported outcome for the CURRENT
+    // goal turn, recorded by update_goal calls and consumed at the next turn
+    // end BEFORE the auto-continue decision. Reset per run and on every
+    // consumption — a report never leaks into the following turn.
+    let pendingDisposition = null;
+    // Read the live goal without ever throwing (a failing accessor ends the
+    // turn normally — the goal simply does not continue).
+    const readLiveGoal = () => {
+        try {
+            return opts?.goal?.getGoal?.() ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Pause-with-preservation via the App-owned callback (state flip plus a
+    // visible notice; the goal text and stats survive). Never throws.
+    const pauseLiveGoal = (objective, reason) => {
+        try {
+            opts?.goal?.pauseGoal(goalPausedNotice(objective, reason));
+        }
+        catch {
+            // observer errors never break the loop
+        }
+    };
+    // Verdict pause (ticket 03): terminal dispositions pause with their own
+    // verdict wording — no goalPausedNotice wrap, the verdict IS the notice
+    // (it already names the objective and carries the reason). Never throws.
+    const pauseLiveGoalWithNotice = (notice) => {
+        try {
+            opts?.goal?.pauseGoal(notice);
+        }
+        catch {
+            // observer errors never break the loop
+        }
+    };
+    // Record one update_goal report into the per-turn slot (ticket 03), in
+    // order: bad args are a model mistake (invalid-call error, nothing
+    // recorded); with no live active goal the call is outside any goal turn
+    // (structured error, zero state change); after a terminal report anything
+    // further is rejected with a notice (first report sticks); the same value
+    // twice is idempotent; otherwise the report replaces any pending
+    // non-terminal one (last wins). Pure parts live in goal.ts; this closure
+    // only owns the slot read/write. Never throws — results are strings.
+    const recordGoalReport = (parsed) => {
+        const detail = validateUpdateGoalArgs(parsed);
+        if (detail)
+            return invalidCall(detail);
+        const live = readLiveGoal();
+        if (live === null || !live.active)
+            return goalReportOutsideError();
+        const next = updateGoalDisposition(parsed);
+        if (pendingDisposition !== null && pendingDisposition.status !== "continue") {
+            return goalReportRejectedNotice(pendingDisposition);
+        }
+        if (pendingDisposition !== null && sameGoalDisposition(pendingDisposition, next)) {
+            return goalReportAck(next);
+        }
+        pendingDisposition = next;
+        return goalReportAck(next);
+    };
+    // Take the pending report and clear the slot (ticket 03 consumption reads
+    // through here so the declared return type drives the turn-end checks —
+    // the captured slot's direct-flow narrowing would otherwise collapse the
+    // read to null). A report never leaks into the following turn.
+    const takeDisposition = () => {
+        const current = pendingDisposition;
+        pendingDisposition = null;
+        return current;
+    };
+    // Novelty progress (ticket 05): per-run memory of committed-result
+    // fingerprints plus the consecutive-non-novel streak. Recorded in the
+    // commit funnel below; read at goal turn end for the stall redirect.
+    // Loop-local is sufficient: a whole goal run normally lives inside one
+    // runLoopWithChat call (continuations `continue` the loop; only
+    // terminal/cancel/budget/failure return).
+    const goalProgress = emptyGoalProgress();
+    // One goal turn taken (guarded — accounting never breaks the turn).
+    const noteGoalTurn = () => {
+        try {
+            opts?.goal?.onGoalTurn?.();
+        }
+        catch {
+            // observer errors never break the loop
+        }
+    };
+    // ---- Hardened-loop state (additive; explicit caps still honored —
+    // see AgenticOpts docs) ----
     const maxTotalToolCalls = resolveMaxTotalToolCalls(opts?.maxTotalToolCalls);
     const repGuard = new RepetitionGuard({ maxRepeatedCalls: opts?.maxRepeatedCalls });
     const errStreak = new ErrorStreakTracker(opts?.maxConsecutiveErrors);
@@ -336,7 +540,9 @@ export async function runLoopWithChat(chatFn, history, opts) {
     let modelCalls = 0;
     let toolCalls = 0;
     let failures = 0;
-    let droppedTurnsTotal = 0;
+    // Empty-response repairs spent (bounded by MAX_EMPTY_ROUNDS — a model
+    // that only answers silence still terminates).
+    let emptyRounds = 0;
     let bottleneck = null;
     const noteBottleneck = (name, durationMs) => {
         if (!Number.isFinite(durationMs) || durationMs < 0)
@@ -368,7 +574,6 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 failures,
                 repetitionHits: repGuard.hitCount,
                 cacheHits,
-                truncationNotices: droppedTurnsTotal,
                 durationMs: Math.max(0, Date.now() - turnStartMs),
                 bottleneck,
                 contextGrowthChars: endChars - startChars,
@@ -384,41 +589,13 @@ export async function runLoopWithChat(chatFn, history, opts) {
             throwIfCancelled(signal);
             // Steering seam: drain one pending steer message (if any) at this safe
             // point — previous tool batches are fully committed, so assistant/tool
-            // pairing can never split. Runs before the budget trim so truncation
-            // accounts for the injected message. No-op without the hook.
+            // pairing can never split. No-op without the hook.
             try {
                 opts?.drainSteer?.();
             }
             catch {
                 // observer errors never break the loop
             }
-            // History budget (uniform for all providers — every POST flows through
-            // here): trim oldest user-turns first before each send.
-            const trimmed = contextManager
-                ? contextManager.trimForSend(history, truncationNoticed
-                    ? undefined
-                    : (notice) => {
-                        try {
-                            opts?.onWarning?.(notice);
-                        }
-                        catch {
-                            // ignore observer errors
-                        }
-                    }, undefined, openTodoNeedles())
-                : truncateHistory(history, truncationNoticed
-                    ? undefined
-                    : (notice) => {
-                        try {
-                            opts?.onWarning?.(notice);
-                        }
-                        catch {
-                            // ignore observer errors
-                        }
-                    });
-            if (trimmed.droppedTurns > 0) {
-                truncationNoticed = true;
-                droppedTurnsTotal += trimmed.droppedTurns;
-            }
             let msg;
             const modelStart = Date.now();
             try {
@@ -449,6 +626,16 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 });
                 if (isCancelError(e) || signal?.aborted)
                     throw new LoopCancelledError();
+                // Empty-response recovery: a silent POST spends repair budget instead
+                // of aborting the turn (see MAX_EMPTY_ROUNDS). Cancellation above still
+                // wins; every other failure throws exactly as before.
+                if (isEmptyReplyError(e) && emptyRounds < MAX_EMPTY_ROUNDS) {
+                    emptyRounds += 1;
+                    failures += 1;
+                    history.push({ role: "assistant", content: "" });
+                    history.push({ role: "user", content: emptyResponseFollowUp(emptyRounds) });
+                    continue;
+                }
                 throw e;
             }
             throwIfCancelled(signal);
@@ -473,6 +660,17 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 // normalization never breaks the turn; the raw message stands
             }
             modelCalls += 1;
+            // Goal slice (ticket 02): one completed POST while a goal is live.
+            // Engages the run for turn accounting below; guarded, never breaks it.
+            try {
+                if (opts?.goal?.getGoal?.()?.active === true) {
+                    goalEngaged = true;
+                    opts.goal.onGoalRequest?.();
+                }
+            }
+            catch {
+                // observer errors never break the loop
+            }
             if (msg.usage !== undefined) {
                 // Spend accounting: EVERY POST that reports usage forwards it, and the
                 // caller accumulates each report as billed spend — tool-round POSTs,
@@ -525,16 +723,180 @@ export async function runLoopWithChat(chatFn, history, opts) {
                     needsVerification,
                     unverifiedPaths: [...unverifiedPaths],
                     verifyRounds,
+                    todoRounds,
                 });
                 if (outcome.kind === "continue") {
-                    // Verification-gate continues are bounded per turn (alongside the
-                    // step budget) so a model that never verifies still terminates.
+                    // Guard continues are bounded per turn so a model that never
+                    // verifies or never resolves todos still terminates.
                     if (outcome.via === "verification")
                         verifyRounds += 1;
+                    else if (outcome.via === "todoCompletionGate")
+                        todoRounds += 1;
                     history.push({ role: "assistant", content: outcome.assistantText });
                     history.push({ role: "user", content: outcome.followUp });
                     continue;
                 }
+                // Disposition protocol (ticket 03): consume this turn's update_goal
+                // report BEFORE the auto-continue decision. Terminal dispositions stop
+                // the run with a verdict — `blocked` unconditionally (even with
+                // unaddressed tool errors), `complete` only through the honesty gate
+                // below (unverified code or open todos continue instead) — pausing
+                // the goal with the verdict as its notice (never clearing, like every
+                // other loop-driven goal ending). A `continue` report's next action
+                // becomes the follow-up below (generic text when absent); no report —
+                // or a goal gone mid-turn — flows into the existing path untouched.
+                // The slot clears on every consumption, so a report never leaks into
+                // the following turn; guard `continue`s above never reach here, so a
+                // report filed mid-turn survives them until a real turn end.
+                const dispositionGoal = readLiveGoal();
+                let disposition = takeDisposition();
+                let goalNextAction = null;
+                // Evaluator fallback (ticket 04): a report-less turn with a live goal
+                // gets exactly ONE bounded judge call before continuing — but only when
+                // a runner is configured. Without one the turn continues exactly as
+                // before (existing tests pin this). A clear verdict flows through the
+                // SAME terminal/continue handling below as a model report (a `complete`
+                // still passes the honesty gate below — one code path for both); a judge error
+                // or an unclear verdict pauses (preserves) instead of looping. The
+                // judge reads history only — this path pushes nothing, so the judge
+                // performs no state mutations.
+                if (disposition === null &&
+                    dispositionGoal !== null &&
+                    dispositionGoal.active &&
+                    opts?.goalJudge) {
+                    // Cancel wins before the extra POST: never judge into a lost turn.
+                    throwIfCancelled(signal);
+                    let verdict = null;
+                    let judgeError = null;
+                    try {
+                        verdict = await opts.goalJudge({
+                            goal: dispositionGoal.objective,
+                            turns: recentTurnsForJudge(history),
+                        });
+                    }
+                    catch (e) {
+                        // Whole-turn cancellation still propagates (it pauses via the outer
+                        // catch, like every other cancel) — anything else pauses here.
+                        if (isCancelError(e) || signal?.aborted)
+                            throw new LoopCancelledError();
+                        const msg = e instanceof Error ? e.message : String(e);
+                        judgeError = msg.length > 200 ? `${msg.slice(0, 200)}…` : msg;
+                    }
+                    // The goal may have cleared/paused mid-judge (slash runs while busy):
+                    // then the verdict is dropped and the turn ends normally — never
+                    // pause or continue a goal that is gone.
+                    const liveAfterJudge = readLiveGoal();
+                    if (liveAfterJudge === null || !liveAfterJudge.active) {
+                        if (goalEngaged)
+                            noteGoalTurn();
+                        history.push({ role: "assistant", content: outcome.finalText });
+                        try {
+                            opts?.onPhase?.("done");
+                        }
+                        catch {
+                            // ignore
+                        }
+                        return outcome.finalText;
+                    }
+                    if (judgeError !== null || verdict === null) {
+                        // Pause-with-preservation (never clear): the goal, todos, and
+                        // history stay for /goal resume. The turn was still taken.
+                        pauseLiveGoal(liveAfterJudge.objective, judgeError !== null ? `(judge failed: ${judgeError})` : `(judge unclear — no clear verdict)`);
+                        noteGoalTurn();
+                        history.push({ role: "assistant", content: outcome.finalText });
+                        try {
+                            opts?.onPhase?.("done");
+                        }
+                        catch {
+                            // ignore
+                        }
+                        return outcome.finalText;
+                    }
+                    disposition = verdict;
+                }
+                if (disposition !== null &&
+                    disposition.status !== "continue" &&
+                    dispositionGoal !== null &&
+                    dispositionGoal.active) {
+                    // Cancel wins even mid-verdict: never stop cleanly into a lost turn.
+                    throwIfCancelled(signal);
+                    // Honest completion gate (ticket 06): a `complete` only lands on
+                    // genuinely finished work. With unverified code pending or todos
+                    // still open the goal continues instead of stopping, naming the
+                    // files/items through the gates' own follow-up voice (todos first,
+                    // matching TURN_END_GATES order). `blocked` skips this entirely and
+                    // stops unconditionally below. Evaluator verdicts share this path —
+                    // they arrive in the same `disposition` slot, so one code path gates
+                    // both. Guard `continue`s above never reach here, so a false
+                    // `complete` filed mid-turn is still caught when its turn ends.
+                    if (disposition.status === "complete") {
+                        // Voice-only probe: budgets/rounds zeroed so the builders return
+                        // their `continue` follow-up whenever their state is dirty — the
+                        // live budget owns spinning protection in the branch below, and the
+                        // pinned gates above own the per-turn nag bounds.
+                        const honestCtx = {
+                            step: 0,
+                            maxSteps: Number.POSITIVE_INFINITY,
+                            filesWritten,
+                            verifiedAfterWrite,
+                            needsVerification,
+                            unverifiedPaths: [...unverifiedPaths],
+                            verifyRounds: 0,
+                            todoRounds: 0,
+                        };
+                        const todoProbe = todoCompletionGate(outcome.finalText, honestCtx);
+                        const verifyProbe = verificationGate(outcome.finalText, honestCtx);
+                        const honestBlock = todoProbe.action === "continue"
+                            ? todoProbe
+                            : verifyProbe.action === "continue"
+                                ? verifyProbe
+                                : null;
+                        if (honestBlock !== null) {
+                            // Spent budget cannot start another turn: pause (preserve) with
+                            // the budget notice instead of completing dirty or spinning.
+                            if (step >= maxSteps || toolCalls >= maxTotalToolCalls) {
+                                pauseLiveGoal(dispositionGoal.objective, "(budget spent)");
+                                noteGoalTurn();
+                                history.push({ role: "assistant", content: outcome.finalText });
+                                try {
+                                    opts?.onPhase?.("done");
+                                }
+                                catch {
+                                    // ignore
+                                }
+                                return outcome.finalText;
+                            }
+                            // A guard-style continue: not a turn end, so no goal-turn
+                            // accounting — and the false report is already consumed, so the
+                            // next turn must file fresh evidence.
+                            history.push({ role: "assistant", content: honestBlock.assistantText });
+                            history.push({ role: "user", content: honestBlock.followUp });
+                            continue;
+                        }
+                    }
+                    const verdict = disposition.status === "complete"
+                        ? goalVerdictNotice(dispositionGoal.objective, "complete", disposition.reason, disposition.unverified)
+                        : goalVerdictNotice(dispositionGoal.objective, disposition.status, disposition.reason);
+                    pauseLiveGoalWithNotice(verdict);
+                    noteGoalTurn();
+                    const base = outcome.finalText;
+                    const final = base ? `${base}\n${verdict}` : verdict;
+                    history.push({ role: "assistant", content: final });
+                    try {
+                        opts?.onPhase?.("done");
+                    }
+                    catch {
+                        // ignore
+                    }
+                    return final;
+                }
+                if (disposition !== null &&
+                    disposition.status === "continue" &&
+                    disposition.next !== undefined &&
+                    dispositionGoal !== null &&
+                    dispositionGoal.active) {
+                    goalNextAction = disposition.next;
+                }
                 // Error-streak recovery (additive, after the pinned gates): ending on
                 // sustained unaddressed `Error:` results is almost always premature.
                 // Single errors still end normally (the model may be reporting a
@@ -546,6 +908,58 @@ export async function runLoopWithChat(chatFn, history, opts) {
                     history.push({ role: "user", content: errorStreakFollowUp(streak) });
                     continue;
                 }
+                // Goal auto-continue (tickets 02–03): with a live goal a would-be turn
+                // end starts the next turn through the same assistant+user follow-up
+                // seam the guards use above — the ONLY continuation message, so the
+                // transcript shows each turn normally with no synthetic user input
+                // beyond this mechanism. Unconditional (no turn cap): the run ends
+                // only via pause (cancel/spent budget), clear, a terminal disposition,
+                // or a thrown failure. A `continue` report's next action becomes the
+                // follow-up text (generic follow-up when absent or unreported).
+                // Runs after the error-streak hold so sustained tool failures still
+                // get their fix-forward guidance first (a hold is not a turn end, so
+                // it counts no goal turn — and a consumed `continue` report is dropped
+                // with it, so the fix-forward guidance wins that round).
+                const liveGoal = readLiveGoal();
+                if (liveGoal !== null && liveGoal.active) {
+                    goalEngaged = true;
+                    // Cancel wins even mid-continuation: never start another turn lost.
+                    throwIfCancelled(signal);
+                    // A spent budget can never make progress — pause (preserve) with a
+                    // notice instead of POSTing forever. The turn was still taken.
+                    if (step >= maxSteps || toolCalls >= maxTotalToolCalls) {
+                        pauseLiveGoal(liveGoal.objective, "(budget spent)");
+                        noteGoalTurn();
+                        history.push({ role: "assistant", content: outcome.finalText });
+                        try {
+                            opts?.onPhase?.("done");
+                        }
+                        catch {
+                            // ignore
+                        }
+                        return outcome.finalText;
+                    }
+                    noteGoalTurn();
+                    history.push({ role: "assistant", content: outcome.finalText });
+                    // Stall redirect (ticket 05): a run of exact repeats gets the replan
+                    // nudge as its follow-up instead of the generic continuation — same
+                    // assistant+user commit shape as the other gates, so the redirect is
+                    // visible in the transcript. The epoch resets; the goal is never
+                    // paused, cleared, or ended here (existing budgets still bound a run
+                    // that keeps stalling, so recurring nudges cannot spin forever).
+                    if (goalStallReached(goalProgress)) {
+                        resetGoalStall(goalProgress);
+                        history.push({ role: "user", content: goalStallNudge(liveGoal.objective, GOAL_STALL_REPEATS) });
+                    }
+                    else {
+                        history.push({ role: "user", content: goalNextAction ?? goalFollowUp(liveGoal.objective) });
+                    }
+                    continue;
+                }
+                // Final turn of a run that engaged a goal before it cleared: the work
+                // happened, so it still counts (no continuation — the goal is gone).
+                if (goalEngaged)
+                    noteGoalTurn();
                 history.push({ role: "assistant", content: outcome.finalText });
                 try {
                     opts?.onPhase?.("done");
@@ -558,6 +972,18 @@ export async function runLoopWithChat(chatFn, history, opts) {
             if (step >= maxSteps) {
                 const base = msg.content ?? "";
                 const notice = `${base}${base ? "\n" : ""}(stopped: too many tool steps) (limit is ${maxSteps}; raise with ATOM_MAX_TOOL_STEPS=<n>)`;
+                // Spent budget during a goal run pauses (preserves) it with a notice
+                // instead of silently dropping it — the stop text stays the reply and
+                // the pause notice lands as its own line via the callback.
+                const overGoal = readLiveGoal();
+                if (overGoal !== null && overGoal.active) {
+                    goalEngaged = true;
+                    pauseLiveGoal(overGoal.objective, "(step budget spent)");
+                    noteGoalTurn();
+                }
+                else if (goalEngaged) {
+                    noteGoalTurn();
+                }
                 history.push({ role: "assistant", content: notice });
                 try {
                     opts?.onPhase?.("done");
@@ -567,12 +993,22 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 }
                 return notice;
             }
-            // Total tool-call budget (parallel-batch explosion guard): counts every
-            // tool_call the model emits, mirroring the maxSteps stop contract. The
-            // default (200) never binds the pinned suites (~30 calls/turn).
+            // Total tool-call budget (explicit `opts.maxTotalToolCalls` only;
+            // uncapped by default): counts every tool_call the model emits and stops
+            // the turn when the explicit budget is exceeded.
             if (toolCalls + calls.length > maxTotalToolCalls) {
                 const base = msg.content ?? "";
                 const notice = `${base}${base ? "\n" : ""}(stopped: too many tool calls) (limit is ${maxTotalToolCalls} per turn)`;
+                // Same pause-with-preservation contract as the step-budget stop above.
+                const overGoal = readLiveGoal();
+                if (overGoal !== null && overGoal.active) {
+                    goalEngaged = true;
+                    pauseLiveGoal(overGoal.objective, "(tool-call budget spent)");
+                    noteGoalTurn();
+                }
+                else if (goalEngaged) {
+                    noteGoalTurn();
+                }
                 history.push({ role: "assistant", content: notice });
                 try {
                     opts?.onPhase?.("done");
@@ -587,12 +1023,34 @@ export async function runLoopWithChat(chatFn, history, opts) {
             // bookkeeping + one ordered transcript entry per call. Only successful
             // executions count — denials, validation errors, and unknown tools (all
             // `Error:` results) never ran, so they neither arm nor clear the gate.
-            const commitToolResult = (name, parsed, call, result, durationMs) => {
-                const isError = typeof result === "string" && result.startsWith("Error");
+            const commitToolResult = async (name, parsed, call, result, durationMs) => {
+                const baseIsError = typeof result === "string" && result.startsWith("Error");
+                // Extension post-hooks observe the raw commit candidate first (every
+                // committed result: executions, blocks, denials, validation errors);
+                // the caller's onToolResult hook runs last on the patched version.
+                // Patches apply per call in commit order, so tool_call_id re-pairing
+                // and ordering are untouched; throwing patchers fail open above.
+                const after = await runAfterIntercept(name, parsed, result, baseIsError);
+                const hooked = await applyToolResultHook(opts?.onToolResult, name, parsed, after.content, after.isError);
+                // Veto: skip the commit entirely — no counters, no gates, no history,
+                // no activity. The turn continues; pairing risk is the hook author's.
+                if (hooked.veto)
+                    return false;
+                const finalResult = hooked.content;
+                const isError = hooked.isError;
                 toolCalls += 1;
                 if (isError)
                     failures += 1;
                 errStreak.noteResult(isError);
+                // Novelty progress (ticket 05): successful commits fingerprint into the
+                // per-run seen-set (Error results are owned by the error-streak
+                // machinery and never count). Guarded — accounting never breaks the turn.
+                try {
+                    noteGoalProgress(goalProgress, name, parsed, finalResult, isError);
+                }
+                catch {
+                    // observer errors never break the loop
+                }
                 if (typeof durationMs === "number")
                     noteBottleneck(name, durationMs);
                 if (!isError && (name === "write" || name === "edit")) {
@@ -608,7 +1066,7 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 else if (!isError && name === "bash") {
                     const command = parsed["command"];
                     if (typeof command === "string" && isVerificationCommand(command) && filesWritten) {
-                        const exit = bashExitCode(result);
+                        const exit = bashExitCode(finalResult);
                         if (exit === null || exit === 0) {
                             // Passing check (or a legacy runner that reports no envelope):
                             // clears everything the gate tracks.
@@ -624,14 +1082,59 @@ export async function runLoopWithChat(chatFn, history, opts) {
                         }
                     }
                 }
-                history.push({ role: "tool", tool_call_id: call?.id ?? "", content: result });
+                history.push({ role: "tool", tool_call_id: call?.id ?? "", content: finalResult });
                 try {
-                    opts?.onToolActivity?.(describeToolCall(name, parsed), result, isError);
+                    opts?.onToolActivity?.(describeToolCall(name, parsed), finalResult, isError);
                 }
                 catch {
                     // ignore observer errors
                 }
+                return true;
             };
+            // Length-truncated response (the output limit cut the tool arguments
+            // off): NOTHING executes — every carried call commits a repair-oriented
+            // error result and the turn continues to the next model round. The
+            // results are `Error:` strings, so failure/error-streak accounting flows
+            // through commitToolResult exactly like any other tool error, and the
+            // step/total-call budgets above keep bounding runaway retries.
+            // Truncated-without-calls never reaches here (handled by the turn-end
+            // gates above, exactly as before).
+            if (msg.truncated === true) {
+                for (let i = 0; i < calls.length; i++) {
+                    const call = calls[i];
+                    const name = call?.function?.name ?? "(unknown)";
+                    const result = `Error: truncated response: the output limit cut off the arguments for tool "${name}" — ` +
+                        `nothing was executed. Re-issue the call with complete arguments ` +
+                        `(narrow the scope or split into smaller calls if it keeps truncating).`;
+                    const toolAt = Date.now();
+                    reportToolCall({
+                        step,
+                        toolCallId: call?.id ?? "",
+                        name,
+                        startedAt: telemetryIso(toolAt),
+                        endedAt: telemetryIso(toolAt),
+                        durationMs: 0,
+                        argsJson: telemetryArgsJson(call?.function?.arguments ?? "{}"),
+                        result,
+                        batchIndex: i,
+                        batchSize: calls.length,
+                    });
+                    // Truncated arguments are often not valid JSON (cut mid-string) —
+                    // fall back to {} for bookkeeping (an error result never arms the
+                    // verification gate, so this only shapes the activity label).
+                    let parsed;
+                    try {
+                        const raw = call?.function?.arguments ?? "{}";
+                        const v = JSON.parse(typeof raw === "string" ? raw : "{}");
+                        parsed = typeof v === "object" && v !== null ? v : {};
+                    }
+                    catch {
+                        parsed = {};
+                    }
+                    await commitToolResult(name, parsed, call, result);
+                }
+                continue;
+            }
             for (const batch of planBatches(calls)) {
                 // No new executions after a cancel: the current tool (if any) already
                 // finished; stop before starting the next batch.
@@ -656,18 +1159,12 @@ export async function runLoopWithChat(chatFn, history, opts) {
                     catch {
                         parsed = {};
                         const result = `Error: invalid call: invalid JSON arguments for tool "${name}" (arguments must be valid JSON). Fix the arguments and retry.`;
-                        toolCalls += 1;
-                        failures += 1;
-                        errStreak.noteResult(true);
+                        // Invalid JSON never executes — route through the commit funnel so
+                        // the result hook still sees every committed result. Bookkeeping
+                        // (counters, error streak, bottleneck, history, activity) is
+                        // identical to the inline block this replaced; only the committed
+                        // content may differ when a hook rewrites it.
                         repGuard.note(toolSignature(name, parsed), name);
-                        noteBottleneck(name, Date.now() - toolStart);
-                        history.push({ role: "tool", tool_call_id: call?.id ?? "", content: result });
-                        try {
-                            opts?.onToolActivity?.(describeToolCall(name, {}), result, true);
-                        }
-                        catch {
-                            // ignore observer errors
-                        }
                         const toolEnd = Date.now();
                         reportToolCall({
                             step,
@@ -681,12 +1178,16 @@ export async function runLoopWithChat(chatFn, history, opts) {
                             batchIndex: 0,
                             batchSize: 1,
                         });
+                        await commitToolResult(name, parsed, call, result, Math.max(0, toolEnd - toolStart));
                         continue;
                     }
                     let result;
-                    // Repetition guard (opt-in via maxRepeatedCalls; unset = track-only
-                    // so the pinned maxSteps contract holds): a repeated signature skips
-                    // execution and yields a guidance error; exhausted nudges stop hard.
+                    // Effective (post-rewrite) args: what validated, approved, and ran —
+                    // telemetry and the commit below must see these, not the originals.
+                    let effectiveArgs = parsed;
+                    // Repetition guard (opt-in via maxRepeatedCalls; unset = track-only):
+                    // a repeated signature skips execution and yields a guidance error;
+                    // exhausted nudges stop hard.
                     const repSig = toolSignature(name, parsed);
                     const repNote = repGuard.note(repSig, name);
                     if (repNote.intervened) {
@@ -705,7 +1206,7 @@ export async function runLoopWithChat(chatFn, history, opts) {
                                 batchIndex: 0,
                                 batchSize: 1,
                             });
-                            commitToolResult(name, parsed, call, guarded, 0);
+                            await commitToolResult(name, parsed, call, guarded, 0);
                             continue;
                         }
                         const guarded = `Error: invalid call: ${repetitionFollowUp(repSig, repNote.consecutive)} Fix the approach and retry.`;
@@ -721,7 +1222,7 @@ export async function runLoopWithChat(chatFn, history, opts) {
                             batchIndex: 0,
                             batchSize: 1,
                         });
-                        commitToolResult(name, parsed, call, guarded, 0);
+                        await commitToolResult(name, parsed, call, guarded, 0);
                         const stopBase = msg.content ?? "";
                         const stopNotice = `${stopBase}${stopBase ? "\n" : ""}${repetitionStopNotice(repSig, repNote.consecutive)}`;
                         history.push({ role: "assistant", content: stopNotice });
@@ -734,7 +1235,9 @@ export async function runLoopWithChat(chatFn, history, opts) {
                         return stopNotice;
                     }
                     try {
-                        result = await runOneTool(call, parsed, opts, execute);
+                        const one = await runOneTool(call, parsed, opts, execute, undefined, recordGoalReport);
+                        result = one.result;
+                        effectiveArgs = one.args;
                     }
                     catch (e) {
                         // A cancelled/throwing tool still records its attempt (with the
@@ -773,17 +1276,19 @@ export async function runLoopWithChat(chatFn, history, opts) {
                             startedAt: telemetryIso(toolStart),
                             endedAt: telemetryIso(toolEnd),
                             durationMs: Math.max(0, toolEnd - toolStart),
-                            argsJson: telemetryArgsJson(parsed),
+                            argsJson: telemetryArgsJson(effectiveArgs),
                             result,
                             batchIndex: 0,
                             batchSize: 1,
                         });
                     }
-                    commitToolResult(name, parsed, call, result, Math.max(0, Date.now() - toolStart));
+                    await commitToolResult(name, effectiveArgs, call, result, Math.max(0, Date.now() - toolStart));
                     continue;
                 }
                 // Parallel batch: every member is pre-validated parallel-safe (see
-                // planToolBatches), so runOneTool neither prompts nor blocks here.
+                // planToolBatches). Approval-gated members (parallel writes) resolve
+                // their decisions serially in call order first, so prompts never run
+                // concurrently; denied members yield inline errors without executing.
                 // Phases fire upfront in call order; results commit in call order, so
                 // each call still shows separately and tool_call_ids re-pair by index.
                 // A throw (cancel or execution error) aborts the turn exactly like the
@@ -809,6 +1314,33 @@ export async function runLoopWithChat(chatFn, history, opts) {
                         repHardStop = { sig: note.signature, consecutive: note.consecutive };
                     }
                 }
+                const memberPlans = new Map();
+                const preDecisions = new Map();
+                for (let i = 0; i < batch.length; i++) {
+                    throwIfCancelled(signal);
+                    if (repNotes[i].intervened)
+                        continue;
+                    const member = batch[i];
+                    const memberName = member.call?.function?.name ?? "(unknown)";
+                    if (!toolNames().includes(memberName)) {
+                        memberPlans.set(i, { args: member.parsed, blocked: null, invalid: null });
+                        continue;
+                    }
+                    const pre = await runBeforeIntercept(memberName, member.parsed);
+                    if (pre.blocked !== null) {
+                        memberPlans.set(i, { args: pre.args, blocked: pre.blocked, invalid: null });
+                        continue;
+                    }
+                    const invalid = validateToolArgs(memberName, pre.args);
+                    if (invalid) {
+                        memberPlans.set(i, { args: pre.args, blocked: null, invalid });
+                        continue;
+                    }
+                    memberPlans.set(i, { args: pre.args, blocked: null, invalid: null });
+                    const decision = await resolveApproval(memberName, pre.args, opts);
+                    if (decision !== null)
+                        preDecisions.set(i, decision);
+                }
                 try {
                     // Each member is timed individually (concurrent wall-clock per call,
                     // not the whole batch attributed to each) and reported in call order
@@ -836,7 +1368,46 @@ export async function runLoopWithChat(chatFn, history, opts) {
                             return guarded;
                         }
                         try {
-                            const r = await runOneTool(member.call, member.parsed, opts, execute);
+                            // Pre-resolved members (blocked/invalid) never reach the
+                            // executor: their inline results commit in call order below.
+                            const plan = memberPlans.get(index);
+                            if (plan?.blocked !== null && plan?.blocked !== undefined) {
+                                const blocked = plan.blocked;
+                                const memberEnd = Date.now();
+                                memberDurations[index] = Math.max(0, memberEnd - memberStart);
+                                reportToolCall({
+                                    step,
+                                    toolCallId: member.call?.id ?? "",
+                                    name: member.call?.function?.name ?? "(unknown)",
+                                    startedAt: telemetryIso(memberStart),
+                                    endedAt: telemetryIso(memberEnd),
+                                    durationMs: Math.max(0, memberEnd - memberStart),
+                                    argsJson: telemetryArgsJson(plan.args),
+                                    result: blocked,
+                                    batchIndex: index,
+                                    batchSize: batch.length,
+                                });
+                                return blocked;
+                            }
+                            if (plan?.invalid) {
+                                const bad = invalidCall(plan.invalid);
+                                const memberEnd = Date.now();
+                                memberDurations[index] = Math.max(0, memberEnd - memberStart);
+                                reportToolCall({
+                                    step,
+                                    toolCallId: member.call?.id ?? "",
+                                    name: member.call?.function?.name ?? "(unknown)",
+                                    startedAt: telemetryIso(memberStart),
+                                    endedAt: telemetryIso(memberEnd),
+                                    durationMs: Math.max(0, memberEnd - memberStart),
+                                    argsJson: telemetryArgsJson(plan.args),
+                                    result: bad,
+                                    batchIndex: index,
+                                    batchSize: batch.length,
+                                });
+                                return bad;
+                            }
+                            const r = await runOneToolWithArgs(member.call, plan?.args ?? member.parsed, opts, execute, preDecisions.get(index) ?? null, recordGoalReport);
                             const memberEnd = Date.now();
                             memberDurations[index] = Math.max(0, memberEnd - memberStart);
                             reportToolCall({
@@ -846,12 +1417,12 @@ export async function runLoopWithChat(chatFn, history, opts) {
                                 startedAt: telemetryIso(memberStart),
                                 endedAt: telemetryIso(memberEnd),
                                 durationMs: Math.max(0, memberEnd - memberStart),
-                                argsJson: telemetryArgsJson(member.parsed),
-                                result: r,
+                                argsJson: telemetryArgsJson(plan?.args ?? member.parsed),
+                                result: r.result,
                                 batchIndex: index,
                                 batchSize: batch.length,
                             });
-                            return r;
+                            return r.result;
                         }
                         catch (e) {
                             const memberEnd = Date.now();
@@ -885,7 +1456,7 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 }
                 for (let i = 0; i < batch.length; i++) {
                     const member = batch[i];
-                    commitToolResult(member.call?.function?.name ?? "(unknown)", member.parsed, member.call, results[i], memberDurations[i]);
+                    await commitToolResult(member.call?.function?.name ?? "(unknown)", memberPlans.get(i)?.args ?? member.parsed, member.call, results[i], memberDurations[i]);
                 }
                 if (repHardStop) {
                     const stopBase = msg.content ?? "";
@@ -902,6 +1473,19 @@ export async function runLoopWithChat(chatFn, history, opts) {
             }
         }
     }
+    catch (e) {
+        // Cancel during a live goal pauses (preserves) it with a notice — never
+        // clears — so a later /goal resume can continue. Failed POSTs skip this
+        // entirely: the caller rolls back per the existing splice contract and
+        // the goal stays active and carries on.
+        if (isCancelError(e) || signal?.aborted) {
+            const cancelledGoal = readLiveGoal();
+            if (cancelledGoal !== null && cancelledGoal.active) {
+                pauseLiveGoal(cancelledGoal.objective, "(cancelled)");
+            }
+        }
+        throw e;
+    }
     finally {
         finishStats();
     }