@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/src/shared-types.ts

@@ -15,6 +15,15 @@ import type {
     DetectedIde,
     AgentEntry,
 } from './types.js';
+import type {
+    SessionAttachedClient as CoreSessionAttachedClient,
+    SessionWriteOwner as CoreSessionWriteOwner,
+    SessionHostRecord as CoreSessionHostRecord,
+    SessionHostLogEntry as CoreSessionHostLogEntry,
+    SessionHostRequestTrace as CoreSessionHostRequestTrace,
+    SessionHostRuntimeTransition as CoreSessionHostRuntimeTransition,
+    SessionHostDiagnostics as CoreSessionHostDiagnostics,
+} from '@adhdev/session-host-core';
 
 export type {
     StatusResponse,
@@ -56,6 +65,7 @@ import type {
     GitWorkspaceUpdate,
     WorkspaceGitSubscriptionParams,
 } from './git/git-types.js';
+import type { InteractivePrompt } from './providers/types/interactive-prompt.js';
 
 export type {
     GitCommandName,
@@ -110,6 +120,14 @@ export interface ReadChatSyncResult {
     status: string;
     title?: string;
     activeModal?: { message: string; buttons: string[] } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    /**
+     * Chat source provenance from ChatSourceMachine (A2). Carries the
+     * selected source, transition cause, lock state, and legacy
+     * fallbackReason — opaque to the daemon-core, consumed by web-core
+     * for the source debug badge and SourceTimeline (A3).
+     */
+    messageSource?: Record<string, unknown>;
 }
 
 export interface ProviderSummaryItem {
@@ -125,70 +143,67 @@ export interface ProviderSummaryMetadata {
     items: ProviderSummaryItem[];
 }
 
-export interface SessionHostAttachedClient {
-    clientId: string;
+/**
+ * Wire-subset session-host types.
+ *
+ * These are the shapes daemon-core / web-core see over the wire — a subset of the
+ * authoritative types owned by @adhdev/session-host-core (which additionally carry
+ * transport / category / launchCommand / buffer and stricter union typing on wire
+ * scalars). They are DERIVED from the SSOT via Pick/Omit so shared fields cannot
+ * drift; only the deliberate wire looseness (string-typed `type`/`lifecycle`,
+ * optional `meta`) is re-applied here.
+ */
+export type SessionHostAttachedClient = Omit<CoreSessionAttachedClient, 'type'> & {
+    /** Widened over the wire — the raw client-type string is not re-validated here. */
     type: string;
-    readOnly: boolean;
-    attachedAt: number;
-    lastSeenAt: number;
-}
-
-export interface SessionHostWriteOwner {
-    clientId: string;
-    ownerType: 'agent' | 'user';
-    acquiredAt: number;
-}
+};
 
-export interface SessionHostRecord {
-    sessionId: string;
-    runtimeKey: string;
-    displayName: string;
-    workspaceLabel: string;
-    providerType: string;
-    workspace: string;
-    lifecycle: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
-    surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
+export type SessionHostWriteOwner = CoreSessionWriteOwner;
+
+export type SessionHostRecord = Pick<
+    CoreSessionHostRecord,
+    | 'sessionId'
+    | 'runtimeKey'
+    | 'displayName'
+    | 'workspaceLabel'
+    | 'providerType'
+    | 'workspace'
+    | 'lifecycle'
+    | 'surfaceKind'
+    | 'osPid'
+    | 'lastActivityAt'
+    | 'createdAt'
+    | 'startedAt'
+> & {
     writeOwner: SessionHostWriteOwner | null;
     attachedClients: SessionHostAttachedClient[];
-    osPid?: number;
-    lastActivityAt: number;
-    createdAt: number;
-    startedAt?: number;
+    /** Optional over the wire — omitted when the record carries no metadata. */
     meta?: Record<string, unknown>;
-}
+};
 
-export interface SessionHostLogEntry {
-    timestamp: number;
-    level: 'debug' | 'info' | 'warn' | 'error';
-    message: string;
-    sessionId?: string;
-}
+export type SessionHostLogEntry = Omit<CoreSessionHostLogEntry, 'data'>;
 
-export interface SessionHostRequestTrace {
-    timestamp: number;
-    requestId: string;
+export type SessionHostRequestTrace = Omit<CoreSessionHostRequestTrace, 'type'> & {
+    /** Widened over the wire — the request-type union is not re-validated here. */
     type: string;
-    sessionId?: string;
-    clientId?: string;
-    success: boolean;
-    durationMs: number;
-    error?: string;
-}
+};
 
-export interface SessionHostRuntimeTransition {
-    timestamp: number;
-    sessionId: string;
-    action: string;
+export type SessionHostRuntimeTransition = Omit<CoreSessionHostRuntimeTransition, 'lifecycle'> & {
+    /** Widened over the wire — the lifecycle union is not re-validated here. */
     lifecycle?: string;
-    detail?: string;
-    success?: boolean;
-    error?: string;
-}
+};
 
-export interface SessionHostDiagnosticsSnapshot {
-    hostStartedAt: number;
-    endpoint: string;
-    runtimeCount: number;
+export type SessionHostDiagnosticsSnapshot = Omit<
+    CoreSessionHostDiagnostics,
+    | 'supportedRequestTypes'
+    | 'sessions'
+    | 'liveRuntimes'
+    | 'recoverySnapshots'
+    | 'inactiveRecords'
+    | 'recentLogs'
+    | 'recentRequests'
+    | 'recentTransitions'
+> & {
     sessions?: SessionHostRecord[];
     liveRuntimes?: SessionHostRecord[];
     recoverySnapshots?: SessionHostRecord[];
@@ -196,7 +211,7 @@ export interface SessionHostDiagnosticsSnapshot {
     recentLogs: SessionHostLogEntry[];
     recentRequests: SessionHostRequestTrace[];
     recentTransitions: SessionHostRuntimeTransition[];
-}
+};
 
 export type TransportTopic = 'session.chat_tail' | 'session.runtime_output' | 'machine.runtime' | 'session_host.diagnostics' | 'session.modal' | 'daemon.metadata' | 'workspace.git';
 
@@ -283,6 +298,18 @@ export interface DaemonMetadataUpdate {
     userName?: string;
     seq: number;
     timestamp: number;
+    /**
+     * Per-mesh state-change revision counters (meshId → monotonically increasing
+     * integer), bumped whenever the daemon's mesh graph/queue/mission state for that
+     * mesh changes (onMeshStateChange). Lets the dashboard replace its client-side
+     * mesh_status polling with an event-driven background refresh: when the revision
+     * for the mesh it is viewing advances, it re-fetches the aggregate mesh_status
+     * (SWR, keeping the current graph on screen). This is a lightweight nudge — the
+     * full aggregate snapshot is fetched on demand, not embedded here, so the
+     * daemon.metadata payload stays small. Optional/absent for daemons/builds that
+     * don't emit it (the client then keeps its polling fallback).
+     */
+    meshStateRevisions?: Record<string, number>;
 }
 
 export interface TopicUpdateEnvelopeMap {
@@ -365,6 +392,7 @@ export interface SessionEntry {
     runtimeRecoveryState?: string | null;
     resume?: ProviderResumeCapability;
     activeChat: SessionActiveChatData | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     capabilities?: SessionCapability[];
     /** Effective message input/media support for this session. Defaults fail-closed to text-only. */
     messageInput?: MessageInputSupport;
@@ -388,7 +416,25 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    /**
+     * User (or coordinator-policy) muted: suppress attention side-effects
+     * (notifications, toasts, completion audio) for this session WITHOUT removing
+     * it from the inbox list. Distinct from surfaceHidden (which collapses it from
+     * the list). Daemon-owned, in-memory; rides the status snapshot.
+     */
+    muted?: boolean;
     settings?: Record<string, any>;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions). The dashboard attributes the session
+     * to this daemon instead of the snapshot daemon so the worker node — not the
+     * coordinator — is shown as its machine.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
+    /** Set when this session is acting as a mesh coordinator for the given mesh. */
+    coordinator?: { meshId: string; role: 'coordinator' };
     meshQueueStats?: {
         total?: number;
         active?: number;
@@ -449,6 +495,7 @@ export interface CompactSessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    muted?: boolean;
     controlValues?: Record<string, string | number | boolean>;
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;
@@ -516,7 +563,43 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-}
+    /** BRAIN-ROUTING: suggested model values for the new-session model dropdown. */
+    modelOptions?: string[];
+    /** BRAIN-ROUTING: reasoning-effort values for the new-session thinking dropdown. */
+    thinkingLevelOptions?: string[];
+    /**
+     * Provider trust classification — derived from the on-disk layer the
+     * manifest came from and the shape of the manifest. Dashboards use
+     * this to render a trust badge and gate activation of
+     * `external-untrusted` providers behind a confirm modal.
+     */
+    trust?: ProviderTrust;
+    /** Daemon-side human-readable description of the trust value. */
+    trustDescription?: string;
+    /** True when activation needs a user-side confirmation step. */
+    requiresConfirmation?: boolean;
+    /** Which on-disk layer the manifest lives in. */
+    sourceLayer?: 'user' | 'upstream' | 'external';
+    /** For external providers, the source-name namespace it came from. */
+    sourceName?: string | null;
+    /** Manifest-declared version, e.g. "1.2.1". */
+    providerVersion?: string;
+    /** Underlying executable name (CLI/binary providers). */
+    binary?: string;
+    /** Lifecycle label from the manifest: "Stable", "Beta", … */
+    status?: string;
+    /** One-line provider description from the manifest. */
+    details?: string;
+    /** Manifest-declared links: homepage, docs, repo, … */
+    links?: Record<string, string>;
+}
+
+export type ProviderTrust =
+    | 'user-custom'
+    | 'trusted'
+    | 'trusted-with-scripts'
+    | 'external-safe'
+    | 'external-untrusted';
 
 export interface MachineProviderCheckResult {
     ok: boolean;
@@ -582,6 +665,13 @@ export interface ProviderControlSchema {
     order?: number;
     /** Hide this control even if it would otherwise render */
     hidden?: boolean;
+    /**
+     * FSM state ids in which this control should be visible. When omitted the
+     * control is always visible. Mirrors the daemon's click-time enforcement so
+     * the bar hides controls the daemon would silently drop. Uses raw FSM state
+     * ids (e.g. 'idle', 'busy'), not the derived dashboard status.
+     */
+    visibleWhenState?: string[];
 }
 
 // ─── Common Sub-Types (used across StatusReportPayload, BaseDaemonData, etc.) ──
@@ -687,6 +777,9 @@ export type DaemonStatusEventName =
     | 'agent:waiting_approval'
     | 'agent:generating_completed'
     | 'agent:stopped'
+    | 'monitor:no_progress'
+    // Legacy alias for 'monitor:no_progress' — kept so older daemons that still
+    // emit it remain type-compatible with consumers during rollout.
     | 'monitor:long_generating';
 
 /** Minimal daemon-originated event payload relayed through the server. */

package/src/status/builders.ts

@@ -25,6 +25,7 @@ import {
     type NormalizeActiveChatOptions,
 } from './normalize.js';
 import { getMeshQueueStats } from '../mesh/mesh-work-queue.js';
+import { getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { normalizeProviderStateControlValues } from '../providers/provider-patch-state.js';
 import { normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import {
@@ -33,6 +34,47 @@ import {
 } from '../providers/open-panel-support.js';
 import { TEXT_ONLY_MESSAGE_INPUT_SUPPORT } from '../providers/provider-input-support.js';
 
+/**
+ * A coordinator-spawned worker session that mesh policy launched hidden. This is
+ * the daemon-side equivalent of the web `shouldAutoHideMeshConversation` predicate:
+ * these sessions should default to muted+hidden in the user dashboard (the user
+ * interacts through the ONE coordinator session, not each worker), while the
+ * coordinator↔worker mesh data/completion path (mesh-event-forwarding) is
+ * unaffected.
+ */
+function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    return settings.launchedByCoordinator === true
+        && typeof settings.meshNodeFor === 'string'
+        && settings.meshNodeFor.trim().length > 0
+        && settings.spawnedSessionVisibility === 'hidden';
+}
+
+/**
+ * A session is surface-hidden (collapsed from the user's inbox/notifications) when
+ * mesh policy spawned it hidden, OR when a coordinator-spawned worker defaults
+ * hidden, OR when the user manually hid it (userHidden). userHidden === false is an
+ * explicit un-hide that overrides the policy/worker default until daemon restart.
+ */
+function resolveSurfaceHidden(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    if (settings.userHidden === true) return true;
+    if (settings.userHidden === false) return false;
+    return settings.spawnedSessionVisibility === 'hidden' || isCoordinatorSpawnedHiddenWorker(settings);
+}
+
+/**
+ * A session is muted (attention side-effects suppressed, but still shown in the
+ * list) when the user muted it, OR a coordinator-spawned worker defaults muted.
+ * userMuted === false is an explicit un-mute overriding the worker default.
+ */
+function resolveMuted(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    if (settings.userMuted === true) return true;
+    if (settings.userMuted === false) return false;
+    return isCoordinatorSpawnedHiddenWorker(settings);
+}
+
 export type SessionEntryProfile = 'full' | 'live' | 'metadata';
 
 export interface SessionEntryBuildOptions {
@@ -164,7 +206,7 @@ const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
     'set_thought_level',
 ];
 
-function buildIdeWorkspaceSession(
+function buildWorkspaceSession(
     state: IdeProviderState,
     cdpManagers: Map<string, DaemonCdpManager>,
     options: SessionEntryBuildOptions,
@@ -179,7 +221,10 @@ function buildIdeWorkspaceSession(
     const git = getGitSummaryForWorkspace(workspace, options);
     const title = activeChat?.title || state.name;
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId || state.type,
         parentId: null,
@@ -203,6 +248,7 @@ function buildIdeWorkspaceSession(
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -221,7 +267,10 @@ function buildExtensionAgentSession(
     const workspace = parent.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = ext.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = ext.instanceId ? getCoordinatorForSession(ext.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
@@ -245,6 +294,7 @@ function buildExtensionAgentSession(
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
         settings: ext.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -287,7 +337,10 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -314,6 +367,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         mode: state.mode,
         resume: state.resume,
         activeChat,
+        activeInteractivePrompt: state.activeInteractivePrompt ?? null,
         ...(summaryMetadata && { summaryMetadata }),
         ...(includeSessionMetadata && {
             capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
@@ -327,7 +381,10 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
+        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
+        ...(resolveMuted(state.settings) && { muted: true }),
     };
 }
 
@@ -341,7 +398,10 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -364,7 +424,10 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
+        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
+        ...(resolveMuted(state.settings) && { muted: true }),
     };
 }
 
@@ -380,7 +443,7 @@ export function buildSessionEntries(
     const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
 
     for (const state of ideStates) {
-        sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
+        sessions.push(buildWorkspaceSession(state, cdpManagers, options));
         for (const ext of state.extensions as ExtensionProviderState[]) {
             if (!shouldIncludeExtensionSession(ext)) continue;
             sessions.push(buildExtensionAgentSession(state, ext, options));

package/src/status/chat-tail-hot-sessions.ts

@@ -60,8 +60,35 @@ export function classifyHotChatSessionsForSubscriptionFlush(
     recentMessageGraceMs?: number;
     activeStatuses?: ReadonlySet<string>;
     activeSessionIds?: ReadonlySet<string>;
+    /**
+     * Per-session `lastMessageAt` of the most recent completion tail that has
+     * already been flushed to subscribers. A completed-but-unseen session is
+     * kept hot for delivery REGARDLESS of the 8s recency timer, but only until
+     * its current tail has been delivered once — bounding the guaranteed
+     * delivery so a slow-finalizing turn is not re-pushed every tick forever.
+     * A newer `lastMessageAt` (fresh turn) re-arms delivery.
+     */
+    deliveredCompletionTailAt?: ReadonlyMap<string, number>;
+    /**
+     * (D8) PER-SUBSCRIPTION ACK gate — the authoritative guaranteed-delivery
+     * signal. Session ids for which at least one currently-subscribed ws has
+     * NOT yet been sent the session's finalized tail (its per-ws
+     * `lastDeliveredSignature` is empty / does not match the session's current
+     * tail). The daemon computes this from its live ws-subscription map; the
+     * classifier keeps every such session hot-for-delivery INDEPENDENT of the
+     * seen/unread badge, so a session whose unread badge cleared (or a fresh
+     * browser that re-subscribed after the single completion flush already
+     * fired) still gets its assistant-final tail delivered. Bounded because a
+     * subscriber's `lastDeliveredSignature` converges to the current tail the
+     * moment it is actually sent, dropping the session out of this set. When
+     * provided, this set is the guaranteed-delivery driver and the
+     * `deliveredCompletionTailAt` recency-watermark path is bypassed for these
+     * sessions (it stays only as the legacy opt-in for callers that don't pass
+     * a per-subscription set).
+     */
+    underDeliveredSessionIds?: ReadonlySet<string>;
   } = {},
-): { active: Set<string>; finalizing: Set<string> } {
+): { active: Set<string>; finalizing: Set<string>; guaranteedDelivery: Set<string> } {
   const now = options.now ?? Date.now();
   const recentMessageGraceMs = Math.max(
     0,
@@ -71,8 +98,19 @@ export function classifyHotChatSessionsForSubscriptionFlush(
   );
   const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
   const activeSessionIds = options.activeSessionIds ?? new Set<string>();
+  // The guaranteed-delivery path is opt-in: only callers that provide a
+  // delivered-watermark map (so they can BOUND re-pushes) participate. Callers
+  // without it keep the original recency-window-only behavior and never enter
+  // the completed-but-unseen keep-hot branch (which would otherwise thrash by
+  // re-pushing every tick with no delivered record to stop it).
+  const deliveredCompletionTailAt = options.deliveredCompletionTailAt ?? null;
+  const underDeliveredSessionIds = options.underDeliveredSessionIds ?? null;
   const active = new Set<string>();
   const excluded = new Set<string>();
+  // Sessions kept hot purely because they finalized late (outside the 8s
+  // window) and have not been delivered yet. The caller records these so the
+  // next classification knows their tail is now delivered.
+  const guaranteedDelivery = new Set<string>();
 
   for (const session of sessions) {
     const sessionId = typeof session?.id === 'string' ? session.id : '';
@@ -104,6 +142,49 @@ export function classifyHotChatSessionsForSubscriptionFlush(
 
     if (activeStatuses.has(status) || shouldKeepRecentTailHot) {
       active.add(sessionId);
+      continue;
+    }
+
+    // (D8) PER-SUBSCRIPTION ACK-BASED guaranteed delivery — the authoritative
+    // path. If ANY currently-subscribed ws for this session still lacks the
+    // finalized tail (empty / mismatched per-ws lastDeliveredSignature), keep
+    // the session hot-for-delivery REGARDLESS of the seen/unread badge. This is
+    // the fix for the agy coordinator stranded user-only: the single completion
+    // flush was marked "delivered" on FLUSH-FIRE (not browser-APPLIED), and
+    // re-delivery was gated on completedUnseen — so once the unread badge
+    // cleared, a subscriber that never actually applied the assistant tail (D6
+    // shrink-defer drop, or a fresh browser that re-subscribed after the flush
+    // instant) was permanently dropped and stayed user-only forever. Gating on
+    // "does a live subscriber still lack the tail" instead of the badge makes it
+    // re-arm for exactly those subscribers, and it self-bounds: the moment a
+    // subscriber is actually sent the tail its signature matches and it leaves
+    // this set (a same-tail re-flush is a cheap no-op via prepareSessionChatTailUpdate).
+    if (underDeliveredSessionIds && underDeliveredSessionIds.has(sessionId)) {
+      active.add(sessionId);
+      guaranteedDelivery.add(sessionId);
+      continue;
+    }
+
+    // Legacy recency-watermark guaranteed-delivery path (opt-in via
+    // deliveredCompletionTailAt): a completed-but-unseen session whose native
+    // tail finalized AFTER the 8s window (common for multi-turn MAGI
+    // coordinators — the native-history tail lags the last PTY echo). Kept for
+    // callers that do not supply a per-subscription ACK set. When the
+    // per-subscription set is provided it is authoritative and this path is not
+    // consulted (the `continue` above already handled under-delivered sessions;
+    // a session NOT in the set is genuinely delivered, so it must not be revived
+    // here on the stale badge alone).
+    const completedUnseen = unread || inboxBucket === 'task_complete';
+    if (!underDeliveredSessionIds && deliveredCompletionTailAt && completedUnseen) {
+      const delivered = deliveredCompletionTailAt.get(sessionId) ?? 0;
+      // Not yet delivered for this turn (no record, or a newer tail arrived
+      // since the last delivery). lastMessageAt===0 (unknown ts) still counts
+      // as undelivered so the tail is not silently dropped.
+      const alreadyDelivered = delivered > 0 && lastMessageAt > 0 && delivered >= lastMessageAt;
+      if (!alreadyDelivered) {
+        active.add(sessionId);
+        guaranteedDelivery.add(sessionId);
+      }
     }
   }
 
@@ -111,5 +192,39 @@ export function classifyHotChatSessionsForSubscriptionFlush(
     Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId) && !excluded.has(sessionId)),
   );
 
-  return { active, finalizing };
+  return { active, finalizing, guaranteedDelivery };
+}
+
+/**
+ * Detect sessions that just transitioned from an active/generating state into
+ * a settled/completed-but-unseen state, so their finalized completion tail can
+ * be flushed exactly once regardless of the recency window. Pure: the caller
+ * owns the `previousStatus` map and updates it from the returned `nextStatus`.
+ */
+export function detectNewlySettledCompletedSessions(
+  sessions: HotChatSessionLike[],
+  previousStatus: ReadonlyMap<string, string>,
+  options: { activeStatuses?: ReadonlySet<string> } = {},
+): { settled: Set<string>; nextStatus: Map<string, string> } {
+  const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
+  const settled = new Set<string>();
+  const nextStatus = new Map<string, string>();
+
+  for (const session of sessions) {
+    const sessionId = typeof session?.id === 'string' ? session.id : '';
+    if (!sessionId) continue;
+    const status = String(session?.status || '').toLowerCase();
+    const prevStatus = previousStatus.get(sessionId);
+    nextStatus.set(sessionId, status);
+
+    const wasActive = prevStatus !== undefined && activeStatuses.has(prevStatus);
+    const isSettledNow = !activeStatuses.has(status);
+    const inboxBucket = String(session?.inboxBucket || '').toLowerCase();
+    const completedUnseen = session?.unread === true || inboxBucket === 'task_complete';
+    if (wasActive && isSettledNow && completedUnseen) {
+      settled.add(sessionId);
+    }
+  }
+
+  return { settled, nextStatus };
 }

package/src/status/normalize.ts

@@ -5,6 +5,7 @@ export type ManagedStatus =
     | 'idle'
     | 'generating'
     | 'waiting_approval'
+    | 'waiting_choice'
     | 'error'
     | 'stopped'
     | 'starting'
@@ -151,6 +152,7 @@ export function normalizeManagedStatus(
 
     const normalized = String(status || 'idle').trim().toLowerCase();
     if (normalized === 'waiting_approval') return 'waiting_approval';
+    if (normalized === 'waiting_choice') return 'waiting_choice';
     if (WORKING_STATUSES.has(normalized)) return 'generating';
     if (normalized === 'error') return 'error';
     if (normalized === 'stopped') return 'stopped';

package/src/status/reporter.ts

@@ -51,6 +51,8 @@ export class DaemonStatusReporter {
     private lastStatusSentAt = 0;
     private statusPendingThrottle = false;
     private lastP2PStatusHash = '';
+    private lastP2PStatusSentAt: number = 0;
+    private p2pDebounceTimer: ReturnType<typeof setTimeout> | null = null;
     private lastServerStatusHash = '';
     private lastStatusSummary = '';
 
@@ -118,7 +120,7 @@ export class DaemonStatusReporter {
             case 'agent:waiting_approval':
             case 'agent:generating_completed':
             case 'agent:stopped':
-            case 'monitor:long_generating':
+            case 'monitor:no_progress':
                 return value;
             default:
                 return null;
@@ -317,6 +319,9 @@ export class DaemonStatusReporter {
                 cdpConnected: session.cdpConnected,
                 summaryMetadata: session.summaryMetadata,
                 settings: session.settings,
+                // Forward surfaceHidden so the server can gate push notifications for
+                // coordinator-hidden sessions (the WS path is the only one the server sees).
+                surfaceHidden: session.surfaceHidden,
             })),
             p2p: payload.p2p,
             timestamp: now,
@@ -355,7 +360,20 @@ export class DaemonStatusReporter {
             : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
+            const now = Date.now();
+            // Rate limit: max 1 per 500ms
+            if (this.lastP2PStatusSentAt && now - this.lastP2PStatusSentAt < 500) {
+                if (!this.p2pDebounceTimer) {
+                    this.p2pDebounceTimer = setTimeout(() => {
+                        this.p2pDebounceTimer = null;
+                        this.sendUnifiedStatusReport({ reason: 'p2p_debounce' });
+                    }, 500);
+                }
+                return false; // Dropped for now, but will trigger later
+            }
+            
             this.lastP2PStatusHash = h;
+            this.lastP2PStatusSentAt = now;
             this.deps.p2p?.sendStatus(payload);
             return true;
         }