@adhdev/daemon-core 0.9.82-rc.453 → 0.9.82-rc.455

package/dist/mesh/mesh-event-classify.d.ts

@@ -3,3 +3,5 @@ export declare const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind>;
 export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
 export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
 export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
+export declare const MESH_APPROVAL_EVENTS: ReadonlySet<string>;
+export declare function isMeshApprovalEvent(eventName: unknown): boolean;

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

@@ -324,10 +324,28 @@ export declare function updateSessionTaskStatus(meshId: string, sessionId: strin
  * Used by the completion event path to decide whether to wake the queue.
  */
 export declare function hasPendingDependents(meshId: string, taskId: string): boolean;
+/**
+ * M1: THE single dependency-gate predicate. A task is claimable from a
+ * dependency standpoint iff it carries no system block (`blockedReason`) AND
+ * every id in `dependsOn` has reached 'completed'.
+ *
+ * DEPENDSON-GATE-SYMMETRY: every scheduler surface that decides whether a
+ * pending task may run MUST route through this one predicate — the queue claim
+ * (claimNextQueueTask), the auto-launch candidate filter
+ * (maybeAutoLaunchOneQueueSession), and the cloud eager P2P push
+ * (enqueue-and-push). If any surface computes dependency readiness on its own,
+ * the gate goes asymmetric and a task blocked from the pull path can still be
+ * eager-pushed straight to an idle session, silently bypassing its
+ * prerequisites. The semantics here (all deps completed && !blocked) are the
+ * invariant — do not fork them.
+ */
+export declare function taskDependenciesSatisfied(entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>, statusById: Map<string, MeshTaskStatus | string>): boolean;
 /**
  * M1-4: view-time dependency state for a task — unmet dependency ids and
  * whether the task is currently claimable from a dependency standpoint.
- * Not stored (truth stays in task statuses).
+ * Not stored (truth stays in task statuses). The `dependenciesSatisfied` field
+ * is derived from {@link taskDependenciesSatisfied} so the view and the
+ * scheduler gates can never disagree.
  */
 export declare function describeTaskDependencyState(entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>, statusById: Map<string, MeshTaskStatus | string>): {
     waitingOn: string[];

package/dist/mesh/worktree-bootstrap-config.d.ts

@@ -38,6 +38,26 @@ export declare function isWorktreeBootstrapStaleRunning(node: {
     };
     workspace?: string;
 } | undefined, nowMs?: number): boolean;
+/**
+ * COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready / bootstrap-pending defer
+ * predicate. A task must NOT be injected into a worktree node whose bootstrap is still 'running'
+ * — the provider is not yet ready to consume input, so the inject lands in the input buffer and
+ * is silently swallowed (empty session). Both the remote dispatch guard (the router agent_command
+ * handler) and the local queue-claim gate (tryAssignQueueTask) route through THIS predicate so
+ * they agree on exactly when to defer. Returns true = defer. The stale-'running' backstop
+ * (isWorktreeBootstrapStaleRunning) is honored here too: a 'running' state far older than any real
+ * bootstrap whose worktree is git-clean is treated as silently complete (do NOT defer), so a node
+ * whose terminal stamp never reached this daemon is not stranded forever.
+ */
+export declare function shouldDeferDispatchForBootstrap(node: {
+    worktreeBootstrap?: {
+        status?: string;
+        startedAt?: string;
+        updatedAt?: string;
+        completedAt?: string;
+    };
+    workspace?: string;
+} | undefined, nowMs?: number): boolean;
 export interface WorktreeBootstrapConfigLoadResult {
     config?: RepoMeshWorktreeBootstrapConfig;
     source: string;

package/package.json

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

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

@@ -114,32 +114,35 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
         if (isSendChat && dispatchNodeId && dispatchMeshId) {
             try {
                 const { getMesh } = await import('../../config/mesh-config.js');
-                const meshObj = getMesh(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
+                // COMPLETION-PROPAGATION F6 (C1 SSOT): read the router's synchronous inline mesh
+                // cache FIRST, falling back to getMesh only when the inline view has nothing. The
+                // inline cache is the authoritative bootstrap-status source — markWorktreeBootstrapTerminalState
+                // stamps 'complete'/'failed' into it SYNCHRONOUSLY, then persists to local config
+                // (what getMesh reads) via a DETACHED async import chain that lags. Reading getMesh
+                // first therefore observed a stale 'running' and deferred a dispatch whose worktree
+                // was already bootstrapped — the stale-'running' defer this eliminates. Inline-first
+                // makes the freshest single source of truth win for both the running and terminal states.
+                const meshObj = ctx.getCachedInlineMesh(dispatchMeshId) ?? getMesh(dispatchMeshId);
                 const nodeObj = Array.isArray(meshObj?.nodes)
                     ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, dispatchNodeId))
                     : undefined;
-                const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                if (bootstrapStatus === 'running') {
-                    // Fix (3) safety net: a 'running' bootstrap far older than any real bootstrap whose
-                    // worktree is git-clean is almost certainly one whose terminal-state stamp never
-                    // reached this daemon — fall through and dispatch instead of deferring forever. The
-                    // conservative threshold + git-clean co-requirement keep a genuinely in-progress
-                    // bootstrap (which must still defer) gated.
-                    const { isWorktreeBootstrapStaleRunning } = await import('../../mesh/worktree-bootstrap-config.js');
-                    if (!isWorktreeBootstrapStaleRunning(nodeObj as any)) {
-                        return {
-                            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.',
-                        };
-                    }
+                // COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready/bootstrap-pending
+                // defer predicate (honors the stale-'running' git-clean backstop internally), reused
+                // by the local queue-claim gate too so remote and local dispatch agree on when to defer.
+                const { shouldDeferDispatchForBootstrap } = await import('../../mesh/worktree-bootstrap-config.js');
+                if (shouldDeferDispatchForBootstrap(nodeObj as any)) {
+                    return {
+                        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 — if the bootstrap probe fails, fall through and dispatch */ }
         }