@adhdev/daemon-core 0.9.77-rc.9 → 0.9.78

package/src/commands/stream-commands.ts

@@ -113,11 +113,18 @@ export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<Com
 export async function handlePtyInput(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
+
+    // Filter out VT100/VT420 Device Attributes responses (e.g. \x1b[?1;2c or \x1b[>0;276;0c)
+    // These are echoed by xterm.js in the dashboard in response to \x1b[c queries
+    // and pollute the CLI input buffer.
+    const cleanData = typeof data === 'string' ? data.replace(/\x1b\[[?>][0-9;]*c/g, '') : data;
+    if (!cleanData) return { success: true };
+
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.writeRaw !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
     }
-    await adapter.writeRaw(data);
+    await adapter.writeRaw(cleanData);
     return { success: true };
 }
 

package/src/config/config.ts

@@ -264,7 +264,8 @@ function ensureMachineId(config: ADHDevConfig): { config: ADHDevConfig; changed:
  * Get the config directory path
  */
 export function getConfigDir(): string {
-    const dir = join(homedir(), '.adhdev');
+    const override = process.env.ADHDEV_CONFIG_DIR;
+    const dir = override && override.trim() ? override.trim() : join(homedir(), '.adhdev');
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }

package/src/config/mesh-config.ts

@@ -180,6 +180,7 @@ export interface AddNodeOptions {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
+    machineId?: string;
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
     isLocalWorktree?: boolean;
@@ -206,6 +207,7 @@ export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntr
         workspace: opts.workspace.trim(),
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
+        machineId: opts.machineId,
         userOverrides: opts.userOverrides || {},
         policy: opts.policy || {},
         isLocalWorktree: opts.isLocalWorktree,

package/src/config/workspaces.ts

@@ -201,7 +201,7 @@ export function addWorkspaceEntry(
         }
     }
     const v = validateWorkspacePath(abs);
-    if (!v.ok) return { error: v.error };
+    if (v.ok !== true) return { error: v.error };
 
     const list = [...(config.workspaces || [])];
     if (list.some(w => path.resolve(w.path) === abs)) {

package/src/git/git-worktree.ts

@@ -20,6 +20,7 @@ const execFileAsync = promisify(execFile);
 const WORKTREE_DIR_NAME = '.adhdev-worktrees';
 const GIT_TIMEOUT_MS = 30_000;
 const GIT_MAX_BUFFER = 4 * 1024 * 1024;
+const SUBMODULE_WORKTREE_REMOVE_RE = /working trees containing submodules cannot be moved or removed/i;
 
 // ─── Types ──────────────────────────────────────
 
@@ -49,9 +50,23 @@ export interface WorktreeEntry {
     bare: boolean;
 }
 
+export interface WorktreeRemoveOptions {
+    /** Refuse to remove a worktree with uncommitted or untracked changes. */
+    requireClean?: boolean;
+    /**
+     * If normal removal fails with Git's submodule-worktree guard, retry with
+     * `git worktree remove --force`. Callers must perform their own
+     * higher-level managed-path/convergence checks before enabling this.
+     */
+    allowSubmoduleForceFallback?: boolean;
+}
+
 export interface WorktreeRemoveResult {
     success: true;
     removedPath: string;
+    fallback?: 'git_worktree_remove_force_submodule';
+    forced?: boolean;
+    reason?: 'working_trees_containing_submodules';
 }
 
 // ─── Path Resolution ────────────────────────────
@@ -120,17 +135,30 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
 /**
  * Remove a git worktree and clean up the directory.
  *
- * Runs: git worktree remove <worktreePath> --force
+ * Runs: git worktree remove <worktreePath>
  */
-export async function removeWorktree(repoRoot: string, worktreePath: string): Promise<WorktreeRemoveResult> {
+export async function removeWorktree(repoRoot: string, worktreePath: string, opts: WorktreeRemoveOptions = {}): Promise<WorktreeRemoveResult> {
     if (!existsSync(worktreePath)) {
         // Already gone — just prune
         await pruneWorktrees(repoRoot);
         return { success: true, removedPath: worktreePath };
     }
 
+    if (opts.requireClean) {
+        const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            windowsHide: true,
+        });
+        if (stdout.trim()) {
+            throw new Error(`Refusing to remove dirty worktree: ${worktreePath}`);
+        }
+    }
+
     try {
-        await execFileAsync('git', ['worktree', 'remove', worktreePath, '--force'], {
+        await execFileAsync('git', ['worktree', 'remove', worktreePath], {
             cwd: repoRoot,
             encoding: 'utf8',
             timeout: GIT_TIMEOUT_MS,
@@ -139,7 +167,31 @@ export async function removeWorktree(repoRoot: string, worktreePath: string): Pr
         });
     } catch (error: any) {
         const stderr = typeof error.stderr === 'string' ? error.stderr : '';
-        throw new Error(`git worktree remove failed: ${stderr.trim() || error.message}`);
+        const stdout = typeof error.stdout === 'string' ? error.stdout : '';
+        const detail = `${stderr}\n${stdout}\n${error.message || ''}`;
+        if (opts.allowSubmoduleForceFallback && SUBMODULE_WORKTREE_REMOVE_RE.test(detail)) {
+            try {
+                await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], {
+                    cwd: repoRoot,
+                    encoding: 'utf8',
+                    timeout: GIT_TIMEOUT_MS,
+                    maxBuffer: GIT_MAX_BUFFER,
+                    windowsHide: true,
+                });
+            } catch (forceError: any) {
+                const forceStderr = typeof forceError.stderr === 'string' ? forceError.stderr : '';
+                const forceStdout = typeof forceError.stdout === 'string' ? forceError.stdout : '';
+                throw new Error(`git worktree remove --force fallback failed: ${forceStderr.trim() || forceStdout.trim() || forceError.message}`);
+            }
+            return {
+                success: true,
+                removedPath: worktreePath,
+                fallback: 'git_worktree_remove_force_submodule',
+                forced: true,
+                reason: 'working_trees_containing_submodules',
+            };
+        }
+        throw new Error(`git worktree remove failed: ${stderr.trim() || stdout.trim() || error.message}`);
     }
 
     return { success: true, removedPath: worktreePath };

package/src/index.d.ts

@@ -22,6 +22,9 @@ export { appendRecentActivity, getRecentActivity } from './config/recent-activit
 export type { RecentActivityEntry } from './config/recent-activity.js';
 export { getSavedProviderSessions, upsertSavedProviderSession } from './config/saved-sessions.js';
 export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
+export { triggerMeshQueue } from './mesh/mesh-events.js';
+export { P2pRelayFailureError, buildP2pRelayFailurePayload, classifyP2pRelayFailure, isP2pRelayTransportFailure } from './mesh/p2p-relay-failure.js';
+export type { P2pRelayFailureClassification, P2pRelayFailureCode, P2pRelayFailureContext, P2pRelayFailurePayload } from './mesh/p2p-relay-failure.js';
 export { loadState, saveState, resetState } from './config/state-store.js';
 export type { DaemonState } from './config/state-store.js';
 export { detectIDEs } from './detection/ide-detector.js';

package/src/index.ts

@@ -119,6 +119,7 @@ export type RuntimeWriteOwner = _RuntimeWriteOwner;
 export type RuntimeAttachedClient = _RuntimeAttachedClient;
 export type RecentLaunchEntry = _RecentLaunchEntry;
 export type TerminalBackendStatus = _TerminalBackendStatus;
+export type { SessionHostEndpoint } from '@adhdev/session-host-core';
 
 // Type aliases — rollup-dts cannot bundle re-exported type aliases at all.
 // Canonical definition lives in shared-types-extra.ts — keep these in sync.
@@ -150,15 +151,39 @@ export { syncMeshes } from './mesh/mesh-sync.js';
 export type { MeshSyncTransport, MeshSyncResult, RemoteMeshRecord } from './mesh/mesh-sync.js';
 
 // ── Mesh Task Ledger ──
-export { appendLedgerEntry, readLedgerEntries, getLedgerSummary, getLedgerDir, getSessionRecoveryContext } from './mesh/mesh-ledger.js';
-export type { MeshLedgerEntry, MeshLedgerKind, MeshLedgerSummary, ReadLedgerOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, readLedgerEntries, readLedgerSlice, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
+export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
+export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence } from './mesh/mesh-ledger-reconciliation.js';
+export type { MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus } from './mesh/mesh-work-queue.js';
-export type { MeshWorkQueueEntry, MeshTaskStatus } from './mesh/mesh-work-queue.js';
+export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';
+export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats } from './mesh/mesh-work-queue.js';
+
+// ── Mesh Visualization ──
+// buildMeshGraph and MeshGraph types moved to @adhdev/web-core to avoid
+// bundling Node.js built-ins (fs, path, etc.) into browser builds.
+// Import from '@adhdev/web-core' instead.
+// export { buildMeshGraph } from './mesh/mesh-visualization.js';
+// export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
 
 // ── Mesh Events ──
-export { triggerMeshQueue } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents } from './mesh/mesh-events.js';
+export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
+
+// ── Mesh P2P Relay Failure Classification ──
+export {
+  P2pRelayFailureError,
+  buildP2pRelayFailurePayload,
+  classifyP2pRelayFailure,
+  isP2pRelayTransportFailure,
+} from './mesh/p2p-relay-failure.js';
+export type {
+  P2pRelayFailureClassification,
+  P2pRelayFailureCode,
+  P2pRelayFailureContext,
+  P2pRelayFailurePayload,
+} from './mesh/p2p-relay-failure.js';
 
 // ── State Store ──
 export { loadState, saveState, resetState } from './config/state-store.js';
