@adhdev/daemon-core 0.9.82-rc.373 → 0.9.82-rc.375

package/dist/mesh/coordinator-prompt.d.ts

@@ -21,6 +21,47 @@
  * a static prompt, which is also fine.
  */
 import type { LocalMeshEntry, RepoMeshStatus } from '../repo-mesh-types.js';
+/**
+ * Cheap, locally-derived "what just happened" snapshot for the coordinator
+ * prompt. Built at launch from the local ledger + work-queue stats — no remote
+ * peer probe. Surfaces the gap a fresh coordinator otherwise misses: it can't
+ * see recent failures / queue depth until it manually calls mesh_task_history.
+ *
+ * All fields are optional so callers that have nothing to report (or fail to
+ * read the ledger) simply omit the section — the prompt output stays identical
+ * to the pre-activity form in that case.
+ */
+export interface CoordinatorRecentActivity {
+    /** task_failed entries from the recent window, newest last. */
+    recentFailures?: Array<{
+        timestamp?: string;
+        nodeId?: string;
+        /** Short task title/message, already truncated by the caller. */
+        summary?: string;
+    }>;
+    /** Count of task_failed entries inside the recent (30-min) window. */
+    recentFailureCount?: number;
+    /** Pending (unclaimed) tasks in the work queue. */
+    pendingTasks?: number;
+    /** Assigned-but-not-yet-terminal tasks in the work queue. */
+    assignedTasks?: number;
+    /** Stalled tasks recorded in the ledger. */
+    stalledTasks?: number;
+    /** ISO timestamp of the most recent ledger activity, if any. */
+    lastActivityAt?: string | null;
+}
+/**
+ * One coordinator operating note — a runtime-accumulated lesson (provider
+ * quirk, pattern to avoid, recovery lesson) persisted in the ledger so it
+ * survives coordinator restarts and is provider-neutral (visible to codex /
+ * hermes / antigravity coordinators, not just Claude's memory).
+ */
+export interface CoordinatorOperatingNote {
+    text: string;
+    category?: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson';
+    createdAt?: string;
+    sourceCoordinator?: string;
+}
 export interface CoordinatorPromptContext {
     mesh: LocalMeshEntry;
     status?: RepoMeshStatus;
@@ -32,6 +73,18 @@ export interface CoordinatorPromptContext {
      * stays identical to the pre-M3 form in that case.
      */
     missionSection?: string;
+    /**
+     * Gap1: recent ledger/queue activity surfaced so a freshly-launched
+     * coordinator sees recent failures + queue depth without first calling
+     * mesh_task_history. Omitted → no "## Recent Activity" section.
+     */
+    recentActivity?: CoordinatorRecentActivity;
+    /**
+     * Gap2-A: runtime-accumulated operating notes (provider-neutral lessons)
+     * read from the ledger at launch. Omitted/empty → no "## Operating Notes"
+     * section.
+     */
+    operatingNotes?: CoordinatorOperatingNote[];
 }
 /**
  * Compose the final coordinator prompt from four layers, in this precedence:

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

@@ -11,6 +11,18 @@ export declare function findRecentTerminalLedgerEvidence(args: {
 } | null;
 export declare function hasDispatchAfterTerminal(meshId: string, sessionId: string, terminalId: string): boolean;
 export declare function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId: string): boolean;
+export declare function findTerminalLedgerEvidenceForTask(args: {
+    meshId: string;
+    taskId?: string;
+    sessionId?: string;
+    nodeId?: string;
+    tail?: number;
+}): {
+    id: string;
+    kind: Extract<MeshLedgerKind, 'task_completed' | 'task_failed' | 'task_stalled'>;
+    payload: Record<string, unknown>;
+    timestamp: string;
+} | null;
 export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
     meshId: string;
     nodeId?: string;

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

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/providers/chat-message-normalization.d.ts

@@ -1,5 +1,5 @@
 import type { ChatMessage } from '../types.js';
-export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4000;
+export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16000;
 export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
 /**
  * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the

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

@@ -87,6 +87,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private runtimeMessages;
     private lastPersistedHistoryMessages;
     private lastAcknowledgedUserInputAt;
+    private recentUserInputAcks;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -168,6 +169,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     isModalParked(): boolean;
     onEvent(event: string, data?: any): void;
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
+    /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+    private pruneRecentUserInputAcks;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;

package/package.json

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

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -59,6 +59,71 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         try { return buildMissionPromptSection(id); } catch { return ''; }
                     };
 
+                    // Gap1: surface recent ledger/queue activity (recent failures +
+                    // queue depth) so a freshly-launched coordinator sees them
+                    // without first calling mesh_task_history. All cheap local reads
+                    // — no remote peer probe. Best-effort: a read failure just omits
+                    // the section, never blocks launch.
+                    const buildRecentActivityBestEffort = async (id: string) => {
+                        try {
+                            const { getLedgerSummary, readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
+                            const { getMeshQueueStats } = await import('../../mesh/mesh-work-queue.js');
+                            const summary = getLedgerSummary(id);
+                            const queue = getMeshQueueStats(id);
+                            const failureEntries = readLedgerEntries(id, { kind: ['task_failed'], tail: 5 });
+                            const recentFailures = failureEntries.map((e) => {
+                                const p = (e.payload || {}) as Record<string, unknown>;
+                                const raw = typeof p.taskSummary === 'string' ? p.taskSummary
+                                    : typeof p.message === 'string' ? p.message
+                                    : typeof p.error === 'string' ? p.error
+                                    : '';
+                                const summaryText = raw.length > 160 ? `${raw.slice(0, 160)}…` : raw;
+                                return {
+                                    timestamp: e.timestamp,
+                                    nodeId: e.nodeId,
+                                    summary: summaryText,
+                                };
+                            });
+                            return {
+                                recentFailures,
+                                recentFailureCount: summary.recentFailures,
+                                pendingTasks: queue.pending,
+                                assignedTasks: queue.assigned,
+                                stalledTasks: summary.taskStalled,
+                                lastActivityAt: summary.lastActivityAt,
+                            };
+                        } catch { return undefined; }
+                    };
+
+                    // Gap2-A: load accumulated operating notes (provider-neutral
+                    // lessons) from the ledger so they ride into the prompt. Newest
+                    // last; cap to the most recent 20 so the section stays lean.
+                    // Best-effort: a read failure just omits the section.
+                    const buildOperatingNotesBestEffort = async (id: string) => {
+                        try {
+                            const { readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
+                            const noteEntries = readLedgerEntries(id, { kind: ['coordinator_operating_note'], tail: 20 });
+                            const notes = noteEntries
+                                .map((e) => {
+                                    const p = (e.payload || {}) as Record<string, unknown>;
+                                    const text = typeof p.text === 'string' ? p.text.trim() : '';
+                                    if (!text) return null;
+                                    const category: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson' | undefined =
+                                        p.category === 'provider_quirk' || p.category === 'pattern_to_avoid' || p.category === 'recovery_lesson'
+                                            ? p.category
+                                            : undefined;
+                                    return {
+                                        text,
+                                        category,
+                                        createdAt: typeof p.createdAt === 'string' ? p.createdAt : e.timestamp,
+                                        sourceCoordinator: typeof p.sourceCoordinator === 'string' ? p.sourceCoordinator : undefined,
+                                    };
+                                })
+                                .filter((n): n is NonNullable<typeof n> => n !== null);
+                            return notes.length ? notes : undefined;
+                        } catch { return undefined; }
+                    };
+
                     // Support inline mesh data from cloud (bypasses local meshes.json lookup)
                     let mesh: any;
                     if (args?.inlineMesh && typeof args.inlineMesh === 'object') {
@@ -164,7 +229,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         // Build coordinator prompt first — fail closed on errors.
                         let cliCmdSystemPrompt = '';
                         try {
-                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id) });
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
                         } catch (error: any) {
                             const message = error?.message || String(error);
                             LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
@@ -382,7 +447,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                     // broken mesh state is visible instead of silently launching with weaker rules.
                     let systemPrompt = '';
                     try {
-                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id) });
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
                     } catch (error: any) {
                         const message = error?.message || String(error);
                         LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);

package/src/commands/med-family/cli-agent.ts

@@ -96,15 +96,22 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
                 } catch { /* best-effort — dispatch still proceeds without the stamp */ }
             }
         }
