trace-needs-input-marker -> main

apps/ade-cli/src/adeRpcServer.test.ts

@@ -1560,7 +1560,7 @@ describe("adeRpcServer", () => {
           args: { outcome: "Shipped" },
           assert: () => expect(runtime.sessionService.settleSession).toHaveBeenCalledWith(
             "chat-1",
-            { outcome: "Shipped" },
+            { outcome: "Shipped", source: "agent_explicit" },
           ),
         },
         {

apps/ade-cli/src/bootstrap.ts

@@ -688,9 +688,23 @@ export async function createAdeRuntime(args: {
   laneServiceRef = laneService;
   await laneService.ensurePrimaryLane();
 
+  // Late-bound because the publisher is constructed after the session/PTY
+  // services. Session changes still use it once publishing is attached.
+  let pushPublisherForPtySignals: PushPublisherService | null = null;
   const sessionService = createSessionService({ db });
   sessionService.onChanged((event) => {
     pushEvent("runtime", { type: "terminal_session_changed", event });
+    const session = sessionService.get(event.sessionId);
+    if (
+      session
+      && (session.status !== "running" || session.runtimeState === "idle")
+      && (
+        session.settleOverride === "settled"
+        || (session.settleOverride !== "active" && Boolean(session.settledAt))
+      )
+    ) {
+      pushPublisherForPtySignals?.handleSessionSettled(projectId, event.sessionId);
+    }
   });
   const processRegistry = createProcessRegistryService({
     db,
@@ -900,10 +914,8 @@ export async function createAdeRuntime(args: {
   // pattern as desktop main. Without this bridge, paired phones only ever
   // receive terminal snapshots, never live terminal_data push.
   let syncServiceForPtyEvents: ReturnType<typeof createSyncService> | null = null;
-  // Same late-binding for the push publisher: it feeds tracked CLI runtime
-  // states (running / waiting-input from OSC 133 markers) into the phone's
-  // Live Activity, and it's constructed after ptyService.
-  let pushPublisherForPtySignals: PushPublisherService | null = null;
+  // The late-bound push publisher feeds tracked CLI runtime states into the
+  // phone's Live Activity.
   const ptyService = createPtyService({
     projectRoot,
     transcriptsDir: paths.transcriptsDir,
@@ -931,6 +943,9 @@ export async function createAdeRuntime(args: {
         runtimeState: signal.runtimeState,
       });
     },
+    onSessionUserInput: ({ sessionId }) => {
+      pushPublisherForPtySignals?.handleSessionAttentionResolved(projectId, sessionId);
+    },
     diskPressureMonitor,
     onSessionEnded: (event) => {
       void sessionDeltaService.computeSessionDelta(event.sessionId).catch((error) => {
@@ -1509,6 +1524,10 @@ export async function createAdeRuntime(args: {
               title: session.title ?? null,
               toolType: session.toolType ?? null,
               chatSessionId: session.chatSessionId ?? null,
+              status: session.status,
+              runtimeState: session.runtimeState ?? null,
+              settledAt: session.settledAt ?? null,
+              settleOverride: session.settleOverride ?? null,
             };
           } catch {
             return null;

apps/ade-cli/src/services/push/pushPublisherService.test.ts

@@ -285,7 +285,15 @@ describe("createPushPublisherService flush", () => {
       flushDebounceMs: 2_000,
       promptFlushMs: 150,
     });
-    const cliSessions = new Map<string, { title: string | null; toolType?: string | null; chatSessionId?: string | null }>();
+    const cliSessions = new Map<string, {
+      title: string | null;
+      toolType?: string | null;
+      chatSessionId?: string | null;
+      status?: string | null;
+      runtimeState?: string | null;
+      settledAt?: string | null;
+      settleOverride?: "settled" | "active" | null;
+    }>();
     const detach = publisher.attachSources("scope-1", {
       agentChatService: agentChatService as never,
       projectName: "ADE",
@@ -1843,7 +1851,7 @@ describe("createPushPublisherService flush", () => {
       run({ sessionId: "s-1", kind: "chat", phase: "waiting_for_input" }),
     ])).toBe(1);
     const waitingRun = second.liveActivity[0].contentState.runs.find((r: { id: string }) => r.id === "cli-1");
-    expect(waitingRun.phase).toBe("waiting_for_input");
+    expect(waitingRun.phase).toBe("stale");
 
     publisher.dispose();
   });
@@ -1875,6 +1883,27 @@ describe("createPushPublisherService flush", () => {
       detail: "Which account should the e2e test use?",
     });
 
+    publisher.handleCliRuntimeSignal("scope-1", {
+      laneId: "auth-lane",
+      sessionId: "cli-ask-1",
+      runtimeState: "idle",
+    });
+    await vi.advanceTimersByTimeAsync(200);
+    const heartbeatPayload = publish.mock.calls.at(-1)?.[0];
+    expect(heartbeatPayload.liveActivity[0].contentState.runs[0]).toMatchObject({
+      id: "cli-ask-1",
+      phase: "waiting_for_input",
+    });
+
+    publisher.handleSessionAttentionResolved("scope-1", "cli-ask-1");
+    expect(publisher._debug.getPendingAlerts()).toEqual([]);
+    await vi.advanceTimersByTimeAsync(200);
+    const resolvedPayload = publish.mock.calls.at(-1)?.[0];
+    expect(resolvedPayload.liveActivity[0].contentState.runs[0]).toMatchObject({
+      id: "cli-ask-1",
+      phase: "running",
+    });
+
     publisher.dispose();
   });
 
@@ -1916,6 +1945,45 @@ describe("createPushPublisherService flush", () => {
     publisher.dispose();
   });
 
+  it("terminates a waiting CLI run when dismiss-and-settle resolves attention", async () => {
+    const { publisher, cliSessions } = makeHarness();
+    await publisher.start();
+
+    publisher.handleSessionAttentionRequested("scope-1", {
+      sessionId: "cli-settle-1",
+      kind: "cli",
+      title: "Fix auth race",
+      message: "Choose an account",
+      laneId: "auth-lane",
+    });
+    publisher.handleSessionSettled("scope-1", "cli-settle-1");
+
+    expect(publisher._debug.getPendingAlerts()).toEqual([]);
+    expect(publisher._debug.runs.has("cli-settle-1")).toBe(false);
+
+    cliSessions.set("cli-settle-1", {
+      title: "Fix auth race",
+      toolType: "codex",
+      status: "running",
+      settledAt: "2026-07-29T22:00:00.000Z",
+    });
+    publisher.handleCliRuntimeSignal("scope-1", {
+      laneId: "auth-lane",
+      sessionId: "cli-settle-1",
+      runtimeState: "running",
+    });
+    expect(publisher._debug.runs.get("cli-settle-1")?.phase).toBe("running");
+
+    publisher.handleCliRuntimeSignal("scope-1", {
+      laneId: "auth-lane",
+      sessionId: "cli-settle-1",
+      runtimeState: "idle",
+    });
+    expect(publisher._debug.runs.has("cli-settle-1")).toBe(false);
+
+    publisher.dispose();
+  });
+
   it("drops chat-owned shells and unknown sessions from CLI run tracking", async () => {
     const { publisher, publish, emit, cliSessions } = makeHarness();
     cliSessions.set("shell-1", { title: "attached shell", toolType: "shell", chatSessionId: "s-1" });

apps/ade-cli/src/services/push/pushPublisherService.ts

@@ -196,6 +196,10 @@ export type PushPublisherSources = {
     title: string | null;
     toolType?: string | null;
     chatSessionId?: string | null;
+    status?: string | null;
+    runtimeState?: string | null;
+    settledAt?: string | null;
+    settleOverride?: "settled" | "active" | null;
   } | null;
 };
 
@@ -932,6 +936,19 @@ export function createPushPublisherService(deps: PushPublisherDeps) {
           runs.delete(run.sessionId);
           continue;
         }
+        const atRest = record.status !== "running" || record.runtimeState === "idle";
+        if (
+          atRest
+          && (
+            record.settleOverride === "settled"
+            || (record.settleOverride !== "active" && record.settledAt)
+          )
+        ) {
+          run.phase = "completed";
+          recentRuns.set(run.sessionId, { ...run });
+          runs.delete(run.sessionId);
+          continue;
+        }
         run.title = record.title?.trim() || run.title || null;
         run.agent = providerDisplayName(record.toolType) ?? run.agent ?? "CLI";
         run.metaResolved = true;
@@ -1548,22 +1565,49 @@ export function createPushPublisherService(deps: PushPublisherDeps) {
   };
 
   /**
-   * OSC 133-derived terminal state for tracked CLI sessions. Feeds the Live
-   * Activity only — no alert pushes: a CLI agent returns to its prompt
-   * (waiting-input) after EVERY turn, so alerting on it would ping the user
-   * once per turn. Failure alerts stay with onPtyExit's non-zero-exit path.
+   * Terminal runtime state for tracked CLI sessions. Prompt/marker inference
+   * must never raise attention: only an explicit `ade chat ask` or a
+   * provider-structured pending input may publish `waiting_for_input`.
    */
   const onCliRuntimeSignal = (scopeKey: string, signal: PushCliRuntimeSignal): void => {
     if (disposed || !signal.sessionId) return;
     const existing = runs.get(signal.sessionId);
+    const session = scopes.get(scopeKey)?.resolveCliSession?.(signal.sessionId) ?? null;
+    const atRest = session?.status !== "running" || signal.runtimeState === "idle";
+    if (
+      atRest
+      && (
+        session?.settleOverride === "settled"
+        || (session?.settleOverride !== "active" && Boolean(session?.settledAt))
+      )
+    ) {
+      if (existing) {
+        existing.phase = "completed";
+        existing.itemId = null;
+        markRunUpdated(existing);
+        recentRuns.set(signal.sessionId, { ...existing });
+        runs.delete(signal.sessionId);
+        pendingAlerts = pendingAlerts.filter(
+          (alert) =>
+            alert.dedupeKey !== `alert:${signal.sessionId}:approval`
+            && alert.dedupeKey !== `alert:${signal.sessionId}:question`,
+        );
+        clearAlertDedupe(`alert:${signal.sessionId}:approval`);
+        clearAlertDedupe(`alert:${signal.sessionId}:question`);
+        scheduleFlush(true);
+      }
+      return;
+    }
     // Exit/kill phases are owned by onPtyExit (which knows the exit code).
     if (signal.runtimeState === "exited" || signal.runtimeState === "killed") return;
+    // Explicit/provider-structured attention owns this phase until the
+    // lifecycle event that resolves it. PTY heartbeats are observational and
+    // must not erase a real request.
+    if (existing?.phase === "waiting_for_input" || existing?.phase === "waiting_for_approval") return;
     // `idle` = no output for 12s with no OSC prompt marker — we can't prove
     // the CLI is working OR at a prompt, so publish it as `stale` (dimmed,
     // not counted active) instead of overstating it as a live running row.
-    const phase: AgentRunPhase = signal.runtimeState === "waiting-input"
-      ? "waiting_for_input"
-      : signal.runtimeState === "idle"
+    const phase: AgentRunPhase = signal.runtimeState === "waiting-input" || signal.runtimeState === "idle"
         ? "stale"
         : "running";
     // Signals re-fire on a ~10s heartbeat; only a phase change is worth a
@@ -1886,6 +1930,43 @@ export function createPushPublisherService(deps: PushPublisherDeps) {
       scheduleFlush(true);
     },
 
+    handleSessionAttentionResolved(scopeKey: string | null, sessionId: string): void {
+      if (disposed || !sessionId) return;
+      const run = runs.get(sessionId);
+      if (!run || (scopeKey != null && run.scopeKey !== scopeKey)) return;
+      if (run.phase !== "waiting_for_input" && run.phase !== "waiting_for_approval") return;
+      run.phase = "running";
+      run.itemId = null;
+      markRunUpdated(run);
+      pendingAlerts = pendingAlerts.filter(
+        (alert) =>
+          alert.dedupeKey !== `alert:${sessionId}:approval`
+          && alert.dedupeKey !== `alert:${sessionId}:question`,
+      );
+      clearAlertDedupe(`alert:${sessionId}:approval`);
+      clearAlertDedupe(`alert:${sessionId}:question`);
+      scheduleFlush(true);
+    },
+
+    handleSessionSettled(scopeKey: string | null, sessionId: string): void {
+      if (disposed || !sessionId) return;
+      const run = runs.get(sessionId);
+      if (!run || (scopeKey != null && run.scopeKey !== scopeKey)) return;
+      run.phase = "completed";
+      run.itemId = null;
+      markRunUpdated(run);
+      recentRuns.set(sessionId, { ...run });
+      runs.delete(sessionId);
+      pendingAlerts = pendingAlerts.filter(
+        (alert) =>
+          alert.dedupeKey !== `alert:${sessionId}:approval`
+          && alert.dedupeKey !== `alert:${sessionId}:question`,
+      );
+      clearAlertDedupe(`alert:${sessionId}:approval`);
+      clearAlertDedupe(`alert:${sessionId}:question`);
+      scheduleFlush(true);
+    },
+
     /** Force a flush soon (e.g. right after a device registers). */
     poke(): void {
       scheduleFlush(true);