@nextclaw/ui 0.15.24 → 0.15.26

package/src/features/chat/features/input/utils/chat-inline-token-composer.utils.ts

@@ -0,0 +1,134 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import {
+  CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+  CHAT_PROJECT_TOKEN_KIND,
+  CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+  CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
+  CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+  CHAT_WORKSPACE_FILE_TOKEN_KIND,
+  type ChatInlineTokenMetadata,
+  type ChatSkillSource,
+} from '@nextclaw/shared';
+
+import { serializeChatComposerTokenText } from './chat-composer-token-protocol.utils';
+import { buildConversationExcerptInlineToken } from './chat-conversation-excerpt-token.utils';
+import { readSystemObjectResolvedReference } from './chat-system-object-reference.utils';
+
+export type ChatSkillReferenceSnapshot = {
+  ref: string;
+  name: string;
+  source: ChatSkillSource;
+  path: string;
+};
+
+function readOptionalString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function readOptionalLine(value: unknown): number | null {
+  return typeof value === 'number' && Number.isInteger(value) && value > 0
+    ? value
+    : null;
+}
+
+function dedupeInlineTokens(tokens: readonly ChatInlineTokenMetadata[]): ChatInlineTokenMetadata[] {
+  const seen = new Set<string>();
+  return tokens.filter((token) => {
+    const identity = 'ref' in token ? token.ref : token.key;
+    const dedupeKey = `${token.kind}:${identity}:${token.rawText}`;
+    if (seen.has(dedupeKey)) return false;
+    seen.add(dedupeKey);
+    return true;
+  });
+}
+
+function buildWorkspaceExcerptToken(
+  node: Extract<ChatComposerNode, { type: 'token' }>,
+  rawText: string,
+): ChatInlineTokenMetadata | null {
+  const path = readOptionalString(node.data?.path);
+  const excerpt = readOptionalString(node.data?.excerpt);
+  if (!path || !excerpt) return null;
+  return {
+    kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+    key: node.tokenKey,
+    path,
+    label: node.label,
+    excerpt,
+    startLine: readOptionalLine(node.data?.startLine),
+    endLine: readOptionalLine(node.data?.endLine),
+    rawText,
+  };
+}
+
+function buildStructuredReferenceToken(
+  node: Extract<ChatComposerNode, { type: 'token' }>,
+  rawText: string,
+): ChatInlineTokenMetadata | null | undefined {
+  if (node.tokenKind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
+    return buildWorkspaceExcerptToken(node, rawText);
+  }
+  if (node.tokenKind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
+    return buildConversationExcerptInlineToken(node, rawText);
+  }
+  if (node.tokenKind === CHAT_SYSTEM_OBJECT_TOKEN_KIND) {
+    const reference = readSystemObjectResolvedReference(node.data?.reference);
+    return reference?.uri === node.tokenKey
+      ? {
+        kind: CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+        key: node.tokenKey,
+        label: node.label,
+        rawText,
+        reference,
+      }
+      : null;
+  }
+  return undefined;
+}
+
+export function buildInlineTokensFromComposer(
+  nodes: readonly ChatComposerNode[],
+  skillRecords: readonly ChatSkillReferenceSnapshot[] = [],
+): ChatInlineTokenMetadata[] {
+  const skillByRef = new Map(skillRecords.map((record) => [record.ref, record]));
+  const tokens: ChatInlineTokenMetadata[] = [];
+  for (const node of nodes) {
+    if (node.type !== 'token') continue;
+    const rawText = serializeChatComposerTokenText(node);
+    if (!rawText) continue;
+    if (node.tokenKind === 'skill') {
+      const skill = skillByRef.get(node.tokenKey);
+      if (skill?.path.trim()) {
+        tokens.push({
+          kind: 'skill',
+          ref: skill.ref,
+          name: skill.name,
+          source: skill.source,
+          path: skill.path,
+          label: node.label,
+          rawText,
+        });
+      }
+      continue;
+    }
+    if (node.tokenKind === CHAT_PROJECT_TOKEN_KIND) {
+      tokens.push({ kind: CHAT_PROJECT_TOKEN_KIND, key: node.tokenKey, label: node.label, rawText });
+      continue;
+    }
+    const structuredReference = buildStructuredReferenceToken(node, rawText);
+    if (structuredReference !== undefined) {
+      if (structuredReference) tokens.push(structuredReference);
+      continue;
+    }
+    if (
+      node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND ||
+      node.tokenKind === CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND
+    ) {
+      const workspaceKind = node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND
+        ? CHAT_WORKSPACE_FILE_TOKEN_KIND
+        : CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
+      tokens.push({ kind: workspaceKind, key: node.tokenKey, label: node.label, rawText });
+    }
+  }
+  return dedupeInlineTokens(tokens);
+}

