@adhdev/daemon-core 0.9.82-rc.364 → 0.9.82-rc.366

package/src/config/mesh-config.ts

@@ -8,7 +8,8 @@
 
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { createHash, randomBytes, randomUUID } from 'crypto';
+import { randomBytes, randomUUID } from 'crypto';
+import { shortHash } from '../system/hash.js';
 import { getConfigDir } from './config.js';
 import type {
     LocalMeshConfig,
@@ -309,7 +310,7 @@ function normalizeManualHostAddress(hostAddress: string): string {
 }
 
 export function tokenIdForManualPairing(token: string): string {
-    return `tok_${createHash('sha256').update(token).digest('hex').slice(0, 16)}`;
+    return `tok_${shortHash(token)}`;
 }
 
 function normalizeTokenExpiry(value: unknown): string | undefined {

package/src/mesh/mesh-active-work.ts

@@ -208,6 +208,60 @@ function classifyDirectDispatch(params: {
     return { ledgerOnlyStaleReason, isFreshUnacknowledged };
 }
 
+/**
+ * Build a direct-dispatch MeshActiveWorkRecord from a `task_dispatched` ledger entry,
+ * matching it against the terminal ledger entries and live mesh nodes. Shared by the
+ * remote-ledger scan (inside the MeshRuntimeStore branch) and the full-ledger scan
+ * (standalone branch) — those two loops were previously byte-identical except for a
+ * single `dbTaskIds.has(taskId)` skip guard that stays in the caller. Returns the record
+ * plus `terminalRow` so the caller can route it into terminal/stale/active buckets.
+ */
+function buildLedgerDirectDispatchRecord(
+    dispatch: MeshLedgerEntry,
+    ctx: { terminals: MeshLedgerEntry[]; nodes: any[] | undefined; now: number },
+): { record: MeshActiveWorkRecord; terminalRow: boolean } {
+    const taskId = directDispatchTaskId(dispatch);
+    const terminal = ctx.terminals
+        .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
+        .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
+    const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
+    const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
+    const status = terminalStatus || live.status || 'assigned';
+    const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
+    const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: terminalRow,
+        hasTerminalStatus: Boolean(terminalStatus),
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true,
+    });
+    const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
+    const { title, summary } = summarizeMessage(message);
+    const record: MeshActiveWorkRecord = {
+        taskId,
+        source: 'direct',
+        status,
+        nodeId: dispatch.nodeId,
+        sessionId: dispatch.sessionId,
+        providerType: dispatch.providerType || readString(dispatch.payload?.providerType),
+        taskTitle: readString(dispatch.payload?.taskTitle) || title,
+        taskSummary: readString(dispatch.payload?.taskSummary) || summary,
+        message,
+        taskMode: readString(dispatch.payload?.taskMode),
+        createdAt: dispatch.timestamp,
+        updatedAt: terminal?.timestamp || dispatch.timestamp,
+        dispatchedAt: dispatch.timestamp,
+        elapsedMs: elapsedSince(dispatch.timestamp, ctx.now),
+        terminal: terminalRow,
+        terminalKind: terminal?.kind,
+        terminalAt: terminal?.timestamp,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...(isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}),
+    };
+    return { record, terminalRow };
+}
+
 export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary {
     const statusCounts: Record<MeshActiveWorkStatus, number> = {
         pending: 0,
@@ -324,51 +378,13 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter(entry => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === 'task_approval_needed');
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-            const taskId = directDispatchTaskId(dispatch);
-            if (dbTaskIds.has(taskId)) continue; // already covered by MeshRuntimeStore path above
-            const terminal = terminals
-                .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
-                .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
-            const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
-            const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-            const status = terminalStatus || live.status || 'assigned';
-            const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
-            const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-                status,
-                isTerminalRow: terminalRow,
-                hasTerminalStatus: Boolean(terminalStatus),
-                liveStatus: live.status,
-                liveStaleReason: live.staleReason,
-                dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true,
-            });
-            const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
-            const { title, summary } = summarizeMessage(message);
-            const record: MeshActiveWorkRecord = {
-                taskId,
-                source: 'direct',
-                status,
-                nodeId: dispatch.nodeId,
-                sessionId: dispatch.sessionId,
-                providerType: dispatch.providerType || readString(dispatch.payload?.providerType),
-                taskTitle: readString(dispatch.payload?.taskTitle) || title,
-                taskSummary: readString(dispatch.payload?.taskSummary) || summary,
-                message,
-                taskMode: readString(dispatch.payload?.taskMode),
-                createdAt: dispatch.timestamp,
-                updatedAt: terminal?.timestamp || dispatch.timestamp,
-                dispatchedAt: dispatch.timestamp,
-                elapsedMs: elapsedSince(dispatch.timestamp, now),
-                terminal: terminalRow,
-                terminalKind: terminal?.kind,
-                terminalAt: terminal?.timestamp,
-                staleReason: live.staleReason || ledgerOnlyStaleReason,
-                ...(isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}),
-            };
+            if (dbTaskIds.has(directDispatchTaskId(dispatch))) continue; // already covered by MeshRuntimeStore path above
+            const { record, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
             if (terminalRow) {
                 terminalDirectWork.push(record);
                 if (opts.includeTerminalDirect !== true) continue;
             }
-            if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+            if (record.staleReason && !terminalRow) {
                 staleDirectWork.push(record);
                 continue;
             }
@@ -379,50 +395,12 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter(entry => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === 'task_approval_needed');
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-            const taskId = directDispatchTaskId(dispatch);
-            const terminal = terminals
-                .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
-                .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
-            const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
-            const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-            const status = terminalStatus || live.status || 'assigned';
-            const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
-            const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-                status,
-                isTerminalRow: terminalRow,
-                hasTerminalStatus: Boolean(terminalStatus),
-                liveStatus: live.status,
-                liveStaleReason: live.staleReason,
-                dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true,
-            });
-            const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
-            const { title, summary } = summarizeMessage(message);
-            const record: MeshActiveWorkRecord = {
-                taskId,
-                source: 'direct',
-                status,
-                nodeId: dispatch.nodeId,
-                sessionId: dispatch.sessionId,
-                providerType: dispatch.providerType || readString(dispatch.payload?.providerType),
-                taskTitle: readString(dispatch.payload?.taskTitle) || title,
-                taskSummary: readString(dispatch.payload?.taskSummary) || summary,
-                message,
-                taskMode: readString(dispatch.payload?.taskMode),
-                createdAt: dispatch.timestamp,
-                updatedAt: terminal?.timestamp || dispatch.timestamp,
-                dispatchedAt: dispatch.timestamp,
-                elapsedMs: elapsedSince(dispatch.timestamp, now),
-                terminal: terminalRow,
-                terminalKind: terminal?.kind,
-                terminalAt: terminal?.timestamp,
-                staleReason: live.staleReason || ledgerOnlyStaleReason,
-                ...(isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}),
-            };
+            const { record, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
             if (terminalRow) {
                 terminalDirectWork.push(record);
                 if (opts.includeTerminalDirect !== true) continue;
             }
-            if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+            if (record.staleReason && !terminalRow) {
                 staleDirectWork.push(record);
                 continue;
             }

package/src/mesh/mesh-events-coordinator.ts

@@ -1325,6 +1325,14 @@ export interface MeshQueueTriggerResult {
         status?: string;
     }>;
     autoLaunchStarted: boolean;
+    /**
+     * True when a worker session is already on its way to claim a still-pending task —
+     * either launched this tick (autoLaunchStarted) or launched on a prior tick and still
+     * booting/awaiting-claim. Callers MUST treat this as "wait, do not launch another
+     * session": a second launch double-edits the worktree. Mutually informative with
+     * `noIdleMeshSessionAvailable`, which is suppressed whenever this is true.
+     */
+    autoLaunchPending?: boolean;
     noIdleMeshSessionAvailable?: boolean;
 }
 
