@adhdev/daemon-core 0.9.82-rc.541 → 0.9.82-rc.543

package/dist/status/builders.d.ts

@@ -11,6 +11,49 @@ import type { DaemonCdpManager } from '../cdp/manager.js';
 import type { GitCompactSummary } from '../git/git-types.js';
 import type { SessionEntry } from '../shared-types.js';
 import type { ProviderState } from '../providers/provider-instance.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.
+ */
+export declare function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefined): boolean;
+/**
+ * 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.
+ */
+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.
+ */
+export declare function resolveMuted(settings: Record<string, any> | undefined): boolean;
+/**
+ * Pure resolver for a mesh-spawned worker session's dashboard hide+mute state,
+ * shared by the standalone/local `buildSessionEntries` path (via the wrappers
+ * above, which read the values off a full settings object) AND the cloud daemon's
+ * synthetic remote-mesh-session mirror path in daemon-cloud
+ * (`appendMeshOwnedSessionsToSnapshot`), which has no full ProviderState — only
+ * the mesh attribution fields. Keeping both paths on this ONE helper guarantees a
+ * remote worker surfaced on the cloud dashboard hides+mutes identically to a local
+ * worker on standalone. A valid `userHidden`/`userMuted` boolean is an explicit
+ * per-session override and wins over the policy/worker default.
+ */
+export declare function resolveSpawnedSessionHideMute(input: {
+    launchedByCoordinator?: unknown;
+    meshNodeFor?: unknown;
+    spawnedSessionVisibility?: unknown;
+    userHidden?: unknown;
+    userMuted?: unknown;
+}): {
+    surfaceHidden: boolean;
+    muted: boolean;
+};
 export type SessionEntryProfile = 'full' | 'live' | 'metadata';
 export interface SessionEntryBuildOptions {
     profile?: SessionEntryProfile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.541",
+  "version": "0.9.82-rc.543",
   "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": "0.9.82-rc.541",
-    "@adhdev/session-host-core": "0.9.82-rc.541",
+    "@adhdev/mesh-shared": "0.9.82-rc.543",
+    "@adhdev/session-host-core": "0.9.82-rc.543",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/router.ts

@@ -34,7 +34,7 @@ import { buildMeshHostRequiredFailure, resolveMeshHostStatus } from '../mesh/mes
 import { analyzeMeshRefineNodeChangeArea, orderMeshRefineBatchNodes } from '../mesh/mesh-refine-batch.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
-import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+import type { RepoMeshSessionCleanupMode, RepoMeshSpawnedSessionVisibility } from '../repo-mesh-types.js';
 import { DEFAULT_MESH_POLICY, magiAutoLaunchedSessionCleanupDecision } from '../repo-mesh-types.js';
 import { resolve as pathResolve } from 'path';
 import * as fs from 'fs';
@@ -362,6 +362,30 @@ export class DaemonCommandRouter {
         return nodes;
     }
 
+    /**
+     * Same flattened node list as getCachedInlineMeshNodes(), but each node is
+     * paired with the `spawnedSessionVisibility` from its OWNING mesh's policy.
+     * The flat node list loses the mesh→node association, yet the cloud daemon's
+     * synthetic mesh-session mirror needs the mesh-level visibility policy to
+     * decide whether a coordinator-spawned worker session should be hidden+muted
+     * on the dashboard (the cached inline-mesh session entry carries no settings
+     * of its own). Falls back to DEFAULT_MESH_POLICY.spawnedSessionVisibility when
+     * the mesh policy is absent, matching the worker-launch stamp.
+     */
+    public getCachedInlineMeshNodesWithVisibility(): Array<{ node: any; spawnedSessionVisibility: RepoMeshSpawnedSessionVisibility }> {
+        const out: Array<{ node: any; spawnedSessionVisibility: RepoMeshSpawnedSessionVisibility }> = [];
+        for (const mesh of this.inlineMeshCache.values()) {
+            const spawnedSessionVisibility: RepoMeshSpawnedSessionVisibility =
+                mesh?.policy?.spawnedSessionVisibility === 'visible' ? 'visible' : 'hidden';
+            if (Array.isArray(mesh?.nodes)) {
+                for (const node of mesh.nodes) {
+                    out.push({ node, spawnedSessionVisibility });
+                }
+            }
+        }
+        return out;
+    }
+
     // ─── Remote mesh-session owner resolution ───────────────────────────
     // Implementation lives in ./router-mesh-session-owner.ts (behavior-preserving
     // code move). resolveRemoteMeshSessionOwnerDaemonId stays public (the [Z]

package/src/index.ts

@@ -384,7 +384,7 @@ export type {
 
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
-export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
+export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected, isCoordinatorSpawnedHiddenWorker, resolveSurfaceHidden, resolveMuted, resolveSpawnedSessionHideMute } from './status/builders.js';
 export { buildStatusSnapshot, buildMachineInfo, buildAvailableProviders, getLastDisplayMessage } from './status/snapshot.js';
 export { getDaemonBuildInfo } from './build-info.js';
 export type { DaemonBuildInfo } from './build-info.js';

package/src/providers/sdk/v1/builders/cli/detect-status.ts

@@ -301,11 +301,19 @@ function modalSupersededBySettledPrompt(
   if (settled.footers.length > 0 && !settled.footers.every((f) => f.test(belowText))) return false;
   // Require a real separator between the leftover box and the composer: a
   // non-blank line that is neither a modal cue NOR part of the settled-prompt
-  // match itself. That separator is the CLI's welcome banner / follow-up hint /
-  // mode footer a stale box shows above the repainted composer. A live modal's
-  // selection cursor sits flush against its buttons with no such prose between
-  // them (and the cursor line, even if it matches the settled regex, is not a
-  // separator), so an active modal is never misread as stale.
+  // match itself (its bare-prompt line OR one of its declared footer lines).
+  // That separator is the CLI's welcome banner / follow-up hint a stale box
+  // shows above the repainted composer. A live modal's selection cursor sits
+  // flush against its buttons with no such prose between them (and neither the
+  // cursor line nor the composer's own footer — e.g. claude's "? for shortcuts"
+  // — is a separator), so an active modal is never misread as stale.
+  //
+  // Footer exclusion is load-bearing: without it, a live approval modal whose
+  // frame also carries the settled composer's footer (question + buttons +
+  // "? for shortcuts" + "❯") gets misread as a stale box — the footer line
+  // counts as fake "separator prose" — and waiting_approval flips to idle, so
+  // the modal is missed and the worker wedges. The footer belongs to the
+  // composer, not to any leftover box.
   const question = compile(modalSpec.questionPattern, modalSpec.questionFlags ?? 'i');
   const variants = (modalSpec.questionVariants ?? []).map((v) => compile(v.regex, v.flags ?? 'i'));
   const buttonFlags = modalSpec.buttonFlags && modalSpec.buttonFlags.includes('m')
@@ -324,7 +332,12 @@ function modalSupersededBySettledPrompt(
   const settledPromptLineRe = compile(settledSpec.regex, (settledSpec.flags ?? 'm').includes('m') ? (settledSpec.flags ?? 'm') : `${settledSpec.flags ?? ''}m`);
   const isSettledLine = (line: string): boolean => {
     settledPromptLineRe.lastIndex = 0;
-    return settledPromptLineRe.test(line);
+    if (settledPromptLineRe.test(line)) return true;
+    // The composer's own declared footer (e.g. claude's "? for shortcuts") is
+    // part of the settled prompt block, not separator prose. Excluding it keeps
+    // a live approval modal that also renders the composer footer from being
+    // misread as a stale box.
+    return settled.footers.some((f) => f.test(line));
   };
   return below.some((line) => line.trim() !== '' && !isModalCueLine(line) && !isSettledLine(line));
 }

package/src/status/builders.ts

@@ -42,7 +42,7 @@ import { TEXT_ONLY_MESSAGE_INPUT_SUPPORT } from '../providers/provider-input-sup
  * coordinator↔worker mesh data/completion path (mesh-event-forwarding) is
  * unaffected.
  */
-function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefined): boolean {
+export function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefined): boolean {
     if (!settings) return false;
     return settings.launchedByCoordinator === true
         && typeof settings.meshNodeFor === 'string'
@@ -56,7 +56,7 @@ function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefi
  * 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 {
+export function resolveSurfaceHidden(settings: Record<string, any> | undefined): boolean {
     if (!settings) return false;
     if (settings.userHidden === true) return true;
     if (settings.userHidden === false) return false;
@@ -68,13 +68,37 @@ function resolveSurfaceHidden(settings: Record<string, any> | undefined): boolea
  * 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 {
+export 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);
 }
 
+/**
+ * Pure resolver for a mesh-spawned worker session's dashboard hide+mute state,
+ * shared by the standalone/local `buildSessionEntries` path (via the wrappers
+ * above, which read the values off a full settings object) AND the cloud daemon's
+ * synthetic remote-mesh-session mirror path in daemon-cloud
+ * (`appendMeshOwnedSessionsToSnapshot`), which has no full ProviderState — only
+ * the mesh attribution fields. Keeping both paths on this ONE helper guarantees a
+ * remote worker surfaced on the cloud dashboard hides+mutes identically to a local
+ * worker on standalone. A valid `userHidden`/`userMuted` boolean is an explicit
+ * per-session override and wins over the policy/worker default.
+ */
+export function resolveSpawnedSessionHideMute(input: {
+    launchedByCoordinator?: unknown;
+    meshNodeFor?: unknown;
+    spawnedSessionVisibility?: unknown;
+    userHidden?: unknown;
+    userMuted?: unknown;
+}): { surfaceHidden: boolean; muted: boolean } {
+    return {
+        surfaceHidden: resolveSurfaceHidden(input as Record<string, any>),
+        muted: resolveMuted(input as Record<string, any>),
+    };
+}
+
 export type SessionEntryProfile = 'full' | 'live' | 'metadata';
 
 export interface SessionEntryBuildOptions {
@@ -383,8 +407,12 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
-        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
-        ...(resolveMuted(state.settings) && { muted: true }),
+        // Emit these booleans explicitly (including false) so an un-hide/un-mute clears a
+        // previously-true value downstream. Consumers merge with `?? existing` and copy only
+        // `!== 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),
     };
 }
 
@@ -426,8 +454,10 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
-        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
-        ...(resolveMuted(state.settings) && { muted: true }),
+        // 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),
     };
 }