@downcity/agent 1.1.408 → 1.1.437

package/src/session/storage/LocalSessionStore.ts

@@ -0,0 +1,414 @@
+/**
+ * LocalSessionStore：Agent 的 Session 查询与管理视图。
+ *
+ * 职责说明（中文）
+ * - 统一管理 Session 创建判断、删除、列表、归档与清理。
+ * - 缓存稳定的 LocalSessionDataStore，避免同一 Session 重复创建 SQLite Storage。
+ * - 使用来源类型建立确定性一级分区，避免跨来源扫描。
+ */
+
+import { isDeepStrictEqual } from "node:util";
+import type {
+  AgentArchiveSessionResult,
+  AgentArchiveSessionsInput,
+  AgentArchiveSessionsResult,
+  AgentCleanArchiveResult,
+  AgentListSessionsInput,
+  AgentSessionSummary,
+  AgentSessionSummaryPage,
+} from "@/types/agent/SessionTypes.js";
+import type { SessionStore } from "@/types/store/SessionStore.js";
+import type { SessionStorage } from "@/types/store/SessionStorage.js";
+import { LocalSessionDataStore } from "@/session/storage/LocalSessionDataStore.js";
+import {
+  get_agent_archived_session_database_path,
+  get_agent_archived_session_origins_path,
+  get_agent_archived_session_path,
+  get_agent_archived_sessions_path,
+  get_agent_session_database_path,
+  get_agent_session_path,
+} from "@/session/storage/LocalStorePaths.js";
+import {
+  build_session_info,
+  list_archived_agent_session_summary_page,
+  list_agent_session_summary_page,
+  read_session_metadata_from_database,
+} from "@/session/browse/Browse.js";
+import type { FileSystem } from "@downcity/type";
+import type { LocalSessionStoreOptions } from "@/types/store/LocalStore.js";
+import type { SessionOrigin } from "@downcity/type";
+import { normalize_session_origin, normalize_session_origin_type } from "@downcity/type";
+
+/** 解码目录中经过 URL 编码的 Session 标识。 */
+function decode_session_id(input: string): string {
+  try {
+    return decodeURIComponent(input);
+  } catch {
+    return input;
+  }
+}
+
+/** 默认本地 Agent Store。 */
+export class LocalSessionStore implements SessionStore {
+  /** 当前 Agent 内部数据文件能力。 */
+  private readonly files: FileSystem;
+
+  /** 当前 Agent 的稳定标识。 */
+  private readonly agent_id: string;
+
+  /** 当前 Workspace 的稳定标识。 */
+  private readonly workspace_id?: string;
+
+  /** 当前 Agent 内部数据根路径。 */
+  private readonly storage_root_path: string;
+
+  /** Session 数据库使用本地文件还是进程内存。 */
+  private readonly database_location: LocalSessionStoreOptions["database_location"];
+
+  /** 已创建的 Session Store 缓存。 */
+  private readonly sessions = new Map<string, LocalSessionDataStore>();
+
+  /** 内存模式中已归档但仍由 Store 持有的 Session。 */
+  private readonly archived_sessions = new Map<string, LocalSessionDataStore>();
+
+  constructor(options: LocalSessionStoreOptions) {
+    this.files = options.files;
+    this.agent_id = options.agent_id;
+    this.workspace_id = options.workspace_id;
+    this.storage_root_path = options.storage_root_path;
+    this.database_location = options.database_location;
+  }
+
+  /** 为新 Session 创建稳定持久化视图。 */
+  create_session(
+    session_id: string,
+    origin: SessionOrigin,
+    workspace_id = this.workspace_id,
+  ): SessionStorage {
+    const resolved_session_id = String(session_id || "").trim();
+    if (!resolved_session_id) {
+      throw new Error("SessionStore.create_session requires a non-empty session_id");
+    }
+    const resolved_origin = normalize_session_origin(origin);
+    const cache_key = this.session_cache_key(resolved_session_id, resolved_origin.type);
+    const cached = this.sessions.get(cache_key);
+    if (cached) {
+      if (isDeepStrictEqual(cached.origin, resolved_origin)) return cached;
+      if (Object.keys(resolved_origin).length === 1) return cached;
+      if (Object.keys(cached.origin).length > 1) {
+        throw new Error(`Session "${resolved_session_id}" origin is immutable`);
+      }
+    }
+    const created = new LocalSessionDataStore({
+      files: this.files,
+      storage_root_path: this.storage_root_path,
+      agent_id: this.agent_id,
+      database_location: this.database_location,
+      workspace_id: workspace_id,
+      session_id: resolved_session_id,
+      origin: resolved_origin,
+    });
+    this.sessions.set(cache_key, created);
+    return created;
+  }
+
+  /** 打开已有 Session，并以数据库中的完整 origin 作为唯一事实。 */
+  async open_session(session_id: string, origin_type = "chat"): Promise<SessionStorage> {
+    const resolved_session_id = String(session_id || "").trim();
+    if (!resolved_session_id) {
+      throw new Error("SessionStore.open_session requires a non-empty session_id");
+    }
+    const resolved_origin_type = normalize_session_origin_type(origin_type);
+    const cache_key = this.session_cache_key(resolved_session_id, resolved_origin_type);
+    const cached = this.sessions.get(cache_key);
+    if (cached) return cached;
+    if (this.database_location.type === "memory") {
+      throw new Error(`Session "${resolved_session_id}" not found`);
+    }
+    const database_path = get_agent_session_database_path(
+      this.storage_root_path,
+      resolved_origin_type,
+      resolved_session_id,
+    );
+    if (!(await this.files.path_exists(database_path))) {
+      throw new Error(`Session "${resolved_session_id}" not found`);
+    }
+    const metadata = read_session_metadata_from_database(database_path, resolved_origin_type);
+    if (!metadata || metadata.agent_id !== this.agent_id) {
+      throw new Error(`Session "${resolved_session_id}" belongs to another Agent`);
+    }
+    const opened = new LocalSessionDataStore({
+      files: this.files,
+      storage_root_path: this.storage_root_path,
+      agent_id: this.agent_id,
+      database_location: this.database_location,
+      ...(metadata.workspace_id ? { workspace_id: metadata.workspace_id } : {}),
+      session_id: resolved_session_id,
+      origin: metadata.origin,
+    });
+    this.sessions.set(cache_key, opened);
+    return opened;
+  }
+
+  /** 判断活动 Session 是否存在。 */
+  async has_session(session_id: string, origin_type = "chat"): Promise<boolean> {
+    const resolved_origin_type = normalize_session_origin_type(origin_type);
+    const cache_key = this.session_cache_key(session_id, resolved_origin_type);
+    if (this.database_location.type === "memory") return this.sessions.has(cache_key);
+    const database_path = get_agent_session_database_path(
+      this.storage_root_path,
+      resolved_origin_type,
+      session_id,
+    );
+    if (!(await this.files.path_exists(database_path))) return false;
+    await this.assert_session_owner(session_id, resolved_origin_type, false);
+    return true;
+  }
+
+  /** 永久删除活动 Session。 */
+  async remove_session(session_id: string, origin_type = "chat"): Promise<boolean> {
+    const resolved_origin_type = normalize_session_origin_type(origin_type);
+    const session_path = this.session_path(session_id, resolved_origin_type);
+    const cache_key = this.session_cache_key(session_id, resolved_origin_type);
+    const cached = this.sessions.get(cache_key);
+    const existed = this.database_location.type === "memory"
+      ? Boolean(cached)
+      : await this.files.path_exists(get_agent_session_database_path(
+          this.storage_root_path,
+          resolved_origin_type,
+          session_id,
+        ));
+    if (existed) {
+      await this.assert_session_owner(session_id, resolved_origin_type, false);
+      await cached?.dispose();
+      await this.files.remove_path(session_path);
+    }
+    this.sessions.delete(cache_key);
+    return existed;
+  }
+
+  /** 清空活动 Session Message 数据。 */
+  async clear_session_messages(session_id: string, origin_type = "chat"): Promise<boolean> {
+    const resolved_origin_type = normalize_session_origin_type(origin_type);
+    if (!(await this.has_session(session_id, resolved_origin_type))) return false;
+    const storage = await this.open_session(session_id, resolved_origin_type);
+    await storage.clear_messages();
+    return true;
+  }
+
+  /** 返回活动 Session 摘要页。 */
+  async list_sessions(
+    input: AgentListSessionsInput | undefined,
+    executing_session_ids: ReadonlySet<string>,
+  ): Promise<AgentSessionSummaryPage> {
+    if (this.database_location.type === "memory") {
+      return await this.list_cached_sessions(input, executing_session_ids);
+    }
+    return await list_agent_session_summary_page({
+      project_root: this.storage_root_path,
+      agent_id: this.agent_id,
+      ...(this.workspace_id || input?.workspace_id ? { workspace_id: this.workspace_id || input?.workspace_id } : {}),
+      input,
+      executing_session_ids,
+      files: this.files,
+    });
+  }
+
+  /** 将活动 Session 迁入归档区。 */
+  async archive_session(session_id: string, origin_type = "chat"): Promise<AgentArchiveSessionResult> {
+    const resolved_origin_type = normalize_session_origin_type(origin_type);
+    const cache_key = this.session_cache_key(session_id, resolved_origin_type);
+    if (this.database_location.type === "memory") {
+      const storage = this.sessions.get(cache_key);
+      if (!storage) throw new Error(`Session "${session_id}" not found`);
+      if (this.archived_sessions.has(cache_key)) {
+        throw new Error(`Archived session "${session_id}" already exists`);
+      }
+      this.sessions.delete(cache_key);
+      this.archived_sessions.set(cache_key, storage);
+      return { session_id, archived_at: Date.now() };
+    }
+    const source_path = this.session_path(session_id, resolved_origin_type);
+    if (!(await this.files.path_exists(source_path))) {
+      throw new Error(`Session "${session_id}" not found`);
+    }
+    await this.assert_session_owner(session_id, resolved_origin_type, false);
+    await this.sessions.get(cache_key)?.dispose();
+    const target_path = get_agent_archived_session_path(
+      this.storage_root_path,
+      resolved_origin_type,
+      session_id,
+    );
+    if (await this.files.path_exists(target_path)) {
+      throw new Error(`Archived session "${session_id}" already exists`);
+    }
+    await this.files.ensure_directory(get_agent_archived_sessions_path(
+      this.storage_root_path,
+      resolved_origin_type,
+    ));
+    await this.files.move_path(source_path, target_path);
+    this.sessions.delete(cache_key);
+    return {
+      session_id: session_id,
+      archived_at: Date.now(),
+    };
+  }
+
+  /** 返回归档 Session 摘要页。 */
+  async list_archived_sessions(
+    input?: AgentArchiveSessionsInput,
+  ): Promise<AgentArchiveSessionsResult> {
+    if (this.database_location.type === "memory") {
+      return await this.list_cached_sessions(input, new Set(), this.archived_sessions);
+    }
+    return await list_archived_agent_session_summary_page({
+      project_root: this.storage_root_path,
+      agent_id: this.agent_id,
+      ...(this.workspace_id || input?.workspace_id ? { workspace_id: this.workspace_id || input?.workspace_id } : {}),
+      input,
+      files: this.files,
+    });
+  }
+
+  /** 永久删除全部归档 Session。 */
+  async clean_archive(): Promise<AgentCleanArchiveResult> {
+    if (this.database_location.type === "memory") {
+      const archived = [...this.archived_sessions.values()];
+      this.archived_sessions.clear();
+      await Promise.all(archived.map(async (storage) => await storage.dispose()));
+      return { removed_session_ids: archived.map((storage) => storage.session_id) };
+    }
+    const archive_root_path = get_agent_archived_session_origins_path(this.storage_root_path);
+    if (!(await this.files.path_exists(archive_root_path))) {
+      return { removed_session_ids: [] };
+    }
+    const removed_session_ids: string[] = [];
+    const origin_entries = await this.files.read_directory(archive_root_path);
+    for (const origin_entry of origin_entries) {
+      if (!origin_entry.is_directory) continue;
+      const origin_type = decode_session_id(origin_entry.name);
+      if (!origin_type) continue;
+      const sessions_path = get_agent_archived_sessions_path(this.storage_root_path, origin_type);
+      const session_entries = await this.files.read_directory(sessions_path);
+      for (const session_entry of session_entries) {
+        if (!session_entry.is_directory) continue;
+        const session_id = decode_session_id(session_entry.name);
+        if (!session_id) continue;
+        if (!(await this.is_session_owner(session_id, origin_type, true))) continue;
+        await this.files.remove_path(get_agent_archived_session_path(
+          this.storage_root_path,
+          origin_type,
+          session_id,
+        ));
+        removed_session_ids.push(session_id);
+      }
+    }
+    return { removed_session_ids: removed_session_ids };
+  }
+
+  /** 关闭全部 Session SQLite 连接并清空缓存。 */
+  async dispose(): Promise<void> {
+    const storages = [...this.sessions.values(), ...this.archived_sessions.values()];
+    this.sessions.clear();
+    this.archived_sessions.clear();
+    await Promise.all(storages.map(async (storage) => await storage.dispose()));
+  }
+
+  /** 返回活动 Session 物理目录，仅供本地实现内部使用。 */
+  private session_path(session_id: string, origin_type: string): string {
+    return get_agent_session_path(
+      this.storage_root_path,
+      origin_type,
+      session_id,
+    );
+  }
+
+  /** 校验目标 Session 确实属于当前 Agent 与 Workspace。 */
+  private async assert_session_owner(
+    session_id: string,
+    origin_type: string,
+    archived: boolean,
+  ): Promise<void> {
+    if (await this.is_session_owner(session_id, origin_type, archived)) return;
+    throw new Error(
+      `Session "${session_id}" belongs to another Agent`,
+    );
+  }
+
+  /** 判断 Session metadata 是否匹配当前查询视图。 */
+  private async is_session_owner(
+    session_id: string,
+    origin_type: string,
+    archived: boolean,
+  ): Promise<boolean> {
+    const cache_key = this.session_cache_key(session_id, origin_type);
+    if (this.database_location.type === "memory") {
+      const cached = (archived ? this.archived_sessions : this.sessions).get(cache_key);
+      if (cached) {
+        try {
+          const metadata = await cached.read_metadata();
+          return metadata.agent_id === this.agent_id && metadata.origin.type === origin_type;
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    }
+    const file_path = archived
+      ? get_agent_archived_session_database_path(
+        this.storage_root_path,
+        origin_type,
+        session_id,
+      )
+      : get_agent_session_database_path(this.storage_root_path, origin_type, session_id);
+    if (!(await this.files.path_exists(file_path))) return false;
+    const metadata = read_session_metadata_from_database(file_path, origin_type);
+    return metadata?.agent_id === this.agent_id && metadata.origin.type === origin_type;
+  }
+
+  /** 从内存数据库缓存投影 Session 列表。 */
+  private async list_cached_sessions(
+    input: AgentListSessionsInput | AgentArchiveSessionsInput | undefined,
+    executing_session_ids: ReadonlySet<string>,
+    storages = this.sessions,
+  ): Promise<AgentSessionSummaryPage> {
+    const origin_type = normalize_session_origin_type(input?.origin_type ?? "chat");
+    const query = String(input?.query || "").trim().toLowerCase();
+    const summaries: AgentSessionSummary[] = [];
+    for (const storage of storages.values()) {
+      if (storage.origin.type !== origin_type) continue;
+      const metadata = await storage.read_metadata();
+      if ((this.workspace_id || input?.workspace_id) &&
+          metadata.workspace_id !== (this.workspace_id || input?.workspace_id)) continue;
+      const summary = build_session_info({
+        project_root: this.storage_root_path,
+        agent_id: this.agent_id,
+        session_id: storage.session_id,
+        metadata,
+        executing: executing_session_ids.has(storage.session_id),
+      });
+      if (query && ![
+        summary.session_id,
+        summary.title || "",
+        summary.preview_text || "",
+      ].join("\n").toLowerCase().includes(query)) continue;
+      summaries.push(summary);
+    }
+    summaries.sort((left, right) => (right.updated_at || 0) - (left.updated_at || 0));
+    const cursor = Math.max(0, Number(input?.cursor) || 0);
+    const limit = Math.min(Math.max(input?.limit ?? 50, 1), 500);
+    const items = summaries.slice(cursor, cursor + limit);
+    const next_cursor = cursor + items.length;
+    return {
+      items,
+      total: summaries.length,
+      ...(next_cursor < summaries.length ? { next_cursor: String(next_cursor) } : {}),
+      has_more: next_cursor < summaries.length,
+    };
+  }
+
+  /** 返回来源分区内唯一的 Session Store 缓存键。 */
+  private session_cache_key(session_id: string, origin_type: string): string {
+    return `${origin_type}\u0000${session_id}`;
+  }
+}

package/src/session/storage/LocalStorePaths.ts

@@ -0,0 +1,123 @@
+/**
+ * Agent 本地运行数据与 Session 路径规则。
+ *
+ * 关键点（中文）
+ * - 调用方已经把文件能力限制在当前 Agent 的私有数据根。
+ * - Session 在 Agent 内使用稳定且唯一的 session_id 定位。
+ * - 本模块只拼接作用域内的相对领域路径，不解析用户级数据根。
+ */
+
+import path from "node:path";
+import { normalize_session_origin_type } from "@downcity/type";
+
+/** 把标识转换为安全、可逆的单层目录名。 */
+function encode_path_segment(input: string): string {
+  // 关键点（中文）：只保留小写安全字符，避免大小写不敏感文件系统碰撞和相对目录语义。
+  let encoded = [...Buffer.from(input, "utf8")]
+    .map((byte) =>
+      (byte >= 97 && byte <= 122)
+      || (byte >= 48 && byte <= 57)
+      || byte === 45
+      || byte === 95
+      || byte === 126
+        ? String.fromCharCode(byte)
+        : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`
+    )
+    .join("");
+  // Windows 保留设备名不能直接作为目录名；编码首字符后仍可由 decodeURIComponent 无损恢复。
+  if (/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/iu.test(encoded)) {
+    encoded = `%${encoded.codePointAt(0)?.toString(16).toUpperCase().padStart(2, "0")}${encoded.slice(1)}`;
+  }
+  return encoded;
+}
+
+/** 把来源类型转换为安全、确定的单层目录名。 */
+function encode_origin_type(origin_type: string): string {
+  return encode_path_segment(normalize_session_origin_type(origin_type));
+}
+
+/** 返回全部活动 Session 来源分区的根目录。 */
+export function get_agent_session_origins_path(storage_root_path: string): string {
+  return path.join(path.resolve(storage_root_path), "sessions");
+}
+
+/** 返回全部归档 Session 来源分区的根目录。 */
+export function get_agent_archived_session_origins_path(storage_root_path: string): string {
+  return path.join(path.resolve(storage_root_path), "archived-sessions");
+}
+
+/** 返回指定来源的活动 Session 集合目录。 */
+export function get_agent_sessions_path(
+  storage_root_path: string,
+  origin_type: string,
+): string {
+  return path.join(get_agent_session_origins_path(storage_root_path), encode_origin_type(origin_type));
+}
+
+/** 返回指定来源的归档 Session 集合目录。 */
+export function get_agent_archived_sessions_path(
+  storage_root_path: string,
+  origin_type: string,
+): string {
+  return path.join(get_agent_archived_session_origins_path(storage_root_path), encode_origin_type(origin_type));
+}
+
+/** 返回单个活动 Session 目录。 */
+export function get_agent_session_path(
+  storage_root_path: string,
+  origin_type: string,
+  session_id: string,
+): string {
+  return path.join(
+    get_agent_sessions_path(storage_root_path, origin_type),
+    encode_path_segment(String(session_id || "").trim()),
+  );
+}
+
+/** 返回单个活动 Session 的 SQLite 数据库路径。 */
+export function get_agent_session_database_path(
+  storage_root_path: string,
+  origin_type: string,
+  session_id: string,
+): string {
+  return path.join(
+    get_agent_session_path(storage_root_path, origin_type, session_id),
+    "session.db",
+  );
+}
+
+/** 返回单个归档 Session 目录。 */
+export function get_agent_archived_session_path(
+  storage_root_path: string,
+  origin_type: string,
+  session_id: string,
+): string {
+  return path.join(
+    get_agent_archived_sessions_path(storage_root_path, origin_type),
+    encode_path_segment(String(session_id || "").trim()),
+  );
+}
+
+/** 返回单个归档 Session 的 SQLite 数据库路径。 */
+export function get_agent_archived_session_database_path(
+  storage_root_path: string,
+  origin_type: string,
+  session_id: string,
+): string {
+  return path.join(
+    get_agent_archived_session_path(storage_root_path, origin_type, session_id),
+    "session.db",
+  );
+}
+
+/** 返回单个 Session 的附件目录。 */
+export function get_agent_session_attachments_path(
+  storage_root_path: string,
+  origin_type: string,
+  session_id: string,
+): string {
+  return path.join(
+    get_agent_session_path(storage_root_path, origin_type, session_id),
+    "attachments",
+  );
+}

package/src/session/storage/Metadata.ts

@@ -2,13 +2,14 @@
  * SDK Session 元数据辅助。
  *
  * 关键点（中文）
- * - 统一负责 Workspace `sessions/<session_id>/meta.json` 的规范化读取。
- * - 仅处理轻量配置摘要与索引信息，不负责消息 JSONL 的读写。
+ * - 统一负责 Session SQLite 中轻量配置摘要与索引字段的规范化。
+ * - 不负责数据库连接、消息聚合或附件读写。
  */
 
-import type { SessionHistoryMetaV1 } from "@/executor/types/SessionHistoryMeta.js";
-import type { SessionOrigin } from "@/types/session/SessionOrigin.js";
-import type { FileSystem } from "@downcity/workspace";
+import type { SessionHistoryMeta } from "@/executor/types/SessionHistoryMeta.js";
+import type { SessionOrigin } from "@downcity/type";
+import type { FileSystem } from "@downcity/type";
+import { restore_session_origin } from "@downcity/type";
 
 function normalizeModelLabel(input: unknown): string | undefined {
   const label = typeof input === "string" ? input.trim() : "";
@@ -56,32 +57,15 @@ function normalize_preview_text(input: unknown): string | undefined {
   return preview_text || undefined;
 }
 
-function normalize_history_bytes(input: unknown): number | undefined {
-  return typeof input === "number" && Number.isInteger(input) && input >= 0
-    ? input
-    : undefined;
-}
-
-/** 归一化 Session 来源元数据。 */
-function normalize_session_origin(input: unknown): SessionOrigin | undefined {
-  if (!input || typeof input !== "object") return undefined;
-  const raw = input as { type?: unknown; group_id?: unknown; group_session_id?: unknown };
-  if (raw.type === "user") return { type: "user" };
-  if (raw.type !== "group") return undefined;
-  const group_id = typeof raw.group_id === "string" ? raw.group_id.trim() : "";
-  const group_session_id = typeof raw.group_session_id === "string" ? raw.group_session_id.trim() : "";
-  return group_id && group_session_id ? { type: "group", group_id, group_session_id } : undefined;
-}
-
 /**
- * 从指定路径读取 session meta.json。
+ * 从指定路径读取旧版 Session metadata。
  *
  * 关键点（中文）
  * - 供归档 session 等需要脱离默认 `sessions/` 目录的场景复用。
  * - 路径本身不做校验，调用方需保证可访问。
  */
 export async function read_session_metadata_from_path(input: {
-  /** meta.json 文件路径。 */
+  /** 旧版 metadata 文件路径。 */
   filePath: string;
   /** 当前 session_id。 */
   session_id: string;
@@ -89,12 +73,14 @@ export async function read_session_metadata_from_path(input: {
   agent_id: string;
   /** 当前查询上下文的 workspace_id；存在时必须与 metadata 严格匹配。 */
   workspace_id?: string;
-  /** 当前 Workspace 的统一文件能力。 */
+  /** 当前读取目录对应的来源类型。 */
+  origin_type: string;
+  /** 当前 Agent 私有 Storage 的文件能力。 */
   files: FileSystem;
-}): Promise<SessionHistoryMetaV1> {
+}): Promise<SessionHistoryMeta> {
   const raw = JSON.parse(
     (await input.files.read_file(input.filePath)).toString("utf8"),
-  ) as Partial<SessionHistoryMetaV1>;
+  ) as Partial<SessionHistoryMeta>;
   if (
     raw.session_id !== input.session_id ||
     raw.agent_id !== input.agent_id
@@ -108,25 +94,25 @@ export async function read_session_metadata_from_path(input: {
     raw,
     input.session_id,
     input.agent_id,
+    restore_session_origin(raw.origin, input.origin_type),
     raw.workspace_id,
   );
 }
 
 /** 将未知 Metadata 内容规范化为当前 Session 的稳定结构。 */
 export function normalize_session_metadata(
-  raw: Partial<SessionHistoryMetaV1>,
+  raw: Partial<SessionHistoryMeta>,
   session_id: string,
   agent_id: string,
+  origin: SessionOrigin,
   workspace_id?: string,
-): SessionHistoryMetaV1 {
+): SessionHistoryMeta {
   return {
-    v: 1,
+    v: 2,
     session_id: session_id,
     agent_id: agent_id,
     ...(workspace_id ? { workspace_id: workspace_id } : {}),
-    ...(normalize_session_origin(raw.origin)
-      ? { origin: normalize_session_origin(raw.origin) }
-      : {}),
+    origin: restore_session_origin(raw.origin ?? origin, origin.type),
     created_at:
       typeof raw.created_at === "number" && Number.isFinite(raw.created_at)
         ? raw.created_at
@@ -151,8 +137,5 @@ export function normalize_session_metadata(
     ...(normalize_preview_text(raw.preview_text)
       ? { preview_text: normalize_preview_text(raw.preview_text) }
       : {}),
-    ...(normalize_history_bytes(raw.historyBytes) !== undefined
-      ? { historyBytes: normalize_history_bytes(raw.historyBytes) }
-      : {}),
   };
 }