@tablestore/tablestore-agent-cli 0.2.5 → 0.2.7

package/dist/dashboard-runtime/dashboard/src/hooks/use-task-source-messages.ts

@@ -0,0 +1,179 @@
+import { useQueries, useQuery } from "@tanstack/react-query";
+import { getMemoryUnit, listMemoryMessages } from "@/services/memory";
+import { queryKeys } from "@/lib/query-keys";
+import { useRuntimeContext } from "@/providers/runtime-context-provider";
+import type { MemoryTask, MemoryUnit, SessionMessage } from "@/types/memory";
+
+function toEpochMs(value: string | number | undefined): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === "number") return value;
+  const ms = new Date(value).getTime();
+  return Number.isFinite(ms) ? ms : undefined;
+}
+
+export interface SourceEvidence {
+  // Real message hashes the task's units cite. Empty when no unit carries refs.
+  refIds: Set<string>;
+  // Tight timestamp window implied by the refs; Infinity / -Infinity if none.
+  minTs: number;
+  maxTs: number;
+}
+
+/**
+ * Collect the REAL source-turn evidence from a task's derived units.
+ *
+ * Only source_turn_refs are read: they carry resolved message hashes (with
+ * timestamps). source_turn_ids are deliberately ignored — they can be LOGICAL
+ * turn labels like "D2:1" (dialogue 2, turn 1) that never equal a stored
+ * messageId, so using them as a filter would hide every real message behind a
+ * false "messages were cleaned up" empty state.
+ */
+export function aggregateSourceEvidence(
+  memories: ReadonlyArray<MemoryUnit | undefined>,
+): SourceEvidence {
+  const refIds = new Set<string>();
+  let minTs = Infinity;
+  let maxTs = -Infinity;
+  for (const memory of memories) {
+    if (!memory) continue;
+    for (const ref of memory.source_turn_refs ?? []) {
+      if (ref?.messageId) refIds.add(ref.messageId);
+      const ts = ref?.timestampMs;
+      if (typeof ts === "number" && Number.isFinite(ts)) {
+        if (ts < minTs) minTs = ts;
+        if (ts > maxTs) maxTs = ts;
+      }
+    }
+  }
+  return { refIds, minTs, maxTs };
+}
+
+/**
+ * Pick the messages a task actually drew from. With real refs, filter to
+ * exactly those messageIds (precise). Without refs, show the fetched window in
+ * timestamp order (precise=false) instead of hiding everything.
+ */
+export function selectSourceMessages(
+  allMessages: ReadonlyArray<SessionMessage>,
+  refIds: ReadonlySet<string>,
+): { messages: SessionMessage[]; precise: boolean } {
+  const precise = refIds.size > 0;
+  const filtered = precise
+    ? allMessages.filter((m) => m.messageId && refIds.has(m.messageId))
+    : [...allMessages];
+  filtered.sort(
+    (a, b) => (toEpochMs(a.timestamp) ?? 0) - (toEpochMs(b.timestamp) ?? 0),
+  );
+  return { messages: filtered, precise };
+}
+
+export interface TaskSourceMessages {
+  messages: SessionMessage[];
+  isLoading: boolean;
+  // True when the result is filtered to the exact source turns the task's
+  // derived units cite. False means we fell back to the task-lifetime window
+  // (e.g. the task produced no units, or the units carry no source refs).
+  precise: boolean;
+}
+
+/**
+ * Resolve the original conversation turns that actually fed an ingest task,
+ * by walking the task's derived units and reading their source-turn evidence.
+ *
+ * This is task-bound: it never bleeds into a neighboring AddMemories call that
+ * happened to write the same scope around the same time, which the old
+ * scope+time-window heuristic could not avoid (a unit's source_turn_refs name
+ * the precise messageIds). The time window is only used to bound the fetch;
+ * the messageId set is what makes the result exact.
+ */
+export function useTaskSourceMessages(
+  memoryStoreName: string,
+  task: MemoryTask | null,
+): TaskSourceMessages {
+  const { context, ready } = useRuntimeContext();
+  const scope = task?.scope ?? null;
+  const unitIds = task?.derivedUnitIds ?? [];
+  const baseEnabled = ready && !!memoryStoreName && !!scope?.appId;
+
+  // 1. Fetch every derived unit in parallel. Shares cache keys with
+  //    ExtractedMemoriesPanel's per-row useMemoryUnit, so no duplicate fetches.
+  const unitQueries = useQueries({
+    queries: unitIds.map((id) => ({
+      queryKey: queryKeys.memoryUnit(
+        context.dataScopeKey,
+        memoryStoreName,
+        id,
+        scope,
+      ),
+      queryFn: () =>
+        getMemoryUnit({ memoryStoreName, memoryId: id, scope: scope! }),
+      enabled: baseEnabled && !!id && id !== "-",
+      staleTime: 30_000,
+    })),
+  });
+
+  const unitsLoading =
+    unitIds.length > 0 && unitQueries.some((q) => q.isLoading);
+
+  // 2. Aggregate source-turn evidence across every derived unit. The filter
+  //    set is built from source_turn_refs only — see aggregateSourceEvidence.
+  const { refIds, minTs, maxTs } = aggregateSourceEvidence(
+    unitQueries.map((q) => q.data?.memory),
+  );
+
+  // 3. Pick a fetch window. Prefer the tight window implied by source-turn
+  //    timestamps; fall back to the task lifetime when refs lack timestamps
+  //    (or there are no units at all).
+  const hasRefWindow = Number.isFinite(minTs) && Number.isFinite(maxTs);
+  const createdMs = toEpochMs(task?.createdAt);
+  const finishedMs = toEpochMs(task?.finishedAt) ?? toEpochMs(task?.updatedAt);
+  const fallbackMax = finishedMs ?? createdMs;
+  const winMin = hasRefWindow
+    ? minTs - 2_000
+    : createdMs !== undefined
+      ? createdMs - 60_000
+      : undefined;
+  const winMax = hasRefWindow
+    ? maxTs + 2_000
+    : fallbackMax !== undefined
+      ? fallbackMax + 60_000
+      : undefined;
+  const minTimestamp =
+    winMin !== undefined ? new Date(winMin).toISOString() : undefined;
+  const maxTimestamp =
+    winMax !== undefined ? new Date(winMax).toISOString() : undefined;
+
+  const messagesEnabled =
+    baseEnabled &&
+    !unitsLoading &&
+    (minTimestamp !== undefined || maxTimestamp !== undefined);
+
+  const messagesQuery = useQuery({
+    queryKey: queryKeys.memoryMessages(
+      context.dataScopeKey,
+      memoryStoreName,
+      scope,
+      undefined,
+      100,
+      { minTimestamp, maxTimestamp },
+    ),
+    queryFn: () =>
+      listMemoryMessages(memoryStoreName, scope!, {
+        limit: 100,
+        minTimestamp,
+        maxTimestamp,
+      }),
+    enabled: messagesEnabled,
+    staleTime: 30_000,
+  });
+
+  // 4. Filter to the exact source turns; keep window order when we can't.
+  const allMessages = messagesQuery.data?.items ?? [];
+  const { messages, precise } = selectSourceMessages(allMessages, refIds);
+
+  return {
+    messages,
+    isLoading: unitsLoading || messagesQuery.isLoading,
+    precise,
+  };
+}

