@signalridge/pi-goal 1.4.2 → 1.4.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @signalridge/pi-goal
 
+## 1.4.4
+### Patch Changes
+
+- ef0158d: Persist goal wait reasons and deadlines, restore scheduled wakes, and resume recorded waits on real input without an extra prompt. Keep deliberate pauses stopped and cancel stale wait timers.
+- 4d300c7: Wake waiting goals only after real input is accepted, exclude unrelated usage from their budgets, preserve cumulative usage across compaction and session-tree navigation, and restore deadline timers across pause, resume, and queue transitions. Recheck overdue waits without overriding restrictive tool policies, reset safety only for delivered input, and reduce repeated goal-binding context.
+
+## 1.4.3
+### Patch Changes
+
+- 8190516: Extend the tested Pi host compatibility range through 0.87.x while retaining supported older hosts. Validate the published extensions against Pi 0.87.1 and adapt changed provider, session-context, and lifecycle contracts where necessary.
+- 8190516: Add Pi 0.99.1 to the supported host peer ranges while retaining Pi 0.84–0.87 compatibility. Align Pi development dependency pins with 0.99.1 for validation against the new host.
+- Updated dependencies [8190516]
+- Updated dependencies [8190516]
+  - @signalridge/pi-ui@1.3.2
+
 ## 1.4.2
 ### Patch Changes
 

package/README.md

@@ -38,7 +38,7 @@ Goal mode uses Codex-like persistence instructions and sends guarded continuatio
 
 ## Install
 
