@adhdev/daemon-core 0.9.82-rc.348 → 0.9.82-rc.349

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

@@ -49,20 +49,6 @@ export declare function readWorkerResultMetadata(event: Record<string, unknown>)
  * and the held-event ledger audit record so both read the summary the same way.
  */
 export declare function readMeshCompletionSummary(metadataEvent: Record<string, unknown>): string;
-/**
- * A coordinator that surfaces a REMOTE worker's mesh session has no local instance for
- * it, so the status snapshot's getLastDisplayMessage has nothing to read and the only
- * preview the coordinator-mirrored copy could ever carry comes from the worker's
- * completion event. The worker's latest assistant reply rides on that event as
- * `finalSummary` (and as `workerResult.summary` / `result.summary` on some paths).
- *
- * This resolves that assistant text into a preview the coordinator can stamp onto its
- * mirror entry so the mobile inbox shows the worker's latest assistant response instead
- * of being stuck on the first dispatched user task (which is the only message the
- * coordinator-side transcript ever holds). Returns undefined when the event carries no
- * assistant text — non-completion lifecycle events (generating_started / ready without a
- * summary) must NOT clobber a previously surfaced preview.
- */
 export declare function resolveMeshSurfacedSessionPreview(metadataEvent: Record<string, unknown>): {
     preview: string;
     role: 'assistant';

package/dist/mesh/mesh-missions.d.ts

@@ -62,6 +62,13 @@ export interface MeshMissionSlimSummary extends Omit<MeshMissionSummary, 'goal'>
 }
 /** Max chars of goal text retained in the slim (compact) mission summary. */
 export declare const GOAL_PREVIEW_MAX = 120;
