@adhdev/daemon-core 0.9.82-rc.1 → 0.9.82-rc.100

package/src/mesh/coordinator-prompt.ts

@@ -76,7 +76,12 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
 // ─── Section Builders ───────────────────────────
 
 function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
-    const lines = ['## Current Node Status', ''];
+    const lines = [
+        '## Current Node Status',
+        '',
+        'Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.',
+        '',
+    ];
     for (const n of nodes) {
         const healthIcon = n.health === 'online' ? '🟢' :
             n.health === 'dirty' ? '🟡' :
@@ -85,21 +90,33 @@ function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
             ? `sessions: ${n.activeSessions.join(', ')}`
             : 'no active sessions';
         const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : '';
-        lines.push(`- ${healthIcon} **${n.machineLabel}** (${n.nodeId})`);
-        lines.push(`  workspace: \`${n.workspace}\` | ${branch} | ${sessions}`);
+        const context = [
+            n.daemonId ? `daemon: \`${n.daemonId}\`` : '',
+            n.providers?.length ? `providers: ${n.providers.join(', ')}` : '',
+        ].filter(Boolean).join(' | ');
+        lines.push(`- ${healthIcon} **${n.machineLabel}** (nodeId: \`${n.nodeId}\`)`);
+        lines.push(`  workspace: \`${n.workspace}\`${context ? ` | ${context}` : ''} | ${branch} | ${sessions}`);
         if (n.error) lines.push(`  ⚠️ ${n.error}`);
     }
     return lines.join('\n');
 }
 
 function buildNodeConfigSection(mesh: LocalMeshEntry): string {
-    const lines = ['## Configured Nodes', ''];
+    const lines = [
+        '## Configured Nodes',
+        '',
+        'Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.',
+        '',
+    ];
     for (const n of mesh.nodes) {
         const labels: string[] = [];
         if (n.isLocalWorktree) labels.push('worktree');
         if (n.policy?.readOnly) labels.push('read-only');
         const suffix = labels.length ? ` [${labels.join(', ')}]` : '';
-        lines.push(`- **${n.workspace}** (${n.id})${suffix}`);
+        const explicitMachineLabel = typeof (n as any).machineLabel === 'string' ? (n as any).machineLabel : '';
+        const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : '';
+        const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(', ')}` : '';
+        lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ''}${providerPriority}${suffix}`);
     }
     lines.push('', '_Use `mesh_status` to probe live health before delegating work._');
     return lines.join('\n');