@@ -374,7 +399,6 @@ export {
 } from './session-host/runtime-surface.js';
 export type { SessionHostSurfaceKind, SessionHostSurfaceRecordLike } from './session-host/runtime-surface.js';
 export { shouldAutoRestoreHostedSessionsOnStartup } from './session-host/startup-restore-policy.js';
-export type { SessionHostEndpoint } from '@adhdev/session-host-core';
 
 // ── Installer ──
 export { getAIExtensions, installExtensions, launchIDE, isExtensionInstalled } from './installer.js';

package/src/mesh/coordinator-prompt.ts

@@ -128,17 +128,24 @@ const TOOLS_SECTION = `## Available Tools
 
 | Tool | Purpose |
 |------|---------|
-| \`mesh_status\` | Check all nodes' health, git state, and active sessions |
+| \`mesh_status\` | Check all nodes' health, git state, active sessions, and branch convergence |
 | \`mesh_list_nodes\` | List nodes with workspace paths |
+| \`mesh_enqueue_task\` | Add a task to the pull-based work queue; idle nodes auto-claim |
+| \`mesh_view_queue\` | View queue status — pending, assigned, completed, failed, cancelled tasks |
+| \`mesh_queue_cancel\` | Cancel a queue task without deleting audit history |
+| \`mesh_queue_requeue\` | Return a task to pending for retry; clears stale session targets |
+| \`mesh_send_task\` | Legacy push: enqueue a task targeted at a specific node |
 | \`mesh_launch_session\` | Start a new agent session on a node |
-| \`mesh_send_task\` | Send a task (natural language) to a running agent |
-| \`mesh_read_chat\` | Read an agent's recent messages to check progress |
+| \`mesh_read_chat\` | Read recent chat messages from a delegated agent session |
+| \`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_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 |
-| \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |`;
+| \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
+| \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |
+| \`mesh_cleanup_sessions\` | Manually clean up delegated session records for a node |`;
 
 const TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
