@agent-native/core 0.87.0 → 0.90.1

package/corpus/core/src/client/AssistantChat.tsx

@@ -658,15 +658,14 @@ function toolCallFingerprintFromContentPart(part: unknown): string | null {
   const argsText =
     typeof candidate.argsText === "string" ? candidate.argsText : "";
   if (!name || !argsText) return null;
-  return `${name}${argsText}`;
+  return `${name}\u0000${argsText}`;
 }
 
 function collectRenderedToolCallStates(messages: readonly unknown[]): {
   byId: Map<string, { hasResult: boolean }>;
-  completedFingerprints: Set<string>;
+  latestAssistantByFingerprint: Map<string, { hasResult: boolean }>;
 } {
   const byId = new Map<string, { hasResult: boolean }>();
-  const completedFingerprints = new Set<string>();
   for (const message of messages) {
     const msg = (message as { message?: unknown })?.message ?? message;
     const content = (msg as { content?: unknown })?.content;
@@ -679,13 +678,29 @@ function collectRenderedToolCallStates(messages: readonly unknown[]): {
       byId.set(id, {
         hasResult: Boolean(existing?.hasResult || hasResult),
       });
-      if (hasResult) {
-        const fingerprint = toolCallFingerprintFromContentPart(part);
-        if (fingerprint) completedFingerprints.add(fingerprint);
-      }
     }
   }
-  return { byId, completedFingerprints };
+
+  const latestAssistantByFingerprint = new Map<
+    string,
+    { hasResult: boolean }
+  >();
+  const latestEntry = messages.at(-1);
+  const latestMessage = getRepoMessage(latestEntry as any);
+  const latestContent = latestMessage?.content;
+  if (latestMessage?.role === "assistant" && Array.isArray(latestContent)) {
+    for (const part of latestContent) {
+      const fingerprint = toolCallFingerprintFromContentPart(part);
+      if (!fingerprint) continue;
+      const hasResult = toolCallPartHasResult(part);
+      const existing = latestAssistantByFingerprint.get(fingerprint);
+      latestAssistantByFingerprint.set(fingerprint, {
+        hasResult: Boolean(existing?.hasResult || hasResult),
+      });
+    }
+  }
+
+  return { byId, latestAssistantByFingerprint };
 }
 
 function assistantTextFromContent(content: unknown): string {
@@ -707,6 +722,32 @@ function latestRenderedAssistantText(messages: readonly unknown[]): string {
   return assistantTextFromContent(latestMessage.content);
 }
 
+function dedupePendingToolCallReplaysWithinContent(
+  content: ContentPart[],
+): ContentPart[] {
+  const seenLaterFingerprints = new Set<string>();
+  let changed = false;
+  const nextReversed: ContentPart[] = [];
+
+  for (let i = content.length - 1; i >= 0; i -= 1) {
+    const part = content[i];
+    if (!part) continue;
+    const fingerprint = toolCallFingerprintFromContentPart(part);
+    if (
+      fingerprint &&
+      !toolCallPartHasResult(part) &&
+      seenLaterFingerprints.has(fingerprint)
+    ) {
+      changed = true;
+      continue;
+    }
+    if (fingerprint) seenLaterFingerprints.add(fingerprint);
+    nextReversed.push(part);
+  }
+
+  return changed ? nextReversed.reverse() : content;
+}
+
 function trimReconnectTextAlreadyRendered(
   content: ContentPart[],
   renderedAssistantText: string,
@@ -748,40 +789,50 @@ export function dedupeReconnectContentAgainstMessages(
   content: ContentPart[],
   messages: readonly unknown[],
 ): ContentPart[] {
-  if (content.length === 0 || messages.length === 0) return content;
-  const { byId, completedFingerprints } =
+  if (content.length === 0) return content;
+  const snapshotDeduped = dedupePendingToolCallReplaysWithinContent(content);
+  let changed = snapshotDeduped !== content;
+  if (messages.length === 0) return changed ? snapshotDeduped : content;
+  const { byId, latestAssistantByFingerprint } =
     collectRenderedToolCallStates(messages);
   const renderedAssistantText = latestRenderedAssistantText(messages);
-  if (byId.size === 0 && !renderedAssistantText) return content;
+  if (
+    byId.size === 0 &&
+    latestAssistantByFingerprint.size === 0 &&
+    !renderedAssistantText
+  ) {
+    return changed ? snapshotDeduped : content;
+  }
 
-  let changed = false;
-  const filtered = byId.size
-    ? content.filter((part) => {
-        const id = toolCallIdFromContentPart(part);
-        if (!id) return true;
-        const existing = byId.get(id);
-        if (existing) {
-          if (toolCallPartHasResult(part) && !existing.hasResult) return true;
-          changed = true;
-          return false;
-        }
-        // Fingerprint fallback for the id-convergence window: a reconnect part
-        // that is still PENDING while the rendered messages already show the same
-        // call (same tool + same serialized args) completed is a replay artifact —
-        // dropping it removes the "one spinning, one done" duplicate pair. Only
-        // pending parts are dropped by fingerprint: completed-vs-completed keeps
-        // the strict id match so a legitimately repeated identical call is never
-        // hidden.
-        if (!toolCallPartHasResult(part)) {
+  const filtered =
+    byId.size > 0 || latestAssistantByFingerprint.size > 0
+      ? snapshotDeduped.filter((part) => {
+          const id = toolCallIdFromContentPart(part);
+          const existing = id ? byId.get(id) : undefined;
+          if (existing) {
+            changed = true;
+            return false;
+          }
+          // Fingerprint fallback for the id-convergence window: two readers of
+          // the same active run can assign unrelated ids to the same logical tool
+          // call before the server id converges. Suppress the reconnect overlay
+          // whenever it matches the latest rendered assistant tool call and either
+          // side is still pending; completed-vs-completed remains visible so a
+          // legitimately repeated identical call is not hidden.
           const fingerprint = toolCallFingerprintFromContentPart(part);
-          if (fingerprint && completedFingerprints.has(fingerprint)) {
+          const latestByFingerprint = fingerprint
+            ? latestAssistantByFingerprint.get(fingerprint)
+            : undefined;
+          if (
+            latestByFingerprint &&
+            (!toolCallPartHasResult(part) || !latestByFingerprint.hasResult)
+          ) {
             changed = true;
             return false;
           }
-        }
-        return true;
-      })
-    : content;
+          return true;
+        })
+      : snapshotDeduped;
   const textDeduped = trimReconnectTextAlreadyRendered(
     filtered,
     renderedAssistantText,
@@ -4063,10 +4114,7 @@ const AssistantChatInner = forwardRef<
                                   setMissingKeyBouncePulse((p) => p + 1);
                                   return;
                                 }
-                                appendThreadMessage({
-                                  role: "user",
-                                  content: [{ type: "text", text: suggestion }],
-                                });
+                                void addToQueue(suggestion);
                               }}
                               className="w-full rounded-lg border border-border px-3 py-2 text-start text-[13px] text-muted-foreground hover:bg-accent hover:text-foreground"
                             >
@@ -4157,6 +4205,7 @@ const AssistantChatInner = forwardRef<
                         )}
                       {(isReconnecting || reconnectFrozen) &&
                         visibleReconnectContent.length === 0 &&
+                        reconnectContent.length === 0 &&
                         reconnectActivityContent.length > 0 && (
                           <ReconnectStreamMessage
                             content={reconnectActivityContent}
@@ -4255,13 +4304,6 @@ const AssistantChatInner = forwardRef<
                     />
                   </div>
                 )}