+/**
+ * Shorter goal preview used by the mesh_status compact (LLM coordinator) surface.
+ * The coordinator only needs to recognize a mission, not read its full goal, and
+ * mesh_status repeats every live mission on every poll — so the status preview is
+ * tighter than the dashboard / mesh_mission_list preview (GOAL_PREVIEW_MAX).
+ */
+export declare const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
 export declare function upsertMeshMission(meshId: string, input: {
     id?: string;
     title: string;
@@ -93,6 +100,47 @@ export declare function getMeshStatusMissionSummaries(meshId: string, options?:
     verbose?: boolean;
     withStats?: boolean;
 }): MeshMissionSummary[] | MeshMissionSlimSummary[];
+/** Folded completed/abandoned history for the mesh_status compact surface. */
+export interface MeshStatusMissionsHistoryFold {
+    /** Total completed + abandoned missions. */
+    count: number;
+    /** Count by lifecycle status (e.g. { completed, abandoned }). */
+    byStatus: Record<string, number>;
+    /** Newest-first id list (capped) so each folded mission stays addressable. */
+    missionIds: string[];
+    note: string;
+}
+/** Compact mesh_status mission projection: live detail + folded history. */
+export interface MeshStatusMissionsCompact {
+    /**
+     * Active + paused missions, goal-elided to COMPACT_STATUS_GOAL_PREVIEW_MAX and
+     * WITHOUT the operational `stats` rollup — the `tasks` aggregate already carries
+     * progress, and stats (durations/retries) is a verbose/dashboard concern.
+     */
+    live: MeshMissionSlimSummary[];
+    /** Completed + abandoned missions folded to counts + ids; null when none. */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+}
+/**
+ * Mission projection for the mesh_status COMPACT (LLM coordinator) surface.
+ *
+ * Unlike getMeshStatusMissionSummaries (which emits every live mission plus a
+ * capped slice of full-detail history, each carrying a stats rollup), this keeps
+ * per-mission detail ONLY for live (active/paused) missions and folds the whole
+ * completed/abandoned history into a counts + id-list summary. Combined with the
+ * tighter goal preview and dropped stats, this is what keeps the compact
+ * mesh_status payload bounded as a mesh accumulates missions — the missions
+ * section previously dominated the payload (full goalPreview + tasks + stats per
+ * mission, for every live mission and up to 10 history missions, on every poll).
+ *
+ * The stored missions are untouched; this is an output-only projection. Full
+ * mission detail (goal text + stats + history) stays available via
+ * mesh_status verbose=true or mesh_mission_list.
+ */
+export declare function getMeshStatusMissionsCompact(meshId: string, options?: {
+    previewMax?: number;
+    historyIdLimit?: number;
+}): MeshStatusMissionsCompact;
 /**
  * Read-only mission listing for the mesh_mission_list tool. Returns summaries
  * (record + live task aggregate) for missions matching `statuses` — or every

package/package.json

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

package/src/index.ts

@@ -188,8 +188,8 @@ export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './con
 
 // ── Mesh Coordinator ──
 export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
-export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, listMeshMissionSummaries, buildMissionPromptSection, GOAL_PREVIEW_MAX, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
-export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate } from './mesh/mesh-missions.js';
+export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
+export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate, MeshStatusMissionsCompact, MeshStatusMissionsHistoryFold } from './mesh/mesh-missions.js';
 export { computeMeshTaskStats, computeMeshMissionStats } from './mesh/mesh-task-stats.js';
 export type { MeshTaskStats, MeshMissionStats } from './mesh/mesh-task-stats.js';
 export { deriveMeshReviewInboxItems } from './mesh/mesh-review-inbox.js';

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

@@ -14,6 +14,7 @@ import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } f
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
+import { getLastDisplayMessage } from '../status/snapshot.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
@@ -1424,6 +1425,26 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorSessionId,
     ) || readNonEmptyString(args.metadataEvent.meshCoordinatorSessionId);
 
+    // T2: a summary-less completion (and any non-completion status-sync event) carries no
+    // assistant text on the event, so resolveMeshSurfacedSessionPreview had nothing to surface
+    // and the coordinator's inbox mirror stayed stuck on the first dispatched user task. When
+    // THIS daemon hosts the live worker instance (sourceSession present), derive the worker's
+    // latest display message straight from its transcript and attach it to the event as
+    // lastMessagePreview/lastMessageRole/lastMessageAt. resolveMeshSurfacedSessionPreview reads
+    // these as an assistant-only fallback; they also ride the pending-queue + P2P relay
+    // (handleMeshForwardEvent whitelist) so a remote coordinator can surface them. A remote
+    // coordinator has no local instance and keeps relying on the relayed fields — unchanged.
+    const enrichedMetadataEvent = ((): Record<string, unknown> => {
+        const last = sourceSession ? getLastDisplayMessage(sourceSession.getState()) : null;
+        if (!last || !last.preview) return args.metadataEvent;
+        return {
+            ...args.metadataEvent,
+            lastMessagePreview: last.preview,
+            lastMessageRole: last.role,
+            ...(last.receivedAt > 0 ? { lastMessageAt: last.receivedAt } : {}),
+        };
+    })();
+
     // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own
     // relay listener; now the single core forwarder invokes the injected hook (no-op on
     // standalone) so the event path stays single-listener and the local code path is identical
@@ -1435,15 +1456,17 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             // mirror would stay stuck on the first dispatched user task. Resolve the
             // worker's latest assistant reply (carried on the completion event's
             // finalSummary / workerResult) into a preview the mirror can stamp, so the
-            // mobile inbox reflects the assistant response. Only completion-style events
-            // carry assistant text; for everything else this is undefined and the prior
-            // surfaced preview is preserved downstream (no clobber).
-            const surfacedPreview = resolveMeshSurfacedSessionPreview(args.metadataEvent);
+            // mobile inbox reflects the assistant response. Completion events carry assistant
+            // text as finalSummary; a summary-less completion / status sync falls back to the
+            // worker's latest assistant display message (enrichedMetadataEvent.lastMessage*).
+            // For a mid-turn user-only event this is undefined and the prior surfaced preview
+            // is preserved downstream (no clobber).
+            const surfacedPreview = resolveMeshSurfacedSessionPreview(enrichedMetadataEvent);
             components.onMeshCoordinatorEventForwarded({
                 event: args.event,
                 meshId: args.meshId,
                 nodeId: eventNodeId || undefined,
-                ...args.metadataEvent,
+                ...enrichedMetadataEvent,
                 // Ensure a `workspace` field reaches updateMeshOwnedSession even when the
                 // worker provider event only carried `workspaceName`. The merge spread of
                 // metadataEvent above wins when it already has a non-empty `workspace`.
@@ -1877,7 +1900,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         workspace: readNonEmptyString(args.metadataEvent.workspace)
             || readNonEmptyString(args.metadataEvent.workspaceName),
         metadataEvent: {
-            ...args.metadataEvent,
+            ...enrichedMetadataEvent,
             ...(recoveryContext ? { recoveryContext } : {}),
             // Stash the coordinator session id INSIDE metadataEvent too, so it survives the
             // P2P relay serialization (buildForwardPayloadFromPending spreads metadata; the
@@ -1955,6 +1978,13 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             providerName: readNonEmptyString(payload.providerName),
             ...(payload.sessionSettings && typeof payload.sessionSettings === 'object' && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {}),
             finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+            // T2: carry the worker's status-snapshot last-message preview across the machine
+            // boundary so a summary-less completion still surfaces the assistant reply in the
+            // coordinator's inbox mirror. resolveMeshSurfacedSessionPreview reads these
+            // (assistant-role only) when finalSummary is absent.
+            lastMessagePreview: readNonEmptyString(payload.lastMessagePreview),
+            lastMessageRole: readNonEmptyString(payload.lastMessageRole),
+            ...(payload.lastMessageAt !== undefined ? { lastMessageAt: payload.lastMessageAt } : {}),
             jobId: readNonEmptyString(payload.jobId),
             interactionId: readNonEmptyString(payload.interactionId),
             status: readNonEmptyString(payload.status),

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

@@ -162,17 +162,46 @@ export function readMeshCompletionSummary(metadataEvent: Record<string, unknown>
  * assistant text — non-completion lifecycle events (generating_started / ready without a
  * summary) must NOT clobber a previously surfaced preview.
  */
+function truncateSurfacedPreview(text: string): string {
+    const truncationSuffix = '...[truncated]';
+    return text.length > MESH_SURFACED_PREVIEW_MAX_CHARS
+        ? `${text.slice(0, MESH_SURFACED_PREVIEW_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}`
+        : text;
+}
+
 export function resolveMeshSurfacedSessionPreview(
     metadataEvent: Record<string, unknown>,
 ): { preview: string; role: 'assistant'; receivedAt: number } | undefined {
+    // 1) Completion summary — the worker's final assistant text rides a completion event
+    //    as finalSummary / workerResult.summary / result.summary.
     const summaryText = readMeshCompletionSummary(metadataEvent);
-    if (!summaryText) return undefined;
-    const truncationSuffix = '...[truncated]';
-    const preview = summaryText.length > MESH_SURFACED_PREVIEW_MAX_CHARS
-        ? `${summaryText.slice(0, MESH_SURFACED_PREVIEW_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}`
-        : summaryText;
-    const timestamp = readEventTimestampValue(metadataEvent.timestamp);
-    return { preview, role: 'assistant', receivedAt: timestamp };
+    if (summaryText) {
+        return {
+            preview: truncateSurfacedPreview(summaryText),
+            role: 'assistant',
+            receivedAt: readEventTimestampValue(metadataEvent.timestamp),
+        };
+    }
+    // 2) Status-snapshot fallback — a completion that carried NO summary (and any later
+    //    status-sync event) still ships the worker's latest display message on the event as
+    //    lastMessagePreview/lastMessageRole/lastMessageAt (computed by getLastDisplayMessage
+    //    on the worker, attached in injectMeshSystemMessage and carried over the relay).
+    //    Surface it ONLY when it is an assistant reply: a user-role last message means the
+    //    turn is still mid-flight (the dispatched task is the only message), and surfacing it
+    //    would both re-introduce the "inbox stuck on the user task" bug and clobber a
+    //    previously surfaced assistant preview. The web inbox guard renders only an
+    //    assistant-role preview anyway, so a user-role one would be inert there.
+    const lastPreview = readNonEmptyString(metadataEvent.lastMessagePreview);
+    const lastRole = readNonEmptyString(metadataEvent.lastMessageRole);
+    if (lastPreview && lastRole === 'assistant') {
+        return {
+            preview: truncateSurfacedPreview(lastPreview),
+            role: 'assistant',
+            receivedAt: readEventTimestampValue(metadataEvent.lastMessageAt)
+                || readEventTimestampValue(metadataEvent.timestamp),
+        };
+    }
+    return undefined;
 }
 
 function readEventTimestampValue(value: unknown): number {

package/src/mesh/mesh-missions.ts

@@ -74,6 +74,14 @@ export interface MeshMissionSlimSummary extends Omit<MeshMissionSummary, 'goal'>
 /** Max chars of goal text retained in the slim (compact) mission summary. */
 export const GOAL_PREVIEW_MAX = 120;
 
+/**
+ * Shorter goal preview used by the mesh_status compact (LLM coordinator) surface.
+ * The coordinator only needs to recognize a mission, not read its full goal, and
+ * mesh_status repeats every live mission on every poll — so the status preview is
+ * tighter than the dashboard / mesh_mission_list preview (GOAL_PREVIEW_MAX).
+ */
+export const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
+
 function normalizeMissionStatus(value: unknown): MeshMissionStatus {
     return MESH_MISSION_STATUSES.includes(value as MeshMissionStatus)
         ? value as MeshMissionStatus
@@ -153,13 +161,13 @@ export function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummar
 }
 
 /** Project a full mission summary down to the slim (goal-elided) shape. */
-function slimMissionSummary(summary: MeshMissionSummary): MeshMissionSlimSummary {
+function slimMissionSummary(summary: MeshMissionSummary, previewMax: number = GOAL_PREVIEW_MAX): MeshMissionSlimSummary {
     const goal = typeof summary.goal === 'string' ? summary.goal : '';
-    const goalTruncated = goal.length > GOAL_PREVIEW_MAX;
+    const goalTruncated = goal.length > previewMax;
     const { goal: _omitGoal, ...rest } = summary;
     return {
         ...rest,
-        goalPreview: goalTruncated ? goal.slice(0, GOAL_PREVIEW_MAX) : goal,
+        goalPreview: goalTruncated ? goal.slice(0, previewMax) : goal,
         goalTruncated,
     };
 }
@@ -197,7 +205,73 @@ export function getMeshStatusMissionSummaries(
     if (options?.withStats) {
         full = full.map(summary => ({ ...summary, stats: computeMeshMissionStats(meshId, summary.id) }));
     }
-    return options?.verbose ? full : full.map(slimMissionSummary);
+    return options?.verbose ? full : full.map(summary => slimMissionSummary(summary));
+}
+
+/** Folded completed/abandoned history for the mesh_status compact surface. */
+export interface MeshStatusMissionsHistoryFold {
+    /** Total completed + abandoned missions. */
+    count: number;
+    /** Count by lifecycle status (e.g. { completed, abandoned }). */
+    byStatus: Record<string, number>;
+    /** Newest-first id list (capped) so each folded mission stays addressable. */
+    missionIds: string[];
+    note: string;
+}
+
+/** Compact mesh_status mission projection: live detail + folded history. */
+export interface MeshStatusMissionsCompact {
+    /**
+     * Active + paused missions, goal-elided to COMPACT_STATUS_GOAL_PREVIEW_MAX and
+     * WITHOUT the operational `stats` rollup — the `tasks` aggregate already carries
+     * progress, and stats (durations/retries) is a verbose/dashboard concern.
+     */
+    live: MeshMissionSlimSummary[];
+    /** Completed + abandoned missions folded to counts + ids; null when none. */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+}
+
+/**
+ * Mission projection for the mesh_status COMPACT (LLM coordinator) surface.
+ *
+ * Unlike getMeshStatusMissionSummaries (which emits every live mission plus a
+ * capped slice of full-detail history, each carrying a stats rollup), this keeps
+ * per-mission detail ONLY for live (active/paused) missions and folds the whole
+ * completed/abandoned history into a counts + id-list summary. Combined with the
+ * tighter goal preview and dropped stats, this is what keeps the compact
+ * mesh_status payload bounded as a mesh accumulates missions — the missions
+ * section previously dominated the payload (full goalPreview + tasks + stats per
+ * mission, for every live mission and up to 10 history missions, on every poll).
+ *
+ * The stored missions are untouched; this is an output-only projection. Full
+ * mission detail (goal text + stats + history) stays available via
+ * mesh_status verbose=true or mesh_mission_list.
+ */
+export function getMeshStatusMissionsCompact(
+    meshId: string,
+    options?: { previewMax?: number; historyIdLimit?: number },
+): MeshStatusMissionsCompact {
+    const previewMax = Math.max(0, options?.previewMax ?? COMPACT_STATUS_GOAL_PREVIEW_MAX);
+    const historyIdLimit = Math.max(0, options?.historyIdLimit ?? 20);
+    const all = getMeshMissions(meshId);
+    const live = all
+        .filter(m => m.status === 'active' || m.status === 'paused')
+        .map(mission => slimMissionSummary(summarizeMeshMission(meshId, mission), previewMax));
+    const history = all
+        .filter(m => m.status === 'completed' || m.status === 'abandoned')
+        .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+    let historyFold: MeshStatusMissionsHistoryFold | null = null;
+    if (history.length > 0) {
+        const byStatus: Record<string, number> = {};
+        for (const m of history) byStatus[m.status] = (byStatus[m.status] ?? 0) + 1;
+        historyFold = {
+            count: history.length,
+            byStatus,
+            missionIds: history.slice(0, historyIdLimit).map(m => m.id),
+            note: 'Completed/abandoned missions are folded to counts + ids in compact mesh_status. Use mesh_mission_list or mesh_status verbose=true for their goal/task detail.',
+        };
+    }
+    return { live, historyFold };
 }
 
 /**
@@ -219,7 +293,7 @@ export function listMeshMissionSummaries(
     const missions = getMeshMissions(meshId, statuses)
         .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
     const full = missions.map(mission => summarizeMeshMission(meshId, mission));
-    return options?.verbose ? full : full.map(slimMissionSummary);
+    return options?.verbose ? full : full.map(summary => slimMissionSummary(summary));
 }
 
 /**