@adhdev/daemon-core 0.9.82-rc.76 → 0.9.82-rc.78

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/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.76",
+  "version": "0.9.82-rc.78",
   "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

@@ -56,7 +56,7 @@ import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDa
 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 { 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,12 +1281,13 @@ async function runMeshRefineSubmoduleReachabilityGate(
             });
             return String(stdout || '');
         };
-        const verifyRemoteCommitReachable = async (remoteUrl: string, commit: string): Promise<void> => {
+        const verifyRemoteMainContainsCommit = async (remoteUrl: string, commit: string, branch = 'main'): 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, ['-c', 'protocol.file.allow=always', 'fetch', '--depth=1', remoteUrl, `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
                 await runGit(probeDir, ['cat-file', '-e', `${commit}^{commit}`]);
+                await runGit(probeDir, ['merge-base', '--is-ancestor', commit, `refs/remotes/origin/${branch}`]);
             } finally {
                 fs.rmSync(probeDir, { recursive: true, force: true });
             }
@@ -1325,15 +1340,18 @@ async function runMeshRefineSubmoduleReachabilityGate(
                         entries.push(entry);
                         continue;
                     }
-                    await verifyRemoteCommitReachable(remoteUrl, gitlink.commit);
+                    entry.remoteMainBranch = 'main';
+                    await verifyRemoteMainContainsCommit(remoteUrl, 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));
@@ -2725,6 +2743,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 +2757,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 +2771,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 +4891,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

@@ -765,8 +765,20 @@ function buildMeshSystemMessage(args: {
         const result = readRecord(args.metadataEvent.result);
         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 convergenceStatus = readNonEmptyString(result?.convergenceStatus);
+        const blockedReason = readNonEmptyString(result?.blockedReason);
+        const nextStep = readNonEmptyString(result?.nextStep) || readNonEmptyString(readRecord(result?.finalBranchConvergenceState)?.nextStep);
+        const details = [
+            jobId ? `job_id=${jobId}` : '',
+            code ? `code=${code}` : '',
+            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 +916,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;
         }
     }
 

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

@@ -43,6 +43,11 @@ type CompletedDebouncePending = {
     loggedBlockReason?: string;
 };
 
+type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+};
+
 const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
 
@@ -817,29 +822,34 @@ export class CliProviderInstance implements ProviderInstance {
         return !this.hasAdapterPendingResponse();
     }
 
-    private getCompletedFinalizationBlockReason(latestVisibleStatus: string): string | null {
-        if (latestVisibleStatus !== 'idle') return `status:${latestVisibleStatus}`;
+    private getCompletedFinalizationBlock(latestVisibleStatus: string): CompletedFinalizationBlock | null {
+        if (latestVisibleStatus !== 'idle') return { reason: `status:${latestVisibleStatus}`, terminal: true };
 
         const adapterAny = this.adapter as any;
-        if (adapterAny?.isWaitingForResponse === true) return 'adapter_waiting_for_response';
-        if (adapterAny?.currentTurnScope) return 'adapter_turn_scope_active';
+        if (adapterAny?.isWaitingForResponse === true) return { reason: 'adapter_waiting_for_response', terminal: true };
+        if (adapterAny?.currentTurnScope) return { reason: 'adapter_turn_scope_active', terminal: true };
+        if (this.hasAdapterPendingResponse()) return { reason: 'adapter_pending_response', terminal: true };
 
         const partial = typeof this.adapter.getPartialResponse === 'function'
             ? this.adapter.getPartialResponse()
             : '';
-        if (typeof partial === 'string' && partial.trim()) return 'partial_response_pending';
+        if (typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
 
         let parsed: any;
         try {
             parsed = this.adapter.getScriptParsedStatus();
         } catch (error: any) {
-            return `parse_error:${error?.message || String(error)}`;
+            return { reason: `parse_error:${error?.message || String(error)}` };
         }
 
         const parsedStatus = typeof parsed?.status === 'string' ? parsed.status : 'unknown';
-        if (parsedStatus !== 'idle') return `parsed_status:${parsedStatus}`;
-        if (parsed?.activeModal || parsed?.modal) return 'parsed_modal_active';
-        if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return 'missing_final_assistant';
+        if (parsedStatus !== 'idle') {
+            const adapterStatus = this.adapter.getStatus({ allowParse: false });
+            if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
+            return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
+        }
+        if (parsed?.activeModal || parsed?.modal) return { reason: 'parsed_modal_active', terminal: true };
+        if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return { reason: 'missing_final_assistant' };
 
         return null;
     }
@@ -866,10 +876,11 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
 
-        const blockReason = this.getCompletedFinalizationBlockReason(latestVisibleStatus);
-        if (blockReason) {
+        const block = this.getCompletedFinalizationBlock(latestVisibleStatus);
+        if (block) {
+            const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
-            if (waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+            if (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
                     pending.loggedBlockReason = blockReason;