@adhdev/daemon-core 0.9.82-rc.353 → 0.9.82-rc.355

package/dist/mesh/mesh-event-trace.d.ts

@@ -0,0 +1,21 @@
+export interface MeshEventTraceCtx {
+    /** Primary correlation anchor — the mesh task id (meshActiveTaskId / metadataEvent.taskId). */
+    taskId?: unknown;
+    /** Optional per-event id when the producer assigns one. */
+    eventId?: unknown;
+    /** Worker session id — the fallback anchor when no task is attached. */
+    sessionId?: unknown;
+    nodeId?: unknown;
+    meshId?: unknown;
+    event?: unknown;
+}
+/**
+ * Stable, greppable correlation key. `task=` and `sess=` are ALWAYS rendered (as `-`
+ * when absent) so the key shape is uniform across stages and a single grep alternation
+ * (`task=<id>\|sess=<id>`) follows the event end-to-end.
+ */
+export declare function meshEventTraceKey(ctx: MeshEventTraceCtx): string;
+/** Lifecycle progress (INFO). One line per stage the event clears. */
+export declare function traceMeshEventStage(stage: string, ctx: MeshEventTraceCtx, detail?: string): void;
+/** Event did not advance — rejected / held / skipped / deduped (WARN). */
+export declare function traceMeshEventDrop(reason: string, ctx: MeshEventTraceCtx, detail?: string): void;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -129,7 +129,7 @@ export declare class MeshRuntimeStore {
         dispatchedAt: string;
         updatedAt: string;
     }>;
-    updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
+    updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale', taskId?: string): void;
     cleanupTerminalDirectDispatches(olderThanMs: number): void;
     deleteDirectDispatches(meshId: string): void;
     /**

package/dist/mesh/mesh-work-queue.d.ts

@@ -320,7 +320,7 @@ export declare function insertDirectDispatch(meshId: string, data: {
     dispatchedAt: string;
 }): void;
 export declare function getActiveDirectDispatches(meshId: string): DirectDispatchRecord[];
-export declare function updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
+export declare function updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale', taskId?: string): void;
 export declare function cleanupTerminalDirectDispatches(olderThanMs?: number): void;
 export declare function markStaleDirectDispatches(meshId: string, olderThanMs?: number): void;
 /**

package/dist/providers/acp-provider-instance.d.ts

@@ -88,6 +88,9 @@ export declare class AcpProviderInstance implements ProviderInstance {
     sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
     private cancelSession;
     private permissionResolvers;
+    private readonly manualAttendance;
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now?: number): void;
     resolvePermission(approved: boolean): Promise<void>;
     private handleSessionUpdate;
     /** Handle legacy session/update formats (pre-standardization compat) */

package/dist/providers/cli-provider-instance.d.ts

@@ -79,6 +79,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pendingAutoApprovalSince;
     private autoApproveSettleTimer;
     private autoApproveInactiveSince;
+    private readonly manualAttendance;
     private controlValues;
     private summaryMetadata;
     private appliedEffectKeys;
@@ -183,6 +184,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private shouldSuppressStaleParsedBusyStatus;
     private getCompletedFinalizationBlock;
     private scheduleCompletedDebounceFlush;
+    private isMeshWorkerSession;
+    private meshTraceCtx;
     private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;
     /**
@@ -204,6 +207,17 @@ export declare class CliProviderInstance implements ProviderInstance {
     get cliType(): string;
     get cliName(): string;
     private shouldAutoApprove;
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now?: number): void;
+    /**
+     * Whether auto-approve should be treated as active *right now* for display
+     * and firing decisions: the configured intent AND the user is not currently
+     * attending this session by hand. When a human is attending, auto-approve is
+     * held so the modal stays visible and they can drive it via the controlbar.
+     * Provider-agnostic — the attendance signal is the command set, never any
+     * CLI-specific modal text.
+     */
+    private autoApproveEffectivelyActive;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
     private formatMarkerTimestamp;