@@ -110,6 +127,9 @@ function buildPolicySection(policy: RepoMeshPolicy): string {
     if (policy.requirePreTaskCheckpoint) rules.push('- Create a git checkpoint **before** starting each task');
     if (policy.requirePostTaskCheckpoint) rules.push('- Create a git checkpoint **after** each task completes');
     if (policy.requireApprovalForPush) rules.push('- **Ask for user approval** before pushing to remote');
+    if (policy.allowAutoPublishSubmoduleMainCommits) {
+        rules.push('- Refinery may auto-publish unreachable submodule gitlink commits to submodule origin/main with non-force pushes after validation and patch-equivalence pass');
+    }
     if (policy.requireApprovalForDestructiveGit) rules.push('- **Ask for user approval** before destructive git operations (force push, reset, etc.)');
 
     const dirtyBehavior = {
@@ -140,6 +160,7 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger — dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_git_status\` | Check git status on a specific node |
+| \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
@@ -161,10 +182,10 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
+4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** — When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** — Call \`mesh_checkpoint\` to save the work.
-7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary and \`mesh_refine_node\` for clean worktree branches when safe. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
 8. **Clean up** — Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** — Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -201,6 +222,8 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Respect node capabilities.** Don't send build tasks to read-only nodes. Don't push from nodes that aren't allowed to.
 - **Never fabricate tool results.** Always call the actual tool; never pretend you did.
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
-- **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
+- **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, fast-forward obvious clean behind-only branches with \`mesh_fast_forward_node\`, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
+- **Keep Refinery validation project-configurable.** \`mesh_refine_node\` must execute validation from repo mesh/refine config (for example \`.adhdev/refine.{json,yaml,yml}\`, \`.adhdev/repo-mesh-refine.*\`, or \`repo-mesh.refine.*\`). Heuristics are suggestions/scaffolding only, not the execution path.
+- **Treat submodule main reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote main branch. Do not treat feature-branch reachability as complete, retry validation blindly, or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit to submodule main, then rerun \`mesh_refine_node\`, unless the mesh or repo refine config explicitly enabled \`allowAutoPublishSubmoduleMainCommits\` and Refinery reports exact path/commit/remote/branch evidence with post-publish verification.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }

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

@@ -0,0 +1,255 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+
+export type MeshActiveWorkSource = 'queue' | 'direct';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
+
+export interface MeshActiveWorkRecord {
+    taskId: string;
+    source: MeshActiveWorkSource;
+    status: MeshActiveWorkStatus;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskTitle: string;
+    taskSummary: string;
+    message?: string;
+    taskMode?: string;
+    createdAt: string;
+    updatedAt: string;
+    dispatchedAt?: string;
+    elapsedMs: number;
+    terminal?: boolean;
+    terminalKind?: string;
+    terminalAt?: string;
+    staleReason?: string;
+}
+
+export interface MeshActiveWorkSummary {
+    totalActiveCount: number;
+    queueActiveCount: number;
+    directActiveCount: number;
+    awaitingApprovalCount: number;
+    generatingCount: number;
+    failedCount: number;
+    idleCount: number;
+    sourceCounts: Record<MeshActiveWorkSource, number>;
+    statusCounts: Record<MeshActiveWorkStatus, number>;
+    staleDirectCount: number;
+    /**
+     * When staleDirectCount > 0, this note clarifies that stale direct records are
+     * historical/recovery evidence — orphaned ledger entries whose original node or session
+     * is no longer present in the live mesh. They are NOT active or unresolved work items.
+     * The active queue (queue source) is the authoritative source for pending/assigned work.
+     */
+    staleDirectNote?: string;
+}
+
+export interface BuildMeshActiveWorkOptions {
+    meshId: string;
+    queue?: MeshWorkQueueEntry[];
+    ledgerEntries?: MeshLedgerEntry[];
+    nodes?: any[];
+    now?: number;
+    /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */
+    includeTerminalDirect?: boolean;
+}
+
+const DIRECT_DISPATCH_VIA = new Set(['p2p_direct', 'local_direct', 'mesh_send_task']);
+const TERMINAL_LEDGER_KINDS = new Set(['task_completed', 'task_failed', 'task_stalled']);
+
+function readString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function summarizeMessage(message: string): { title: string; summary: string } {
+    const oneLine = message.replace(/\s+/g, ' ').trim();
+    const title = oneLine.length > 96 ? `${oneLine.slice(0, 93)}...` : oneLine;
+    return { title: title || '(untitled task)', summary: oneLine };
+}
+
+function elapsedSince(value: string | undefined, now: number): number {
+    const started = value ? new Date(value).getTime() : Number.NaN;
+    return Number.isFinite(started) ? Math.max(0, now - started) : 0;
+}
+
+function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessionId?: string): { status?: MeshActiveWorkStatus; staleReason?: string } {
+    if (!Array.isArray(nodes)) return {};
+    if (!nodeId) return { staleReason: 'direct task has no node id' };
+    const node = nodes.find(item => readString(item?.id) === nodeId || readString(item?.nodeId) === nodeId || readString(item?.node_id) === nodeId);
+    if (!node) return { staleReason: 'direct task node is no longer in the live mesh' };
+    if (!sessionId) return {};
+    const candidates: any[] = [];
+    for (const value of [
+        node.sessions,
+        node.activeSessions,
+        node.active_sessions,
+        node.activeSessionDetails,
+        node.active_session_details,
+        node.sessionDetails,
+        node.session_details,
+        node.lastProbe?.sessions,
+        node.last_probe?.sessions,
+        node.lastProbe?.status?.sessions,
+        node.last_probe?.status?.sessions,
+    ]) {
+        if (Array.isArray(value)) candidates.push(...value);
+    }
+    for (const value of [node.activeSession, node.active_session, node.currentSession, node.current_session, node.runtimeSession, node.runtime_session, node.session]) {
+        if (value && typeof value === 'object') candidates.push(value);
+    }
+    const session = candidates.find(item => {
+        if (typeof item === 'string') return item === sessionId;
+        const id = readString(item?.id) || readString(item?.sessionId) || readString(item?.session_id) || readString(item?.runtimeSessionId) || readString(item?.instanceId);
+        return id === sessionId;
+    });
+    if (!session) return { staleReason: 'direct task session is not present in live session records' };
+    if (typeof session === 'string') return {};
+    const raw = `${readString(session.status) || ''} ${readString(session.lifecycle) || ''} ${readString(session.state) || ''} ${readString(session.activeChat?.status) || ''}`.toLowerCase();
+    if (raw.includes('approval')) return { status: 'awaiting_approval' };
+    if (raw.includes('generating') || raw.includes('running') || raw.includes('busy')) return { status: 'generating' };
+    if (raw.includes('failed') || raw.includes('stopped') || raw.includes('terminated') || raw.includes('exited')) return { status: 'failed' };
+    if (raw.includes('idle') || raw.includes('waiting_input') || raw.includes('ready')) return { status: 'idle' };
+    return {};
+}
+
+function isDirectDispatch(entry: MeshLedgerEntry): boolean {
+    if (entry.kind !== 'task_dispatched') return false;
+    const payload = entry.payload || {};
+    if (payload.source === 'direct') return true;
+    const via = readString(payload.via);
+    return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== 'queue');
+}
+
+function directDispatchTaskId(entry: MeshLedgerEntry): string {
+    return readString(entry.payload?.taskId) || entry.id;
+}
+
+function terminalMatchesDispatch(terminal: MeshLedgerEntry, dispatch: MeshLedgerEntry, taskId: string): boolean {
+    const terminalTaskId = readString(terminal.payload?.taskId);
+    if (terminalTaskId && terminalTaskId === taskId) return true;
+    if (terminalTaskId && terminalTaskId !== taskId) return false;
+    if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
+    return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
+}
+
+function statusFromTerminal(entry: MeshLedgerEntry): MeshActiveWorkStatus {
+    if (entry.kind === 'task_approval_needed') return 'awaiting_approval';
+    if (entry.kind === 'task_completed') return 'idle';
+    return 'failed';
+}
+
+export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary {
+    const statusCounts: Record<MeshActiveWorkStatus, number> = {
+        pending: 0,
+        assigned: 0,
+        generating: 0,
+        idle: 0,
+        failed: 0,
+        awaiting_approval: 0,
+    };
+    const sourceCounts: Record<MeshActiveWorkSource, number> = { queue: 0, direct: 0 };
+    for (const item of activeWork) {
+        sourceCounts[item.source] += 1;
+        statusCounts[item.status] += 1;
+    }
+    const staleDirectCount = activeWork.filter(item => item.source === 'direct' && item.staleReason).length;
+    return {
+        totalActiveCount: activeWork.length,
+        queueActiveCount: sourceCounts.queue,
+        directActiveCount: sourceCounts.direct,
+        awaitingApprovalCount: statusCounts.awaiting_approval,
+        generatingCount: statusCounts.generating,
+        failedCount: statusCounts.failed,
+        idleCount: statusCounts.idle,
+        sourceCounts,
+        statusCounts,
+        staleDirectCount,
+        ...(staleDirectCount > 0 ? { staleDirectNote: 'Stale direct records are orphaned ledger entries whose node/session no longer exists. They are historical recovery evidence only — not active or unresolved work. The queue (source: queue) is authoritative for pending/assigned tasks.' } : {}),
+    };
+}
+
+
+export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeWork: MeshActiveWorkRecord[]; staleDirectWork: MeshActiveWorkRecord[]; staleDirectWorkNote?: string; terminalDirectWork: MeshActiveWorkRecord[]; summary: MeshActiveWorkSummary } {
+    const now = opts.now ?? Date.now();
+    const records: MeshActiveWorkRecord[] = [];
+    const staleDirectWork: MeshActiveWorkRecord[] = [];
+    const terminalDirectWork: MeshActiveWorkRecord[] = [];
+
+    for (const task of opts.queue || []) {
+        if (task.status !== 'pending' && task.status !== 'assigned') continue;
+        const { title, summary } = summarizeMessage(task.message || '');
+        records.push({
+            taskId: task.id,
+            source: 'queue',
+            status: task.status,
+            nodeId: task.assignedNodeId || task.targetNodeId,
+            sessionId: task.assignedSessionId || task.targetSessionId,
+            taskTitle: title,
+            taskSummary: summary,
+            message: task.message,
+            taskMode: task.taskMode,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            dispatchedAt: task.dispatchTimestamp,
+            elapsedMs: elapsedSince(task.dispatchTimestamp || task.createdAt, now),
+        });
+    }
+
+    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 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,
+        };
+        if (terminalRow) {
+            terminalDirectWork.push(record);
+            if (opts.includeTerminalDirect !== true) continue;
+        }
+        if (live.staleReason && !terminalRow) {
+            staleDirectWork.push(record);
+            continue;
+        }
+        records.push(record);
+    }
+
+    records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    staleDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    terminalDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    const summary = buildMeshActiveWorkSummary(records);
+    summary.staleDirectCount = staleDirectWork.length;
+    const staleDirectWorkNote = staleDirectWork.length > 0
+        ? 'These are orphaned ledger entries whose original node or session no longer exists in the live mesh. They are historical/recovery evidence only — not active or unresolved work. Do not treat staleDirectCount as a status mismatch; use the queue (source: queue) as authoritative for pending/assigned tasks.'
+        : undefined;
+    if (staleDirectWorkNote) {
+        summary.staleDirectNote = staleDirectWorkNote;
+    }
+    return { activeWork: records, staleDirectWork, staleDirectWorkNote, terminalDirectWork, summary };
+}