@agent-native/core 0.227.0 → 0.228.0-nightly-20261110212400

package/dist/agent/reaped-run-thread.js

@@ -87,6 +87,12 @@ export async function foldReapedRunIntoThread(runId, terminalError) {
         if (!thread)
             return "superseded";
         const repo = readThreadRepository(run.threadId, run.turnId, thread.threadData);
+        // A thread with no messages has no tail for the retry check below to wait
+        // on, so retrying would defer forever and fail every sweep.
+        if (repo.messages.length === 0) {
+            console.warn(`[agent-chat] dropping stopped run ${runId}: thread ${run.threadId} has no messages (turn ${run.turnId})`);
+            return "superseded";
+        }
         const folded = foldAssistantTurnWithSteers(repo, assistant, steered, {
             runId,
             turnId: run.turnId,

package/dist/application-state/handlers.d.ts

@@ -36,18 +36,18 @@ export declare const listComposeDrafts: import("h3").EventHandlerWithFetch<impor
 export declare const getComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | null>>;
 export declare const putComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<any>>;
 export declare const saveComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    errorCode?: undefined;
     error: string;
     value?: undefined;
     revision?: undefined;
+    errorCode?: undefined;
     details?: undefined;
 } | {
-    errorCode?: undefined;
-    error?: undefined;
     value: {
         id: string;
     };
     revision: string;
+    error?: undefined;
+    errorCode?: undefined;
     details?: undefined;
 } | {
     value?: undefined;

package/dist/application-state/handlers.js

@@ -2,7 +2,8 @@ import { createError, defineEventHandler, getRouterParam, getHeader, getQuery, s
 import { isSaveConflict, saveRevisionOf } from "../save-conflict/index.js";
 import { readBrowserTabIdHeader } from "../server/agent-run-context.js";
 import { readBody } from "../server/h3-helpers.js";
-import { APP_STATE_BATCH_ROUTE_HEADER, APP_STATE_SEQ_HEADER, APP_STATE_WRITER_HEADER, TAB_SCOPED_APP_STATE_KEYS, } from "../shared/app-state-routes.js";
+import { APP_STATE_BATCH_ROUTE_HEADER, APP_STATE_SEQ_HEADER, APP_STATE_WRITER_HEADER, BROWSER_TAB_USED_APP_STATE_KEY, TAB_SCOPED_APP_STATE_KEYS, } from "../shared/app-state-routes.js";
+import { browserTabUsedKey } from "./last-used-tab.js";
 import { appStateSaveIfCurrent } from "./save-if-current.js";
 import { appStateKeyForBrowserTab } from "./script-helpers.js";
 import { appStateGet, appStateGetManyEntries, appStatePut, appStateCompareAndSet, appStateDelete, appStateList, appStateDeleteByPrefix, } from "./store.js";
@@ -54,6 +55,10 @@ function headerSeq(event) {
     return seq !== undefined && /^[0-9]{1,16}$/.test(seq) ? Number(seq) : seq;
 }
 function requestScopedKey(key, event) {
+    if (key === BROWSER_TAB_USED_APP_STATE_KEY) {
+        const browserTabId = readBrowserTabIdHeader(event);
+        return browserTabId ? browserTabUsedKey(browserTabId) : key;
+    }
     return TAB_SCOPED_APP_STATE_KEYS.has(key)
         ? appStateKeyForBrowserTab(key, readBrowserTabIdHeader(event))
         : key;

package/dist/application-state/index.d.ts

@@ -1,4 +1,5 @@
-export { appStateGet, appStateGetMany, appStateGetManyEntries, appStatePut, appStateDelete, appStateCompareAndSet, appStateCompareAndSetMany, appStateList, appStateDeleteByPrefix, type AppStateCompareAndSetOperation, } from "./store.js";
+export { appStateGet, appStateGetMany, appStateGetManyEntries, appStatePut, appStateDelete, appStateCompareAndSet, appStateCompareAndSetMany, appStateList, appStateListUpdatedAt, appStateDeleteByPrefix, type AppStateCompareAndSetOperation, } from "./store.js";
+export { browserTabUsedKey, findLastUsedBrowserTab, LAST_USED_BROWSER_TAB_MAX_AGE_MS, } from "./last-used-tab.js";
 export { getAppStateEmitter, emitAppStateChange, emitAppStateDelete, type AppStateEvent, } from "./emitter.js";
 export { getState, getStateMany, MAX_APP_STATE_BATCH_KEYS, MAX_APP_STATE_BATCH_WRITES, putState, putStateMany, deleteState, listComposeDrafts, getComposeDraft, putComposeDraft, deleteComposeDraft, deleteAllComposeDrafts, } from "./handlers.js";
-export { readAppState, writeAppState, deleteAppState, compareAndSetAppState, compareAndSetManyAppState, listAppState, deleteAppStateByPrefix, readAppStateForCurrentTab, writeAppStateForCurrentTab, appStateKeyForBrowserTab, getCurrentRequestBrowserTabId, } from "./script-helpers.js";
+export { readAppState, writeAppState, deleteAppState, compareAndSetAppState, compareAndSetManyAppState, listAppState, deleteAppStateByPrefix, readAppStateForCurrentTab, writeAppStateForCurrentTab, appStateKeyForBrowserTab, getCurrentRequestBrowserTabId, resolveCurrentRequestStateTab, } from "./script-helpers.js";

package/dist/application-state/index.js

@@ -1,4 +1,5 @@
-export { appStateGet, appStateGetMany, appStateGetManyEntries, appStatePut, appStateDelete, appStateCompareAndSet, appStateCompareAndSetMany, appStateList, appStateDeleteByPrefix, } from "./store.js";
+export { appStateGet, appStateGetMany, appStateGetManyEntries, appStatePut, appStateDelete, appStateCompareAndSet, appStateCompareAndSetMany, appStateList, appStateListUpdatedAt, appStateDeleteByPrefix, } from "./store.js";
+export { browserTabUsedKey, findLastUsedBrowserTab, LAST_USED_BROWSER_TAB_MAX_AGE_MS, } from "./last-used-tab.js";
 export { getAppStateEmitter, emitAppStateChange, emitAppStateDelete, } from "./emitter.js";
 export { getState, getStateMany, MAX_APP_STATE_BATCH_KEYS, MAX_APP_STATE_BATCH_WRITES, putState, putStateMany, deleteState, listComposeDrafts, getComposeDraft, putComposeDraft, deleteComposeDraft, deleteAllComposeDrafts, } from "./handlers.js";
-export { readAppState, writeAppState, deleteAppState, compareAndSetAppState, compareAndSetManyAppState, listAppState, deleteAppStateByPrefix, readAppStateForCurrentTab, writeAppStateForCurrentTab, appStateKeyForBrowserTab, getCurrentRequestBrowserTabId, } from "./script-helpers.js";
+export { readAppState, writeAppState, deleteAppState, compareAndSetAppState, compareAndSetManyAppState, listAppState, deleteAppStateByPrefix, readAppStateForCurrentTab, writeAppStateForCurrentTab, appStateKeyForBrowserTab, getCurrentRequestBrowserTabId, resolveCurrentRequestStateTab, } from "./script-helpers.js";

package/dist/application-state/last-used-tab.d.ts

@@ -0,0 +1,11 @@
+import type { BrowserTabTarget } from "../server/request-context.js";
+/** How long after its last use a tab still counts as the one to act on. */
+export declare const LAST_USED_BROWSER_TAB_MAX_AGE_MS: number;
+/** The row that records a tab's last use: one per app and tab. */
+export declare function browserTabUsedKey(browserTabId: string): string;
+/**
+ * The tab of this app the user used last, if one was used within
+ * LAST_USED_BROWSER_TAB_MAX_AGE_MS. Tabs are ordered by when the server
+ * stored their use, so browser clocks don't matter.
+ */
+export declare function findLastUsedBrowserTab(sessionId: string, now?: number): Promise<BrowserTabTarget>;

package/dist/application-state/last-used-tab.js

@@ -0,0 +1,43 @@
+import { getAppConfig } from "../app-config/index.js";
+import { BROWSER_TAB_USED_APP_STATE_KEY } from "../shared/app-state-routes.js";
+import { appStateListUpdatedAt } from "./store.js";
+/** How long after its last use a tab still counts as the one to act on. */
+export const LAST_USED_BROWSER_TAB_MAX_AGE_MS = 12 * 60 * 60 * 1000;
+const SAFE_TAB_ID_RE = /^[A-Za-z0-9_-]{1,96}$/;
+// Several apps can share one database (Design and Slides do), so each app
+// keeps its tabs' records under its own name. The browser's write and the
+// MCP lookup both run in this app's server, so they name it the same way.
+// Encoding keeps distinct names distinct and keeps ":" out of the name.
+function appScope() {
+    const app = getAppConfig().app;
+    const name = app.workspaceId ?? app.id ?? app.slug ?? app.packageName ?? app.name;
+    return name ? encodeURIComponent(name) : "app";
+}
+function browserTabUsedKeyPrefix() {
+    return `${BROWSER_TAB_USED_APP_STATE_KEY}:${appScope()}:`;
+}
+/** The row that records a tab's last use: one per app and tab. */
+export function browserTabUsedKey(browserTabId) {
+    return `${browserTabUsedKeyPrefix()}${browserTabId}`;
+}
+/**
+ * The tab of this app the user used last, if one was used within
+ * LAST_USED_BROWSER_TAB_MAX_AGE_MS. Tabs are ordered by when the server
+ * stored their use, so browser clocks don't matter.
+ */
+export async function findLastUsedBrowserTab(sessionId, now = Date.now()) {
+    const prefix = browserTabUsedKeyPrefix();
+    let best;
+    for (const { key, updatedAt } of await appStateListUpdatedAt(sessionId, prefix, now - LAST_USED_BROWSER_TAB_MAX_AGE_MS)) {
+        const tabId = key.slice(prefix.length);
+        if (!SAFE_TAB_ID_RE.test(tabId))
+            continue;
+        if (!Number.isFinite(updatedAt))
+            continue;
+        if (now - updatedAt > LAST_USED_BROWSER_TAB_MAX_AGE_MS)
+            continue;
+        if (!best || updatedAt > best.usedAt)
+            best = { tabId, usedAt: updatedAt };
+    }
+    return best ? { kind: "last-used", ...best } : { kind: "unavailable" };
+}

package/dist/application-state/script-helpers.d.ts

@@ -10,9 +10,35 @@ export declare function listAppState(prefix: string): Promise<Array<{
 }>>;
 export declare function deleteAppStateByPrefix(prefix: string): Promise<number>;
 export declare function normalizeBrowserTabId(value: unknown): string | null;
+/** The browser tab the current request came from, if any. */
 export declare function getCurrentRequestBrowserTabId(): string | null;
+/**
+ * The tab whose tab-scoped app state the current request reads and writes:
+ * the tab it came from or, for an MCP call from no tab, the tab of this app
+ * the user used last. `unavailable` when the call looked for a tab and none
+ * was used recently. Requests that have neither (scripts, jobs, the CLI) get
+ * no tab and keep the account-wide rows.
+ */
+export declare function resolveCurrentRequestStateTab(): Promise<{
+    tabId: string | null;
+    unavailable: boolean;
+}>;
 export declare function appStateKeyForBrowserTab(key: string, browserTabId: unknown): string;
+/**
+ * Reads `key` for the current request's tab (see
+ * resolveCurrentRequestStateTab), falling back to the account-wide row only
+ * when `fallbackToGlobal` is true. A request with no tab at all reads the
+ * account-wide row. An MCP call that found no recently used tab reads it
+ * only when it opted in, and never for the ambient keys: no tab keeps those
+ * rows current.
+ */
 export declare function readAppStateForCurrentTab(key: string, options?: {
     fallbackToGlobal?: boolean;
 }): Promise<Record<string, unknown> | null>;
+/**
+ * Writes `key` for the current request's tab (see
+ * resolveCurrentRequestStateTab). With no tab, it writes the account-wide
+ * row, as it always has: an MCP caller learns from the call's result that no
+ * tab was found.
+ */
 export declare function writeAppStateForCurrentTab(key: string, value: Record<string, unknown>): Promise<void>;

package/dist/application-state/script-helpers.js

@@ -19,30 +19,43 @@ async function resolveSessionId() {
     throw new Error("Application state access requires an authenticated request context or AGENT_USER_EMAIL env var");
 }
 export async function readAppState(key) {
-    return readUnscopedAppState(requestScopedAppStateKey(key));
+    const scoped = await requestScopedAppStateKey(key);
+    // No tab to read from: a call that asked for one gets nothing rather than
+    // the account-wide row, which no tab keeps current.
+    if (scoped.unavailable)
+        return null;
+    return readUnscopedAppState(scoped.key);
 }
 export async function writeAppState(key, value) {
     const sessionId = await resolveSessionId();
-    return appStatePut(sessionId, requestScopedAppStateKey(key), value, {
+    const { key: scopedKey } = await requestScopedAppStateKey(key);
+    return appStatePut(sessionId, scopedKey, value, {
         requestSource: "agent",
     });
 }
 export async function deleteAppState(key) {
     const sessionId = await resolveSessionId();
-    return appStateDelete(sessionId, requestScopedAppStateKey(key), {
+    const { key: scopedKey } = await requestScopedAppStateKey(key);
+    return appStateDelete(sessionId, scopedKey, {
         requestSource: "agent",
     });
 }
 export async function compareAndSetAppState(key, expectedValue, nextValue) {
     const sessionId = await resolveSessionId();
-    return appStateCompareAndSet(sessionId, requestScopedAppStateKey(key), expectedValue, nextValue, { requestSource: "agent" });
+    const { key: scopedKey } = await requestScopedAppStateKey(key);
+    return appStateCompareAndSet(sessionId, scopedKey, expectedValue, nextValue, {
+        requestSource: "agent",
+    });
 }
 export async function compareAndSetManyAppState(operations) {
     const sessionId = await resolveSessionId();
-    return appStateCompareAndSetMany(sessionId, operations.map((operation) => ({
+    const scopedOperations = await Promise.all(operations.map(async (operation) => ({
         ...operation,
-        key: requestScopedAppStateKey(operation.key),
-    })), { requestSource: "agent" });
+        key: (await requestScopedAppStateKey(operation.key)).key,
+    })));
+    return appStateCompareAndSetMany(sessionId, scopedOperations, {
+        requestSource: "agent",
+    });
 }
 export async function listAppState(prefix) {
     const sessionId = await resolveSessionId();
@@ -69,6 +82,7 @@ export function normalizeBrowserTabId(value) {
     const trimmed = value.trim();
     return SAFE_TAB_ID_RE.test(trimmed) ? trimmed : null;
 }
+/** The browser tab the current request came from, if any. */
 export function getCurrentRequestBrowserTabId() {
     try {
         return normalizeBrowserTabId(getRequestRunContext()?.browserTabId);
@@ -77,32 +91,86 @@ export function getCurrentRequestBrowserTabId() {
         return null;
     }
 }
+/**
+ * The tab whose tab-scoped app state the current request reads and writes:
+ * the tab it came from or, for an MCP call from no tab, the tab of this app
+ * the user used last. `unavailable` when the call looked for a tab and none
+ * was used recently. Requests that have neither (scripts, jobs, the CLI) get
+ * no tab and keep the account-wide rows.
+ */
+export async function resolveCurrentRequestStateTab() {
+    const browserTabId = getCurrentRequestBrowserTabId();
+    if (browserTabId)
+        return { tabId: browserTabId, unavailable: false };
+    let slot;
+    try {
+        slot = getRequestRunContext()?.browserTabTarget;
+    }
+    catch {
+        slot = undefined;
+    }
+    if (!slot)
+        return { tabId: null, unavailable: false };
+    const target = await slot.resolve();
+    if (target.kind === "last-used") {
+        const tabId = normalizeBrowserTabId(target.tabId);
+        if (tabId)
+            return { tabId, unavailable: false };
+    }
+    return { tabId: null, unavailable: true };
+}
 export function appStateKeyForBrowserTab(key, browserTabId) {
     const normalized = normalizeBrowserTabId(browserTabId);
     return normalized ? `${key}:${normalized}` : key;
 }
-function requestScopedAppStateKey(key) {
+async function requestScopedAppStateKey(key) {
     if (!TAB_SCOPED_AMBIENT_KEYS.has(key))
-        return key;
-    return appStateKeyForBrowserTab(key, getCurrentRequestBrowserTabId());
+        return { key, unavailable: false };
+    const tab = await resolveCurrentRequestStateTab();
+    return {
+        key: appStateKeyForBrowserTab(key, tab.tabId),
+        unavailable: tab.unavailable,
+    };
 }
 async function readUnscopedAppState(key) {
     const sessionId = await resolveSessionId();
     return appStateGet(sessionId, key);
 }
+/**
+ * Reads `key` for the current request's tab (see
+ * resolveCurrentRequestStateTab), falling back to the account-wide row only
+ * when `fallbackToGlobal` is true. A request with no tab at all reads the
+ * account-wide row. An MCP call that found no recently used tab reads it
+ * only when it opted in, and never for the ambient keys: no tab keeps those
+ * rows current.
+ */
 export async function readAppStateForCurrentTab(key, options) {
-    const browserTabId = getCurrentRequestBrowserTabId();
-    const tabKey = appStateKeyForBrowserTab(key, browserTabId);
+    const tab = await resolveCurrentRequestStateTab();
+    const tabKey = appStateKeyForBrowserTab(key, tab.tabId);
+    const fallbackToGlobal = options?.fallbackToGlobal === true;
     if (tabKey !== key) {
         const scoped = await readAppState(tabKey);
         if (scoped)
             return scoped;
-        if (options?.fallbackToGlobal !== true)
+        if (!fallbackToGlobal)
             return null;
     }
+    if (tab.unavailable &&
+        (!fallbackToGlobal || TAB_SCOPED_AMBIENT_KEYS.has(key)))
+        return null;
     return readUnscopedAppState(key);
 }
+/**
+ * Writes `key` for the current request's tab (see
+ * resolveCurrentRequestStateTab). With no tab, it writes the account-wide
+ * row, as it always has: an MCP caller learns from the call's result that no
+ * tab was found.
+ */
 export async function writeAppStateForCurrentTab(key, value) {
-    const tabKey = appStateKeyForBrowserTab(key, getCurrentRequestBrowserTabId());
-    return writeAppState(tabKey, value);
+    const tab = await resolveCurrentRequestStateTab();
+    const tabKey = appStateKeyForBrowserTab(key, tab.tabId);
+    if (tabKey !== key)
+        return writeAppState(tabKey, value);
+    const sessionId = await resolveSessionId();
+    return appStatePut(sessionId, key, value, { requestSource: "agent" });
 }

package/dist/application-state/store.d.ts

@@ -46,6 +46,14 @@ export declare function appStateList(sessionId: string, keyPrefix: string): Prom
     key: string;
     value: Record<string, unknown>;
 }>>;
+/**
+ * Lists the keys under `keyPrefix` with when the server last wrote each,
+ * leaving out any written before `writtenSince`.
+ */
+export declare function appStateListUpdatedAt(sessionId: string, keyPrefix: string, writtenSince?: number): Promise<Array<{
+    key: string;
+    updatedAt: number;
+}>>;
 export declare function appStateListByKeyPrefix(keyPrefix: string, limit?: number): Promise<Array<{
     sessionId: string;
     key: string;

package/dist/application-state/store.js

@@ -253,6 +253,22 @@ export async function appStateList(sessionId, keyPrefix) {
         value: JSON.parse(row.value),
     }));
 }
+/**
+ * Lists the keys under `keyPrefix` with when the server last wrote each,
+ * leaving out any written before `writtenSince`.
+ */
+export async function appStateListUpdatedAt(sessionId, keyPrefix, writtenSince = 0) {
+    await ensureTable();
+    const client = getDbExec();
+    const { rows } = await client.execute({
+        sql: `SELECT key, updated_at FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!' AND updated_at >= ?`,
+        args: [sessionId, escapeLike(keyPrefix) + "%", writtenSince],
+    });
+    return rows.map((row) => ({
+        key: row.key,
+        updatedAt: Number(row.updated_at),
+    }));
+}
 export async function appStateListByKeyPrefix(keyPrefix, limit = 100) {
     await ensureTable();
     const client = getDbExec();

package/dist/client/agent-sidebar-state.d.ts

@@ -13,6 +13,8 @@ export interface AgentSidebarStateChangeDetail {
     open: boolean;
     source: AgentSidebarStateSource;
     mode: AgentSidebarStateMode;
+    /** The panel draws inside the app's `panelHost`, not beside the page. */
+    hosted?: boolean;
 }
 export declare function snapAgentSidebarWidth(width: number): number;
 export declare function getAgentSidebarWideWidth(viewportWidth?: number): number;

package/dist/client/browser-tab-use.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Records when someone uses this browser tab (it gains focus, or its route
+ * changes while focused) and forgets the tab when the page goes away. An MCP
+ * tool call comes from no tab, so the server points its tab-scoped app
+ * state (navigation, navigate commands, selection) at the tab of this app
+ * used last. `useAgentRouteState` calls it; an app with its own navigation
+ * sync calls it once with its current route.
+ */
+export declare function useBrowserTabUse(route: string, enabled?: boolean): void;

package/dist/client/browser-tab-use.js

@@ -0,0 +1,112 @@
+import { useEffect } from "react";
+import { BROWSER_TAB_USED_APP_STATE_KEY } from "../shared/app-state-routes.js";
+import { deleteClientAppState, setClientAppState, } from "./application-state.js";
+import { getBrowserTabId } from "./browser-tab-id.js";
+// While the tab keeps focus, moving around in it refreshes its record at most
+// this often. Coming back to the tab from elsewhere always records it.
+const ROUTE_CHANGE_RECORD_INTERVAL_MS = 60_000;
+let mounts = 0;
+let removeListeners;
+let lastRecordedAt = 0;
+// Whether focus has left the page (to another tab, window or app) since the
+// last record. Focus moving into one of the page's own frames doesn't count.
+let leftSinceRecorded = true;
+function hasFocus() {
+    return (typeof document !== "undefined" &&
+        typeof document.hasFocus === "function" &&
+        document.hasFocus());
+}
+// A record that fails to save leaves the tab unfindable, and the MCP call
+// then says no tab was used, so a failed write needs no handling here.
+function record() {
+    lastRecordedAt = Date.now();
+    leftSinceRecorded = false;
+    void setClientAppState(BROWSER_TAB_USED_APP_STATE_KEY, { usedAt: lastRecordedAt }, { requestSource: getBrowserTabId() }).catch(() => { });
+}
+function recordIfReturned() {
+    if (leftSinceRecorded ||
+        Date.now() - lastRecordedAt >= ROUTE_CHANGE_RECORD_INTERVAL_MS) {
+        record();
+    }
+}
+// A lost delete leaves the record to expire after
+// LAST_USED_BROWSER_TAB_MAX_AGE_MS.
+function forget() {
+    leftSinceRecorded = true;
+    void deleteClientAppState(BROWSER_TAB_USED_APP_STATE_KEY, {
+        keepalive: true,
+        requestSource: getBrowserTabId(),
+    }).catch(() => { });
+}
+function listen() {
+    if (typeof window.addEventListener !== "function" ||
+        typeof document === "undefined" ||
+        typeof document.addEventListener !== "function") {
+        return () => { };
+    }
+    const onFocus = () => recordIfReturned();
+    const onBlur = () => {
+        // Focus moving into one of the page's frames blurs the window, but the
+        // page still has focus once it settles.
+        setTimeout(() => {
+            if (!hasFocus())
+                leftSinceRecorded = true;
+        }, 0);
+    };
+    const onVisibilityChange = () => {
+        if (document.visibilityState === "hidden")
+            leftSinceRecorded = true;
+        else if (hasFocus())
+            recordIfReturned();
+    };
+    const onPageShow = (event) => {
+        if (event.persisted && hasFocus())
+            record();
+    };
+    const onPageHide = () => forget();
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    window.addEventListener("pageshow", onPageShow);
+    window.addEventListener("pagehide", onPageHide);
+    return () => {
+        window.removeEventListener("focus", onFocus);
+        window.removeEventListener("blur", onBlur);
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+        window.removeEventListener("pageshow", onPageShow);
+        window.removeEventListener("pagehide", onPageHide);
+    };
+}
+/**
+ * Records when someone uses this browser tab (it gains focus, or its route
+ * changes while focused) and forgets the tab when the page goes away. An MCP
+ * tool call comes from no tab, so the server points its tab-scoped app
+ * state (navigation, navigate commands, selection) at the tab of this app
+ * used last. `useAgentRouteState` calls it; an app with its own navigation
+ * sync calls it once with its current route.
+ */
+export function useBrowserTabUse(route, enabled = true) {
+    useEffect(() => {
+        if (!enabled || typeof window === "undefined")
+            return;
+        mounts += 1;
+        if (mounts === 1) {
+            removeListeners = listen();
+            if (hasFocus())
+                record();
+        }
+        return () => {
+            mounts -= 1;
+            if (mounts === 0) {
+                removeListeners?.();
+                removeListeners = undefined;
+            }
+        };
+    }, [enabled]);
+    useEffect(() => {
+        if (!enabled || typeof window === "undefined")
+            return;
+        if (hasFocus())
+            recordIfReturned();
+    }, [enabled, route]);
+}

package/dist/client/navigation/index.d.ts

@@ -1,5 +1,6 @@
 export { agentNativePath, appApiPath, appBasePath, appPath, } from "../api-path.js";
 export { useAgentRouteState, useSemanticNavigationState, type AgentRouteTarget, type AgentRouteLocation, type SemanticNavigationCommandEnvelope, type UseAgentRouteStateOptions, type UseAgentRouteStateResult, type UseSemanticNavigationStateOptions, type UseSemanticNavigationStateResult, type WorkspaceAppRouteTarget, } from "../route-state.js";
+export { useBrowserTabUse } from "../browser-tab-use.js";
 export { AGENT_NATIVE_WORKSPACE_APP_ROUTE_MESSAGE_TYPE, postAgentNativeWorkspaceAppRoute, type AgentNativeWorkspaceAppRouteMessage, } from "../workspace-app-navigation.js";
 export { buildOpenRouteLink, buildOpenRoutePath, buildLegacyAgentSettingsRoute, buildResourceRoute, buildSettingsEntryRoute, buildSettingsRedirectRoute, buildSettingsRoute, buildStandardAppRoute, buildTeamRoute, createStandardOpenPathResolver, resolveLegacySettingsId, resolveSettingsSectionRedirect, SETTINGS_PAGE_IDS, STANDARD_APP_ROUTES, STANDARD_SETTINGS_TABS, type BuildResourceRouteOptions, type BuildSettingsRouteOptions, type CoreSettingsPageId, type SettingsRedirect, type BuildStandardAppRouteOptions, type NavigationLink, type NavigationTarget, type StandardAppRouteId, type StandardOpenPathResolverOptions, type StandardOpenPathRoute, type StandardSettingsTabId, } from "../../navigation/index.js";
 export { getSettingsShortcutHint, isSettingsRoutePath, isSettingsShortcutEvent, OPEN_SETTINGS_PAGE_EVENT, openSettingsPage, SETTINGS_SHORTCUT_PAGE, settingsPagePath, useSettingsShortcut, type OpenSettingsPageDetail, } from "../use-settings-shortcut.js";

package/dist/client/navigation/index.js

@@ -1,5 +1,6 @@
 export { agentNativePath, appApiPath, appBasePath, appPath, } from "../api-path.js";
 export { useAgentRouteState, useSemanticNavigationState, } from "../route-state.js";
+export { useBrowserTabUse } from "../browser-tab-use.js";
 export { AGENT_NATIVE_WORKSPACE_APP_ROUTE_MESSAGE_TYPE, postAgentNativeWorkspaceAppRoute, } from "../workspace-app-navigation.js";
 export { buildOpenRouteLink, buildOpenRoutePath, buildLegacyAgentSettingsRoute, buildResourceRoute, buildSettingsEntryRoute, buildSettingsRedirectRoute, buildSettingsRoute, buildStandardAppRoute, buildTeamRoute, createStandardOpenPathResolver, resolveLegacySettingsId, resolveSettingsSectionRedirect, SETTINGS_PAGE_IDS, STANDARD_APP_ROUTES, STANDARD_SETTINGS_TABS, } from "../../navigation/index.js";
 export { getSettingsShortcutHint, isSettingsRoutePath, isSettingsShortcutEvent, OPEN_SETTINGS_PAGE_EVENT, openSettingsPage, SETTINGS_SHORTCUT_PAGE, settingsPagePath, useSettingsShortcut, } from "../use-settings-shortcut.js";

package/dist/client/review/use-review.d.ts

@@ -7,11 +7,21 @@ export interface ListReviewCommentsParams {
     includeResolved?: boolean;
     includeDeleted?: boolean;
     targetId?: string | null;
+    /** One surface's comments, or `null` for those on no surface. */
+    surfaceId?: string | null;
     newestFirst?: boolean;
     limit?: number;
+    /** The `nextCursor` from the previous page. */
+    cursor?: string;
 }
 export interface ListReviewCommentsResult {
     comments: ReviewComment[];
+    /**
+     * Oldest first: the next page's cursor, to pass back as `cursor`, or null on
+     * the last page. A newest-first list isn't paged and leaves it out; its
+     * `summary` still counts every open thread.
+     */
+    nextCursor?: string | null;
     discussion: ReviewDiscussionState;
     reviewStatus: ReviewStatusEntry | null;
     summary: {
@@ -32,8 +42,11 @@ export interface CreateReviewCommentInput {
     resourceType: string;
     resourceId: string;
     targetId?: string | null;
+    surfaceId?: string | null;
     kind?: ReviewCommentKind;
     anchor?: unknown;
+    anchorKind?: string | null;
+    anchorVersion?: number | null;
     body: string;
     authorName?: string | null;
     resolutionTarget?: ReviewResolutionTarget | null;
@@ -120,7 +133,11 @@ export interface UpdateReviewCommentInput {
     commentId: string;
     body?: string;
     anchor?: unknown;
+    anchorKind?: string | null;
+    anchorVersion?: number | null;
     mentions?: ReviewMention[];
+    /** Refuse the edit if the comment changed since this revision. */
+    expectedRevision?: number;
 }
 export interface ConsumeReviewFeedbackInput {
     resourceType: string;
@@ -236,6 +253,17 @@ export declare class ReviewOptimisticCache {
  * its first comment, so the cache does the same.
  */
 export declare function markCommentDeleted(comments: ReviewComment[], commentId: string): ReviewComment[];
+/**
+ * Adds a new comment to a cached list. Oldest first, it lists last, so a page
+ * with more after it is left alone; the comment shows on the last page.
+ */
+export declare function addOptimisticComment(data: unknown, params: unknown, comment: ReviewComment): unknown;
+/**
+ * Adds a reply to a cached list that holds its parent. Oldest first, a new
+ * reply lists after every comment there is, so like a new comment it goes
+ * only on the last page.
+ */
+export declare function addOptimisticReply(data: unknown, params: unknown, parentId: string, reply: (parent: ReviewComment) => ReviewComment): unknown;
 export declare function insertOptimisticComment(comments: ReviewComment[], comment: ReviewComment, params: unknown): ReviewComment[];
 export declare function replaceOptimisticSuggestion(suggestions: ResourceSuggestion[], optimisticId: string, result: ResourceSuggestion): ResourceSuggestion[];
 export declare function reconcileSuggestionAmendment(suggestions: ResourceSuggestion[], saved: ResourceSuggestion): ResourceSuggestion[];