package/src/features/chat/features/input/utils/chat-inline-token.utils.ts

@@ -1,18 +1,23 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import {
   CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
   CHAT_INLINE_TOKENS_METADATA_KEY,
   CHAT_INLINE_TOKENS_SCHEMA_VERSION,
   CHAT_PROJECT_TOKEN_KIND,
+  CHAT_SYSTEM_OBJECT_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
   type ChatInlineTokenMetadata,
   type ChatInlineTokensMetadata,
   type ChatSkillSource,
+  type SystemObjectResolvedReference,
 } from '@nextclaw/shared';
-import { serializeChatComposerTokenText } from './chat-composer-token-protocol.utils';
-import { buildConversationExcerptInlineToken, readConversationExcerptInlineToken } from './chat-conversation-excerpt-token.utils';
+import { readConversationExcerptInlineToken } from './chat-conversation-excerpt-token.utils';
+import { readSystemObjectResolvedReference } from './chat-system-object-reference.utils';
+export {
+  buildInlineTokensFromComposer,
+  type ChatSkillReferenceSnapshot,
+} from './chat-inline-token-composer.utils';
 
 export { CHAT_INLINE_TOKENS_METADATA_KEY };
 const CHAT_PANEL_APP_TOKEN_PREFIX = '@panel-app:';
