@ycodium-ai/plugin-conversation 0.2.2938 → 0.2.2944

package/dist/index.js

@@ -1,9 +1,1324 @@
 // src/index.ts
 import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/sessionMap/activate.ts
+import * as NodeCrypto from "node:crypto";
+import {
+  TURN_PROGRESS_TRIGGER_KIND
+} from "@ycodium-ai/plugin-api";
+
+// src/sessionMap/actions.ts
+function createCommands(input) {
+  return [
+    {
+      type: "thread.create",
+      commandId: input.commandId,
+      threadId: input.threadId,
+      projectId: input.projectId,
+      title: input.title,
+      modelSelection: input.modelSelection,
+      runtimeMode: input.runtimeMode,
+      interactionMode: input.interactionMode,
+      branch: null,
+      worktreePath: null,
+      createdAt: input.now
+    },
+    turnCommand({
+      threadId: input.threadId,
+      text: input.text,
+      now: input.now,
+      messageId: input.messageId,
+      commandId: input.turnCommandId,
+      runtimeMode: input.runtimeMode,
+      interactionMode: input.interactionMode,
+      modelSelection: input.modelSelection
+    })
+  ];
+}
+function turnCommand(input) {
+  return {
+    type: "thread.turn.start",
+    commandId: input.commandId,
+    threadId: input.threadId,
+    message: {
+      messageId: input.messageId,
+      role: "user",
+      text: input.text,
+      attachments: []
+    },
+    runtimeMode: input.runtimeMode,
+    interactionMode: input.interactionMode,
+    createdAt: input.now,
+    ...input.modelSelection == null ? {} : { modelSelection: input.modelSelection }
+  };
+}
+function forkCommand(input) {
+  return {
+    type: "thread.fork",
+    commandId: input.commandId,
+    threadId: input.threadId,
+    sourceThreadId: input.sourceThreadId,
+    sourceMessageId: input.sourceMessageId,
+    createdAt: input.now
+  };
+}
+function titleFromText(text2) {
+  const line = text2.trim().split("\n")[0] ?? "";
+  const title = line.trim().slice(0, 80);
+  return title.length > 0 ? title : "New session";
+}
+function forkPointOf(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const point = value;
+  if (typeof point.sourceThreadId !== "string" || typeof point.sourceMessageId !== "string") {
+    return null;
+  }
+  return { sourceThreadId: point.sourceThreadId, sourceMessageId: point.sourceMessageId };
+}
+
+// src/ui/sessionMap/limits.ts
+var MAX_CARD_TEXT = 8e3;
+var MAX_PREVIEW_TEXT = 480;
+var MAX_DETAIL_MESSAGES = 40;
+var MAX_DETAIL_TEXT = 32e3;
+var MAX_TURNS_PER_THREAD = 48;
+var MAX_TOOLS_PER_TURN = 12;
+var MAX_TOOL_LABEL = 180;
+var THREAD_PAGE_SIZE = 200;
+var PROJECTION_NAME = "card";
+
+// src/ui/sessionMap/text.ts
+function clipText(value, limit = MAX_CARD_TEXT) {
+  const text2 = value.replaceAll("\0", "");
+  if (text2.length <= limit) return { text: text2, truncated: false };
+  return { text: text2.slice(0, limit), truncated: true };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+
+// src/ui/sessionMap/canvas.ts
+var EMPTY_CANVAS = {
+  version: 1,
+  revision: 0,
+  autoProjection: true,
+  workspaceTitle: "",
+  showArchived: false,
+  hiddenThreadIds: [],
+  seenThreadIds: [],
+  anchors: {},
+  positions: []
+};
+var MAX_TITLE = 120;
+var MAX_POSITIONS = 4e3;
+var MAX_IDS = 2e4;
+function parseCanvas(value) {
+  if (!isRecord(value)) return EMPTY_CANVAS;
+  return {
+    version: 1,
+    revision: readRevision(value.revision),
+    autoProjection: value.autoProjection !== false,
+    workspaceTitle: readString(value.workspaceTitle).trim().slice(0, MAX_TITLE),
+    showArchived: value.showArchived === true,
+    hiddenThreadIds: readIds(value.hiddenThreadIds),
+    seenThreadIds: readIds(value.seenThreadIds),
+    anchors: readAnchors(value.anchors),
+    positions: readPositions(value.positions)
+  };
+}
+function canvasJson(state) {
+  return `${JSON.stringify(state)}
+`;
+}
+function admitThreads(state, threadIds) {
+  const seen = new Set(state.seenThreadIds);
+  const hidden = new Set(state.hiddenThreadIds);
+  let changed = false;
+  for (const threadId of threadIds) {
+    if (threadId.length === 0 || seen.has(threadId)) continue;
+    seen.add(threadId);
+    changed = true;
+    if (!state.autoProjection) hidden.add(threadId);
+  }
+  if (!changed) return state;
+  return {
+    ...state,
+    seenThreadIds: [...seen].slice(-MAX_IDS),
+    hiddenThreadIds: [...hidden].slice(-MAX_IDS)
+  };
+}
+function hideThread(state, threadId) {
+  if (state.hiddenThreadIds.includes(threadId)) return state;
+  return { ...state, hiddenThreadIds: [...state.hiddenThreadIds, threadId].slice(-MAX_IDS) };
+}
+function restoreThread(state, threadId) {
+  if (!state.hiddenThreadIds.includes(threadId)) return state;
+  return { ...state, hiddenThreadIds: state.hiddenThreadIds.filter((id) => id !== threadId) };
+}
+function clearPositions(state) {
+  if (state.positions.length === 0) return state;
+  return { ...state, positions: [] };
+}
+function rememberPosition(state, position) {
+  const next = state.positions.filter((item) => item.cardId !== position.cardId);
+  next.push({
+    cardId: position.cardId,
+    x: finite(position.x),
+    y: finite(position.y)
+  });
+  return { ...state, positions: next.slice(-MAX_POSITIONS) };
+}
+function patchCanvas(state, patch) {
+  const anchors = { ...state.anchors };
+  if (patch.anchor === null) {
+  } else if (patch.anchor !== void 0) {
+    if (patch.anchor.cardId.length === 0) delete anchors[patch.anchor.threadId];
+    else anchors[patch.anchor.threadId] = patch.anchor.cardId.slice(0, 200);
+  }
+  return {
+    ...state,
+    autoProjection: patch.autoProjection ?? state.autoProjection,
+    workspaceTitle: patch.workspaceTitle === void 0 ? state.workspaceTitle : patch.workspaceTitle.trim().slice(0, MAX_TITLE),
+    showArchived: patch.showArchived ?? state.showArchived,
+    anchors
+  };
+}
+function readRevision(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value < 1e9 ? value : 0;
+}
+function readIds(value) {
+  if (!Array.isArray(value)) return [];
+  const ids = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim().length === 0 || ids.includes(item)) continue;
+    ids.push(item);
+    if (ids.length === MAX_IDS) break;
+  }
+  return ids;
+}
+function readAnchors(value) {
+  if (!isRecord(value)) return {};
+  const anchors = {};
+  for (const [threadId, cardId] of Object.entries(value)) {
+    if (threadId.trim().length === 0 || typeof cardId !== "string" || cardId.length === 0) continue;
+    anchors[threadId] = cardId.slice(0, 200);
+  }
+  return anchors;
+}
+function readPositions(value) {
+  if (!Array.isArray(value)) return [];
+  const positions = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.cardId !== "string") continue;
+    positions.push({ cardId: item.cardId, x: finite(item.x), y: finite(item.y) });
+    if (positions.length === MAX_POSITIONS) break;
+  }
+  return positions;
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/sessionMap/canvasFile.ts
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath from "node:path";
+var MAX_ATTEMPTS = 8;
+var STALE_LOCK_MS = 5e3;
+function openCanvasFile(dataDir) {
+  const file = NodePath.join(dataDir, "workspaces.json");
+  const lock = `${file}.lock`;
+  let chain = Promise.resolve();
+  const read = async () => {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+      const stamp = await readStamp(file);
+      if (stamp !== null) return stamp.state;
+    }
+    return EMPTY_CANVAS;
+  };
+  const update = (change) => withLock(lock, async () => {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+      const before = await readStamp(file);
+      if (before === null) continue;
+      const next = {
+        ...change(before.state),
+        version: 1,
+        revision: before.revision + 1
+      };
+      const raced = await readStamp(file);
+      if (raced === null || raced.mtimeMs !== before.mtimeMs || raced.revision !== before.revision) {
+        continue;
+      }
+      await NodeFSP.mkdir(dataDir, { recursive: true });
+      const temporary = `${file}.${process.pid}.${attempt}.tmp`;
+      await NodeFSP.writeFile(temporary, canvasJson(next), "utf8");
+      const again = await readStamp(file);
+      if (again === null || again.mtimeMs !== before.mtimeMs || again.revision !== before.revision) {
+        await NodeFSP.rm(temporary, { force: true });
+        continue;
+      }
+      await NodeFSP.rename(temporary, file);
+      return next;
+    }
+    throw new Error("canvas file changed while it was being saved");
+  });
+  return {
+    read,
+    update(change) {
+      const run = chain.then(() => update(change));
+      chain = run.then(
+        () => void 0,
+        () => void 0
+      );
+      return run;
+    }
+  };
+}
+async function readStamp(file) {
+  let stat2;
+  try {
+    stat2 = await NodeFSP.stat(file);
+  } catch (error) {
+    if (isCode(error, "ENOENT")) return { mtimeMs: 0, revision: 0, state: EMPTY_CANVAS };
+    throw error;
+  }
+  const text2 = await NodeFSP.readFile(file, "utf8");
+  let again;
+  try {
+    again = await NodeFSP.stat(file);
+  } catch (error) {
+    if (isCode(error, "ENOENT")) return null;
+    throw error;
+  }
+  if (again.mtimeMs !== stat2.mtimeMs || again.size !== stat2.size) return null;
+  let state = EMPTY_CANVAS;
+  try {
+    state = parseCanvas(JSON.parse(text2));
+  } catch {
+    state = EMPTY_CANVAS;
+  }
+  return { mtimeMs: again.mtimeMs, revision: state.revision, state };
+}
+async function withLock(lock, body) {
+  await NodeFSP.mkdir(NodePath.dirname(lock), { recursive: true });
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const handle = await NodeFSP.open(lock, "wx");
+      try {
+        return await body();
+      } finally {
+        await handle.close();
+        await NodeFSP.rm(lock, { force: true });
+      }
+    } catch (error) {
+      if (!isCode(error, "EEXIST")) throw error;
+      await stealStaleLock(lock);
+      await delay(20 * (attempt + 1));
+    }
+  }
+  throw new Error("canvas file is locked");
+}
+async function stealStaleLock(lock) {
+  try {
+    const stat2 = await NodeFSP.stat(lock);
+    if (Date.now() - stat2.mtimeMs > STALE_LOCK_MS) await NodeFSP.rm(lock, { force: true });
+  } catch (error) {
+    if (!isCode(error, "ENOENT")) throw error;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// src/ui/sessionMap/graph.ts
+function resolveForkAnchor(messages, anchorId) {
+  const index = messages.findIndex((message) => message.messageId === anchorId);
+  if (index < 0) return null;
+  if (messages[index]?.role === "user") return { messageId: anchorId, walkedBack: false };
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const message = messages[cursor];
+    if (message?.role === "user") return { messageId: message.messageId, walkedBack: true };
+  }
+  return null;
+}
+function inheritedMessageCount(parent, sourceMessageId) {
+  if (parent === null || sourceMessageId === null) return 0;
+  const index = parent.findIndex((message) => message.messageId === sourceMessageId);
+  return index < 0 ? 0 : index;
+}
+function buildTurns(messages, tools, running, textLimit) {
+  const own = messages;
+  const turns = [];
+  for (let index = 0; index < own.length; index += 1) {
+    const message = own[index];
+    if (message === void 0 || message.role !== "user") continue;
+    const replies = [];
+    const errors = [];
+    for (let cursor = index + 1; cursor < own.length; cursor += 1) {
+      const next = own[cursor];
+      if (next === void 0 || next.role === "user") break;
+      if (next.role === "assistant") replies.push(next);
+      else if (next.text.trim().length > 0) errors.push(next);
+    }
+    const question = clipText(message.text, textLimit);
+    const answerSource = replies.at(-1);
+    const answer = clipText(answerSource?.text ?? "", textLimit);
+    const errorSource = errors.at(-1);
+    turns.push({
+      messageId: message.messageId,
+      question: question.text,
+      questionTruncated: question.truncated,
+      answer: answer.text,
+      answerTruncated: answer.truncated,
+      error: errorSource === void 0 ? null : clipText(errorSource.text, textLimit).text,
+      tools: [],
+      running: false
+    });
+  }
+  const kept = turns.slice(-MAX_TURNS_PER_THREAD);
+  const latest = kept.at(-1);
+  if (latest === void 0) return turns;
+  const withTools = {
+    ...latest,
+    tools: tools.slice(-MAX_TOOLS_PER_TURN).map((tool) => ({
+      callId: tool.callId,
+      title: tool.title.slice(0, MAX_TOOL_LABEL),
+      status: tool.status
+    })),
+    running
+  };
+  return [...kept.slice(0, -1), withTools];
+}
+
+// src/sessionMap/mapLive.ts
+import {
+  readTurnProgress
+} from "@ycodium-ai/plugin-api";
+
+// src/ui/sessionMap/liveAnswer.ts
+function liveSegmentForTurn(messages, segment) {
+  if (segment === void 0) return null;
+  let lastUser = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") {
+      lastUser = index;
+      break;
+    }
+  }
+  if (lastUser < 0) return null;
+  for (let index = lastUser + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.messageId === segment.messageId && message.role === "assistant") return segment;
+  }
+  return null;
+}
+function applyLiveAnswer(thread, messages, segment, answer) {
+  const live = liveSegmentForTurn(messages, segment);
+  if (live === null || answer === null || thread.turns.length === 0) return thread;
+  const turns = thread.turns.slice();
+  const last = turns.at(-1);
+  if (last === void 0) return thread;
+  turns[turns.length - 1] = {
+    ...last,
+    answer: answer.text,
+    answerTruncated: answer.truncated,
+    running: live.streaming
+  };
+  return { ...thread, running: thread.running || live.streaming, turns };
+}
+
+// src/ui/sessionMap/toolStrip.ts
+function record(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+}
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function toolTitleFromActivity(payload) {
+  const root = record(payload);
+  if (root === null) return "";
+  const data = record(root.data) ?? root;
+  const toolLabel = record(data.toolLabel) ?? record(root.toolLabel);
+  if (toolLabel !== null) {
+    if (toolLabel.descriptive === false) return "";
+    const detail = text(toolLabel.detail);
+    if (detail.length > 0) return detail;
+    return text(toolLabel.title);
+  }
+  return text(root.title);
+}
+function titlesByCallId(activities) {
+  const titles = /* @__PURE__ */ new Map();
+  for (const activity of activities) {
+    const root = record(activity.payload);
+    if (root === null) continue;
+    const data = record(root.data) ?? root;
+    const callId = text(data.toolCallId) || text(root.toolCallId);
+    if (callId.length === 0) continue;
+    const title = toolTitleFromActivity(activity.payload);
+    if (title.length > 0) titles.set(callId, title);
+  }
+  return titles;
+}
+
+// src/sessionMap/refreshGate.ts
+var CARD_REFRESH_MS = 800;
+var CardRefreshGate = class {
+  lastAt = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Set();
+  deferred = /* @__PURE__ */ new Set();
+  note(input) {
+    if (input.threadId.length === 0) return { run: [], dueAt: null };
+    if (input.subscribers === 0 && !input.immediate) {
+      this.deferred.add(input.threadId);
+      return { run: [], dueAt: null };
+    }
+    this.deferred.delete(input.threadId);
+    this.waiting.add(input.threadId);
+    if (input.immediate) return this.flush(input.now);
+    const last = this.lastAt.get(input.threadId);
+    if (last === void 0 || input.now - last >= CARD_REFRESH_MS) return this.flush(input.now);
+    return { run: [], dueAt: last + CARD_REFRESH_MS };
+  }
+  flush(now) {
+    const run = [...this.waiting];
+    this.waiting.clear();
+    for (const id of run) this.lastAt.set(id, now);
+    return { run, dueAt: null };
+  }
+  takeDeferred() {
+    const ids = [...this.deferred];
+    this.deferred.clear();
+    return ids;
+  }
+};
+var TranscriptCache = class {
+  byThread = /* @__PURE__ */ new Map();
+  has(threadId) {
+    return this.byThread.has(threadId);
+  }
+  get(threadId) {
+    return this.byThread.get(threadId) ?? null;
+  }
+  seed(threadId, messages) {
+    this.byThread.set(
+      threadId,
+      messages.map((message) => ({ ...message }))
+    );
+  }
+  upsert(threadId, message) {
+    const list = this.byThread.get(threadId);
+    if (list === void 0) return false;
+    const index = list.findIndex((item) => item.messageId === message.messageId);
+    if (index < 0) list.push({ ...message });
+    else list[index] = { ...message };
+    return true;
+  }
+  invalidate(threadId) {
+    this.byThread.delete(threadId);
+  }
+};
+
+// src/sessionMap/runtime.ts
+async function listSessionShells(ctx) {
+  const shells = [];
+  let cursor = null;
+  for (; ; ) {
+    const page = await ctx.projections.listThreads({
+      limit: THREAD_PAGE_SIZE,
+      cursor,
+      includeArchived: true
+    });
+    shells.push(...page.threads);
+    if (page.nextCursor === null || page.nextCursor === cursor) return shells;
+    cursor = page.nextCursor;
+  }
+}
+function threadFromShell(shell) {
+  return projectThread({
+    execution: {
+      threadId: shell.threadId,
+      projectId: shell.projectId,
+      title: shell.title,
+      updatedAt: shell.updatedAt,
+      archived: shell.archivedAt !== null,
+      running: runningOf(shell.sessionStatus),
+      sessionStatus: shell.sessionStatus,
+      forkedFrom: forkPointOf(shell.forkedFrom),
+      runtimeMode: shell.runtimeMode,
+      interactionMode: shell.interactionMode,
+      modelSelection: shell.modelSelection
+    },
+    messages: [],
+    parentMessages: null,
+    tools: [],
+    textLimit: MAX_PREVIEW_TEXT
+  });
+}
+function projectThread(input) {
+  const inherited = inheritedMessageCount(
+    input.parentMessages,
+    input.execution.forkedFrom?.sourceMessageId ?? null
+  );
+  const own = input.messages.slice(inherited);
+  return {
+    threadId: input.execution.threadId,
+    projectId: input.execution.projectId,
+    title: input.execution.title,
+    updatedAt: input.execution.updatedAt,
+    archived: input.execution.archived,
+    running: input.execution.running,
+    forkedFrom: input.execution.forkedFrom,
+    inheritedMessageCount: inherited,
+    cutWalkedBack: false,
+    turns: buildTurns(own, input.tools, input.execution.running, input.textLimit)
+  };
+}
+function boardSnapshot(input) {
+  const byId = new Map(input.threads.map((thread) => [thread.threadId, thread]));
+  const hidden = new Set(input.canvas.hiddenThreadIds);
+  const hiddenThreads = input.canvas.hiddenThreadIds.flatMap((threadId) => {
+    const thread = byId.get(threadId);
+    return thread === void 0 ? [] : [{ threadId, title: thread.title }];
+  });
+  const visible = input.threads.filter((thread) => {
+    if (hidden.has(thread.threadId)) return false;
+    if (!input.canvas.showArchived && thread.archived) return false;
+    return true;
+  });
+  const ranked = [...visible].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  return {
+    projects: input.projects,
+    threads: ranked.map(previewThread),
+    hiddenThreadIds: input.canvas.hiddenThreadIds,
+    hiddenThreads,
+    anchors: input.canvas.anchors,
+    workspaceTitle: input.canvas.workspaceTitle,
+    autoProjection: input.canvas.autoProjection,
+    showArchived: input.canvas.showArchived,
+    positions: input.canvas.positions
+  };
+}
+function previewThread(thread) {
+  return {
+    ...thread,
+    turns: thread.turns.map((turn) => {
+      const question = clipText(turn.question, MAX_PREVIEW_TEXT);
+      const answer = clipText(turn.answer, MAX_PREVIEW_TEXT);
+      return {
+        ...turn,
+        question: question.text,
+        questionTruncated: turn.questionTruncated || question.truncated,
+        answer: answer.text,
+        answerTruncated: turn.answerTruncated || answer.truncated
+      };
+    })
+  };
+}
+function runningOf(status) {
+  return status === "starting" || status === "running";
+}
+function executionRow(execution) {
+  const running = runningOf(execution.session?.status ?? null) || execution.latestTurn?.state === "running";
+  return {
+    threadId: execution.threadId,
+    projectId: execution.projectId,
+    title: execution.title,
+    updatedAt: execution.updatedAt,
+    archived: execution.archivedAt !== null,
+    running,
+    sessionStatus: execution.session?.status ?? null,
+    forkedFrom: forkPointOf(execution.forkedFrom),
+    runtimeMode: execution.runtimeMode,
+    interactionMode: execution.interactionMode,
+    modelSelection: execution.modelSelection
+  };
+}
+async function executionOf(ctx, threadId) {
+  const execution = await ctx.projections.getThreadExecution(threadId);
+  if (execution === null) return null;
+  return executionRow(execution);
+}
+
+// src/sessionMap/mapLive.ts
+function createSessionMapHub(ctx, canvas, options = {}) {
+  return new SessionMapHub(ctx, canvas, options.timers !== false);
+}
+var SessionMapHub = class {
+  gate = new CardRefreshGate();
+  transcripts = new TranscriptCache();
+  cards = /* @__PURE__ */ new Map();
+  tools = /* @__PURE__ */ new Map();
+  toolTitles = /* @__PURE__ */ new Map();
+  executions = /* @__PURE__ */ new Map();
+  live = /* @__PURE__ */ new Map();
+  pendingMessage = /* @__PURE__ */ new Map();
+  queued = /* @__PURE__ */ new Set();
+  removed = /* @__PURE__ */ new Set();
+  emitters = /* @__PURE__ */ new Set();
+  shells = null;
+  projects = null;
+  directoryFlight = null;
+  tail = Promise.resolve();
+  wantFull = false;
+  dueTimer = null;
+  ctx;
+  canvas;
+  timers;
+  constructor(ctx, canvas, timers) {
+    this.ctx = ctx;
+    this.canvas = canvas;
+    this.timers = timers;
+  }
+  subscribe(emit) {
+    this.emitters.add(emit);
+    const deferred = this.gate.takeDeferred();
+    this.enqueue(deferred, true);
+    return () => {
+      this.emitters.delete(emit);
+    };
+  }
+  onMessage(threadId, event, now = Date.now()) {
+    if (threadId.length === 0) return;
+    const messageId = messageIdOf(event);
+    if (messageId !== null) {
+      const pending = this.pendingMessage.get(threadId) ?? /* @__PURE__ */ new Set();
+      pending.add(messageId);
+      this.pendingMessage.set(threadId, pending);
+    }
+    this.note(threadId, now, false);
+  }
+  onProgress(event, now = Date.now()) {
+    const progress = readTurnProgress(event);
+    const threadId = event.threadId;
+    if (progress === null || threadId === null || threadId.length === 0) return;
+    const cached = this.executions.get(threadId);
+    if (cached !== void 0 && cached.running !== (progress.phase !== "ended")) {
+      this.executions.set(threadId, { ...cached, running: progress.phase !== "ended" });
+    }
+    const known = this.toolTitles.get(threadId);
+    this.tools.set(
+      threadId,
+      progress.tools.map((tool) => ({
+        callId: tool.toolCallId,
+        title: known?.get(tool.toolCallId) ?? "",
+        status: tool.status
+      }))
+    );
+    if (progress.phase === "ended") this.live.delete(threadId);
+    else {
+      const segment = progress.segments.at(-1);
+      if (segment !== void 0) this.live.set(threadId, segment);
+    }
+    this.note(threadId, now, false);
+  }
+  onDirectory(type, threadId) {
+    if (type === "thread.deleted") {
+      this.drop(threadId);
+      this.removed.add(threadId);
+      if (this.shells !== null) {
+        this.shells = this.shells.filter((shell) => shell.threadId !== threadId);
+      }
+      if (this.emitters.size > 0) this.enqueue([], false);
+      return;
+    }
+    this.shells = null;
+    this.projects = null;
+    if (threadId.length > 0) {
+      this.transcripts.invalidate(threadId);
+      this.executions.delete(threadId);
+    }
+    if (threadId.length > 0) this.note(threadId, Date.now(), false);
+    else if (this.emitters.size > 0) this.enqueue([], true);
+  }
+  /** 用户命令：立刻读这一条，不管节流窗口。 */
+  touch(threadId, now = Date.now()) {
+    this.executions.delete(threadId);
+    this.note(threadId, now, true);
+  }
+  canvasChanged() {
+    this.enqueue([], true);
+  }
+  flushDue(now) {
+    this.clearTimer();
+    const step = this.gate.flush(now);
+    if (step.run.length > 0) this.enqueue(step.run, false);
+  }
+  settled() {
+    return this.tail;
+  }
+  stop() {
+    this.clearTimer();
+  }
+  note(threadId, now, immediate) {
+    const step = this.gate.note({
+      threadId,
+      now,
+      subscribers: this.emitters.size,
+      immediate
+    });
+    if (step.run.length > 0) this.enqueue(step.run, false);
+    if (step.dueAt !== null && this.timers) this.arm(step.dueAt);
+  }
+  arm(dueAt) {
+    if (this.dueTimer !== null) return;
+    const wait = Math.max(0, dueAt - Date.now());
+    this.dueTimer = setTimeout(() => {
+      this.dueTimer = null;
+      this.flushDue(Date.now());
+    }, wait);
+  }
+  clearTimer() {
+    if (this.dueTimer === null) return;
+    clearTimeout(this.dueTimer);
+    this.dueTimer = null;
+  }
+  enqueue(ids, full) {
+    for (const id of ids) {
+      if (id.length > 0) this.queued.add(id);
+    }
+    if (full) this.wantFull = true;
+    this.tail = this.tail.then(() => this.drain()).catch((error) => {
+      this.ctx.log.warn("session map projection skipped a thread", {
+        detail: error instanceof Error ? error.message : "unknown"
+      });
+    });
+  }
+  async drain() {
+    const ids = [...this.queued];
+    const full = this.wantFull;
+    this.queued.clear();
+    this.wantFull = false;
+    for (const id of ids) await this.projectStored(id);
+    if (this.emitters.size === 0) return;
+    if (full || this.shells === null) await this.emitFull();
+    else if (ids.length > 0 || this.removed.size > 0) this.emitPatch(ids);
+  }
+  async projectStored(threadId) {
+    const projected = await this.projectOne(threadId);
+    if (projected === null) {
+      this.drop(threadId);
+      this.removed.add(threadId);
+      return;
+    }
+    this.cards.set(threadId, projected);
+    await this.ctx.sessionProjections.set({
+      name: PROJECTION_NAME,
+      threadId,
+      value: jsonValue(projected)
+    });
+  }
+  async projectOne(threadId) {
+    const execution = await this.executionFor(threadId);
+    if (execution === null) return null;
+    const messages = await this.loadMessages(threadId);
+    let parentMessages = null;
+    if (execution.forkedFrom !== null) {
+      parentMessages = await this.loadParent(execution.forkedFrom.sourceThreadId);
+    }
+    const segment = this.live.get(threadId);
+    const live = segment === void 0 ? void 0 : segment;
+    let answer = null;
+    if (live !== void 0) {
+      const message = await this.ctx.projections.getThreadMessage(live.messageId);
+      if (message !== null) {
+        this.transcripts.upsert(threadId, messageOf(message));
+        const clipped = clipText(message.text, MAX_CARD_TEXT);
+        answer = { text: clipped.text, truncated: clipped.truncated };
+      }
+    }
+    const projected = projectThread({
+      execution,
+      messages: this.transcripts.get(threadId) ?? messages,
+      parentMessages,
+      tools: this.tools.get(threadId) ?? [],
+      textLimit: MAX_CARD_TEXT
+    });
+    return applyLiveAnswer(projected, this.transcripts.get(threadId) ?? messages, live, answer);
+  }
+  async executionFor(threadId) {
+    const cached = this.executions.get(threadId);
+    if (cached !== void 0) return cached;
+    const row = await executionOf(this.ctx, threadId);
+    if (row !== null) this.executions.set(threadId, row);
+    return row;
+  }
+  async seedTranscript(threadId) {
+    if (this.transcripts.has(threadId)) return;
+    const thread = await this.ctx.projections.getThread(threadId, { includeActivities: true });
+    this.transcripts.seed(threadId, transcriptOf(thread));
+    this.rememberTitles(threadId, titlesByCallId(thread?.activities ?? []));
+  }
+  rememberTitles(threadId, titles) {
+    if (titles.size === 0) return;
+    const known = this.toolTitles.get(threadId) ?? /* @__PURE__ */ new Map();
+    for (const [id, title] of titles) known.set(id, title);
+    this.toolTitles.set(threadId, known);
+    const tools = this.tools.get(threadId);
+    if (tools === void 0) return;
+    this.tools.set(
+      threadId,
+      tools.map((tool) => ({ ...tool, title: known.get(tool.callId) ?? tool.title }))
+    );
+  }
+  async loadMessages(threadId) {
+    const pending = this.pendingMessage.get(threadId);
+    this.pendingMessage.delete(threadId);
+    await this.seedTranscript(threadId);
+    if (pending !== void 0) {
+      for (const messageId of pending) {
+        const message = await this.ctx.projections.getThreadMessage(messageId);
+        if (message !== null) this.transcripts.upsert(threadId, messageOf(message));
+      }
+    }
+    return this.transcripts.get(threadId) ?? [];
+  }
+  async loadParent(threadId) {
+    if (!this.transcripts.has(threadId)) {
+      const thread = await this.ctx.projections.getThread(threadId);
+      this.transcripts.seed(threadId, transcriptOf(thread));
+    }
+    return this.transcripts.get(threadId) ?? [];
+  }
+  async emitFull() {
+    await this.ensureDirectory();
+    const shells = this.shells ?? [];
+    const ids = shells.map((shell) => shell.threadId);
+    const current = await this.canvas.read();
+    const state = admitThreads(current, ids) === current ? current : await this.canvas.update((latest) => admitThreads(latest, ids));
+    const known = new Set(ids);
+    for (const threadId of this.cards.keys()) {
+      if (!known.has(threadId)) this.drop(threadId);
+    }
+    const threads = shells.map((shell) => this.cards.get(shell.threadId) ?? threadFromShell(shell));
+    const frame = boardSnapshot({
+      projects: this.projects ?? [],
+      threads,
+      canvas: state
+    });
+    this.removed.clear();
+    for (const emit of this.emitters) emit(frame);
+  }
+  emitPatch(ids) {
+    const removedThreadIds = [...this.removed];
+    this.removed.clear();
+    const threads = ids.flatMap((id) => {
+      const card = this.cards.get(id);
+      return card === void 0 ? [] : [card];
+    });
+    const frame = { patch: true, threads, removedThreadIds };
+    for (const emit of this.emitters) emit(frame);
+  }
+  ensureDirectory() {
+    if (this.shells !== null && this.projects !== null) return Promise.resolve();
+    if (this.directoryFlight !== null) return this.directoryFlight;
+    this.directoryFlight = this.loadDirectory().finally(() => {
+      this.directoryFlight = null;
+    });
+    return this.directoryFlight;
+  }
+  async loadDirectory() {
+    const shells = await listSessionShells(this.ctx);
+    const projects = (await this.ctx.projections.listProjects()).map((project) => ({
+      projectId: project.projectId,
+      title: project.title,
+      workspaceRoot: project.workspaceRoot,
+      archived: project.archivedAt != null
+    }));
+    this.shells = shells;
+    this.projects = projects;
+  }
+  drop(threadId) {
+    this.cards.delete(threadId);
+    this.transcripts.invalidate(threadId);
+    this.tools.delete(threadId);
+    this.toolTitles.delete(threadId);
+    this.executions.delete(threadId);
+    this.live.delete(threadId);
+    this.pendingMessage.delete(threadId);
+  }
+};
+function messageIdOf(event) {
+  if (!isRecord(event.payload)) return null;
+  const messageId = readString(event.payload.messageId);
+  return messageId.length > 0 ? messageId : null;
+}
+function transcriptOf(thread) {
+  if (thread === null) return [];
+  return thread.messages.map(messageOf);
+}
+function messageOf(message) {
+  return { messageId: message.messageId, role: message.role, text: message.text };
+}
+function jsonValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/sessionMap/activate.ts
+function activateSessionMap(ctx) {
+  const canvas = openCanvasFile(ctx.paths.dataDir);
+  const hub = createSessionMapHub(ctx, canvas);
+  ctx.sessionProjections.register({ name: PROJECTION_NAME });
+  ctx.reactor({
+    name: "project-cards",
+    events: [
+      "thread.created",
+      "thread.deleted",
+      "thread.message-sent",
+      "thread.archived",
+      "thread.unarchived"
+    ],
+    handle: (event) => {
+      const threadId = event.aggregateKind === "thread" ? event.aggregateId : "";
+      if (event.type === "thread.message-sent") {
+        hub.onMessage(threadId, event);
+        return;
+      }
+      hub.onDirectory(event.type, threadId);
+    }
+  });
+  ctx.events.on(TURN_PROGRESS_TRIGGER_KIND, (event) => {
+    hub.onProgress(event);
+  });
+  ctx.command({
+    name: "focus",
+    description: "Load one session onto the map.",
+    scope: "read",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => {
+      hub.touch(readString(payload["threadId"]));
+      return { ok: true };
+    }
+  });
+  ctx.command({
+    name: "snapshot",
+    description: "Read the session map.",
+    scope: "read",
+    payloadSchema: { type: "object", properties: {} },
+    handle: async () => {
+      const frames = [];
+      const stop = hub.subscribe((frame) => {
+        frames.push(frame);
+      });
+      await hub.settled();
+      stop();
+      return frames.at(-1) ?? { projects: [], threads: [] };
+    }
+  });
+  ctx.stream({
+    name: "live",
+    description: "Follow the session map.",
+    scope: "read",
+    buffer: { latest: 1 },
+    payloadSchema: { type: "object", properties: {} },
+    handle: async (_payload, emit, signal) => {
+      const stop = hub.subscribe((frame) => {
+        emit(frame);
+      });
+      try {
+        await abort(signal);
+      } finally {
+        stop();
+      }
+    }
+  });
+  ctx.command({
+    name: "detail",
+    description: "Read one session for the detail pane.",
+    scope: "read",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => detailOf(ctx, readString(payload["threadId"]))
+  });
+  ctx.command({
+    name: "preferences",
+    description: "Read or update canvas preferences.",
+    scope: "operate",
+    payloadSchema: { type: "object", properties: { patch: {} } },
+    handle: async (payload) => {
+      const patch = payload["patch"];
+      const next = patch === void 0 ? await canvas.read() : await canvas.update((state) => patchCanvas(state, preferencePatch(patch)));
+      hub.canvasChanged();
+      return next;
+    }
+  });
+  ctx.command({
+    name: "move",
+    description: "Save a card position.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        cardId: { type: "string" },
+        x: { type: "number" },
+        y: { type: "number" }
+      },
+      required: ["cardId", "x", "y"]
+    },
+    handle: async (payload) => {
+      const next = await canvas.update(
+        (state) => rememberPosition(state, {
+          cardId: readString(payload["cardId"]),
+          x: typeof payload["x"] === "number" ? payload["x"] : 0,
+          y: typeof payload["y"] === "number" ? payload["y"] : 0
+        })
+      );
+      hub.canvasChanged();
+      return { positions: next.positions };
+    }
+  });
+  ctx.command({
+    name: "tidy",
+    description: "Drop saved card positions so the map uses the fork layout.",
+    scope: "operate",
+    payloadSchema: { type: "object", properties: {} },
+    handle: async () => {
+      await canvas.update(clearPositions);
+      hub.canvasChanged();
+      return { ok: true };
+    }
+  });
+  ctx.command({
+    name: "hide",
+    description: "Hide a session card without deleting the session.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => {
+      const threadId = readString(payload["threadId"]);
+      await canvas.update((state) => hideThread(state, threadId));
+      hub.canvasChanged();
+      return { ok: true };
+    }
+  });
+  ctx.command({
+    name: "restore",
+    description: "Show a hidden session card again.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => {
+      await canvas.update((state) => restoreThread(state, readString(payload["threadId"])));
+      hub.canvasChanged();
+      return { ok: true };
+    }
+  });
+  ctx.command({
+    name: "create",
+    description: "Open a session in a project and send the first message.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string" },
+        text: { type: "string" }
+      },
+      required: ["projectId", "text"]
+    },
+    handle: async (payload) => createSession(
+      ctx,
+      readString(payload["projectId"]),
+      readString(payload["text"]),
+      (id) => hub.touch(id)
+    )
+  });
+  ctx.command({
+    name: "send",
+    description: "Send a follow-up into an existing session.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        threadId: { type: "string" },
+        text: { type: "string" }
+      },
+      required: ["threadId", "text"]
+    },
+    handle: async (payload) => sendFollowUp(
+      ctx,
+      readString(payload["threadId"]),
+      readString(payload["text"]),
+      (id) => hub.touch(id)
+    )
+  });
+  ctx.command({
+    name: "fork",
+    description: "Fork at a user message, then send the draft.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        threadId: { type: "string" },
+        messageId: { type: "string" },
+        text: { type: "string" }
+      },
+      required: ["threadId", "messageId", "text"]
+    },
+    handle: async (payload) => forkSession(
+      ctx,
+      readString(payload["threadId"]),
+      readString(payload["messageId"]),
+      readString(payload["text"]),
+      (id) => hub.touch(id)
+    )
+  });
+}
+function transcriptOf2(thread) {
+  if (thread === null) return [];
+  return thread.messages.map(messageOf2);
+}
+function messageOf2(message) {
+  return { messageId: message.messageId, role: message.role, text: message.text };
+}
+async function detailOf(ctx, threadId) {
+  const thread = await ctx.projections.getThread(threadId);
+  if (thread === null) return { found: false, messages: [] };
+  const tail = thread.messages.slice(-MAX_DETAIL_MESSAGES);
+  return {
+    found: true,
+    title: thread.title,
+    omitted: Math.max(0, thread.messages.length - tail.length),
+    messages: tail.map((message) => {
+      const clipped = clipText(message.text, MAX_DETAIL_TEXT);
+      return {
+        messageId: message.messageId,
+        role: message.role,
+        text: clipped.text,
+        truncated: clipped.truncated
+      };
+    })
+  };
+}
+async function createSession(ctx, projectId, text2, refresh) {
+  const trimmed = text2.trim();
+  if (trimmed.length === 0) return { ok: false, code: "empty" };
+  const project = await ctx.projections.getProject(projectId);
+  if (project === null) return { ok: false, code: "missing-project" };
+  const selection = await ctx.providers.resolveSelection({ base: project.defaultModelSelection });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const threadId = NodeCrypto.randomUUID();
+  const commands = createCommands({
+    projectId,
+    title: titleFromText(trimmed),
+    text: trimmed,
+    modelSelection: selection.modelSelection,
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    now,
+    threadId,
+    commandId: NodeCrypto.randomUUID(),
+    messageId: NodeCrypto.randomUUID(),
+    turnCommandId: NodeCrypto.randomUUID()
+  });
+  for (const command of commands) await ctx.commands.dispatch(command);
+  refresh(threadId);
+  return { ok: true, threadId, walkedBack: false };
+}
+async function sendFollowUp(ctx, threadId, text2, refresh) {
+  const trimmed = text2.trim();
+  if (trimmed.length === 0) return { ok: false, code: "empty" };
+  const execution = await executionOf(ctx, threadId);
+  if (execution === null) return { ok: false, code: "missing-thread" };
+  await ctx.commands.dispatch(
+    turnCommand({
+      threadId,
+      text: trimmed,
+      now: (/* @__PURE__ */ new Date()).toISOString(),
+      messageId: NodeCrypto.randomUUID(),
+      commandId: NodeCrypto.randomUUID(),
+      runtimeMode: execution.runtimeMode,
+      interactionMode: execution.interactionMode,
+      modelSelection: execution.modelSelection
+    })
+  );
+  refresh(threadId);
+  return { ok: true, threadId, walkedBack: false };
+}
+async function forkSession(ctx, threadId, messageId, text2, refresh) {
+  const trimmed = text2.trim();
+  if (trimmed.length === 0) return { ok: false, code: "empty" };
+  const thread = await ctx.projections.getThread(threadId);
+  if (thread === null) return { ok: false, code: "missing-thread" };
+  const anchor = resolveForkAnchor(transcriptOf2(thread), messageId);
+  if (anchor === null) return { ok: false, code: "no-user-message" };
+  const execution = await executionOf(ctx, threadId);
+  const childId = NodeCrypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.commands.dispatch(
+    forkCommand({
+      sourceThreadId: threadId,
+      sourceMessageId: anchor.messageId,
+      now,
+      threadId: childId,
+      commandId: NodeCrypto.randomUUID()
+    })
+  );
+  await ctx.commands.dispatch(
+    turnCommand({
+      threadId: childId,
+      text: trimmed,
+      now,
+      messageId: NodeCrypto.randomUUID(),
+      commandId: NodeCrypto.randomUUID(),
+      runtimeMode: execution?.runtimeMode ?? "full-access",
+      interactionMode: execution?.interactionMode ?? "default",
+      modelSelection: execution === null ? null : execution.modelSelection
+    })
+  );
+  refresh(threadId);
+  refresh(childId);
+  return { ok: true, threadId: childId, walkedBack: anchor.walkedBack };
+}
+function preferencePatch(value) {
+  if (!isRecord(value)) return {};
+  const anchor = isRecord(value.anchor) ? {
+    threadId: readString(value.anchor.threadId),
+    cardId: readString(value.anchor.cardId)
+  } : void 0;
+  return {
+    ...typeof value.autoProjection === "boolean" ? { autoProjection: value.autoProjection } : {},
+    ...typeof value.workspaceTitle === "string" ? { workspaceTitle: value.workspaceTitle } : {},
+    ...typeof value.showArchived === "boolean" ? { showArchived: value.showArchived } : {},
+    ...anchor === void 0 ? {} : { anchor }
+  };
+}
+function abort(signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+
+// src/index.ts
 var index_default = definePlugin({
   id: "conversation",
   apiVersion: 3,
-  activate: () => {
+  activate(ctx) {
+    activateSessionMap(ctx);
   }
 });
 export {