@adhdev/daemon-core 0.9.82-rc.70 → 0.9.82-rc.72

package/package.json

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

package/src/commands/chat-commands.ts

@@ -24,6 +24,7 @@ import { filterUserFacingChatMessages, normalizeChatMessages } from '../provider
 const RECENT_SEND_WINDOW_MS = 1200;
 export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
 const HERMES_CLI_STARTING_SEND_SETTLE_MS = 2_000;
+const CODEX_NATIVE_HISTORY_FRESH_MS = 5 * 60_000;
 const recentSendByTarget = new Map<string, number>();
 
 interface ApprovalSelectableInstance extends ProviderInstance {
@@ -221,6 +222,114 @@ function normalizeReadChatMessages(payload: Record<string, any>): ChatMessage[]
     return normalizeChatMessages(messages);
 }
 
+function getMessageNewestReceivedAt(messages: Array<{ receivedAt?: unknown; timestamp?: unknown }>): number {
+    let newest = 0;
+    for (const message of messages) {
+        const receivedAt = Number(message?.receivedAt ?? message?.timestamp ?? 0);
+        if (Number.isFinite(receivedAt) && receivedAt > newest) newest = receivedAt;
+    }
+    return newest;
+}
+
+function buildCliMessageSourceProvenance(args: {
+    selected: 'native-history' | 'pty-parser';
+    provider: string;
+    nativeHandle?: string;
+    fallbackReason?: string;
+    nativeSource?: string;
+    sourcePath?: string;
+    sourceMtimeMs?: number;
+    nativeMessages?: ChatMessage[];
+    ptyMessages?: ChatMessage[];
+    returnedMessages?: ChatMessage[];
+    safeMapping?: boolean;
+    freshEnough?: boolean;
+    ptyStatusApprovalOnly?: boolean;
+}): Record<string, unknown> {
+    const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
+    const sourceMtimeAgeMs = sourceMtimeMs > 0 ? Math.max(0, Date.now() - sourceMtimeMs) : undefined;
+    const nativeMessages = args.nativeMessages || [];
+    const ptyMessages = args.ptyMessages || [];
+    const returnedMessages = args.returnedMessages || [];
+    return {
+        selected: args.selected,
+        provider: args.provider,
+        ...(args.nativeHandle ? { nativeHandle: args.nativeHandle } : {}),
+        ...(args.fallbackReason ? { fallbackReason: args.fallbackReason } : {}),
+        ...(args.nativeSource ? { nativeSource: args.nativeSource } : {}),
+        ...(args.sourcePath ? { sourcePath: args.sourcePath } : {}),
+        ptyStatusApprovalOnly: args.ptyStatusApprovalOnly === true,
+        staleness: {
+            sourceMtimeMs: sourceMtimeMs || undefined,
+            sourceMtimeAgeMs,
+            nativeNewestMessageAt: getMessageNewestReceivedAt(nativeMessages),
+            ptyNewestMessageAt: getMessageNewestReceivedAt(ptyMessages),
+            freshEnough: args.freshEnough === true,
+        },
+        coverage: {
+            nativeMessageCount: nativeMessages.length,
+            ptyMessageCount: ptyMessages.length,
+            returnedMessageCount: returnedMessages.length,
+            safeMapping: args.safeMapping === true,
+        },
+    };
+}
+
+function buildNativeHistoryFallbackReason(args: {
+    providerType: string;
+    nativeSource?: string;
+    nativeMessageCount: number;
+    safeMapping: boolean;
+    freshEnough: boolean;
+}): string {
+    if (args.providerType !== 'codex-cli') return 'provider_not_codex_cli';
+    if (args.nativeSource === 'native-unavailable') return 'native_history_unavailable';
+    if (args.nativeSource && args.nativeSource !== 'provider-native') return `native_history_source_${args.nativeSource}`;
+    if (args.nativeMessageCount <= 0) return 'native_history_empty';
+    if (!args.safeMapping) return 'native_history_not_safely_mapped';
+    if (!args.freshEnough) return 'native_history_stale';
+    return 'native_history_not_selected';
+}
+
+function isCodexCliProvider(providerType: string): boolean {
+    return providerType === 'codex-cli';
+}
+
+function hasSafeNativeHistoryMapping(args: {
+    historySessionId?: string;
+    providerSessionId?: string;
+    workspace?: string;
+    nativeMessages: ChatMessage[];
+}): boolean {
+    const explicitSessionId = String(args.historySessionId || args.providerSessionId || '').trim();
+    if (explicitSessionId) {
+        const messageSessionIds = args.nativeMessages
+            .map((message: any) => typeof message?.historySessionId === 'string' ? message.historySessionId.trim() : '')
+            .filter(Boolean);
+        if (messageSessionIds.length === 0) return true;
+        return messageSessionIds.some((id) => id === explicitSessionId);
+    }
+    const workspace = String(args.workspace || '').trim();
+    if (!workspace) return false;
+    return args.nativeMessages.some((message: any) => String(message?.workspace || '').trim() === workspace);
+}
+
+function isNativeHistoryFreshEnough(args: {
+    sourceMtimeMs?: number;
+    nativeMessages: ChatMessage[];
+    ptyMessages: ChatMessage[];
+}): boolean {
+    const nativeNewest = getMessageNewestReceivedAt(args.nativeMessages);
+    const ptyNewest = getMessageNewestReceivedAt(args.ptyMessages);
+    if (nativeNewest > 0 && nativeNewest >= ptyNewest) return true;
+    const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
+    if (sourceMtimeMs > 0 && Date.now() - sourceMtimeMs <= CODEX_NATIVE_HISTORY_FRESH_MS) return true;
+    return ptyNewest === 0 && nativeNewest > 0;
+}
+
+function shouldPreserveReadChatPayloadField(key: string): boolean {
+    return key === 'messageSource' || key === 'transcriptProvenance';
+}
 
 function deriveHistoryDedupKey(message: ChatMessage & { _unitKey?: string; _turnKey?: string }): string | undefined {
     const unitKey = typeof message._unitKey === 'string' ? message._unitKey.trim() : '';
@@ -356,6 +465,7 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
     return {
         success: true,
         ...validatedPayload,
+        ...Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key))),
         messages: sync.messages,
         totalMessages: sync.totalMessages,
         ...(returnedDebugReadChat ? { debugReadChat: returnedDebugReadChat } : {}),
