@adhdev/daemon-core 0.9.82-rc.521 → 0.9.82-rc.523

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

@@ -1,5 +1,8 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
+/** Whether the assignment path currently holds an ff lease on this node's workspace —
+ *  used to skip a task claim while an auto ff is mutating the same workspace. */
+export declare function isWorkspaceAutoFastForwardInFlight(workspace: string | undefined): boolean;
 export declare function __resetIdleAutoFastForwardForTests(): void;
 export declare function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
@@ -154,6 +157,19 @@ export declare function maybeAutoFastForwardIdleNode(components: DaemonComponent
     sessionId?: string;
     providerType?: string;
 }): Promise<void>;
+/**
+ * Continuous-mode remote auto fast-forward scan (mode:"continuous" only). Called by
+ * the reconcile tick BEFORE queue claim. Scans every connected, eligible, non-worktree
+ * remote node of every mesh this daemon hosts and delegates an ff to its owning daemon
+ * when it is online/clean/behind within policy. Per-node cooldown + the workspace lease
+ * keep the ~4s reconcile cadence from hammering peers or racing an assignment.
+ *
+ * Ephemeral worktree nodes are DELIBERATELY excluded from the continuous catch-up: a
+ * Refinery worktree branch must not be silently advanced by a background scan (only its
+ * own idle-edge ff, which the coordinator drives intentionally). Non-worktree base
+ * nodes are the sole continuous target.
+ */
+export declare function runContinuousAutoFastForwardScan(components: DaemonComponents, mesh: any): Promise<void>;
 export declare function runIdleMaintenanceThenAssignQueue(components: DaemonComponents, args: {
     meshId: string;
     nodeId: string;

package/dist/repo-mesh-types.d.ts

@@ -184,6 +184,25 @@ export interface RepoMeshAutoFastForwardPolicy {
     maxBehind?: number;
     /** Defaults to true. Require submodule status to be clean before automatic fast-forward. */
     requireCleanSubmodules?: boolean;
+    /**
+     * Opt-in: extend auto fast-forward to REMOTE owning-daemon nodes (not just the
+     * coordinator's local workspace). Defaults to **false** so the historical
+     * self-only behavior is preserved byte-for-byte. When true, the coordinator
+     * delegates the ff to the node's owning daemon via dispatchMeshCommand
+     * (fast_forward_mesh_node), which runs the same git safety gates on the machine
+     * that actually holds the workspace.
+     */
+    remoteNodes?: boolean;
+    /**
+     * When to run remote auto fast-forward detection. Defaults to **"idle"** — the
+     * historical behavior where the ff is only attempted on a node's idle edge
+     * (agent:ready / genuine generating_completed). "continuous" adds a periodic
+     * scan inside the reconcile tick so an online/clean/behind remote node is caught
+     * up even when it emits no fresh idle edge (e.g. a base node that has been idle
+     * for a while while upstream advanced). Only governs remote-node detection;
+     * local idle-edge ff is unchanged either way.
+     */
+    mode?: 'idle' | 'continuous';
 }
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;

package/package.json

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

package/src/commands/chat-commands-read.ts

@@ -386,7 +386,10 @@ function shouldPreserveNativeIdentity(providerType: string, sessionId: string, m
     // (A2.3) v2 stamped identity is producer-owned and globally stable; trust it
     // unconditionally. Producers may omit _turnKey (the daemon recomputes it
     // from the current ordering), so do not require turnKey for v2 messages.
-    if (providerUnitKey.startsWith('v2:') || providerUnitKey.startsWith('v2-pty:')) {
+    // (CHAT-FLAP-LONG-CONVO) v3 native identity is daemon-stamped and
+    // position-independent (see normalizeNativeHistoryMessages); trust it the
+    // same way so a re-read of an already-normalized message preserves its key.
+    if (providerUnitKey.startsWith('v2:') || providerUnitKey.startsWith('v2-pty:') || providerUnitKey.startsWith('v3:')) {
         return true;
     }
     // v1 identity always required both keys to be present.
@@ -474,8 +477,30 @@ function normalizeAndFilterNativeHistory(
     return maybeHideCoordinatorPromptMessage(h, providerType, sessionId, normalized);
 }
 
-function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[] {
+export function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[] {
     let turnIndex = 0;
+    // (CHAT-FLAP-LONG-CONVO root fix) The providerUnitKey / bubbleId MUST be
+    // position-independent: native history is re-derived on every read_chat, so
+    // sending a user message grows the tail and shifts every array index by one.
+    // A key that embeds `index` therefore changes for every pre-existing bubble
+    // across a send → web-core getChatMessageStableKey (which correctly trusts
+    // bubbleId/providerUnitKey as identity) sees a new React key → unmount+remount
+    // flash. The invariant we enforce here: the same logical message keeps the
+    // same key as the tail grows; different messages get different keys.
+    //
+    // Position-independent identity = (role, kind, content-signature) plus, for
+    // messages whose (role, kind, content-signature) collides (e.g. an identical
+    // reply repeated in the transcript, or ts-less messages), a stable occurrence
+    // ordinal: the count of prior messages sharing the same signature. Appending
+    // to the tail never renumbers earlier occurrences, so the ordinal is stable.
+    // A provider-supplied native id (message.id) short-circuits the ordinal — it
+    // is already globally unique and position-independent.
+    const signatureOccurrences = new Map<string, number>();
+    // Anchor for the ts-less sequence fallback (see below): the last real
+    // timestamp seen, plus a running offset so consecutive ts-less messages stay
+    // strictly ordered after it.
+    let lastSequenceAnchor = 0;
+    let anchorOffset = 0;
     return normalizeChatMessages(messages).map((message, index) => {
         const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
         const kind = typeof message.kind === 'string' && message.kind.trim() ? message.kind.trim() : (role === 'system' ? 'system' : 'standard');
@@ -483,21 +508,35 @@ function normalizeNativeHistoryMessages(providerType: string, messages: ChatMess
         const historySessionId = typeof (message as any).historySessionId === 'string'
             ? (message as any).historySessionId.trim()
             : '';
-        const contentHash = hashSignatureParts([
+        // Content signature is intentionally position-independent: the ts fallback
+        // is '' (NOT `index`) so a message with no timestamp still hashes the same
+        // regardless of where it sits in the array. Hash the FULL flattened content
+        // (no slice) so distinct long messages that share a 12-char prefix do not
+        // collide.
+        const contentSignature = hashSignatureParts([
             providerType,
             historySessionId,
-            String(message.receivedAt || message.timestamp || index),
+            String(message.receivedAt || message.timestamp || ''),
             role,
             kind,
             flattenContent(message.content),
-        ]).slice(0, 12);
+        ]);
+        const contentHash = contentSignature.slice(0, 12);
         const nativeIdentitySessionId = historySessionId || (typeof nativeSessionId === 'string' ? nativeSessionId.trim() : '');
+        // Stable occurrence ordinal for signature collisions (0 for the first,
+        // 1 for the second identical-signature message, …). A provider-native id,
+        // when present, is preferred as the collision discriminator because it is
+        // globally unique and never renumbers.
+        const nativeMessageId = typeof message.id === 'string' && message.id.trim() ? message.id.trim() : '';
+        const occurrence = signatureOccurrences.get(contentSignature) ?? 0;
+        signatureOccurrences.set(contentSignature, occurrence + 1);
+        const collisionDiscriminator = nativeMessageId || `#${occurrence}`;
         const preserveNativeIdentity = shouldPreserveNativeIdentity(providerType, nativeIdentitySessionId, message);
         const existingProviderUnitKey = typeof message.providerUnitKey === 'string' ? message.providerUnitKey.trim() : '';
         const existingTurnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
         const providerUnitKey = preserveNativeIdentity
             ? existingProviderUnitKey
-            : `${providerType}:native:${nativeIdentitySessionId || 'workspace'}:${index}:${role || 'message'}:${kind}:${contentHash}`;
+            : `v3:${providerType}:native:${nativeIdentitySessionId || 'workspace'}:${role || 'message'}:${kind}:${contentHash}:${collisionDiscriminator}`;
         const meta = message.meta && typeof message.meta === 'object' ? message.meta as Record<string, unknown> : undefined;
         const isSystemSessionStart = role === 'system' || kind === 'system' || kind === 'session_start';
         const isActivity = role === 'assistant' && (kind === 'tool' || kind === 'terminal' || kind === 'thought');
@@ -510,9 +549,23 @@ function normalizeNativeHistoryMessages(providerType: string, messages: ChatMess
                 ? (message as any).sequence
                 : null;
         const tsCandidate = Number(message.receivedAt || message.timestamp || 0);
-        const sequence = existingSequence !== null
-            ? existingSequence
-            : (tsCandidate > 0 ? tsCandidate : index);
+        // (CHAT-FLAP-LONG-CONVO) sequence is part of web-core's React-key
+        // composite, so a ts-less fallback of `index` would also shift the key
+        // across a send. Anchor a ts-less message to the last real timestamp
+        // seen (plus its occurrence offset within that anchor) so the value stays
+        // ordered AND stable under tail-append instead of tracking the raw
+        // array position.
+        let sequence: number;
+        if (existingSequence !== null) {
+            sequence = existingSequence;
+        } else if (tsCandidate > 0) {
+            sequence = tsCandidate;
+            lastSequenceAnchor = tsCandidate;
+            anchorOffset = 0;
+        } else {
+            anchorOffset += 1;
+            sequence = lastSequenceAnchor + anchorOffset;
+        }
         return {
             ...message,
             role: role === 'human' ? 'user' : (role || 'assistant'),

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

@@ -47,8 +47,47 @@ function localCoordinatorDaemonId(): string | undefined {
 const IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1000;
 const idleAutoFastForwardLastAttempt = new Map<string, number>();
 
+// Continuous-mode per-node scan cooldown (mode:"continuous" reconcile scan). The
+// reconcile tick fires every ~4s; fetching every connected peer that often would
+// hammer the network and each owning daemon's git. This cooldown throttles the
+// per-node continuous scan to at most once per window (default 45s), independent of
+// the 30-minute idle-edge throttle above (which stays the idle-edge cadence).
+const CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS = 45 * 1000;
+const continuousAutoFastForwardLastScan = new Map<string, number>();
+
+// Workspace mutation lease. A git-mutating auto ff and the task-assignment path must
+// not both touch the same workspace concurrently (an ff mid-checkout while a task is
+// being dispatched can move HEAD out from under the worker). The lease is keyed by
+// CANONICAL WORKSPACE — not nodeId — so two mesh nodes that reference the same
+// on-disk workspace (e.g. a base node and a stale duplicate) cannot both ff it at
+// once. Best-effort in-process advisory lock; a crash mid-ff simply leaves a stale
+// entry that the finally-release clears on the same tick, so it never wedges.
+const autoFastForwardWorkspaceLease = new Set<string>();
+
+function acquireAutoFastForwardLease(workspace: string): boolean {
+    const key = normalizeMeshWorkspaceForCompare(workspace);
+    if (!key) return false;
+    if (autoFastForwardWorkspaceLease.has(key)) return false;
+    autoFastForwardWorkspaceLease.add(key);
+    return true;
+}
+
+function releaseAutoFastForwardLease(workspace: string): void {
+    const key = normalizeMeshWorkspaceForCompare(workspace);
+    if (key) autoFastForwardWorkspaceLease.delete(key);
+}
+
+/** Whether the assignment path currently holds an ff lease on this node's workspace —
+ *  used to skip a task claim while an auto ff is mutating the same workspace. */
+export function isWorkspaceAutoFastForwardInFlight(workspace: string | undefined): boolean {
+    const key = normalizeMeshWorkspaceForCompare(workspace || '');
+    return !!key && autoFastForwardWorkspaceLease.has(key);
+}
+
 export function __resetIdleAutoFastForwardForTests(): void {
     idleAutoFastForwardLastAttempt.clear();
+    continuousAutoFastForwardLastScan.clear();
+    autoFastForwardWorkspaceLease.clear();
 }
 
 export function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined {
@@ -386,6 +425,18 @@ export function tryAssignQueueTask(
     // resolve, mirroring the remote idle-session path below (:1341).
     const node = mesh?.nodes.find((n: any) => meshNodeIdMatches(n, nodeId));
 
+    // AUTO-FF LEASE: an auto fast-forward may be mutating this node's workspace right
+    // now (git merge --ff-only can move HEAD). Dispatching a task into it mid-checkout
+    // would run the worker against an inconsistent tree. Skip the claim while the lease
+    // is held — the task stays pending (return false without touching its status) and
+    // re-fires on the next drain tick, by which time the short ff has released the lease.
+    // Keyed by canonical workspace so a node sharing a workspace with the one being ff'd
+    // is also gated. No-op unless an auto ff is actually in flight (default: never).
+    if (isWorkspaceAutoFastForwardInFlight(readNonEmptyString(node?.workspace))) {
+        LOG.info('MeshQueue', `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace — task left pending, claim re-fires next tick`);
+        return false;
+    }
+
     // WORKTREE-CLAIM-GATE-BYPASS: the SINGLE claim-time gate for the worktree-bootstrap defer.
     // tryAssignQueueTask is the one funnel every claim path flows through — the event-driven
     // agent:ready drain, the triggerMeshQueue idle-session drain (local + remote), the
@@ -1006,7 +1057,7 @@ function isDirtyNode(node: any): boolean {
     return node?.health === 'dirty' || node?.git?.dirty === true;
 }
 
-function resolveAutoFastForwardPolicy(mesh: any): { enabled: boolean; maxBehind?: number; requireCleanSubmodules: boolean } {
+function resolveAutoFastForwardPolicy(mesh: any): { enabled: boolean; maxBehind?: number; requireCleanSubmodules: boolean; remoteNodes: boolean; mode: 'idle' | 'continuous' } {
     const record = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === 'object' && !Array.isArray(mesh.policy.autoFastForward)
         ? mesh.policy.autoFastForward as Record<string, unknown>
         : {};
@@ -1015,6 +1066,11 @@ function resolveAutoFastForwardPolicy(mesh: any): { enabled: boolean; maxBehind?
         enabled: record.enabled !== false,
         ...(Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {}),
         requireCleanSubmodules: record.requireCleanSubmodules !== false,
+        // Strict opt-in: absent/false → self-only (historical behavior). Only an
+        // explicit `true` extends auto ff to remote owning-daemon nodes.
+        remoteNodes: record.remoteNodes === true,
+        // Absent/anything-but-continuous → 'idle' (historical idle-edge-only detection).
+        mode: record.mode === 'continuous' ? 'continuous' : 'idle',
     };
 }
 
@@ -2448,61 +2504,245 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
     };
 }
 
-export async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args: {
+/** Passed dry-run result satisfies the policy gates (maxBehind + clean submodules).
+ *  Shared by the local execute path and the remote preflight re-verification so both
+ *  apply exactly the same policy gate. */
+function dryRunSatisfiesAutoFastForwardPolicy(
+    dryRun: { code?: string; allowed?: boolean; current?: any } | null | undefined,
+    policy: { maxBehind?: number; requireCleanSubmodules: boolean },
+): boolean {
+    if (!dryRun || dryRun.code !== 'fast_forward_available' || dryRun.allowed !== true) return false;
+    const behind = Number(dryRun.current?.behind);
+    // Behind must be a real, positive count within the policy cap. ahead must be 0 for
+    // an ff-only merge — fast_forward_available already encodes that (ahead=0,behind>0),
+    // but re-assert behind>0 defensively for the continuous/remote path.
+    if (!Number.isFinite(behind) || behind <= 0) return false;
+    if (policy.maxBehind !== undefined && behind > policy.maxBehind) return false;
+    if (policy.requireCleanSubmodules) {
+        const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
+        if (submodules.some((submodule: any) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return false;
+    }
+    return true;
+}
+
+function readNodeSubmoduleIgnorePaths(node: any): string[] | undefined {
+    return Array.isArray(node?.policy?.submoduleIgnorePaths)
+        ? node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
+        : undefined;
+}
+
+/** Whether a node is eligible to be an auto-ff target this instant: connected (for a
+ *  remote node), not disabled/removed/readOnly, not a worktree still bootstrapping,
+ *  and holding no active mesh work (assignment / direct dispatch / busy session). The
+ *  worktree exclusion for continuous mode is applied by the caller (idle-edge ff still
+ *  runs for worktree nodes on their own idle edge). */
+function nodeIsAutoFastForwardEligible(components: DaemonComponents, meshId: string, nodeId: string, node: any, currentSessionId?: string): boolean {
+    if (!node) return false;
+    if (node.status === 'disabled' || node.status === 'removed') return false;
+    if (node.readOnly === true || node.policy?.readOnly === true) return false;
+    if (isWorktreeBootstrapStaleRunning(node)) return false;
+    if (node.worktreeBootstrap?.status === 'running') return false;
+    if (nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId)) return false;
+    return true;
+}
+
+/** True when the node is connected (has an open peer/DataChannel) per the same
+ *  authoritative peer-status getter the remote-event pull uses. When the getter is
+ *  UNWIRED (standalone — no remote nodes at all) this returns false so the continuous
+ *  scan never claims to reach a remote node it cannot dispatch to. */
+function remoteNodeIsConnected(components: DaemonComponents, node: any): boolean {
+    const daemonId = readMeshNodeDaemonId(node ?? {});
+    if (!daemonId) return false;
+    const getPeerStatus = components.getMeshPeerConnectionStatus;
+    if (getPeerStatus) {
+        const snapshot = getPeerStatus(daemonId);
+        return !!snapshot && String(snapshot.state) === 'connected';
+    }
+    // No peer-status getter: fall back to the node's own reported connection state.
+    return readNonEmptyString(node?.connection?.state).toLowerCase() === 'connected';
+}
+
+/**
+ * Execute an auto fast-forward for a REMOTE owning-daemon node by delegating to that
+ * daemon via dispatchMeshCommand('fast_forward_mesh_node'). The owning daemon re-runs
+ * the FULL git safety gate on the machine that actually holds the workspace, so the
+ * coordinator's earlier dry-run is only an eligibility hint — the fresh preflight on
+ * the owning daemon (STATUS_OPTIONS forceFresh) is the TOCTOU-safe decision point.
+ *
+ * We do NOT execute blindly: we first request a fresh remote dry-run, re-verify it
+ * against the policy gate, and only then send execute:true — closing the window
+ * between the coordinator's scan and the actual mutation. The lease is held across
+ * both remote calls so the assignment path cannot dispatch a task onto this workspace
+ * mid-ff.
+ */
+async function delegateRemoteAutoFastForward(components: DaemonComponents, args: {
     meshId: string;
     nodeId: string;
-    sessionId?: string;
-    providerType?: string;
+    node: any;
+    daemonId: string;
+    workspace: string;
+    policy: { maxBehind?: number; requireCleanSubmodules: boolean };
+    trigger: string;
 }): Promise<void> {
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    if (!dispatchMeshCommand) return;
+    if (!acquireAutoFastForwardLease(args.workspace)) return; // another ff already mutating this workspace
+    const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
     const mesh = getMeshWithCache(components, args.meshId);
-    const node = mesh?.nodes?.find((candidate: any) => meshNodeIdMatches(candidate, args.nodeId));
-    const workspace = readNonEmptyString(node?.workspace);
-    if (!workspace) return;
-    if (!existsSync(workspace)) return;
-
-    const policy = resolveAutoFastForwardPolicy(mesh);
-    if (!policy.enabled) return;
-    if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
-
-    const throttleKey = `${args.meshId}:${args.nodeId}`;
-    const now = Date.now();
-    const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
-    if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
-    idleAutoFastForwardLastAttempt.set(throttleKey, now);
+    const baseArgs: Record<string, unknown> = {
+        meshId: args.meshId,
+        nodeId: args.nodeId,
+        workspace: args.workspace,
+        inlineMesh: mesh,
+        ...(submoduleIgnorePaths ? { submoduleIgnorePaths } : {}),
+        trigger: args.trigger,
+        // Preserve the pre-fix self-only semantics for submodules: the local idle path
+        // never updated submodules (updateSubmodules:false), so the remote path matches.
+        updateSubmodules: false,
+    };
+    try {
+        // Fresh remote dry-run (owning daemon re-reads live git state) — TOCTOU re-check.
+        const remoteDry = await dispatchMeshCommand(args.daemonId, 'fast_forward_mesh_node', {
+            ...baseArgs,
+            execute: false,
+            dryRun: true,
+        }) as { code?: string; allowed?: boolean; current?: any } | null;
+        if (!dryRunSatisfiesAutoFastForwardPolicy(remoteDry, args.policy)) return;
+        // Re-check eligibility right before mutating: a task may have been dispatched to
+        // this node between the scan and now (busy → skip, not an error).
+        if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId)) return;
+        const executed = await dispatchMeshCommand(args.daemonId, 'fast_forward_mesh_node', {
+            ...baseArgs,
+            execute: true,
+            dryRun: false,
+        }) as { executed?: boolean; postStatus?: any; code?: string } | null;
+        if (executed?.executed === true) {
+            LOG.info('MeshFastForward', `Remote auto fast-forward executed for node ${args.nodeId} (daemon ${String(args.daemonId).slice(0, 12)}, trigger ${args.trigger})`);
+        }
+    } catch (e: any) {
+        LOG.warn('MeshFastForward', `Remote auto fast-forward delegation failed for ${args.nodeId}: ${e?.message || e}`);
+    } finally {
+        releaseAutoFastForwardLease(args.workspace);
+    }
+}
 
-    const submoduleIgnorePaths = Array.isArray(node?.policy?.submoduleIgnorePaths)
-        ? node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
-        : undefined;
+/** Execute an auto fast-forward for a LOCAL node (the coordinator's own workspace) —
+ *  the historical self-only path, now lease-guarded so a continuous-mode local scan
+ *  and the assignment path cannot race the same workspace. */
+async function executeLocalAutoFastForward(args: {
+    meshId: string;
+    nodeId: string;
+    node: any;
+    workspace: string;
+    policy: { maxBehind?: number; requireCleanSubmodules: boolean };
+    trigger: string;
+}): Promise<void> {
+    if (!acquireAutoFastForwardLease(args.workspace)) return;
+    const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
     try {
         const dryRun = await fastForwardMeshNode({
             meshId: args.meshId,
             nodeId: args.nodeId,
-            workspace,
+            workspace: args.workspace,
             execute: false,
             dryRun: true,
             updateSubmodules: false,
             submoduleIgnorePaths,
-            trigger: 'idle_auto',
+            trigger: args.trigger,
         });
-        if (!dryRun || dryRun.code !== 'fast_forward_available' || dryRun.allowed !== true) return;
-        const behind = Number(dryRun.current?.behind);
-        if (policy.maxBehind !== undefined && Number.isFinite(behind) && behind > policy.maxBehind) return;
-        if (policy.requireCleanSubmodules) {
-            const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
-            if (submodules.some((submodule: any) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return;
-        }
+        if (!dryRunSatisfiesAutoFastForwardPolicy(dryRun, args.policy)) return;
         await fastForwardMeshNode({
             meshId: args.meshId,
             nodeId: args.nodeId,
-            workspace,
+            workspace: args.workspace,
             execute: true,
             dryRun: false,
             updateSubmodules: false,
             submoduleIgnorePaths,
-            trigger: 'idle_auto',
+            trigger: args.trigger,
         });
     } catch (e: any) {
         LOG.warn('MeshFastForward', `Idle auto fast-forward check failed for ${args.nodeId}: ${e?.message || e}`);
+    } finally {
+        releaseAutoFastForwardLease(args.workspace);
+    }
+}
+
+export async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args: {
+    meshId: string;
+    nodeId: string;
+    sessionId?: string;
+    providerType?: string;
+}): Promise<void> {
+    const mesh = getMeshWithCache(components, args.meshId);
+    const node = mesh?.nodes?.find((candidate: any) => meshNodeIdMatches(candidate, args.nodeId));
+    const workspace = readNonEmptyString(node?.workspace);
+    if (!workspace) return;
+
+    const policy = resolveAutoFastForwardPolicy(mesh);
+    if (!policy.enabled) return;
+    if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
+
+    const throttleKey = `${args.meshId}:${args.nodeId}`;
+    const now = Date.now();
+    const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
+    if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
+    idleAutoFastForwardLastAttempt.set(throttleKey, now);
+
+    // Local node (coordinator's own workspace): the historical self-only path. Gate on
+    // existsSync — a local workspace must be on THIS disk. Unchanged behavior.
+    if (isLocalAutoLaunchNode(node)) {
+        if (!existsSync(workspace)) return;
+        await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: 'idle_auto' });
+        return;
+    }
+
+    // Remote node: strictly opt-in. Without remoteNodes:true the historical behavior
+    // (self-only) is preserved — a remote idle edge simply does nothing here.
+    if (!policy.remoteNodes) return;
+    const daemonId = readMeshNodeDaemonId(node ?? {});
+    if (!daemonId || !components.dispatchMeshCommand) return;
+    if (!remoteNodeIsConnected(components, node)) return;
+    await delegateRemoteAutoFastForward(components, { meshId: args.meshId, nodeId: args.nodeId, node, daemonId, workspace, policy, trigger: 'idle_auto' });
+}
+
+/**
+ * Continuous-mode remote auto fast-forward scan (mode:"continuous" only). Called by
+ * the reconcile tick BEFORE queue claim. Scans every connected, eligible, non-worktree
+ * remote node of every mesh this daemon hosts and delegates an ff to its owning daemon
+ * when it is online/clean/behind within policy. Per-node cooldown + the workspace lease
+ * keep the ~4s reconcile cadence from hammering peers or racing an assignment.
+ *
+ * Ephemeral worktree nodes are DELIBERATELY excluded from the continuous catch-up: a
+ * Refinery worktree branch must not be silently advanced by a background scan (only its
+ * own idle-edge ff, which the coordinator drives intentionally). Non-worktree base
+ * nodes are the sole continuous target.
+ */
+export async function runContinuousAutoFastForwardScan(components: DaemonComponents, mesh: any): Promise<void> {
+    if (!components.dispatchMeshCommand) return; // standalone has no remote nodes to scan
+    const policy = resolveAutoFastForwardPolicy(mesh);
+    if (!policy.enabled || !policy.remoteNodes || policy.mode !== 'continuous') return;
+    const meshId = readNonEmptyString(mesh?.id);
+    if (!meshId) return;
+    const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+    const now = Date.now();
+    for (const node of nodes) {
+        const nodeId = normalizeMeshNodeId(node);
+        if (!nodeId) continue;
+        // Continuous targets non-worktree remote base nodes only.
+        if (node?.isLocalWorktree === true) continue;
+        if (isLocalAutoLaunchNode(node)) continue; // local is covered by the idle-edge path
+        const workspace = readNonEmptyString(node?.workspace);
+        if (!workspace) continue;
+        const daemonId = readMeshNodeDaemonId(node ?? {});
+        if (!daemonId) continue;
+        if (!nodeIsAutoFastForwardEligible(components, meshId, nodeId, node)) continue;
+        if (!remoteNodeIsConnected(components, node)) continue;
+        const cooldownKey = `${meshId}:${nodeId}`;
+        const lastScan = continuousAutoFastForwardLastScan.get(cooldownKey) || 0;
+        if (now - lastScan < CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS) continue;
+        continuousAutoFastForwardLastScan.set(cooldownKey, now);
+        await delegateRemoteAutoFastForward(components, { meshId, nodeId, node, daemonId, workspace, policy, trigger: 'reconcile_auto' });
     }
 }
 

package/src/mesh/mesh-reconcile-loop.ts

@@ -61,7 +61,7 @@ import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage }
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent, sessionIdsEquivalent, meshNodeIdMatches, withStatusProbeMarker } from '@adhdev/mesh-shared';
 import { getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
-import { resolveSessionBusyVerdict } from './mesh-queue-assignment.js';
+import { resolveSessionBusyVerdict, runContinuousAutoFastForwardScan } from './mesh-queue-assignment.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerEntry } from './mesh-ledger.js';
 import { findTerminalLedgerEvidenceForTask } from './mesh-events-stale.js';
@@ -1082,6 +1082,26 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
     }
 
+    // ── PHASE 2.7: continuous remote auto fast-forward (opt-in, default OFF) ────
+    // mode:"continuous" + remoteNodes:true only. Catch up an online/clean/behind
+    // REMOTE base node that emits no fresh idle edge (e.g. a long-idle base node while
+    // upstream advanced). Runs BEFORE PHASE 3's queue claim so a node it advances is
+    // caught up before any new task is dispatched onto it. Cloud-only (dispatchMeshCommand);
+    // a per-node cooldown + workspace lease inside the scan keep the 4s cadence from
+    // hammering peers. No-op for every mesh that has not opted into continuous mode, so
+    // the default (idle-edge only) path is byte-for-byte unchanged.
+    if (dispatchMeshCommand) {
+        for (const mesh of listMeshes()) {
+            const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+            if (!daemonHostsMesh(mesh, selfIds)) continue;
+            try {
+                await runContinuousAutoFastForwardScan(components, mesh);
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Continuous auto fast-forward scan failed for mesh ${mesh.id}: ${e?.message || e}`);
+            }
+        }
+    }
+
     // ── PHASE 3: recover pending queue claims for newly-idle sessions ──────────
     // The event-driven claim paths (agent:ready / agent:generating_completed in
     // mesh-events-coordinator) re-claim the queue the moment a session goes idle,

package/src/providers/sdk/v1/builders/cli/parse-session.ts

@@ -132,13 +132,26 @@ export function normalizeMessageIdentity<T extends { role?: string; kind?: strin
 }> {
     const list = Array.isArray(messages) ? messages : []
     let turnIndex = -1
+    // (CHAT-FLAP-LONG-CONVO root fix) The PTY-parsed providerUnitKey must be
+    // position-independent for the same reason as the native-history path: the
+    // transcript is re-parsed on every read, so a `index`-embedded key changes
+    // for every pre-existing bubble whenever the tail grows, causing web-core to
+    // remount the bubble (a visible flash). Identity = (role, kind, content-hash)
+    // plus a stable occurrence ordinal that disambiguates identical repeated
+    // lines without renumbering earlier occurrences when the tail grows.
+    const signatureOccurrences = new Map<string, number>()
     return list.map((message, index) => {
         const role = message?.role || 'assistant'
         const kind = message?.kind || 'standard'
         const content = typeof message?.content === 'string' ? message.content : ''
         if (role === 'user' || turnIndex < 0) turnIndex += 1
-        const seed = [role, kind, '', index, content].join('\n')
-        const providerUnitKey = `v2-pty:${role}:${kind}:${index}:${stableHash(seed)}`
+        // Seed is position-independent: no array index. The occurrence ordinal is
+        // appended separately so identical repeated lines still get distinct keys.
+        const seed = [role, kind, '', content].join('\n')
+        const contentHash = stableHash(seed)
+        const occurrence = signatureOccurrences.get(contentHash) ?? 0
+        signatureOccurrences.set(contentHash, occurrence + 1)
+        const providerUnitKey = `v2-pty:${role}:${kind}:${contentHash}:#${occurrence}`
         const bubbleId = `bubble:${providerUnitKey}`
         const turnKey = `turn:${turnIndex}`
         const isStreamingTail = status === 'generating' && role === 'assistant' && index === list.length - 1