@@ -20,13 +25,7 @@ const CHAT_PANEL_APP_TOKEN_PATTERN = /@panel-app:([A-Za-z0-9_-]+)/g;
 const CHAT_PROJECT_TOKEN_PATTERN = /@project:([^\s]+)/g;
 const CHAT_WORKSPACE_FILE_TOKEN_PATTERN = /@file:([^\s]+)/g;
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PATTERN = /@folder:([^\s]+)/g;
-
-export type ChatSkillReferenceSnapshot = {
-  ref: string;
-  name: string;
-  source: ChatSkillSource;
-  path: string;
-};
+const CHAT_SYSTEM_OBJECT_TOKEN_PATTERN = /@object:([^\s]+)/g;
 
 export type ChatInlineTokenSource =
   | {
@@ -62,6 +61,13 @@ export type ChatInlineTokenSource =
       key: string;
       label: string;
       rawText: string;
+    }
+  | {
+      kind: typeof CHAT_SYSTEM_OBJECT_TOKEN_KIND;
+      key: string;
+      label: string;
+      rawText: string;
+      reference: SystemObjectResolvedReference;
     };
 
 export function resolveWorkspaceReferencePath(params: {
@@ -114,100 +120,10 @@ function dedupeInlineTokens<T extends ChatInlineTokenSource>(tokens: readonly T[
   return output;
 }
 
-function appendWorkspaceExcerptToken(
-  tokens: ChatInlineTokenMetadata[],
-  node: Extract<ChatComposerNode, { type: 'token' }>,
-  rawText: string,
-): void {
-  const path = readOptionalString(node.data?.path);
-  const excerpt = readOptionalString(node.data?.excerpt);
-  if (!path || !excerpt) return;
-  tokens.push({
-    kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
-    key: node.tokenKey,
-    path,
-    label: node.label,
-    excerpt,
-    startLine: readOptionalLine(node.data?.startLine),
-    endLine: readOptionalLine(node.data?.endLine),
-    rawText,
-  });
-}
-
-export function buildInlineTokensFromComposer(
-  nodes: readonly ChatComposerNode[],
-  skillRecords: readonly ChatSkillReferenceSnapshot[] = [],
-): ChatInlineTokenMetadata[] {
-  const skillByRef = new Map(skillRecords.map((record) => [record.ref, record]));
-  const tokens: ChatInlineTokenMetadata[] = [];
-  for (const node of nodes) {
-    if (node.type !== 'token') {
-      continue;
-    }
-    if (
-      node.tokenKind !== 'skill' &&
-      node.tokenKind !== CHAT_PROJECT_TOKEN_KIND &&
-      node.tokenKind !== CHAT_WORKSPACE_FILE_TOKEN_KIND &&
-      node.tokenKind !== CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND &&
-      node.tokenKind !== CHAT_WORKSPACE_EXCERPT_TOKEN_KIND &&
-      node.tokenKind !== CHAT_CONVERSATION_EXCERPT_TOKEN_KIND
-    ) {
-      continue;
-    }
-    const rawText = serializeChatComposerTokenText(node);
-    if (!rawText) {
-      continue;
-    }
-    if (node.tokenKind === 'skill') {
-      const skill = skillByRef.get(node.tokenKey);
-      if (!skill?.path.trim()) {
-        continue;
-      }
-      tokens.push({
-        kind: 'skill',
-        ref: skill.ref,
-        name: skill.name,
-        source: skill.source,
-        path: skill.path,
-        label: node.label,
-        rawText,
-      });
-      continue;
-    }
-    if (node.tokenKind === CHAT_PROJECT_TOKEN_KIND) {
-      tokens.push({
-        kind: CHAT_PROJECT_TOKEN_KIND,
-        key: node.tokenKey,
-        label: node.label,
-        rawText,
-      });
-      continue;
-    }
-    if (node.tokenKind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
-      appendWorkspaceExcerptToken(tokens, node, rawText);
-      continue;
-    }
-    if (node.tokenKind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
-      const token = buildConversationExcerptInlineToken(node, rawText);
-      if (token) tokens.push(token);
-      continue;
-    }
-    const workspaceKind = node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND
-      ? CHAT_WORKSPACE_FILE_TOKEN_KIND
-      : CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
-    tokens.push({
-      kind: workspaceKind,
-      key: node.tokenKey,
-      label: node.label,
-      rawText,
-    });
-  }
-  return dedupeInlineTokens(tokens);
-}
-
 function appendEncodedKeyTokens(params: {
   kind:
     | typeof CHAT_PROJECT_TOKEN_KIND
+    | typeof CHAT_SYSTEM_OBJECT_TOKEN_KIND
     | typeof CHAT_WORKSPACE_FILE_TOKEN_KIND
     | typeof CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
   pattern: RegExp;
@@ -255,6 +171,12 @@ export function buildInlineTokensFromTextProtocol(text: string): ChatInlineToken
     text,
     tokens,
   });
+  appendEncodedKeyTokens({
+    kind: CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+    pattern: CHAT_SYSTEM_OBJECT_TOKEN_PATTERN,
+    text,
+    tokens,
+  });
   appendEncodedKeyTokens({
     kind: CHAT_WORKSPACE_FILE_TOKEN_KIND,
     pattern: CHAT_WORKSPACE_FILE_TOKEN_PATTERN,
@@ -340,6 +262,13 @@ function readInlineTokenEntry(entry: unknown): ChatInlineTokenSource | null {
   if (kind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
     return readConversationExcerptInlineToken({ entry, label, rawText });
   }
+  if (kind === CHAT_SYSTEM_OBJECT_TOKEN_KIND) {
+    const key = readOptionalString(entry.key);
+    const reference = readSystemObjectResolvedReference(entry.reference);
+    return key && reference && reference.uri === key
+      ? { kind, key, label, rawText, reference }
+      : null;
+  }
   const key = readOptionalString(entry.key);
   return key ? { kind, key, rawText, label } : null;
 }

package/src/features/chat/features/input/utils/chat-system-object-reference.utils.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { CHAT_SYSTEM_OBJECT_TOKEN_KIND, type SystemObjectResolvedReference } from '@nextclaw/shared';
+import {
+  appendSystemObjectReferenceToken,
+  readSystemObjectReferenceFromToken,
+} from './chat-system-object-reference.utils';
+
+const reference: SystemObjectResolvedReference = {
+  uri: 'nextclaw://objects/cron-job/cron-1',
+  objectType: 'cron-job',
+  objectId: 'cron-1',
+  label: 'Daily review',
+  description: 'Review reports',
+  updatedAt: '2026-08-11T00:00:00.000Z',
+  version: 'a'.repeat(64),
+  assetUri: 'asset://store/cron-1',
+  fileName: 'daily-review.md',
+  mimeType: 'text/markdown',
+  sizeBytes: 42,
+};
+
+describe('system object reference composer utilities', () => {
+  it('creates one visible generic token and deduplicates the same snapshot', () => {
+    const first = appendSystemObjectReferenceToken([], reference);
+    const second = appendSystemObjectReferenceToken(first, reference);
+
+    expect(second).toHaveLength(first.length);
+    expect(second.find((node) => node.type === 'token')).toMatchObject({
+      tokenKind: CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+      tokenKey: reference.uri,
+      label: reference.label,
+    });
+    expect(readSystemObjectReferenceFromToken(second[0]!)).toEqual(reference);
+  });
+
+  it('rejects metadata whose URI identity disagrees with its object fields', () => {
+    const [node] = appendSystemObjectReferenceToken([], {
+      ...reference,
+      objectId: 'different-cron',
+    });
+
+    expect(readSystemObjectReferenceFromToken(node!)).toBeNull();
+  });
+});

package/src/features/chat/features/input/utils/chat-system-object-reference.utils.ts

@@ -0,0 +1,46 @@
+import {
+  createChatComposerTokenNode,
+  normalizeChatComposerNodes,
+  type ChatComposerNode,
+} from '@nextclaw/agent-chat-ui';
+import {
+  CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+  readSystemObjectResolvedReference,
+  type SystemObjectResolvedReference,
+} from '@nextclaw/shared';
+
+export { readSystemObjectResolvedReference } from '@nextclaw/shared';
+
+export function createSystemObjectReferenceTokenNode(
+  reference: SystemObjectResolvedReference,
+): ChatComposerNode {
+  return createChatComposerTokenNode({
+    tokenKind: CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+    tokenKey: reference.uri,
+    label: reference.label,
+    data: { reference },
+  });
+}
+
+export function appendSystemObjectReferenceToken(
+  nodes: readonly ChatComposerNode[],
+  reference: SystemObjectResolvedReference,
+): ChatComposerNode[] {
+  const exists = nodes.some((node) =>
+    node.type === 'token' &&
+    node.tokenKind === CHAT_SYSTEM_OBJECT_TOKEN_KIND &&
+    node.tokenKey === reference.uri &&
+    readSystemObjectResolvedReference(node.data?.reference)?.version === reference.version
+  );
+  return exists
+    ? normalizeChatComposerNodes([...nodes])
+    : normalizeChatComposerNodes([...nodes, createSystemObjectReferenceTokenNode(reference)]);
+}
+
+export function readSystemObjectReferenceFromToken(
+  node: ChatComposerNode,
+): SystemObjectResolvedReference | null {
+  return node.type === 'token' && node.tokenKind === CHAT_SYSTEM_OBJECT_TOKEN_KIND
+    ? readSystemObjectResolvedReference(node.data?.reference)
+    : null;
+}

package/src/features/chat/features/ncp/hooks/__tests__/use-hydrated-ncp-agent.test.tsx

@@ -248,10 +248,9 @@ describe("useHydratedNcpAgent", () => {
       );
 
       await vi.waitFor(() => {
-        expect(result.current.hydrateError?.message).toBe(
-          "stream disconnected",
-        );
+        expect(mocks.stream).toHaveBeenCalledTimes(1);
       });
+      expect(result.current.hydrateError).toBeNull();
       await act(async () => {
         await vi.runOnlyPendingTimersAsync();
       });
@@ -268,4 +267,42 @@ describe("useHydratedNcpAgent", () => {
       vi.useRealTimers();
     }
   });
+
+  it("reports a stream error only after repeated immediate recovery failures", async () => {
+    vi.useFakeTimers();
+    try {
+      const client = {
+        stop: mocks.stop.mockResolvedValue(undefined),
+        stream: mocks.stream.mockRejectedValue(new Error("stream unavailable")),
+        subscribe: vi.fn(() => () => {}),
+        send: mocks.send,
+      } as unknown as NcpAgentClientEndpoint;
+      const loadSeed = vi.fn().mockResolvedValue({ messages: [], status: "idle" });
+      const { result } = renderHook(() =>
+        useHydratedNcpAgent({
+          sessionId: "session-offline",
+          client: client as never,
+          loadSeed,
+        }),
+      );
+
+      await vi.waitFor(() => expect(mocks.stream).toHaveBeenCalledTimes(1));
+      expect(result.current.hydrateError).toBeNull();
+
+      await act(async () => {
+        await vi.runOnlyPendingTimersAsync();
+      });
+      await vi.waitFor(() => expect(mocks.stream).toHaveBeenCalledTimes(2));
+      expect(result.current.hydrateError).toBeNull();
+
+      await act(async () => {
+        await vi.runOnlyPendingTimersAsync();
+      });
+      await vi.waitFor(() => {
+        expect(result.current.hydrateError?.message).toBe("stream unavailable");
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });

package/src/features/chat/features/workspace/components/__tests__/chat-session-workspace-file-preview.selection.test.tsx

@@ -0,0 +1,66 @@
+import type { ReactNode } from "react";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ChatSessionWorkspaceFilePreview } from "@/features/chat/features/workspace/components/chat-session-workspace-file-preview";
+
+const onTextExcerptAdd = vi.fn();
+
+vi.mock("@/shared/hooks/use-server-path-read", () => ({
+  useServerPathRead: () => ({
+    isLoading: false,
+    error: null,
+    data: {
+      kind: "markdown",
+      resolvedPath: "/Users/demo/.nextclaw/workspace/BOOT.md",
+      startLine: 1,
+      text: "Add short, explicit startup instructions.",
+      truncated: false,
+    },
+  }),
+}));
+
+vi.mock("@/shared/hooks/use-server-path-browse", () => ({
+  useServerPathBrowse: () => ({ isLoading: false, error: new Error("not a directory"), data: null }),
+}));
+
+vi.mock("@nextclaw/agent-chat-ui", () => ({
+  ChatMessageMarkdown: ({ text }: { text: string }) => <div>{text}</div>,
+  FileOperationCodeSurface: () => null,
+  ChatTextSelectionAction: ({ children, onAddToChat }: { children: ReactNode; onAddToChat: (value: { text: string }) => void }) => (
+    <div>
+      {children}
+      <button type="button" onClick={() => onAddToChat({ text: "Add short, explicit startup instructions." })}>
+        select excerpt
+      </button>
+    </div>
+  ),
+}));
+
+describe("ChatSessionWorkspaceFilePreview selection", () => {
+  it("uses the resolved absolute path when a shell-style workspace root cannot be compared in the browser", () => {
+    render(
+      <ChatSessionWorkspaceFilePreview
+        file={{
+          key: "boot",
+          parentSessionKey: null,
+          path: "/Users/demo/.nextclaw/workspace/BOOT.md",
+          label: "BOOT.md",
+          viewMode: "preview",
+        }}
+        sessionProjectRoot="~/.nextclaw/workspace"
+        sessionWorkingDir="~/.nextclaw/workspace"
+        onFileOpen={vi.fn()}
+        onTextExcerptAdd={onTextExcerptAdd}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "select excerpt" }));
+    expect(onTextExcerptAdd).toHaveBeenCalledWith({
+      path: "/Users/demo/.nextclaw/workspace/BOOT.md",
+      label: "BOOT.md",
+      excerpt: "Add short, explicit startup instructions.",
+      startLine: 1,
+      endLine: 1,
+    });
+  });
+});

package/src/features/chat/features/workspace/components/__tests__/chat-session-workspace-file-preview.test.tsx

@@ -1,4 +1,5 @@
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type {
   ChatFileOpenActionViewModel,
@@ -38,6 +39,7 @@ vi.mock("@/shared/hooks/use-server-path-browse", () => ({
 }));
 
 vi.mock("@nextclaw/agent-chat-ui", () => ({
+  ChatTextSelectionAction: ({ children }: { children: ReactNode }) => children,
   ChatMessageMarkdown: ({ text }: { text: string }) => (
     <div data-testid="markdown-preview">{text}</div>
   ),
@@ -56,6 +58,16 @@ vi.mock("@nextclaw/agent-chat-ui", () => ({
   ),
 }));
 
+vi.mock("@/features/chat/components/providers/chat-presenter.provider", () => ({
+  usePresenter: () => ({
+    chatThreadManager: { removeWorkspacePath: vi.fn(), renameWorkspacePath: vi.fn() },
+    chatComposerIntentManager: {
+      requestDirectoryReference: vi.fn(),
+      requestFileReference: vi.fn(),
+    },
+  }),
+}));
+
 vi.mock("docx-preview", () => ({
   renderAsync: (...args: unknown[]) => renderDocxMock(...args),
 }));
@@ -787,7 +799,7 @@ describe("ChatSessionWorkspaceFilePreview breadcrumbs", () => {
       screen.getByTestId("workspace-file-breadcrumb-scroll").className,
     ).toContain("py-1.5");
     expect(
-      screen.getByTestId("workspace-file-breadcrumbs").className,
+      screen.getByTestId("workspace-file-breadcrumb-scroll").className,
     ).toContain("workspace-horizontal-scrollbar");
   });