@@ -150,14 +157,16 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
 2. **Plan** — Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign.
 3. **Queue / Delegate** — The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
-   b. **Node Preparation**: Call \`mesh_launch_session\` to ensure enough agent sessions are active to handle the queue. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
    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. Always 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.
+   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\`.
 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. **Clean up** — Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
-8. **Report** — Summarize what was done, what changed, and any issues.
+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.
+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.
 
 ## Failure Recovery
 
@@ -167,7 +176,7 @@ When a node agent stops unexpectedly, the daemon automatically enriches the syst
 - A recommendation: **retry**, **reassign**, or **escalate**
 
 Follow these recovery rules:
-1. **If "Retry recommended"**: Re-launch the session on the same node (\`mesh_launch_session\`), then resend the original task (\`mesh_send_task\`). The system message includes the original task text.
+1. **If "Retry recommended"**: Check \`mesh_view_queue\` first — the daemon may have auto-requeued. If not, re-launch the session on the same node (\`mesh_launch_session\`), then resend the original task (\`mesh_send_task\`). The system message includes the original task text.
 2. **If "Max retries exceeded"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.
 3. **If no recovery context**: The stop may be intentional (normal completion). Use \`mesh_read_chat\` once to verify, then move on.
 4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
@@ -182,7 +191,8 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Minimize coordinator context.** The coordinator's job is routing, not implementing. Do not read source files, run commands, or analyze code directly — delegate all of that to node agents. Your context should stay lean.
 - **Delegate analysis too.** If you need to understand a bug or explore the codebase, send that investigation as a task to the queue or a node. Do not do it yourself.
 - **Respect explicit provider requests.** If the user names an agent/provider, pass the matching provider type to \`mesh_launch_session\`: Hermes → \`hermes-cli\`, Claude Code/Claude → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`. Never substitute \`claude-cli\` just because the coordinator itself is Claude Code.
-- **Front-load the task message.** When calling \`mesh_enqueue_task\` or \`mesh_send_task\`, include everything the agent needs: what files to touch, what the problem is, what the fix should look like. The agent won't ask follow-up questions.
+- **Front-load new task messages.** When calling \`mesh_enqueue_task\` or \`mesh_send_task\` for a new task, include everything the agent needs: what files to touch, what the problem is, what the fix should look like. The agent won't ask follow-up questions.
+- **Avoid context-wasting restarts.** For follow-up, retry, commit/push, preview, or cleanup work on the same issue, prefer the existing idle session and send only the delta from its last verified state. Start a fresh chat/session only for genuinely independent work, explicit provider/user request, unsafe transcript contamination, or required branch/worktree isolation.
 - **Don't inspect code.** Treat delegated agent summaries as self-reports, not verification. Verify side effects via \`mesh_git_status\` (including related repo freshness when configured), not by reading source files.
 - **Don't over-parallelize.** Start with 1-2 concurrent tasks. Scale up if they succeed. Never launch a duplicate session or second worker solely because \`mesh_read_chat\` has no final assistant message while the delegated session is still showing tool/terminal activity.
 - **Handle failures with context.** If a task fails, check \`mesh_task_history\` first to see if this task was attempted before and how it failed. Read the chat to understand why, then decide: retry on the same node, reassign to a different node, or escalate to the user.
@@ -191,5 +201,6 @@ 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.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }