@ycodium-ai/plugin-session-import 0.2.0

package/dist/index.js

@@ -0,0 +1,1954 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/schemas.ts
+var nonEmptyString = { type: "string", minLength: 1 };
+var nullableString = {
+  oneOf: [{ type: "string", minLength: 1 }, { type: "null" }]
+};
+var nonNegativeInt = { type: "integer", minimum: 0 };
+var providerKind = { type: "string", enum: ["claude", "codex"] };
+var phase = { type: "string", enum: ["read", "create", "link"] };
+var candidate = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "provider",
+    "instanceId",
+    "nativeSessionId",
+    "title",
+    "preview",
+    "model",
+    "turnCount",
+    "updatedAt",
+    "cwd",
+    "availability",
+    "openElsewhere"
+  ],
+  properties: {
+    provider: providerKind,
+    instanceId: nonEmptyString,
+    nativeSessionId: nonEmptyString,
+    title: nullableString,
+    preview: nullableString,
+    model: nullableString,
+    turnCount: nonNegativeInt,
+    updatedAt: { type: "number" },
+    cwd: nonEmptyString,
+    availability: { type: "string", enum: ["importable", "alreadyImported"] },
+    openElsewhere: { type: "boolean" },
+    importedThreadId: nonEmptyString
+  }
+};
+var source = {
+  type: "object",
+  additionalProperties: false,
+  required: ["instanceId", "provider", "candidates", "unavailableReason"],
+  properties: {
+    instanceId: nonEmptyString,
+    provider: providerKind,
+    candidates: { type: "array", items: candidate },
+    unavailableReason: nullableString
+  }
+};
+var sessionImportListInputSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["projectId"],
+  properties: {
+    projectId: nonEmptyString,
+    directory: nonEmptyString
+  }
+};
+var sessionImportListResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["sources", "directory"],
+  properties: {
+    sources: { type: "array", items: source },
+    directory: nonEmptyString
+  }
+};
+var sessionImportInputSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["projectId", "instanceId", "provider", "nativeSessionId", "cwd", "threadId"],
+  properties: {
+    projectId: nonEmptyString,
+    instanceId: nonEmptyString,
+    provider: providerKind,
+    nativeSessionId: nonEmptyString,
+    cwd: nonEmptyString,
+    threadId: nonEmptyString
+  }
+};
+var sessionImportProgressEventSchema = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "threadId", "phases"],
+      properties: {
+        kind: { const: "import_started" },
+        threadId: nonEmptyString,
+        phases: { type: "array", items: phase }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "threadId", "phase"],
+      properties: {
+        kind: { const: "phase_started" },
+        threadId: nonEmptyString,
+        phase
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "threadId", "availableMessages", "restoredMessages"],
+      properties: {
+        kind: { const: "session_read" },
+        threadId: nonEmptyString,
+        availableMessages: nonNegativeInt,
+        restoredMessages: nonNegativeInt,
+        availableActivities: nonNegativeInt,
+        restoredActivities: nonNegativeInt
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "threadId", "restoredMessages"],
+      properties: {
+        kind: { const: "import_finished" },
+        threadId: nonEmptyString,
+        restoredMessages: nonNegativeInt,
+        restoredActivities: nonNegativeInt
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "threadId", "phase", "message", "threadCreated"],
+      properties: {
+        kind: { const: "import_failed" },
+        threadId: nonEmptyString,
+        phase,
+        message: nonEmptyString,
+        threadCreated: { type: "boolean" }
+      }
+    }
+  ]
+};
+var sessionImportSyncInputSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["threadId"],
+  properties: {
+    threadId: nonEmptyString
+  }
+};
+var sessionImportSyncResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["status", "appended"],
+  properties: {
+    status: {
+      type: "string",
+      enum: ["not-imported", "unchanged", "synced", "skipped-active", "failed"]
+    },
+    appended: nonNegativeInt
+  }
+};
+
+// src/sessionImportRuntime.ts
+import * as NodeCrypto3 from "node:crypto";
+import * as NodeProcess2 from "node:process";
+
+// src/claudeSessionScan.ts
+import * as NodePath from "node:path";
+import * as NodeProcess from "node:process";
+
+// src/sessionScope.ts
+var EXTENDED_LENGTH_UNC = "//?/UNC/";
+var EXTENDED_LENGTH = "//?/";
+function normalize(value, caseInsensitive) {
+  let unified = value.trim().replace(/\\/gu, "/");
+  const upper = unified.toUpperCase();
+  if (upper.startsWith(EXTENDED_LENGTH_UNC)) {
+    unified = `//${unified.slice(EXTENDED_LENGTH_UNC.length)}`;
+  } else if (upper.startsWith(EXTENDED_LENGTH)) {
+    unified = unified.slice(EXTENDED_LENGTH.length);
+  }
+  const isUnc = unified.startsWith("//");
+  unified = unified.replace(/\/+/gu, "/").replace(/\/+$/u, "");
+  if (isUnc) unified = `/${unified}`;
+  return caseInsensitive ? unified.toLowerCase() : unified;
+}
+function isWithinDirectory(candidate2, root, caseInsensitive) {
+  const normalizedRoot = normalize(root, caseInsensitive);
+  if (normalizedRoot.length === 0 || normalizedRoot === "/") return false;
+  const normalizedCandidate = normalize(candidate2, caseInsensitive);
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
+
+// src/claudeSessionScan.ts
+var PREVIEW_LIMIT = 200;
+var MAX_SCANNED_FILES = 200;
+var MAX_ROWS = 50;
+var MAX_PARSED_LINE_BYTES = 1e6;
+var TRANSCRIPT_SUFFIX = ".jsonl";
+function truncate(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0) return null;
+  return trimmed.length <= PREVIEW_LIMIT ? trimmed : `${trimmed.slice(0, PREVIEW_LIMIT)}\u2026`;
+}
+function encodeClaudeProjectDirName(cwd) {
+  return cwd.replace(/[^A-Za-z0-9]/gu, "-");
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const typed = block;
+    if (typed.type === "text" && typeof typed.text === "string") parts.push(typed.text);
+  }
+  return parts.join("\n\n").trim();
+}
+async function readClaudeTranscriptDigest(fs, filePath) {
+  let cwd = null;
+  let model = null;
+  let preview = null;
+  let customTitle = null;
+  let aiTitle = null;
+  let turnCount = 0;
+  try {
+    for await (const line of fs.readLines(filePath)) {
+      const isUser = line.includes('"type":"user"');
+      const wantsAssistant = model === null && line.includes('"type":"assistant"');
+      const isTitle = line.includes('"custom-title"') || line.includes('"ai-title"');
+      if (!isUser && !wantsAssistant && !isTitle) continue;
+      if (line.length > MAX_PARSED_LINE_BYTES) continue;
+      let record3;
+      try {
+        record3 = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!record3 || typeof record3 !== "object") continue;
+      const typed = record3;
+      if (cwd === null && typeof typed.cwd === "string" && typed.cwd.length > 0) cwd = typed.cwd;
+      if (typed.type === "custom-title" && typeof typed.customTitle === "string") {
+        customTitle = typed.customTitle;
+        continue;
+      }
+      if (typed.type === "ai-title" && typeof typed.aiTitle === "string") {
+        aiTitle = typed.aiTitle;
+        continue;
+      }
+      if (typed.isSidechain === true) continue;
+      if (typed.type === "assistant") {
+        if (model === null && typeof typed.message?.model === "string") model = typed.message.model;
+        continue;
+      }
+      if (typed.type !== "user") continue;
+      const text = textFromContent(typed.message?.content);
+      if (text.length === 0) continue;
+      turnCount += 1;
+      if (preview === null) preview = text;
+    }
+  } catch {
+    return null;
+  }
+  return {
+    cwd,
+    title: truncate(customTitle ?? aiTitle),
+    preview: truncate(preview),
+    model,
+    turnCount
+  };
+}
+async function listTranscriptFiles(fs, transcriptDir, directory) {
+  let dirs;
+  try {
+    dirs = (await fs.readDir(transcriptDir)).filter((entry) => entry.type === "directory").map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  const encodedRoot = encodeClaudeProjectDirName(directory);
+  const matched = dirs.filter((name) => name.startsWith(encodedRoot));
+  const scanned = matched.length > 0 ? matched : dirs;
+  const found = [];
+  for (const dir of scanned) {
+    const projectDir = NodePath.join(transcriptDir, dir);
+    let names;
+    try {
+      names = (await fs.readDir(projectDir)).filter((entry) => entry.type === "file" && entry.name.endsWith(TRANSCRIPT_SUFFIX)).map((entry) => entry.name);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      let stat;
+      try {
+        stat = await fs.stat(NodePath.join(projectDir, name));
+      } catch {
+        continue;
+      }
+      const mtimeMs = stat.modifiedAtIso === null ? 0 : Date.parse(stat.modifiedAtIso);
+      found.push({
+        path: NodePath.join(projectDir, name),
+        sessionId: name.slice(0, -TRANSCRIPT_SUFFIX.length),
+        size: stat.size,
+        mtimeMs: Number.isFinite(mtimeMs) ? mtimeMs : 0
+      });
+    }
+  }
+  return found;
+}
+async function readClaudeLiveSessionIds(fs, configDir) {
+  const live = /* @__PURE__ */ new Set();
+  const markerDir = NodePath.join(configDir, "sessions");
+  let entries;
+  try {
+    entries = (await fs.readDir(markerDir)).filter((entry) => entry.type === "file" && entry.name.endsWith(".json")).map((entry) => entry.name);
+  } catch {
+    return live;
+  }
+  for (const entry of entries) {
+    let marker;
+    try {
+      marker = JSON.parse(await fs.readFile(NodePath.join(markerDir, entry)));
+    } catch {
+      continue;
+    }
+    if (!marker || typeof marker !== "object") continue;
+    const typed = marker;
+    if (typeof typed.pid !== "number" || typeof typed.sessionId !== "string") continue;
+    try {
+      NodeProcess.kill(typed.pid, 0);
+    } catch {
+      continue;
+    }
+    live.add(typed.sessionId);
+  }
+  return live;
+}
+var digestCacheKey = (file) => `claude-digest:${file.path}:${String(file.size)}:${String(file.mtimeMs)}`;
+async function scanClaudeSessions(input) {
+  const root = await input.fs.stat(input.transcriptDir);
+  if (root.type !== "directory") {
+    throw new Error(`The Claude transcript directory ${input.transcriptDir} is not a directory.`);
+  }
+  const files = [...await listTranscriptFiles(input.fs, input.transcriptDir, input.directory)].sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, MAX_SCANNED_FILES);
+  const live = await readClaudeLiveSessionIds(input.fs, input.configDir);
+  const rows = [];
+  for (const file of files) {
+    if (rows.length >= MAX_ROWS) break;
+    const key = digestCacheKey(file);
+    const cached = input.cache === void 0 ? null : await input.cache.getJson(key);
+    let digest = cached?.value ?? null;
+    if (digest === null) {
+      digest = await readClaudeTranscriptDigest(input.fs, file.path);
+      if (digest === null) continue;
+      await input.cache?.setJson(key, digest);
+    }
+    if (digest.cwd === null) continue;
+    if (!isWithinDirectory(digest.cwd, input.directory, input.caseInsensitive)) continue;
+    rows.push({
+      sessionId: file.sessionId,
+      cwd: digest.cwd,
+      title: digest.title,
+      preview: digest.preview,
+      model: digest.model,
+      turnCount: digest.turnCount,
+      updatedAt: file.mtimeMs,
+      openElsewhere: live.has(file.sessionId)
+    });
+  }
+  return rows;
+}
+async function readClaudeSessionRecords(input) {
+  const path = await resolveTranscriptPath(input);
+  if (path === null) {
+    throw new Error(`No transcript file for Claude session ${input.sessionId}.`);
+  }
+  const records = [];
+  for await (const line of input.fs.readLines(path)) {
+    if (line.length > MAX_PARSED_LINE_BYTES) continue;
+    if (!line.includes('"type":"user"') && !line.includes('"type":"assistant"')) continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return records;
+}
+async function resolveTranscriptPath(input) {
+  const fileName = `${input.sessionId}${TRANSCRIPT_SUFFIX}`;
+  if (input.cwd !== void 0 && input.cwd.length > 0) {
+    const direct = NodePath.join(
+      input.transcriptDir,
+      encodeClaudeProjectDirName(input.cwd),
+      fileName
+    );
+    try {
+      if ((await input.fs.stat(direct)).type === "file") return direct;
+    } catch {
+    }
+  }
+  let dirs;
+  try {
+    dirs = (await input.fs.readDir(input.transcriptDir)).filter((entry) => entry.type === "directory").map((entry) => entry.name);
+  } catch {
+    return null;
+  }
+  for (const dir of dirs) {
+    const candidate2 = NodePath.join(input.transcriptDir, dir, fileName);
+    try {
+      if ((await input.fs.stat(candidate2)).type === "file") return candidate2;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function claudeSessionModifiedAt(input) {
+  const path = await resolveTranscriptPath(input);
+  if (path === null) return null;
+  try {
+    const stat = await input.fs.stat(path);
+    const mtimeMs = stat.modifiedAtIso === null ? 0 : Date.parse(stat.modifiedAtIso);
+    return Number.isFinite(mtimeMs) ? mtimeMs : 0;
+  } catch {
+    return null;
+  }
+}
+
+// src/codexAppServer.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var STDERR_TAIL_LIMIT = 2e3;
+var CODEX_INITIALIZE_PARAMS = {
+  clientInfo: { name: "ycodium", title: "Ycodium", version: "0" },
+  capabilities: { experimentalApi: true }
+};
+async function openCodexAppServer(input) {
+  const handle = await input.process.spawn({
+    program: input.program,
+    args: ["app-server", ...input.args],
+    ...input.env === void 0 ? {} : { env: input.env }
+  });
+  const pending = /* @__PURE__ */ new Map();
+  const decoder = new TextDecoder();
+  let nextId = 1;
+  let stderrTail = "";
+  let exitReason = null;
+  const failAll = (reason) => {
+    exitReason = reason;
+    for (const [, entry] of pending) {
+      entry.reject(new Error(`codex app-server ${entry.method} failed: ${reason}`));
+    }
+    pending.clear();
+  };
+  const dispatch = (line) => {
+    if (line.trim().length === 0) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    const typed = message;
+    if (typeof typed.id !== "number") return;
+    const entry = pending.get(typed.id);
+    if (entry === void 0) return;
+    pending.delete(typed.id);
+    if (typed.error !== void 0 && typed.error !== null) {
+      const detail = typeof typed.error.message === "string" ? typed.error.message : JSON.stringify(typed.error);
+      entry.reject(new Error(`codex app-server ${entry.method} failed: ${detail}`));
+      return;
+    }
+    entry.resolve(typed.result);
+  };
+  const pumpStdout = (async () => {
+    let buffer = "";
+    for await (const chunk of handle.stdout) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        dispatch(buffer.slice(0, index));
+        buffer = buffer.slice(index + 1);
+        index = buffer.indexOf("\n");
+      }
+    }
+    dispatch(buffer);
+  })().catch(() => void 0);
+  const pumpStderr = (async () => {
+    const errorDecoder = new TextDecoder();
+    for await (const chunk of handle.stderr) {
+      stderrTail = `${stderrTail}${errorDecoder.decode(chunk, { stream: true })}`.slice(
+        -STDERR_TAIL_LIMIT
+      );
+    }
+  })().catch(() => void 0);
+  void handle.exited.then((code) => {
+    failAll(
+      `the process exited with code ${String(code)}${stderrTail.length > 0 ? `: ${stderrTail.trim()}` : ""}`
+    );
+  }).catch(() => failAll("the process ended unexpectedly"));
+  const timeoutMs = input.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const request = async (method, params) => {
+    if (exitReason !== null) throw new Error(`codex app-server ${method} failed: ${exitReason}`);
+    const id = nextId;
+    nextId += 1;
+    const settled = new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject, method });
+    });
+    await handle.writeStdin(
+      `${JSON.stringify({ id, method, ...params === void 0 ? {} : { params } })}
+`
+    );
+    let timer;
+    try {
+      return await Promise.race([
+        settled,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error(`codex app-server ${method} timed out after ${String(timeoutMs)}ms`));
+          }, timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  const notify = async (method, params) => {
+    await handle.writeStdin(
+      `${JSON.stringify({ method, ...params === void 0 ? {} : { params } })}
+`
+    );
+  };
+  const close = async () => {
+    try {
+      await handle.closeStdin();
+    } catch {
+    }
+    try {
+      await handle.kill();
+    } catch {
+    }
+    failAll("the client was closed");
+    await Promise.all([pumpStdout, pumpStderr]);
+  };
+  try {
+    await request("initialize", CODEX_INITIALIZE_PARAMS);
+    await notify("initialized");
+  } catch (error) {
+    await close();
+    throw error;
+  }
+  return { request, notify, close };
+}
+
+// src/codexSessionScan.ts
+import * as NodePath2 from "node:path";
+var PAGE_LIMIT = 50;
+var MAX_PAGES = 10;
+var MAX_ROWS2 = 50;
+var PREVIEW_LIMIT2 = 200;
+function truncate2(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0) return null;
+  return trimmed.length <= PREVIEW_LIMIT2 ? trimmed : `${trimmed.slice(0, PREVIEW_LIMIT2)}\u2026`;
+}
+var asString = (value) => typeof value === "string" ? value : null;
+var nativeModel = (value) => {
+  const model = asString(value)?.trim();
+  return model && model !== "<synthetic>" ? model : null;
+};
+var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function readListPage(response) {
+  if (!response || typeof response !== "object") return { threads: [], nextCursor: null };
+  const typed = response;
+  const rows = Array.isArray(typed.data) ? typed.data : [];
+  const threads = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const thread = row;
+    if (typeof thread.id !== "string" || typeof thread.cwd !== "string") continue;
+    threads.push({
+      id: thread.id,
+      cwd: thread.cwd,
+      name: asString(thread.name),
+      preview: asString(thread.preview),
+      model: asString(thread.model),
+      updatedAt: typeof thread.updatedAt === "number" ? thread.updatedAt : 0
+    });
+  }
+  return { threads, nextCursor: asString(typed.nextCursor) };
+}
+function readThreadTurns(response) {
+  if (!response || typeof response !== "object") return [];
+  const thread = response.thread;
+  if (!thread || typeof thread !== "object") return [];
+  const turns = thread.turns;
+  if (!Array.isArray(turns)) return [];
+  return turns.flatMap((turn) => {
+    if (!turn || typeof turn !== "object") return [];
+    const typed = turn;
+    return [
+      {
+        ...typeof typed.id === "string" && typed.id.length > 0 ? { id: typed.id } : {},
+        ...typeof typed.model === "string" && typed.model.length > 0 ? { model: typed.model } : {},
+        startedAt: typeof typed.startedAt === "number" ? typed.startedAt : null,
+        items: Array.isArray(typed.items) ? typed.items : []
+      }
+    ];
+  });
+}
+async function scanCodexSessions(input) {
+  const threads = [];
+  let cursor = null;
+  for (let page = 0; page < MAX_PAGES && threads.length < MAX_ROWS2; page += 1) {
+    const listed = readListPage(
+      await input.client.request("thread/list", {
+        limit: PAGE_LIMIT,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        ...cursor === null ? {} : { cursor }
+      })
+    );
+    for (const thread of listed.threads) {
+      if (!isWithinDirectory(thread.cwd, input.directory, input.caseInsensitive)) continue;
+      threads.push(thread);
+      if (threads.length >= MAX_ROWS2) break;
+    }
+    if (listed.nextCursor === null || listed.nextCursor.length === 0) break;
+    cursor = listed.nextCursor;
+  }
+  const rows = [];
+  for (const thread of threads) {
+    const turnCount = await input.client.request("thread/read", { threadId: thread.id, includeTurns: true }).then((response) => readThreadTurns(response).length).catch(() => 0);
+    rows.push({
+      threadId: thread.id,
+      cwd: thread.cwd,
+      title: truncate2(thread.name),
+      preview: truncate2(thread.preview),
+      // modelProvider 是供应商标识，不是生成回复的模型；缺模型字段就省略。
+      model: truncate2(thread.model),
+      turnCount,
+      // app-server 给的是 Unix 秒，列表行统一按毫秒走，跟 Claude 那边对齐。
+      updatedAt: thread.updatedAt * 1e3
+    });
+  }
+  return rows;
+}
+async function readCodexSession(input) {
+  const response = await input.client.request("thread/read", {
+    threadId: input.threadId,
+    includeTurns: true
+  });
+  const thread = asRecord(asRecord(response)?.thread);
+  const path = input.caseInsensitive ? NodePath2.win32 : NodePath2;
+  const sameDirectory = (left, right) => isWithinDirectory(path.resolve(left), path.resolve(right), input.caseInsensitive) && isWithinDirectory(path.resolve(right), path.resolve(left), input.caseInsensitive);
+  if (thread?.id !== input.threadId || typeof thread.cwd !== "string" || !path.isAbsolute(thread.cwd) || !path.isAbsolute(input.cwd) || !sameDirectory(thread.cwd, input.cwd)) {
+    throw new Error("The native Codex session does not match the requested session and directory.");
+  }
+  const model = nativeModel(thread.model);
+  return {
+    turns: readThreadTurns(response),
+    model: model ?? (input.readRolloutModel === false ? null : await readRolloutModel(input, thread.path, sameDirectory))
+  };
+}
+async function readRolloutModel(input, rolloutPath, sameDirectory) {
+  const path = input.caseInsensitive ? NodePath2.win32 : NodePath2;
+  if (typeof rolloutPath !== "string" || !path.isAbsolute(rolloutPath) || path.extname(rolloutPath).toLowerCase() !== ".jsonl")
+    return null;
+  const resolved = path.resolve(rolloutPath);
+  const roots = [
+    ...input.homePath ? [path.join(input.homePath, "sessions"), path.join(input.homePath, "archived_sessions")] : [],
+    ...input.transcriptDir ? [input.transcriptDir, path.join(path.dirname(input.transcriptDir), "archived_sessions")] : []
+  ];
+  if (!roots.some((root) => isWithinDirectory(resolved, path.resolve(root), input.caseInsensitive)))
+    return null;
+  let verified = false;
+  let model = null;
+  try {
+    for await (const line of input.fs.readLines(resolved)) {
+      if (!line.includes('"session_meta"') && !line.includes('"turn_context"')) continue;
+      let record3;
+      try {
+        record3 = asRecord(JSON.parse(line));
+      } catch {
+        continue;
+      }
+      const payload = asRecord(record3?.payload);
+      if (!record3 || !payload) continue;
+      if (record3.type === "session_meta" && !verified) {
+        if ((payload.id ?? payload.session_id) !== input.threadId || typeof payload.cwd !== "string" || !path.isAbsolute(payload.cwd) || !sameDirectory(payload.cwd, input.cwd))
+          return null;
+        verified = true;
+      } else if (record3.type === "turn_context" && verified) {
+        model = nativeModel(payload.model) ?? model;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return model;
+}
+
+// src/reconcileImportedTimeline.ts
+import * as NodeCrypto from "node:crypto";
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function sourceId(value, input) {
+  const source2 = record(value);
+  return source2?.kind === "native-session" && source2.provider === input.provider && source2.sessionId === input.nativeSessionId && typeof source2.messageId === "string" ? source2.messageId : void 0;
+}
+function stableId(input, kind, nativeId) {
+  const digest = NodeCrypto.createHash("sha256").update(JSON.stringify([input.threadId, input.provider, input.nativeSessionId, kind, nativeId])).digest("hex");
+  return `native-${kind}:${digest}`;
+}
+function sourceFor(input, item) {
+  return {
+    kind: "native-session",
+    provider: input.provider,
+    sessionId: input.nativeSessionId,
+    messageId: item.sourceId,
+    ...item.nativeTurnId ? { turnId: item.nativeTurnId } : {},
+    order: item.sourceOrder
+  };
+}
+function equalValue(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => equalValue(value, right[index]));
+  }
+  const leftRecord = record(left);
+  const rightRecord = record(right);
+  if (!leftRecord || !rightRecord) return false;
+  const keys = Object.keys(leftRecord);
+  return keys.length === Object.keys(rightRecord).length && keys.every(
+    (key) => Object.hasOwn(rightRecord, key) && equalValue(leftRecord[key], rightRecord[key])
+  );
+}
+function messageFingerprint(message) {
+  return JSON.stringify([message.role, message.text, message.createdAt]);
+}
+function toolCallId(activity) {
+  const value = record(activity.payload)?.toolCallId;
+  return activity.kind.startsWith("tool.") && typeof value === "string" ? value : void 0;
+}
+function reconcileImportedTimeline(input) {
+  const messages = [];
+  const activities = [];
+  const nativeMessages = [
+    ...new Map(input.transcript.messages.map((item) => [item.sourceId, item])).values()
+  ].sort((left, right) => left.sourceOrder - right.sourceOrder);
+  const existingBySource = /* @__PURE__ */ new Map();
+  const legacyByFingerprint = /* @__PURE__ */ new Map();
+  for (const message of input.existingMessages) {
+    const identity = sourceId(message.source, input);
+    if (identity) existingBySource.set(identity, message);
+    else if (!message.source) {
+      const fingerprint = messageFingerprint(message);
+      const bucket = legacyByFingerprint.get(fingerprint) ?? [];
+      bucket.push(message);
+      legacyByFingerprint.set(fingerprint, bucket);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const message of nativeMessages) {
+    const recordId = /^claude:(.+):block:\d+$/.exec(message.sourceId)?.[1];
+    if (input.provider !== "claude" || !recordId) continue;
+    const group = groups.get(recordId) ?? [];
+    group.push(message);
+    groups.set(recordId, group);
+  }
+  const units = [];
+  const coveredIds = /* @__PURE__ */ new Set();
+  for (const group of groups.values()) {
+    const first = group[0];
+    if (!first || group.length < 2) continue;
+    const combined = {
+      ...first,
+      text: group.map((message) => message.text).join("\n\n").trim()
+    };
+    const sourced = existingBySource.get(first.sourceId);
+    const legacy = legacyByFingerprint.get(messageFingerprint(combined));
+    if (sourced?.text === combined.text && sourced.role === combined.role || legacy?.length === 1) {
+      units.push({ message: combined, covered: group });
+      for (const message of group) coveredIds.add(message.sourceId);
+    }
+  }
+  for (const message of nativeMessages) {
+    if (coveredIds.has(message.sourceId)) continue;
+    const trimmed = { ...message, text: message.text.trim() };
+    const sourced = existingBySource.get(message.sourceId);
+    const wasTrimmed = message.text !== trimmed.text && (sourced?.text === trimmed.text && sourced.role === message.role || !legacyByFingerprint.has(messageFingerprint(message)) && legacyByFingerprint.has(messageFingerprint(trimmed)));
+    units.push({ message: wasTrimmed ? trimmed : message, covered: [message] });
+  }
+  units.sort((left, right) => left.message.sourceOrder - right.message.sourceOrder);
+  const nativeFingerprintCounts = /* @__PURE__ */ new Map();
+  for (const { message } of units) {
+    const fingerprint = messageFingerprint(message);
+    nativeFingerprintCounts.set(fingerprint, (nativeFingerprintCounts.get(fingerprint) ?? 0) + 1);
+  }
+  const aligned = /* @__PURE__ */ new Map();
+  const matchedExisting = /* @__PURE__ */ new Set();
+  let hasLegacyMatches = false;
+  for (const { message } of units) {
+    const sourced = existingBySource.get(message.sourceId);
+    const fingerprint = messageFingerprint(message);
+    const legacy = message.createdAt && nativeFingerprintCounts.get(fingerprint) === 1 ? legacyByFingerprint.get(fingerprint) : void 0;
+    const existing = sourced ?? (legacy?.length === 1 ? legacy[0] : void 0);
+    if (!existing || matchedExisting.has(existing.messageId)) continue;
+    aligned.set(message.sourceId, existing);
+    matchedExisting.add(existing.messageId);
+    if (!sourced) hasLegacyMatches = true;
+  }
+  const latest = input.existingMessages.at(-1);
+  const latestOwned = latest && matchedExisting.has(latest.messageId);
+  let suffixOrder = Number.POSITIVE_INFINITY;
+  const latestSource = record(latest?.source);
+  if (sourceId(latest?.source, input) && typeof latestSource?.order === "number") {
+    suffixOrder = latestSource.order;
+  }
+  if (latest && !latestOwned && !latest.source) {
+    for (let index = units.length - 1; index >= 0; index--) {
+      const unit = units[index];
+      if (unit?.message.role === latest.role && unit.message.text === latest.text) {
+        suffixOrder = Math.max(...unit.covered.map((message) => message.sourceOrder));
+        break;
+      }
+    }
+  }
+  const mayBackfill = !latest || latestOwned;
+  let appendedMessageCount = 0;
+  for (const { message } of units) {
+    const existing = aligned.get(message.sourceId);
+    if (!existing && legacyByFingerprint.has(messageFingerprint(message))) continue;
+    if (!existing && !mayBackfill && message.sourceOrder <= suffixOrder) continue;
+    const createdAt = message.createdAt || existing?.createdAt || input.fallbackIso;
+    const modelSelection = message.model?.trim() ? { instanceId: input.instanceId, model: message.model } : existing?.modelSelection;
+    const next = {
+      messageId: existing?.messageId ?? stableId(input, "message", message.sourceId),
+      role: message.role,
+      text: message.text,
+      createdAt,
+      updatedAt: existing?.text === message.text ? existing.updatedAt ?? createdAt : createdAt,
+      source: sourceFor(input, message),
+      ...modelSelection ? { modelSelection } : {}
+    };
+    if (existing && existing.role === next.role && existing.text === next.text && existing.createdAt === next.createdAt && equalValue(existing.source, next.source) && equalValue(existing.modelSelection, next.modelSelection))
+      continue;
+    messages.push(next);
+    if (!existing) appendedMessageCount++;
+  }
+  const activityBySource = /* @__PURE__ */ new Map();
+  const activityById = /* @__PURE__ */ new Map();
+  const activitiesByCall = /* @__PURE__ */ new Map();
+  for (const activity of input.existingActivities) {
+    const identity = sourceId(record(activity.payload)?.source, input);
+    if (identity) activityBySource.set(identity, activity);
+    const id = activity.id ?? activity.activityId;
+    if (id) activityById.set(id, activity);
+    const callId = toolCallId(activity);
+    if (callId) {
+      const bucket = activitiesByCall.get(callId) ?? [];
+      bucket.push(activity);
+      activitiesByCall.set(callId, bucket);
+    }
+  }
+  const nativeActivities = new Map(
+    input.transcript.activities.map((item) => [item.sourceId, item])
+  );
+  for (const activity of nativeActivities.values()) {
+    const generatedId = stableId(input, "activity", activity.sourceId);
+    const sourced = activityBySource.get(activity.sourceId) ?? activityById.get(generatedId);
+    const callId = toolCallId(activity);
+    const callMatches = callId ? activitiesByCall.get(callId) : void 0;
+    if (!sourced && callMatches?.some((match) => match.turnId !== null)) continue;
+    const legacyMatches = callMatches?.filter(
+      (match) => match.kind === activity.kind && !record(match.payload)?.source
+    );
+    const legacy = legacyMatches?.length === 1 ? legacyMatches[0] : void 0;
+    const existing = sourced ?? legacy;
+    if (!existing && callMatches?.length) continue;
+    if (!existing && !mayBackfill && !hasLegacyMatches && activity.sourceOrder <= suffixOrder)
+      continue;
+    const payload = {
+      ...record(existing?.payload),
+      ...record(activity.payload),
+      source: sourceFor(input, activity)
+    };
+    const next = {
+      id: existing?.id ?? existing?.activityId ?? generatedId,
+      kind: activity.kind,
+      tone: activity.tone,
+      summary: activity.summary,
+      payload,
+      createdAt: activity.createdAt || existing?.createdAt || input.fallbackIso,
+      turnId: null
+    };
+    if (existing && existing.kind === next.kind && existing.tone === next.tone && existing.summary === next.summary && existing.createdAt === next.createdAt && existing.turnId === null && equalValue(existing.payload, next.payload))
+      continue;
+    activities.push(next);
+  }
+  return { messages, activities, hasLegacyMatches, appendedMessageCount };
+}
+
+// src/sessionTranscript.ts
+import * as NodeCrypto2 from "node:crypto";
+
+// src/wireTypes.ts
+var SESSION_IMPORT_MESSAGE_LIMIT = 200;
+var SessionImportFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SessionImportFailure";
+    this.code = code;
+  }
+};
+
+// src/sessionTranscript.ts
+var SESSION_IMPORT_ACTIVITY_LIMIT = 1e3;
+var SESSION_IMPORT_ACTIVITY_TEXT_LIMIT = 32e3;
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var nonempty = (value) => typeof value === "string" && value.trim().length > 0 ? value : void 0;
+function nativeModel2(value) {
+  const model = nonempty(value);
+  return model?.trim() === "<synthetic>" ? void 0 : model;
+}
+function fallbackId(value) {
+  let text;
+  try {
+    text = JSON.stringify(value) ?? "";
+  } catch {
+    text = "";
+  }
+  return `record:${NodeCrypto2.createHash("sha256").update(text).digest("hex").slice(0, 20)}`;
+}
+function readableContent(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.flatMap((entry) => {
+    if (typeof entry === "string") return [entry];
+    const block = record2(entry);
+    return block && ["text", "input_text", "output_text", "summary_text", "reasoning_text"].includes(
+      String(block.type)
+    ) && typeof block.text === "string" ? [block.text] : [];
+  }).join("\n\n");
+}
+function toolInput(value) {
+  if (typeof value === "string") return value;
+  const input = record2(value);
+  if (input && Object.keys(input).length === 1 && typeof input.command === "string")
+    return input.command;
+  if (input && Object.keys(input).length === 1 && typeof input.cmd === "string") return input.cmd;
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return void 0;
+  }
+}
+function toolType(name) {
+  const normalized = name.toLowerCase();
+  if (/^(bash|shell|command|terminal|exec_command|write_stdin)$/u.test(normalized))
+    return "command_execution";
+  if (/^(edit|write|multiedit|apply_patch|applypatch|patch)$/u.test(normalized))
+    return "file_change";
+  if (/^(agent|task|workflow)$/u.test(normalized)) return "dynamic_tool_call";
+  if (normalized.startsWith("mcp")) return "mcp_tool_call";
+  if (/^(websearch|webfetch|web_search)$/u.test(normalized)) return "web_search";
+  return "dynamic_tool_call";
+}
+function limit(messages, activities) {
+  const availableMessages = messages.length;
+  const retainedMessages = messages.slice(-SESSION_IMPORT_MESSAGE_LIMIT);
+  const floor = availableMessages > SESSION_IMPORT_MESSAGE_LIMIT ? retainedMessages[0]?.sourceOrder ?? 0 : 0;
+  const visibleActivities = activities.filter((activity) => activity.sourceOrder >= floor);
+  const retainedActivities = visibleActivities.slice(-SESSION_IMPORT_ACTIVITY_LIMIT);
+  return {
+    availableMessages,
+    availableActivities: activities.length,
+    ...retainedActivities.length < activities.length ? { activityTruncated: true } : {},
+    messages: retainedMessages,
+    activities: retainedActivities
+  };
+}
+function bounded(value, tail = false) {
+  if (value.length <= SESSION_IMPORT_ACTIVITY_TEXT_LIMIT) return { text: value, truncated: false };
+  const offset = tail ? value.length - SESSION_IMPORT_ACTIVITY_TEXT_LIMIT : SESSION_IMPORT_ACTIVITY_TEXT_LIMIT;
+  const character = value.charCodeAt(offset);
+  const previous = value.charCodeAt(offset - 1);
+  const splitPair = character >= 56320 && character <= 57343 && previous >= 55296 && previous <= 56319;
+  return {
+    text: tail ? value.slice(offset + (splitPair ? 1 : 0)) : value.slice(0, offset - (splitPair ? 1 : 0)),
+    truncated: true
+  };
+}
+function inputPayload(input) {
+  if (input === void 0) return {};
+  const result = bounded(input);
+  return { input: result.text, ...result.truncated ? { inputTruncated: true } : {} };
+}
+function outputPayload(output) {
+  if (output === void 0) return {};
+  const result = bounded(output, true);
+  return { output: result.text, ...result.truncated ? { outputTruncated: true } : {} };
+}
+function reasoning(identity, text, streamKind) {
+  const result = bounded(text);
+  return {
+    ...identity,
+    kind: "reasoning",
+    tone: "info",
+    summary: "Reasoning",
+    payload: {
+      text: result.text,
+      streamKind,
+      chars: result.text.length,
+      streaming: false,
+      ...result.truncated ? { truncated: true } : {}
+    }
+  };
+}
+function readClaudeTranscript(records) {
+  const messages = [];
+  const activities = [];
+  const byUuid = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Map();
+  const toolsById = /* @__PURE__ */ new Map();
+  for (const raw of records) {
+    const value = record2(raw);
+    if (!value || value.type !== "user" && value.type !== "assistant") continue;
+    if (value.isSidechain === true || value.isSideChain === true || value.isMeta === true || nonempty(value.parent_tool_use_id))
+      continue;
+    const uuid = nonempty(value.uuid) ?? fallbackId(raw);
+    const previous = byUuid.get(uuid);
+    const beforeMessage = record2(previous?.message);
+    const nextMessage = record2(value.message);
+    if (previous && beforeMessage && nextMessage && Array.isArray(beforeMessage.content) && Array.isArray(nextMessage.content)) {
+      const beforeBlocks = beforeMessage.content;
+      byUuid.set(uuid, {
+        ...previous,
+        ...value,
+        message: {
+          ...beforeMessage,
+          ...nextMessage,
+          content: nextMessage.content.map((entry, index) => {
+            const block = record2(entry);
+            const before = record2(beforeBlocks[index]);
+            return block?.type === "tool_result" && before?.type === "tool_result" && block.tool_use_id === before.tool_use_id && block.is_error === void 0 && before.is_error === true ? { ...block, is_error: true } : entry;
+          })
+        }
+      });
+    } else byUuid.set(uuid, value);
+  }
+  let nativeTurnId;
+  let sourceOrder = 0;
+  for (const [uuid, value] of byUuid) {
+    const message = record2(value.message);
+    if (!message) continue;
+    const content = message.content;
+    const blocks = typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : [];
+    const hasToolResult = blocks.some((block) => record2(block)?.type === "tool_result");
+    const hasUserText = value.type === "user" && !hasToolResult && blocks.some((block) => {
+      const text = record2(block);
+      return text?.type === "text" && nonempty(text.text) !== void 0;
+    });
+    const hasUserInput = hasUserText || value.type === "user" && !hasToolResult && blocks.some((block) => record2(block)?.type === "image");
+    if (hasUserInput) nativeTurnId = nonempty(value.uuid);
+    const createdAt = typeof value.timestamp === "string" ? value.timestamp : "";
+    const model = nativeModel2(message.model) ?? nativeModel2(value.model);
+    for (const [blockIndex, rawBlock] of blocks.entries()) {
+      const block = record2(rawBlock);
+      const identity = {
+        sourceId: `claude:${uuid}:block:${blockIndex}`,
+        sourceOrder: sourceOrder++,
+        createdAt,
+        ...nativeTurnId !== void 0 ? { nativeTurnId } : {},
+        ...model !== void 0 ? { model } : {}
+      };
+      if (!block) continue;
+      if (block.type === "text" && nonempty(block.text) !== void 0 && (value.type === "assistant" || hasUserText)) {
+        messages.push({
+          ...identity,
+          role: value.type === "assistant" ? "assistant" : "user",
+          text: block.text
+        });
+      } else if (value.type === "assistant" && block.type === "thinking" && nonempty(block.thinking) !== void 0) {
+        activities.push(reasoning(identity, block.thinking, "reasoning_text"));
+      } else if (value.type === "assistant" && (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use")) {
+        const toolCallId2 = nonempty(block.id);
+        if (!toolCallId2) continue;
+        const key = `${nativeTurnId ?? ""}\0${toolCallId2}`;
+        const name = nonempty(block.name) ?? "Tool";
+        const input = toolInput(block.input);
+        const known = tools.get(key);
+        if (known) {
+          if (input !== void 0 && input !== "{}" && known.startIndex !== void 0) {
+            const { inputTruncated: _inputTruncated, ...before } = known.start.payload;
+            known.start = { ...known.start, payload: { ...before, ...inputPayload(input) } };
+            activities[known.startIndex] = known.start;
+            if (known.completionIndex !== void 0) {
+              const completion = activities[known.completionIndex];
+              const { inputTruncated: _completedTruncated, ...completedPayload } = completion.payload;
+              activities[known.completionIndex] = {
+                ...completion,
+                payload: { ...completedPayload, ...inputPayload(input) }
+              };
+            }
+          }
+          continue;
+        }
+        const start = {
+          ...identity,
+          kind: "tool.started",
+          tone: "tool",
+          summary: name,
+          payload: {
+            toolCallId: toolCallId2,
+            itemType: toolType(name),
+            toolName: name,
+            startedAt: createdAt,
+            ...inputPayload(input)
+          }
+        };
+        const startIndex = activities.push(start) - 1;
+        const tool = { start, startIndex, completedId: `${identity.sourceId}:completed` };
+        tools.set(key, tool);
+        toolsById.set(toolCallId2, tool);
+      } else if (block.type === "tool_result") {
+        const toolCallId2 = nonempty(block.tool_use_id);
+        if (!toolCallId2) continue;
+        const key = `${nativeTurnId ?? ""}\0${toolCallId2}`;
+        const tool = tools.get(key) ?? toolsById.get(toolCallId2);
+        const output = readableContent(block.content);
+        const previousStatus = tool?.completionIndex !== void 0 ? activities[tool.completionIndex]?.payload.status : void 0;
+        const status = block.is_error === true || block.status === "failed" ? "failed" : block.is_error === false ? "completed" : previousStatus === "failed" ? "failed" : "completed";
+        const completed = {
+          ...identity,
+          sourceId: tool?.completedId ?? `claude:tool:${toolCallId2}:completed`,
+          ...tool?.start.nativeTurnId !== void 0 ? { nativeTurnId: tool.start.nativeTurnId } : {},
+          ...tool?.start.model !== void 0 ? { model: tool.start.model } : {},
+          kind: "tool.completed",
+          tone: status === "failed" ? "error" : "tool",
+          summary: tool?.start.summary ?? "Tool",
+          payload: {
+            ...tool?.start.payload,
+            toolCallId: toolCallId2,
+            itemType: tool?.start.payload.itemType ?? "dynamic_tool_call",
+            status,
+            ...outputPayload(output)
+          }
+        };
+        if (tool?.completionIndex !== void 0) {
+          const previous = activities[tool.completionIndex];
+          activities[tool.completionIndex] = {
+            ...completed,
+            sourceOrder: previous.sourceOrder,
+            createdAt: previous.createdAt
+          };
+        } else {
+          const completionIndex = activities.push(completed) - 1;
+          if (tool) tool.completionIndex = completionIndex;
+          else {
+            const orphan = { start: completed, completedId: completed.sourceId, completionIndex };
+            tools.set(key, orphan);
+            toolsById.set(toolCallId2, orphan);
+          }
+        }
+      }
+    }
+  }
+  return limit(messages, activities);
+}
+function codexStatus(item) {
+  if (item.status === "failed" || item.error != null) return "failed";
+  if (item.status === "completed" || item.status === "done") return "completed";
+  if (item.status === "declined") return "declined";
+  if (item.status === "inProgress" || item.status === "in_progress" || item.status === "running")
+    return "inProgress";
+  if (typeof item.exitCode === "number" && Number.isInteger(item.exitCode))
+    return item.exitCode === 0 ? "completed" : "failed";
+  return void 0;
+}
+function codexOutput(item) {
+  if (typeof item.aggregatedOutput === "string") return item.aggregatedOutput;
+  if (typeof item.output === "string") return item.output;
+  const result = record2(item.result);
+  if (typeof item.result === "string") return item.result;
+  if (result?.content !== void 0) return readableContent(result.content);
+  if (item.contentItems !== void 0) return readableContent(item.contentItems);
+  const error = record2(item.error);
+  return typeof error?.message === "string" ? error.message : void 0;
+}
+function readCodexTranscript(turns) {
+  const messages = [];
+  const activities = [];
+  const items = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    for (const raw of turn.items) {
+      const item = record2(raw);
+      if (!item) continue;
+      const sourceId2 = `codex:${turn.id ?? "unassigned"}:${nonempty(item.id) ?? fallbackId(raw)}`;
+      const previous = items.get(sourceId2);
+      items.set(sourceId2, {
+        item: { ...previous?.item, ...item },
+        turn: previous ? {
+          ...previous.turn,
+          ...turn,
+          startedAt: turn.startedAt ?? previous.turn.startedAt,
+          model: turn.model ?? previous.turn.model
+        } : turn,
+        sourceId: sourceId2
+      });
+    }
+  }
+  let sourceOrder = 0;
+  for (const { item, turn, sourceId: sourceId2 } of items.values()) {
+    const milliseconds = typeof turn.startedAt === "number" ? turn.startedAt * 1e3 : NaN;
+    const createdAt = Number.isFinite(milliseconds) && Math.abs(milliseconds) <= 864e13 ? new Date(milliseconds).toISOString() : "";
+    const model = nativeModel2(item.model) ?? nativeModel2(turn.model);
+    const nativeTurnId = nonempty(turn.id);
+    const identity = {
+      sourceId: sourceId2,
+      sourceOrder,
+      createdAt,
+      ...nativeTurnId !== void 0 ? { nativeTurnId } : {},
+      ...model !== void 0 ? { model } : {}
+    };
+    sourceOrder += 4;
+    if (item.type === "userMessage" || item.type === "agentMessage") {
+      const text = item.type === "userMessage" ? readableContent(item.content) : typeof item.text === "string" ? item.text : "";
+      if (text.trim().length > 0)
+        messages.push({
+          ...identity,
+          role: item.type === "userMessage" ? "user" : "assistant",
+          text
+        });
+      continue;
+    }
+    if (item.type === "reasoning") {
+      const summary2 = readableContent(item.summary);
+      const text = readableContent(item.content) || (typeof item.text === "string" ? item.text : "");
+      if (summary2.trim().length > 0)
+        activities.push(
+          reasoning(
+            { ...identity, sourceId: `${sourceId2}:summary` },
+            summary2,
+            "reasoning_summary_text"
+          )
+        );
+      if (text.trim().length > 0 && text !== summary2)
+        activities.push(
+          reasoning(
+            {
+              ...identity,
+              sourceId: `${sourceId2}:text`,
+              sourceOrder: summary2 ? identity.sourceOrder + 1 : identity.sourceOrder
+            },
+            text,
+            "reasoning_text"
+          )
+        );
+      continue;
+    }
+    const itemTypes = {
+      commandExecution: "command_execution",
+      fileChange: "file_change",
+      mcpToolCall: "mcp_tool_call",
+      dynamicToolCall: "dynamic_tool_call",
+      collabAgentToolCall: "dynamic_tool_call",
+      webSearch: "web_search",
+      imageView: "image_view"
+    };
+    const itemType = itemTypes[String(item.type)];
+    const toolCallId2 = nonempty(item.id);
+    if (!itemType || !toolCallId2) continue;
+    const input = toolInput(item.command ?? item.arguments ?? item.input ?? item.changes);
+    const output = codexOutput(item);
+    const status = codexStatus(item);
+    const summary = nonempty(item.tool) ?? nonempty(item.name) ?? (itemType === "command_execution" ? "Command" : itemType === "file_change" ? "File changes" : "Tool");
+    const payload = {
+      toolCallId: toolCallId2,
+      itemType,
+      startedAt: createdAt,
+      ...inputPayload(input),
+      ...status === "inProgress" ? { status } : {}
+    };
+    activities.push({
+      ...identity,
+      kind: "tool.started",
+      tone: "tool",
+      summary,
+      payload: {
+        ...payload,
+        ...status === void 0 ? outputPayload(output) : {}
+      }
+    });
+    if (status && status !== "inProgress")
+      activities.push({
+        ...identity,
+        sourceId: `${sourceId2}:completed`,
+        sourceOrder: identity.sourceOrder + 1,
+        kind: "tool.completed",
+        tone: status === "failed" ? "error" : "tool",
+        summary,
+        payload: {
+          ...payload,
+          status,
+          ...outputPayload(output),
+          ...typeof item.exitCode === "number" && Number.isInteger(item.exitCode) ? { exitCode: item.exitCode } : {}
+        }
+      });
+  }
+  return limit(messages, activities);
+}
+
+// src/sessionImportRuntime.ts
+var NOT_IMPORTED = {
+  status: "not-imported",
+  appended: 0
+};
+var UNCHANGED = { status: "unchanged", appended: 0 };
+var SKIPPED_ACTIVE = {
+  status: "skipped-active",
+  appended: 0
+};
+var IMPORTED_TITLE_MAX_LENGTH = 80;
+var CLAUDE_DRIVER = "claudeAgent";
+var CODEX_DRIVER = "codex";
+var providerKindOfDriver = (driverKind) => driverKind === CLAUDE_DRIVER ? "claude" : driverKind === CODEX_DRIVER ? "codex" : void 0;
+var importedThreadKey = (provider, nativeSessionId) => `${provider}:${nativeSessionId}`;
+var caseInsensitivePaths = () => NodeProcess2.platform === "win32";
+var LAUNCH_ARGS_ENV = "YCODIUM_CODEX_LAUNCH_ARGS";
+var resolveCodexLaunchArgs = (instance) => instance.environment[LAUNCH_ARGS_ENV]?.trim() || instance.launchArgs.trim() || "";
+function tokenizeLaunchArgs(value) {
+  const input = value.trim();
+  if (input.length === 0) return [];
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let quoted = false;
+  for (const char of input) {
+    if (quote !== null) {
+      if (char === quote) quote = null;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      quoted = true;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      if (current.length > 0 || quoted) tokens.push(current);
+      current = "";
+      quoted = false;
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0 || quoted) tokens.push(current);
+  return tokens;
+}
+var nativeSessionIdOf = (provider, cursor) => {
+  if (cursor === null || typeof cursor !== "object") return null;
+  const record3 = cursor;
+  const value = provider === "claude" ? record3.resume ?? record3.sessionId : record3.threadId;
+  return typeof value === "string" && value.length > 0 ? value : null;
+};
+async function readImportedThreads(ctx) {
+  const imported = /* @__PURE__ */ new Map();
+  const bindings = await ctx.providers.sessions.list().catch(() => []);
+  for (const binding of bindings) {
+    const provider = providerKindOfDriver(binding.driver);
+    if (provider === void 0) continue;
+    const nativeId = nativeSessionIdOf(provider, binding.resumeCursor);
+    if (nativeId === null) continue;
+    imported.set(importedThreadKey(provider, nativeId), binding.threadId);
+  }
+  return imported;
+}
+var candidateOf = (input) => ({
+  provider: input.provider,
+  instanceId: input.instanceId,
+  nativeSessionId: input.nativeSessionId,
+  cwd: input.cwd,
+  title: input.title,
+  preview: input.preview,
+  model: input.model,
+  turnCount: input.turnCount,
+  updatedAt: input.updatedAt,
+  availability: input.importedThreadId !== void 0 ? "alreadyImported" : "importable",
+  openElsewhere: input.openElsewhere,
+  ...input.importedThreadId !== void 0 ? { importedThreadId: input.importedThreadId } : {}
+});
+async function openCodexFor(ctx, instance) {
+  const binaryPath = ctx.config.codexBinaries?.[instance.instanceId];
+  if (binaryPath === void 0 || binaryPath.length === 0) {
+    throw new Error(`No codex binary is configured for provider instance ${instance.instanceId}.`);
+  }
+  return openCodexAppServer({
+    process: ctx.process,
+    // 白名单条目的键就是 instanceId：路径由宿主查，插件手上不留第二份。
+    program: { key: instance.instanceId },
+    args: [...tokenizeLaunchArgs(resolveCodexLaunchArgs(instance))],
+    // 转录始终在 CODEX_HOME 下；实例的 home 是宿主解析过的那个（含 auth overlay）。
+    ...instance.homePath === null ? {} : { env: { CODEX_HOME: instance.homePath } }
+  });
+}
+async function withCodex(ctx, instance, use) {
+  const client = await openCodexFor(ctx, instance);
+  try {
+    return await use(client);
+  } finally {
+    await client.close();
+  }
+}
+async function listSessions(ctx, input) {
+  const project = await ctx.projections.getProject(input.projectId);
+  if (project === null) {
+    throw new SessionImportFailure("notFound", "Project not found.");
+  }
+  const directory = input.directory ?? project.workspaceRoot;
+  const caseInsensitive = caseInsensitivePaths();
+  const instances = await ctx.providers.listInstances();
+  const imported = await readImportedThreads(ctx);
+  const sources = [];
+  const scannedKeys = /* @__PURE__ */ new Set();
+  for (const instance of instances) {
+    if (!instance.enabled) continue;
+    if (instance.driver === CODEX_DRIVER) {
+      const binaryPath = ctx.config.codexBinaries?.[instance.instanceId];
+      if (binaryPath === void 0) continue;
+      const scanKey2 = `codex:${instance.homePath ?? ""}:${binaryPath}`;
+      if (scannedKeys.has(scanKey2)) continue;
+      scannedKeys.add(scanKey2);
+      try {
+        const rows = await withCodex(
+          ctx,
+          instance,
+          (client) => scanCodexSessions({ client, directory, caseInsensitive })
+        );
+        sources.push({
+          instanceId: instance.instanceId,
+          provider: "codex",
+          candidates: rows.map(
+            (row) => candidateOf({
+              provider: "codex",
+              instanceId: instance.instanceId,
+              nativeSessionId: row.threadId,
+              cwd: row.cwd,
+              title: row.title,
+              preview: row.preview,
+              model: row.model,
+              turnCount: row.turnCount,
+              updatedAt: row.updatedAt,
+              // Codex 判不了活，双开由它自己在 resume 上挡。
+              openElsewhere: false,
+              importedThreadId: imported.get(importedThreadKey("codex", row.threadId))
+            })
+          ),
+          unavailableReason: null
+        });
+      } catch (error) {
+        ctx.log.warn("session-import could not read codex sessions", {
+          instanceId: instance.instanceId,
+          detail: describeError(error)
+        });
+        sources.push({
+          instanceId: instance.instanceId,
+          provider: "codex",
+          candidates: [],
+          unavailableReason: "Codex sessions could not be read."
+        });
+      }
+      continue;
+    }
+    if (instance.driver !== CLAUDE_DRIVER) continue;
+    if (instance.transcriptDir === null || instance.configDirPath === null) continue;
+    const scanKey = `claude:${instance.transcriptDir}`;
+    if (scannedKeys.has(scanKey)) continue;
+    scannedKeys.add(scanKey);
+    try {
+      const rows = await scanClaudeSessions({
+        fs: ctx.fs,
+        cache: ctx.cache,
+        transcriptDir: instance.transcriptDir,
+        configDir: instance.configDirPath,
+        directory,
+        caseInsensitive
+      });
+      sources.push({
+        instanceId: instance.instanceId,
+        provider: "claude",
+        candidates: rows.map(
+          (row) => candidateOf({
+            provider: "claude",
+            instanceId: instance.instanceId,
+            nativeSessionId: row.sessionId,
+            cwd: row.cwd,
+            title: row.title,
+            preview: row.preview,
+            model: row.model,
+            turnCount: row.turnCount,
+            updatedAt: row.updatedAt,
+            openElsewhere: row.openElsewhere,
+            importedThreadId: imported.get(importedThreadKey("claude", row.sessionId))
+          })
+        ),
+        unavailableReason: null
+      });
+    } catch (error) {
+      ctx.log.warn("session-import could not read claude sessions", {
+        instanceId: instance.instanceId,
+        detail: describeError(error)
+      });
+      sources.push({
+        instanceId: instance.instanceId,
+        provider: "claude",
+        candidates: [],
+        unavailableReason: "Claude sessions could not be read."
+      });
+    }
+  }
+  return { sources, directory };
+}
+var describeError = (error) => error instanceof Error ? error.message : String(error);
+function resolveImportedTitle(transcript) {
+  const first = transcript.messages.find((message) => message.role === "user");
+  const text = (first?.text ?? "").replace(/\s+/gu, " ").trim();
+  if (text.length === 0) return "Imported session";
+  return text.length > IMPORTED_TITLE_MAX_LENGTH ? `${text.slice(0, IMPORTED_TITLE_MAX_LENGTH - 1).trimEnd()}\u2026` : text;
+}
+function resolveImportedModelSelection(input) {
+  if (input.projectDefault !== null && input.projectDefault.instanceId === input.instance.instanceId) {
+    return input.projectDefault;
+  }
+  const models = input.instance.models;
+  if (models === void 0) return null;
+  const catalogModel = models.find((candidate2) => candidate2.isDefault) ?? models[0];
+  if (catalogModel !== void 0) {
+    return { instanceId: input.instance.instanceId, model: catalogModel.slug };
+  }
+  const transcript = input.transcript;
+  if (transcript === void 0) return null;
+  let model = transcript.model?.trim();
+  if (model === "<synthetic>") model = void 0;
+  if (!model) {
+    let latestOrder = -1;
+    for (const entry of [...transcript.messages, ...transcript.activities]) {
+      const nativeModel3 = entry.model?.trim();
+      if (nativeModel3 && nativeModel3 !== "<synthetic>" && entry.sourceOrder > latestOrder) {
+        model = nativeModel3;
+        latestOrder = entry.sourceOrder;
+      }
+    }
+  }
+  return model ? { instanceId: input.instance.instanceId, model } : null;
+}
+function importedHistoryBatches(history) {
+  const entries = [
+    ...history.messages.map((message) => ({ order: message.source.order, message })),
+    ...history.activities.map((activity) => ({
+      order: activity.payload.source.order,
+      activity
+    }))
+  ].sort((left, right) => left.order - right.order);
+  const batches = [];
+  let batch = { messages: [], activities: [] };
+  let bytes = 0;
+  let count = 0;
+  for (const entry of entries) {
+    const size = new TextEncoder().encode(JSON.stringify(entry)).byteLength;
+    if (size > 512e3) throw new Error("A native history record exceeds the import batch limit.");
+    if (count > 0 && (count >= 64 || bytes + size > 512e3)) {
+      batches.push(batch);
+      batch = { messages: [], activities: [] };
+      bytes = 0;
+      count = 0;
+    }
+    if ("message" in entry) batch.messages.push(entry.message);
+    else batch.activities.push(entry.activity);
+    bytes += size;
+    count++;
+  }
+  if (count > 0) batches.push(batch);
+  return batches;
+}
+var historyCommandId = (threadId, batch) => `native-history:${NodeCrypto3.createHash("sha256").update(JSON.stringify([threadId, batch])).digest("hex")}`;
+var importsInFlight = /* @__PURE__ */ new WeakMap();
+async function runImport(ctx, input, emit) {
+  let pending = importsInFlight.get(ctx);
+  if (!pending) importsInFlight.set(ctx, pending = /* @__PURE__ */ new Map());
+  const key = JSON.stringify([input.projectId, input.provider, input.nativeSessionId]);
+  const previous = pending.get(key) ?? Promise.resolve();
+  const operation = previous.catch(() => {
+  }).then(() => runImportOnce(ctx, input, emit));
+  pending.set(key, operation);
+  try {
+    await operation;
+  } finally {
+    if (pending.get(key) === operation) pending.delete(key);
+  }
+}
+async function runImportOnce(ctx, input, emit) {
+  let threadCreated = false;
+  let phase2 = "read";
+  const fail = (detail, code = "importFailed") => {
+    emit({
+      kind: "import_failed",
+      threadId: input.threadId,
+      phase: phase2,
+      message: detail,
+      threadCreated
+    });
+    throw new SessionImportFailure(code, detail);
+  };
+  const enterPhase = (next) => {
+    phase2 = next;
+    emit({ kind: "phase_started", threadId: input.threadId, phase: next });
+  };
+  emit({ kind: "import_started", threadId: input.threadId, phases: ["read", "create", "link"] });
+  const project = await ctx.projections.getProject(input.projectId);
+  if (project === null) return fail("Project not found.", "notFound");
+  const instances = await ctx.providers.listInstances();
+  const instance = instances.find((row) => row.instanceId === input.instanceId);
+  if (instance === void 0 || !instance.enabled) {
+    return fail(`This ${input.provider} provider instance is not enabled.`);
+  }
+  if (providerKindOfDriver(instance.driver) !== input.provider) {
+    return fail("The selected provider does not own this native session.");
+  }
+  const bindings = await ctx.providers.sessions.list();
+  const existing = await ctx.projections.getThread(input.threadId, { includeActivities: true });
+  const binding = bindings.find((candidate2) => candidate2.threadId === input.threadId);
+  if (existing !== null) {
+    const savedSources = [
+      ...existing.messages.map((message) => message.source),
+      ...(existing.activities ?? []).map(
+        (activity) => activity.payload !== null && typeof activity.payload === "object" ? activity.payload.source : void 0
+      )
+    ].filter((source2) => source2 !== void 0);
+    const pendingLink = binding === void 0 && savedSources.length > 0 && savedSources.every(
+      (source2) => source2 !== null && typeof source2 === "object" && source2.provider === input.provider && source2.sessionId === input.nativeSessionId
+    );
+    if (existing.projectId !== input.projectId || !pendingLink && (binding?.instanceId !== input.instanceId || providerKindOfDriver(binding.driver) !== input.provider || nativeSessionIdOf(input.provider, binding.resumeCursor) !== input.nativeSessionId))
+      return fail("This thread is not linked to the selected native session.");
+    if (existing.archivedAt !== null || existing.session?.activeTurnId != null || existing.session?.status === "running" || existing.session?.status === "starting")
+      return fail(
+        "The existing thread must be idle and unarchived before its history can be refreshed."
+      );
+    threadCreated = true;
+  } else {
+    for (const candidate2 of bindings) {
+      if (providerKindOfDriver(candidate2.driver) !== input.provider || nativeSessionIdOf(input.provider, candidate2.resumeCursor) !== input.nativeSessionId)
+        continue;
+      const imported = await ctx.projections.getThread(candidate2.threadId);
+      if (imported?.projectId === input.projectId)
+        return fail(
+          "This native session is already imported. Refresh its existing thread instead.",
+          "alreadyImported"
+        );
+    }
+  }
+  enterPhase("read");
+  const preferredModelSelection = existing?.modelSelection ?? resolveImportedModelSelection({ instance, projectDefault: project.defaultModelSelection });
+  const transcript = await readNativeTranscript(
+    ctx,
+    instance,
+    input,
+    preferredModelSelection === null && instance.models !== void 0
+  ).catch((error) => {
+    ctx.log.warn("session-import could not read the native session", {
+      instanceId: input.instanceId,
+      detail: describeError(error)
+    });
+    return null;
+  });
+  if (transcript === null) return fail("The session could not be read from disk.");
+  emit({
+    kind: "session_read",
+    threadId: input.threadId,
+    availableMessages: transcript.availableMessages,
+    restoredMessages: transcript.messages.length,
+    availableActivities: transcript.availableActivities,
+    restoredActivities: transcript.activities.length
+  });
+  enterPhase("create");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const history = reconcileImportedTimeline({
+    threadId: input.threadId,
+    provider: input.provider,
+    nativeSessionId: input.nativeSessionId,
+    instanceId: input.instanceId,
+    transcript,
+    existingMessages: existing?.messages ?? [],
+    existingActivities: existing?.activities ?? [],
+    fallbackIso: now
+  });
+  const modelSelection = preferredModelSelection ?? resolveImportedModelSelection({
+    instance,
+    projectDefault: project.defaultModelSelection,
+    // Codex 的续聊默认只认会话 API/rollout 读数，不借未经核实的 turn.model 回退。
+    transcript: input.provider === "codex" ? { model: transcript.model ?? null, messages: [], activities: [] } : transcript
+  });
+  if (modelSelection === null) return fail("This provider instance has no model to start from.");
+  let batches;
+  try {
+    batches = [...importedHistoryBatches(history)];
+  } catch {
+    return fail("A native history record is too large to import without truncating its text.");
+  }
+  if (existing === null && batches.length === 0) batches.push({ messages: [], activities: [] });
+  try {
+    for (const batch of batches) {
+      await ctx.commands.dispatch({
+        ...threadCreated ? { type: "thread.external-messages.append" } : {
+          type: "thread.import",
+          projectId: input.projectId,
+          title: resolveImportedTitle(transcript),
+          modelSelection,
+          runtimeMode: "full-access",
+          branch: null,
+          worktreePath: null
+        },
+        commandId: historyCommandId(input.threadId, batch),
+        threadId: input.threadId,
+        ...batch,
+        createdAt: now
+      });
+      threadCreated = true;
+    }
+  } catch (error) {
+    ctx.log.warn("session-import could not create the thread", {
+      threadId: input.threadId,
+      detail: describeError(error)
+    });
+    return fail("The native session history could not be saved.");
+  }
+  enterPhase("link");
+  const linked = await ctx.providers.sessions.setResumeCursor({
+    instanceId: input.instanceId,
+    threadId: input.threadId,
+    cursor: input.provider === "claude" ? { threadId: input.threadId, resume: input.nativeSessionId } : { threadId: input.nativeSessionId }
+  }).then(() => true).catch(() => false);
+  if (!linked) return fail("The thread was created but could not be linked to the session.");
+  emit({
+    kind: "import_finished",
+    threadId: input.threadId,
+    restoredMessages: transcript.messages.length,
+    restoredActivities: transcript.activities.length
+  });
+}
+async function readNativeTranscript(ctx, instance, input, readRolloutModel2) {
+  if (input.provider === "claude") {
+    if (instance.transcriptDir === null) {
+      throw new Error("This Claude instance has no transcript directory.");
+    }
+    return readClaudeTranscript(
+      await readClaudeSessionRecords({
+        fs: ctx.fs,
+        transcriptDir: instance.transcriptDir,
+        sessionId: input.nativeSessionId,
+        cwd: input.cwd
+      })
+    );
+  }
+  const session = await withCodex(
+    ctx,
+    instance,
+    (client) => readCodexSession({
+      client,
+      fs: ctx.fs,
+      threadId: input.nativeSessionId,
+      cwd: input.cwd,
+      homePath: instance.homePath,
+      transcriptDir: instance.transcriptDir,
+      caseInsensitive: caseInsensitivePaths(),
+      readRolloutModel: readRolloutModel2
+    })
+  );
+  return { ...readCodexTranscript(session.turns), model: session.model };
+}
+var NativeSessionTail = class {
+  /** 同一条 thread 的并发拾取串行化：打开会话与发消息可能同时打进来。 */
+  inFlight = /* @__PURE__ */ new Map();
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** 拾取一条 thread。任何失败都收成 `failed`，调用方不必 catch。 */
+  async sync(threadId) {
+    const previous = this.inFlight.get(threadId);
+    if (previous !== void 0) return previous;
+    const operation = this.syncOnce(threadId).catch((error) => {
+      this.ctx.log.warn("session-import sync failed", {
+        threadId,
+        detail: describeError(error)
+      });
+      return { status: "failed", appended: 0 };
+    });
+    this.inFlight.set(threadId, operation);
+    try {
+      return await operation;
+    } finally {
+      if (this.inFlight.get(threadId) === operation) this.inFlight.delete(threadId);
+    }
+  }
+  baselineKey(threadId) {
+    return `native-session-tail:${threadId}`;
+  }
+  /** 缓存里那条基线；没有、或者形状不对都当作“没见过”。 */
+  async readBaseline(threadId) {
+    const cached = await this.ctx.cache.getJson(this.baselineKey(threadId)).catch(() => null);
+    const value = cached?.value.modifiedAt;
+    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  }
+  async writeBaseline(threadId, modifiedAt) {
+    await this.ctx.cache.setJson(this.baselineKey(threadId), { modifiedAt }).catch((error) => {
+      this.ctx.log.warn("session-import could not record the tail baseline", {
+        threadId,
+        detail: describeError(error)
+      });
+    });
+  }
+  async syncOnce(threadId) {
+    const binding = (await this.ctx.providers.sessions.list()).find(
+      (candidate2) => candidate2.threadId === threadId && providerKindOfDriver(candidate2.driver) === "claude"
+    );
+    if (binding === void 0 || binding.instanceId === null) return NOT_IMPORTED;
+    const nativeSessionId = nativeSessionIdOf("claude", binding.resumeCursor);
+    if (nativeSessionId === null) return NOT_IMPORTED;
+    const instance = (await this.ctx.providers.listInstances()).find(
+      (row) => row.instanceId === binding.instanceId
+    );
+    const transcriptDir = instance?.transcriptDir ?? null;
+    if (transcriptDir === null) return NOT_IMPORTED;
+    const modifiedAt = await claudeSessionModifiedAt({
+      fs: this.ctx.fs,
+      transcriptDir,
+      sessionId: nativeSessionId
+    });
+    if (modifiedAt === null) return NOT_IMPORTED;
+    const seen = await this.readBaseline(threadId);
+    if (seen !== void 0 && modifiedAt <= seen) return UNCHANGED;
+    const thread = await this.ctx.projections.getThread(threadId, { includeActivities: true });
+    if (thread === null || thread.archivedAt !== null) return NOT_IMPORTED;
+    if (thread.session?.activeTurnId != null) return SKIPPED_ACTIVE;
+    if (thread.session?.status === "running" || thread.session?.status === "starting")
+      return SKIPPED_ACTIVE;
+    const records = await readClaudeSessionRecords({
+      fs: this.ctx.fs,
+      transcriptDir,
+      sessionId: nativeSessionId
+    }).catch(() => null);
+    if (records === null) return { status: "failed", appended: 0 };
+    const appendedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const history = reconcileImportedTimeline({
+      threadId,
+      provider: "claude",
+      nativeSessionId,
+      instanceId: binding.instanceId,
+      transcript: readClaudeTranscript(records),
+      existingMessages: thread.messages,
+      existingActivities: thread.activities ?? [],
+      fallbackIso: appendedAt
+    });
+    const batches = importedHistoryBatches(history);
+    if (batches.length === 0) {
+      await this.writeBaseline(threadId, modifiedAt);
+      return { status: "synced", appended: 0 };
+    }
+    try {
+      for (const batch of batches) {
+        await this.ctx.commands.dispatch({
+          type: "thread.external-messages.append",
+          commandId: historyCommandId(threadId, batch),
+          threadId,
+          ...batch,
+          createdAt: appendedAt
+        });
+      }
+    } catch (error) {
+      this.ctx.log.warn("session-import sync append failed", {
+        threadId,
+        detail: describeError(error)
+      });
+      return { status: "failed", appended: 0 };
+    }
+    await this.writeBaseline(threadId, modifiedAt);
+    this.ctx.log.info("session-import sync appended external messages", {
+      threadId,
+      appendedMessages: history.appendedMessageCount,
+      updatedMessages: history.messages.length,
+      updatedActivities: history.activities.length
+    });
+    if (history.appendedMessageCount === 0 && (history.hasLegacyMatches || history.activities.length === 0))
+      return { status: "synced", appended: history.appendedMessageCount };
+    const current = await this.ctx.projections.getThread(threadId);
+    if (current?.session == null || current.session.status === "stopped" || current.session.activeTurnId !== null || current.session.status === "running" || current.session.status === "starting")
+      return { status: "synced", appended: history.appendedMessageCount };
+    await this.ctx.providers.sessions.stop(threadId).catch((error) => {
+      this.ctx.log.warn("session-import sync could not stop the session", {
+        threadId,
+        detail: describeError(error)
+      });
+    });
+    return { status: "synced", appended: history.appendedMessageCount };
+  }
+};
+
+// src/index.ts
+var index_default = definePlugin({
+  id: "session-import",
+  apiVersion: 2,
+  activate: (ctx) => {
+    ctx.command({
+      name: "scan",
+      description: "Native CLI sessions under a project directory that can be taken over.",
+      scope: "read",
+      payloadSchema: sessionImportListInputSchema,
+      resultSchema: sessionImportListResultSchema,
+      handle: (payload) => listSessions(ctx, payload)
+    });
+    ctx.stream({
+      name: "import",
+      description: "Takes over one native CLI session, reporting each phase as it goes.",
+      scope: "operate",
+      payloadSchema: sessionImportInputSchema,
+      itemSchema: sessionImportProgressEventSchema,
+      handle: async (payload, emit, signal) => {
+        await runImport(ctx, payload, (event) => {
+          if (!signal.aborted) emit(event);
+        });
+      }
+    });
+    const tail = new NativeSessionTail(ctx);
+    ctx.command({
+      name: "sync",
+      description: "Picks up what a terminal wrote to one imported session since the last check.",
+      scope: "operate",
+      payloadSchema: sessionImportSyncInputSchema,
+      resultSchema: sessionImportSyncResultSchema,
+      handle: (payload) => tail.sync(payload.threadId)
+    });
+  }
+});
+export {
+  index_default as default
+};