@adhdev/daemon-core 1.0.8 → 1.0.10-rc.1

package/dist/mesh/mesh-events-pending.d.ts

@@ -122,6 +122,8 @@ export declare function getMeshV2DrainCounters(): Readonly<typeof meshV2DrainCou
 export declare function __resetMeshV2DrainCountersForTests(): void;
 /** Test helper: clear the one-shot WARN dedup set. */
 export declare function __resetMeshV2WarnDedupForTests(): void;
+/** Test helper: reset the one-shot SQLite-drain-failure WARN guard. */
+export declare function __resetSqlitePendingDrainWarnForTests(): void;
 export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;
 } | Record<string, unknown>): string;

package/dist/repo-mesh-types.d.ts

@@ -304,6 +304,27 @@ export interface RepoMeshPolicy {
      * Set to false to suppress the reminder entirely.
      */
     idleActiveMissionReminder?: boolean;
+    /**
+     * Whether a coordinator-dispatched worker's routine idle/completion push
+     * notification is delivered to the owner every time ('always', the default —
+     * historical behavior, byte-for-byte unchanged), or auto-silenced for the single
+     * completion that follows a coordinator dispatch ('auto_silent_on_dispatch').
+     *
+     * When 'auto_silent_on_dispatch', dispatching a task to a worker arms a ONE-SHOT
+     * transient mute (settings.silentNextIdlePush) on that worker session. The next
+     * agent:generating_completed rides a muted status snapshot, so the server push
+     * gate (which already honors session.muted) suppresses ONLY that routine
+     * completion push; the flag auto-clears afterward so subsequent turns notify
+     * normally, and it is status-gated to `idle` so an approval-needed / long-running
+     * / failure notification in the SAME turn is NEVER suppressed. A stale one-shot
+     * self-expires (SILENT_IDLE_PUSH_TTL_MS) so a worker that never completes cannot
+     * strand its session permanently muted.
+     *
+     * Coordinator-spawned HIDDEN workers already default muted (they emit no owner
+     * push), so this only changes behavior for VISIBLE / manually-unmuted delegated
+     * workers. Defaults to 'always' — zero behavior change unless the mesh opts in.
+     */
+    coordinatorIdlePushPolicy?: 'always' | 'auto_silent_on_dispatch';
 }
 export interface RepoMeshRelatedRepo {
     /** Stable display label for an explicitly configured associated checkout. */
@@ -413,6 +434,21 @@ export interface RepoMeshNodePolicy {
     initSubmodulesOnClone?: boolean;
 }
 export declare const DEFAULT_MESH_POLICY: RepoMeshPolicy;
+/**
+ * TTL for the one-shot silent-idle-push arm (settings.silentNextIdlePushArmedAt).
+ * A dispatched worker whose completion never arrives (crash, offline, dropped event)
+ * must not leave its session muted forever — after this window the arm is treated as
+ * expired and stops muting, so the session self-heals to normal notification behavior.
+ * Ten minutes comfortably covers a long delegated turn while still bounding the leak.
+ */
+export declare const SILENT_IDLE_PUSH_TTL_MS: number;
+/**
+ * Resolve the effective coordinator idle-push policy from a mesh policy, defaulting
+ * to 'always' (notify) for a missing/invalid value so a typo can never silently
+ * disable owner completion notifications. Mirrors the other policy resolvers so the
+ * arm site and any future consumer read one source of truth.
+ */
+export declare function resolveCoordinatorIdlePushPolicy(meshPolicy?: Pick<RepoMeshPolicy, 'coordinatorIdlePushPolicy'> | null): 'always' | 'auto_silent_on_dispatch';
 /**
  * Resolve a magiSessionCleanup policy value (string mode, boolean shorthand,
  * or unset) to a canonical mode. Unset → the default ('stop_and_delete', ON).

package/dist/status/builders.d.ts

@@ -29,10 +29,19 @@ export declare function isCoordinatorSpawnedHiddenWorker(settings: Record<string
 export declare function resolveSurfaceHidden(settings: Record<string, any> | undefined): boolean;
 /**
  * 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.
+ * list) when the user muted it, OR a coordinator-spawned worker defaults muted, OR
+ * a one-shot silent-idle-push arm is active for this completion snapshot (see
+ * isSilentIdlePushArmActive — status-gated + TTL-bounded so approval/failure pushes
+ * and never-completing workers are unaffected). userMuted === false is an explicit
+ * un-mute overriding the worker/policy default — but NOT the one-shot arm, which is a
+ * coordinator-driven per-completion decision that a stale manual un-mute must not
+ * defeat.
+ *
+ * `status` is the session's resolved status for the snapshot being built; omit it
+ * (undefined) for callers that only have mesh-attribution fields (the cloud mirror),
+ * where the one-shot never applies.
  */
-export declare function resolveMuted(settings: Record<string, any> | undefined): boolean;
+export declare function resolveMuted(settings: Record<string, any> | undefined, status?: string): boolean;
 /**
  * Pure resolver for a mesh-spawned worker session's dashboard hide+mute state,
  * shared by the standalone/local `buildSessionEntries` path (via the wrappers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.8",
+  "version": "1.0.10-rc.1",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "*",
-    "@adhdev/session-host-core": "*",
+    "@adhdev/mesh-shared": "1.0.10-rc.1",
+    "@adhdev/session-host-core": "1.0.10-rc.1",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/cli-manager.ts

@@ -1739,6 +1739,26 @@ export class DaemonCliManager {
                         if (stampResult && stampResult.stamped === false && stampResult.reason === 'task_already_stamped_on_live_instance') {
                             throw new Error(`Refusing duplicate mesh dispatch: task ${meshContext.taskId} is already being worked by a live session on this daemon`);
                         }
+                        // COORDINATOR-SILENT-IDLE (opt-in): the coordinator's mesh policy is
+                        // 'auto_silent_on_dispatch', so arm a ONE-SHOT transient mute on THIS
+                        // worker session for the single completion that follows this dispatch.
+                        // resolveMuted honors it only for an idle snapshot within
+                        // SILENT_IDLE_PUSH_TTL_MS, so the routine completion push is suppressed
+                        // while approval/failure/long-running notifications (non-idle status) and
+                        // a worker that never completes (TTL expiry) are unaffected. Re-armed on
+                        // every dispatch (fresh armedAt) and one-shot-cleared at the completion
+                        // emission (emitGeneratingCompleted) so subsequent turns notify normally.
+                        if ((meshContext as any).silentIdlePush === true) {
+                            try {
+                                const workerInst = this.deps.getInstanceManager()?.getInstance(targetInstanceId);
+                                if (workerInst && typeof workerInst.updateSettings === 'function') {
+                                    workerInst.updateSettings({
+                                        silentNextIdlePush: true,
+                                        silentNextIdlePushArmedAt: Date.now(),
+                                    });
+                                }
+                            } catch { /* best-effort — silent-idle is a notification nicety, never fail the dispatch */ }
+                        }
                     }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);

