@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/contexts/subspace-context.tsx

@@ -10,11 +10,34 @@ import {
 } from "react";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import {
-  clearActiveSubspace,
-  getActiveSubspace,
-  setActiveSubspace,
+  getSubspaceScopeId,
   useSubspaceHistory,
 } from "@/hooks/use-subspace-history";
+import {
+  clearActiveSubspace,
+  readActiveSubspace,
+  writeActiveSubspace,
+} from "@/lib/subspace-history";
+import { useDataScopeKey } from "@/providers/runtime-context-provider";
+
+type ActiveSubspaceStorage = Pick<
+  Storage,
+  "getItem" | "setItem" | "removeItem"
+>;
+
+const unavailableSessionStorage: ActiveSubspaceStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+};
+
+export function getSessionStorage(): ActiveSubspaceStorage {
+  try {
+    return window.sessionStorage;
+  } catch {
+    return unavailableSessionStorage;
+  }
+}
 
 export interface SubspaceContextValue {
   subspace: string | null;
@@ -22,6 +45,7 @@ export interface SubspaceContextValue {
   clearSubspace: () => void;
   history: string[];
   addToHistory: (subspace: string) => void;
+  clearHistory: () => void;
 }
 
 export const SubspaceContext = createContext<SubspaceContextValue | null>(null);
@@ -52,12 +76,68 @@ interface SubspaceProviderProps {
   children: ReactNode;
 }
 
+export interface ActiveSubspaceReconcileState {
+  scopeId: string | null;
+  pendingRestore: string | null;
+}
+
+export type ActiveSubspaceReconcileResult = {
+  state: ActiveSubspaceReconcileState;
+  effect:
+    | { type: "restore"; subspace: string }
+    | { type: "persist"; subspace: string }
+    | { type: "clear" }
+    | { type: "none" };
+};
+
+export function reconcileActiveSubspace(
+  state: ActiveSubspaceReconcileState,
+  scopeId: string,
+  urlSubspace: string | null,
+  storedSubspace: string | null,
+): ActiveSubspaceReconcileResult {
+  if (state.scopeId !== scopeId) {
+    if (urlSubspace) {
+      return {
+        state: { scopeId, pendingRestore: null },
+        effect: { type: "persist", subspace: urlSubspace },
+      };
+    }
+    if (storedSubspace) {
+      return {
+        state: { scopeId, pendingRestore: storedSubspace },
+        effect: { type: "restore", subspace: storedSubspace },
+      };
+    }
+    return {
+      state: { scopeId, pendingRestore: null },
+      effect: { type: "clear" },
+    };
+  }
+
+  if (state.pendingRestore && !urlSubspace) {
+    return { state, effect: { type: "none" } };
+  }
+
+  if (urlSubspace) {
+    return {
+      state: { scopeId, pendingRestore: null },
+      effect: { type: "persist", subspace: urlSubspace },
+    };
+  }
+
+  return {
+    state: { scopeId, pendingRestore: null },
+    effect: { type: "clear" },
+  };
+}
+
 /**
  * Subspace state container backed by the URL as the single source of truth.
  * The `?subspace=` query parameter drives every read; writes only call
  * router.replace and let the URL change propagate. A per-tab sessionStorage
- * preference is replayed into the URL once on mount so revisiting the page
- * without a query string still lands on the previously chosen scope.
+ * preference is reconciled into the URL once per runtime/KB identity so
+ * revisiting without a query string lands on the previously chosen scope.
  */
 export function SubspaceProvider({
   knowledgeBaseName,
@@ -67,38 +147,65 @@ export function SubspaceProvider({
   const searchParamsKey = searchParams.toString();
   const pathname = usePathname();
   const router = useRouter();
-  const { history, addToHistory } = useSubspaceHistory(knowledgeBaseName);
+  const dataScopeKey = useDataScopeKey();
+  const { history, addToHistory, clearHistory } = useSubspaceHistory(
+    dataScopeKey,
+    knowledgeBaseName,
+  );
+  const activeScopeId = getSubspaceScopeId(dataScopeKey, knowledgeBaseName);
 
   // URL is the single source of truth — derive directly, no local state.
   const subspace = searchParams.get("subspace");
 
-  // One-shot mount-time sticky hydration: when arriving without a query
-  // param but a per-tab session preference exists, replay it into the URL.
-  // After this single redirect every read flows through URL again, so a
-  // later clearSubspace() cannot be undone by re-running this effect.
-  const hydratedRef = useRef(false);
+  // Reconcile once per runtime/KB identity. A pending restore suppresses the
+  // persistence branch until router.replace has replayed it into the URL.
+  const reconcileRef = useRef<ActiveSubspaceReconcileState>({
+    scopeId: null,
+    pendingRestore: null,
+  });
   useEffect(() => {
-    if (hydratedRef.current) return;
-    hydratedRef.current = true;
-    if (subspace) return;
-    const stored = getActiveSubspace(knowledgeBaseName);
-    if (!stored) return;
-    const params = new URLSearchParams(searchParamsKey);
-    params.set("subspace", stored);
-    router.replace(`${pathname}?${params.toString()}`);
-  }, [knowledgeBaseName, subspace, searchParamsKey, pathname, router]);
+    const storage = getSessionStorage();
+    const stored =
+      reconcileRef.current.scopeId !== activeScopeId && !subspace
+        ? readActiveSubspace(storage, dataScopeKey, knowledgeBaseName)
+        : null;
+    const result = reconcileActiveSubspace(
+      reconcileRef.current,
+      activeScopeId,
+      subspace,
+      stored,
+    );
+    reconcileRef.current = result.state;
 
-  // Side effects follow the URL: persist to sessionStorage and history
-  // whenever the active scope changes. Centralising the writes here means
-  // setSubspace / clearSubspace stay tiny and free of race conditions.
-  useEffect(() => {
-    if (!subspace) {
-      clearActiveSubspace(knowledgeBaseName);
+    if (result.effect.type === "restore") {
+      const params = new URLSearchParams(searchParamsKey);
+      params.set("subspace", result.effect.subspace);
+      router.replace(`${pathname}?${params.toString()}`);
       return;
     }
-    setActiveSubspace(knowledgeBaseName, subspace);
-    addToHistory(subspace);
-  }, [subspace, knowledgeBaseName, addToHistory]);
+    if (result.effect.type === "persist") {
+      writeActiveSubspace(
+        storage,
+        dataScopeKey,
+        knowledgeBaseName,
+        result.effect.subspace,
+      );
+      addToHistory(result.effect.subspace);
+      return;
+    }
+    if (result.effect.type === "clear") {
+      clearActiveSubspace(storage, dataScopeKey, knowledgeBaseName);
+    }
+  }, [
+    activeScopeId,
+    dataScopeKey,
+    knowledgeBaseName,
+    subspace,
+    searchParamsKey,
+    pathname,
+    router,
+    addToHistory,
+  ]);
 
   const setSubspace = useCallback(
     (next: string) => {
@@ -120,7 +227,14 @@ export function SubspaceProvider({
 
   return (
     <SubspaceContext.Provider
-      value={{ subspace, setSubspace, clearSubspace, history, addToHistory }}
+      value={{
+        subspace,
+        setSubspace,
+        clearSubspace,
+        history,
+        addToHistory,
+        clearHistory,
+      }}
     >
       {children}
     </SubspaceContext.Provider>

package/dist/dashboard-runtime/dashboard/src/hooks/use-approve-dream-plan.ts

@@ -0,0 +1,25 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { approveDreamPlan } from "@/services/memory";
+
+export function useApproveDreamPlan(memoryStoreName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      dreamId,
+      approver,
+    }: {
+      dreamId: string;
+      approver: string;
+    }) => approveDreamPlan(memoryStoreName, dreamId, approver),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["memory"],
+        predicate: (query) =>
+          Array.isArray(query.queryKey) &&
+          query.queryKey.includes("dream-tasks") &&
+          query.queryKey.includes(memoryStoreName),
+      });
+    },
+  });
+}

package/dist/dashboard-runtime/dashboard/src/hooks/use-chat-history.ts

@@ -3,6 +3,10 @@
 import { useCallback, useMemo, useSyncExternalStore } from "react";
 
 import { newId } from "@/lib/random-id";
+import {
+  normalizeMemoryRunId,
+  type StorageMode,
+} from "@/lib/memory-storage-mode";
 import type { ChatMessage } from "@/types/llm-chat";
 
 /** Legacy global key kept for read-only migration. */
@@ -70,6 +74,7 @@ export interface ChatSessionMemoryScope {
 export interface ChatSessionMemoryBinding {
   id: string;
   memoryStoreName: string;
+  storageMode?: StorageMode;
   scope: ChatSessionMemoryScope;
   topK?: number;
   autoSave: boolean;
@@ -138,6 +143,32 @@ function belongsToScope(
   );
 }
 
+function sanitizeSessionMessages(messages: unknown[]): ChatMessage[] {
+  return messages.flatMap((message) => {
+    if (!message || typeof message !== "object") return [];
+    const candidate = message as ChatMessage;
+    if (candidate.memorySaveStatus !== "saving") return [candidate];
+    const sanitized = { ...candidate };
+    delete sanitized.memorySaveStatus;
+    delete sanitized.memorySavePath;
+    delete sanitized.memorySaveCount;
+    delete sanitized.memorySaveError;
+    return [sanitized];
+  });
+}
+
+const FNV64_OFFSET_BASIS = BigInt("14695981039346656037");
+const FNV64_PRIME = BigInt("1099511628211");
+
+function createLegacyRunId(seed: string): string {
+  let hash = FNV64_OFFSET_BASIS;
+  for (const byte of new TextEncoder().encode(seed)) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV64_PRIME);
+  }
+  return `run_legacy_${hash.toString(16).padStart(16, "0")}`;
+}
+
 function sanitizeSessions(parsed: unknown): ChatSession[] {
   if (!Array.isArray(parsed)) return [];
   const sessions = parsed.filter(
@@ -150,6 +181,7 @@ function sanitizeSessions(parsed: unknown): ChatSession[] {
   return sessions.map((s) => ({
     ...s,
     activeInstance: normalizeActiveInstance(s.activeInstance),
+    messages: sanitizeSessionMessages(s.messages),
     config: {
       ...s.config,
       mounts: (s.config?.mounts ?? []).map((m) => ({
@@ -159,13 +191,14 @@ function sanitizeSessions(parsed: unknown): ChatSession[] {
         ...(m.retrieval ? { retrieval: m.retrieval } : {}),
         ...(typeof m.topK === "number" ? { topK: m.topK } : {}),
       })),
-      memory: sanitizeMemoryBinding(s.config?.memory),
+      memory: sanitizeMemoryBinding(s.config?.memory, s.id),
     },
   }));
 }
 
 function sanitizeMemoryBinding(
   raw: unknown,
+  sessionId: string,
 ): ChatSessionMemoryBinding | undefined {
   if (!raw || typeof raw !== "object") return undefined;
   const r = raw as Partial<ChatSessionMemoryBinding>;
@@ -180,21 +213,36 @@ function sanitizeMemoryBinding(
     typeof s.runId !== "string" ||
     !s.appId ||
     !s.tenantId ||
-    !s.agentId ||
-    !s.runId
+    !s.agentId
   ) {
     return undefined;
   }
+  const runId = normalizeMemoryRunId(r.storageMode, s.runId, () =>
+    createLegacyRunId(
+      JSON.stringify([
+        sessionId,
+        r.memoryStoreName,
+        s.appId,
+        s.tenantId,
+        s.agentId,
+      ]),
+    ),
+  );
   return {
-    // 兜底分支只服务于"老快照 / 被手动改坏的数据"。正常路径的 binding 由 reducer
-    // 在 SET_MEMORY 时就铸了稳定 id；这里 newId() 每次重生属于可接受代价。
+    // 缺失 binding id 只可能来自老快照或手动损坏的数据；写 scope 的 runId
+    // 则在上方用会话与 scope seed 做确定性修复，不依赖这个临时 UI key。
     id: typeof r.id === "string" && r.id ? r.id : newId("memory"),
     memoryStoreName: r.memoryStoreName,
+    ...(r.storageMode === "ots" ||
+    r.storageMode === "file+ots" ||
+    r.storageMode === "filemem"
+      ? { storageMode: r.storageMode }
+      : {}),
     scope: {
       appId: s.appId,
       tenantId: s.tenantId,
       agentId: s.agentId,
-      runId: s.runId,
+      runId,
     },
     ...(Number.isInteger(r.topK) && (r.topK as number) > 0
       ? { topK: r.topK as number }
@@ -207,33 +255,57 @@ function sanitizeMemoryBinding(
   };
 }
 
-function readStorageKey(storageKey: string): ChatSession[] {
-  if (typeof window === "undefined") return [];
-  try {
-    const raw = window.localStorage.getItem(storageKey);
-    if (!raw) return [];
-    return sanitizeSessions(JSON.parse(raw));
-  } catch {
-    return [];
-  }
+interface ChatHistorySnapshotRead {
+  token: string;
+  sessions: ChatSession[];
 }
 
-function migrateLegacyIfNeeded(activeInstance: string | null): void {
-  if (typeof window === "undefined") return;
-  const scopedKey = getChatHistoryStorageKey(activeInstance);
-  if (window.localStorage.getItem(scopedKey) !== null) return;
-  const migrated = readStorageKey(CHAT_HISTORY_LEGACY_STORAGE_KEY).filter((s) =>
-    belongsToScope(s, activeInstance),
+function rawSessionBelongsToScope(
+  candidate: unknown,
+  activeInstance: string | null,
+): boolean {
+  if (!candidate || typeof candidate !== "object") return false;
+  return (
+    normalizeActiveInstance(
+      (candidate as Partial<ChatSession>).activeInstance,
+    ) === activeInstance
   );
-  if (migrated.length === 0) return;
-  writeStorageKey(scopedKey, migrated);
+}
+
+function readChatHistorySnapshot(
+  activeInstance: string | null,
+): ChatHistorySnapshotRead {
+  if (typeof window === "undefined") {
+    return { token: "server", sessions: [] };
+  }
+  const scopedKey = getChatHistoryStorageKey(activeInstance);
+  try {
+    const scopedRaw = window.localStorage.getItem(scopedKey);
+    const usesLegacy = scopedRaw === null;
+    const raw = usesLegacy
+      ? window.localStorage.getItem(CHAT_HISTORY_LEGACY_STORAGE_KEY)
+      : scopedRaw;
+    const parsed = raw ? JSON.parse(raw) : [];
+    const candidates = Array.isArray(parsed) ? parsed : [];
+    const scopedCandidates = usesLegacy
+      ? candidates.filter((candidate) =>
+          rawSessionBelongsToScope(candidate, activeInstance),
+        )
+      : candidates;
+    const sessions = sanitizeSessions(scopedCandidates)
+      .filter((candidate) => belongsToScope(candidate, activeInstance))
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+    const token = usesLegacy
+      ? `legacy\0${JSON.stringify(scopedCandidates)}`
+      : `v2\0${raw ?? ""}`;
+    return { token, sessions };
+  } catch {
+    return { token: "storage-error", sessions: [] };
+  }
 }
 
 function readAll(activeInstance: string | null): ChatSession[] {
-  migrateLegacyIfNeeded(activeInstance);
-  return readStorageKey(getChatHistoryStorageKey(activeInstance)).filter((s) =>
-    belongsToScope(s, activeInstance),
-  );
+  return readChatHistorySnapshot(activeInstance).sessions;
 }
 
 function isQuotaError(err: unknown): boolean {
@@ -312,10 +384,7 @@ export function deriveSessionTitle(
 export function listSessions(
   activeInstance: string | null | undefined,
 ): ChatSession[] {
-  // Always return sorted by updatedAt desc so the sidebar can render directly.
-  return readAll(normalizeActiveInstance(activeInstance)).sort(
-    (a, b) => b.updatedAt - a.updatedAt,
-  );
+  return readAll(normalizeActiveInstance(activeInstance));
 }
 
 export function getSession(
@@ -375,13 +444,19 @@ export function clearAllSessions(
 
 type Listener = () => void;
 
-function subscribeToStorageKey(
+function subscribeToStorageKeys(
   storageKey: string | null,
   listener: Listener,
 ): () => void {
   if (!storageKey || typeof window === "undefined") return () => {};
   const handler = (event: StorageEvent) => {
-    if (event.key && event.key !== storageKey) return;
+    if (
+      event.key &&
+      event.key !== storageKey &&
+      event.key !== CHAT_HISTORY_LEGACY_STORAGE_KEY
+    ) {
+      return;
+    }
     listener();
   };
   window.addEventListener("storage", handler);
@@ -394,23 +469,25 @@ function subscribeToStorageKey(
 // stable reference when nothing changed.
 const snapshotCache = new Map<
   string,
-  { raw: string; snapshot: ChatSession[] }
+  { token: string; snapshot: ChatSession[] }
 >();
 const EMPTY_SESSIONS: ChatSession[] = [];
 
-function getSnapshotFor(
-  activeInstance: string | null,
-  ready: boolean,
+/**
+ * Cached read-only snapshot used by `useSyncExternalStore`. Exported so
+ * identity-sensitive consumers can verify that unrelated project changes do
+ * not replace a scope's array reference.
+ */
+export function getChatHistorySnapshot(
+  activeInstance: string | null | undefined,
 ): ChatSession[] {
-  if (!ready || typeof window === "undefined") return EMPTY_SESSIONS;
-  migrateLegacyIfNeeded(activeInstance);
-  const storageKey = getChatHistoryStorageKey(activeInstance);
-  const raw = window.localStorage.getItem(storageKey) ?? "";
+  const scope = normalizeActiveInstance(activeInstance);
+  const storageKey = getChatHistoryStorageKey(scope);
+  const { token, sessions } = readChatHistorySnapshot(scope);
   const cached = snapshotCache.get(storageKey);
-  if (cached?.raw === raw) return cached.snapshot;
-  const snapshot = listSessions(activeInstance);
-  snapshotCache.set(storageKey, { raw, snapshot });
-  return snapshot;
+  if (cached?.token === token) return cached.snapshot;
+  snapshotCache.set(storageKey, { token, snapshot: sessions });
+  return sessions;
 }
 
 function getServerSnapshot(): ChatSession[] {
@@ -432,11 +509,12 @@ export function useChatHistory(scope: ChatHistoryScope): UseChatHistoryResult {
     : null;
 
   const subscribe = useCallback(
-    (listener: Listener) => subscribeToStorageKey(storageKey, listener),
+    (listener: Listener) => subscribeToStorageKeys(storageKey, listener),
     [storageKey],
   );
   const getSnapshot = useCallback(
-    () => getSnapshotFor(activeInstance, scope.ready),
+    () =>
+      scope.ready ? getChatHistorySnapshot(activeInstance) : EMPTY_SESSIONS,
     [activeInstance, scope.ready],
   );
   const sessions = useSyncExternalStore(