@astrosheep/pi-goal-next 0.1.3 → 0.1.5

package/README.md

@@ -61,9 +61,9 @@ The prompt text is copied byte-for-byte from Codex Goal (`continuation.md`, `bud
 
 ## Limits and accounting
 
-- The default maximum is 25 continuation turns (`maxContinuations`). Change it with `/goal turns N`.
+- The default maximum is 25 continuation turns (`maxContinuations`) per run. Change it with `/goal turns N`. `/goal resume` resets the run's continuation count and immediately schedules work when idle. It preserves the objective, journal history, cumulative usage, and token budget. If the token budget is exhausted or the continuation allowance is zero, resume reports the limit instead of claiming success.
 - A token budget is unset by default. Set one at creation with `/goal --tokens N[k|M] ...` or later with `/goal budget N`.
-- Usage is attributed by message entry id, separately for assistant and tool-result messages. Duplicate entry ids are ignored.
+- Usage comes directly from each completed assistant/tool-result event. Repeated delivery of the same live message object is deduplicated. Pi has not assigned a session entry id at this event boundary; historical messages are not re-accounted on reload.
 - Missing provider usage is recorded as unknown, never treated as confirmed zero.
 - Nested or subagent usage is counted only when Pi exposes it as `toolResult.usage` data; see [limits](docs/limits.md).
 - The final completing turn is included in accounting.
@@ -72,4 +72,6 @@ The prompt text is copied byte-for-byte from Codex Goal (`continuation.md`, `bud
 
 The model calls `update_goal` after auditing the current goal against the Codex completion audit carried in every continuation prompt. The host accepts `complete` and `blocked` at face value and performs no independent verification; the prompt is the only guard. `complete` reports final token usage in the tool result, and `blocked` is meant to follow three consecutive turns with the same blocker. `paused` is user-only (`/goal pause`). Runtime accounting may instead move an active goal to `budget_limited`; the model cannot declare that state, and the transition triggers one `budget_limit.md` steering message.
 
-Continuation messages are sent only after a successful journal commit and only while Pi is idle with no pending messages. A continuation carries the goal id, generation, and sequence number. User input and compare-and-swap conflicts prevent a new continuation from being sent.
+Automatic continuation waits for a fresh normal assistant completion and for the entire Pi run to settle, including tools, retries, compaction, and queued input. Errors, cancellation (including cancellation after text finishes), and runs ending at a tool boundary do not trigger continuation or budget steering. Ordinary user input has no continuation attached; once the response to that input finishes normally, an active goal may continue.
+
+Continuation messages are sent only after a successful journal commit. The plugin checks cancellation, goal state, and pending input again after that commit, immediately before sending. A continuation carries the goal id, generation, and sequence number. Input received during scheduling invalidates the automatic send. Explicit `/goal` create/resume can start work immediately when idle.

package/docs/architecture.md

@@ -27,7 +27,7 @@ Pi 0.85.1 extension package adding a long-running `/goal`. Behavior follows Code
 | `prompts.ts` | Pure: the three Codex-verbatim goal templates — `continuationPrompt(goal)`, `budgetLimitPrompt(goal)`, `objectiveUpdatedPrompt(goal)`; `escapeXmlText` applies to the objective only. | IO, model calls, host-side validation |
 | `tools.ts` | Codex-verbatim tool descriptions, TypeBox schema → `goalCommit.commit` → tool result. Three tools: get_goal / create_goal / update_goal. `update_goal` accepts only complete\|blocked and reports final usage on complete. | writing rules text, touching store/continuation |
 | `commands.ts` | `/goal` subcommands → goal-commit. | direct store access |
-| `lifecycle.ts` | Stateless event mapping (owns only sessionId). Session/branch/compaction policies plus budget-limit steering, see below. | holding Goal state, growing beyond the listed policies |
+| `lifecycle.ts` | Event ordering, live-message identities, run cancellation signal, and input/settlement fences. Session/branch/compaction policies plus budget-limit steering, see below. | holding Goal state |
 | `ui.ts` | status/widget text from `current()` + `accounting.summary()`. Read-only. | writes |
 | `index.ts` | dependency assembly + registration only. | logic |
 
@@ -46,28 +46,33 @@ Internally: check `revision === expectedRevision` and no pending → mark pendin
 ## Two counters
 
 - `revision` (goal-commit): +1 per commit, CAS basis.
-- `generation` (continuation): the implementation currently invalidates it on tree navigation (`session_before_tree`). Pause, clear, resume, and session restore do not call the continuation invalidation hook; status changes are still protected by the active-status check and the commit CAS. Every continuation message carries `{ goalId, generation, seq }` in details.
+- `generation` (continuation): invalidated on session restore, tree navigation, input receipt, and user-message delivery. Pause and clear are protected by the active-status check and the commit CAS. Every continuation message carries `{ goalId, generation, seq }` in details. A separate lifecycle epoch rejects settlement work overtaken by another run or input.
 
 ## Continuation protocol
 
-`agent_settled` → read `current()` + require `ctx.isIdle() && !ctx.hasPendingMessages()` → `commit(continuation_sent {generation, seq}, revision)` → only on success `pi.sendMessage(continuation, { triggerTurn: true })`. On conflict: abandon this round, wait for next settle.
+`message_end` captures the current event's stop reason. Only a fresh `stop` or `length` response authorizes automatic work at `agent_settled`, after Pi has drained tools, retries, compaction, and queued messages. Settlement consumes that authorization once. The run's captured abort signal must not be aborted, no new input may be awaiting delivery, and Pi must be idle with no queued messages.
+
+Then read `current()` → `commit(continuation_sent {generation}, revision)` → recheck lifecycle authorization, generation, goal identity/status, idle state, and pending messages → `pi.sendMessage(continuation, { triggerTurn: true })`. On conflict or invalidation, abandon this attempt. An abandoned attempt may consume a sequence number because Pi cannot atomically commit the journal and admit a new turn. Explicit `/goal` create/resume can start idle work without a preceding assistant response.
 
 Stale continuation: Pi has no message retraction and `abort` cannot selectively cancel a goal message, so **never abort**. On `message_start`, lifecycle notifies continuation; if the custom continuation message is ours and generation is stale, record `stale_turn`. The current implementation does not propagate that marker to accounting usage deltas and does not have a separate stale-turn scheduling fence; subsequent scheduling still uses the normal active-status, idle/pending-message, limit, and CAS checks. Every continuation message body is Codex's `continuation.md` verbatim: the objective is wrapped in `<objective>` as user-provided data, and the budget, evidence, fidelity, completion-audit, blocked-audit, and closing rules are stated inline.
 
-User messages win: `hasPendingMessages()` check + CAS conflict as backstop.
+User messages win: `input` invalidates outstanding continuation attempts before Pi queues the message. Delivery at `message_start` clears the input-preflight fence and invalidates old completion state. Idle/queue checks are repeated after the commit await. Ordinary input injects no goal prompt; a normal response to that input may continue the still-active goal once the whole run settles.
 
 ## lifecycle.ts — the lifecycle policies
 
-1. `session_start`: any restored `active` goal → commit a system transition to `paused` (the journal does not contain a separate `loaded` entry). Never silently resume; the continuation generation is not explicitly invalidated by this hook.
-2. `session_before_tree`: tell continuation to void generation; next event triggers rebuild from `getBranch()` via goal-commit.
-3. `session_before_compact`: append `goal.summarize()` text to the compaction if the hook allows (verify at implementation; continuation messages are self-contained regardless).
-4. `agent_settled`: commit the accounting verdict, then — if the current goal is `budget_limited` and this goal instance has not been steered yet — send `budgetLimitPrompt(goal)` with `triggerTurn: true`. Steering is sent once per goal instance (`steeredGoalId`/`steered` closure state, reset on a null snapshot or a new goal id). Then run `continuation.onSettled()`, except that it skips continuation when the previous turn ended error/aborted (structured `stopReason`; such turns produced no completed work).
+1. `session_start`: invalidate pending work, rebuild, and transition any restored `active` goal to `paused`. Never silently resume.
+2. `session_before_tree`: invalidate pending work; the next event rebuilds from the selected branch.
+3. `session_before_compact`: provide `goal.summarize()` text if the hook supports the required fields.
+4. `agent_start`: reset completion state and capture `ctx.signal`. Retain that signal after Pi clears its current signal at idle, so cancellation during message/agent-end handlers still suppresses continuation.
+5. `message_end`: account the current message and capture its stop reason. Pi dispatches this hook **before** appending the message to SessionManager; never substitute the last persisted same-role message.
+6. `input` / user `message_start`: invalidate old scheduling and track input receipt through delivery.
+7. `agent_settled`: require and consume a fresh normal, uncancelled completion. Apply accounting limits, recheck input/run eligibility, and send budget steering once per goal instance if eligible. Otherwise run `continuation.onSettled(canSend)` with the same eligibility checks across the commit await. Error, aborted, toolUse-only, and empty runs send nothing.
 
-No other business. Retry needs no lifecycle handling — accounting dedupes by message id; retry messages have new ids and are honestly counted (they cost real tokens).
+Retry messages are separately accounted because each response costs real tokens. Only the final successful run can authorize continuation.
 
 ## accounting rules
 
-- Dedup key: session entry id of the assistant/toolResult message.
+- Dedup key: an in-memory ID assigned by WeakMap to each assistant/toolResult event message object. Session entry IDs do not yet exist at `message_end`. Usage deltas are journaled immediately; historical messages are not replayed into accounting on reload.
 - Only count usage Pi reports. Missing usage → recorded as `unknown`, never assumed zero.
 - toolResult.usage (nested/subagent usage) counts only when present; the coverage gap is disclosed in UI + limits.md.
 - Final completing turn IS accounted (same as both reference implementations).
@@ -88,7 +93,7 @@ The blocked audit is prompt-level only: the runtime does not count blocking turn
 
 `/goal` or `/goal status` · `/goal [--tokens N[k|M]] <objective>` (create; refuses while unfinished) · `/goal edit <objective>` · `/goal pause` · `/goal resume` · `/goal clear` · `/goal budget <tokens|none>` · `/goal turns <max-continuations>`.
 
-A successful `create` or `resume` calls `continuation.onSettled()` so an idle session starts pursuing immediately (Codex starts the turn directly). A successful `edit` sends `objectiveUpdatedPrompt(goal)` with `triggerTurn: true`; `pause` and `clear` send nothing (the active-status check stops continuation).
+A successful `resume` atomically journals `resetContinuations: true` on the user transition to active, resetting the run's continuation count while preserving the objective, usage, budget, and historical entries. It also accepts an already-active goal. Exhausted token budgets and zero continuation allowances are reported without resuming. A successful `create` or `resume` calls `continuation.onSettled()` so an idle session starts pursuing immediately (Codex starts the turn directly). A successful `edit` sends `objectiveUpdatedPrompt(goal)` with `triggerTurn: true`; `pause` and `clear` send nothing (the active-status check stops continuation).
 
 ## Defaults
 
@@ -103,4 +108,4 @@ max continuations (turns): 25 · token budget: unset (opt-in) · the blocked-loo
 
 ## Testing
 
-vitest or node:test (implementer's choice, state it). fake-pi support harness drives events. Required: goal transitions incl. illegal ones; CAS conflict/pending/append-failure; branch fold isolation; dedup by message id; settleTurn verdicts incl. final-turn accounting; continuation send-only-after-commit, conflict-abandon, generation fencing, stale turn; prompt templates (escaping, budget math, injection guard, no update_plan); tools schema; command flows; lifecycle policies incl. budget steering; integration replay of a full goal session on fake-pi.
+node:test covers goal transitions, journal replay, CAS conflicts, limits, prompts, commands, and lifecycle races. `test/pi-session.test.ts` additionally runs real Pi 0.85.1 AgentSessions with in-memory settings/sessions and a deterministic model stream (no network). It verifies pre-append event ordering, usage accounting, normal→error/abort transitions, abort during streaming and at message/agent-end boundaries, steering delivery, and the absence of a continuation attached to user input. The pre-fix 0.1.4 code fails the real-session error/abort regressions.

package/docs/limits.md

@@ -16,7 +16,7 @@ The extension uses the public Pi 0.85.1 event, session, message, and send APIs.
 
 **Cannot guarantee:** Pi does not expose nested or subagent token usage consistently for every tool result.
 
-**What it does:** Counts nested usage only when it is present in `toolResult.usage`; missing usage is recorded as unknown. Top-level assistant and tool-result messages are deduplicated by entry id.
+**What it does:** Counts nested usage only when it is present in `toolResult.usage`; missing usage is recorded as unknown. Top-level assistant and tool-result events are deduplicated by live message-object identity, since their session entry IDs do not yet exist during `message_end`. Journaled usage survives reload; historical events are not counted again.
 
 **User sees:** The status line can show `unknown messages=N`, and budget totals can be lower than provider-side totals when nested usage was not reported.
 
@@ -42,7 +42,7 @@ The extension uses the public Pi 0.85.1 event, session, message, and send APIs.
 
 **Cannot guarantee:** Restoring a session does not prove that an in-flight continuation was never sent before the process stopped.
 
-**What it does:** Rebuilds from the selected branch and converts any restored `active` goal to `paused` with a system transition. It does not silently resume and does not explicitly invalidate the continuation generation in this hook.
+**What it does:** Invalidates outstanding scheduling, rebuilds from the selected branch, and converts any restored `active` goal to `paused` with a system transition. It does not silently resume.
 
 **User sees:** A restored active goal is paused and requires `/goal resume`. A previously sent message may still be present in the provider transcript, but the restored status prevents normal continuation scheduling.
 
@@ -74,6 +74,6 @@ The extension uses the public Pi 0.85.1 event, session, message, and send APIs.
 
 **Cannot guarantee:** Event delivery and message queue timing are controlled by Pi.
 
-**What it does:** Requires idle state and no pending messages before the continuation CAS commit, then sends only after that commit succeeds. A user message arriving concurrently is handled by the pending-message check or a CAS conflict.
+**What it does:** Requires a fresh normal completion and an uncancelled run. Input receipt invalidates pending scheduling before Pi queues the message; its delivery clears the input-preflight fence. Idle/queue state, cancellation, and lifecycle eligibility are checked both before and after the continuation CAS commit. Pi does not expose an atomic journal-commit-and-start-if-idle operation, so a cancelled attempt may consume a continuation sequence number without sending a prompt.
 
-**User sees:** A continuation can be skipped after a race with user input; the goal remains available for the next settled event or explicit resume.
+**User sees:** A continuation can be skipped after a race with user input; the goal remains available after a later normal completion or explicit resume. If another extension handles/rejects input without delivering a user message, automatic scheduling stays suppressed until a later user message is delivered; explicit resume remains available.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/pi-goal-next",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Persistent autonomous goals for pi, with Codex-verbatim goal semantics: continuation prompts, self-audited completion, budgets, and CAS-journaled state.",
   "type": "module",
   "files": [

package/src/commands.ts

@@ -49,7 +49,13 @@ export function registerGoalCommands(piLike: CommandPiLike, deps: CommandDeps):
         case "clear": return finish(await goalCommit.commit({ type: "clear" }, revision), "Goal cleared.");
         case "pause": return finish(await goalCommit.commit({ type: "transition", to: "paused", by: "user", userRequest: '"/goal pause"' }, revision), "Goal paused.");
         case "resume": {
-          const r = await goalCommit.commit({ type: "transition", to: "active", by: "user" }, revision);
+          if (!current) return "Cannot resume: no goal exists.";
+          const goal = current.goal;
+          if (goal.status === "complete") return "Cannot resume: goal is complete.";
+          const used = goal.usage.input + goal.usage.output + goal.usage.cacheRead + goal.usage.cacheWrite;
+          if (goal.tokenBudget !== null && used >= goal.tokenBudget) return "Cannot resume: token budget exhausted. Adjust /goal budget first; cumulative usage is preserved.";
+          if (goal.maxContinuations === 0) return "Cannot resume: continuation allowance is zero. Adjust /goal turns first.";
+          const r = await goalCommit.commit({ type: "transition", to: "active", by: "user", resetContinuations: true }, revision);
           if (r.kind === "ok") await deps.kick();
           return r.kind === "ok" ? "Goal resumed." : "Goal update failed.";
         }

package/src/continuation.ts

@@ -18,7 +18,7 @@ export type ContinuationDeps = {
 
 export type Continuation = {
   invalidate(): void;
-  onSettled(): Promise<void>;
+  onSettled(canSend?: () => boolean): Promise<void>;
   onMessageStart(message: unknown): Promise<void>;
   hadStaleTurn(): boolean;
 };
@@ -32,8 +32,8 @@ export function createContinuation(deps: ContinuationDeps): Continuation {
     generation += 1;
   }
 
-  async function onSettled(): Promise<void> {
-    if (!deps.isIdle() || deps.hasPendingMessages()) return;
+  async function onSettled(canSend: () => boolean = () => true): Promise<void> {
+    if (!canSend() || !deps.isIdle() || deps.hasPendingMessages()) return;
     const snapshot = deps.getSnapshot();
     if (!snapshot || snapshot.goal.status !== "active") return;
     const { goal, revision } = snapshot;
@@ -45,6 +45,7 @@ export function createContinuation(deps: ContinuationDeps): Continuation {
     if (result.kind !== "ok" || generation !== leaseGeneration) return;
     const latest = deps.getSnapshot();
     if (!latest || latest.goal.id !== goal.id || latest.goal.status !== "active") return; // user may have cleared/paused during the commit await
+    if (!canSend() || !deps.isIdle() || deps.hasPendingMessages()) return;
 
     deps.send({
       customType: "pi-goal-next/continuation",

package/src/goal-commit.ts

@@ -39,7 +39,7 @@ export function createGoalCommit(store: GoalStore) {
     switch (intent.type) {
       case "create": return { type: "goal.created", version: 1, seq, goal: next! };
       case "clear": return { type: "goal.cleared", version: 1, seq };
-      case "transition": return { type: "goal.transition", version: 1, seq, from: previous!.status, to: intent.to, by: intent.by, ...(intent.userRequest ? { userRequest: intent.userRequest } : {}) };
+      case "transition": return { type: "goal.transition", version: 1, seq, from: previous!.status, to: intent.to, by: intent.by, ...(intent.userRequest ? { userRequest: intent.userRequest } : {}), ...(intent.resetContinuations ? { resetContinuations: true } : {}) };
       case "usage": return { type: "goal.usage", version: 1, seq, input: intent.input ?? null, output: intent.output ?? null, cacheRead: intent.cacheRead ?? null, cacheWrite: intent.cacheWrite ?? null, unknownMessages: intent.unknownMessages ?? 0 };
       case "continuation_sent": return { type: "goal.continuation_sent", version: 1, seq, generation: intent.generation };
       case "stale_turn": return { type: "goal.stale_turn", version: 1, seq, generation: intent.generation };

package/src/goal.ts

@@ -7,7 +7,7 @@ export type Goal = {
 };
 export type Entry =
   | { type: "goal.created"; version: 1; seq: number; goal: Goal }
-  | { type: "goal.transition"; version: 1; seq: number; from: Status; to: Status; by: Actor; userRequest?: string }
+  | { type: "goal.transition"; version: 1; seq: number; from: Status; to: Status; by: Actor; userRequest?: string; resetContinuations?: boolean }
   | { type: "goal.cleared"; version: 1; seq: number }
   | { type: "goal.usage"; version: 1; seq: number; input: number | null; output: number | null; cacheRead: number | null; cacheWrite: number | null; unknownMessages: number }
   | { type: "goal.continuation_sent"; version: 1; seq: number; generation: number }
@@ -15,7 +15,7 @@ export type Entry =
   | { type: "goal.limit_config"; version: 1; seq: number; tokenBudget: number | null; maxContinuations: number };
 export type Intent =
   | { type: "create"; id: string; objective: string; tokenBudget?: number | null; maxContinuations?: number }
-  | { type: "transition"; to: Status; by: Actor; userRequest?: string }
+  | { type: "transition"; to: Status; by: Actor; userRequest?: string; resetContinuations?: boolean }
   | { type: "clear" }
   | { type: "usage"; input?: number | null; output?: number | null; cacheRead?: number | null; cacheWrite?: number | null; unknownMessages?: number }
   | { type: "continuation_sent"; generation: number }
@@ -55,8 +55,11 @@ export function transition(state: Goal | null, intent: Intent): Goal | null {
     if (intent.to === "paused" && !intent.userRequest?.trim()) throw new GoalError("forbidden", "paused requires user request evidence");
     if (intent.by === "agent" && !["complete", "blocked"].includes(intent.to)) throw new GoalError("forbidden", "agent cannot set this status");
     if (intent.by === "agent" && intent.to === "complete" && state.status !== "active") throw new GoalError("forbidden", "agent can complete only an active goal");
-    if (state.status === "complete" || intent.to === state.status) throw new GoalError("illegal", "illegal status transition");
-    return { ...state, status: intent.to };
+    const reset = intent.resetContinuations === true;
+    if (reset && (intent.by !== "user" || intent.to !== "active")) throw new GoalError("forbidden", "only user resume can reset continuations");
+    if (reset && state.tokenBudget !== null && usageKeys.reduce((sum, key) => sum + state.usage[key], 0) >= state.tokenBudget) throw new GoalError("budget", "token budget exhausted; adjust /goal budget before resuming");
+    if (state.status === "complete" || (intent.to === state.status && !reset)) throw new GoalError("illegal", "illegal status transition");
+    return { ...state, status: intent.to, ...(reset ? { continuationSeq: 0 } : {}) };
   }
   if (intent.type === "limit_config") {
     if (!Number.isInteger(intent.maxContinuations) || intent.maxContinuations < 0 || (intent.tokenBudget !== null && (!Number.isFinite(intent.tokenBudget) || intent.tokenBudget < 0))) throw new GoalError("invalid", "invalid limits");
@@ -95,7 +98,7 @@ export function fold(entries: readonly Entry[]): Goal | null {
     if (!entry.type.startsWith("goal.")) continue;
     if (entry.type === "goal.created") state = { ...entry.goal };
     else if (entry.type === "goal.cleared") state = null;
-    else if (state && entry.type === "goal.transition") state = transition(state, { type: "transition", to: entry.to, by: entry.by, userRequest: entry.userRequest });
+    else if (state && entry.type === "goal.transition") state = transition(state, { type: "transition", to: entry.to, by: entry.by, userRequest: entry.userRequest, resetContinuations: entry.resetContinuations });
     else if (state && entry.type === "goal.limit_config") state = transition(state, { type: "limit_config", tokenBudget: entry.tokenBudget, maxContinuations: entry.maxContinuations });
     else if (state && entry.type === "goal.continuation_sent") state = transition(state, { type: "continuation_sent", generation: entry.generation });
     else if (state && entry.type === "goal.usage") state = transition(state, { type: "usage", input: entry.input, output: entry.output, cacheRead: entry.cacheRead, cacheWrite: entry.cacheWrite, unknownMessages: entry.unknownMessages });

package/src/lifecycle.ts

@@ -15,27 +15,6 @@ export type LifecycleDeps = {
   rebuild(): void;
 };
 
-function branchTail(ctx: any): any[] {
-  const branch = ctx?.sessionManager?.getBranch?.();
-  return Array.isArray(branch) ? branch : [];
-}
-
-function messageFromEvent(event: any, ctx: any): Message | null {
-  const message = event?.message ?? event;
-  if (!message || (message.role !== "assistant" && message.role !== "toolResult")) return null;
-  const tail = branchTail(ctx);
-  const candidate = [...tail].reverse().find((entry: any) => {
-    const m = entry?.message ?? entry;
-    return m?.role === message.role;
-  });
-  const m = candidate?.message ?? candidate ?? message;
-  const entryId = candidate?.id ?? candidate?.entryId ?? m?.id ?? m?.entryId ?? message.id ?? message.entryId;
-  // Entry identity is heuristic-by-position because branch entries may omit message ids.
-  return typeof entryId === "string"
-    ? { entryId, role: message.role, usage: m?.usage ?? message.usage, toolName: m?.toolName ?? message.toolName, stopReason: m?.stopReason ?? message.stopReason }
-    : null;
-}
-
 export type PiEvents = { on(name: string, handler: (event: any, ctx: any) => unknown): void };
 export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   async function commitWithRetry(intent: Intent, attempts = 3): Promise<void> {
@@ -53,8 +32,28 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   let steered = false;
   // Stop reason of the most recent assistant turn; gates continuation on normal completion.
   let lastAssistantStop: string | undefined;
+  let epoch = 0;
+  let inputPending = false;
+  let runSignal: AbortSignal | undefined;
+  // message_end precedes SessionManager.appendMessage. Its object is authoritative;
+  // no persisted entry ID exists yet. Deduplicate live events by object identity.
+  const messageIds = new WeakMap<object, string>();
+  let messageSeq = 0;
+  const invalidate = () => {
+    epoch += 1;
+    lastAssistantStop = undefined;
+    deps.continuation.invalidate();
+  };
+  pi.on("agent_start", (_event: unknown, ctx: any) => {
+    epoch += 1;
+    lastAssistantStop = undefined;
+    // Retain the signal: ctx.signal becomes undefined once the run is idle.
+    runSignal = ctx.signal;
+  });
 
   pi.on("session_start", async (_event: SessionStartEvent, ctx: any) => {
+    invalidate();
+    inputPending = false;
     await bootstrap();
     const snapshot = deps.goalCommit.current();
     if (snapshot?.goal?.status === "active") {
@@ -63,7 +62,8 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   });
 
   pi.on("session_before_tree", async (_event: any, ctx: any) => {
-    deps.continuation.invalidate();
+    invalidate();
+    inputPending = false;
     pendingRebuild = true;
     // Pi's tree hook does not expose the post-navigation branch; rebuild on the next event.
     void ctx;
@@ -82,9 +82,12 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   const before = async (_ctx: any) => { if (pendingRebuild) { pendingRebuild = false; await bootstrap(); } };
   pi.on("message_end", async (event: MessageEndEvent, ctx: any) => {
     await before(ctx);
-    const message = messageFromEvent(event, ctx);
-    if (!message) return;
-    if (message.role === "assistant") lastAssistantStop = message.stopReason;
+    const m = event.message;
+    if (m.role !== "assistant" && m.role !== "toolResult") return;
+    if (m.role === "assistant") lastAssistantStop = m.stopReason;
+    let entryId = messageIds.get(m);
+    if (!entryId) { entryId = `live-message:${++messageSeq}`; messageIds.set(m, entryId); }
+    const message: Message = { ...m, entryId };
     const recorded = deps.accounting.recordMessage(message);
     if (recorded && !recorded.duplicate) {
       const delta = recorded.delta;
@@ -95,14 +98,21 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
     await before(ctx);
     const snapshot = deps.goalCommit.current();
     if (!snapshot) { steeredGoalId = null; steered = false; return; }
-    // Cancellation gates every automatic send, including budget-limit steering.
-    if (lastAssistantStop === "error" || lastAssistantStop === "aborted") return;
+    const settledEpoch = epoch;
+    const settledSignal = runSignal;
+    const canSend = () => epoch === settledEpoch && !settledSignal?.aborted && !inputPending && ctx.isIdle() && !ctx.hasPendingMessages();
+    // Only a fresh normal completion can authorize automatic work. Consume it
+    // once: duplicate settled events and tool-boundary aborts cannot restart us.
+    const stop = lastAssistantStop;
+    lastAssistantStop = undefined;
+    if ((stop !== "stop" && stop !== "length") || !canSend()) return;
     if (snapshot.goal.status !== "active" && snapshot.goal.status !== "budget_limited") return;
     const verdict = deps.accounting.settleTurn(snapshot.goal);
     if (verdict.kind !== "ok") {
       const latest = deps.goalCommit.current();
       if (latest && latest.goal.status !== verdict.kind) await commitWithRetry({ type: "transition", to: verdict.kind, by: "system" });
     }
+    if (!canSend()) return;
     const latest = deps.goalCommit.current();
     if (!latest) { steeredGoalId = null; steered = false; return; }
     const goal = latest.goal;
@@ -111,8 +121,17 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
       steered = true;
       deps.send({ customType: "pi-goal-next/budget_limit", content: budgetLimitPrompt(goal), display: false, details: { goalId: goal.id } }, { triggerTurn: true });
     }
-    await deps.continuation.onSettled();
+    await deps.continuation.onSettled(canSend);
+  });
+  pi.on("message_start", async (event: MessageStartEvent, ctx: any) => {
+    if (event.message.role === "user") { inputPending = false; invalidate(); }
+    await before(ctx);
+    await deps.continuation.onMessageStart(event.message);
+  });
+  pi.on("input", async (_event: InputEvent, ctx: any) => {
+    // Runs before Pi queues the input, so hasPendingMessages alone is too late.
+    inputPending = true;
+    invalidate();
+    await before(ctx);
   });
-  pi.on("message_start", async (event: MessageStartEvent, ctx: any) => { await before(ctx); await deps.continuation.onMessageStart(event?.message ?? event); });
-  pi.on("input", async (_event: InputEvent, ctx: any) => { await before(ctx); });
 }