package/src/mesh/coordinator-prompt.ts

@@ -724,6 +724,10 @@ function buildPolicySection(policy: RepoMeshPolicy): string {
 
     rules.push(`- Maximum **${policy.maxParallelTasks}** tasks running in parallel`);
 
+    if (policy.coordinatorIdlePushPolicy === 'auto_silent_on_dispatch') {
+        rules.push('- Delegated-worker completions are **auto-silenced**: the routine idle/completion push for a task you dispatch is suppressed once (approval-needed, failure, and long-running alerts still notify the owner normally)');
+    }
+
     return `## Policy\n${rules.join('\n')}`;
 }
 

package/src/mesh/mesh-events-pending.ts

@@ -272,6 +272,22 @@ export function __resetMeshV2WarnDedupForTests(): void {
     warnedV2Violations.clear();
 }
 
+// Log-once guard for the SQLite pending-event drain failure. When better-sqlite3 is
+// unavailable (native load failure on a clean npx install with no build tools), the
+// SQLite drain throws every drain call — once per mesh, every reconcile tick (~4s) —
+// while the JSONL fallback below keeps delivering events correctly. That is the
+// intended degraded path, so the operator only needs to be told ONCE that SQLite is
+// down; repeating the WARN every cycle floods the logs (mirrors MeshRuntimeStore's
+// loggedGetInstanceFailure guard). New/different drain errors still surface: the
+// guard keys on nothing beyond "already warned", but the first occurrence is always
+// shown at WARN and every occurrence stays at debug.
+let loggedSqlitePendingDrainFailure = false;
+
+/** Test helper: reset the one-shot SQLite-drain-failure WARN guard. */
+export function __resetSqlitePendingDrainWarnForTests(): void {
+    loggedSqlitePendingDrainFailure = false;
+}
+
 /**
  * Resolve the drainer's CoordinatorIdentity for v2 routing from the daemon-id
  * argument the (untouchable) reconcile-loop already passes. The daemon ids are the
@@ -1216,7 +1232,16 @@ export function drainPendingMeshCoordinatorEvents(
         // failure here means the JSONL copy is emptied while the SQLite rows
         // survive undrained, so the next drain re-delivers the same events to the
         // coordinator (duplicate refine:completed etc.) with no diagnostic trail.
-        LOG.warn('MeshEvents', `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
+        // Log-once (then debug): when better-sqlite3 is unavailable this throws every
+        // tick × mesh count, and the JSONL fallback below is the intended degraded
+        // path — so warn ONCE, then keep the per-cycle repetition at debug to stop the
+        // log flood without hiding the diagnosis (see loggedSqlitePendingDrainFailure).
+        if (!loggedSqlitePendingDrainFailure) {
+            loggedSqlitePendingDrainFailure = true;
+            LOG.warn('MeshEvents', `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only (further occurrences at debug): ${e?.message || e}`);
+        } else {
+            LOG.debug('MeshEvents', `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
+        }
     }
 
     // JSONL (legacy / migration path) — always drained alongside SQLite.

package/src/mesh/mesh-queue-assignment.ts

@@ -13,7 +13,7 @@ import { createSessionDelivery, updateSessionDeliveryStatus } from './mesh-deliv
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
-import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks } from '../repo-mesh-types.js';
+import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks, resolveCoordinatorIdlePushPolicy } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, expandDaemonIdForms, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, normalizeNodeCapabilitySlots, isMeshTaskDifficulty, withStatusProbeMarker, type MeshNodeIdentified, type NodeCapabilitySlot, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
 import { resolveNodeCapabilitySlots } from './mesh-node-slots.js';
@@ -612,6 +612,17 @@ export function tryAssignQueueTask(
     // failure / cancel / reclaim).
     beginTaskDispatchInFlight(meshId, task.id);
 
+    // COORDINATOR-SILENT-IDLE (opt-in): when the mesh policy is
+    // 'auto_silent_on_dispatch', carry a one-shot silent-idle-push signal in the
+    // dispatch meshContext. The worker stamps settings.silentNextIdlePush on its own
+    // live session (cli-manager send_chat), so the SINGLE completion that follows this
+    // dispatch rides a muted status snapshot and the server suppresses ONLY that
+    // routine idle push. Status-gated + TTL-bounded downstream (see resolveMuted), so
+    // approval/failure/long-running notifications and never-completing workers are
+    // unaffected. Default 'always' → this stays undefined and nothing changes.
+    const silentIdlePushOnDispatch =
+        resolveCoordinatorIdlePushPolicy(mesh?.policy) === 'auto_silent_on_dispatch';
+
     // CANON-IDENTITY: read the remote daemon id through the normalizing helper so a node
     // whose daemonId arrives in a non-top-level-camelCase serialization form (daemon_id /
     // machine.daemonId / lastProbe.machine.daemon_id / …) is still recognized as remote.
@@ -648,6 +659,7 @@ export function tryAssignQueueTask(
                         ...(typeof task.dispatchNonce === 'number' ? { dispatchNonce: task.dispatchNonce } : {}),
                         ...(localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}),
                         ...(sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}),
+                        ...(silentIdlePushOnDispatch ? { silentIdlePush: true } : {}),
                     },
                 }),
                 {
@@ -730,6 +742,7 @@ export function tryAssignQueueTask(
                 ...(typeof task.dispatchNonce === 'number' ? { dispatchNonce: task.dispatchNonce } : {}),
                 ...(localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {}),
                 ...(readNonEmptyString(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {}),
+                ...(silentIdlePushOnDispatch ? { silentIdlePush: true } : {}),
             },
         }),
         {

package/src/mesh/mesh-reconcile-loop.ts

@@ -1277,18 +1277,25 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
     // indexed status column, so an idle mesh costs one cheap query per tick.
     // claimNextQueueTask is atomic, so racing the event-driven path can only have
     // one winner; double-claiming is impossible.
-    for (const mesh of listMeshes()) {
-        const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
-        if (!daemonHostsMesh(mesh, selfIds)) continue;
-        if (store) {
+    // The mesh work-queue is SQLite-only (claimNextQueueTask/countQueueStatus all go
+    // through MeshRuntimeStore — there is no JSONL fallback for the QUEUE, only for
+    // pending EVENTS drained in PHASE 1/2). So when SQLite is unavailable (store
+    // undefined, e.g. better-sqlite3 native load failure on a clean install),
+    // triggerMeshQueue can do no useful work — it would only re-throw inside the
+    // store and emit the WARN below every tick × mesh count, flooding the logs. Skip
+    // the phase entirely in that case; the JSONL event-delivery path is unaffected.
+    if (store) {
+        for (const mesh of listMeshes()) {
+            const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+            if (!daemonHostsMesh(mesh, selfIds)) continue;
             try {
                 if (store.pendingQueueTaskCount(mesh.id) === 0) continue;
             } catch { /* fall through and let triggerMeshQueue decide */ }