-        const agentResult = await ctx.deps.cliManager.handleCliCommand('agent_command', args);
-        // Bug C fix (part 2): when dispatching a task to a mesh node session, override
-        // the dispatch acknowledgement risk reason to 'bootstrap_still_running' when
-        // the target node's worktree bootstrap is still running. Informational only —
-        // dispatch is NOT blocked.
+        // Bug C fix / bootstrapPending dispatch gap: a task dispatched to a mesh node
+        // whose worktree bootstrap is STILL running must NOT be injected yet. Before this
+        // gate the dispatch proceeded and the prompt landed in the session's input buffer
+        // while the provider (e.g. claude CLI) was not yet ready to consume it — the inject
+        // was silently swallowed (the chat bubble showed the text but the session never
+        // transitioned to generating and never claimed the task). The prior code only
+        // ANNOTATED the already-completed dispatch with 'bootstrap_still_running' after the
+        // fact, which did not close the gap. Defer instead: refuse the inject with a
+        // recoverable signal so the coordinator re-sends once the node is ready (the
+        // confirmed "re-send to a ready session works" path), mirroring the queued-delivery
+        // contract for busy sessions. send_chat only — non-task actions still pass through.
         const meshCtx = args?.meshContext as Record<string, unknown> | undefined;
         const dispatchNodeId = readStringValue(meshCtx?.nodeId);
         const dispatchMeshId = readStringValue(meshCtx?.meshId);