package/dist/providers/manual-attendance.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ManualAttendanceTracker — provider-agnostic "is a human driving this session
+ * right now" signal, used to suppress auto-approve while the user is taking
+ * manual control of a session from the dashboard.
+ *
+ * Why this exists
+ * ---------------
+ * When `autoApprove` is on, an approval modal is auto-dismissed within a few
+ * hundred ms of appearing. For a background mesh worker that is exactly the
+ * desired delegated behavior. But for a session the user is actively watching
+ * and operating (a base-node / foreground session), the auto-fire closes the
+ * modal before the human can pick a button — and likewise fights their use of
+ * the controlbar. The fix is to give the human a short quiet window: while they
+ * are attending the session by hand, auto-approve holds; once they go idle it
+ * resumes.
+ *
+ * The tracker holds only a timestamp. The *signal* — which commands count as
+ * "a human attending" — is decided by the caller (the command handler), and is
+ * the same set for every provider: foreground tab selection (select_session /
+ * open_panel), controlbar use (invoke_provider_script / set_mode / change_model
+ * / set_thought_level), manual approval (resolve_action) and manual terminal
+ * input (pty_input). Notably NOT send_chat, which is also how a coordinator
+ * delegates a task to a worker — counting it would wrongly suppress the
+ * worker's delegated auto-approve.
+ *
+ * Because a background worker never receives any of those attending commands,
+ * it is never "attended", so its delegated auto-approve is unaffected. The
+ * mechanism is therefore provider-common AND preserves worker auto-approve
+ * without any per-provider branching.
+ */
+/**
+ * How long after the last manual interaction auto-approve stays suppressed.
+ *
+ * Trade-off: long enough that after foregrounding a session's tab the user has
+ * a realistic chance to act on an incoming approval (the auto-approve settle
+ * window is only ~600ms, so a human cannot out-race it), yet short enough that
+ * a session left unattended — e.g. a worker tab the user briefly peeked at —
+ * resumes auto-approving within about a minute. Re-armed on every attending
+ * command, so a user who keeps interacting keeps the window fresh.
+ */
+export declare const AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 60000;
+export declare class ManualAttendanceTracker {
+    private readonly suppressMs;
+    private lastInteractionAt;
+    constructor(suppressMs?: number);
+    /** Record that a human just drove this session by hand. */
+    note(now?: number): void;
+    /** True while a manual interaction is recent enough to suppress auto-approve. */
+    isAttended(now?: number): boolean;
+    /**
+     * Milliseconds remaining in the current suppression window, or 0 when not
+     * attended. Used to re-arm a re-check timer so auto-approve fires the moment
+     * the window lapses even if the PTY/agent has since gone silent.
+     */
+    remainingMs(now?: number): number;
+}
+/**
+ * The session-scoped commands that count as "a human is attending this session
+ * by hand". Shared so the command handler and any forward path agree on one
+ * definition. Deliberately excludes send_chat (coordinator task delegation) and
+ * pure read commands (read_chat / list_chats — passive polling, not driving).
+ */
+export declare const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string>;

package/dist/providers/provider-instance.d.ts

@@ -194,6 +194,14 @@ export interface ProviderInstance {
     detachMeshAssignment?(): void;
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
+    /**
+     * Record that a human is actively attending this session by hand right now
+     * (foreground tab selection, controlbar use, manual approval, terminal
+     * input). Provider-common signal that suppresses auto-approve for a short
+     * window so the user can drive the session manually; background mesh worker
+     * sessions never receive it, so their delegated auto-approve is unaffected.
+     */
+    noteManualInteraction?(now?: number): void;
     /** cleanup */
     dispose(): void;
 }

package/dist/providers/spec/adapter.d.ts

@@ -33,6 +33,21 @@ export interface TerminalAdapterHandlers {
     }): void;
     tick?(): void;
 }
