@nextclaw/ui 0.15.23 → 0.15.25

package/src/features/chat/features/workspace/hooks/use-workspace-file-actions.ts

@@ -0,0 +1,335 @@
+import { useEffect, useRef, useState } from 'react';
+import { NextClawClientError } from '@nextclaw/client-sdk';
+import { toast } from 'sonner';
+import type { useConfirmDialog } from '@/shared/hooks/use-confirm-dialog';
+import {
+  createServerPathDirectory,
+  createServerPathFile,
+  deleteServerPathEntry,
+  renameServerPathEntry,
+  uploadServerPathFiles,
+  type ServerPathEntryView,
+} from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+
+type WorkspaceFilePendingAction = 'create-directory' | 'create-file' | 'delete' | 'rename' | 'upload';
+type Confirm = ReturnType<typeof useConfirmDialog>['confirm'];
+
+export type RefreshDirectory = () => Promise<unknown>;
+
+export type WorkspaceDirectoryActionTarget = {
+  label: string;
+  path: string;
+  refresh: RefreshDirectory;
+  expand?: () => void;
+};
+
+export type WorkspaceTreeSelection = {
+  path: string;
+  createTarget: WorkspaceDirectoryActionTarget;
+};
+
+function readErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function replaceCount(text: string, count: number): string {
+  return text.replace('{count}', String(count));
+}
+
+function useWorkspaceFileActions() {
+  const [pendingAction, setPendingAction] = useState<WorkspaceFilePendingAction | null>(null);
+  const pendingActionRef = useRef<WorkspaceFilePendingAction | null>(null);
+
+  const run = async <T>(action: WorkspaceFilePendingAction, operation: () => Promise<T>): Promise<T> => {
+    if (pendingActionRef.current) {
+      throw new Error('another workspace file operation is already running');
+    }
+    pendingActionRef.current = action;
+    setPendingAction(action);
+    try {
+      return await operation();
+    } finally {
+      pendingActionRef.current = null;
+      setPendingAction(null);
+    }
+  };
+
+  return {
+    pendingAction,
+    createDirectory: (params: { basePath: string; parentPath: string; name: string }) =>
+      run('create-directory', () => createServerPathDirectory(params)),
+    createFile: (params: { basePath: string; parentPath: string; name: string }) =>
+      run('create-file', () => createServerPathFile(params)),
+    deleteEntry: (params: { basePath: string; path: string }) => run('delete', () => deleteServerPathEntry(params)),
+    renameEntry: (params: { basePath: string; path: string; name: string }) =>
+      run('rename', () => renameServerPathEntry(params)),
+    uploadFiles: (params: { basePath: string; targetPath: string; files: readonly File[]; overwrite?: boolean }) =>
+      run('upload', () => uploadServerPathFiles(params)),
+  };
+}
+
+type WorkspaceFileActions = ReturnType<typeof useWorkspaceFileActions>;
+
+async function uploadWorkspaceFiles({
+  actions,
+  confirm,
+  files,
+  rootPath,
+  target,
+}: {
+  actions: WorkspaceFileActions;
+  confirm: Confirm;
+  files: readonly File[];
+  rootPath: string;
+  target: WorkspaceDirectoryActionTarget;
+}) {
+  try {
+    let result;
+    try {
+      result = await actions.uploadFiles({
+        basePath: rootPath,
+        targetPath: target.path,
+        files,
+      });
+    } catch (error) {
+      if (!(error instanceof NextClawClientError) || error.code !== 'SERVER_PATH_FILE_EXISTS') {
+        throw error;
+      }
+      const conflicts = Array.isArray(error.details?.conflicts) ? error.details.conflicts.length : files.length;
+      const shouldReplace = await confirm({
+        title: t('chatWorkspaceUploadConflictTitle'),
+        description: replaceCount(t('chatWorkspaceUploadConflictDescription'), conflicts),
+        confirmLabel: t('chatWorkspaceReplaceFiles'),
+        variant: 'destructive',
+      });
+      if (!shouldReplace) return;
+      result = await actions.uploadFiles({
+        basePath: rootPath,
+        targetPath: target.path,
+        files,
+        overwrite: true,
+      });
+    }
+    await target.refresh();
+    toast.success(replaceCount(t('chatWorkspaceUploadSucceeded'), result.files.length));
+  } catch (error) {
+    toast.error(`${t('chatWorkspaceUploadFailed')}: ${readErrorMessage(error)}`);
+  }
+}
+
+async function deleteWorkspaceEntry({
+  actions,
+  confirm,
+  entry,
+  refresh,
+  rootPath,
+}: {
+  actions: WorkspaceFileActions;
+  confirm: Confirm;
+  entry: ServerPathEntryView;
+  refresh: RefreshDirectory;
+  rootPath: string;
+}) {
+  const isDirectory = entry.kind === 'directory';
+  const confirmed = await confirm({
+    title: t(isDirectory ? 'chatWorkspaceDeleteFolderTitle' : 'chatWorkspaceDeleteFileTitle').replace(
+      '{name}',
+      entry.name,
+    ),
+    description: t(isDirectory ? 'chatWorkspaceDeleteFolderDescription' : 'chatWorkspaceDeleteFileDescription'),
+    confirmLabel: t('chatWorkspaceDelete'),
+    variant: 'destructive',
+  });
+  if (!confirmed) return;
+  const toastId = toast.loading(t('chatWorkspaceDeleting').replace('{name}', entry.name));
+  try {
+    const deleted = await actions.deleteEntry({
+      basePath: rootPath,
+      path: entry.path,
+    });
+    await refresh();
+    toast.dismiss(toastId);
+    toast.success(t('chatWorkspaceDeleteSucceeded').replace('{name}', entry.name));
+    return deleted;
+  } catch (error) {
+    toast.dismiss(toastId);
+    toast.error(`${t('chatWorkspaceDeleteFailed').replace('{name}', entry.name)}: ${readErrorMessage(error)}`);
+    return null;
+  }
+}
+
+async function createWorkspaceEntry({
+  actions,
+  kind,
+  name,
+  rootPath,
+  setError,
+  target,
+}: {
+  actions: WorkspaceFileActions;
+  kind: 'directory' | 'file';
+  name: string;
+  rootPath: string;
+  setError: (error: string | null) => void;
+  target: WorkspaceDirectoryActionTarget;
+}) {
+  setError(null);
+  try {
+    const created = await (kind === 'file' ? actions.createFile : actions.createDirectory)({
+      basePath: rootPath,
+      parentPath: target.path,
+      name,
+    });
+    await target.refresh();
+    toast.success(t(kind === 'file' ? 'chatWorkspaceFileCreated' : 'chatWorkspaceFolderCreated'));
+    return created;
+  } catch (error) {
+    setError(
+      `${t(kind === 'file' ? 'chatWorkspaceFileCreateFailed' : 'chatWorkspaceFolderCreateFailed')}: ${readErrorMessage(error)}`,
+    );
+    return null;
+  }
+}
+
+type WorkspaceProjectFilesControllerOptions = {
+  confirm: Confirm;
+  onEntryDeleted?: (path: string) => void;
+  onEntryRenamed?: (params: { previousPath: string; path: string; label: string }) => void;
+  rootPath: string | null;
+};
+
+export function useWorkspaceProjectFilesController({
+  confirm,
+  onEntryDeleted,
+  onEntryRenamed,
+  rootPath,
+}: WorkspaceProjectFilesControllerOptions) {
+  const fileInputRef = useRef<HTMLInputElement | null>(null);
+  const actions = useWorkspaceFileActions();
+  const [createTarget, setCreateTarget] = useState<WorkspaceDirectoryActionTarget | null>(null);
+  const [createName, setCreateName] = useState('');
+  const [createKind, setCreateKind] = useState<'directory' | 'file'>('directory');
+  const [createError, setCreateError] = useState<string | null>(null);
+  const [selectedPath, setSelectedPath] = useState<string | null>(null);
+  const [selectedCreateTarget, setSelectedCreateTarget] = useState<WorkspaceDirectoryActionTarget | null>(null);
+  const [revealPath, setRevealPath] = useState<string | null>(null);
+  const [uploadTarget, setUploadTarget] = useState<WorkspaceDirectoryActionTarget | null>(null);
+
+  useEffect(() => {
+    setCreateTarget(null);
+    setSelectedPath(null);
+    setSelectedCreateTarget(null);
+    setRevealPath(null);
+    setUploadTarget(null);
+  }, [rootPath]);
+
+  const requestUpload = (target: WorkspaceDirectoryActionTarget) => {
+    setUploadTarget(target);
+    if (!fileInputRef.current) return;
+    fileInputRef.current.value = '';
+    fileInputRef.current.click();
+  };
+  const selectEntry = (selection: WorkspaceTreeSelection) => {
+    setSelectedPath(selection.path);
+    setSelectedCreateTarget(selection.createTarget);
+  };
+  const openCreate = (kind: 'directory' | 'file', target: WorkspaceDirectoryActionTarget) => {
+    target.expand?.();
+    setCreateKind(kind);
+    setCreateName('');
+    setCreateError(null);
+    setCreateTarget(target);
+  };
+  const uploadFiles = async (files: readonly File[]) => {
+    if (!rootPath || !uploadTarget || files.length === 0) return;
+    await uploadWorkspaceFiles({
+      actions,
+      confirm,
+      files,
+      rootPath,
+      target: uploadTarget,
+    });
+  };
+  const deleteEntry = async (entry: ServerPathEntryView, refresh: RefreshDirectory) => {
+    if (!rootPath) return;
+    const deleted = await deleteWorkspaceEntry({
+      actions,
+      confirm,
+      entry,
+      refresh,
+      rootPath,
+    });
+    if (deleted) onEntryDeleted?.(deleted.path);
+  };
+  const renameEntry = async (entry: ServerPathEntryView, name: string, refresh: RefreshDirectory) => {
+    if (!rootPath) return null;
+    const renamed = await actions.renameEntry({
+      basePath: rootPath,
+      path: entry.path,
+      name,
+    });
+    onEntryRenamed?.({
+      previousPath: renamed.oldPath,
+      path: renamed.path,
+      label: renamed.name,
+    });
+    await refresh();
+    setSelectedPath(renamed.path);
+    setRevealPath(renamed.path);
+    toast.success(t('chatWorkspaceRenameSucceeded').replace('{name}', renamed.name));
+    return renamed;
+  };
+  const submitCreate = async () => {
+    if (!rootPath || !createTarget) return;
+    const created = await createWorkspaceEntry({
+      actions,
+      kind: createKind,
+      name: createName,
+      rootPath,
+      setError: setCreateError,
+      target: createTarget,
+    });
+    if (!created) return;
+    setCreateTarget(null);
+    setSelectedPath(created.path);
+    setSelectedCreateTarget({
+      label: createName.trim(),
+      path: created.path,
+      refresh: createTarget.refresh,
+    });
+    setRevealPath(created.path);
+  };
+
+  return {
+    actions,
+    cancelCreateFolder: () => {
+      setCreateTarget(null);
+      setCreateName('');
+      setCreateError(null);
+    },
+    clearSelection: () => {
+      setSelectedPath(null);
+      setSelectedCreateTarget(null);
+    },
+    completeReveal: () => setRevealPath(null),
+    submitCreate,
+    createError,
+    createName,
+    createKind,
+    createTarget,
+    deleteEntry,
+    fileInputRef,
+    openCreateFile: (target: WorkspaceDirectoryActionTarget) => openCreate('file', target),
+    openCreateFolder: (target: WorkspaceDirectoryActionTarget) => openCreate('directory', target),
+    requestUpload,
+    renameEntry,
+    revealPath,
+    selectEntry,
+    selectedCreateTarget,
+    selectedPath,
+    setCreateError,
+    setCreateName,
+    uploadFiles,
+  };
+}