@@ -1485,6 +1493,28 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
             nodeId: task.assignedNodeId,
             sessionId: task.assignedSessionId,
         }));
+
+    // An auto-launch is "pending" when the coordinator has already spun a session up
+    // for a still-pending task and is waiting on that session's idle→claim. This covers
+    // two ticks:
+    //   - THIS tick fired the launch (autoLaunchStarted), or
+    //   - a PRIOR tick launched a session that is still booting/awaiting-claim — the
+    //     per-task await-claim guard (maybeAutoLaunchOneQueueSession) deliberately
+    //     declines to launch again, so autoLaunchStarted is false even though a session
+    //     is on its way to claim this task.
+    // Without this signal, the second tick reports `noIdleMeshSessionAvailable` and the
+    // MCP guidance tells the coordinator to launch ANOTHER worker — producing a duplicate
+    // session that double-edits the worktree. The claim itself is fine; only the wording
+    // was wrong, so we surface `autoLaunchPending` to suppress the bad "launch one more"
+    // advice while the just-launched session converges.
+    const autoLaunchPending = autoLaunchStarted || afterQueue.some(task => {
+        if (task.status !== 'pending') return false;
+        const al = task.autoLaunch;
+        if (!al || (al.status !== 'started' && al.status !== 'completed')) return false;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        return Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    });
+
     return {
         success: true,
         meshId,
@@ -1498,7 +1528,11 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
         remoteIdleSessionsChecked,
         skippedSessions,
         autoLaunchStarted,
-        ...(pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchStarted
+        ...(autoLaunchPending ? { autoLaunchPending: true } : {}),
+        // Only report "no idle session, go launch one" when nothing is already on its way.
+        // A pending auto-launch (this tick or a prior still-converging one) means a session
+        // WILL claim shortly, so it is not a no-session-available situation.
+        ...(pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchPending
             ? { noIdleMeshSessionAvailable: true }
             : {}),
     };

package/src/system/hash.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared SHA-256 hashing helpers for daemon-core (Node runtime).
+ *
+ * daemon-core runs under Node, so it uses `node:crypto` directly and must NOT
+ * import the server's WebCrypto-based `utils/crypto.ts` (different runtime +
+ * cross-package dependency direction). Output is byte-identical to that helper
+ * for the same input — lowercase hex SHA-256.
+ */
+import { createHash } from 'node:crypto';
+
+/** Full lowercase hex SHA-256 digest of `input`. */
+export function sha256Hex(input: string): string {
+    return createHash('sha256').update(input).digest('hex');
+}
+
+/**
+ * Truncated SHA-256 hex digest — the first `length` hex chars (default 16).
+ * Used for stable short identifiers (workspace hashes, token ids, coordinator
+ * home dirs) where collision risk at 16 hex chars (64 bits) is negligible.
+ */
+export function shortHash(input: string, length = 16): string {
+    return sha256Hex(input).slice(0, length);
+}