@adhdev/daemon-core 0.9.82-rc.81 → 0.9.82-rc.83

package/dist/mesh/refine-config.d.ts

@@ -12,6 +12,13 @@ export interface RepoMeshRefineValidationCommandConfig {
 }
 export interface RepoMeshRefineConfig {
     version: 1;
+    /**
+     * Narrow Refinery opt-in for monorepos with submodule gitlinks.
+     * When true, Refinery may non-force publish unreachable submodule gitlink
+     * commits to the submodule remote main branch after validation and
+     * patch-equivalence pass, then verify remote-main reachability.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     validation?: {
         required?: boolean;
         commands?: RepoMeshRefineValidationCommandConfig[];
@@ -54,6 +61,11 @@ export declare const MESH_REFINE_CONFIG_SCHEMA: {
         readonly version: {
             readonly const: 1;
         };
+        readonly allowAutoPublishSubmoduleMainCommits: {
+            readonly type: "boolean";
+            readonly default: false;
+            readonly description: "When true, Refinery may non-force publish submodule gitlink commits referenced by the refined root tree to each submodule origin/main after validation and patch-equivalence pass, then verify reachability.";
+        };
         readonly validation: {
             readonly type: "object";
             readonly additionalProperties: false;

package/dist/repo-mesh-types.d.ts

@@ -74,6 +74,13 @@ export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
     requireApprovalForPush: boolean;
+    /**
+     * Narrow Refinery opt-in: when validation and patch-equivalence have passed,
+     * allow Refinery to publish submodule gitlink commits to each submodule's
+     * configured remote main branch with a non-force push, then verify reachability.
+     * Defaults to false; root branch pushes/merges are not affected.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     requireApprovalForDestructiveGit: boolean;
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.81",
+  "version": "0.9.82-rc.83",
   "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

@@ -1035,7 +1035,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 ptyStatusApprovalOnly: false,
             });
 
-            if (supportsCliNativeTranscript(providerType)) {
+            if (supportsCliNativeTranscript(providerType) && (provider?.canonicalHistory as any)?.mode === 'native-source') {
                 const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
                 const workspace = typeof args?.workspace === 'string'
                     ? args.workspace
@@ -1220,6 +1220,18 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 freshEnough: true,
                 ptyStatusApprovalOnly: false,
             });
+            const requiresNativeSource = supportsCliNativeTranscript(agentStr)
+                && (provider?.canonicalHistory as any)?.mode === 'native-source';
+            if (requiresNativeSource && !nativeSelected) {
+                return {
+                    success: false,
+                    code: 'native_history_not_safely_available',
+                    error: 'Provider-native history was not safely available for the requested CLI session.',
+                    providerSessionId: historyProviderSessionId,
+                    messageSource,
+                    transcriptProvenance: messageSource,
+                };
+            }
             return buildReadChatCommandResult({
                 messages: historyMessages,
                 status: 'idle',

package/src/commands/cli-manager.ts

@@ -109,6 +109,15 @@ function countMessages(value: unknown): number {
     return Array.isArray(value) ? value.length : 0;
 }
 
+function hasFinalAssistantMessage(value: unknown): boolean {
+    const messages = Array.isArray(value) ? value : [];
+    const last = messages[messages.length - 1] as any;
+    if (!last || last.role !== 'assistant') return false;
+    if (last.bubbleState === 'streaming') return false;
+    if (last.meta?.streaming === true) return false;
+    return typeof last.content === 'string' && last.content.trim().length > 0;
+}
+
 function hasZeroMessageStartingLaunch(adapter: any): boolean {
     const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
     const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
@@ -123,6 +132,21 @@ function hasZeroMessageStartingLaunch(adapter: any): boolean {
     return !hasAdapterPendingResponse(adapter);
 }
 
+function hasCompletedStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (hasAdapterPendingResponse(adapter)) return false;
+
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (parsedRawStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return hasFinalAssistantMessage(parsedStatus?.messages);
+}
+
 function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
     const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
     if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
@@ -133,6 +157,7 @@ function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus
 
 function getEffectiveAgentSendStatus(adapter: any): string {
     const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+    if (adapterStatus === 'starting' && hasCompletedStartingLaunch(adapter)) return 'idle';
     if (adapterStatus && adapterStatus !== 'idle') return adapterStatus;
     if (adapterStatus !== 'idle') return adapterStatus;
 

package/src/commands/router.ts

@@ -1102,6 +1102,11 @@ type MeshRefineSubmoduleReachabilityEntry = {
     commit: string;
     reachable: boolean;
     publishRequired?: boolean;
+    autoPublishAllowed?: boolean;
+    autoPublishAttempted?: boolean;
+    autoPublishSucceeded?: boolean;
+    autoPublishVerified?: boolean;
+    autoPublishRefspec?: string;
     checkedLocal?: boolean;
     localReachable?: boolean;
     remote?: string;
@@ -1111,6 +1116,8 @@ type MeshRefineSubmoduleReachabilityEntry = {
     remoteMainReachable?: boolean;
     fetchedFromOrigin?: boolean;
     error?: string;
+    publishStdout?: string;
+    publishStderr?: string;
 };
 
 type MeshRefineSubmoduleReachabilitySummary = {
@@ -1119,6 +1126,8 @@ type MeshRefineSubmoduleReachabilitySummary = {
     unreachable: MeshRefineSubmoduleReachabilityEntry[];
     entries: MeshRefineSubmoduleReachabilityEntry[];
     durationMs: number;
+    autoPublishAllowed?: boolean;
+    autoPublishPolicySource?: string;
     error?: string;
 };
 
@@ -1187,6 +1196,17 @@ function buildSubmodulePublishRequiredNextStep(entries: MeshRefineSubmoduleReach
     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.`;
 }
 
+function resolveRefineryAutoPublishSubmoduleMainCommits(mesh: any, workspace: string): { enabled: boolean; source?: string } {
+    if (mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true) {
+        return { enabled: true, source: 'mesh.policy.allowAutoPublishSubmoduleMainCommits' };
+    }
+    const loaded = loadMeshRefineConfig(mesh, workspace);
+    if (loaded.config?.allowAutoPublishSubmoduleMainCommits === true) {
+        return { enabled: true, source: loaded.path || loaded.source };
+    }
+    return { enabled: false };
+}
+
 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], {
@@ -1264,6 +1284,7 @@ async function runMeshRefinePatchEquivalenceGate(
 async function runMeshRefineSubmoduleReachabilityGate(
     repoRoot: string,
     mergedTree: string,
+    options: { allowAutoPublishSubmoduleMainCommits?: boolean; autoPublishPolicySource?: string } = {},
 ): Promise<MeshRefineSubmoduleReachabilitySummary> {
     const startedAt = Date.now();
     const entries: MeshRefineSubmoduleReachabilityEntry[] = [];
@@ -1285,6 +1306,17 @@ async function runMeshRefineSubmoduleReachabilityGate(
             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 publishCommitToRemoteMain = async (submodulePath: string, commit: string, branch = 'main'): Promise<{ stdout: string; stderr: string; refspec: string }> => {
+            const refspec = `${commit}:refs/heads/${branch}`;
+            const { stdout, stderr } = await execFileAsync('git', ['push', 'origin', refspec], {
+                cwd: submodulePath,
+                encoding: 'utf8',
+                timeout: 30_000,
+                maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+                windowsHide: true,
+            });
+            return { stdout: String(stdout || ''), stderr: String(stderr || ''), refspec };
+        };
 
         const treeOutput = await runGit(repoRoot, ['ls-tree', '-r', '-z', mergedTree]);
         const gitlinks = treeOutput
@@ -1334,11 +1366,43 @@ async function runMeshRefineSubmoduleReachabilityGate(
                         continue;
                     }
                     entry.remoteMainBranch = 'main';
-                    await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, 'main');
-                    entry.fetchedFromOrigin = true;
-                    entry.remoteReachable = true;
-                    entry.remoteMainReachable = true;
-                    entry.reachable = true;
+                    try {
+                        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 main reachability check failed for origin/main: ${details}`;
+                        if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
+                            entry.autoPublishAllowed = true;
+                            entry.autoPublishAttempted = true;
+                            try {
+                                const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, 'main');
+                                entry.autoPublishRefspec = publish.refspec;
+                                entry.publishStdout = truncateValidationOutput(publish.stdout);
+                                entry.publishStderr = truncateValidationOutput(publish.stderr);
+                                entry.autoPublishSucceeded = true;
+                                await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, 'main');
+                                entry.fetchedFromOrigin = true;
+                                entry.remoteReachable = true;
+                                entry.remoteMainReachable = true;
+                                entry.autoPublishVerified = true;
+                                entry.publishRequired = false;
+                                entry.reachable = true;
+                                entry.error = undefined;
+                            } catch (publishError: any) {
+                                entry.autoPublishSucceeded = false;
+                                entry.autoPublishVerified = false;
+                                const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
+                                entry.error = `Submodule auto-publish to origin/main failed or could not be verified: ${publishDetails}`;
+                            }
+                        }
+                    }
                 } catch (e: any) {
                     entry.remoteReachable = false;
                     entry.remoteMainReachable = false;
@@ -1360,6 +1424,8 @@ async function runMeshRefineSubmoduleReachabilityGate(
             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,
+            autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+            autoPublishPolicySource: options.autoPublishPolicySource,
         };
     } catch (e: any) {
         const unreachable = entries.filter(entry => !entry.reachable).map(entry => ({ ...entry, publishRequired: true }));
@@ -1369,6 +1435,8 @@ async function runMeshRefineSubmoduleReachabilityGate(
             unreachable,
             entries: entries.map(entry => entry.reachable ? entry : { ...entry, publishRequired: true }),
             durationMs: Date.now() - startedAt,
+            autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+            autoPublishPolicySource: options.autoPublishPolicySource,
             error: truncateValidationOutput(e?.message || String(e)),
         };
     }
@@ -2753,13 +2821,38 @@ export class DaemonCommandRouter {
             }
 
             const submoduleReachabilityStarted = Date.now();
-            const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
+            const autoPublishSubmoduleMainCommits = resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace);
+            const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead, {
+                allowAutoPublishSubmoduleMainCommits: autoPublishSubmoduleMainCommits.enabled,
+                autoPublishPolicySource: autoPublishSubmoduleMainCommits.source,
+            });
             recordMeshRefineStage(refineStages, 'submodule_reachability', submoduleReachability.status, submoduleReachabilityStarted, {
                 checked: submoduleReachability.checked,
+                autoPublishAllowed: submoduleReachability.autoPublishAllowed,
+                autoPublishPolicySource: submoduleReachability.autoPublishPolicySource,
+                autoPublished: submoduleReachability.entries
+                    .filter(entry => entry.autoPublishAttempted)
+                    .map(entry => ({
+                        path: entry.path,
+                        commit: entry.commit,
+                        remote: entry.remote,
+                        remoteUrl: entry.remoteUrl,
+                        remoteMainBranch: entry.remoteMainBranch,
+                        refspec: entry.autoPublishRefspec,
+                        succeeded: entry.autoPublishSucceeded,
+                        verified: entry.autoPublishVerified,
+                        remoteMainReachable: entry.remoteMainReachable,
+                        error: entry.error,
+                    })),
                 unreachable: submoduleReachability.unreachable.map(entry => ({
                     path: entry.path,
                     commit: entry.commit,
                     publishRequired: entry.publishRequired === true,
+                    autoPublishAllowed: entry.autoPublishAllowed,
+                    autoPublishAttempted: entry.autoPublishAttempted,
+                    autoPublishSucceeded: entry.autoPublishSucceeded,
+                    autoPublishVerified: entry.autoPublishVerified,
+                    autoPublishRefspec: entry.autoPublishRefspec,
                     remote: entry.remote,
                     remoteUrl: entry.remoteUrl,
                     remoteReachable: entry.remoteReachable,
@@ -2793,6 +2886,11 @@ export class DaemonCommandRouter {
                         remoteReachable: entry.remoteReachable,
                         remoteMainBranch: entry.remoteMainBranch,
                         remoteMainReachable: entry.remoteMainReachable,
+                        autoPublishAllowed: entry.autoPublishAllowed,
+                        autoPublishAttempted: entry.autoPublishAttempted,
+                        autoPublishSucceeded: entry.autoPublishSucceeded,
+                        autoPublishVerified: entry.autoPublishVerified,
+                        autoPublishRefspec: entry.autoPublishRefspec,
                         error: entry.error,
                     })),
                     branch,
@@ -2870,7 +2968,7 @@ export class DaemonCommandRouter {
                 appendLedgerEntry(meshId, {
                     kind: 'node_removed',
                     nodeId,
-                    payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence },
+                    payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability },
                 });
                 recordMeshRefineStage(refineStages, 'ledger', 'passed', ledgerStarted);
             } catch (e: any) {
@@ -2900,6 +2998,7 @@ export class DaemonCommandRouter {
                     removeResult,
                     validationSummary,
                     patchEquivalence,
+                    submoduleReachability,
                     mergeResult,
                     refineStages,
                     ...(ledgerError ? { ledgerError } : {}),
@@ -2915,6 +3014,7 @@ export class DaemonCommandRouter {
                 removeResult,
                 validationSummary,
                 patchEquivalence,
+                submoduleReachability,
                 mergeResult,
                 refineStages,
                 ...(ledgerError ? { ledgerError } : {}),

package/src/config/mesh-config.ts

@@ -87,6 +87,7 @@ function mergeMeshPolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMe
     }
     const maxParallelTasks = Number(policy.maxParallelTasks);
     policy.maxParallelTasks = Number.isFinite(maxParallelTasks) ? Math.max(1, Math.min(8, Math.floor(maxParallelTasks))) : 2;
+    policy.allowAutoPublishSubmoduleMainCommits = policy.allowAutoPublishSubmoduleMainCommits === true;
     if (!SESSION_CLEANUP_MODES.has(String(policy.sessionCleanupOnNodeRemove))) {
         policy.sessionCleanupOnNodeRemove = 'preserve';
     }

package/src/mesh/coordinator-prompt.ts

@@ -127,6 +127,9 @@ function buildPolicySection(policy: RepoMeshPolicy): string {
     if (policy.requirePreTaskCheckpoint) rules.push('- Create a git checkpoint **before** starting each task');
     if (policy.requirePostTaskCheckpoint) rules.push('- Create a git checkpoint **after** each task completes');
     if (policy.requireApprovalForPush) rules.push('- **Ask for user approval** before pushing to remote');
+    if (policy.allowAutoPublishSubmoduleMainCommits) {
+        rules.push('- Refinery may auto-publish unreachable submodule gitlink commits to submodule origin/main with non-force pushes after validation and patch-equivalence pass');
+    }
     if (policy.requireApprovalForDestructiveGit) rules.push('- **Ask for user approval** before destructive git operations (force push, reset, etc.)');
 
     const dirtyBehavior = {
@@ -182,7 +185,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 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.
+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\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, 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.
 
@@ -221,6 +224,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 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\`.
+- **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\`, unless the mesh or repo refine config explicitly enabled \`allowAutoPublishSubmoduleMainCommits\` and Refinery reports exact path/commit/remote/branch evidence with post-publish verification.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }

package/src/mesh/mesh-events.ts

@@ -914,7 +914,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const providerSessionId = readNonEmptyString(args.metadataEvent.providerSessionId) || undefined;
         const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
         const workerResult = readWorkerResultMetadata(args.metadataEvent);
-        const completedTask = sessionId
+        const hasCompletionEvidence = !!finalSummary || !!workerResult;
+        const completedTask = sessionId && hasCompletionEvidence
             ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
             : null;
         if (completedTask) {

package/src/mesh/refine-config.ts

@@ -18,6 +18,13 @@ export interface RepoMeshRefineValidationCommandConfig {
 
 export interface RepoMeshRefineConfig {
     version: 1;
+    /**
+     * Narrow Refinery opt-in for monorepos with submodule gitlinks.
+     * When true, Refinery may non-force publish unreachable submodule gitlink
+     * commits to the submodule remote main branch after validation and
+     * patch-equivalence pass, then verify remote-main reachability.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     validation?: {
         required?: boolean;
         commands?: RepoMeshRefineValidationCommandConfig[];
@@ -73,6 +80,11 @@ export const MESH_REFINE_CONFIG_SCHEMA = {
     required: ['version'],
     properties: {
         version: { const: 1 },
+        allowAutoPublishSubmoduleMainCommits: {
+            type: 'boolean',
+            default: false,
+            description: 'When true, Refinery may non-force publish submodule gitlink commits referenced by the refined root tree to each submodule origin/main after validation and patch-equivalence pass, then verify reachability.',
+        },
         validation: {
             type: 'object',
             additionalProperties: false,
@@ -179,6 +191,9 @@ export function validateMeshRefineConfig(config: unknown, source = 'inline'): {
 
     if (!isRecord(config)) return { valid: false, errors: ['config must be an object'], commands, rejectedCommands };
     if (config.version !== 1) errors.push('version must be 1');
+    if (config.allowAutoPublishSubmoduleMainCommits !== undefined && typeof config.allowAutoPublishSubmoduleMainCommits !== 'boolean') {
+        errors.push('allowAutoPublishSubmoduleMainCommits must be a boolean when provided');
+    }
     const validation = config.validation;
     if (validation !== undefined && !isRecord(validation)) errors.push('validation must be an object');
     const rawCommands = isRecord(validation) ? validation.commands : undefined;

package/src/repo-mesh-types.ts

@@ -94,6 +94,13 @@ export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
     requireApprovalForPush: boolean;
+    /**
+     * Narrow Refinery opt-in: when validation and patch-equivalence have passed,
+     * allow Refinery to publish submodule gitlink commits to each submodule's
+     * configured remote main branch with a non-force push, then verify reachability.
+     * Defaults to false; root branch pushes/merges are not affected.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     requireApprovalForDestructiveGit: boolean;
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
@@ -158,6 +165,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requirePreTaskCheckpoint: false,
     requirePostTaskCheckpoint: true,
     requireApprovalForPush: true,
+    allowAutoPublishSubmoduleMainCommits: false,
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,