@@ -584,6 +694,8 @@ function buildChatDebugBundleSummary(bundle: Record<string, unknown>): Record<st
             adapterStatus: debugReadChat.adapterStatus,
             parsedStatus: debugReadChat.parsedStatus,
             returnedStatus: debugReadChat.returnedStatus,
+            selectedMessageSource: debugReadChat.selectedMessageSource,
+            messageSource: debugReadChat.messageSource,
             parsedMsgCount: debugReadChat.parsedMsgCount,
             returnedMsgCount: debugReadChat.returnedMsgCount,
             shouldPreferAdapterMessages: debugReadChat.shouldPreferAdapterMessages,
@@ -646,6 +758,8 @@ export async function handleGetChatDebugBundle(h: CommandHelpers, args: any): Pr
                 providerSessionId: readResult.providerSessionId,
                 transcriptAuthority: readResult.transcriptAuthority,
                 coverage: readResult.coverage,
+                messageSource: readResult.messageSource,
+                transcriptProvenance: readResult.transcriptProvenance,
                 activeModal: readResult.activeModal,
                 messagesTail: Array.isArray(readResult.messages) ? readResult.messages.slice(-20) : [],
                 debugReadChat: readResult.debugReadChat,
@@ -882,25 +996,146 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 && typeof runtimeMessageMerger.mergeRuntimeChatMessages === 'function'
                 ? runtimeMessageMerger.mergeRuntimeChatMessages(parsedMessages)
                 : parsedMessages;
