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

package/dist/commands/chat-commands-read.d.ts

@@ -3,6 +3,7 @@
  * native-history / source-resolution / normalization helpers they use.
  */
 import type { CommandResult, CommandHelpers } from './handler.js';
+import type { ChatMessage } from '../types.js';
 /**
  * Test-only: clear the in-memory read-pin map and re-arm cold-start hydration so
  * each test starts from a clean pin state. The on-disk mirror is isolated per
@@ -19,5 +20,6 @@ export declare function __resetProviderSessionPinsForTest(): void;
  * non-owner-confirmed read did NOT. Not part of the runtime contract.
  */
 export declare function __getProviderSessionPinForTest(meshSessionId: string): string | undefined;
+export declare function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[];
 export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
 export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;

package/dist/index.js

@@ -73,7 +73,9 @@ function normalizeAutoFastForwardPolicy(value) {
   return {
     enabled: record.enabled !== false,
     ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
-    requireCleanSubmodules: record.requireCleanSubmodules !== false
+    requireCleanSubmodules: record.requireCleanSubmodules !== false,
+    ...record.remoteNodes === true ? { remoteNodes: true } : {},
+    ...record.mode === "continuous" ? { mode: "continuous" } : {}
   };
 }
 function mergeAndNormalizePolicy(base, patch) {
@@ -417,10 +419,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "ba90523a7fd7277668cc67ab7c596402c3d77959" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "ba90523a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.521" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-14T01:41:02.959Z" : void 0);
+  const commit = readInjected(true ? "d3a44d29416fef77ac6cd36f4798637571260dfb" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "d3a44d29" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.522" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-14T03:03:55.067Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -15826,8 +15828,25 @@ var init_model_provider_compat = __esm({
 function localCoordinatorDaemonId() {
   return canonicalDaemonId(readNonEmptyString2(loadConfig().machineId));
 }
+function acquireAutoFastForwardLease(workspace) {
+  const key2 = normalizeMeshWorkspaceForCompare(workspace);
+  if (!key2) return false;
+  if (autoFastForwardWorkspaceLease.has(key2)) return false;
+  autoFastForwardWorkspaceLease.add(key2);
+  return true;
+}
+function releaseAutoFastForwardLease(workspace) {
+  const key2 = normalizeMeshWorkspaceForCompare(workspace);
+  if (key2) autoFastForwardWorkspaceLease.delete(key2);
+}
+function isWorkspaceAutoFastForwardInFlight(workspace) {
+  const key2 = normalizeMeshWorkspaceForCompare(workspace || "");
+  return !!key2 && autoFastForwardWorkspaceLease.has(key2);
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
+  continuousAutoFastForwardLastScan.clear();
+  autoFastForwardWorkspaceLease.clear();
 }
 function getMeshWithCache(components, meshId) {
   const localMesh = getMesh(meshId);
@@ -15960,6 +15979,10 @@ function deliverTaskToSession(dispatchThunk, ctx, warmup) {
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const mesh = getMeshWithCache(components, meshId);
   const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
+  if (isWorkspaceAutoFastForwardInFlight(readNonEmptyString2(node?.workspace))) {
+    LOG.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
+    return false;
+  }
   const inlineBootstrapNode = (() => {
     try {
       const inlineMesh = components.router?.getCachedInlineMesh?.(meshId);
@@ -16285,7 +16308,12 @@ function resolveAutoFastForwardPolicy(mesh) {
   return {
     enabled: record.enabled !== false,
     ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
-    requireCleanSubmodules: record.requireCleanSubmodules !== false
+    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"
   };
 }
 function sessionStateLooksActive(state) {
@@ -17035,51 +17063,157 @@ async function triggerMeshQueue(components, meshId) {
     ...pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchPending ? { noIdleMeshSessionAvailable: true } : {}
   };
 }
-async function maybeAutoFastForwardIdleNode(components, args) {
+function dryRunSatisfiesAutoFastForwardPolicy(dryRun, policy) {
+  if (!dryRun || dryRun.code !== "fast_forward_available" || dryRun.allowed !== true) return false;
+  const behind = Number(dryRun.current?.behind);
+  if (!Number.isFinite(behind) || behind <= 0) return false;
+  if (policy.maxBehind !== void 0 && behind > policy.maxBehind) return false;
+  if (policy.requireCleanSubmodules) {
+    const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
+    if (submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return false;
+  }
+  return true;
+}
+function readNodeSubmoduleIgnorePaths(node) {
+  return Array.isArray(node?.policy?.submoduleIgnorePaths) ? node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+}
+function nodeIsAutoFastForwardEligible(components, meshId, nodeId, node, currentSessionId) {
+  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;
+}
+function remoteNodeIsConnected(components, node) {
+  const daemonId = readMeshNodeDaemonId(node ?? {});
+  if (!daemonId) return false;
+  const getPeerStatus = components.getMeshPeerConnectionStatus;
+  if (getPeerStatus) {
+    const snapshot = getPeerStatus(daemonId);
+    return !!snapshot && String(snapshot.state) === "connected";
+  }
+  return readNonEmptyString2(node?.connection?.state).toLowerCase() === "connected";
+}
+async function delegateRemoteAutoFastForward(components, args) {
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  if (!dispatchMeshCommand) return;
+  if (!acquireAutoFastForwardLease(args.workspace)) return;
+  const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
   const mesh = getMeshWithCache(components, args.meshId);
-  const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
-  const workspace = readNonEmptyString2(node?.workspace);
-  if (!workspace) return;
-  if (!(0, import_fs13.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 submoduleIgnorePaths = Array.isArray(node?.policy?.submoduleIgnorePaths) ? node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+  const baseArgs = {
+    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 {
+    const remoteDry = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
+      ...baseArgs,
+      execute: false,
+      dryRun: true
+    });
+    if (!dryRunSatisfiesAutoFastForwardPolicy(remoteDry, args.policy)) return;
+    if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId)) return;
+    const executed = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
+      ...baseArgs,
+      execute: true,
+      dryRun: false
+    });
+    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) {
+    LOG.warn("MeshFastForward", `Remote auto fast-forward delegation failed for ${args.nodeId}: ${e?.message || e}`);
+  } finally {
+    releaseAutoFastForwardLease(args.workspace);
+  }
+}
+async function executeLocalAutoFastForward(args) {
+  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 !== void 0 && Number.isFinite(behind) && behind > policy.maxBehind) return;
-    if (policy.requireCleanSubmodules) {
-      const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
-      if (submodules.some((submodule) => 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) {
     LOG.warn("MeshFastForward", `Idle auto fast-forward check failed for ${args.nodeId}: ${e?.message || e}`);
+  } finally {
+    releaseAutoFastForwardLease(args.workspace);
+  }
+}
+async function maybeAutoFastForwardIdleNode(components, args) {
+  const mesh = getMeshWithCache(components, args.meshId);
+  const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
+  const workspace = readNonEmptyString2(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);
+  if (isLocalAutoLaunchNode(node)) {
+    if (!(0, import_fs13.existsSync)(workspace)) return;
+    await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: "idle_auto" });
+    return;
+  }
+  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" });
+}
+async function runContinuousAutoFastForwardScan(components, mesh) {
+  if (!components.dispatchMeshCommand) return;
+  const policy = resolveAutoFastForwardPolicy(mesh);
+  if (!policy.enabled || !policy.remoteNodes || policy.mode !== "continuous") return;
+  const meshId = readNonEmptyString2(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;
+    if (node?.isLocalWorktree === true) continue;
+    if (isLocalAutoLaunchNode(node)) continue;
+    const workspace = readNonEmptyString2(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" });
   }
 }
 function runIdleMaintenanceThenAssignQueue(components, args) {
@@ -17093,7 +17227,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var import_fs13, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, BOOTSTRAP_TERMINAL_STATUSES, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
+var import_fs13, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS, continuousAutoFastForwardLastScan, autoFastForwardWorkspaceLease, BOOTSTRAP_TERMINAL_STATUSES, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -17123,6 +17257,9 @@ var init_mesh_queue_assignment = __esm({
     init_model_provider_compat();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
+    CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS = 45 * 1e3;
+    continuousAutoFastForwardLastScan = /* @__PURE__ */ new Map();
+    autoFastForwardWorkspaceLease = /* @__PURE__ */ new Set();
     BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
     DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
     DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS;
@@ -22075,6 +22212,17 @@ async function runMeshReconcileTick(components) {
       }
     }
   }
+  if (dispatchMeshCommand) {
+    for (const mesh of listMeshes()) {
+      const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+      if (!daemonHostsMesh(mesh, selfIds)) continue;
+      try {
+        await runContinuousAutoFastForwardScan(components, mesh);
+      } catch (e) {
+        LOG.warn("MeshReconcile", `Continuous auto fast-forward scan failed for mesh ${mesh.id}: ${e?.message || e}`);
+      }
+    }
+  }
   for (const mesh of listMeshes()) {
     const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
     if (!daemonHostsMesh(mesh, selfIds)) continue;
@@ -24435,13 +24583,17 @@ function stableHash(value) {
 function normalizeMessageIdentity(messages, status) {
   const list = Array.isArray(messages) ? messages : [];
   let turnIndex = -1;
+  const signatureOccurrences = /* @__PURE__ */ new Map();
   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)}`;
+    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;
@@ -35833,7 +35985,7 @@ function shouldPreserveNativeIdentity(providerType, sessionId, message) {
   const providerUnitKey = typeof message.providerUnitKey === "string" ? message.providerUnitKey.trim() : "";
   const turnKey = typeof message._turnKey === "string" ? message._turnKey.trim() : "";
   if (!providerUnitKey) return false;
-  if (providerUnitKey.startsWith("v2:") || providerUnitKey.startsWith("v2-pty:")) {
+  if (providerUnitKey.startsWith("v2:") || providerUnitKey.startsWith("v2-pty:") || providerUnitKey.startsWith("v3:")) {
     return true;
   }
   if (!turnKey) return false;
@@ -35878,30 +36030,48 @@ function normalizeAndFilterNativeHistory(h, providerType, args, messages, native
 }
 function normalizeNativeHistoryMessages(providerType, messages, nativeSessionId) {
   let turnIndex = 0;
+  const signatureOccurrences = /* @__PURE__ */ new Map();
+  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";
     if ((role === "user" || role === "human") && index > 0) turnIndex += 1;
     const historySessionId = typeof message.historySessionId === "string" ? message.historySessionId.trim() : "";
-    const contentHash = hashSignatureParts([
+    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() : "");
+    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}`;
+    const providerUnitKey = preserveNativeIdentity ? existingProviderUnitKey : `v3:${providerType}:native:${nativeIdentitySessionId || "workspace"}:${role || "message"}:${kind}:${contentHash}:${collisionDiscriminator}`;
     const meta = message.meta && typeof message.meta === "object" ? message.meta : void 0;
     const isSystemSessionStart = role === "system" || kind === "system" || kind === "session_start";
     const isActivity = role === "assistant" && (kind === "tool" || kind === "terminal" || kind === "thought");
     const existingSequence = typeof message.sequence === "number" && Number.isFinite(message.sequence) ? message.sequence : null;
     const tsCandidate = Number(message.receivedAt || message.timestamp || 0);
-    const sequence = existingSequence !== null ? existingSequence : tsCandidate > 0 ? tsCandidate : index;
+    let sequence;
+    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",