package/dist/dashboard-runtime/dashboard/src/lib/utils.ts

@@ -8,6 +8,10 @@ export function cn(...inputs: ClassValue[]) {
 /**
  * Extract the file name from an OSS key / path string.
  * e.g. "uploads/2024/report.pdf" → "report.pdf"
+ *
+ * Only splits on `/` because OSS object keys use `/` as the separator.
+ * Backslash `\` is NOT treated as a separator — on macOS it can be a
+ * legitimate filename character (e.g. `盘\古\2.1.0\运维手册.docx`).
  */
 export function extractFileName(ossKey: string): string {
   const parts = ossKey.split("/");

package/dist/dashboard-runtime/dashboard/src/types/memory.ts

@@ -1,6 +1,7 @@
 export interface MemoryStore {
   memoryStoreName: string;
   description?: string;
+  extractInstructions?: string;
   createdAt?: number | string;
   updatedAt?: number | string;
   lastSeenAt?: number | string;
@@ -14,6 +15,11 @@ export interface MemoryScope {
   runId?: string;
 }
 
+export interface SourceTurnRef {
+  messageId: string;
+  timestampMs: number;
+}
+
 export interface MemoryUnit {
   id?: string;
   memoryId?: string;
@@ -21,6 +27,10 @@ export interface MemoryUnit {
   scope?: MemoryScope;
   memcell_id?: string;
   unit_type?: string;
+  // Evidence linking a unit back to the short-term turns it was derived from.
+  // Populated at ingest time; source_turn_refs carries per-turn timestamps.
+  source_turn_ids?: string[];
+  source_turn_refs?: SourceTurnRef[];
   text: string;
   search_text?: string;
   metadata?: Record<string, string>;
@@ -37,6 +47,7 @@ export interface MemoryUnit {
 export interface MemorySearchHit {
   unit: MemoryUnit;
   score?: number;
+  similarity?: number;
   source?: string;
 }
 
@@ -66,11 +77,13 @@ export interface MemoryRequestLog {
 export interface CreateMemoryStoreRequest {
   memoryStoreName: string;
   description?: string;
+  extractInstructions?: string;
 }
 
 export interface UpdateMemoryStoreRequest {
   memoryStoreName: string;
   description?: string;
+  extractInstructions?: string;
 }
 
 export interface AddMemoryRequest {
@@ -102,6 +115,7 @@ export interface SearchMemoryRequest {
   scope: MemoryScope;
   topK?: number;
   enableRerank?: boolean;
+  minSimilarity?: number;
   metadata?: Record<string, string>;
 }
 
@@ -136,6 +150,8 @@ export interface MemoryTask {
 // Dreaming (SDK 0.0.3+)
 // ---------------------------------------------------------------------------
 
+export type DreamTaskType = "memory" | "skill" | "profile";
+
 export type DreamTaskStatus =
   | "queued"
   | "running"
@@ -150,7 +166,7 @@ export type DreamApplyMode = "proposal" | "safe_auto";
 export type DreamScopeOutputMode = "preserve_scope" | "promote_scope";
 
 export type DreamActionStatus = "proposed" | "applied" | "skipped" | "failed";
-export type DreamActionType = "ADD" | "UPDATE" | "DELETE" | "MERGE" | "NOOP";
+export type DreamActionType = "ADD" | "UPDATE" | "DELETE" | "MERGE" | "NOOP" | "EMIT_SKILL" | "EMIT_PROFILE";
 export type DreamActionListOrderBy =
   | "created_at_asc"
   | "created_at_desc"
@@ -164,7 +180,9 @@ export type DreamSkippedReason =
   | "missing_source"
   | "delete_requires_manual_apply"
   | "promote_requires_manual_apply"
-  | "confidence_below_threshold";
+  | "confidence_below_threshold"
+  | "superseded_by_skill"
+  | "superseded_by_profile";
 
 export interface DreamMemorySpec {
   text: string;
@@ -173,6 +191,13 @@ export interface DreamMemorySpec {
   metadata?: Record<string, string>;
 }
 
+export interface DreamExtractSpec {
+  kind: string;
+  name: string;
+  description: string;
+  instructions: string;
+}
+
 export interface DreamTaskInputSummary {
   scopes: MemoryScope[];
   minTimestamp: number;
@@ -194,8 +219,10 @@ export interface DreamTaskSummary {
   memoryStoreName: string;
   dreamId: string;
   status: DreamTaskStatus;
+  taskType: DreamTaskType;
   applyMode: DreamApplyMode;
   scopeOutputMode: DreamScopeOutputMode;
+  instructions?: string;
   input: DreamTaskInputSummary;
   actions: DreamTaskActionStats;
   lastError?: string;
@@ -208,6 +235,7 @@ export interface DreamTask {
   dreamId: string;
   memoryStoreName: string;
   status: DreamTaskStatus;
+  taskType?: DreamTaskType;
   applyMode: DreamApplyMode;
   scopeOutputMode: DreamScopeOutputMode;
   clientToken?: string;
@@ -250,6 +278,7 @@ export interface DreamActionRecord {
   targetMemoryVersion?: number;
   targetMemoryUpdatedAtMs?: number;
   newMemory?: DreamMemorySpec;
+  newExtract?: DreamExtractSpec;
   sourceMessageIds?: string[];
   sourceMemoryIds?: string[];
   reason?: string;
@@ -276,6 +305,7 @@ export interface DreamApplyActionResult {
 
 export interface CreateDreamTaskRequest {
   scopes: MemoryScope[];
+  taskType?: DreamTaskType;
   minTimestamp?: number | string;
   maxTimestamp?: number | string;
   maxSessions?: number;