+            const providerType = provider?.type || adapter.cliType;
+            let selectedMessages = returnedMessages;
+            let selectedTitle = title;
+            let selectedProviderSessionId = providerSessionId;
+            let selectedTranscriptAuthority = transcriptAuthority;
+            let selectedCoverage = coverage;
+            let messageSource = buildCliMessageSourceProvenance({
+                selected: 'pty-parser',
+                provider: adapter.cliType,
+                fallbackReason: isCodexCliProvider(providerType) ? 'native_history_not_checked' : 'provider_not_codex_cli',
+                ptyMessages: returnedMessages,
+                returnedMessages,
+                ptyStatusApprovalOnly: false,
+            });
+
+            if (isCodexCliProvider(providerType)) {
+                const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
+                const workspace = typeof args?.workspace === 'string'
+                    ? args.workspace
+                    : typeof (h.currentSession as any)?.workspace === 'string'
+                        ? (h.currentSession as any).workspace
+                        : typeof adapter.workingDir === 'string'
+                            ? adapter.workingDir
+                            : undefined;
+                const nativeHistoryLimit = Math.max(
+                    normalizeReadChatTailLimit(args) || 0,
+                    returnedMessages.length,
+                    200,
+                );
+                let nativeHistory: ReturnType<typeof readProviderChatHistory> | null = null;
+                try {
+                    nativeHistory = readProviderChatHistory(agentStr, {
+                        canonicalHistory: provider?.canonicalHistory,
+                        historySessionId,
+                        workspace,
+                        offset: 0,
+                        limit: nativeHistoryLimit,
+                        excludeRecentCount: 0,
+                        historyBehavior: provider?.historyBehavior,
+                        scripts: provider?.scripts as any,
+                    });
+                } catch (error: any) {
+                    const fallbackReason = `native_history_error:${error?.message || String(error)}`;
+                    messageSource = buildCliMessageSourceProvenance({
+                        selected: 'pty-parser',
+                        provider: adapter.cliType,
+                        fallbackReason,
+                        ptyMessages: returnedMessages,
+                        returnedMessages,
+                        ptyStatusApprovalOnly: false,
+                    });
+                    nativeHistory = null;
+                }
+
+                if (nativeHistory) {
+                    const nativeMessages = Array.isArray((nativeHistory as any).messages)
+                        ? normalizeChatMessages((nativeHistory as any).messages as ChatMessage[])
+                        : [];
+                    const historyProviderSessionId = typeof (nativeHistory as any)?.providerSessionId === 'string'
+                        ? (nativeHistory as any).providerSessionId
+                        : historySessionId;
+                    const safeMapping = hasSafeNativeHistoryMapping({
+                        historySessionId,
+                        providerSessionId,
+                        workspace,
+                        nativeMessages,
+                    });
+                    const freshEnough = isNativeHistoryFreshEnough({
+                        sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                        nativeMessages,
+                        ptyMessages: returnedMessages,
+                    });
+                    if ((nativeHistory as any).source === 'provider-native' && nativeMessages.length > 0 && safeMapping && freshEnough) {
+                        selectedMessages = finalizeStreamingMessagesWhenIdle(nativeMessages, returnedStatus);
+                        selectedProviderSessionId = historyProviderSessionId || providerSessionId;
+                        selectedTranscriptAuthority = 'provider';
+                        selectedCoverage = (nativeHistory as any).hasMore ? 'tail' : 'full';
+                        messageSource = buildCliMessageSourceProvenance({
+                            selected: 'native-history',
+                            provider: adapter.cliType,
+                            nativeHandle: selectedProviderSessionId || historySessionId,
+                            nativeSource: (nativeHistory as any).source,
+                            sourcePath: (nativeHistory as any).sourcePath,
+                            sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                            nativeMessages,
+                            ptyMessages: returnedMessages,
+                            returnedMessages: selectedMessages,
+                            safeMapping,
+                            freshEnough,
+                            ptyStatusApprovalOnly: true,
+                        });
+                    } else {
+                        const fallbackReason = buildNativeHistoryFallbackReason({
+                            providerType,
+                            nativeSource: (nativeHistory as any).source,
+                            nativeMessageCount: nativeMessages.length,
+                            safeMapping,
+                            freshEnough,
+                        });
+                        messageSource = buildCliMessageSourceProvenance({
+                            selected: 'pty-parser',
+                            provider: adapter.cliType,
+                            nativeHandle: historyProviderSessionId || historySessionId,
+                            fallbackReason,
+                            nativeSource: (nativeHistory as any).source,
+                            sourcePath: (nativeHistory as any).sourcePath,
+                            sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                            nativeMessages,
+                            ptyMessages: returnedMessages,
+                            returnedMessages,
+                            safeMapping,
+                            freshEnough,
+                            ptyStatusApprovalOnly: false,
+                        });
+                    }
+                }
+            }
             LOG.debug('Command', `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || '')} adapterStatus=${String(adapterStatus.status || '')} parsedStatus=${String(parsedRecord.status || '')} parsedMsgCount=${parsedRecord.messages.length} returnedMsgCount=${returnedMessages.length}`);
             return buildReadChatCommandResult({
-                messages: returnedMessages,
+                messages: selectedMessages,
                 status: returnedStatus,
                 activeModal,
+                messageSource,
+                transcriptProvenance: messageSource,
                 debugReadChat: {
                     provider: adapter.cliType,
                     targetSessionId: String(args?.targetSessionId || ''),
                     adapterStatus: String(adapterStatus.status || ''),
                     parsedStatus: String(parsedRecord.status || ''),
                     returnedStatus: String(returnedStatus || ''),
-                    shouldPreferAdapterMessages: false,
+                    selectedMessageSource: (messageSource as any).selected,
+                    messageSource,
+                    shouldPreferAdapterMessages: (messageSource as any).selected !== 'native-history',
                     parsedMsgCount: parsedRecord.messages.length,
-                    returnedMsgCount: returnedMessages.length,
+                    returnedMsgCount: selectedMessages.length,
                 },
-                ...(title ? { title } : {}),
-                ...(providerSessionId ? { providerSessionId } : {}),
-                ...(transcriptAuthority ? { transcriptAuthority } : {}),
-                ...(coverage ? { coverage } : {}),
+                ...(selectedTitle ? { title: selectedTitle } : {}),
+                ...(selectedProviderSessionId ? { providerSessionId: selectedProviderSessionId } : {}),
+                ...(selectedTranscriptAuthority ? { transcriptAuthority: selectedTranscriptAuthority } : {}),
+                ...(selectedCoverage ? { coverage: selectedCoverage } : {}),
             }, args);
         }
         const historyLimit = normalizeReadChatTailLimit(args);