-        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+        const isSendChat = args?.action === 'send_chat';
+        if (isSendChat && dispatchNodeId && dispatchMeshId) {
             try {
                 const { getMesh } = await import('../../config/mesh-config.js');
                 const meshObj = getMesh(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
@@ -114,16 +121,21 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
                 const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                 if (bootstrapStatus === 'running') {
                     return {
-                        success: true,
-                        ...agentResult,
-                        dispatchAcknowledgementRisk: true,
-                        dispatchAcknowledgementRiskReason: 'bootstrap_still_running',
-                        nextAction: 'Wait for worktree_bootstrap_complete event before dispatching work to this node.',
+                        success: false,
+                        recoverable: true,
+                        dispatched: false,
+                        code: 'mesh_node_bootstrap_pending',
+                        reason: 'bootstrap_still_running',
+                        nodeId: dispatchNodeId,
+                        meshId: dispatchMeshId,
+                        ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
+                        error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+                        nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
                     };
                 }
-            } catch { /* best-effort */ }
+            } catch { /* best-effort — if the bootstrap probe fails, fall through and dispatch */ }
         }
-        return agentResult;
+        return ctx.deps.cliManager.handleCliCommand('agent_command', args);
     },
 
     // ─── Logs ───

package/src/commands/med-family/fast-forward.ts

@@ -51,58 +51,90 @@ export const fastForwardHandlers: Record<string, MedFamilyHandler> = {
     },
 
     fast_forward_mesh_node: async (ctx: MedFamilyContext, args: any) => {
-        const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-        const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
-        let workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
-        let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
-            ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
-            : undefined;
-        let nodeDaemonId: string | undefined;
-        let allowAutoPublishSubmoduleMainCommits = false;
-        if (meshId && nodeId) {
-            // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
-            const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-            if (!workspace) {
-                workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+        // The whole handler is wrapped: the safety-gate evaluation (mesh resolution,
+        // git status/stash/submodule fan-out) can throw on some platforms — notably a
+        // win32 daemon whose git invocation parsing or slow submodule probe raises
+        // before fastForwardMeshNode's own guarded body runs. router.execute re-throws,
+        // so an escaping throw surfaces to the coordinator as an opaque
+        // "Daemon IPC command failed" instead of the structured blockingReasons result
+        // a mac node returns cleanly. Catch it and return the same blocked shape so the
+        // coordinator can read the reason and route, never an IPC crash. Mirrors the
+        // mesh_init handler's try-catch contract.
+        const workspaceForError = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+        const meshIdForError = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        const nodeIdForError = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+        try {
+            const meshId = meshIdForError;
+            const nodeId = nodeIdForError;
+            let workspace = workspaceForError;
+            let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
+                ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
+                : undefined;
+            let nodeDaemonId: string | undefined;
+            let allowAutoPublishSubmoduleMainCommits = false;
+            if (meshId && nodeId) {
+                // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
+                const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+                const mesh = meshRecord?.mesh;
+                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+                if (!workspace) {
+                    workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+                }
+                if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+                    submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
+                }
+                allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+                nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
             }
-            if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
-                submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
+            // If the target node belongs to a remote daemon, forward the command there.
+            // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
+            // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
+            const selfDaemonId = ctx.deps.statusInstanceId;
+            // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
+            // machine's core must be treated as local (not remote) so it is not forwarded /
+            // P2P self-dialed. Equivalent → local.
+            const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+            if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+                const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
+                    ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                    workspace,
+                    _meshDirectDispatch: true,
+                });
+                return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
             }