-                {showPlanModeCallout && (
-                  <PlanModeCallout
-                    canImplementPlan={canImplementPlan}
-                    onImplementPlan={handleImplementPlan}
-                    onSwitchToAct={handleSwitchToAct}
-                  />
-                )}
                 {/* Inline attachment / body-size error */}
                 {composerError && (
                   <div
@@ -4301,6 +4343,13 @@ const AssistantChatInner = forwardRef<
                       />
                     </div>
                   ) : null}
+                  {showPlanModeCallout && (
+                    <PlanModeCallout
+                      canImplementPlan={canImplementPlan}
+                      onImplementPlan={handleImplementPlan}
+                      onSwitchToAct={handleSwitchToAct}
+                    />
+                  )}
                   {/* Input area */}
                   <AgentComposerFrame
                     layoutVariant={composerLayoutVariant}

package/corpus/core/src/client/KeepTabOpenNotice.tsx

@@ -0,0 +1,176 @@
+import { IconInfoCircle } from "@tabler/icons-react";
+import { useEffect, useRef, useState } from "react";
+
+import { useRunStuckDetection } from "./use-run-stuck-detection.js";
+import { cn } from "./utils.js";
+
+/** Continuous foreground running time before the notice appears — just
+ *  before the hosted ~40s soft-timeout chunk boundary. */
+export const DEFAULT_KEEP_TAB_OPEN_AFTER_MS = 30_000;
+
+/**
+ * Subtle, non-blocking notice that a long-running FOREGROUND agent turn
+ * depends on this tab staying open.
+ *
+ * On hosted deployments a foreground turn runs in ~40s chunks and the CLIENT
+ * re-POSTs `auto_continue` to start each next chunk — close the tab
+ * mid-turn and the work silently stops at the next chunk boundary. Only
+ * server-driven runs (`dispatchMode` starting with "background": the durable
+ * background worker, or a server self-chained continuation) survive a closed
+ * tab, and for those this notice never shows.
+ *
+ * Visibility rules (show only while the condition is true — no new
+ * always-visible chrome):
+ *   - a foreground-dispatched run for this thread has been continuously
+ *     running for `showAfterMs` (default 30s — approaching the hosted ~40s
+ *     chunk boundary where the client-driven continuation starts), and
+ *   - the run is NOT background-dispatched (hidden immediately when the
+ *     server owns recovery), and
+ *   - this is a production client bundle (`hosted` auto-detect): local dev
+ *     runs a turn unbounded in a single chunk that survives a closed tab,
+ *     so the notice would be wrong there.
+ * Brief non-running blips (the sub-second gap between continuation chunks)
+ * are debounced so the notice does not flicker across chunk boundaries.
+ */
+export interface KeepTabOpenNoticeProps {
+  /** The thread to monitor. Pass null/undefined to disable. */
+  threadId: string | null | undefined;
+  /**
+   * Set false to skip polling entirely — used when this notice is mounted
+   * for a background tab kept alive via display:none. Only the active tab
+   * should poll `/runs/active`. Defaults to true.
+   */
+  enabled?: boolean;
+  /** API base path. Default `/_agent-native/agent-chat`. */
+  apiUrl?: string;
+  /**
+   * How long a foreground run must have been continuously running before
+   * the notice appears. Default 30s — just before the hosted ~40s
+   * soft-timeout chunk boundary, so short turns never see it.
+   */
+  showAfterMs?: number;
+  /**
+   * Whether this client is talking to a hosted (serverless) deployment
+   * whose foreground turns run in client-driven chunks. Defaults to
+   * auto-detection from the bundle mode (a dev bundle → not hosted).
+   */
+  hosted?: boolean;
+  /** Extra class on the outer container. */
+  className?: string;
+}
+
+/** How long the notice lingers through a non-running poll result before
+ *  hiding — covers the brief idle gap between continuation chunks. */
+const IDLE_LINGER_MS = 12_000;
+
+/** Poll interval for the notice's `/runs/active` loop. Deliberately slower
+ *  than the stuck-detector's default — the notice is passive, so freshness
+ *  matters less than keeping the extra polling cheap. */
+const NOTICE_POLL_INTERVAL_MS = 8_000;
+
+function isDevClientBundle(): boolean {
+  try {
+    return (
+      (import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV === true
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function KeepTabOpenNotice({
+  threadId,
+  enabled = true,
+  apiUrl,
+  showAfterMs = DEFAULT_KEEP_TAB_OPEN_AFTER_MS,
+  hosted,
+  className,
+}: KeepTabOpenNoticeProps) {
+  const effectiveHosted = hosted ?? !isDevClientBundle();
+  const state = useRunStuckDetection({
+    threadId,
+    enabled: enabled && effectiveHosted,
+    apiUrl,
+    pollIntervalMs: NOTICE_POLL_INTERVAL_MS,
+  });
+  const isBackgroundDispatch =
+    state.dispatchMode?.startsWith("background") === true;
+  const foregroundRunning =
+    state.status === "running" && Boolean(state.runId) && !isBackgroundDispatch;
+
+  const [visible, setVisible] = useState(false);
+  const runningSinceRef = useRef<number | null>(null);
+
+  // Reset tracking whenever the monitored thread changes so a long run on
+  // the previous thread cannot leak the notice onto the new one.
+  useEffect(() => {
+    runningSinceRef.current = null;
+    setVisible(false);
+  }, [threadId]);
+
+  useEffect(() => {
+    if (!effectiveHosted || isBackgroundDispatch) {
+      // Server-owned turn (or non-hosted client): the tab is not load-bearing.
+      // Hide immediately and reset — no linger.
+      runningSinceRef.current = null;
+      setVisible(false);
+      return;
+    }
+    if (foregroundRunning) {
+      if (runningSinceRef.current == null) {
+        runningSinceRef.current = Date.now();
+      }
+      const elapsed = Date.now() - runningSinceRef.current;
+      if (elapsed >= showAfterMs) {
+        setVisible(true);
+        return;
+      }
+      const timer = setTimeout(() => setVisible(true), showAfterMs - elapsed);
+      return () => clearTimeout(timer);
+    }
+    if (!visible) {
+      runningSinceRef.current = null;
+      return;
+    }
+    // The run left "running" while the notice is up. Linger briefly — the
+    // gap between continuation chunks is sub-second, and hiding/re-showing
+    // across every boundary would flicker — then reset.
+    const timer = setTimeout(() => {
+      runningSinceRef.current = null;
+      setVisible(false);
+    }, IDLE_LINGER_MS);
+    return () => clearTimeout(timer);
+  }, [
+    effectiveHosted,
+    foregroundRunning,
+    isBackgroundDispatch,
+    showAfterMs,
+    visible,
+  ]);
+
+  if (!visible) return null;
+
+  return (
+    <div
+      role="status"
+      aria-live="polite"
+      className={cn(
+        "mx-3 mt-2 flex items-start gap-2 rounded-md border border-border/70 bg-muted/40 px-3 py-2 text-xs text-muted-foreground",
+        className,
+      )}
+    >
+      <IconInfoCircle
+        size={14}
+        className="mt-0.5 shrink-0 opacity-70"
+        aria-hidden="true"
+      />
+      <span className="min-w-0 leading-snug">
+        <span className="font-medium text-foreground/80">
+          Keep this tab open.
+        </span>{" "}
+        This task continues from your browser — closing or leaving this tab will
+        pause it until you come back.
+      </span>
+    </div>
+  );
+}

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -57,6 +57,7 @@ import {
   TooltipTrigger,
 } from "./components/ui/tooltip.js";
 import { isTrustedFrameMessage } from "./frame.js";
+import { KeepTabOpenNotice } from "./KeepTabOpenNotice.js";
 import { RunStuckBanner } from "./RunStuckBanner.js";
 import { callAction } from "./use-action.js";
 import {
@@ -2682,8 +2683,14 @@ export function MultiTabAssistantChat({
                     contentHidden || tabId !== activeThreadId ? "none" : "flex",
                 }}
               >
+                <KeepTabOpenNotice
+                  threadId={tabId}
+                  enabled={tabId === activeThreadId}
+                  apiUrl={apiUrl}
+                />
                 <RunStuckBanner
                   threadId={tabId}
+                  enabled={tabId === activeThreadId}
                   apiUrl={apiUrl}
                   autoRetry
                   autoRetryOwnerId={browserTabId}

package/corpus/core/src/client/RunStuckBanner.tsx

@@ -19,6 +19,12 @@ import { cn } from "./utils.js";
 export interface RunStuckBannerProps {
   /** The thread to monitor. Pass null/undefined to disable. */
   threadId: string | null | undefined;
+  /**
+   * Set false to skip polling entirely — used when this banner is mounted
+   * for a background tab kept alive via display:none. Only the active tab
+   * should poll `/runs/active`. Defaults to true.
+   */
+  enabled?: boolean;
   /** API base path. Default `/_agent-native/agent-chat`. */
   apiUrl?: string;
   /**
@@ -145,6 +151,7 @@ async function claimAutoRetryAttempt(
 
 export function RunStuckBanner({
   threadId,
+  enabled = true,
   apiUrl,
   stuckThresholdMs,
   onRetry,
@@ -153,7 +160,12 @@ export function RunStuckBanner({
   autoRetryOwnerId,
   className,
 }: RunStuckBannerProps) {
-  const state = useRunStuckDetection({ threadId, stuckThresholdMs, apiUrl });
+  const state = useRunStuckDetection({
+    threadId,
+    enabled,
+    stuckThresholdMs,
+    apiUrl,
+  });
   const abortRun = useAbortRun(apiUrl);
   const [busy, setBusy] = useState<BusyState>({ type: "none" });
   const autoRetriedRunIdsRef = useRef<Set<string>>(new Set());

package/corpus/core/src/client/chat/run-recovery.tsx

@@ -920,6 +920,12 @@ export function LoopLimitContinueCard({
 }
 
 // ─── PlanModeCallout ──────────────────────────────────────────────────────────
+//
+// Renders inside the same width-constrained column as the composer (see
+// `.agent-plan-mode-callout` in agent-native.css and the fullscreen rule
+// injected by AgentPanel) so the pill hugs the composer's right edge in both
+// narrow sidebar chats and wide/centered page layouts, instead of floating
+// against the full pane width.
 
 export function PlanModeCallout({
   canImplementPlan,
@@ -931,7 +937,7 @@ export function PlanModeCallout({
   onSwitchToAct: () => void;
 }) {
   return (
-    <div className="shrink-0 px-3 pt-1">
+    <div className="agent-plan-mode-callout shrink-0 px-3">
       <div className="ml-auto flex w-fit max-w-full items-center gap-2 rounded-full border border-border/70 bg-background/95 px-2 py-1.5 text-xs text-muted-foreground shadow-sm">
         <IconClipboardList size={13} className="shrink-0" />
         <span className="min-w-0 truncate">

package/corpus/core/src/client/clipboard.ts

@@ -1,16 +1,21 @@
-type ElectronClipboardApi = {
-  clipboard?: {
-    writeText?: (text: string) => boolean | Promise<boolean>;
+type ClipboardWriter = {
+  writeText?: (text: string) => boolean | Promise<boolean>;
+};
+
+type DesktopClipboardApis = {
+  electronAPI?: {
+    clipboard?: ClipboardWriter;
+  };
+  agentNativeDesktop?: {
+    clipboard?: ClipboardWriter;
   };
 };
 
-function getElectronClipboard(): ElectronClipboardApi["clipboard"] | null {
-  const api = (
-    globalThis as typeof globalThis & {
-      electronAPI?: ElectronClipboardApi;
-    }
-  ).electronAPI;
-  return api?.clipboard ?? null;
+function getDesktopClipboards(): ClipboardWriter[] {
+  const api = globalThis as typeof globalThis & DesktopClipboardApis;
+  return [api.electronAPI?.clipboard, api.agentNativeDesktop?.clipboard].filter(
+    (clipboard): clipboard is ClipboardWriter => !!clipboard?.writeText,
+  );
 }
 
 function writeWithExecCommand(text: string): boolean {
@@ -35,10 +40,9 @@ function writeWithExecCommand(text: string): boolean {
 }
 
 export async function writeClipboardText(text: string): Promise<boolean> {
-  const electronClipboard = getElectronClipboard();
-  if (electronClipboard?.writeText) {
+  for (const desktopClipboard of getDesktopClipboards()) {
     try {
-      const result = await electronClipboard.writeText(text);
+      const result = await desktopClipboard.writeText?.(text);
       if (result !== false) return true;
     } catch {
       // Fall through to browser clipboard options.

package/corpus/core/src/client/components/AgentPresenceChip.tsx

@@ -1,69 +1,4 @@
-export interface AgentPresenceChipProps {
-  /** Whether the agent is actively editing this element. */
-  active: boolean;
-  /** Label text. Default: "AI editing" */
-  label?: string;
-  /** Color. Default: "#00B5FF" */
-  color?: string;
-  /** Additional CSS classes. */
-  className?: string;
-}
-
-const pulseKeyframes = `
-@keyframes _anChipPulse {
-  0%, 100% { opacity: 1; }
-  50% { opacity: 0.6; }
-}
-`;
-
-let styleInjected = false;
-
-function injectStyles() {
-  if (styleInjected || typeof document === "undefined") return;
-  const style = document.createElement("style");
-  style.textContent = pulseKeyframes;
-  document.head.appendChild(style);
-  styleInjected = true;
-}
-
-export function AgentPresenceChip({
-  active,
-  label = "AI editing",
-  color = "#00B5FF",
-  className,
-}: AgentPresenceChipProps) {
-  if (!active) return null;
-
-  injectStyles();
-
-  return (
-    <span
-      className={className}
-      style={{
-        display: "inline-flex",
-        alignItems: "center",
-        gap: 4,
-        height: 20,
-        padding: "0 8px",
-        borderRadius: 9999,
-        backgroundColor: `${color}20`,
-        color,
-        fontSize: 11,
-        fontWeight: 600,
-        whiteSpace: "nowrap",
-      }}
-    >
-      <span
-        style={{
-          width: 6,
-          height: 6,
-          borderRadius: "50%",
-          backgroundColor: color,
-          animation: "_anChipPulse 2s infinite",
-          flexShrink: 0,
-        }}
-      />
-      {label}
-    </span>
-  );
-}
+export {
+  AgentPresenceChip,
+  type AgentPresenceChipProps,
+} from "@agent-native/toolkit/collab-ui";