package/src/commands/cli-manager.ts

@@ -80,6 +80,12 @@ export interface CliManagerDeps {
 
 type CommandResult = { success: boolean;[key: string]: unknown };
 
+const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'long_generating']);
+
+function normalizeAgentStatus(value: unknown): string {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
 export interface CliTransportFactoryParams {
     runtimeId: string;
     providerType: string;
@@ -1073,6 +1079,19 @@ export class DaemonCliManager {
                 const { adapter, key } = found;
 
                 if (action === 'send_chat') {
+                    const currentStatus = normalizeAgentStatus(adapter.getStatus?.()?.status);
+                    if (BUSY_AGENT_STATUSES.has(currentStatus)) {
+                        return {
+                            success: false,
+                            code: 'agent_runtime_busy',
+                            reason: 'agent_runtime_busy',
+                            retryable: true,
+                            retryRecommended: true,
+                            status: currentStatus,
+                            targetSessionId: args?.targetSessionId,
+                            error: `CLI agent '${agentType}' is currently ${currentStatus}; retry after the current turn finishes.`,
+                        };
+                    }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
                     if (provider?.category === 'acp') {

package/src/commands/router.ts

@@ -55,7 +55,7 @@ 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 } from 'os';
+import { homedir, tmpdir } from 'os';
 import { join as pathJoin, resolve as pathResolve } from 'path';
 import * as fs from 'fs';
 
@@ -1089,7 +1089,12 @@ type MeshRefineSubmoduleReachabilityEntry = {
     path: string;
     commit: string;
     reachable: boolean;
+    publishRequired?: boolean;
     checkedLocal?: boolean;
+    localReachable?: boolean;
+    remote?: string;
+    remoteUrl?: string;
+    remoteReachable?: boolean;
     fetchedFromOrigin?: boolean;
     error?: string;
 };
@@ -1161,6 +1166,13 @@ function recordMeshRefineStage(
     });
 }
 
+function buildSubmodulePublishRequiredNextStep(entries: MeshRefineSubmoduleReachabilityEntry[]): string {
+    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.`;
+}
+
 async function computeGitPatchId(cwd: string, fromRef: string, toRef: string): Promise<string> {
     const { execFileSync } = await import('node:child_process');
     const diff = execFileSync('git', ['diff', '--patch', '--full-index', fromRef, toRef], {
@@ -1255,6 +1267,16 @@ 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 treeOutput = await runGit(repoRoot, ['ls-tree', '-r', '-z', mergedTree]);
         const gitlinks = treeOutput
@@ -1276,6 +1298,7 @@ async function runMeshRefineSubmoduleReachabilityGate(
             try {
                 if (!fs.existsSync(submodulePath)) {
                     entry.error = `Submodule checkout missing at ${gitlink.path}`;
+                    entry.publishRequired = true;
                     entries.push(entry);
                     continue;
                 }
@@ -1283,23 +1306,38 @@ async function runMeshRefineSubmoduleReachabilityGate(
                 entry.checkedLocal = true;
                 try {
                     await runGit(submodulePath, ['cat-file', '-e', `${gitlink.commit}^{commit}`]);
-                    entry.reachable = true;
-                    entries.push(entry);
-                    continue;
+                    entry.localReachable = true;
                 } catch {
+                    entry.localReachable = false;
                     // Probe the submodule remote before allowing cleanup/completion.
                 }
 
                 try {
-                    await runGit(submodulePath, ['fetch', 'origin', gitlink.commit]);
+                    entry.remote = 'origin';
+                    let remoteUrl = '';
+                    try {
+                        remoteUrl = (await runGit(submodulePath, ['remote', 'get-url', 'origin'])).trim();
+                        if (!remoteUrl) throw new Error('origin remote has no URL');
+                        entry.remoteUrl = remoteUrl;
+                    } catch {
+                        entry.error = 'Submodule remote reachability check failed: no configured origin remote';
+                        entry.publishRequired = true;
+                        entries.push(entry);
+                        continue;
+                    }
+                    await verifyRemoteCommitReachable(remoteUrl, gitlink.commit);
                     entry.fetchedFromOrigin = true;
-                    await runGit(submodulePath, ['cat-file', '-e', `${gitlink.commit}^{commit}`]);
+                    entry.remoteReachable = true;
                     entry.reachable = true;
                 } catch (e: any) {
-                    entry.error = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                    entry.remoteReachable = false;
+                    entry.publishRequired = true;
+                    const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                    entry.error = `Submodule remote reachability check failed for origin: ${details}`;
                 }
             } catch (e: any) {
                 entry.error = truncateValidationOutput(e?.message || String(e));
+                entry.publishRequired = true;
             }
             entries.push(entry);
         }
@@ -1308,16 +1346,17 @@ async function runMeshRefineSubmoduleReachabilityGate(
         return {
             status: unreachable.length ? 'failed' : 'passed',
             checked: entries.length,
-            unreachable,
-            entries,
+            unreachable: unreachable.map(entry => ({ ...entry, publishRequired: entry.publishRequired !== false })),
+            entries: entries.map(entry => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
             durationMs: Date.now() - startedAt,
         };
     } catch (e: any) {
+        const unreachable = entries.filter(entry => !entry.reachable).map(entry => ({ ...entry, publishRequired: true }));
         return {
             status: 'failed',
             checked: entries.length,
-            unreachable: entries.filter(entry => !entry.reachable),
-            entries,
+            unreachable,
+            entries: entries.map(entry => entry.reachable ? entry : { ...entry, publishRequired: true }),
             durationMs: Date.now() - startedAt,
             error: truncateValidationOutput(e?.message || String(e)),
         };
@@ -2679,15 +2718,41 @@ export class DaemonCommandRouter {
             const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
             recordMeshRefineStage(refineStages, 'submodule_reachability', submoduleReachability.status, submoduleReachabilityStarted, {
                 checked: submoduleReachability.checked,
-                unreachable: submoduleReachability.unreachable.map(entry => ({ path: entry.path, commit: entry.commit, error: entry.error })),
+                unreachable: submoduleReachability.unreachable.map(entry => ({
+                    path: entry.path,
+                    commit: entry.commit,
+                    publishRequired: entry.publishRequired === true,
+                    remote: entry.remote,
+                    remoteUrl: entry.remoteUrl,
+                    remoteReachable: entry.remoteReachable,
+                    error: entry.error,
+                })),
                 error: submoduleReachability.error,
             });
             if (submoduleReachability.status === 'failed') {
+                const nextStep = buildSubmodulePublishRequiredNextStep(submoduleReachability.unreachable);
                 return {
                     success: false,
                     code: 'submodule_reachability_failed',
                     convergenceStatus: 'blocked_review',
-                    error: 'Refinery submodule reachability preflight failed; merge/refine cleanup was not attempted.',
+                    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.',
+                    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.',
+                        '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.',
+                    ],
+                    unreachableSubmoduleCommits: submoduleReachability.unreachable.map(entry => ({
+                        path: entry.path,
+                        commit: entry.commit,
+                        remote: entry.remote,
+                        remoteUrl: entry.remoteUrl,
+                        remoteReachable: entry.remoteReachable,
+                        error: entry.error,
+                    })),
                     branch,
                     into: baseBranch,
                     validationSummary,
@@ -2703,6 +2768,8 @@ export class DaemonCommandRouter {
                 patchEquivalence: 'passed',
                 submoduleReachability: 'failed',
                 status: 'blocked_review',
+                reason: 'submodule_publish_required',
+                nextStep,
                     },
                 };
             }

package/src/mesh/coordinator-prompt.ts

@@ -165,7 +165,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. 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 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.
 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,5 +204,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\`.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }

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

@@ -891,7 +891,9 @@ export class CliProviderInstance implements ProviderInstance {
                 chatTitle: pending.chatTitle,
                 duration: pending.duration,
                 timestamp: pending.timestamp,
-                finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
+                finalSummary: blockReason.startsWith('parsed_status:')
+                    ? ''
+                    : extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
                 completionDiagnostic,
             });
             this.completedDebouncePending = null;