fix(cli): settle goal pause suppression on command settle and announce resumed live goals

- /goal pause cleared selfInitiatedPauseGoalId only when the push handler
  observed the transition; a response-before-push ordering left the flag
  set and suppressed a later host-initiated pause notice. The success path
  now clears the flag and syncs the transition cache to the authoritative
  response, so the trailing push no longer duplicates the notice.
- The attach-time goal notice ran before the driver adopted a resumed
  session, so resuming into a session with a live durable goal never
  announced the auto-continuing loop. switchSession now syncs the goal
  transition cache and emits the notice after the transcript replacement
  that would erase an adoption-time notice.

Author: me2seeks

packages/cli/src/__tests__/pi-tui-runner.test.ts

@@ -5005,6 +5005,99 @@ describe('Maka Pi TUI runner', () => {
       ]);
     });
 
+    test('a settled /goal pause does not suppress a later host-initiated pause notice', async () => {
+      const terminal = new FakeTerminal(160, 24);
+      const driver = new SlashCommandDriver();
+      driver.goal = armedGoal;
+      // The host can answer the control RPC before the subscription push folds
+      // the transition; the suppression flag must settle with the command
+      // instead of lingering for the push handler.
+      driver.deferGoalControlPush = true;
+      const run = runMakaPiTui({
+        title: 'Maka',
+        driver,
+        cwd: '/repo',
+        model: 'claude-sonnet-4-5',
+        connectionSlug: 'claude-subscription',
+        permissionMode: 'ask',
+        terminal,
+      });
+      await waitFor(() => plainTerminalOutput(terminal.output()).includes('goal 2/50'));
+
+      terminal.input('/goal pause');
+      terminal.input('\r');
+      await waitFor(() =>
+        plainTerminalOutput(terminal.output()).includes('Goal paused. /goal resume continues it'),
+      );
+
+      // The trailing push of the command's own pause folds onto the settled
+      // projection: no duplicate auto-pause notice.
+      driver.pushGoal({ ...armedGoal, status: 'paused', revision: 4, pausedAt: Date.now() });
+      await waitFor(() => plainTerminalOutput(terminal.output()).includes('goal paused 2/50'));
+      assert.equal(
+        plainTerminalOutput(terminal.output()).includes('Goal paused (2/50).'),
+        false,
+      );
+
+      terminal.input('/goal resume');
+      terminal.input('\r');
+      await waitFor(() => plainTerminalOutput(terminal.output()).includes('Goal resumed.'));
+
+      // A later host-initiated pause of the same goal (e.g. the Ctrl+C
+      // auto-pause) must announce itself.
+      driver.pushGoal({
+        ...armedGoal,
+        status: 'paused',
+        revision: 6,
+        pausedAt: Date.now(),
+        lastReason: 'Goal-associated turn was aborted.',
+      });
+      await waitFor(() =>
+        plainTerminalOutput(terminal.output()).includes(
+          'Goal paused (2/50). Goal-associated turn was aborted.',
+        ),
+      );
+
+      exitMaka(terminal);
+      await Promise.race([
+        run,
+        delay(CLOSE_BUDGET_MS).then(() => {
+          throw new Error('TUI did not close during test cleanup');
+        }),
+      ]);
+    });
+
+    test('resuming into a session with a live goal announces the auto-continuing loop', async () => {
+      const terminal = new FakeTerminal(160, 24);
+      const driver = new SlashCommandDriver([fakeSessionSummary('session-2', '/repo')]);
+      // Before the switch, the driver has no attached session — the init-time
+      // check sees nothing; the notice must come from the switch seam.
+      driver.goal = null;
+      driver.goalsBySessionId.set('session-2', armedGoal);
+      const run = runMakaPiTui({
+        title: 'Maka',
+        driver,
+        cwd: '/repo',
+        model: 'claude-sonnet-4-5',
+        connectionSlug: 'claude-subscription',
+        permissionMode: 'ask',
+        terminal,
+        resumeSessionId: 'session-2',
+      });
+
+      await waitFor(() =>
+        plainTerminalOutput(terminal.output()).includes('Autonomous goal is running (2/50)'),
+      );
+
+      exitMaka(terminal);
+      await Promise.race([
+        run,
+        delay(CLOSE_BUDGET_MS).then(() => {
+          throw new Error('TUI did not close during test cleanup');
+        }),
+      ]);
+    });
+
     test('/goal control pre-validates impossible transitions', async () => {
       const terminal = new FakeTerminal();
       const driver = new SlashCommandDriver();
@@ -6264,6 +6357,13 @@ class SlashCommandDriver implements MakaSessionDriver {
 
   /** Records control actions and applies them to the local goal like the host would. */
   readonly controlledGoalActions: Array<'pause' | 'resume' | 'clear'> = [];
+  /**
+   * When true, controlGoal resolves without pushing the projection first —
+   * the response-before-push ordering a slow subscription stream can produce.
+   */
+  deferGoalControlPush = false;
+  /** Per-session goal projections applied when switchSession adopts a session. */
+  readonly goalsBySessionId = new Map<string, GoalProjection | null>();
 
   controlGoal(action: 'pause' | 'resume' | 'clear'): Promise<GoalProjection | null> {
     this.controlledGoalActions.push(action);
@@ -6275,7 +6375,11 @@ class SlashCommandDriver implements MakaSessionDriver {
         : action === 'pause'
           ? { ...goal, status: 'paused', revision: goal.revision + 1, pausedAt: Date.now() }
           : { ...goal, status: 'active', revision: goal.revision + 1, pausedAt: null };
-    this.pushGoal(next);
+    if (this.deferGoalControlPush) {
+      this.goal = next;
+    } else {
+      this.pushGoal(next);
+    }
     return Promise.resolve(next);
   }
 
@@ -6381,6 +6485,9 @@ class SlashCommandDriver implements MakaSessionDriver {
     const nextSummary = summary ?? fakeSessionSummary(sessionId);
     this.orchestrationMode = nextSummary.orchestrationMode ?? 'default';
     this.activeBoundaryDisplayMode = this.boundaryDisplayModeBySession.get(nextSummary.id);
+    if (this.goalsBySessionId.has(sessionId)) {
+      this.goal = this.goalsBySessionId.get(sessionId) ?? null;
+    }
     return switchResult(nextSummary, [...(this.sessionMessages.get(nextSummary.id) ?? [])]);
   }
   async listRewindTargets(): Promise<RewindTarget[]> {

packages/cli/src/pi-tui-runner.ts

@@ -368,7 +368,9 @@ export async function runMakaPiTui(input: MakaPiTuiInput): Promise<void> {
     requestRender();
   });
   // Attaching to a session whose durable goal auto-continues after recovery
-  // must never resume a token-burning loop silently.
+  // must never resume a token-burning loop silently. This covers a driver
+  // that is already attached at startup; a resumeSessionId attach happens
+  // later, so switchSession repeats the check after adopting the session.
   if (
     currentGoal !== null &&
     (currentGoal.status === 'active' || currentGoal.status === 'waiting')
@@ -1423,6 +1425,23 @@ export async function runMakaPiTui(input: MakaPiTuiInput): Promise<void> {
       relocateCwd === undefined ? undefined : { relocateCwd },
     );
     await applySwitchResult(result);
+    // Sync the transition cache to the adopted session's goal, then announce a
+    // live durable goal: the init-time check ran before the driver attached
+    // the resumed session, and the goal subscription only announces pause
+    // transitions. Emitting here — after the transcript replacement that
+    // would erase a notice from adoption time — keeps an auto-continuing
+    // token-burning loop from resuming silently.
+    currentGoal = input.driver.getGoal?.() ?? null;
+    if (
+      currentGoal !== null &&
+      (currentGoal.status === 'active' || currentGoal.status === 'waiting')
+    ) {
+      state.entries.push({
+        kind: 'notice',
+        level: 'info',
+        text: goalAttachedNoticeText(currentGoal),
+      });
+    }
     if (result.relocation?.changed) {
       const warning =
         result.relocation.oldCwdDirty === true
@@ -2518,7 +2537,15 @@ export async function runMakaPiTui(input: MakaPiTuiInput): Promise<void> {
       notice(action === 'clear' ? 'Goal cleared.' : 'The goal no longer exists.');
       return;
     }
+    // Keep the transition cache on the authoritative response: a trailing push
+    // of this same transition then folds onto an identical previous state and
+    // is not mistaken for a fresh one.
+    currentGoal = result;
     if (action === 'pause') {
+      // Settle the suppression flag: the command's own confirmation has told
+      // the user, and a lingering flag would suppress a later host-initiated
+      // pause of this goal (e.g. the Ctrl+C auto-pause).
+      selfInitiatedPauseGoalId = null;
       notice('Goal paused. /goal resume continues it, /goal clear stops it.');
     } else if (action === 'resume') {
       notice('Goal resumed.');