package/src/features/chat/features/workspace/utils/chat-workspace-file-path-mutation.utils.ts

@@ -0,0 +1,58 @@
+import type { ChatThreadSnapshot, ChatWorkspaceNavigationEntry } from '@/features/chat/stores/chat-thread.store';
+import { closeWorkspaceTabSnapshot } from '@/features/chat/features/workspace/utils/chat-thread-workspace-session.utils';
+import { replaceWorkspaceFileTabPath } from '@/features/chat/features/workspace/utils/chat-workspace-file-tab.utils';
+
+function replaceWorkspacePathPrefix(candidate: string, previousPath: string, nextPath: string): string | null {
+  if (candidate === previousPath) return nextPath;
+  if (candidate.startsWith(`${previousPath}/`) || candidate.startsWith(`${previousPath}\\`)) {
+    return `${nextPath}${candidate.slice(previousPath.length)}`;
+  }
+  return null;
+}
+
+export function createRenamedWorkspacePathPatch(
+  snapshot: ChatThreadSnapshot,
+  params: { previousPath: string; path: string; label: string },
+): Partial<ChatThreadSnapshot> | null {
+  const previousPath = params.previousPath.trim();
+  const path = params.path.trim();
+  if (!previousPath || !path || previousPath === path) return null;
+
+  const keyMap = new Map<string, string>();
+  const workspaceFileTabs = snapshot.workspaceFileTabs.map((tab) => {
+    const nextPath = replaceWorkspacePathPrefix(tab.path, previousPath, path);
+    if (!nextPath) return tab;
+    const nextTab = replaceWorkspaceFileTabPath(tab, nextPath, tab.path === previousPath ? params.label : tab.label);
+    keyMap.set(tab.key, nextTab.key);
+    return nextTab;
+  });
+  if (keyMap.size === 0) return null;
+
+  const remapEntry = (entry: ChatWorkspaceNavigationEntry): ChatWorkspaceNavigationEntry =>
+    entry.kind === 'file' && keyMap.has(entry.key) ? { kind: 'file', key: keyMap.get(entry.key)! } : entry;
+  return {
+    workspaceFileTabs,
+    activeWorkspaceFileKey: snapshot.activeWorkspaceFileKey
+      ? (keyMap.get(snapshot.activeWorkspaceFileKey) ?? snapshot.activeWorkspaceFileKey)
+      : null,
+    closedWorkspaceTabEntries: snapshot.closedWorkspaceTabEntries.map(remapEntry),
+    workspaceNavigationHistory: snapshot.workspaceNavigationHistory.map(remapEntry),
+  };
+}
+
+export function createRemovedWorkspacePathSnapshot(
+  snapshot: ChatThreadSnapshot,
+  path: string,
+): ChatThreadSnapshot | null {
+  const normalizedPath = path.trim();
+  if (!normalizedPath) return null;
+  let nextSnapshot = snapshot;
+  const matchingKeys = snapshot.workspaceFileTabs
+    .filter((tab) => replaceWorkspacePathPrefix(tab.path, normalizedPath, normalizedPath) !== null)
+    .map((tab) => tab.key);
+  for (const key of matchingKeys) {
+    const patch = closeWorkspaceTabSnapshot(nextSnapshot, { kind: 'file', key });
+    if (patch) nextSnapshot = { ...nextSnapshot, ...patch };
+  }
+  return matchingKeys.length > 0 ? nextSnapshot : null;
+}