-        }
-        try {
-            await triggerMeshQueue(components, mesh.id);
-        } catch (e: any) {
-            LOG.warn('MeshReconcile', `Pending-claim recovery trigger failed for mesh ${mesh.id}: ${e?.message || e}`);
+            try {
+                await triggerMeshQueue(components, mesh.id);
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Pending-claim recovery trigger failed for mesh ${mesh.id}: ${e?.message || e}`);
+            }
         }
     }
 

package/src/providers/cli-provider-instance.ts

@@ -2881,6 +2881,15 @@ export class CliProviderInstance implements ProviderInstance {
             ...(opts.evidenceLevel !== undefined ? { evidenceLevel: opts.evidenceLevel } : {}),
             ...(opts.completionDiagnostic !== undefined ? { completionDiagnostic: opts.completionDiagnostic } : {}),
         });
+        // COORDINATOR-SILENT-IDLE one-shot consume: this completion's snapshot rides the
+        // armed mute (resolveMuted honors settings.silentNextIdlePush for the idle status
+        // above), so the routine idle push is suppressed for THIS completion only. Clear
+        // the arm now — AFTER the completion event was pushed — so the NEXT turn notifies
+        // normally. Redundant with the TTL leak-guard, but the deterministic clear is the
+        // primary one-shot mechanism; the TTL only covers a worker that never completes.
+        if (this.settings?.silentNextIdlePush === true) {
+            this.updateSettings({ silentNextIdlePush: undefined, silentNextIdlePushArmedAt: undefined });
+        }
     }
 
     /**

package/src/repo-mesh-types.ts

@@ -399,6 +399,27 @@ export interface RepoMeshPolicy {
      * Set to false to suppress the reminder entirely.
      */
     idleActiveMissionReminder?: boolean;
+    /**
+     * Whether a coordinator-dispatched worker's routine idle/completion push
+     * notification is delivered to the owner every time ('always', the default —
+     * historical behavior, byte-for-byte unchanged), or auto-silenced for the single
+     * completion that follows a coordinator dispatch ('auto_silent_on_dispatch').
+     *
+     * When 'auto_silent_on_dispatch', dispatching a task to a worker arms a ONE-SHOT
+     * transient mute (settings.silentNextIdlePush) on that worker session. The next
+     * agent:generating_completed rides a muted status snapshot, so the server push
+     * gate (which already honors session.muted) suppresses ONLY that routine
+     * completion push; the flag auto-clears afterward so subsequent turns notify
+     * normally, and it is status-gated to `idle` so an approval-needed / long-running
+     * / failure notification in the SAME turn is NEVER suppressed. A stale one-shot
+     * self-expires (SILENT_IDLE_PUSH_TTL_MS) so a worker that never completes cannot
+     * strand its session permanently muted.
+     *
+     * Coordinator-spawned HIDDEN workers already default muted (they emit no owner
+     * push), so this only changes behavior for VISIBLE / manually-unmuted delegated
+     * workers. Defaults to 'always' — zero behavior change unless the mesh opts in.
+     */
+    coordinatorIdlePushPolicy?: 'always' | 'auto_silent_on_dispatch';
 }
 
 export interface RepoMeshRelatedRepo {
@@ -540,8 +561,36 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     // Nudge the coordinator when the mesh is fully idle but active missions linger,
     // so a mission is never left drifting in `active` after its work is really done.
     idleActiveMissionReminder: true,
+    // Conservative default: every coordinator-dispatched worker completion still
+    // notifies the owner. Opt into 'auto_silent_on_dispatch' to one-shot-silence the
+    // routine idle push for a coordinator-driven task (approval/failure notifications
+    // are never affected — see coordinatorIdlePushPolicy).
+    coordinatorIdlePushPolicy: 'always',
 };
 
+/**
+ * TTL for the one-shot silent-idle-push arm (settings.silentNextIdlePushArmedAt).
+ * A dispatched worker whose completion never arrives (crash, offline, dropped event)
+ * must not leave its session muted forever — after this window the arm is treated as
+ * expired and stops muting, so the session self-heals to normal notification behavior.
+ * Ten minutes comfortably covers a long delegated turn while still bounding the leak.
+ */
+export const SILENT_IDLE_PUSH_TTL_MS = 10 * 60 * 1000;
+
+/**
+ * Resolve the effective coordinator idle-push policy from a mesh policy, defaulting
+ * to 'always' (notify) for a missing/invalid value so a typo can never silently
+ * disable owner completion notifications. Mirrors the other policy resolvers so the
+ * arm site and any future consumer read one source of truth.
+ */
+export function resolveCoordinatorIdlePushPolicy(
+    meshPolicy?: Pick<RepoMeshPolicy, 'coordinatorIdlePushPolicy'> | null,
+): 'always' | 'auto_silent_on_dispatch' {
+    return meshPolicy?.coordinatorIdlePushPolicy === 'auto_silent_on_dispatch'
+        ? 'auto_silent_on_dispatch'
+        : 'always';
+}
+
 // ─── Policy normalization (single source of truth) ──────────────────────────
 //
 // Every mesh policy passes through mergeAndNormalizePolicy exactly once on write
@@ -727,6 +776,15 @@ export function mergeAndNormalizePolicy(
     } else {
         delete policy.autoConvergeCodeChange;
     }
+    // Coordinator idle-push policy: strict opt-in. Only persist the explicit
+    // 'auto_silent_on_dispatch' value; any other/invalid value normalizes to the
+    // 'always' default and is dropped so existing meshes.json stays byte-for-byte
+    // untouched (a typo cannot silently disable owner completion notifications).
+    if (policy.coordinatorIdlePushPolicy === 'auto_silent_on_dispatch') {
+        policy.coordinatorIdlePushPolicy = 'auto_silent_on_dispatch';
+    } else {
+        delete policy.coordinatorIdlePushPolicy;
+    }
     return policy;
 }
 

package/src/status/builders.ts

@@ -25,6 +25,7 @@ import {
     type NormalizeActiveChatOptions,
 } from './normalize.js';
 import { getMeshQueueStats } from '../mesh/mesh-work-queue.js';
+import { SILENT_IDLE_PUSH_TTL_MS } from '../repo-mesh-types.js';
 import { getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { normalizeProviderStateControlValues } from '../providers/provider-patch-state.js';
 import { normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
@@ -63,13 +64,51 @@ export function resolveSurfaceHidden(settings: Record<string, any> | undefined):
     return settings.spawnedSessionVisibility === 'hidden' || isCoordinatorSpawnedHiddenWorker(settings);
 }
 
+/**
+ * Whether a one-shot silent-idle-push arm is currently ACTIVE for this session's
+ * completion snapshot. Set on a coordinator-dispatched worker when the mesh policy
+ * is `coordinatorIdlePushPolicy: 'auto_silent_on_dispatch'` (see arm sites in
+ * mesh-queue-assignment). Guardrails baked in here:
+ *  - status-gated to `idle`: the arm mutes ONLY the routine completion snapshot, so
+ *    an approval-needed / failure / long-running notification in the SAME turn (which
+ *    the worker emits with a non-idle status) is NEVER suppressed.
+ *  - TTL leak-guard: an arm older than SILENT_IDLE_PUSH_TTL_MS is treated as expired,
+ *    so a worker whose completion never arrives cannot strand its session muted.
+ * The arm itself is one-shot: emitGeneratingCompleted clears it after the completion
+ * so the following turn notifies normally.
+ */
+function isSilentIdlePushArmActive(
+    settings: Record<string, any> | undefined,
+    status: string | undefined,
+): boolean {
+    if (!settings || settings.silentNextIdlePush !== true) return false;
+    if (status !== 'idle') return false;
+    const armedAt = Number(settings.silentNextIdlePushArmedAt);
+    if (!Number.isFinite(armedAt) || armedAt <= 0) {
+        // No/invalid arm timestamp: honor the flag (fail-safe toward the explicit
+        // arm) but it will be one-shot-cleared at the completion emission.
+        return true;
+    }
+    return (Date.now() - armedAt) <= SILENT_IDLE_PUSH_TTL_MS;
+}
+
 /**
  * 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.
+ * list) when the user muted it, OR a coordinator-spawned worker defaults muted, OR
+ * a one-shot silent-idle-push arm is active for this completion snapshot (see
+ * isSilentIdlePushArmActive — status-gated + TTL-bounded so approval/failure pushes
+ * and never-completing workers are unaffected). userMuted === false is an explicit
+ * un-mute overriding the worker/policy default — but NOT the one-shot arm, which is a
+ * coordinator-driven per-completion decision that a stale manual un-mute must not
+ * defeat.
+ *
+ * `status` is the session's resolved status for the snapshot being built; omit it
+ * (undefined) for callers that only have mesh-attribution fields (the cloud mirror),
+ * where the one-shot never applies.
  */
-export function resolveMuted(settings: Record<string, any> | undefined): boolean {
+export function resolveMuted(settings: Record<string, any> | undefined, status?: string): boolean {
     if (!settings) return false;
+    if (isSilentIdlePushArmActive(settings, status)) return true;
     if (settings.userMuted === true) return true;
     if (settings.userMuted === false) return false;
     return isCoordinatorSpawnedHiddenWorker(settings);
@@ -365,6 +404,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
     const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
     const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
     const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
+    const resolvedStatus = resolveSessionStatus(activeChat, state.status);
     return {
         id: state.instanceId,
         parentId: null,
@@ -373,7 +413,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         providerSessionId: state.providerSessionId,
         kind: 'agent',
         transport: 'pty',
-        status: resolveSessionStatus(activeChat, state.status),
+        status: resolvedStatus,
         title: activeChat?.title || state.name,
         workspace,
         ...(git && { git }),
@@ -412,7 +452,9 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         // `!== undefined` fields, so an absent field on false never overwrote a prior true —
         // the toggle-off direction silently stuck. See session-entry-merge.ts.
         surfaceHidden: resolveSurfaceHidden(state.settings),
-        muted: resolveMuted(state.settings),
+        // status-gated so a one-shot silent-idle arm mutes ONLY the idle/completion
+        // snapshot, never an approval/generating frame in the same turn.
+        muted: resolveMuted(state.settings, resolvedStatus),
     };
 }
 
@@ -430,6 +472,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
     const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
     const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
     const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
+    const resolvedStatus = resolveSessionStatus(activeChat, state.status);
     return {
         id: state.instanceId,
         parentId: null,
@@ -437,7 +480,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         providerName: state.name,
         kind: 'agent',
         transport: 'acp',
-        status: resolveSessionStatus(activeChat, state.status),
+        status: resolvedStatus,
         title: activeChat?.title || state.name,
         workspace,
         ...(git && { git }),
@@ -457,7 +500,8 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         // Emit explicitly (including false) so un-hide/un-mute clears a prior true downstream —
         // see buildCliSession above and session-entry-merge.ts.
         surfaceHidden: resolveSurfaceHidden(state.settings),
-        muted: resolveMuted(state.settings),
+        // status-gated one-shot silent-idle arm — see buildCliSession above.
+        muted: resolveMuted(state.settings, resolvedStatus),
     };
 }