-Supports Pi `0.84.x` and `0.85.x`; tested with `0.85.1` — see the `peerDependencies` range. The `agent_settled` lifecycle event this extension depends on landed in `0.80.6`.
+The declared Pi peer range covers `0.84.x`–`0.87.x` and `0.99.1+` within the 0.99 minor; the current development host is `0.99.1`. See the [compatibility review](https://github.com/signalridge/pi-extensions/blob/main/docs/pi-0.99-compatibility.md) for verification details. The `agent_settled` lifecycle event this extension depends on landed in `0.80.6`.
 
 ```bash
 pi install npm:@signalridge/pi-goal
@@ -141,11 +141,11 @@ Tool visibility is a baseline, not ownership of Pi's global active-tool list. Pl
   navigate, Enter selects or submits, Escape goes Back, and Ctrl+C closes the full flow.
 - In RPC mode, bare `/goal` and `/goal status` report the current summary through an observable notification without opening terminal UI. Pi exposes no extension-command output channel in print or JSON mode, so those routes reject with an explicit unsupported-mode error instead of misreporting stderr as status output.
 - Menu-driven Replace, Clear, Prioritize, Skip, and Drop last actions preview the exact affected goals and require confirmation. Existing direct routes remain immediate for compatibility and automation.
-- `/goal <goal_to_complete>` starts goal mode. If another unfinished goal exists, Pi asks for confirmation before replacing it with a new active goal and resetting its usage counters. Failed kickoff delivery clears a new goal or restores the prior goal; a previously active goal is restored as paused.
+- `/goal <goal_to_complete>` starts goal mode. If another unfinished goal exists, Pi asks for confirmation before replacing it with a new active goal and resetting its usage counters. A synchronous kickoff-submission failure clears a new goal or restores the prior goal; a previously active goal is restored as paused.
 - `/goal --tokens 100k <goal_to_complete>` starts or replaces goal mode with a token budget. `k` and `m` suffixes are accepted, for example `100k` or `1.5m`.
-- `/goal edit <goal_to_complete>` updates the existing goal objective without resetting usage counters. A successful active edit rotates the stale-turn guard and starts a fresh safety epoch. Paused, blocked, and usage-limited goals stay stopped and retain their safety state until resume. A budget-limited goal reactivates only when `edit --tokens` raises its budget above current usage. Failed prompt delivery restores the exact previous safety counters/cause; it restores a budget-limited goal or restores and pauses a previously active goal.
-- `/goal pause` stops prompt injection and auto-continuation, aborts the current turn, and keeps the goal for later resume. Only active goals can be paused.
-- `/goal resume` resumes a paused, blocked, usage-limited, or budget-limited goal when its token budget allows it, rotates the stale-turn guard id, resets the automatic-response/repeat safety epoch when the queued resume prompt starts, clears a safety-pause cause, and reports the new finite epoch or explicit Unlimited state. Objective, cumulative usage, elapsed time, and queue are preserved. If prompt delivery fails, the original stopped state, guard id, counters, fingerprint, and cause are restored.
+- `/goal edit <goal_to_complete>` updates the existing goal objective without resetting usage counters. A successful active edit rotates the stale-turn guard and starts a fresh safety epoch. Paused, blocked, and usage-limited goals stay stopped and retain their safety state until resume. A budget-limited goal reactivates only when `edit --tokens` raises its budget above current usage. A synchronous prompt-submission failure restores the exact previous safety counters/cause; it restores a budget-limited goal or restores and pauses a previously active goal.
+- `/goal pause` stops prompt injection and auto-continuation and keeps the goal for later resume. It aborts an active goal's current turn; pausing an already-waiting goal does not interrupt unrelated work. Pausing a waiting goal cancels its deadline and input wake; only `/goal resume` can restart that deliberate pause.
+- `/goal resume` resumes a paused, blocked, usage-limited, or budget-limited goal when its token budget allows it, rotates the stale-turn guard id, resets the automatic-response/repeat safety epoch when the queued resume prompt starts, clears a safety-pause cause, and reports the new finite epoch or explicit Unlimited state. Objective, cumulative usage, elapsed time, and queue are preserved. If prompt submission throws synchronously, the original stopped state, guard id, counters, fingerprint, and cause are restored.
 - `/goal clear` clears the current goal or the entire ordered queue, status, pending continuation/transition, and legacy persisted state for the current working directory without aborting unrelated in-flight work.
 
 With `experimental.goals: true`:
@@ -163,7 +163,11 @@ Goal objectives are limited to 4,000 characters. Put longer instructions in a fi
 
 ## Session and reload behavior
 
-Goal state is stored as Pi session state, similar to Codex's thread-owned goals. `/reload` and reopening the same Pi session can restore that session's unfinished goal. An active restored goal already at or above its finite automatic-work limit pauses before another provider request and reports that progress is saved; use `/goal` to review and continue. With `"after-first-goal"`, an unfinished restore marks the tools unlocked in the new extension runtime, but it does not widen an active-tool set already restricted by an earlier lifecycle handler; an active goal instead restores as paused when either terminal tool is missing. If no unfinished goal remains, a fresh runtime starts locked again. Active elapsed time is checkpointed before shutdown and restarted after reload, so offline and stopped wall-clock time is excluded. Automatic-response counts, repeat fingerprints, and safety-pause causes persist across reload and compaction. A direct non-`/goal` user/RPC input resets the safety epoch only while the goal is active and reclassifies the in-flight run as manual; extension input and messages sent while stopped do not reset it. Starting a new Pi session in the same working directory does not inherit the old goal.
+Goal state is stored as Pi session state, similar to Codex's thread-owned goals. `/reload` and reopening the same Pi session can restore that session's unfinished goal. An active restored goal already at or above its finite automatic-work limit pauses before another provider request and reports that progress is saved; use `/goal` to review and continue. With `"after-first-goal"`, an unfinished restore marks the tools unlocked in the new extension runtime, but it does not widen an active-tool set already restricted by an earlier lifecycle handler; an active goal instead restores as paused when either terminal tool is missing. If no unfinished goal remains, a fresh runtime starts locked again. Active elapsed time is checkpointed before shutdown and restarted after reload, so offline and stopped wall-clock time is excluded. Automatic-response counts, repeat fingerprints, and safety-pause causes persist across reload and compaction. An accepted non-`/goal` user/RPC input resets the safety epoch only while the goal is active and reclassifies the in-flight run as manual; input consumed by another extension or rejected before a turn starts does not reset it. Navigating the session tree checkpoints the source goal's active time, restores the destination branch's own Goal state, and accounts only for assistant work after that branch's last Goal-state checkpoint. Pending queue transitions resume after navigation settles; leaving a managed Goal branch closes that run. Starting a new Pi session in the same working directory does not inherit the old goal.
+
+A `goal_wait` pause stores its reason and optional absolute wake deadline in the same session entry. On reload or session resume, a future deadline is re-armed; an overdue deadline gets one resume attempt after Pi is idle and pending messages have drained. No timer runs while Pi is closed. A wait without a deadline stays quiet until real interactive or RPC input is accepted for delivery, or `/goal resume` is used. Input consumed by another extension or rejected before the turn starts leaves the wait intact. Accepted real input resumes only a recorded wait and supplies the turn itself, without an extra resume prompt. A queued follow-up wakes the wait when delivered, not when queued. If delivery stays inside an existing agent run, the context hook supplies the rotated goal ID before its next response; it does not add another user turn. Extension-generated input and `/goal` commands do not count as real-input wake triggers. When Pi cannot distinguish real and extension input at delivery (for example, identical queued text or cross-transformed messages), the goal stays waiting rather than accepting a possible extension wake. That ambiguity remains attached to the waiting goal, including its deadline, until explicit `/goal resume` or reload; later input is not used to guess which earlier message was delivered. Automatic wakes do not override a restrictive active-tool policy; an overdue deadline rechecks readiness at most once per minute until Goal tools are available, while a settled boundary may wake sooner. An input whose delivery has not been confirmed also defers the deadline rather than racing a second prompt; if that input was rejected, resolve the failure and use `/goal resume` explicitly.
+
+Ordinary pauses, safety pauses, blockers, usage limits, exhausted budgets, and frozen queues do not auto-resume. Older paused entries without wait metadata remain paused; the extension does not infer a wait from transcript text. `/goal pause`, edit, clear, and replacement cancel the old wait. A synchronous deadline prompt-submission failure restores the stopped goal and wait metadata without a timer retry loop; use `/goal resume` or reload after resolving the problem. Pi's extension API does not acknowledge asynchronous prompt acceptance, so a later authentication or model failure cannot be rolled back by the extension; if no turn starts, inspect `/goal status` and explicitly pause/resume or reload after fixing the failure. Objective, cumulative usage, and the configured finite or Unlimited automatic-work setting are retained.
 
 Ordered queues use the same canonical `goal-state` session entry as single goals. Every item owns independent usage and safety state. Shelving, priority displacement, automatic advancement, and later reactivation preserve that item's epoch rather than granting more automatic work. The legacy `{ goal }` shape remains valid, and missing safety fields normalize to zero/defaults. Queue fields are written only when needed. Sessions created by the former standalone `pi-goals` experiment can migrate their last `goals-state` array and pending `unshift` intent when the branch has never written a canonical `goal-state`; any canonical entry, including an explicit clear, takes precedence so old plural state cannot be resurrected.
 
@@ -180,6 +184,7 @@ Older versions wrote unfinished goals to `~/.pi/agent/pi-goal-state.json` keyed
 - `active 3m · automatic Unlimited` — explicit Unlimited automatic work.
 - `paused · automatic limit 25/25` — the automatic-work limit paused the goal; `/goal` opens the recovery preview.
 - `paused · automatic 12/25` — another pause reason stopped work while preserving the finite epoch.
+- `waiting · automatic Unlimited` — a recorded `goal_wait` pause; `/goal status` shows its reason and any deadline.
 - `blocked · automatic 12/25` — progress requires user or external action, or a terminal non-usage error stopped work.
 - `usage · automatic 12/25` — the provider or account usage limit stopped work.
 - `budget 100k/100k · automatic 12/25` — the user-configured token budget was reached; auto-continuation stops.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalridge/pi-goal",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Pi extension for autonomous /goal completion with opt-in experimental ordered queues.",
   "type": "module",
   "license": "MIT",
@@ -36,22 +36,22 @@
     "lint": "biome check ."
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.0 || ^0.85.0",
-    "@earendil-works/pi-coding-agent": "^0.84.0 || ^0.85.0",
-    "@earendil-works/pi-tui": "^0.84.0 || ^0.85.0",
+    "@earendil-works/pi-ai": "^0.84.0 || ^0.85.0 || ^0.86.0 || ^0.87.0 || ^0.99.1",
+    "@earendil-works/pi-coding-agent": "^0.84.0 || ^0.85.0 || ^0.86.0 || ^0.87.0 || ^0.99.1",
+    "@earendil-works/pi-tui": "^0.84.0 || ^0.85.0 || ^0.86.0 || ^0.87.0 || ^0.99.1",
     "typebox": "^1.3.11"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.7",
-    "@earendil-works/pi-ai": "0.85.1",
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "typebox": "1.3.11",
     "typescript": "7.0.2"
   },
   "dependencies": {
     "@narumitw/pi-tui-kit": "^0.54.0",
-    "@signalridge/pi-ui": "^1.3.1"
+    "@signalridge/pi-ui": "^1.3.2"
   },
   "repository": {
     "type": "git",

package/src/accounting.ts

@@ -3,6 +3,8 @@ import type { Usage } from "@earendil-works/pi-ai";
 export interface GoalAccountingState {
   status: string;
   baselineTokens: number;
+  /** Usage retained from before the current session-token baseline. */
+  usageOffset?: number;
   tokensUsed: number;
   timeUsedSeconds: number;
   activeStartedAt?: number;
@@ -29,15 +31,36 @@ export function checkpointGoalActiveTime(goal: GoalAccountingState, now: number,
   goal.activeStartedAt = continueClock ? now : undefined;
 }
 
+export function rebaseGoalUsage<T extends GoalAccountingState>(goal: T, totalTokens: number): T {
+  const total = nonNegativeFiniteNumber(totalTokens);
+  const used = nonNegativeFiniteNumber(goal.tokensUsed);
+  return {
+    ...goal,
+    baselineTokens: Math.max(0, total - used),
+    usageOffset: total < used ? used - total : undefined,
+  };
+}
+
 export function updateGoalUsage(
   goal: GoalAccountingState,
   ctx: UsageContext,
   continueClock = goal.status === "active",
 ) {
   const now = Date.now();
-  const baselineTokens = nonNegativeFiniteNumber(goal.baselineTokens);
-  goal.baselineTokens = baselineTokens;
-  goal.tokensUsed = Math.max(0, currentTokenTotal(ctx) - baselineTokens);
+  const total = currentTokenTotal(ctx);
+  goal.baselineTokens = nonNegativeFiniteNumber(goal.baselineTokens);
+  goal.tokensUsed = nonNegativeFiniteNumber(goal.tokensUsed);
+  goal.usageOffset = Math.min(goal.tokensUsed, nonNegativeFiniteNumber(goal.usageOffset)) || undefined;
+  const previousTotal = goal.baselineTokens + goal.tokensUsed - (goal.usageOffset ?? 0);
+  if (total < previousTotal) {
+    const rebased = rebaseGoalUsage(goal, total);
+    goal.baselineTokens = rebased.baselineTokens;
+    goal.usageOffset = rebased.usageOffset;
+  }
+  goal.tokensUsed = Math.min(
+    Number.MAX_SAFE_INTEGER,
+    (goal.usageOffset ?? 0) + Math.max(0, total - goal.baselineTokens),
+  );
   checkpointGoalActiveTime(goal, now, continueClock);
   goal.updatedAt = now;
 }
@@ -100,3 +123,14 @@ export function currentTokenTotal(ctx: UsageContext): number {
   const sessionManager = ctx.sessionManager as { getBranch?: () => unknown[] } | undefined;
   return cumulativeAssistantTokens(sessionManager?.getBranch?.() ?? []);
 }
+
+export function assistantTokensAfterGoalState(ctx: UsageContext, customType = "goal-state") {
+  const sessionManager = ctx.sessionManager as { getBranch?: () => unknown[] } | undefined;
+  const branch = sessionManager?.getBranch?.() ?? [];
+  let lastStateIndex = -1;
+  for (let index = 0; index < branch.length; index++) {
+    const entry = branch[index] as { type?: unknown; customType?: unknown };
+    if (entry?.type === "custom" && entry.customType === customType) lastStateIndex = index;
+  }
+  return lastStateIndex < 0 ? 0 : cumulativeAssistantTokens(branch.slice(lastStateIndex + 1));
+}

package/src/commands.ts

@@ -1,4 +1,4 @@
-import { checkpointGoalActiveTime, currentTokenTotal, formatTokenCount } from "./accounting.js";
+import { checkpointGoalActiveTime, currentTokenTotal, formatTokenCount, rebaseGoalUsage } from "./accounting.js";
 import { validateObjective } from "./command.js";
 import { notifyTerminal, safeGoalMenuText } from "./errors.js";
 import type { ActiveGoal } from "./persistence.js";
@@ -24,10 +24,12 @@ import {
   isResumableGoalStatus,
   nextGoalInstance,
   queueGoalSafetyReset,
+  resetGoalSafetyEpoch,
   STATUS_KEY,
   type StatusContext,
   stoppedStatusLabel,
   transitionGoal,
+  type WaitingInputWake,
 } from "./runtime.js";
 
 // User-command mutations are kept separate from Pi event wiring. Every controller
@@ -56,6 +58,7 @@ export class GoalCommandController {
 
     const existingGoal = this.runtime.activeGoal?.status !== "complete" ? this.runtime.activeGoal : undefined;
     const existingQueuedGoals = [...this.runtime.queuedGoals];
+    const existingReplacementUsage = this.runtime.pendingReplacementUsage;
     const existingQueueIdentity = goalQueueIdentity(
       this.runtime.activeGoal,
       this.runtime.queuedGoals,
@@ -106,6 +109,14 @@ export class GoalCommandController {
     this.runtime.pendingQueueAction = undefined;
     this.runtime.activeGoal = createGoal(objective, tokenBudget, currentTokenTotal(ctx));
     const startedGoal = this.runtime.activeGoal;
+    this.runtime.pendingReplacementUsage =
+      this.runtime.agentRunGoalId !== undefined
+        ? { runGoalId: this.runtime.agentRunGoalId, replacementGoalId: startedGoal.id }
+        : undefined;
+    if (this.runtime.pendingReplacementUsage) startedGoal.usageBaselinePending = true;
+    this.runtime.ambiguousWaitInputGoalId = undefined;
+    this.runtime.pendingDirectInputs = [];
+    this.runtime.pendingNonGoalInputs = [];
     onActivated?.(startedGoal);
     this.runtime.persistGoal(startedGoal);
     if (this.runtime.activeGoal?.id !== startedGoal.id || this.runtime.activeGoal.status !== "active") {
@@ -126,7 +137,7 @@ export class GoalCommandController {
         rolledBackStartedGoal = true;
         if (existingGoal) {
           this.runtime.queuedGoals = existingQueuedGoals;
-          this.runtime.recordGoalUsage(existingGoal, ctx);
+          if (existingGoal.status === "active") this.runtime.recordGoalUsage(existingGoal, ctx);
           if (existingGoal.status === "active") {
             this.runtime.stopActiveGoal(ctx, {
               kind: "activation_rollback",
@@ -149,7 +160,9 @@ export class GoalCommandController {
         }
       }
       if (rolledBackStartedGoal) {
+        this.runtime.pendingReplacementUsage = existingReplacementUsage;
         this.runtime.toolPolicy.restore(goalToolVisibilityBeforeActivation);
+        this.runtime.scheduleGoalWaitWake(ctx);
       }
       return;
     }
@@ -274,6 +287,7 @@ export class GoalCommandController {
       return this.dispatchPendingQueueActionIfSettled(ctx);
     }
     const goal = this.runtime.activeGoal;
+    this.runtime.scheduleGoalWaitWake(ctx);
     if (goal?.status !== "active") return false;
     this.runtime.requestContinuation(goal);
     return this.runtime.dispatchContinuationIfSettled(ctx);
@@ -330,6 +344,7 @@ export class GoalCommandController {
       if (blocksStaleGoalToolCalls(this.runtime.activeGoal.status)) {
         this.runtime.blockStaleGoalToolCalls();
       }
+      this.runtime.scheduleGoalWaitWake(ctx);
       notifyTerminal(
         ctx.ui,
         `${reason === "complete" ? "Goal complete" : "Goal skipped"}: ${previousText}. Next goal remains ${this.runtime.activeGoal.status}: ${this.runtime.activeGoal.text}`,
@@ -388,8 +403,12 @@ export class GoalCommandController {
       notifyTerminal(ctx.ui, "No active goal.", "info");
       return;
     }
-    if (this.runtime.activeGoal.status !== "active") {
-      notifyTerminal(ctx.ui, `Goal is ${this.runtime.activeGoal.status}; only active goals can be paused.`, "warning");
+    if (this.runtime.activeGoal.status !== "active" && !this.runtime.activeGoal.wait) {
+      notifyTerminal(
+        ctx.ui,
+        `Goal is ${this.runtime.activeGoal.status}; only active or waiting goals can be paused.`,
+        "warning",
+      );
       return;
     }
     const stoppedGoal = this.runtime.stopActiveGoal(ctx, {
@@ -399,7 +418,74 @@ export class GoalCommandController {
     if (stoppedGoal) notifyTerminal(ctx.ui, `Goal paused: ${stoppedGoal.text}`, "info");
   }
 
-  async resumeGoal(ctx: StatusContext) {
+  private canWakeWaitingGoal() {
+    const goal = this.runtime.activeGoal;
+    return Boolean(
+      !this.runtime.queueFrozen &&
+        !this.runtime.pendingQueueAction &&
+        goal?.status === "paused" &&
+        goal.wait &&
+        this.runtime.ambiguousWaitInputGoalId !== goal.id &&
+        this.runtime.toolPolicy.toolsAvailable() &&
+        (goal.tokenBudget === undefined || goal.tokensUsed < goal.tokenBudget),
+    );
+  }
+
+  prepareWaitingGoalOnInput(ctx: StatusContext): WaitingInputWake | undefined {
+    const goal = this.runtime.activeGoal;
+    if (!goal || !this.canWakeWaitingGoal()) return undefined;
+    // Reserve the prompt binding without changing the persisted wait. Pi can
+    // still reject images after before_agent_start, before any message starts.
+    const resumedGoal = resetGoalSafetyEpoch(
+      transitionGoal(nextGoalInstance(rebaseGoalUsage(goal, currentTokenTotal(ctx))), "active"),
+    );
+    return { waitingGoal: goal, resumedGoal, generation: this.runtime.menuGeneration };
+  }
+
+  commitWaitingGoalOnInput(ctx: StatusContext, ticket: WaitingInputWake, inRun = false) {
+    if (
+      ticket.generation !== this.runtime.menuGeneration ||
+      this.runtime.activeGoal !== ticket.waitingGoal ||
+      !this.canWakeWaitingGoal()
+    )
+      return false;
+    const previousRunGoalId = this.runtime.agentRunGoalId;
+    const resumedGoal = resetGoalSafetyEpoch(
+      transitionGoal(
+        {
+          ...rebaseGoalUsage(ticket.waitingGoal, currentTokenTotal(ctx)),
+          id: ticket.resumedGoal.id,
+        },
+        "active",
+      ),
+    );
+    this.runtime.pendingInputWake = undefined;
+    this.runtime.cancelContinuationWork();
+    this.runtime.clearGoalRecovery();
+    this.runtime.clearBudgetWrapUp();
+    this.runtime.clearStaleGoalToolCallBlock();
+    this.runtime.pendingDirectInputs = this.runtime.pendingDirectInputs
+      .filter((pending) => pending.realInput && pending.goalId === ticket.waitingGoal.id)
+      .map((pending) => ({ ...pending, goalId: resumedGoal.id }));
+    this.runtime.pendingNonGoalInputs = this.runtime.pendingNonGoalInputs.filter((pending) => pending.realInput);
+    this.runtime.activeGoal = resumedGoal;
+    if (inRun) {
+      this.runtime.inputWakeGoalId = resumedGoal.id;
+      this.runtime.inputWakeNeedsPrompt = previousRunGoalId !== ticket.waitingGoal.id;
+    }
+    this.runtime.beginAgentRun(resumedGoal.id, "manual");
+    this.runtime.persistGoal(resumedGoal);
+    if (ticket.generation !== this.runtime.menuGeneration || this.runtime.activeGoal !== resumedGoal) return false;
+    this.runtime.updateStatus(ctx, resumedGoal);
+    return true;
+  }
+
+  resumeWaitingGoalOnInput(ctx: StatusContext, inRun = false) {
+    const ticket = this.prepareWaitingGoalOnInput(ctx);
+    return ticket ? this.commitWaitingGoalOnInput(ctx, ticket, inRun) : false;
+  }
+
+  private prepareGoalResume(ctx: StatusContext, resetOnPrompt: boolean) {
     if (!this.runtime.activeGoal) {
       notifyTerminal(ctx.ui, "No active goal.", "info");
       return;
@@ -427,19 +513,29 @@ export class GoalCommandController {
       return;
     }
     const stoppedGoal = this.runtime.activeGoal;
-    const stoppedStatus = stoppedGoal.status;
+    this.runtime.ambiguousWaitInputGoalId = undefined;
+    this.runtime.pendingDirectInputs = [];
+    this.runtime.pendingNonGoalInputs = [];
     this.runtime.cancelContinuationWork();
     this.runtime.clearGoalRecovery();
     this.runtime.clearBudgetWrapUp();
     this.runtime.clearStaleGoalToolCallBlock();
-    this.runtime.activeGoal = queueGoalSafetyReset(transitionGoal(nextGoalInstance(this.runtime.activeGoal), "active"));
-    this.runtime.persistGoal(this.runtime.activeGoal);
-    this.runtime.updateStatus(ctx, this.runtime.activeGoal);
-    if (this.runtime.activeGoal.status !== "active") {
-      notifyTerminal(ctx.ui, `Goal token budget is still reached: ${formatBudget(this.runtime.activeGoal)}`, "warning");
-      return;
-    }
-    const resumedGoal = this.runtime.activeGoal;
+    const rebased = rebaseGoalUsage({ ...stoppedGoal, usageBaselinePending: undefined }, currentTokenTotal(ctx));
+    const active = transitionGoal(nextGoalInstance(rebased), "active");
+    const resumedGoal = resetOnPrompt ? queueGoalSafetyReset(active) : resetGoalSafetyEpoch(active);
+    this.runtime.activeGoal = resumedGoal;
+    this.runtime.persistGoal(resumedGoal);
+    // Canonical state publication can synchronously pause or replace the goal.
+    if (this.runtime.activeGoal !== resumedGoal || resumedGoal.status !== "active") return;
+    this.runtime.updateStatus(ctx, resumedGoal);
+    return { stoppedGoal, resumedGoal, goalToolVisibilityBeforeActivation };
+  }
+
+  async resumeGoal(ctx: StatusContext, source: "explicit" | "deadline" = "explicit") {
+    const prepared = this.prepareGoalResume(ctx, true);
+    if (!prepared) return;
+    const { stoppedGoal, resumedGoal, goalToolVisibilityBeforeActivation } = prepared;
+    const stoppedStatus = stoppedGoal.status;
     const sent = await this.runtime.sendOwnedGoalPrompt(
       ctx,
       resumedGoal.id,
@@ -454,6 +550,9 @@ export class GoalCommandController {
           this.runtime.blockStaleGoalToolCalls();
         }
         this.runtime.toolPolicy.restore(goalToolVisibilityBeforeActivation);
+        if (source === "explicit" && stoppedGoal.wait?.resumeAt !== undefined) {
+          this.runtime.scheduleGoalWaitWake(ctx);
+        }
       }
       return;
     }
@@ -497,7 +596,7 @@ export class GoalCommandController {
       return;
     }
 
-    this.runtime.recordGoalUsage(this.runtime.activeGoal, ctx);
+    if (this.runtime.activeGoal.status === "active") this.runtime.recordGoalUsage(this.runtime.activeGoal, ctx);
     const previousGoal = { ...this.runtime.activeGoal };
     this.runtime.cancelContinuationWork();
     this.runtime.clearGoalRecovery();
@@ -512,7 +611,12 @@ export class GoalCommandController {
       },
       editedGoalStatus(previousStatus),
     );
-    const nextGoal = transitionedGoal.status === "active" ? queueGoalSafetyReset(transitionedGoal) : transitionedGoal;
+    const nextGoal =
+      transitionedGoal.status === "active"
+        ? queueGoalSafetyReset(
+            previousStatus === "active" ? transitionedGoal : rebaseGoalUsage(transitionedGoal, currentTokenTotal(ctx)),
+          )
+        : transitionedGoal;
     const goalToolVisibilityBeforeActivation =
       nextGoal.status === "active" ? this.runtime.toolPolicy.snapshot() : undefined;
     if (nextGoal.status === "active") {
@@ -574,7 +678,7 @@ export class GoalCommandController {
       this.reportGoalStatus(ctx, message);
       return;
     }
-    if (!this.runtime.queueFrozen) {
+    if (!this.runtime.queueFrozen && this.runtime.activeGoal.status === "active") {
       this.runtime.recordGoalUsage(this.runtime.activeGoal, ctx);
       this.runtime.persistGoal(this.runtime.activeGoal);
       this.runtime.updateStatus(ctx, this.runtime.activeGoal);
@@ -640,6 +744,7 @@ export class GoalCommandController {
           this.runtime.pauseGoalForUnavailableTools(ctx, true, !displacedUsageFinalized);
         } else {
           this.runtime.persistGoal(currentGoal);
+          this.runtime.scheduleGoalWaitWake(ctx);
         }
       }
       return false;
@@ -685,6 +790,7 @@ export class GoalCommandController {
         this.runtime.updateStatus(ctx, this.runtime.activeGoal);
       }
       this.runtime.toolPolicy.restore(visibilityBeforeActivation);
+      this.runtime.scheduleGoalWaitWake(ctx);
       return false;
     }
     notifyTerminal(ctx.ui, `Goal prioritized: ${objective}`, "info");

package/src/goal.ts

@@ -21,7 +21,7 @@ function registerGoalRuntime(pi: ExtensionAPI, options: GoalOptions = {}) {
   // the real one. Wired here because the controller owns it and the runtime,
   // which arms the timer, deliberately does not depend on the controller.
   runtime.onGoalWaitElapsed = (ctx) => {
-    void commands.resumeGoal(ctx);
+    void commands.resumeGoal(ctx, "deadline");
   };
 
   // Keep registration order explicit: managed-run bus listeners exist before tools,