@adhdev/daemon-core 0.9.82-rc.77 → 0.9.82-rc.79

package/dist/mesh/mesh-active-work.d.ts

@@ -20,6 +20,7 @@ export interface MeshActiveWorkRecord {
     terminal?: boolean;
     terminalKind?: string;
     terminalAt?: string;
+    staleReason?: string;
 }
 export interface MeshActiveWorkSummary {
     totalActiveCount: number;
@@ -31,6 +32,7 @@ export interface MeshActiveWorkSummary {
     idleCount: number;
     sourceCounts: Record<MeshActiveWorkSource, number>;
     statusCounts: Record<MeshActiveWorkStatus, number>;
+    staleDirectCount: number;
 }
 export interface BuildMeshActiveWorkOptions {
     meshId: string;
@@ -44,5 +46,6 @@ export interface BuildMeshActiveWorkOptions {
 export declare function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary;
 export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
     activeWork: MeshActiveWorkRecord[];
+    staleDirectWork: MeshActiveWorkRecord[];
     summary: MeshActiveWorkSummary;
 };

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

@@ -6,6 +6,7 @@ export interface PendingMeshCoordinatorEvent {
     nodeId?: string;
     workspace?: string;
     metadataEvent: Record<string, unknown>;
+    coordinatorMessage?: string;
     queuedAt: number;
 }
 export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;

package/dist/providers/cli-provider-instance.d.ts

@@ -104,7 +104,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;
-    private getCompletedFinalizationBlockReason;
+    private getCompletedFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.77",
+  "version": "0.9.82-rc.79",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/cli-manager.ts

@@ -86,6 +86,50 @@ function normalizeAgentStatus(value: unknown): string {
     return typeof value === 'string' ? value.trim().toLowerCase() : '';
 }
 
+function hasNonEmptyModalButtons(activeModal: unknown): boolean {
+    const buttons = (activeModal as any)?.buttons;
+    return Array.isArray(buttons) && buttons.some((button) => String(button || '').trim().length > 0);
+}
+
+function hasAdapterPendingResponse(adapter: any): boolean {
+    if (adapter?.isWaitingForResponse === true) return true;
+    if (adapter?.currentTurnScope) return true;
+    try {
+        if (typeof adapter?.isProcessing === 'function' && adapter.isProcessing()) return true;
+    } catch { /* defensive: send guard should not fail on diagnostics */ }
+    try {
+        const partial = typeof adapter?.getPartialResponse === 'function' ? adapter.getPartialResponse() : '';
+        if (typeof partial === 'string' && partial.trim()) return true;
+    } catch { /* defensive: missing partial means no pending evidence */ }
+    return false;
+}
+
+function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
+    if (adapterStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function getEffectiveAgentSendStatus(adapter: any): string {
+    const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+    if (adapterStatus && adapterStatus !== 'idle') return adapterStatus;
+    if (adapterStatus !== 'idle') return adapterStatus;
+
+    if (typeof adapter?.getScriptParsedStatus !== 'function') return adapterStatus;
+    try {
+        const parsedStatus = adapter.getScriptParsedStatus();
+        const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+        if (BUSY_AGENT_STATUSES.has(parsedRawStatus) && !shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter)) {
+            return parsedRawStatus;
+        }
+    } catch {
+        return adapterStatus;
+    }
+    return adapterStatus;
+}
+
 export interface CliTransportFactoryParams {
     runtimeId: string;
     providerType: string;
@@ -1079,7 +1123,7 @@ export class DaemonCliManager {
                 const { adapter, key } = found;
 
                 if (action === 'send_chat') {
-                    const currentStatus = normalizeAgentStatus(adapter.getStatus?.()?.status);
+                    const currentStatus = getEffectiveAgentSendStatus(adapter);
                     if (BUSY_AGENT_STATUSES.has(currentStatus)) {
                         return {
                             success: false,

package/src/commands/router.ts

@@ -55,8 +55,8 @@ import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
 import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
-import { homedir, tmpdir } from 'os';
-import { join as pathJoin, resolve as pathResolve } from 'path';
+import { homedir } from 'os';
+import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from 'path';
 import * as fs from 'fs';
 
 type ReleaseChannel = 'stable' | 'preview';
@@ -230,6 +230,18 @@ function readGitSubmodules(value: unknown, parentRepoRoot?: string): GitSubmodul
     return submodules.length > 0 ? submodules : undefined;
 }
 
+function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string {
+    const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
+    if (explicit) return explicit;
+    const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
+    const workspaceName = workspace ? pathBasename(workspace) : undefined;
+    const host = readStringValue(node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
+    const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : undefined);
+    const parts = [workspaceName, host, provider].filter(Boolean);
+    if (parts.length > 0) return parts.join(' · ');
+    return nodeId || 'unidentified mesh node';
+}
+
 function normalizeInlineMeshGitStatus(
     status: Record<string, unknown>,
     node: any,
@@ -1095,6 +1107,8 @@ type MeshRefineSubmoduleReachabilityEntry = {
     remote?: string;
     remoteUrl?: string;
     remoteReachable?: boolean;
+    remoteMainBranch?: string;
+    remoteMainReachable?: boolean;
     fetchedFromOrigin?: boolean;
     error?: string;
 };
@@ -1170,7 +1184,7 @@ function buildSubmodulePublishRequiredNextStep(entries: MeshRefineSubmoduleReach
     const refs = entries
         .map(entry => `${entry.path}@${entry.commit}`)
         .join(', ');
-    return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to their configured submodule remote(s), then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from its configured remote.`;
+    return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.`;
 }
 
 async function computeGitPatchId(cwd: string, fromRef: string, toRef: string): Promise<string> {
@@ -1267,15 +1281,9 @@ async function runMeshRefineSubmoduleReachabilityGate(
             });
             return String(stdout || '');
         };
-        const verifyRemoteCommitReachable = async (remoteUrl: string, commit: string): Promise<void> => {
-            const probeDir = fs.mkdtempSync(pathJoin(tmpdir(), 'adhdev-submodule-reachability-'));
-            try {
-                await runGit(probeDir, ['init', '-q']);
-                await runGit(probeDir, ['-c', 'protocol.file.allow=always', 'fetch', '--depth=1', remoteUrl, commit]);
-                await runGit(probeDir, ['cat-file', '-e', `${commit}^{commit}`]);
-            } finally {
-                fs.rmSync(probeDir, { recursive: true, force: true });
-            }
+        const verifyRemoteMainContainsCommit = async (submodulePath: string, commit: string, branch = 'main'): Promise<void> => {
+            await runGit(submodulePath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+            await runGit(submodulePath, ['merge-base', '--is-ancestor', commit, `refs/remotes/origin/${branch}`]);
         };
 
         const treeOutput = await runGit(repoRoot, ['ls-tree', '-r', '-z', mergedTree]);
@@ -1325,15 +1333,18 @@ async function runMeshRefineSubmoduleReachabilityGate(
                         entries.push(entry);
                         continue;
                     }
-                    await verifyRemoteCommitReachable(remoteUrl, gitlink.commit);
+                    entry.remoteMainBranch = 'main';
+                    await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, 'main');
                     entry.fetchedFromOrigin = true;
                     entry.remoteReachable = true;
+                    entry.remoteMainReachable = true;
                     entry.reachable = true;
                 } catch (e: any) {
                     entry.remoteReachable = false;
+                    entry.remoteMainReachable = false;
                     entry.publishRequired = true;
                     const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-                    entry.error = `Submodule remote reachability check failed for origin: ${details}`;
+                    entry.error = `Submodule remote main reachability check failed for origin/main: ${details}`;
                 }
             } catch (e: any) {
                 entry.error = truncateValidationOutput(e?.message || String(e));
@@ -2540,28 +2551,51 @@ export class DaemonCommandRouter {
     }
 
     private queueRefineJobEvent(event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void {
-        queuePendingMeshCoordinatorEvent({
+        const metadataEvent = {
+            source: 'refine_mesh_node_async_job',
+            jobId: handle.jobId,
+            interactionId: handle.interactionId,
+            meshId: handle.meshId,
+            nodeId: handle.targetNodeId,
+            targetDaemonId: handle.targetDaemonId,
+            workspace: handle.workspace,
+            status: handle.status,
+            startedAt: handle.startedAt,
+            completedAt: handle.completedAt,
+            retryOfJobId: handle.retryOfJobId,
+            ...(result ? { result } : {}),
+        };
+        const eventPayload = {
             event,
             meshId: handle.meshId,
             nodeLabel: handle.targetNodeId,
             nodeId: handle.targetNodeId,
             workspace: handle.workspace,
-            metadataEvent: {
-                source: 'refine_mesh_node_async_job',
-                jobId: handle.jobId,
-                interactionId: handle.interactionId,
-                meshId: handle.meshId,
-                nodeId: handle.targetNodeId,
-                targetDaemonId: handle.targetDaemonId,
-                workspace: handle.workspace,
-                status: handle.status,
-                startedAt: handle.startedAt,
-                completedAt: handle.completedAt,
-                retryOfJobId: handle.retryOfJobId,
-                ...(result ? { result } : {}),
-            },
+            metadataEvent,
             queuedAt: Date.now(),
-        });
+        };
+        if (typeof this.deps.instanceManager?.getByCategory === 'function') {
+            const forwarded = handleMeshForwardEvent(
+                { instanceManager: this.deps.instanceManager } as any,
+                {
+                    event,
+                    meshId: handle.meshId,
+                    nodeId: handle.targetNodeId,
+                    workspace: handle.workspace,
+                    jobId: handle.jobId,
+                    interactionId: handle.interactionId,
+                    status: handle.status,
+                    targetDaemonId: handle.targetDaemonId,
+                    startedAt: handle.startedAt,
+                    completedAt: handle.completedAt,
+                    retryOfJobId: handle.retryOfJobId,
+                    ...(result ? { result } : {}),
+                },
+            );
+            if (forwarded?.success === true) return;
+            LOG.warn('Mesh', `[Refinery] Failed to forward async refine event ${event}: ${forwarded?.error || 'unknown error'}`);
+        }
+        queuePendingMeshCoordinatorEvent(eventPayload);
     }
 
     private async appendRefineJobLedger(kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): Promise<void> {
@@ -2725,6 +2759,8 @@ export class DaemonCommandRouter {
                     remote: entry.remote,
                     remoteUrl: entry.remoteUrl,
                     remoteReachable: entry.remoteReachable,
+                    remoteMainBranch: entry.remoteMainBranch,
+                    remoteMainReachable: entry.remoteMainReachable,
                     error: entry.error,
                 })),
                 error: submoduleReachability.error,
@@ -2737,13 +2773,13 @@ export class DaemonCommandRouter {
                     convergenceStatus: 'blocked_review',
                     publishRequired: true,
                     blockedReason: 'submodule_publish_required',
-                    error: 'Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote; merge/refine cleanup was not attempted.',
+                    error: 'Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.',
                     nextStep,
                     nextSteps: [
                         'Ask the user for explicit approval before pushing or publishing any submodule commit.',
-                        'Push/publish each unreachable submodule commit to the configured submodule remote shown in the evidence.',
+                        'Push/publish each unreachable submodule commit to the configured submodule remote main branch shown in the evidence.',
                         'Rerun mesh_refine_node after remote reachability is confirmed.',
-                        'Do not merge the root branch until every submodule gitlink commit is reachable from its configured remote.',
+                        'Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.',
                     ],
                     unreachableSubmoduleCommits: submoduleReachability.unreachable.map(entry => ({
                         path: entry.path,
@@ -2751,6 +2787,8 @@ export class DaemonCommandRouter {
                         remote: entry.remote,
                         remoteUrl: entry.remoteUrl,
                         remoteReachable: entry.remoteReachable,
+                        remoteMainBranch: entry.remoteMainBranch,
+                        remoteMainReachable: entry.remoteMainReachable,
                         error: entry.error,
                     })),
                     branch,
@@ -4869,7 +4907,10 @@ export class DaemonCommandRouter {
                         ) || Boolean(meshRecord?.inline && nodeIndex === 0);
                         const status: Record<string, unknown> = {
                             nodeId,
-                            machineLabel: node.machineLabel || node.id || node.nodeId,
+                            machineLabel: buildMeshNodeDisplayLabel(node as Record<string, unknown>, nodeId, providerPriority),
+                            labelSource: readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias)
+                                ? 'explicit_metadata'
+                                : 'workspace_host_provider_context',
                             workspace: node.workspace,
                             repoRoot: node.repoRoot,
                             isLocalWorktree: node.isLocalWorktree,

package/src/mesh/coordinator-prompt.ts

@@ -76,7 +76,12 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
 // ─── Section Builders ───────────────────────────
 
 function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
-    const lines = ['## Current Node Status', ''];
+    const lines = [
+        '## Current Node Status',
+        '',
+        'Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.',
+        '',
+    ];
     for (const n of nodes) {
         const healthIcon = n.health === 'online' ? '🟢' :
             n.health === 'dirty' ? '🟡' :
@@ -85,21 +90,33 @@ function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
             ? `sessions: ${n.activeSessions.join(', ')}`
             : 'no active sessions';
         const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : '';
-        lines.push(`- ${healthIcon} **${n.machineLabel}** (${n.nodeId})`);
-        lines.push(`  workspace: \`${n.workspace}\` | ${branch} | ${sessions}`);
+        const context = [
+            n.daemonId ? `daemon: \`${n.daemonId}\`` : '',
+            n.providers?.length ? `providers: ${n.providers.join(', ')}` : '',
+        ].filter(Boolean).join(' | ');
+        lines.push(`- ${healthIcon} **${n.machineLabel}** (nodeId: \`${n.nodeId}\`)`);
+        lines.push(`  workspace: \`${n.workspace}\`${context ? ` | ${context}` : ''} | ${branch} | ${sessions}`);
         if (n.error) lines.push(`  ⚠️ ${n.error}`);
     }
     return lines.join('\n');
 }
 
 function buildNodeConfigSection(mesh: LocalMeshEntry): string {
-    const lines = ['## Configured Nodes', ''];
+    const lines = [
+        '## Configured Nodes',
+        '',
+        'Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.',
+        '',
+    ];
     for (const n of mesh.nodes) {
         const labels: string[] = [];
         if (n.isLocalWorktree) labels.push('worktree');
         if (n.policy?.readOnly) labels.push('read-only');
         const suffix = labels.length ? ` [${labels.join(', ')}]` : '';
-        lines.push(`- **${n.workspace}** (${n.id})${suffix}`);
+        const explicitMachineLabel = typeof (n as any).machineLabel === 'string' ? (n as any).machineLabel : '';
+        const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : '';
+        const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(', ')}` : '';
+        lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ''}${providerPriority}${suffix}`);
     }
     lines.push('', '_Use `mesh_status` to probe live health before delegating work._');
     return lines.join('\n');
@@ -165,7 +182,7 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
 4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** — When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** — Call \`mesh_checkpoint\` to save the work.
-7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from its configured remote. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`, ask the user for explicit approval to push/publish the unreachable submodule commit(s), then rerun \`mesh_refine_node\`; do not merge the root branch until the submodule commit(s) are reachable. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`; do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
 8. **Clean up** — Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** — Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -204,6 +221,6 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
 - **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, fast-forward obvious clean behind-only branches with \`mesh_fast_forward_node\`, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
 - **Keep Refinery validation project-configurable.** \`mesh_refine_node\` must execute validation from repo mesh/refine config (for example \`.adhdev/refine.{json,yaml,yml}\`, \`.adhdev/repo-mesh-refine.*\`, or \`repo-mesh.refine.*\`). Heuristics are suggestions/scaffolding only, not the execution path.
-- **Treat submodule reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote. Do not retry validation blindly or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit, then rerun \`mesh_refine_node\`.
+- **Treat submodule main reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote main branch. Do not treat feature-branch reachability as complete, retry validation blindly, or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit to submodule main, then rerun \`mesh_refine_node\`.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }

package/src/mesh/mesh-active-work.ts

@@ -22,6 +22,7 @@ export interface MeshActiveWorkRecord {
     terminal?: boolean;
     terminalKind?: string;
     terminalAt?: string;
+    staleReason?: string;
 }
 
 export interface MeshActiveWorkSummary {
@@ -34,6 +35,7 @@ export interface MeshActiveWorkSummary {
     idleCount: number;
     sourceCounts: Record<MeshActiveWorkSource, number>;
     statusCounts: Record<MeshActiveWorkStatus, number>;
+    staleDirectCount: number;
 }
 
 export interface BuildMeshActiveWorkOptions {
@@ -64,10 +66,12 @@ function elapsedSince(value: string | undefined, now: number): number {
     return Number.isFinite(started) ? Math.max(0, now - started) : 0;
 }
 
-function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessionId?: string): MeshActiveWorkStatus | undefined {
-    if (!nodeId || !sessionId || !Array.isArray(nodes)) return undefined;
+function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessionId?: string): { status?: MeshActiveWorkStatus; staleReason?: string } {
+    if (!Array.isArray(nodes)) return {};
+    if (!nodeId) return { staleReason: 'direct task has no node id' };
     const node = nodes.find(item => readString(item?.id) === nodeId || readString(item?.nodeId) === nodeId || readString(item?.node_id) === nodeId);
-    if (!node) return undefined;
+    if (!node) return { staleReason: 'direct task node is no longer in the live mesh' };
+    if (!sessionId) return {};
     const candidates: any[] = [];
     for (const value of [node.sessions, node.activeSessions, node.active_sessions, node.lastProbe?.sessions, node.last_probe?.sessions, node.lastProbe?.status?.sessions, node.last_probe?.status?.sessions]) {
         if (Array.isArray(value)) candidates.push(...value);
@@ -76,16 +80,18 @@ function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessi
         if (value && typeof value === 'object') candidates.push(value);
     }
     const session = candidates.find(item => {
+        if (typeof item === 'string') return item === sessionId;
         const id = readString(item?.id) || readString(item?.sessionId) || readString(item?.session_id) || readString(item?.runtimeSessionId) || readString(item?.instanceId);
         return id === sessionId;
     });
-    if (!session) return undefined;
+    if (!session) return { staleReason: 'direct task session is not present in live session records' };
+    if (typeof session === 'string') return {};
     const raw = `${readString(session.status) || ''} ${readString(session.lifecycle) || ''} ${readString(session.state) || ''} ${readString(session.activeChat?.status) || ''}`.toLowerCase();
-    if (raw.includes('approval')) return 'awaiting_approval';
-    if (raw.includes('generating') || raw.includes('running') || raw.includes('busy')) return 'generating';
-    if (raw.includes('failed') || raw.includes('stopped') || raw.includes('terminated') || raw.includes('exited')) return 'failed';
-    if (raw.includes('idle') || raw.includes('waiting_input') || raw.includes('ready')) return 'idle';
-    return undefined;
+    if (raw.includes('approval')) return { status: 'awaiting_approval' };
+    if (raw.includes('generating') || raw.includes('running') || raw.includes('busy')) return { status: 'generating' };
+    if (raw.includes('failed') || raw.includes('stopped') || raw.includes('terminated') || raw.includes('exited')) return { status: 'failed' };
+    if (raw.includes('idle') || raw.includes('waiting_input') || raw.includes('ready')) return { status: 'idle' };
+    return {};
 }
 
 function isDirectDispatch(entry: MeshLedgerEntry): boolean {
@@ -138,12 +144,14 @@ export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]):
         idleCount: statusCounts.idle,
         sourceCounts,
         statusCounts,
+        staleDirectCount: activeWork.filter(item => item.source === 'direct' && item.staleReason).length,
     };
 }
 
-export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeWork: MeshActiveWorkRecord[]; summary: MeshActiveWorkSummary } {
+export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeWork: MeshActiveWorkRecord[]; staleDirectWork: MeshActiveWorkRecord[]; summary: MeshActiveWorkSummary } {
     const now = opts.now ?? Date.now();
     const records: MeshActiveWorkRecord[] = [];
+    const staleDirectWork: MeshActiveWorkRecord[] = [];
 
     for (const task of opts.queue || []) {
         if (task.status !== 'pending' && task.status !== 'assigned') continue;
@@ -173,13 +181,13 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
             .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
         const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
-        const liveStatus = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-        const status = terminalStatus || liveStatus || 'assigned';
+        const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+        const status = terminalStatus || live.status || 'assigned';
         const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
         if (terminalRow && opts.includeTerminalDirect !== true) continue;
         const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
         const { title, summary } = summarizeMessage(message);
-        records.push({
+        const record: MeshActiveWorkRecord = {
             taskId,
             source: 'direct',
             status,
@@ -197,9 +205,18 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             terminal: terminalRow,
             terminalKind: terminal?.kind,
             terminalAt: terminal?.timestamp,
-        });
+            staleReason: live.staleReason,
+        };
+        if (live.staleReason && !terminalRow) {
+            staleDirectWork.push(record);
+            continue;
+        }
+        records.push(record);
     }
 
     records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-    return { activeWork: records, summary: buildMeshActiveWorkSummary(records) };
+    staleDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    const summary = buildMeshActiveWorkSummary(records);
+    summary.staleDirectCount = staleDirectWork.length;
+    return { activeWork: records, staleDirectWork, summary };
 }

package/src/mesh/mesh-events.ts

@@ -55,6 +55,7 @@ export interface PendingMeshCoordinatorEvent {
     nodeId?: string;
     workspace?: string;
     metadataEvent: Record<string, unknown>;
+    coordinatorMessage?: string;
     queuedAt: number;
 }
 
@@ -750,23 +751,62 @@ function buildMeshSystemMessage(args: {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
         const result = readRecord(args.metadataEvent.result);
         const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
         const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
         const into = readNonEmptyString(result?.into);
         const branch = readNonEmptyString(result?.branch);
+        const mergeStatus = result?.merged === true ? 'merged' : readNonEmptyString(finalConvergence?.status);
+        const convergenceStatus = readNonEmptyString(finalConvergence?.status);
+        const nextStep = readNonEmptyString(result?.nextStep)
+            || readNonEmptyString(finalConvergence?.nextStep)
+            || 'Continue from the updated mesh state.';
         const details = [
             jobId ? `job_id=${jobId}` : '',
             branch && into ? `${branch}→${into}` : '',
             validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
+            convergenceStatus ? `final_convergence=${convergenceStatus}` : '',
         ].filter(Boolean).join('; ');
-        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}. The worktree was merged and cleanup completed; continue from the updated mesh state.`;
+        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}.\nNext step: ${nextStep}`;
     }
     if (args.event === 'refine:failed') {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
         const result = readRecord(args.metadataEvent.result);
+        const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
         const code = readNonEmptyString(result?.code);
         const error = readNonEmptyString(result?.error);
-        const details = [jobId ? `job_id=${jobId}` : '', code ? `code=${code}` : ''].filter(Boolean).join('; ');
-        return `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ''}${error ? `: ${error}` : '.'} Review the terminal refine event/ledger before retrying.`;
+        const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
+        const mergeStatus = result?.merged === true
+            ? 'merged'
+            : finalConvergence?.merged === false
+                ? 'not_merged'
+                : '';
+        const convergenceStatus = readNonEmptyString(result?.convergenceStatus)
+            || readNonEmptyString(finalConvergence?.status);
+        const blockedReason = readNonEmptyString(result?.blockedReason);
+        const nextStep = readNonEmptyString(result?.nextStep) || readNonEmptyString(finalConvergence?.nextStep);
+        const details = [
+            jobId ? `job_id=${jobId}` : '',
+            code ? `code=${code}` : '',
+            validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
+            convergenceStatus ? `convergence=${convergenceStatus}` : '',
+            blockedReason ? `reason=${blockedReason}` : '',
+        ].filter(Boolean).join('; ');
+        const parts = [
+            `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ''}${error ? `: ${error}` : '.'}`,
+            nextStep ? `Next step: ${nextStep}` : 'Review the terminal refine event/ledger before retrying.',
+        ];
+        return parts.join('\n');
     }
     return '';
 }
@@ -904,7 +944,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
         }
         if (sessionId) {
-            updateSessionTaskStatus(args.meshId, sessionId, 'failed');
+            const failedTask = updateSessionTaskStatus(args.meshId, sessionId, 'failed');
+            completedTaskForLedger = failedTask ? { id: failedTask.id } : null;
         }
     }
 
@@ -1015,6 +1056,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     }
 
+    const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+        recoveryContext,
+    });
+    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+
     const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
         const instState = inst.getState();
         if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
@@ -1034,6 +1083,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                     ...args.metadataEvent,
                     ...(recoveryContext ? { recoveryContext } : {}),
                 },
+                coordinatorMessage: messageText,
                 queuedAt: Date.now(),
             })) {
             LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
@@ -1041,14 +1091,6 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0 };
     }
 
-    const messageText = buildMeshSystemMessage({
-        event: args.event,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: args.metadataEvent,
-        recoveryContext,
-    });
-    if (!messageText) return { success: false, error: 'unsupported mesh event' };
-
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
         LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);