-            allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-            nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
-        }
-        // If the target node belongs to a remote daemon, forward the command there.
-        // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
-        // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
-        const selfDaemonId = ctx.deps.statusInstanceId;
-        // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
-        // machine's core must be treated as local (not remote) so it is not forwarded /
-        // P2P self-dialed. Equivalent → local.
-        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
-                ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+            const result = await (fastForwardMeshNode({
+                meshId: meshId || undefined,
+                nodeId: nodeId || undefined,
                 workspace,
-                _meshDirectDispatch: true,
-            });
-            return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+                branch: typeof args?.branch === 'string' ? args.branch : undefined,
+                execute: args?.execute === true,
+                dryRun: args?.dryRun === true,
+                updateSubmodules: args?.updateSubmodules === true,
+                submoduleIgnorePaths,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                pushSubmodules: args?.pushSubmodules === true,
+                allowAutoPublishSubmoduleMainCommits,
+            }) as Promise<unknown>);
+            return result as CommandRouterResult;
+        } catch (e: any) {
+            const errorMessage = e?.message || String(e);
+            return {
+                success: false,
+                code: 'fast_forward_safety_gate_error',
+                ...(meshIdForError ? { meshId: meshIdForError } : {}),
+                ...(nodeIdForError ? { nodeId: nodeIdForError } : {}),
+                workspace: workspaceForError,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                allowed: false,
+                willRun: false,
+                executed: false,
+                // Surface the throw as a blocking reason instead of an opaque IPC crash
+                // so the coordinator gets the same structured shape a clean node returns.
+                blockingReasons: ['fast_forward_safety_gate_error'],
+                operationError: errorMessage,
+                error: errorMessage,
+            } as CommandRouterResult;
         }
-        const result = await (fastForwardMeshNode({
-            meshId: meshId || undefined,
-            nodeId: nodeId || undefined,
-            workspace,
-            branch: typeof args?.branch === 'string' ? args.branch : undefined,
-            execute: args?.execute === true,
-            dryRun: args?.dryRun === true,
-            updateSubmodules: args?.updateSubmodules === true,
-            submoduleIgnorePaths,
-            mode: args?.mode === 'push' ? 'push' : 'merge',
-            pushSubmodules: args?.pushSubmodules === true,
-            allowAutoPublishSubmoduleMainCommits,
-        }) as Promise<unknown>);
-        return result as CommandRouterResult;
     },
 
     refine_mesh_node: async (ctx: MedFamilyContext, args: any) => {

package/src/commands/med-family/mesh-crud.ts

@@ -289,9 +289,19 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>) || '';
                 const selfDaemonId = ctx.deps.statusInstanceId || '';
                 const selfMachineId = (() => { try { return loadConfig().machineId || ''; } catch { return ''; } })();
+                // Identity match is form-safe: a daemon answers to the same machine
+                // under interchangeable id forms (bare `mach_X`, cloud `daemon_mach_X`,
+                // standalone `standalone_mach_X`). statusInstanceId/loadConfig().machineId
+                // and the node's stored daemonId/machineId frequently hold DIFFERENT forms
+                // of the same machine, so a raw `===` would miss the self-match and let the
+                // coordinator delete its own live base node (the very accident this guard
+                // exists to prevent). daemonIdsEquivalent collapses every form to its
+                // machine core before comparing, so a same-machine match is caught
+                // regardless of which form each side carries. This only widens matches
+                // (every raw-`===` hit still matches) — fail-open → fail-closed.
                 const isCoordinatorBaseNode =
-                    (!!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId))
-                    || (!!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId));
+                    (!!selfDaemonId && (daemonIdsEquivalent(nodeDaemonId, selfDaemonId) || daemonIdsEquivalent(nodeMachineId, selfDaemonId)))
+                    || (!!selfMachineId && (daemonIdsEquivalent(nodeDaemonId, selfMachineId) || daemonIdsEquivalent(nodeMachineId, selfMachineId)));
                 if (isCoordinatorBaseNode) {
                     return {
                         success: false,