wave-code 1.4.0 → 1.5.0

package/src/stdio/agentBridge.ts

@@ -37,6 +37,8 @@ import {
   isValidHookEvent,
   listSessions,
   listAllSessions,
+  readRecentWorkdirs,
+  rememberRecentWorkdir,
   setSessionCustomTitle,
   searchFiles,
   generateRandomName,
@@ -46,7 +48,9 @@ import {
   AuthService,
   PluginCore,
   validateWorktreeRemovalPath,
-  type SlashCommand,
+  type HostSurface,
+  type SlashCommandInfo,
+  type ConfiguredModel,
   loadUserConfigEnv,
   loadWaveConfigFromFile,
   getUserConfigPaths,
@@ -59,7 +63,18 @@ import {
   type SkillMetadata,
   type PluginReloadResult,
   type RemoteControlSnapshot,
+  type CompletionSnippet,
+  type NextEditExcerpt,
+  type NextEditHistoryEntry,
+  type NextEditRegion,
+  type NextEditSuggestion,
   normalizeEntrypoint,
+  fetchArtifactGalleryList,
+  fetchArtifactShareView,
+  saveArtifactShare,
+  revokeArtifact,
+  searchArtifactMembers,
+  type ArtifactShareMode,
 } from "wave-agent-sdk";
 import {
   type ClientNotificationMethod,
@@ -91,7 +106,8 @@ import {
 import { logger } from "../utils/logger.js";
 import {
   InvalidMessageWindowError,
-  sliceMessageWindow,
+  normalizeMessageWindow,
+  type MessageWindow,
   type MessageWindowResult,
 } from "../remote/messageWindow.js";
 import {
@@ -103,6 +119,12 @@ import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 import { getWorkspaceDiff } from "../utils/workspaceDiff.js";
 import { installGitCredentialHelper } from "../utils/gitCredentialHelper.js";
 import type { RemoteControlController } from "../remote/remoteControlService.js";
+import {
+  hostSlashCommandsFor,
+  parseHostSurface,
+  toSlashCommandInfo,
+} from "./hostSlashCommands.js";
+import { messageForUi, messagesForUi } from "./uiPayload.js";
 
 export type NotificationEmitter = (
   method: ServerNotificationMethod,
@@ -179,7 +201,7 @@ interface SessionEntry {
   storedConfig: Partial<InitializeParams>;
   /**
    * The workdir the session was CREATED in — an immutable identity, unlike the
-   * live `agent.workingDirectory`, which drifts as the session `cd`s (bash tool
+   * live `agent.currentWorkdir`, which drifts as the session `cd`s (bash tool
    * / worktree switches). Hosted-session consumers (destroy --remove-worktree's
    * worktree resolution, list) read this instead of the live value so a session
    * that moved out of its worktree into the main repo is still cleaned up at
@@ -241,6 +263,14 @@ export class AgentBridge {
    * docs/specs/ui/code-completion.md: 同一时刻只允许一个补全请求在途).
    */
   private inFlightCompletions = new Map<string, AbortController>();
+  /**
+   * In-flight next-edit calls, same one-per-session rule and same reason as
+   * completions. It also participates in the cross-capability exclusion from
+   * `docs/specs/ui/next-edit-suggestion.md`: completion and next-edit never hold
+   * an in-flight request at the same time, so one of them cannot answer into a
+   * buffer the other has already rewritten.
+   */
+  private inFlightNextEdits = new Map<string, AbortController>();
   private emit: NotificationEmitter;
   private onShutdownRequest: (() => void) | undefined;
   private remoteControl:
@@ -370,7 +400,6 @@ export class AgentBridge {
         return this.deleteQueuedMessageById(p.id as string, sessionId);
       case "getMessages":
         return this.getMessages(sessionId, {
-          before: p.before as string | undefined,
           since: p.since as string | undefined,
           limit: p.limit as number | undefined,
         });
@@ -410,7 +439,7 @@ export class AgentBridge {
 
       // ── Commands ──
       case "getSlashCommands":
-        return this.getSlashCommands(sessionId);
+        return this.getSlashCommands(sessionId, parseHostSurface(p.surface));
       case "getSubagentConfigurations":
         return this.getSubagentConfigurations(sessionId);
       case "getSkillMetadata":
@@ -462,6 +491,28 @@ export class AgentBridge {
       case "installGitCredentialHelper":
         return installGitCredentialHelper();
 
+      // ── 创作集（global — 账号级读写，无 session 要求）──
+      // 桌面端整页与右侧预览面板共用这一组；HTTP 与 token 只留在本进程
+      // （services/artifactGallery.ts），宿主不直连网络。
+      case "artifactGalleryList":
+        return fetchArtifactGalleryList();
+      case "artifactShareView":
+        return fetchArtifactShareView(p.slug as string);
+      case "artifactShareSave":
+        return saveArtifactShare({
+          slug: p.slug as string,
+          mode: p.mode as ArtifactShareMode,
+          userIds: p.userIds as string[] | undefined,
+          pinnedVersion: p.pinnedVersion as number | null | undefined,
+        });
+      case "artifactRevoke":
+        return revokeArtifact(p.slug as string);
+      case "artifactMembersSearch":
+        return searchArtifactMembers(
+          (p.search as string | undefined) ?? "",
+          p.limit as number | undefined,
+        );
+
       // ── Memory files (settings UI — user-level ~/.wave/AGENTS.md and
       //    project-level <workdir>/AGENTS.md) ──
       case "getAgentsContent":
@@ -601,6 +652,14 @@ export class AgentBridge {
       // ── Filesystem / Git / worktree (global — no session required) ──
       case "listDirectories":
         return this.listDirectories(p.dir as string | undefined);
+      // ── 最近打开的工作目录（spec core/recent-workdirs.md）──
+      // 机器级、与会话无关：文件就在这台机器上，谁问就回谁的。桌面端按主机
+      // 各问一次，远控 Web 页问它连着的那个进程。
+      case "getRecentWorkdirs":
+        return { dirs: readRecentWorkdirs() };
+      case "rememberRecentWorkdir":
+        rememberRecentWorkdir(p.workdir as string);
+        return null;
       case "listGitBranches":
         return this.listGitBranches(p.workdir as string | undefined);
       case "createWorktree":
@@ -639,6 +698,28 @@ export class AgentBridge {
             suffix?: string;
             language?: string;
             filePath?: string;
+            snippets?: CompletionSnippet[];
+          },
+          sessionId,
+        );
+      case "reportCompletionOutcome":
+        return this.reportCompletionOutcome(
+          p.outcome as "displayed" | "accepted",
+          sessionId,
+        );
+      case "reportNextEditOutcome":
+        return this.reportNextEditOutcome(
+          p.outcome as "displayed" | "accepted",
+          sessionId,
+        );
+      case "getNextEdit":
+        return this.getNextEdit(
+          p as unknown as {
+            edits?: NextEditHistoryEntry[];
+            region?: NextEditRegion;
+            excerpt?: NextEditExcerpt;
+            language?: string;
+            filePath?: string;
           },
           sessionId,
         );
@@ -680,7 +761,9 @@ export class AgentBridge {
 
   private async initialize(params: InitializeParams): Promise<{
     sessionId: string;
-    workingDirectory: string;
+    currentWorkdir: string;
+    sessionCwd: string;
+    repoRoot?: string;
     permissionMode: PermissionMode;
     latestTotalTokens: number;
   }> {
@@ -690,12 +773,7 @@ export class AgentBridge {
     if (params.restoreSessionId) {
       const live = this.sessions.get(params.restoreSessionId);
       if (live) {
-        return {
-          sessionId: live.agent.sessionId,
-          workingDirectory: live.agent.workingDirectory,
-          permissionMode: live.agent.getPermissionMode(),
-          latestTotalTokens: live.agent.latestTotalTokens,
-        };
+        return this.initializeReply(live.agent, live.createdWorkdir);
       }
     }
 
@@ -751,9 +829,9 @@ export class AgentBridge {
       createdWorkdir =
         (await readTranscriptWorkdir(agent.sessionFilePath)) ??
         params.workdir ??
-        agent.workingDirectory;
+        agent.currentWorkdir;
     } else {
-      createdWorkdir = params.workdir ?? agent.workingDirectory;
+      createdWorkdir = params.workdir ?? agent.currentWorkdir;
     }
 
     this.sessions.set(agent.sessionId, {
@@ -764,9 +842,43 @@ export class AgentBridge {
       createdWorkdir,
     });
 
+    return this.initializeReply(agent, createdWorkdir);
+  }
+
+  /**
+   * The `initialize` reply.
+   *
+   * The current cwd and the session root travel as two separate facts on
+   * purpose. A re-attached session may have bash-`cd`'d away from where it was
+   * created, so `agent.currentWorkdir` answers "where is it now" while
+   * `createdWorkdir` answers "which project does this conversation belong to".
+   * Hosts key durable things (sidebar grouping, project-scoped config, `@file`
+   * scope) off the latter — the desktop used to derive both from one
+   * `workingDirectory` field and moved a resumed conversation into a
+   * subdirectory group.
+   *
+   * `repoRoot` closes the worktree case: a session created inside a linked git
+   * worktree belongs to the repo it was forked from. It is derived the same way
+   * `listDaemonSessions` derives each row's `worktree`, i.e. from the
+   * filesystem, without shelling out to git.
+   */
+  private initializeReply(
+    agent: Agent,
+    sessionCwd: string,
+  ): {
+    sessionId: string;
+    currentWorkdir: string;
+    sessionCwd: string;
+    repoRoot?: string;
+    permissionMode: PermissionMode;
+    latestTotalTokens: number;
+  } {
+    const worktree = deriveWorktreeInfo(sessionCwd);
     return {
       sessionId: agent.sessionId,
-      workingDirectory: agent.workingDirectory,
+      currentWorkdir: agent.currentWorkdir,
+      sessionCwd,
+      ...(worktree ? { repoRoot: worktree.repoRoot } : {}),
       permissionMode: agent.getPermissionMode(),
       latestTotalTokens: agent.latestTotalTokens,
     };
@@ -1186,6 +1298,7 @@ export class AgentBridge {
       suffix?: string;
       language?: string;
       filePath?: string;
+      snippets?: CompletionSnippet[];
     },
     sessionId?: string,
   ): Promise<{ text: string; model: string }> {
@@ -1193,8 +1306,10 @@ export class AgentBridge {
     const key = sessionId as string;
 
     // Supersede the session's previous request: its answer would land at a
-    // cursor position that no longer exists.
+    // cursor position that no longer exists. A next-edit suggestion in flight is
+    // dropped too — both rewrite the same buffer (spec ui/next-edit-suggestion.md).
     this.inFlightCompletions.get(key)?.abort();
+    this.inFlightNextEdits.get(key)?.abort();
     const controller = new AbortController();
     this.inFlightCompletions.set(key, controller);
 
@@ -1204,6 +1319,10 @@ export class AgentBridge {
         suffix: params.suffix ?? "",
         ...(params.language ? { language: params.language } : {}),
         ...(params.filePath ? { filePath: params.filePath } : {}),
+        // `undefined` (host cannot collect snippets) and `[]` (tried, found
+        // nothing) stay distinguishable here and both mean "no snippets" to
+        // the model; only an absent field is left out of the call.
+        ...(params.snippets ? { snippets: params.snippets } : {}),
         abortSignal: controller.signal,
       });
     } finally {
@@ -1214,6 +1333,55 @@ export class AgentBridge {
     }
   }
 
+  /**
+   * One next-edit suggestion for the editor plugins (spec
+   * ui/next-edit-suggestion.md).
+   *
+   * Session-scoped for the same reason as completion: the model, the switch and
+   * the credentials all live in that session. Read-only, so a suggestion still
+   * resolves while `updateConfig` rebuilds the session.
+   */
+  private async getNextEdit(
+    params: {
+      edits?: NextEditHistoryEntry[];
+      region?: NextEditRegion;
+      excerpt?: NextEditExcerpt;
+      language?: string;
+      filePath?: string;
+    },
+    sessionId?: string,
+  ): Promise<{ suggestion: NextEditSuggestion | null; model: string }> {
+    const entry = this.requireSessionForRead(sessionId);
+    const key = sessionId as string;
+
+    // A region and its excerpt are the whole basis of the answer; without them
+    // there is nothing to predict into, so this is a no-op rather than an error.
+    if (!params.region || !params.excerpt) {
+      return { suggestion: null, model: "" };
+    }
+
+    // Same exclusion as the completion path, from this side.
+    this.inFlightNextEdits.get(key)?.abort();
+    this.inFlightCompletions.get(key)?.abort();
+    const controller = new AbortController();
+    this.inFlightNextEdits.set(key, controller);
+
+    try {
+      return await entry.agent.getNextEdit({
+        edits: params.edits ?? [],
+        region: params.region,
+        excerpt: params.excerpt,
+        ...(params.language ? { language: params.language } : {}),
+        ...(params.filePath ? { filePath: params.filePath } : {}),
+        abortSignal: controller.signal,
+      });
+    } finally {
+      if (this.inFlightNextEdits.get(key) === controller) {
+        this.inFlightNextEdits.delete(key);
+      }
+    }
+  }
+
   private async createWorktreeSession(params: {
     workdir: string;
     baseBranch?: string;
@@ -1301,7 +1469,7 @@ export class AgentBridge {
 
   private async getSessionInfo(sessionId?: string): Promise<{
     sessionId: string;
-    workingDirectory: string;
+    sessionCwd: string;
     latestTotalTokens: number;
     permissionMode: PermissionMode;
     availableTools: string[];
@@ -1314,10 +1482,10 @@ export class AgentBridge {
     const entry = this.requireSessionForRead(sessionId);
     return {
       sessionId: entry.agent.sessionId,
-      // The recorded creation workdir, not the live agent.workingDirectory:
+      // The recorded creation workdir, not the live agent.currentWorkdir:
       // destroy --remove-worktree resolves the session's worktree from this
       // value, and it must not drift when the session cd'd out of the worktree.
-      workingDirectory: entry.createdWorkdir,
+      sessionCwd: entry.createdWorkdir,
       latestTotalTokens: entry.agent.latestTotalTokens,
       permissionMode: entry.agent.getPermissionMode(),
       availableTools: entry.agent.getAvailableToolNames(),
@@ -1447,7 +1615,7 @@ export class AgentBridge {
   }
 
   private getConfiguredModels(sessionId?: string): {
-    models: string[];
+    models: ConfiguredModel[];
     currentModel: string | undefined;
   } {
     const entry = this.requireSessionForRead(sessionId);
@@ -1519,20 +1687,31 @@ export class AgentBridge {
     sessionId?: string,
   ): Promise<null> {
     const entry = this.requireSession(sessionId);
-    if (params.force) {
-      entry.agent.abortMessage();
-    }
     // Save prompt to history (mirrors VSCE chatSession.ts:236-242)
     try {
       await PromptHistoryManager.addEntry(
         params.text,
         entry.agent.sessionId,
         {},
-        entry.agent.workingDirectory,
+        entry.agent.currentWorkdir,
       );
     } catch {
       // Best-effort; don't block message sending on history save failure
     }
+    if (params.force) {
+      // "Send now" for one queued item: interrupt the running turn but keep the
+      // rest of the queue — the host removes the picked item separately, and
+      // everything it did not touch must still be delivered afterwards.
+      //
+      // The abort must be immediately followed by `sendMessage` with nothing
+      // awaited in between: the abort resets the loading flag, which is the gate
+      // a queued item waits behind, so any await here lets the *next* queued
+      // message start a turn first — the picked one would then be enqueued at
+      // the tail instead of going out now (realhost smoke: with the history
+      // write above the abort, a `deleteQueuedMessageById` landing in that gap
+      // started the remaining message immediately).
+      entry.agent.abortMessage({ keepQueue: true });
+    }
     await entry.agent.sendMessage(
       params.text,
       this.persistDataUrlImages(params.images),
@@ -1694,61 +1873,72 @@ export class AgentBridge {
   /**
    * Read a session's display messages.
    *
-   * With no window this returns the whole list — that is the contract every
-   * existing host relies on (VS Code / JetBrains / desktop call `getMessages`
-   * with no parameters and must keep seeing the full thread, byte for byte).
-   * The window exists for remote clients on a phone, which only ever want the
-   * tail of a long conversation and must not be handed 13 MB on every cold
-   * start:
+   * With no parameters this returns the whole list the agent holds, read once
+   * and cached nowhere (spec ui/message-rendering-system.md「首屏就是整份列表，
+   * 不分页」). Two parameters narrow it, both for the remote page:
    *
-   * - `limit`  — page size.
-   * - `before` — the page that ends immediately before the given message id
-   *              (paging *backwards* into history).
-   * - `since`  — everything appended after the given message id (catching up
-   *              after a reconnect).
+   * - `limit` — the newest `limit` messages (that page's frame budget).
+   * - `since` — everything appended after the given message id (catching up
+   *             after a reconnect).
+   *
+   * The list starts at the last compaction, so its earliest entry is the
+   * earliest any UI can reach; there is nothing older to read back.
    *
    * `since` is a position, not a version number: message ids are stable, so a
    * caller can name its last known message without the list carrying a
    * sequence number. The one failure that matters is the anchor having been
    * truncated away (rewind / clear) — there is no seq/version in the store that
    * could detect it otherwise — and that comes back as `reset: true` so the
-   * caller re-pulls the tail instead of guessing.
+   * caller re-pulls instead of guessing.
    *
-   * Ids can repeat in the display list (a compacted message is re-added), so
-   * anchors are resolved to their **last** occurrence: "after `since`" means
-   * after the newest copy the caller could have seen.
+   * Ids can repeat (old transcripts re-appended the preserved rounds at each
+   * compact point), so anchors are resolved to their **last** occurrence:
+   * "after `since`" means after the newest copy the caller could have seen.
    */
-  private getMessages(
+  private async getMessages(
     sessionId?: string,
-    window?: { before?: string; since?: string; limit?: number },
-  ): {
-    messages: Message[];
-    contextUsagePercent?: number;
-    /** Older messages exist before the returned page. */
-    hasMore?: boolean;
-    /** The `since` anchor is gone — rebuild from the tail. */
-    reset?: boolean;
-    /** Total display messages held for the session. */
-    total?: number;
-  } {
+    window?: MessageWindow,
+  ): Promise<MessageWindowResult> {
     const entry = this.requireSessionForRead(sessionId);
-    const all = entry.agent.displayMessages;
     const contextUsagePercent = this.contextUsagePercentOf(entry.agent);
 
-    // The slicing is shared with the CLI front end (`RemoteControlCliHost`): the
-    // phone's reconciliation rules belong to the wire contract, not to this
+    // The validation is shared with the CLI front end (`RemoteControlCliHost`):
+    // the phone's reconciliation rules belong to the wire contract, not to this
     // registry, and the two hosts must answer identically.
-    let sliced: MessageWindowResult | undefined;
+    let normalized: MessageWindow | undefined;
     try {
-      sliced = sliceMessageWindow(all, window);
+      normalized = normalizeMessageWindow(window);
     } catch (err) {
       if (err instanceof InvalidMessageWindowError) {
         throw new RpcError(PROTOCOL_INVALID_PARAMS, err.message);
       }
       throw err;
     }
-    if (!sliced) return { messages: all, contextUsagePercent };
-    return { ...sliced, contextUsagePercent };
+    // The totals ride along with the window: the list starts at the last
+    // compaction, so this reply is the only place a host can learn the
+    // thread's size and its first user message (the session-title fallback).
+    const threadSummary = entry.agent.getThreadSummary();
+    // Trimmed on the way out, never in the agent's own list: no UI renders tool
+    // pictures, and the agent has to keep them for the next request
+    // (specs/ui/stdio-transport.md「工具图片的字节不下发 UI」). The trim is
+    // copy-on-write, so a message with no picture keeps its identity.
+    if (!normalized) {
+      return {
+        // `Agent.messages` already hands back a copy, so this reply is a
+        // single-pass view for the host that asked once — do not copy again
+        // (a long session makes this O(n) per call).
+        messages: messagesForUi(entry.agent.messages),
+        contextUsagePercent,
+        threadSummary,
+      };
+    }
+    const page = entry.agent.getMessagePage(normalized);
+    return {
+      ...page,
+      messages: messagesForUi(page.messages),
+      contextUsagePercent,
+      threadSummary,
+    };
   }
 
   private async getFullMessageThread(sessionId?: string): Promise<{
@@ -1756,7 +1946,8 @@ export class AgentBridge {
     sessionIds: string[];
   }> {
     const entry = this.requireSessionForRead(sessionId);
-    return entry.agent.getFullMessageThread();
+    const thread = await entry.agent.getFullMessageThread();
+    return { ...thread, messages: messagesForUi(thread.messages) };
   }
 
   private async compact(
@@ -1832,6 +2023,43 @@ export class AgentBridge {
     return { mode: entry.agent.getPermissionMode() };
   }
 
+  /**
+   * Records what the editor host saw happen to the last suggestion —
+   * `displayed` when it rendered the ghost text, `accepted` when the user took
+   * it. The outcome is the only thing the host reports: the model and the
+   * language stay on this side, derived when the completion was produced.
+   */
+  private reportCompletionOutcome(
+    outcome: "displayed" | "accepted",
+    sessionId?: string,
+  ): { ok: true } {
+    const entry = this.requireSessionForRead(sessionId);
+    if (outcome !== "displayed" && outcome !== "accepted") {
+      throw new RpcError(
+        PROTOCOL_INTERNAL_ERROR,
+        "outcome must be 'displayed' or 'accepted'",
+      );
+    }
+    entry.agent.reportCompletionOutcome(outcome);
+    return { ok: true };
+  }
+
+  /** The next-edit twin: same validation, its own metric series in the SDK. */
+  private reportNextEditOutcome(
+    outcome: "displayed" | "accepted",
+    sessionId?: string,
+  ): { ok: true } {
+    const entry = this.requireSessionForRead(sessionId);
+    if (outcome !== "displayed" && outcome !== "accepted") {
+      throw new RpcError(
+        PROTOCOL_INTERNAL_ERROR,
+        "outcome must be 'displayed' or 'accepted'",
+      );
+    }
+    entry.agent.reportNextEditOutcome(outcome);
+    return { ok: true };
+  }
+
   /**
    * Returns the current plan file path and its contents for the session.
    * When the path generation is still in flight (e.g. the host just switched
@@ -1906,9 +2134,28 @@ export class AgentBridge {
 
   // ── Commands ──────────────────────────────────────────────────
 
-  private getSlashCommands(sessionId?: string): { commands: SlashCommand[] } {
+  /**
+   * The popup's rows: the agent's own commands (skills / custom / plugin) plus
+   * the host-local table for the front end that asked.
+   *
+   * `surface` is optional on purpose: a client that predates the field asks
+   * without it and gets exactly what it got before (the SDK half), instead of
+   * being handed rows it has no handling for. Unknown values are dropped the
+   * same way by `parseHostSurface`.
+   */
+  private getSlashCommands(
+    sessionId?: string,
+    surface?: HostSurface,
+  ): { commands: SlashCommandInfo[] } {
     const entry = this.requireSessionForRead(sessionId);
-    return { commands: entry.agent.getSlashCommands() };
+    const agentCommands = entry.agent
+      .getSlashCommands()
+      .map((command) => toSlashCommandInfo(command));
+    return {
+      commands: surface
+        ? [...agentCommands, ...hostSlashCommandsFor(surface)]
+        : agentCommands,
+    };
   }
 
   private getSubagentConfigurations(sessionId?: string): {
@@ -2114,7 +2361,7 @@ export class AgentBridge {
   private listDaemonSessions(): {
     sessions: Array<{
       sessionId: string;
-      workingDirectory: string;
+      sessionCwd: string;
       isLoading: boolean;
       hasRunningBackgroundWork: boolean;
       hasPendingMessages: boolean;
@@ -2144,20 +2391,23 @@ export class AgentBridge {
   } {
     return {
       sessions: [...this.sessions.entries()].map(([sessionId, entry]) => {
-        const messages = entry.agent.displayMessages;
         const customTitle = entry.agent.customTitle;
-        const firstMessage = firstUserText(messages);
-        const lastActiveAt = messages[messages.length - 1]?.timestamp;
+        // Totals come from the agent's counters, not from `displayMessages`:
+        // that is only the resident tail now, so its length and its first
+        // message are no longer the thread's.
+        const summary = entry.agent.getThreadSummary();
+        const firstMessage = summary.firstUserText;
+        const lastActiveAt = summary.lastActiveAt;
         // Derived from the creation workdir (not the live one) and fs-only —
         // see `deriveWorktreeInfo` for why this must not shell out to git.
         const worktree = deriveWorktreeInfo(entry.createdWorkdir);
         return {
           sessionId,
-          workingDirectory: entry.createdWorkdir,
+          sessionCwd: entry.createdWorkdir,
           isLoading: entry.transitioning === true || entry.agent.isLoading,
           hasRunningBackgroundWork: entry.agent.hasRunningBackgroundWork,
           hasPendingMessages: entry.agent.hasPendingMessages,
-          messageCount: messages.length,
+          messageCount: summary.messageCount,
           ...(customTitle ? { customTitle } : {}),
           ...(firstMessage ? { firstMessage } : {}),
           ...(lastActiveAt ? { lastActiveAt } : {}),
@@ -2320,7 +2570,7 @@ export class AgentBridge {
       return { content: await readTextFileSafe(path), path };
     }
     const resolvedWorkdir =
-      workdir || (agent?.workingDirectory as string | undefined);
+      workdir || (agent?.currentWorkdir as string | undefined);
     if (!resolvedWorkdir) {
       throw new RpcError(
         PROTOCOL_INVALID_PARAMS,
@@ -2359,7 +2609,7 @@ export class AgentBridge {
       return { ok: true };
     }
     const resolvedWorkdir =
-      workdir || (agent?.workingDirectory as string | undefined);
+      workdir || (agent?.currentWorkdir as string | undefined);
     if (!resolvedWorkdir) {
       throw new RpcError(
         PROTOCOL_INVALID_PARAMS,
@@ -2661,7 +2911,7 @@ export class AgentBridge {
         if (msg)
           this.emit(
             "userMessageAdded",
-            { message: msg },
+            { message: messageForUi(msg) },
             ctx.registeredSessionId,
           );
       },
@@ -2670,7 +2920,7 @@ export class AgentBridge {
         if (msg)
           this.emit(
             "assistantMessageAdded",
-            { message: msg },
+            { message: messageForUi(msg) },
             ctx.registeredSessionId,
           );
       },
@@ -2795,7 +3045,7 @@ export class AgentBridge {
         // than once under the same task id (a workflow warns about its size
         // mid-run, then notifies again when it finishes), and this callback
         // fires for the message that was just appended — the newest one.
-        const matches = (ctx.agent?.displayMessages ?? []).filter(
+        const matches = (ctx.agent?.messages ?? []).filter(
           (m) =>
             m.role === "user" &&
             m.blocks.some(
@@ -2807,14 +3057,14 @@ export class AgentBridge {
         const msg = matches[matches.length - 1];
         this.emit(
           "notificationMessageAdded",
-          { ...params, message: msg },
+          { ...params, message: msg ? messageForUi(msg) : undefined },
           ctx.registeredSessionId,
         );
       },
       onCompactBlockAdded: (content: string, message?: Message) => {
         this.emit(
           "compactBlockAdded",
-          { content, message },
+          { content, message: message ? messageForUi(message) : undefined },
           ctx.registeredSessionId,
         );
       },
@@ -2891,7 +3141,7 @@ export class AgentBridge {
 
   private getSessionWorkdir(sessionId?: string): string | undefined {
     if (!sessionId) return undefined;
-    return this.sessions.get(sessionId)?.agent.workingDirectory;
+    return this.sessions.get(sessionId)?.agent.currentWorkdir;
   }
 }
 
@@ -2923,22 +3173,6 @@ function isSessionRecoveryError(error: unknown): boolean {
   );
 }
 
-/**
- * The label a session list shows when no custom title is set: the first real
- * user message. Same rule as the webview's `firstUserMessageText` — meta messages
- * (task notifications and other injected turns) are skipped, because they are not
- * what the user typed — so the phone labels a conversation the way the IDE hosts
- * do.
- */
-function firstUserText(messages: Message[]): string | undefined {
-  for (const message of messages) {
-    if (message.role !== "user" || message.isMeta) continue;
-    const text = getMessageContent(message).trim();
-    if (text) return text;
-  }
-  return undefined;
-}
-
 /** Read a text file, returning "" when it does not exist. */
 async function readTextFileSafe(filePath: string): Promise<string> {
   try {