package/src/features/chat/features/workspace/utils/chat-workspace-file-tab.utils.ts

@@ -11,15 +11,12 @@ export function createWorkspaceFileTab(
     return null;
   }
   const normalizedParentSessionKey = parentSessionKey?.trim() || null;
-  const previewViewer = action.viewMode === 'preview'
-    ? normalizeWorkspaceFilePreviewViewer(
-        path,
-        action.previewViewer ?? (action.line ? 'source' : undefined),
-      )
-    : action.previewViewer ?? null;
-  const viewIdentity = action.viewMode === 'preview' && previewViewer === 'rendered'
-    ? 'preview:rendered'
-    : action.viewMode;
+  const previewViewer =
+    action.viewMode === 'preview'
+      ? normalizeWorkspaceFilePreviewViewer(path, action.previewViewer ?? (action.line ? 'source' : undefined))
+      : (action.previewViewer ?? null);
+  const viewIdentity =
+    action.viewMode === 'preview' && previewViewer === 'rendered' ? 'preview:rendered' : action.viewMode;
   return {
     key: `${normalizedParentSessionKey ?? 'draft'}::${viewIdentity}::${path}`,
     parentSessionKey: normalizedParentSessionKey,
@@ -53,28 +50,32 @@ export function upsertWorkspaceFileTab(
     nextTabs[existingIndex] = { ...tabs[existingIndex], ...nextTab };
     return nextTabs;
   }
-  const adjacentIndex = adjacentToKey
-    ? tabs.findIndex((tab) => tab.key === adjacentToKey)
-    : -1;
+  const adjacentIndex = adjacentToKey ? tabs.findIndex((tab) => tab.key === adjacentToKey) : -1;
   if (adjacentIndex === -1) {
     return [nextTab, ...tabs];
   }
-  return [
-    ...tabs.slice(0, adjacentIndex + 1),
-    nextTab,
-    ...tabs.slice(adjacentIndex + 1),
-  ];
+  return [...tabs.slice(0, adjacentIndex + 1), nextTab, ...tabs.slice(adjacentIndex + 1)];
 }
 
