@adhdev/daemon-core 0.9.82-rc.363 → 0.9.82-rc.365

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/providers/spec/fsm-driver.ts

@@ -294,6 +294,11 @@ export class FsmDriver implements ISpecDriver {
     private lastWin32WriteAt = 0;
     /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
     private win32WriteTimer: ReturnType<typeof setTimeout> | null = null;
+    /** Timer driving the win32 verification-based modal-confirm CR resend loop (see
+     *  scheduleWin32ModalConfirm). A lone CR that confirms an approval/picker choice
+     *  is absorbed by ConPTY the same way a send_message submit CR is, so the confirm
+     *  must be resent until the modal actually resolves (status leaves 'approval'). */
+    private win32ModalConfirmTimer: ReturnType<typeof setTimeout> | null = null;
 
     private currentEval: CurrentEval | null = null;
     private stateHistory: HistoryEntry[] = [];
@@ -413,6 +418,7 @@ export class FsmDriver implements ISpecDriver {
         if (this.stallTimer) { clearTimeout(this.stallTimer); this.stallTimer = null; }
         if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
         if (this.win32WriteTimer) { clearTimeout(this.win32WriteTimer); this.win32WriteTimer = null; }
+        if (this.win32ModalConfirmTimer) { clearTimeout(this.win32ModalConfirmTimer); this.win32ModalConfirmTimer = null; }
         this.specWatcher?.close();
         this.adapter.kill();
     }
@@ -1140,10 +1146,58 @@ export class FsmDriver implements ISpecDriver {
             // `{index}\r` → `\r`.
             const confirm = (rule.key_for_index || '\r').replace(/\{index\}/g, '') || '\r';
             if (nav) this.adapter.send_keys(nav);
-            this.adapter.send_keys(confirm);
+            this.submitModalConfirm(confirm);
             return;
         }
-        this.adapter.send_keys(btn.key);
+        this.submitModalConfirm(btn.key);
+    }
+
+    /**
+     * Submit a modal-confirm key sequence (the choice key + its trailing CR).
+     *
+     * On win32 the trailing CR is the SAME lone-CR-swallow case as a send_message
+     * submit: ConPTY can absorb a single CR as a literal newline instead of a
+     * confirm, so the approval/picker modal never resolves and the FSM flaps
+     * approval↔busy while auto-approve keeps firing into the void (APPROVESTUCK).
+     * So we split any non-CR prefix (e.g. the "1" of "1\r") off, write it once, and
+     * resend the CR on a fixed cadence until the modal actually resolves (status
+     * leaves 'approval'). Non-win32 keeps the single direct write — its CR submits
+     * on the first try.
+     */
+    private submitModalConfirm(keys: string): void {
+        if (process.platform !== 'win32') {
+            this.adapter.send_keys(keys);
+            return;
+        }
+        const m = /^([\s\S]*?)([\r\n]+)$/.exec(keys);
+        const prefix = m ? m[1] : keys;
+        const cr = m ? m[2] : '';
+        if (prefix) this.adapter.send_keys(prefix);
+        if (!cr) return;
+        this.scheduleWin32ModalConfirm(cr);
+    }
+
+    /**
+     * win32 modal-confirm CR resend loop. Mirrors scheduleWin32Submit's phase-2
+     * verified resend, but gated on still being IN a modal (status 'approval')
+     * rather than still idle: the first CR fires immediately, then resends every
+     * WIN32_SUBMIT_RESEND_GAP_MS while the FSM is still showing the modal, up to
+     * WIN32_SUBMIT_MAX_RESENDS. The instant the modal resolves (status flips to
+     * generating/idle) we stop, so no stray CR leaks into the next turn's composer.
+     */
+    private scheduleWin32ModalConfirm(submitKey: string): void {
+        if (this.win32ModalConfirmTimer) { clearTimeout(this.win32ModalConfirmTimer); this.win32ModalConfirmTimer = null; }
+        const fire = (attempt: number): void => {
+            this.win32ModalConfirmTimer = null;
+            this.adapter.send_keys(submitKey);
+            if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+            this.win32ModalConfirmTimer = setTimeout(() => {
+                // Left the modal → it resolved; stop resending.
+                if (this.currentStatus() !== 'approval') { this.win32ModalConfirmTimer = null; return; }
+                fire(attempt + 1);
+            }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        fire(0);
     }
 
     private handleAttachImage(blob: string, mime: string): void {

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);
+}