@adhdev/daemon-core 0.9.82-rc.135 → 0.9.82-rc.137

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

@@ -21,10 +21,12 @@ export interface MeshTaskModeValidationResult {
 
 const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> = [
     { label: 'source_edit', pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
-    { label: 'git_mutation', pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv)|push\b)/i },
+    { label: 'git_mutation', pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv|stash|worktree\s+(?:add|remove|move))|push\b)/i },
     { label: 'checkpoint', pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
-    { label: 'deploy_or_version_bump', pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release)\b/i },
-    { label: 'destructive_shell', pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i)\b/i },
+    { label: 'deploy_or_version_bump', pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release|npm\s+publish|yarn\s+publish|pnpm\s+publish)\b/i },
+    { label: 'destructive_shell', pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i|shred\b)\b/i },
+    { label: 'package_install', pattern: /\b(npm\s+(?:install|i|add|link|uninstall|remove)|yarn\s+(?:add|remove|link)|pnpm\s+(?:add|remove|link)|pip\s+install|brew\s+install|apt\s+install|cargo\s+install)\b/i },
+    { label: 'container_mutation', pattern: /\b(docker\s+(?:build|run|exec|push|tag|rmi|rm|create|start|stop|kill)|kubectl\s+(?:apply|delete|patch|replace|create|scale))\b/i },
 ];
 
 export function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined {
@@ -122,35 +124,26 @@ export function enqueueTask(
     if (!modeValidation.valid) {
         throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(', ')})`);
     }
-    return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const entry: MeshWorkQueueEntry = {
-            id: randomUUID(),
-            meshId,
-            message,
-            status: 'pending',
-            taskMode: modeValidation.taskMode,
-            targetNodeId: opts?.targetNodeId,
-            targetSessionId: opts?.targetSessionId,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        queue.push(entry);
-        writeQueue(meshId, queue);
-        return entry;
-    });
+    const entry: MeshWorkQueueEntry = {
+        id: randomUUID(),
+        meshId,
+        message,
+        status: 'pending',
+        taskMode: modeValidation.taskMode,
+        targetNodeId: opts?.targetNodeId,
+        targetSessionId: opts?.targetSessionId,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    BeadsDB.getInstance().insertQueueEntry(entry);
+    return entry;
 }
 
 /**
  * Get all tasks in the queue, optionally filtered by status.
  */
 export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }): MeshWorkQueueEntry[] {
-    let queue = readQueue(meshId);
-    if (opts?.status?.length) {
-        const statuses = new Set(opts.status);
-        queue = queue.filter(q => statuses.has(q.status));
-    }
-    return queue;
+    return BeadsDB.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : undefined);
 }
 
 export function getMeshQueueRevision(meshId: string): string {
@@ -161,29 +154,7 @@ export function getMeshQueueRevision(meshId: string): string {
  * Find the next pending task that this node is allowed to claim, and mark it as assigned.
  */
 export function claimNextTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null {
-    return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const hasActiveAssignment = queue.some(q => q.status === 'assigned' && (
-            q.assignedSessionId === sessionId || q.assignedNodeId === nodeId
-        ));
-        if (hasActiveAssignment) return null;
-        let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetSessionId === sessionId);
-        if (targetIdx === -1) {
-            targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId && !q.targetSessionId);
-        }
-        if (targetIdx === -1) {
-            targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
-        }
-        if (targetIdx === -1) return null;
-        const entry = queue[targetIdx];
-        entry.status = 'assigned';
-        entry.assignedNodeId = nodeId;
-        entry.assignedSessionId = sessionId;
-        entry.dispatchTimestamp = new Date().toISOString();
-        entry.updatedAt = new Date().toISOString();
-        writeQueue(meshId, queue);
-        return entry;
-    });
+    return BeadsDB.getInstance().claimNextQueueTask(meshId, nodeId, sessionId);
 }
 
 /**
@@ -198,13 +169,11 @@ export function updateTaskStatus(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const idx = queue.findIndex(q => q.id === taskId);
-        if (idx === -1) return null;
-        queue[idx].status = status;
-        queue[idx].updatedAt = new Date().toISOString();
-        writeQueue(meshId, queue);
-        return queue[idx];
+        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        if (!entry) return null;
+        entry.status = status;
+        BeadsDB.getInstance().updateQueueEntry(entry);
+        return entry;
     });
 }
 
@@ -214,14 +183,12 @@ export function recordTaskAutoLaunch(
     autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>,
 ): MeshWorkQueueEntry | null {
     return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const idx = queue.findIndex(q => q.id === taskId);
-        if (idx === -1) return null;
+        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        if (!entry) return null;
         const now = new Date().toISOString();
-        queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
-        queue[idx].updatedAt = now;
-        writeQueue(meshId, queue);
-        return queue[idx];
+        entry.autoLaunch = { ...autoLaunch, updatedAt: now };
+        BeadsDB.getInstance().updateQueueEntry(entry);
+        return entry;
     });
 }
 
@@ -235,16 +202,14 @@ export function cancelTask(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const idx = queue.findIndex(q => q.id === taskId);
-        if (idx === -1) return null;
+        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        if (!entry) return null;
         const now = new Date().toISOString();
-        queue[idx].status = 'cancelled';
-        queue[idx].updatedAt = now;
-        queue[idx].cancelledAt = now;
-        if (opts?.reason) queue[idx].cancelReason = opts.reason;
-        writeQueue(meshId, queue);
-        return queue[idx];
+        entry.status = 'cancelled';
+        entry.cancelledAt = now;
+        if (opts?.reason) entry.cancelReason = opts.reason;
+        BeadsDB.getInstance().updateQueueEntry(entry);
+        return entry;
     });
 }
 
@@ -265,11 +230,8 @@ export function requeueTask(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const idx = queue.findIndex(q => q.id === taskId);
-        if (idx === -1) return null;
-        const entry = queue[idx];
-        const now = new Date().toISOString();
+        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        if (!entry) return null;
         entry.status = 'pending';
         delete entry.assignedNodeId;
         delete entry.assignedSessionId;
@@ -279,11 +241,10 @@ export function requeueTask(
         if (typeof opts?.targetNodeId === 'string') entry.targetNodeId = opts.targetNodeId;
         if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
         if (typeof opts?.targetSessionId === 'string') entry.targetSessionId = opts.targetSessionId;
-        entry.updatedAt = now;
-        entry.requeuedAt = now;
+        entry.requeuedAt = new Date().toISOString();
         entry.requeueCount = (entry.requeueCount || 0) + 1;
         if (opts?.reason) entry.requeueReason = opts.reason;
-        writeQueue(meshId, queue);
+        BeadsDB.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -298,22 +259,12 @@ export function updateSessionTaskStatus(
     opts?: { occurredAt?: string },
 ): MeshWorkQueueEntry | null {
     return withQueueLock(meshId, () => {
-        const queue = readQueue(meshId);
-        const occurredAtTime = opts?.occurredAt ? new Date(opts.occurredAt).getTime() : Number.NaN;
-        const hasOccurredAt = Number.isFinite(occurredAtTime);
-        let bestIdx = -1;
-        let bestTime = 0;
-        for (let i = queue.length - 1; i >= 0; i--) {
-            if (queue[i].assignedSessionId !== sessionId || queue[i].status !== 'assigned') continue;
-            const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
-            if (hasOccurredAt && Number.isFinite(time) && time > occurredAtTime) continue;
-            if (time > bestTime) { bestTime = time; bestIdx = i; }
-        }
-        if (bestIdx === -1) return null;
-        queue[bestIdx].status = status;
-        queue[bestIdx].updatedAt = new Date().toISOString();
-        writeQueue(meshId, queue);
-        return queue[bestIdx];
+        const occurredAtIso = opts?.occurredAt ? new Date(opts.occurredAt).toISOString() : undefined;
+        const entry = BeadsDB.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
+        if (!entry) return null;
+        entry.status = status;
+        BeadsDB.getInstance().updateQueueEntry(entry);
+        return entry;
     });
 }
 
@@ -342,14 +293,16 @@ export interface MeshWorkQueueStats {
  * Return aggregate queue statistics for the given mesh.
  */
 export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
-    const queue = readQueue(meshId);
-    const pending = queue.filter(q => q.status === 'pending').length;
-    const assigned = queue.filter(q => q.status === 'assigned').length;
-    const completed = queue.filter(q => q.status === 'completed').length;
-    const failed = queue.filter(q => q.status === 'failed').length;
-    const cancelled = queue.filter(q => q.status === 'cancelled').length;
+    const rows = BeadsDB.getInstance().getQueueStatsByStatus(meshId);
+    const counts: Record<string, number> = {};
+    for (const r of rows) counts[r.status] = r.count;
+    const pending = counts['pending'] ?? 0;
+    const assigned = counts['assigned'] ?? 0;
+    const completed = counts['completed'] ?? 0;
+    const failed = counts['failed'] ?? 0;
+    const cancelled = counts['cancelled'] ?? 0;
     return {
-        total: queue.length,
+        total: pending + assigned + completed + failed + cancelled,
         active: pending + assigned,
         historical: completed + failed + cancelled,
         pending,
@@ -357,23 +310,9 @@ export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
         completed,
         failed,
         cancelled,
-        activeCounts: {
-            pending,
-            assigned,
-        },
-        historicalCounts: {
-            completed,
-            failed,
-            cancelled,
-        },
-        activeAssignments: queue
-            .filter(q => q.status === 'assigned')
-            .map(q => ({
-                id: q.id,
-                nodeId: q.assignedNodeId,
-                sessionId: q.assignedSessionId,
-                message: q.message,
-            })),
+        activeCounts: { pending, assigned },
+        historicalCounts: { completed, failed, cancelled },
+        activeAssignments: BeadsDB.getInstance().getActiveAssignmentDetails(meshId),
     };
 }
 
@@ -390,3 +329,60 @@ export function __clearMeshQueueForTests(meshId: string): void {
 export function __resetBeadsDBForTests(): void {
     BeadsDB.resetForTests();
 }
+
+// ── Direct Dispatch Tracking ─────────────────────────────────────────────────
+// Persists direct (non-queue) task dispatches so buildMeshActiveWork can read
+// active work from BeadsDB instead of scanning ledger JSONL entries.
+
+export type DirectDispatchRecord = ReturnType<BeadsDB['getActiveDirectDispatches']>[number];
+
+export function insertDirectDispatch(
+    meshId: string,
+    data: {
+        taskId: string;
+        nodeId?: string;
+        sessionId?: string;
+        providerType?: string;
+        message: string;
+        taskMode?: string;
+        via: string;
+        dispatchedToIdleSession?: boolean;
+        dispatchedAt: string;
+    },
+): void {
+    try {
+        BeadsDB.getInstance().insertDirectDispatch({ ...data, meshId });
+    } catch (e: any) {
+        process.stderr.write(`[adhdev-mesh] insertDirectDispatch failed for task ${data.taskId}: ${e?.message || e}\n`);
+    }
+}
+
+export function getActiveDirectDispatches(meshId: string): DirectDispatchRecord[] {
+    try {
+        return BeadsDB.getInstance().getActiveDirectDispatches(meshId);
+    } catch {
+        return [];
+    }
+}
+
+export function updateDirectDispatchStatus(
+    meshId: string,
+    sessionId: string,
+    status: 'acked' | 'completed' | 'failed' | 'stale',
+): void {
+    try {
+        BeadsDB.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
+    } catch { /* best-effort */ }
+}
+
+export function cleanupTerminalDirectDispatches(olderThanMs = 7 * 24 * 60 * 60_000): void {
+    try {
+        BeadsDB.getInstance().cleanupTerminalDirectDispatches(olderThanMs);
+    } catch { /* best-effort */ }
+}
+
+export function markStaleDirectDispatches(meshId: string, olderThanMs = 60 * 60_000): void {
+    try {
+        BeadsDB.getInstance().markStaleDirectDispatches(meshId, olderThanMs);
+    } catch { /* best-effort */ }
+}

package/src/mesh/worktree-bootstrap-config.ts

@@ -9,6 +9,7 @@ import {
     type MeshRefineValidationCommandPlan,
     type RepoMeshRefineValidationCommandConfig,
 } from './refine-config.js';
+import type { MeshAsyncJobLifecycle } from '../repo-mesh-types.js';
 
 export type WorktreeBootstrapStatus = 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
 
@@ -21,16 +22,13 @@ export interface RepoMeshWorktreeBootstrapConfig {
     staleInputs?: string[];
 }
 
-export interface WorktreeBootstrapState {
+export interface WorktreeBootstrapState extends MeshAsyncJobLifecycle {
     status: WorktreeBootstrapStatus;
     required: boolean;
     configSource?: string;
     configSourceType?: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
-    startedAt?: string;
-    completedAt?: string;
     lastCommand?: string;
     exitCode?: number | null;
-    error?: string;
     commandsRun?: Array<Record<string, unknown>>;
     staleInputs?: string[];
 }
@@ -177,7 +175,22 @@ export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Pr
         commandsRun: [],
         staleInputs: loaded.config.staleInputs,
     };
+    const staleInputPaths = loaded.config.staleInputs ?? [];
+    // Snapshot which staleInputs files are absent at bootstrap start.
+    // Files already present before we start are not interference signals.
+    const initiallyAbsent = staleInputPaths.filter(p => !existsSync(join(workspace, p)));
     for (const command of validation.commands) {
+        // Check if any initially-absent staleInputs files appeared since bootstrap started
+        // (indicates another process modified the environment mid-run).
+        if (initiallyAbsent.length > 0) {
+            const appearedNow = initiallyAbsent.filter(p => existsSync(join(workspace, p)));
+            if (appearedNow.length > 0) {
+                state.status = 'stale';
+                state.completedAt = new Date().toISOString();
+                state.error = `Bootstrap interrupted: staleInputs files appeared during run: ${appearedNow.join(', ')}`;
+                return state;
+            }
+        }
         const cwd = command.cwd ? pathResolve(workspace, command.cwd) : workspace;
         const startedAt = Date.now();
         state.lastCommand = command.displayCommand;

package/src/providers/approval-utils.ts

@@ -72,3 +72,30 @@ export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: s
     if (cleanMessage) lines.push(cleanMessage);
     return lines.join('\n');
 }
+
+/**
+ * Returns true when the given text (e.g. last assistant message content, or
+ * the tail of the PTY screen) looks like an active approval/input prompt
+ * rather than a completed assistant response. Used to prevent false
+ * idle/completion events when Claude Code surfaces a "Do you want to proceed?"
+ * style prompt that the PTY parser captures as an assistant turn while the
+ * session is still awaiting user input.
+ */
+export function looksLikeActiveApprovalPromptText(content: string): boolean {
+    const text = content.trim();
+    if (!text || text.length > 2000) return false;
+    const hasApprovalQuestion = /do you want to (?:proceed|allow|run|make this edit|create)/i.test(text)
+        || /this command requires approval/i.test(text)
+        || /quick safety check/i.test(text)
+        || /is this a project you trust/i.test(text);
+    const hasNumberedChoices = /^\s*[❯›>]?\s*1[.)]\s+(?:yes|allow|proceed|run)/im.test(text)
+        || /^\s*1[.)]\s+yes\b/im.test(text);
+    if (hasApprovalQuestion && hasNumberedChoices) return true;
+    const lastLines = text.split(/\r?\n/).slice(-12).join('\n');
+    const hasDontAskAgain = /yes.*don'?t ask again/i.test(lastLines)
+        || /yes.*always allow/i.test(lastLines);
+    const hasNoOption = /^\s*[❯›>]?\s*\d+[.)]\s+no\b/im.test(lastLines);
+    if (hasDontAskAgain && hasNoOption) return true;
+    if (/what do you want to do\?/i.test(text) && /^\s*\d+[.)]\s+\S/m.test(text)) return true;
+    return false;
+}

package/src/providers/cli-provider-instance.ts

@@ -21,7 +21,7 @@ import { ChatHistoryWriter, isNativeSourceCanonicalHistory, materializeProviderN
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, looksLikeActiveApprovalPromptText } from './approval-utils.js';
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
@@ -48,6 +48,7 @@ function isIdleStatus(value: unknown): boolean {
     return !status || status === 'idle' || status === 'ready';
 }
 
+
 function getMessageTime(message: unknown): number {
     if (!message || typeof message !== 'object') return 0;
     const record = message as { receivedAt?: unknown; timestamp?: unknown };
@@ -389,6 +390,9 @@ export class CliProviderInstance implements ProviderInstance {
         this.launchMode = options?.launchMode || 'new';
         this.onProviderSessionResolved = options?.onProviderSessionResolved;
         this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
+        if (this.providerSessionId) {
+            this.adapter.updateRuntimeMeta({ providerSessionId: this.providerSessionId });
+        }
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -825,7 +829,11 @@ export class CliProviderInstance implements ProviderInstance {
         const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
         const role = typeof lastVisible?.role === 'string' ? lastVisible.role.trim().toLowerCase() : '';
         const content = lastVisible ? flattenContent(lastVisible.content).trim() : '';
-        return role === 'assistant' && !!content;
+        if (role !== 'assistant' || !content) return false;
+        // Guard: if the last assistant message looks like an active approval/input prompt,
+        // it is not a real completion — the session is still awaiting user input.
+        if (looksLikeActiveApprovalPromptText(content)) return false;
+        return true;
     }
 
     private buildCompletedFinalizationDiagnostic(args: {
@@ -940,6 +948,22 @@ export class CliProviderInstance implements ProviderInstance {
         if (parsed?.activeModal || parsed?.modal) return { reason: 'parsed_modal_active', terminal: true };
         if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return { reason: 'missing_final_assistant' };
 
+        // Guard: if the screen still shows an approval/choice prompt as the last visible text,
+        // the turn is not complete even if the parsed status says idle and there is an assistant
+        // message. This catches the case where waiting_approval→idle transitions occur before
+        // the modal has been resolved (e.g. the PTY rendered the prompt but no button press fired).
+        try {
+            const screenText = typeof (this.adapter as any).getScreenText === 'function'
+                ? String((this.adapter as any).getScreenText() || '')
+                : '';
+            if (screenText) {
+                const tailLines = screenText.split(/\r?\n/).slice(-16).join('\n');
+                if (looksLikeActiveApprovalPromptText(tailLines)) {
+                    return { reason: 'screen_shows_approval_prompt', terminal: false };
+                }
+            }
+        } catch { /* defensive: screen text read is best-effort */ }
+
         return null;
     }
 

package/src/providers/provider-schema.ts

@@ -64,6 +64,8 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'sendKey',
   'submitStrategy',
   'requirePromptEchoBeforeSubmit',
+  'requiresFinalAssistantBeforeIdle',
+  'augmentStaleSnapshot',
   'timeouts',
   'disableUpstream',
 ])

package/src/repo-mesh-types.ts

@@ -472,3 +472,13 @@ export interface RepoMeshLedgerStatus {
     entries: RepoMeshLedgerEntryStatus[];
     summary: RepoMeshLedgerSummaryStatus;
 }
+
+// ─── Async Job Lifecycle ─────────────────────────
+// Shared base for all mesh async job types (refine jobs, bootstrap runs, etc.)
+// Each concrete type adds its own status enum and domain-specific fields.
+
+export interface MeshAsyncJobLifecycle {
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+}