-export function reparentWorkspaceFileTab(
+export function replaceWorkspaceFileTabPath(
   tab: ChatWorkspaceFileTab,
-  parentSessionKey: string,
+  path: string,
+  label?: string | null,
 ): ChatWorkspaceFileTab {
+  const viewIdentity =
+    tab.viewMode === 'preview' && tab.previewViewer === 'rendered' ? 'preview:rendered' : tab.viewMode;
+  return {
+    ...tab,
+    key: `${tab.parentSessionKey ?? 'draft'}::${viewIdentity}::${path}`,
+    path,
+    label: label?.trim() || tab.label,
+  };
+}
+
+export function reparentWorkspaceFileTab(tab: ChatWorkspaceFileTab, parentSessionKey: string): ChatWorkspaceFileTab {
   const normalizedParentSessionKey = parentSessionKey.trim();
   const identitySeparatorIndex = tab.key.indexOf('::');
-  const tabIdentity = identitySeparatorIndex >= 0
-    ? tab.key.slice(identitySeparatorIndex)
-    : `::${tab.key}`;
+  const tabIdentity = identitySeparatorIndex >= 0 ? tab.key.slice(identitySeparatorIndex) : `::${tab.key}`;
   return {
     ...tab,
     key: `${normalizedParentSessionKey}${tabIdentity}`,

package/src/features/chat/features/workspace/utils/chat-workspace-panel-layout.utils.ts

@@ -2,12 +2,21 @@ export const CHAT_WORKSPACE_PANEL_DEFAULT_WIDTH = 480;
 export const CHAT_WORKSPACE_PANEL_MIN_WIDTH = 360;
 export const CHAT_WORKSPACE_PANEL_MAX_WIDTH = 860;
 
+export const CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH = 224;
+export const CHAT_WORKSPACE_EXPLORER_MIN_WIDTH = 192;
+export const CHAT_WORKSPACE_EXPLORER_MAX_WIDTH = 400;
+export const CHAT_WORKSPACE_EXPLORER_COMPACT_THRESHOLD = 560;
+
 export function normalizeChatWorkspacePanelWidth(value: unknown): number {
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return CHAT_WORKSPACE_PANEL_DEFAULT_WIDTH;
   }
-  return Math.max(
-    CHAT_WORKSPACE_PANEL_MIN_WIDTH,
-    Math.min(CHAT_WORKSPACE_PANEL_MAX_WIDTH, value),
-  );
+  return Math.max(CHAT_WORKSPACE_PANEL_MIN_WIDTH, Math.min(CHAT_WORKSPACE_PANEL_MAX_WIDTH, value));
+}
+
+export function normalizeChatWorkspaceExplorerWidth(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH;
+  }
+  return Math.max(CHAT_WORKSPACE_EXPLORER_MIN_WIDTH, Math.min(CHAT_WORKSPACE_EXPLORER_MAX_WIDTH, value));
 }

package/src/features/chat/managers/__tests__/chat-composer-intent.manager.test.ts

@@ -1,106 +1,155 @@
-import { describe, expect, it, vi } from "vitest";
-import { ChatComposerIntentManager } from "@/features/chat/managers/chat-composer-intent.manager";
+import { describe, expect, it, vi } from 'vitest';
+import { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
 
-describe("ChatComposerIntentManager", () => {
-  it("delivers a file reference only to the targeted composer", () => {
+describe('ChatComposerIntentManager', () => {
+  it('delivers a file reference only to the targeted composer', () => {
     const manager = new ChatComposerIntentManager();
     const draftListener = vi.fn();
     const sessionListener = vi.fn();
     manager.subscribe(null, draftListener);
-    manager.subscribe("session-1", sessionListener);
+    manager.subscribe('session-1', sessionListener);
 
     manager.requestFileReference({
       targetSessionKey: null,
-      tokenKey: "docs/guide.md",
-      label: "guide.md",
+      tokenKey: 'docs/guide.md',
+      label: 'guide.md',
     });
 
     expect(draftListener).toHaveBeenCalledWith(
       expect.objectContaining({
         targetSessionKey: null,
-        tokenKey: "docs/guide.md",
-        label: "guide.md",
+        tokenKey: 'docs/guide.md',
+        label: 'guide.md',
       }),
     );
     expect(sessionListener).not.toHaveBeenCalled();
   });
 
-  it("keeps an intent pending until its matching composer mounts", () => {
+  it('keeps an intent pending until its matching composer mounts', () => {
     const manager = new ChatComposerIntentManager();
     manager.requestFileReference({
-      targetSessionKey: " session-1 ",
-      tokenKey: " src/index.ts ",
-      label: " index.ts ",
+      targetSessionKey: ' session-1 ',
+      tokenKey: ' src/index.ts ',
+      label: ' index.ts ',
     });
 
     expect(manager.consumePending(null)).toBeNull();
-    expect(manager.consumePending("session-1")).toMatchObject({
-      targetSessionKey: "session-1",
-      tokenKey: "src/index.ts",
-      label: "index.ts",
+    expect(manager.consumePending('session-1')).toMatchObject({
+      targetSessionKey: 'session-1',
+      tokenKey: 'src/index.ts',
+      label: 'index.ts',
     });
-    expect(manager.consumePending("session-1")).toBeNull();
+    expect(manager.consumePending('session-1')).toBeNull();
   });
 
-  it("ignores incomplete file references", () => {
+  it('publishes a directory reference with the workspace directory kind', () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe('session-1', listener);
+
+    manager.requestDirectoryReference({
+      targetSessionKey: 'session-1',
+      tokenKey: 'docs/designs',
+      label: 'designs',
+    });
+
+    expect(listener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'workspace_directory',
+        tokenKey: 'docs/designs',
+        label: 'designs',
+      }),
+    );
+  });
+
+  it('ignores incomplete file references', () => {
     const manager = new ChatComposerIntentManager();
     const listener = vi.fn();
     manager.subscribe(null, listener);
 
     manager.requestFileReference({
       targetSessionKey: null,
-      tokenKey: " ",
-      label: "README.md",
+      tokenKey: ' ',
+      label: 'README.md',
     });
 
     expect(listener).not.toHaveBeenCalled();
     expect(manager.consumePending(null)).toBeNull();
   });
 
-  it("publishes a source-aware excerpt with a stable content identity", () => {
+  it('publishes a source-aware excerpt with a stable content identity', () => {
     const manager = new ChatComposerIntentManager();
     const listener = vi.fn();
-    manager.subscribe("session-1", listener);
+    manager.subscribe('session-1', listener);
 
     manager.requestExcerptReference({
-      targetSessionKey: "session-1",
-      path: "docs/guide.md",
-      label: "guide.md",
-      excerpt: "selected text",
+      targetSessionKey: 'session-1',
+      path: 'docs/guide.md',
+      label: 'guide.md',
+      excerpt: 'selected text',
       startLine: 12,
       endLine: 13,
     });
 
-    expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-      kind: "workspace_excerpt",
-      path: "docs/guide.md",
-      label: "guide.md",
-      excerpt: "selected text",
-      startLine: 12,
-      endLine: 13,
-      tokenKey: expect.stringMatching(/^docs\/guide\.md#excerpt-/),
-    }));
+    expect(listener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'workspace_excerpt',
+        path: 'docs/guide.md',
+        label: 'guide.md',
+        excerpt: 'selected text',
+        startLine: 12,
+        endLine: 13,
+        tokenKey: expect.stringMatching(/^docs\/guide\.md#excerpt-/),
+      }),
+    );
   });
 
-  it("delivers an excerpt to the unmaterialized new-chat composer", () => {
+  it('delivers an excerpt to the unmaterialized new-chat composer', () => {
     const manager = new ChatComposerIntentManager();
     const draftListener = vi.fn();
     manager.subscribe(null, draftListener);
 
     manager.requestExcerptReference({
       targetSessionKey: null,
-      path: "package.json",
-      label: "package.json",
+      path: 'package.json',
+      label: 'package.json',
       excerpt: '"name": "nextclaw"',
       startLine: 2,
       endLine: 2,
     });
 
-    expect(draftListener).toHaveBeenCalledWith(expect.objectContaining({
-      targetSessionKey: null,
-      kind: "workspace_excerpt",
-      path: "package.json",
-      excerpt: '"name": "nextclaw"',
-    }));
+    expect(draftListener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        targetSessionKey: null,
+        kind: 'workspace_excerpt',
+        path: 'package.json',
+        excerpt: '"name": "nextclaw"',
+      }),
+    );
+  });
+
+  it('publishes a conversation excerpt with its source message identity', () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe('session-1', listener);
+
+    manager.requestConversationExcerptReference({
+      targetSessionKey: 'session-1',
+      messageId: 'assistant-message-1',
+      role: 'assistant',
+      label: 'AI reply',
+      excerpt: 'Keep the visible tag concise.',
+    });
+
+    expect(listener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'conversation_excerpt',
+        messageId: 'assistant-message-1',
+        role: 'assistant',
+        label: 'AI reply',
+        excerpt: 'Keep the visible tag concise.',
+        tokenKey: expect.stringMatching(/^assistant-message-1#excerpt-/),
+      }),
+    );
   });
 });