+/**
+ * One entry in the PTY input/output event timeline (debug-only). Captured at
+ * the single common point every spec@4 provider funnels through — this adapter
+ * — so the Spec Debug Snapshot can answer "what input / output preceded a status
+ * transition?". Observation only; nothing here feeds the FSM decision.
+ */
+export interface SpecPtyEvent {
+    /** Wall-clock ms. */
+    ts: number;
+    kind: 'spawn' | 'input' | 'output' | 'resize' | 'cursor' | 'exit';
+    /** Human-readable, control-char-escaped, length-capped preview. */
+    content: string;
+    /** Raw byte length before truncation (output/input only). */
+    bytes?: number;
+}
 export declare class TerminalAdapter {
     private readonly opts;
     private readonly handlers;
@@ -46,6 +61,9 @@ export declare class TerminalAdapter {
     private screenTimer;
     private tickTimer;
     private lastScreen;
+    /** Debug-only ring buffer of PTY input/output/resize/cursor events. */
+    private events;
+    private lastCursorKey;
     constructor(opts: TerminalAdapterOpts, handlers: TerminalAdapterHandlers);
     start(): void;
     resize(cols: number, rows: number): void;
@@ -62,6 +80,10 @@ export declare class TerminalAdapter {
         col: number;
     };
     send_keys(text: string): void;
+    /** Debug-only: most-recent PTY input/output/resize/cursor events, oldest
+     *  first. Pure observation — never consulted by the FSM. */
+    getEventTimeline(limit?: number): SpecPtyEvent[];
+    private recordEvent;
     kill(): void;
     private onChunk;
     private computeScreen;

package/dist/providers/spec/fsm-driver.d.ts

@@ -1,3 +1,4 @@
+import { type SpecPtyEvent } from './adapter.js';
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
 import { type TraceEntry } from './evaluator.js';
 import { type TransitionEval } from './fsm-evaluator.js';
@@ -139,6 +140,7 @@ export interface ISpecDriver {
     } | null;
     getFsmDebug?(): unknown;
     getFsmSnapshotHistory?(): ReadonlyArray<FsmSnapshotEntry>;
+    getEventTimeline?(limit?: number): ReadonlyArray<SpecPtyEvent>;
 }
 export interface SpecDriverOpts {
     specPath: string;
@@ -152,6 +154,10 @@ export interface SpecDriverOpts {
     extraCliArgs?: string[];
 }
 export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
+/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
+ *  between a high and low surrogate (which would corrupt an astral char — emoji,
+ *  etc. — on the UTF-8 PTY write). */
+export declare function chunkPreservingSurrogates(text: string, size: number): string[];
 export declare function guessExt(mime: string): string;
 type HistoryEntry = DriverHistoryEntry;
 export declare class FsmDriver implements ISpecDriver {
@@ -181,6 +187,16 @@ export declare class FsmDriver implements ISpecDriver {
      *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
      *  leaves idle (submitted) or the resend budget is spent. */
     private win32SubmitTimer;
+    /** Wall-clock (ms) of the most recent raw PTY output chunk. Advances on every
+     *  on_pty_data — including the echo of text written into the composer — so the
+     *  win32 submit settle-gate can tell when input has finished landing. */
+    private lastPtyDataAt;
+    /** Wall-clock (ms) of the most recent win32 message-body input write. Bridges
+     *  the gap between writing a chunk and its echo so the settle-gate does not
+     *  declare "quiet" mid-write. */
+    private lastWin32WriteAt;
+    /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
+    private win32WriteTimer;
     private currentEval;
     private stateHistory;
     private prevStateAt;
@@ -230,6 +246,8 @@ export declare class FsmDriver implements ISpecDriver {
     };
     getStateHistory(): ReadonlyArray<HistoryEntry>;
     getFsmSnapshotHistory(): ReadonlyArray<FsmSnapshotEntry>;
+    /** Debug-only PTY input/output/resize/cursor timeline from the adapter. */
+    getEventTimeline(limit?: number): ReadonlyArray<SpecPtyEvent>;
     getSections(): Array<{
         id: string;
         text: string;
@@ -300,14 +318,38 @@ export declare class FsmDriver implements ISpecDriver {
     private actuallySendMessage;
     /** The agent's current coarse status, derived from the FSM node we're in. */
     private currentStatus;
+    /** Record a win32 body write so the settle-gate counts it as input activity
+     *  even before the echo arrives. */
+    private markWin32Write;
+    /** Most recent win32 input activity — a write we issued OR a PTY output chunk
+     *  (echo). The submit settle-gate waits for this to go quiet. */
+    private lastWin32InputActivityAt;
     /**
-     * win32 verification-based submit. Sends the submit key, waits a gap, and if
-     * the FSM is still 'idle' (the prompt did not submit — the CR was absorbed as
-     * a multiline-paste newline) resends, up to WIN32_SUBMIT_MAX_RESENDS. The
-     * first CR always fires (so a stale/edge status never suppresses the submit);
-     * subsequent resends are gated on still being idle, and stop the instant the
-     * agent leaves idle (submitted → generating / approval). This converges the
-     * nondeterministic multiline window without spamming Enter into the next turn.
+     * Write the message body to the PTY for win32, paced into bounded chunks. A
+     * single unbounded ConPTY write can overflow the input pipe and drop leading
+     * bytes; splitting it with a short inter-chunk gap keeps the console input
+     * buffer from overflowing. Small bodies still go out in a single write. Each
+     * chunk advances lastWin32WriteAt so the submit settle-gate keeps waiting until
+     * the final chunk is out and echoed.
+     */
+    private writeWin32Body;
+    /**
+     * win32 submit. Two phases:
+     *
+     *  Phase 1 (settle-gate): hold the first CR until the PTY output has been quiet
+     *  for WIN32_SUBMIT_SETTLE_MS after the last input write — i.e. the full
+     *  (possibly multi-KB / multiline) body has finished arriving in the composer
+     *  and echoing. Honors an initial minimum delay and is bounded by
+     *  WIN32_SUBMIT_MAX_SETTLE_WAIT_MS so a noisy screen can never hang the submit.
+     *  This is what stops a long message from being submitted half-arrived (its
+     *  leading lines lost). A short message settles almost immediately.
+     *
+     *  Phase 2 (verified resend — unchanged): send the submit key, wait a gap, and
+     *  if the FSM is still 'idle' (the CR was absorbed as a multiline-paste
+     *  newline) resend, up to WIN32_SUBMIT_MAX_RESENDS. The first CR always fires
+     *  (a stale/edge status never suppresses it); resends are gated on still being
+     *  idle and stop the instant the agent leaves idle (submitted → generating /
+     *  approval). This preserves the win32 lone-CR-swallow handling.
      */
     private scheduleWin32Submit;
     private handleClickControl;

package/dist/providers/spec/fsm-evaluator.d.ts

@@ -19,6 +19,10 @@ export interface CondResult {
     /** Remaining ms until a time-based condition would flip to true. 0 if
      *  already true or not applicable. Lets the UI show a countdown. */
     remainingMs?: number;
+    /** Debug-only: the actual substring a TRUE regex condition matched, so the
+     *  snapshot shows WHAT text the rule fired on — not just which regex. Never
+     *  read by the FSM; purely for the Spec Debug Snapshot. */
+    matchedText?: string;
     children?: CondResult[];
 }
 /** One evaluated transition with its full reasoning. */

package/dist/providers/spec/types.d.ts

@@ -123,11 +123,15 @@ export interface SectionDef {
     until?: string;
     /**
      * Anchor regex(es). A single string anchors on the first/last matching line
-     * (per `anchor_last`). An array is an OR-set: every candidate line is one
-     * that matches ANY entry; with `anchor_last` the LAST such line across all
-     * patterns wins, otherwise the FIRST. This lets one section capture two
-     * different shapes — e.g. a box-divider modal AND a divider-less modal whose
-     * only stable landmark is the question line above its numbered choices.
+     * (per `anchor_last`). An array is an OR-set of candidate shapes: each
+     * candidate resolves its OWN anchor line independently (anchor_last → that
+     * candidate's last matching line, else its first), then the TOPMOST resolved
+     * line across candidates wins — a section's anchor marks the top of its
+     * block, so the highest recognized landmark bounds the whole block. This
+     * lets one section capture two shapes — e.g. a box-divider modal AND a
+     * divider-less modal whose only stable landmark is the question line above
+     * its numbered choices — while preventing a stray LOWER landmark (e.g. an
+     * input-box `────` rule below the choices) from clipping the block.
      */
     anchor?: string | string[];
     anchor_flags?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.353",
+  "version": "0.9.82-rc.355",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.353",
+    "@adhdev/mesh-shared": "0.9.82-rc.355",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/cli-manager.ts

@@ -18,7 +18,7 @@ import { loadConfig } from '../config/config.js';
 import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
-import { unregisterMeshCoordinator } from '../mesh/coordinator-registry.js';
+import { unregisterMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { upsertSavedProviderSession } from '../config/saved-sessions.js';
 import { buildLegacyModelModeSummaryMetadata, normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
@@ -1042,6 +1042,24 @@ export class DaemonCliManager {
                 );
                 continue;
             }
+            // Re-establish the launch-time settings a fresh launch applies. startSession
+            // seeds every new instance with { ...providerLoader.getSettings(type), ...override };
+            // passing a bare {} here on restart silently dropped TWO launch settings, so a
+            // restored session diverged from a freshly-launched one:
+            //   - autoApprove (a provider/machine setting from getSettings) → a restored
+            //     coordinator self-session lost auto-approve and re-prompted on every tool call.
+            //   - meshCoordinatorFor (the coordinator launch's settingsOverride) → the restored
+            //     session was no longer recognized as this daemon's live CLI coordinator by
+            //     findLiveCoordinators (so pending mesh events stopped draining into its PTY) nor
+            //     surfaced with the coordinator badge via settings. The persisted coordinator
+            //     registry (loaded on boot) is the source of truth to rebuild that mark.
+            // Both restores are provider-agnostic — getSettings is keyed by provider type and the
+            // registry mark is type-independent.
+            const restoredSettings: Record<string, any> = { ...this.providerLoader.getSettings(normalizedType) };
+            const coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+            if (coordinatorEntry?.meshId) {
+                restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
+            }
             try {
                 await this.registerCliInstance(
                     record.runtimeId,
@@ -1050,7 +1068,7 @@ export class DaemonCliManager {
                     record.workspace,
                     record.cliArgs,
                     resolvedProvider,
-                    {},
+                    restoredSettings,
                     true,
                     {
                         providerSessionId: sessionBinding.providerSessionId,

package/src/commands/handler.ts

@@ -25,6 +25,7 @@ import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry
 import { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 import { resolveLegacyProviderScript, type LegacyStringScript } from './provider-script-resolver.js';
+import { MANUAL_ATTENDANCE_COMMANDS } from '../providers/manual-attendance.js';
 
 // Sub-module imports
 import * as Chat from './chat-commands.js';
@@ -375,6 +376,36 @@ export class DaemonCommandHandler implements CommandHelpers {
         this._agentStream = manager;
     }
 
+    /**
+     * When a command in the manual-attendance set arrives for a session this
+     * daemon hosts, stamp the live instance so auto-approve holds while the user
+     * drives the session by hand. Provider-common: the signal is the command
+     * (foreground select_session / open_panel, controlbar invoke_provider_script
+     * / set_mode / change_model / set_thought_level, manual resolve_action,
+     * pty_input), never any CLI-specific modal text — so it works identically for
+     * every CLI/ACP provider. send_chat is deliberately excluded because a
+     * coordinator delegating a task to a worker also uses send_chat; counting it
+     * would wrongly suppress the worker's delegated auto-approve. For a remote
+     * mesh worker session the controlbar commands are forwarded to the owning
+     * worker daemon, which runs this same hook there, so attendance is recorded
+     * on the daemon that actually hosts the instance.
+     */
+    private noteManualAttendanceIfApplicable(cmd: string, args: any): void {
+        if (!MANUAL_ATTENDANCE_COMMANDS.has(cmd)) return;
+        const sessionId = this._currentRoute.session?.sessionId
+            || (typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '');
+        if (!sessionId) return;
+        const session = this._ctx.sessionRegistry?.get(sessionId);
+        const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
+        const instance = this._ctx.instanceManager?.getInstance(instanceKey) as
+            { noteManualInteraction?: (now?: number) => void } | undefined;
+        try {
+            instance?.noteManualInteraction?.();
+        } catch {
+            // attendance is best-effort — never block command dispatch
+        }
+    }
+
     // ─── Command Dispatcher ──────────────────────────
 
     async handle(cmd: string, args: any): Promise<CommandResult> {
@@ -382,6 +413,7 @@ export class DaemonCommandHandler implements CommandHelpers {
         this._currentRoute = this.resolveRoute(args);
         const startedAt = Date.now();
         this.logCommandStart(cmd, args);
+        this.noteManualAttendanceIfApplicable(cmd, args);
         let result: CommandResult;
 
         if (isGitCommandName(cmd)) {

package/src/commands/router.ts

@@ -8110,7 +8110,10 @@ export class DaemonCommandRouter {
                 // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
                 // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
                 const selfDaemonId = this.deps.statusInstanceId;
-                const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+                // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
+                // machine's core must be treated as local (not remote) so it is not forwarded /
+                // P2P self-dialed. Equivalent → local.
+                const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
                 if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
                     const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
                         ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
@@ -8154,7 +8157,9 @@ export class DaemonCommandRouter {
                 // once the call lands on the owning daemon — that daemon then reads
                 // its own logs even if the stored daemonId uses a legacy form.
                 const selfDaemonId = this.deps.statusInstanceId;
-                const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+                // daemonIdsEquivalent: a legacy-form daemonId resolving to this machine's core is
+                // local — read locally instead of forwarding. Equivalent → local.
+                const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
                 if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
                     const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId!, 'get_mesh_node_logs', {
                         ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
@@ -8230,7 +8235,9 @@ export class DaemonCommandRouter {
                     const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                     const nodeDaemonId = typeof forwardNode?.daemonId === 'string' ? forwardNode.daemonId.trim() : undefined;
                     const selfDaemonId = this.deps.statusInstanceId;
-                    const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+                    // daemonIdsEquivalent: a legacy-form daemonId resolving to this machine's core
+                    // is local — execute locally instead of forwarding. Equivalent → local.
+                    const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
                     if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
                         const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === 'string' && args.coordinatorDaemonId.trim()
                             ? args.coordinatorDaemonId.trim()
@@ -8347,7 +8354,9 @@ export class DaemonCommandRouter {
                     let worktreeCleanup: Record<string, unknown> | undefined;
                     if (node?.isLocalWorktree) {
                         const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
-                        const isRemoteWorktree = nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand
+                        // daemonIdsEquivalent: an equivalent-form daemonId is this machine —
+                        // clean up locally, do not forward. Equivalent → local.
+                        const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
                             && !args?._meshDirectDispatch;
                         if (isRemoteWorktree) {
                             // Worktree lives on a different machine — ask that daemon to clean it up.
@@ -8473,7 +8482,9 @@ export class DaemonCommandRouter {
                     // _meshDirectDispatch prevents infinite re-forwarding when the stored daemonId
                     // uses a legacy format that doesn't match the receiving daemon's statusInstanceId.
                     const sourceDaemonId = typeof sourceNode.daemonId === 'string' ? sourceNode.daemonId.trim() : undefined;
-                    if (sourceDaemonId && sourceDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand
+                    // daemonIdsEquivalent: an equivalent-form source daemonId is this machine —
+                    // clone locally, do not forward. Equivalent → local.
+                    if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
                         && !args?._meshDirectDispatch) {
                         const forwarded = await this.deps.dispatchMeshCommand(sourceDaemonId, 'clone_mesh_node', {
                             ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
@@ -8748,7 +8759,9 @@ export class DaemonCommandRouter {
                     // Bootstrap runs scripts in the worktree path — forward to the node's daemon if remote.
                     // _meshDirectDispatch prevents re-forwarding when stored daemonId uses legacy format.
                     const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
-                    if (nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand
+                    // daemonIdsEquivalent: an equivalent-form daemonId is this machine —
+                    // bootstrap locally, do not forward. Equivalent → local.
+                    if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
                         && !args?._meshDirectDispatch) {
                         const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, 'retry_mesh_node_bootstrap', {
                             ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),

package/src/git/git-diff.ts

@@ -1,7 +1,7 @@
 import { readFile, realpath } from 'node:fs/promises';
 import * as path from 'node:path';
 import type { GitDiffSummary, GitFileChange, GitFileChangeStatus } from './git-types.js';
-import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
+import { GIT_STATUS_TIMEOUT_MS, GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
 
 const DEFAULT_MAX_FILES = 200;
 const DEFAULT_MAX_BYTES = 200_000;
@@ -18,6 +18,21 @@ export interface GitDiffOptions {
   baseRef?: string;
 }
 
+/**
+ * Diff collection fans out an even larger parallel git burst than status (up to five
+ * concurrent spawns — name-status/numstat × unstaged/staged + ls-files — plus its own
+ * `rev-parse --show-toplevel`) and runs concurrently with the status path. On Windows the
+ * per-spawn cost alone can exceed the 5s `execGitRaw` default, so — exactly like
+ * getGitRepoStatus — give the collection path the larger status budget unless the caller
+ * pinned a timeout. Without this, a slow-but-healthy Windows worktree times out on the diff
+ * burst and the catch below flattens it to `repoRoot:null, isGitRepo:false`, dropping the
+ * diff while the (already-hardened) status block reports isGitRepo:true — an asymmetric
+ * failure that reads as "not a git repo" for diff only.
+ */
+function withCollectionTimeout(options: GitDiffOptions): GitDiffOptions {
+  return options.timeoutMs === undefined ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
+}
+
 function validateBaseRef(ref: string): string {
   const trimmed = ref.trim();
   if (!trimmed || trimmed.startsWith('-') || trimmed.includes('..') || !/^[A-Za-z0-9][A-Za-z0-9._/@-]*$/.test(trimmed)) {
@@ -54,16 +69,17 @@ export async function getGitDiffSummary(
   options: GitDiffOptions = {},
 ): Promise<GitDiffSummary> {
   const lastCheckedAt = Date.now();
+  const effectiveOptions = withCollectionTimeout(options);
 
   try {
-    const repo = await resolveGitRepository(workspace, options);
+    const repo = await resolveGitRepository(workspace, effectiveOptions);
     const repoRoot = repo.repoRoot!;
 
     if (options.baseRef) {
       const range = `${validateBaseRef(options.baseRef)}...HEAD`;
       const [nameStatus, numstat] = await Promise.all([
-        runGit(repo, ['diff', '--no-ext-diff', '--name-status', range, '--'], { ...options, cwd: repoRoot }),
-        runGit(repo, ['diff', '--no-ext-diff', '--numstat', range, '--'], { ...options, cwd: repoRoot }),
+        runGit(repo, ['diff', '--no-ext-diff', '--name-status', range, '--'], { ...effectiveOptions, cwd: repoRoot }),
+        runGit(repo, ['diff', '--no-ext-diff', '--numstat', range, '--'], { ...effectiveOptions, cwd: repoRoot }),
       ]);
       const outputBytes = byteLength(nameStatus.stdout + numstat.stdout);
       const changes = combineDiffEntries(nameStatus.stdout, numstat.stdout, false);
@@ -83,11 +99,11 @@ export async function getGitDiffSummary(
     }
 
     const [unstagedNameStatus, unstagedNumstat, stagedNameStatus, stagedNumstat, untracked] = await Promise.all([
-      runGit(repo, ['diff', '--no-ext-diff', '--name-status'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--no-ext-diff', '--numstat'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--name-status'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--numstat'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['ls-files', '--others', '--exclude-standard'], { ...options, cwd: repoRoot }),
+      runGit(repo, ['diff', '--no-ext-diff', '--name-status'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--no-ext-diff', '--numstat'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--name-status'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--numstat'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['ls-files', '--others', '--exclude-standard'], { ...effectiveOptions, cwd: repoRoot }),
     ]);
 
     const outputBytes = byteLength(
@@ -139,14 +155,15 @@ export async function getGitFileDiff(
   options: GitDiffOptions = {},
 ): Promise<GitFileDiffResult> {
   const lastCheckedAt = Date.now();
-  const repo = await resolveGitRepository(workspace, options);
+  const effectiveOptions = withCollectionTimeout(options);
+  const repo = await resolveGitRepository(workspace, effectiveOptions);
   const repoRoot = repo.repoRoot!;
   const selected = await resolveRepoFilePath(repoRoot, filePath);
   const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
 
   if (options.baseRef) {
     const range = `${validateBaseRef(options.baseRef)}...HEAD`;
-    const result = await runGit(repo, ['diff', '--no-ext-diff', range, '--', selected.relativePath], { ...options, cwd: repoRoot });
+    const result = await runGit(repo, ['diff', '--no-ext-diff', range, '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot });
     const bounded = truncateText(result.stdout, maxBytes);
     return {
       workspace: repo.workspace,
@@ -160,15 +177,15 @@ export async function getGitFileDiff(
   }
 
   const [unstaged, staged] = await Promise.all([
-    runGit(repo, ['diff', '--no-ext-diff', '--', selected.relativePath], { ...options, cwd: repoRoot }),
-    runGit(repo, ['diff', '--cached', '--no-ext-diff', '--', selected.relativePath], { ...options, cwd: repoRoot }),
+    runGit(repo, ['diff', '--no-ext-diff', '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
+    runGit(repo, ['diff', '--cached', '--no-ext-diff', '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
   ]);
 
   let diff = [unstaged.stdout, staged.stdout].filter((part) => part.length > 0).join('\n');
 
   if (!diff) {
     const untracked = await runGit(repo, ['ls-files', '--others', '--exclude-standard', '--', selected.relativePath], {
-      ...options,
+      ...effectiveOptions,
       cwd: repoRoot,
     });
     const untrackedFiles = untracked.stdout.split('\n').filter(Boolean);