@ycodium-ai/plugin-conversation 0.2.3244 → 0.2.3250

package/dist/index.js

@@ -3,51 +3,9 @@ import { definePlugin } from "@ycodium-ai/plugin-api";
 
 // src/sessionMap/activate.ts
 import * as NodeCrypto from "node:crypto";
-import {
-  TURN_PROGRESS_TRIGGER_KIND,
-  projectOrNull
-} from "@ycodium-ai/plugin-api";
+import { TURN_PROGRESS_TRIGGER_KIND } from "@ycodium-ai/plugin-api";
 
 // src/sessionMap/actions.ts
-function createCommands(input) {
-  return [
-    {
-      requestId: input.commandId,
-      threadId: input.threadId,
-      projectId: input.projectId,
-      title: input.title,
-      modelSelection: input.modelSelection,
-      runtimeMode: input.runtimeMode,
-      interactionMode: input.interactionMode,
-      branch: null,
-      worktreePath: null
-    },
-    turnCommand({
-      threadId: input.threadId,
-      text: input.text,
-      messageId: input.messageId,
-      commandId: input.turnCommandId,
-      runtimeMode: input.runtimeMode,
-      interactionMode: input.interactionMode,
-      modelSelection: input.modelSelection
-    })
-  ];
-}
-function turnCommand(input) {
-  return {
-    requestId: input.commandId,
-    threadId: input.threadId,
-    message: {
-      messageId: input.messageId,
-      role: "user",
-      text: input.text,
-      attachments: []
-    },
-    runtimeMode: input.runtimeMode,
-    interactionMode: input.interactionMode,
-    ...input.modelSelection == null ? {} : { modelSelection: input.modelSelection }
-  };
-}
 function forkCommand(input) {
   return {
     requestId: input.commandId,
@@ -56,11 +14,6 @@ function forkCommand(input) {
     sourceMessageId: input.sourceMessageId
   };
 }
-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;
@@ -73,13 +26,12 @@ function forkPointOf(value) {
 // 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";
+var MAX_LOAD_PER_CALL = 60;
 
 // src/ui/sessionMap/text.ts
 function clipText(value, limit = MAX_CARD_TEXT) {
@@ -127,22 +79,8 @@ 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 showArchived(state, show) {
+  return state.showArchived === show ? state : { ...state, showArchived: show };
 }
 function hideThread(state, threadId) {
   if (state.hiddenThreadIds.includes(threadId)) return state;
@@ -152,34 +90,6 @@ 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;
 }
@@ -486,15 +396,28 @@ var TranscriptCache = class {
   }
 };
 
+// src/sessionMap/turnOutline.ts
+function buildTurnOutline(messages, failedIds, waitingId) {
+  const failed = new Set(failedIds);
+  const users = messages.filter((message) => message.role === "user");
+  return users.map((message, index) => ({
+    messageId: message.messageId,
+    ordinal: index + 1,
+    ...failed.has(message.messageId) ? { failed: true } : {},
+    ...message.messageId === waitingId ? { waiting: true } : {}
+  }));
+}
+
 // src/sessionMap/runtime.ts
-async function listSessionShells(ctx) {
+async function listSessionShells(ctx, projectId) {
   const shells = [];
   let cursor = null;
   for (; ; ) {
     const page = await ctx.threads.list({
       limit: THREAD_PAGE_SIZE,
       cursor,
-      archived: "include"
+      archived: "include",
+      ...projectId === void 0 ? {} : { projectId }
     });
     shells.push(...page.items);
     if (page.nextCursor === null || page.nextCursor === cursor) return shells;
@@ -507,19 +430,19 @@ function threadFromShell(shell) {
       threadId: shell.threadId,
       projectId: shell.projectId,
       title: shell.title,
+      createdAt: shell.createdAt,
       updatedAt: shell.updatedAt,
       archived: shell.archivedAt !== null,
       running: runningOf(shell.sessionStatus),
+      status: statusOfShell(shell.status),
       sessionStatus: shell.sessionStatus,
-      forkedFrom: forkPointOf(shell.forkedFrom),
-      runtimeMode: shell.runtimeMode,
-      interactionMode: shell.interactionMode,
-      modelSelection: shell.modelSelection
+      forkedFrom: forkPointOf(shell.forkedFrom)
     },
     messages: [],
     parentMessages: null,
     tools: [],
-    textLimit: MAX_PREVIEW_TEXT
+    textLimit: MAX_PREVIEW_TEXT,
+    loaded: false
   });
 }
 function projectThread(input) {
@@ -532,13 +455,22 @@ function projectThread(input) {
     threadId: input.execution.threadId,
     projectId: input.execution.projectId,
     title: input.execution.title,
+    createdAt: input.execution.createdAt,
     updatedAt: input.execution.updatedAt,
     archived: input.execution.archived,
     running: input.execution.running,
+    status: input.execution.status,
+    turnCount: own.filter((message) => message.role === "user").length,
+    loaded: input.loaded ?? true,
     forkedFrom: input.execution.forkedFrom,
     inheritedMessageCount: inherited,
     cutWalkedBack: false,
-    turns: buildTurns(own, input.tools, input.execution.running, input.textLimit)
+    turns: buildTurns(own, input.tools, input.execution.running, input.textLimit),
+    turnOutline: buildTurnOutline(
+      own,
+      input.execution.failedMessageIds ?? [],
+      input.execution.status === "waiting" ? input.execution.waitingMessageId ?? own.findLast((message) => message.role === "user")?.messageId ?? null : null
+    )
   };
 }
 function boardSnapshot(input) {
@@ -548,6 +480,14 @@ function boardSnapshot(input) {
     const thread = byId.get(threadId);
     return thread === void 0 ? [] : [{ threadId, title: thread.title }];
   });
+  const sources = /* @__PURE__ */ new Map();
+  for (const thread of input.threads) {
+    const fork = thread.forkedFrom;
+    if (fork === null) continue;
+    const ids = sources.get(fork.sourceThreadId) ?? /* @__PURE__ */ new Set();
+    ids.add(fork.sourceMessageId);
+    sources.set(fork.sourceThreadId, ids);
+  }
   const visible = input.threads.filter((thread) => {
     if (hidden.has(thread.threadId)) return false;
     if (!input.canvas.showArchived && thread.archived) return false;
@@ -556,20 +496,25 @@ function boardSnapshot(input) {
   const ranked = [...visible].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
   return {
     projects: input.projects,
-    threads: ranked.map(previewThread),
+    threads: ranked.map(
+      (thread) => previewThread({
+        ...thread,
+        ...thread.turnOutline === void 0 ? {} : {
+          turnOutline: thread.turnOutline.map(
+            (turn) => sources.get(thread.threadId)?.has(turn.messageId) ? { ...turn, forkSource: true } : turn
+          )
+        }
+      })
+    ),
     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
+    showArchived: input.canvas.showArchived
   };
 }
 function previewThread(thread) {
   return {
     ...thread,
-    turns: thread.turns.map((turn) => {
+    turns: thread.turns.slice(-3).map((turn) => {
       const question = clipText(turn.question, MAX_PREVIEW_TEXT);
       const answer = clipText(turn.answer, MAX_PREVIEW_TEXT);
       return {
@@ -582,6 +527,34 @@ function previewThread(thread) {
     })
   };
 }
+function statusOfShell(status) {
+  switch (status) {
+    case "needs-approval":
+    case "needs-input":
+    case "plan-ready":
+      return "waiting";
+    case "running":
+    case "background":
+      return "running";
+    case "failed":
+      return "failed";
+    case "stopped":
+    case "idle":
+      return "done";
+    default: {
+      const unreachable = status;
+      return unreachable;
+    }
+  }
+}
+function statusOfExecution(execution, running) {
+  if (execution.hasPendingApprovals || execution.hasPendingUserInput) return "waiting";
+  if (running) return "running";
+  if (execution.latestTurn?.state === "error" || execution.session?.status === "error") {
+    return "failed";
+  }
+  return "done";
+}
 function runningOf(status) {
   return status === "starting" || status === "running";
 }
@@ -591,14 +564,22 @@ function executionRow(execution) {
     threadId: execution.threadId,
     projectId: execution.projectId,
     title: execution.title,
+    createdAt: execution.createdAt,
     updatedAt: execution.updatedAt,
     archived: execution.archivedAt !== null,
     running,
+    status: statusOfExecution(execution, running),
     sessionStatus: execution.session?.status ?? null,
     forkedFrom: forkPointOf(execution.forkedFrom),
-    runtimeMode: execution.runtimeMode,
-    interactionMode: execution.interactionMode,
-    modelSelection: execution.modelSelection
+    failedMessageIds: [
+      ...(execution.turnIntents ?? []).flatMap(
+        (intent) => intent.turn?.state === "error" ? [intent.turn.userMessageId] : []
+      ),
+      ...execution.latestTurn?.state === "error" && execution.latestTurn.userMessageId !== void 0 ? [execution.latestTurn.userMessageId] : []
+    ],
+    waitingMessageId: (execution.turnIntents ?? []).find(
+      (intent) => intent.turn?.turnId != null && intent.turn.turnId === execution.session?.activeTurnId
+    )?.turn?.userMessageId ?? execution.latestTurn?.userMessageId ?? null
   };
 }
 async function executionOf(ctx, threadId) {
@@ -607,11 +588,109 @@ async function executionOf(ctx, threadId) {
   return executionRow(execution);
 }
 
+// src/sessionMap/mapDirectory.ts
+var MapDirectory = class {
+  rows = /* @__PURE__ */ new Map();
+  projects = /* @__PURE__ */ new Map();
+  sources = /* @__PURE__ */ new Map();
+  ready = /* @__PURE__ */ new Set();
+  flights = /* @__PURE__ */ new Map();
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  isReady(projectId) {
+    return this.ready.has(null) || this.ready.has(projectId);
+  }
+  ensure(projectId) {
+    if (this.isReady(projectId)) return Promise.resolve();
+    const pending = this.flights.get(projectId);
+    if (pending !== void 0) return pending;
+    const flight = listSessionShells(this.ctx, projectId ?? void 0).then((shells) => {
+      for (const shell of shells) this.set(threadFromShell(shell));
+      this.ready.add(projectId);
+    }).finally(() => this.flights.delete(projectId));
+    this.flights.set(projectId, flight);
+    return flight;
+  }
+  set(thread) {
+    const previous = this.rows.get(thread.threadId);
+    if (previous?.forkedFrom != null) this.removeSource(previous);
+    if (previous !== void 0 && previous.projectId !== thread.projectId)
+      this.projects.get(previous.projectId)?.delete(thread.threadId);
+    this.rows.set(thread.threadId, thread);
+    const ids = this.projects.get(thread.projectId) ?? /* @__PURE__ */ new Set();
+    ids.add(thread.threadId);
+    this.projects.set(thread.projectId, ids);
+    if (thread.forkedFrom !== null) {
+      const fork = thread.forkedFrom;
+      const messages = this.sources.get(fork.sourceThreadId) ?? /* @__PURE__ */ new Map();
+      const children = messages.get(fork.sourceMessageId) ?? /* @__PURE__ */ new Set();
+      children.add(thread.threadId);
+      messages.set(fork.sourceMessageId, children);
+      this.sources.set(fork.sourceThreadId, messages);
+    }
+  }
+  decorate(thread) {
+    const sources = this.sources.get(thread.threadId);
+    if (sources === void 0 || thread.turnOutline === void 0) return thread;
+    return {
+      ...thread,
+      turnOutline: thread.turnOutline.map(
+        (turn) => sources.has(turn.messageId) ? { ...turn, forkSource: true } : turn
+      )
+    };
+  }
+  get(threadId) {
+    return this.rows.get(threadId);
+  }
+  list(projectId) {
+    if (projectId === null) return [...this.rows.values()];
+    return [...this.projects.get(projectId) ?? []].flatMap((id) => {
+      const row = this.rows.get(id);
+      return row === void 0 ? [] : [row];
+    });
+  }
+  delete(threadId) {
+    const row = this.rows.get(threadId);
+    if (row === void 0) return null;
+    this.removeSource(row);
+    this.rows.delete(threadId);
+    this.projects.get(row.projectId)?.delete(threadId);
+    return row.projectId;
+  }
+  removeSource(thread) {
+    const fork = thread.forkedFrom;
+    if (fork === null) return;
+    const messages = this.sources.get(fork.sourceThreadId);
+    const children = messages?.get(fork.sourceMessageId);
+    children?.delete(thread.threadId);
+    if (children?.size === 0) messages?.delete(fork.sourceMessageId);
+    if (messages?.size === 0) this.sources.delete(fork.sourceThreadId);
+  }
+};
+
+// src/sessionMap/turnCards.ts
+function turnCards(messages, ids, tools, running) {
+  const wanted = new Set(ids.slice(0, 60));
+  const starts = messages.flatMap((message, index) => message.role === "user" ? [index] : []);
+  return starts.flatMap((start, index) => {
+    const message = messages[start];
+    if (message === void 0 || !wanted.has(message.messageId)) return [];
+    const latest = index === starts.length - 1;
+    return buildTurns(
+      messages.slice(start, starts[index + 1]),
+      latest ? tools : [],
+      latest && running,
+      MAX_PREVIEW_TEXT
+    );
+  });
+}
+
 // src/sessionMap/threadReads.ts
 import {
   isThreadNotFound,
   threadMessagesNewestFirst,
-  threadOrNull,
   THREAD_ACTIVITIES_LIST_LIMIT,
   TOOL_LIFECYCLE_ACTIVITY_KINDS
 } from "@ycodium-ai/plugin-api";
@@ -697,37 +776,16 @@ async function readToolTitles(threads, threadId) {
   }
   return titles;
 }
-async function readDetail(threads, threadId) {
-  const thread = await threadOrNull(threads, threadId);
-  if (thread === null) return { found: false, messages: [] };
-  let latest;
-  try {
-    latest = await threads.messages.list({
-      threadId,
-      limit: MAX_DETAIL_MESSAGES,
-      includeTotal: true
-    });
-  } catch (error) {
-    if (isThreadNotFound(error)) return { found: false, messages: [] };
-    throw error;
-  }
-  return {
-    found: true,
-    title: thread.title,
-    omitted: Math.max(0, (latest.total ?? 0) - latest.items.length),
-    messages: latest.items.toReversed().map((message) => {
-      const clipped = clipText(message.text, MAX_DETAIL_TEXT);
-      return {
-        messageId: message.id,
-        role: message.role,
-        text: clipped.text,
-        truncated: clipped.truncated
-      };
-    })
-  };
-}
 
 // src/sessionMap/mapLive.ts
+var WAITING_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+  "approval.requested",
+  "approval.resolved",
+  "provider.approval.respond.failed",
+  "user-input.requested",
+  "user-input.resolved",
+  "provider.user-input.respond.failed"
+]);
 function createSessionMapHub(ctx, canvas, options = {}) {
   return new SessionMapHub(ctx, canvas, options.timers !== false);
 }
@@ -738,14 +796,15 @@ var SessionMapHub = class {
   tools = /* @__PURE__ */ new Map();
   toolTitles = /* @__PURE__ */ new Map();
   executions = /* @__PURE__ */ new Map();
+  executionGenerations = /* @__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;
+  removed = /* @__PURE__ */ new Map();
+  emitters = /* @__PURE__ */ new Map();
+  pendingFull = /* @__PURE__ */ new Set();
+  directory;
   projects = null;
-  directoryFlight = null;
   tail = Promise.resolve();
   wantFull = false;
   dueTimer = null;
@@ -756,13 +815,16 @@ var SessionMapHub = class {
     this.ctx = ctx;
     this.canvas = canvas;
     this.timers = timers;
+    this.directory = new MapDirectory(ctx);
   }
-  subscribe(emit) {
-    this.emitters.add(emit);
+  subscribe(emit, projectId = null) {
+    this.emitters.set(emit, projectId);
+    this.pendingFull.add(emit);
     const deferred = this.gate.takeDeferred();
-    this.enqueue(deferred, true);
+    this.enqueue(deferred, false);
     return () => {
       this.emitters.delete(emit);
+      this.pendingFull.delete(emit);
     };
   }
   onMessage(threadId, event, now = Date.now()) {
@@ -780,8 +842,12 @@ var SessionMapHub = class {
     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 running = progress.phase !== "ended";
+    if (!running || cached === void 0) this.invalidateExecution(threadId);
+    else if (cached !== void 0 && !cached.running) {
+      this.invalidateExecution(threadId);
+      const status = cached.status === "waiting" ? "waiting" : "running";
+      this.executions.set(threadId, { ...cached, running, status });
     }
     const known = this.toolTitles.get(threadId);
     this.tools.set(
@@ -801,28 +867,58 @@ var SessionMapHub = class {
   }
   onDirectory(type, threadId) {
     if (type === "thread.deleted") {
+      const projectId = this.directory.delete(threadId);
       this.drop(threadId);
-      this.removed.add(threadId);
-      if (this.shells !== null) {
-        this.shells = this.shells.filter((shell) => shell.threadId !== threadId);
-      }
+      if (projectId !== null) this.removed.set(threadId, projectId);
       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);
+      this.invalidateExecution(threadId);
     }
     if (threadId.length > 0) this.note(threadId, Date.now(), false);
     else if (this.emitters.size > 0) this.enqueue([], true);
   }
+  /** 只有审批与提问的发出、答复会改「等你」；别的活动（工具进展等）不重读执行。 */
+  onActivity(threadId, payload, now = Date.now()) {
+    if (!isRecord(payload) || !isRecord(payload.activity)) return;
+    if (WAITING_ACTIVITY_KINDS.has(readString(payload.activity.kind))) this.onStatus(threadId, now);
+  }
+  /** 审批、提问或会话状态变了：卡片状态要跟着变，执行行重读。 */
+  onStatus(threadId, now = Date.now()) {
+    if (threadId.length === 0) return;
+    this.invalidateExecution(threadId);
+    this.note(threadId, now, false);
+  }
+  /** 屏幕上的卡片只有目录那几样：读它们的正文。读过的不再读。 */
+  load(threadIds, now = Date.now()) {
+    for (const threadId of threadIds.slice(0, MAX_LOAD_PER_CALL)) {
+      if (threadId.length === 0 || this.cards.has(threadId)) continue;
+      this.note(threadId, now, true);
+    }
+  }
   /** 用户命令：立刻读这一条，不管节流窗口。 */
   touch(threadId, now = Date.now()) {
-    this.executions.delete(threadId);
+    this.invalidateExecution(threadId);
     this.note(threadId, now, true);
   }
+  async readTurns(threadId, messageIds) {
+    const execution = await this.executionFor(threadId);
+    if (execution === null) return { threadId, turns: [] };
+    const messages = await this.loadMessages(threadId);
+    const parent = execution.forkedFrom === null ? null : await this.loadParent(execution.forkedFrom.sourceThreadId);
+    const inherited = inheritedMessageCount(parent, execution.forkedFrom?.sourceMessageId ?? null);
+    return {
+      threadId,
+      turns: turnCards(
+        messages.slice(inherited),
+        messageIds,
+        this.tools.get(threadId) ?? [],
+        execution.running
+      )
+    };
+  }
   canvasChanged() {
     this.enqueue([], true);
   }
@@ -876,16 +972,49 @@ var SessionMapHub = class {
     const full = this.wantFull;
     this.queued.clear();
     this.wantFull = false;
+    for (const scope of new Set(this.emitters.values())) await this.directory.ensure(scope);
     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);
+    const fresh = /* @__PURE__ */ new Set();
+    for (const [emit, scope] of this.emitters) {
+      if (!this.directory.isReady(scope)) continue;
+      if (full || this.pendingFull.has(emit)) fresh.add(emit);
+      this.pendingFull.delete(emit);
+    }
+    if (fresh.size > 0) await this.emitFull(fresh);
+    if (ids.length > 0 || this.removed.size > 0)
+      this.emitPatch(ids, /* @__PURE__ */ new Set([...fresh, ...this.pendingFull]));
   }
   async projectStored(threadId) {
+    const generation = this.executionGenerations.get(threadId) ?? 0;
+    const execution = await this.executionFor(threadId);
+    if (generation !== (this.executionGenerations.get(threadId) ?? 0))
+      return this.projectStored(threadId);
+    if (execution !== null) {
+      this.directory.set(
+        projectThread({
+          execution,
+          messages: [],
+          parentMessages: null,
+          tools: [],
+          textLimit: MAX_CARD_TEXT,
+          loaded: false
+        })
+      );
+      if (![...this.emitters.values()].some(
+        (scope) => scope === null || scope === execution.projectId
+      )) {
+        this.cards.delete(threadId);
+        return;
+      }
+    }
     const projected = await this.projectOne(threadId);
+    if (generation !== (this.executionGenerations.get(threadId) ?? 0))
+      return this.projectStored(threadId);
     if (projected === null) {
+      const projectId = this.directory.delete(threadId);
       this.drop(threadId);
-      this.removed.add(threadId);
+      if (projectId !== null) this.removed.set(threadId, projectId);
       return;
     }
     this.cards.set(threadId, projected);
@@ -924,11 +1053,19 @@ var SessionMapHub = class {
     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;
+    for (; ; ) {
+      const cached = this.executions.get(threadId);
+      if (cached !== void 0) return cached;
+      const generation = this.executionGenerations.get(threadId) ?? 0;
+      const row = await executionOf(this.ctx, threadId);
+      if (generation !== (this.executionGenerations.get(threadId) ?? 0)) continue;
+      if (row !== null) this.executions.set(threadId, row);
+      return row;
+    }
+  }
+  invalidateExecution(threadId) {
+    this.executions.delete(threadId);
+    this.executionGenerations.set(threadId, (this.executionGenerations.get(threadId) ?? 0) + 1);
   }
   async seedTranscript(threadId) {
     if (this.transcripts.has(threadId)) return;
@@ -965,62 +1102,55 @@ var SessionMapHub = class {
     }
     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);
+  async emitFull(targets) {
+    const state = await this.canvas.read();
+    if ([...targets].some((emit) => this.emitters.get(emit) === null) && this.projects === null) {
+      this.projects = (await this.ctx.projects.list({ repositoryIdentity: "skip" })).map(
+        (project) => ({
+          projectId: project.id,
+          title: project.title,
+          workspaceRoot: project.workspaceRoot,
+          archived: project.archivedAt != null
+        })
+      );
+    }
+    for (const emit of targets) {
+      const scope = this.emitters.get(emit);
+      if (scope === void 0) continue;
+      const threads = this.directory.list(scope).map((row) => this.cards.get(row.threadId) ?? row);
+      const ids = new Set(threads.map((thread) => thread.threadId));
+      emit(
+        boardSnapshot({
+          projects: scope === null ? this.projects ?? [] : [],
+          threads,
+          canvas: scope === null ? state : { ...state, hiddenThreadIds: state.hiddenThreadIds.filter((id) => ids.has(id)) }
+        })
+      );
     }
-    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];
+  emitPatch(ids, skip) {
+    const removed = new Map(this.removed);
     this.removed.clear();
     const threads = ids.flatMap((id) => {
       const card = this.cards.get(id);
-      return card === void 0 ? [] : [card];
+      return card === void 0 ? [] : [previewThread(this.directory.decorate(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.projects.list({ repositoryIdentity: "skip" })).map(
-      (project) => ({
-        projectId: project.id,
-        title: project.title,
-        workspaceRoot: project.workspaceRoot,
-        archived: project.archivedAt != null
-      })
-    );
-    this.shells = shells;
-    this.projects = projects;
+    for (const [emit, scope] of Array.from(this.emitters)) {
+      if (skip.has(emit) || !this.emitters.has(emit)) continue;
+      const scopedThreads = scope === null ? threads : threads.filter((thread) => thread.projectId === scope);
+      const removedThreadIds = [...removed].flatMap(
+        ([id, projectId]) => scope === null || projectId === scope ? [id] : []
+      );
+      if (scopedThreads.length > 0 || removedThreadIds.length > 0)
+        emit({ patch: true, threads: scopedThreads, removedThreadIds });
+    }
   }
   drop(threadId) {
     this.cards.delete(threadId);
     this.transcripts.invalidate(threadId);
     this.tools.delete(threadId);
     this.toolTitles.delete(threadId);
-    this.executions.delete(threadId);
+    this.invalidateExecution(threadId);
     this.live.delete(threadId);
     this.pendingMessage.delete(threadId);
   }
@@ -1049,7 +1179,9 @@ function activateSessionMap(ctx) {
       "thread.deleted",
       "thread.message-sent",
       "thread.archived",
-      "thread.unarchived"
+      "thread.unarchived",
+      "thread.activity-appended",
+      "thread.session-set"
     ],
     handle: (event) => {
       const threadId = event.aggregateKind === "thread" ? event.aggregateId : "";
@@ -1057,6 +1189,14 @@ function activateSessionMap(ctx) {
         hub.onMessage(threadId, event);
         return;
       }
+      if (event.type === "thread.session-set") {
+        hub.onStatus(threadId);
+        return;
+      }
+      if (event.type === "thread.activity-appended") {
+        hub.onActivity(threadId, event.payload);
+        return;
+      }
       hub.onDirectory(event.type, threadId);
     }
   });
@@ -1077,16 +1217,54 @@ function activateSessionMap(ctx) {
       return { ok: true };
     }
   });
+  ctx.command({
+    name: "load",
+    description: "Read the sessions whose cards are on screen.",
+    scope: "read",
+    payloadSchema: {
+      type: "object",
+      properties: { threadIds: { type: "array", items: { type: "string" } } },
+      required: ["threadIds"]
+    },
+    handle: async (payload) => {
+      const ids = payload["threadIds"];
+      hub.load(Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : []);
+      return { ok: true };
+    }
+  });
+  ctx.command({
+    name: "turns",
+    description: "Read short text for the turn cards on screen.",
+    scope: "read",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        threadId: { type: "string" },
+        messageIds: { type: "array", maxItems: 60, items: { type: "string" } }
+      },
+      required: ["threadId", "messageIds"]
+    },
+    handle: async (payload) => {
+      const ids = payload["messageIds"];
+      return hub.readTurns(
+        readString(payload["threadId"]),
+        Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : []
+      );
+    }
+  });
   ctx.command({
     name: "snapshot",
     description: "Read the session map.",
     scope: "read",
-    payloadSchema: { type: "object", properties: {} },
-    handle: async () => {
+    payloadSchema: { type: "object", properties: { projectId: { type: "string" } } },
+    handle: async (payload) => {
       const frames = [];
-      const stop = hub.subscribe((frame) => {
-        frames.push(frame);
-      });
+      const stop = hub.subscribe(
+        (frame) => {
+          frames.push(frame);
+        },
+        readString(payload["projectId"]) || null
+      );
       await hub.settled();
       stop();
       return frames.at(-1) ?? { projects: [], threads: [] };
@@ -1097,11 +1275,14 @@ function activateSessionMap(ctx) {
     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);
-      });
+    payloadSchema: { type: "object", properties: { projectId: { type: "string" } } },
+    handle: async (payload, emit, signal) => {
+      const stop = hub.subscribe(
+        (frame) => {
+          emit(frame);
+        },
+        readString(payload["projectId"]) || null
+      );
       try {
         await abort(signal);
       } finally {
@@ -1109,63 +1290,16 @@ function activateSessionMap(ctx) {
       }
     }
   });
-  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) => readDetail(ctx.threads, 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)));
+      const show = preferencePatch(payload["patch"]);
+      const next = show === null ? await canvas.read() : await canvas.update((state) => showArchived(state, show));
       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 };
+      return { showArchived: next.showArchived };
     }
   });
   ctx.command({
@@ -1199,117 +1333,31 @@ function activateSessionMap(ctx) {
       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.",
+    description: "Fork at a user message. The first message is written in the new session.",
     scope: "operate",
     payloadSchema: {
       type: "object",
       properties: {
         threadId: { type: "string" },
-        messageId: { type: "string" },
-        text: { type: "string" }
+        messageId: { type: "string" }
       },
-      required: ["threadId", "messageId", "text"]
+      required: ["threadId", "messageId"]
     },
     handle: async (payload) => forkSession(
       ctx,
       readString(payload["threadId"]),
       readString(payload["messageId"]),
-      readString(payload["text"]),
       (id) => hub.touch(id)
     )
   });
 }
-async function createSession(ctx, projectId, text2, refresh) {
-  const trimmed = text2.trim();
-  if (trimmed.length === 0) return { ok: false, code: "empty" };
-  const project = await projectOrNull(ctx.projects, projectId);
-  if (project === null) return { ok: false, code: "missing-project" };
-  const selection = await ctx.providers.selection.resolve({ base: project.defaultModelSelection });
-  const threadId = NodeCrypto.randomUUID();
-  const [create, start] = createCommands({
-    projectId,
-    title: titleFromText(trimmed),
-    text: trimmed,
-    modelSelection: selection.modelSelection,
-    runtimeMode: "full-access",
-    interactionMode: "default",
-    threadId,
-    commandId: NodeCrypto.randomUUID(),
-    messageId: NodeCrypto.randomUUID(),
-    turnCommandId: NodeCrypto.randomUUID()
-  });
-  await ctx.threads.create(create);
-  await ctx.threads.turns.start(start);
-  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.threads.turns.start(
-    turnCommand({
-      threadId,
-      text: trimmed,
-      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" };
+async function forkSession(ctx, threadId, messageId, refresh) {
   const transcript = await readTranscript(ctx.threads, threadId);
   if (transcript === null) return { ok: false, code: "missing-thread" };
   const anchor = resolveForkAnchor(transcript, messageId);
   if (anchor === null) return { ok: false, code: "no-user-message" };
-  const execution = await executionOf(ctx, threadId);
   const childId = NodeCrypto.randomUUID();
   await ctx.threads.fork(
     forkCommand({
@@ -1319,33 +1367,13 @@ async function forkSession(ctx, threadId, messageId, text2, refresh) {
       commandId: NodeCrypto.randomUUID()
     })
   );
-  await ctx.threads.turns.start(
-    turnCommand({
-      threadId: childId,
-      text: trimmed,
-      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 }
-  };
+  if (!isRecord(value) || typeof value.showArchived !== "boolean") return null;
+  return value.showArchived;
 }
 function abort(signal) {
   return new Promise((resolve) => {
@@ -1360,7 +1388,7 @@ function abort(signal) {
 // src/index.ts
 var index_default = definePlugin({
   id: "conversation",
-  apiVersion: 27,
+  apiVersion: 28,
   activate(ctx) {
     activateSessionMap(ctx);
   }