@nextclaw/ui 0.15.21 → 0.15.23

package/src/features/chat/features/message/utils/__tests__/chat-message-timeline.utils.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it } from "vitest";
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+import { CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY } from "@nextclaw/shared";
+import {
+  buildChatMessageTimelineItems,
+  isVisibleChatMessage,
+  projectVisibleChatMessages,
+} from "@/features/chat/features/message/utils/chat-message-timeline.utils";
+
+const visibleMessage = {
+  id: "assistant-visible",
+  sessionId: "session-1",
+  role: "assistant",
+  status: "final",
+  timestamp: "2026-08-07T00:00:00.000Z",
+  parts: [{ type: "text", text: "visible" }],
+} satisfies NcpMessage;
+
+describe("chat message timeline visibility", () => {
+  it("places context compaction between surrounding visible messages", () => {
+    const afterMessage = {
+      ...visibleMessage,
+      id: "assistant-after",
+      timestamp: "2026-08-07T00:02:00.000Z",
+    };
+    const compactionMessage = {
+      ...visibleMessage,
+      id: "context-compaction-1",
+      role: "service" as const,
+      timestamp: "2026-08-07T00:01:00.000Z",
+      metadata: {
+        nextclaw_timeline_kind: "context_compaction",
+        checkpoint: {
+          id: "ctx-1",
+          status: "compressed",
+          summary: "Compressed earlier context",
+          coveredMessageCount: 8,
+          coveredSessionMessageCount: 8,
+          originalEstimatedTokens: 76_000,
+          projectedEstimatedTokens: 51_000,
+          createdAt: "2026-08-07T00:00:50.000Z",
+          updatedAt: "2026-08-07T00:01:00.000Z",
+        },
+      },
+    } satisfies NcpMessage;
+
+    const items = buildChatMessageTimelineItems({
+      rawMessages: [visibleMessage, compactionMessage, afterMessage],
+      messages: [
+        { id: visibleMessage.id } as never,
+        { id: afterMessage.id } as never,
+      ],
+    });
+
+    expect(items.map((item) => item.kind)).toEqual([
+      "message",
+      "compaction",
+      "message",
+    ]);
+  });
+
+  it("hides internal and legacy silent messages", () => {
+    expect(isVisibleChatMessage({
+      ...visibleMessage,
+      metadata: { [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden" },
+    })).toBe(false);
+    expect(isVisibleChatMessage({
+      ...visibleMessage,
+      parts: [{ type: "text", text: "\\n\\n<noreply/>" }],
+    })).toBe(false);
+    expect(isVisibleChatMessage(visibleMessage)).toBe(true);
+  });
+
+  it("projects continued assistant output into the interrupted message", () => {
+    const messages = projectVisibleChatMessages([
+      {
+        ...visibleMessage,
+        lifecycle: { startedAt: "2026-08-07T00:00:01.000Z" },
+        parts: [{ type: "text", text: "half" }],
+        status: "error",
+      },
+      {
+        id: "continue-1",
+        sessionId: "session-1",
+        role: "user",
+        status: "final",
+        timestamp: "2026-08-07T00:01:00.000Z",
+        parts: [{ type: "text", text: "continue" }],
+        metadata: {
+          [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+          [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: "assistant-visible",
+        },
+      },
+      {
+        ...visibleMessage,
+        id: "assistant-continuation",
+        lifecycle: { endedAt: "2026-08-07T00:02:00.000Z" },
+        parts: [{ type: "text", text: " done" }],
+        timestamp: "2026-08-07T00:01:01.000Z",
+      },
+    ]);
+
+    expect(messages).toEqual([
+      expect.objectContaining({
+        id: "assistant-visible",
+        status: "final",
+        parts: [
+          { type: "text", text: "half" },
+          { type: "text", text: " done" },
+        ],
+        lifecycle: {
+          startedAt: "2026-08-07T00:00:01.000Z",
+          endedAt: "2026-08-07T00:02:00.000Z",
+        },
+      }),
+    ]);
+  });
+
+  it("keeps repeated continuations in one canonical assistant message", () => {
+    const continuationPrompt = (id: string, targetId: string): NcpMessage => ({
+      id,
+      sessionId: "session-1",
+      role: "user",
+      status: "final",
+      timestamp: "2026-08-07T00:01:00.000Z",
+      parts: [{ type: "text", text: "continue" }],
+      metadata: {
+        [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+        [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: targetId,
+      },
+    });
+    const messages = projectVisibleChatMessages([
+      { ...visibleMessage, parts: [{ type: "text", text: "one" }] },
+      continuationPrompt("continue-1", "assistant-visible"),
+      { ...visibleMessage, id: "assistant-2", parts: [{ type: "text", text: " two" }] },
+      continuationPrompt("continue-2", "assistant-2"),
+      { ...visibleMessage, id: "assistant-3", parts: [{ type: "text", text: " three" }] },
+    ]);
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toMatchObject({
+      id: "assistant-visible",
+      parts: [
+        { type: "text", text: "one" },
+        { type: "text", text: " two" },
+        { type: "text", text: " three" },
+      ],
+    });
+  });
+
+  it("marks the interrupted message pending before continuation output arrives", () => {
+    const messages = projectVisibleChatMessages([
+      visibleMessage,
+      {
+        id: "continue-1",
+        sessionId: "session-1",
+        role: "user",
+        status: "final",
+        timestamp: "2026-08-07T00:01:00.000Z",
+        parts: [],
+        metadata: {
+          [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+          [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: "assistant-visible",
+        },
+      },
+    ], { continuationRunning: true });
+
+    expect(messages).toEqual([
+      expect.objectContaining({ id: "assistant-visible", status: "pending" }),
+    ]);
+  });
+
+  it("never merges unrelated adjacent assistant messages", () => {
+    expect(projectVisibleChatMessages([
+      visibleMessage,
+      { ...visibleMessage, id: "assistant-unrelated" },
+    ]).map((message) => message.id)).toEqual([
+      "assistant-visible",
+      "assistant-unrelated",
+    ]);
+  });
+
+  it("rejects a malformed continuation target that is not an assistant", () => {
+    const userMessage = { ...visibleMessage, id: "user-1", role: "user" as const };
+    const hiddenPrompt = {
+      ...userMessage,
+      id: "continue-1",
+      metadata: {
+        [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+        [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: "user-1",
+      },
+    };
+
+    expect(projectVisibleChatMessages([
+      userMessage,
+      hiddenPrompt,
+      { ...visibleMessage, id: "assistant-1" },
+    ]).map((message) => message.id)).toEqual(["user-1", "assistant-1"]);
+  });
+});

package/src/features/chat/features/message/utils/__tests__/chat-message.utils.test.ts

@@ -90,6 +90,32 @@ it("preserves the prepared execution summary on the message view model", () => {
   });
 });
 
+it("maps context compaction extensions into stable process parts", () => {
+  const adapted = adapt([{
+    id: "assistant-compaction",
+    role: "assistant",
+    parts: [{
+      type: "extension",
+      extensionType: "nextclaw.context-compaction",
+      data: {
+        id: "context-compaction-message-1",
+        checkpoint: { id: "checkpoint-1", status: "compressed" },
+      },
+    }],
+  }]);
+
+  expect(adapted[0]?.parts).toEqual([{
+    type: "custom",
+    id: "context-compaction-message-1",
+    customType: "nextclaw.context-compaction",
+    data: {
+      id: "context-compaction-message-1",
+      checkpoint: { id: "checkpoint-1", status: "compressed" },
+    },
+    process: true,
+  }]);
+});
+
 it("maps tool lifecycle statuses into visible card state feedback", () => {
   const adapted = adapt([
     {

package/src/features/chat/features/message/utils/chat-message-action-targets.utils.ts

@@ -0,0 +1,28 @@
+import type { NcpMessage } from '@nextclaw/ncp';
+
+import { projectVisibleChatMessages } from '@/features/chat/features/message/utils/chat-message-timeline.utils';
+
+export type ChatMessageActionTargets = {
+  readonly continuationAssistantMessageId: string | null;
+  readonly editableUserMessageId: string | null;
+};
+
+export function resolveChatMessageActionTargets(params: {
+  readonly canContinue: boolean;
+  readonly isBusy: boolean;
+  readonly messages: readonly NcpMessage[];
+}): ChatMessageActionTargets {
+  const visibleMessages = projectVisibleChatMessages(params.messages);
+  const editableUserMessage = visibleMessages.findLast(
+    (message) => message.role === 'user',
+  );
+  const lastVisibleMessage = visibleMessages.at(-1);
+  return {
+    continuationAssistantMessageId:
+      params.canContinue && lastVisibleMessage?.role === 'assistant'
+        ? lastVisibleMessage.id
+        : null,
+    editableUserMessageId:
+      params.isBusy ? null : editableUserMessage?.id ?? null,
+  };
+}

package/src/features/chat/features/message/utils/chat-message-part.utils.ts

@@ -27,6 +27,10 @@ import type {
   ChatMessageAdapterTexts,
   ChatMessagePartSource,
 } from "@/features/chat/types/chat-message.types";
+import {
+  CONTEXT_COMPACTION_PART_EXTENSION_TYPE,
+  type ContextCompactionPartData,
+} from "@/features/chat/features/message/utils/chat-message-timeline.utils";
 
 export type {
   ChatMessageAdapterTexts,
@@ -241,6 +245,37 @@ function isToolInvocationPart(
   );
 }
 
+function buildExtensionPart(
+  part: Extract<ChatMessagePartSource, { type: "extension" }>,
+): Extract<ChatMessagePartViewModel, { type: "custom" }> | null {
+  if (part.extensionType !== CONTEXT_COMPACTION_PART_EXTENSION_TYPE) {
+    return null;
+  }
+  const data = part.data as Partial<ContextCompactionPartData> | null;
+  if (!data || typeof data.id !== "string" || !data.checkpoint) {
+    return null;
+  }
+  return {
+    type: "custom",
+    id: data.id,
+    customType: part.extensionType,
+    data: {
+      id: data.id,
+      checkpoint: data.checkpoint,
+    } satisfies ContextCompactionPartData,
+    process: true,
+  };
+}
+
+function isExtensionPart(
+  part: ChatMessagePartSource,
+): part is Extract<ChatMessagePartSource, { type: "extension" }> {
+  return part.type === "extension" &&
+    "extensionType" in part &&
+    typeof part.extensionType === "string" &&
+    "data" in part;
+}
+
 export function adaptChatMessagePart(
   params: ChatMessagePartAdapterParams,
 ): ChatMessagePartViewModel | null {
@@ -257,5 +292,8 @@ export function adaptChatMessagePart(
   if (isToolInvocationPart(part)) {
     return buildToolInvocationPart(part, texts);
   }
+  if (isExtensionPart(part)) {
+    return buildExtensionPart(part);
+  }
   return buildUnknownPart(part, texts);
 }

package/src/features/chat/features/message/utils/chat-message-texts.utils.ts

@@ -149,6 +149,7 @@ export function buildChatMessageTexts(
     copiedCodeLabel: t("chatCodeCopied"),
     copyMessageLabel: t("chatMessageCopy"),
     copiedMessageLabel: t("chatMessageCopied"),
+    excerptCharacterCountTemplate: t("chatWorkspaceExcerptCharacterCount"),
     mermaidDiagramLabel: t("chatMermaidDiagram"),
     mermaidExpandLabel: t("chatMermaidExpand"),
     mermaidLoadingLabel: t("chatMermaidLoading"),

package/src/features/chat/features/message/utils/chat-message-timeline.utils.ts

@@ -1,4 +1,8 @@
-import type { NcpMessage } from "@nextclaw/ncp";
+import { isHiddenNcpMessage, type NcpMessage } from "@nextclaw/ncp";
+import {
+  CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY,
+  isSilentReplyNcpMessage,
+} from "@nextclaw/shared";
 import type { ChatMessageViewModel } from "@nextclaw/agent-chat-ui";
 import {
   readContextCompactionTimeline,
@@ -6,6 +10,13 @@ import {
 } from "@/features/chat/features/session/utils/ncp-session-context-metadata.utils";
 
 const INHERITED_FROM_SESSION_METADATA_KEY = "inherited_from_session_id";
+export const CONTEXT_COMPACTION_PART_EXTENSION_TYPE =
+  "nextclaw.context-compaction";
+
+export type ContextCompactionPartData = {
+  id: string;
+  checkpoint: ContextCompactionTimelineView;
+};
 
 export type ContextInheritanceTimelineView = {
   sourceSessionId: string;
@@ -48,11 +59,195 @@ function readInheritedSourceSessionId(message: NcpMessage): string | null {
 
 export function isVisibleChatMessage(message: NcpMessage): boolean {
   return (
+    !isHiddenNcpMessage(message) &&
+    !isSilentReplyNcpMessage(message) &&
     !readContextCompactionTimeline(message) &&
     !readInheritedSourceSessionId(message)
   );
 }
 
+function readContinuationTargetMessageId(message: NcpMessage): string | null {
+  const value =
+    message.metadata?.[CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function appendContinuationParts(
+  targetParts: NcpMessage["parts"],
+  continuationParts: NcpMessage["parts"],
+): NcpMessage["parts"] {
+  return [...targetParts, ...continuationParts];
+}
+
+function mergeAssistantContinuation(
+  target: NcpMessage,
+  continuation: NcpMessage,
+): NcpMessage {
+  const startedAt = target.lifecycle?.startedAt ?? continuation.lifecycle?.startedAt;
+  const endedAt = continuation.lifecycle?.endedAt ?? target.lifecycle?.endedAt;
+  return {
+    ...target,
+    status: continuation.status,
+    parts: appendContinuationParts(target.parts, continuation.parts),
+    lifecycle: startedAt || endedAt ? { startedAt, endedAt } : undefined,
+    metadata:
+      target.metadata || continuation.metadata
+        ? { ...target.metadata, ...continuation.metadata }
+        : undefined,
+  };
+}
+
+type VisibleChatMessageProjection = {
+  messages: NcpMessage[];
+  inlineCompactionMessageIds: Set<string>;
+};
+
+type ProjectedMessagePartAnchor = {
+  messageIndex: number;
+  partOffset: number;
+};
+
+type InlineCompactionPlacement = {
+  boundaryIndex: number;
+  checkpoint: ContextCompactionTimelineView;
+  messageIndex: number;
+  rawOrder: number;
+  serviceMessageId: string;
+};
+
+function projectVisibleChatMessageState(
+  rawMessages: readonly NcpMessage[],
+  options: { continuationRunning?: boolean } = {},
+): VisibleChatMessageProjection {
+  const messages: NcpMessage[] = [];
+  const projectedIndexByMessageId = new Map<string, number>();
+  const partAnchorByMessageId = new Map<string, ProjectedMessagePartAnchor>();
+  const partCountByMessageId = new Map(
+    rawMessages.map((message) => [message.id, message.parts.length]),
+  );
+  const inlineCompactions: InlineCompactionPlacement[] = [];
+  const inlineCompactionMessageIds = new Set<string>();
+  let pendingContinuationTargetId: string | null = null;
+
+  rawMessages.forEach((message, rawOrder) => {
+    const checkpoint = readContextCompactionTimeline(message);
+    const explicitMessageId = checkpoint?.continuationMessageId;
+    const legacyPreRunMessageId = checkpoint?.phase === "pre-run"
+      ? pendingContinuationTargetId
+      : null;
+    const placementMessageId = explicitMessageId ?? legacyPreRunMessageId;
+    const coveredPartCount = checkpoint?.continuationMessageCoveredPartCount
+      ?? (legacyPreRunMessageId
+        ? partCountByMessageId.get(legacyPreRunMessageId)
+        : undefined);
+    const anchor = placementMessageId
+      ? partAnchorByMessageId.get(placementMessageId)
+      : undefined;
+    if (
+      (checkpoint?.phase === "mid-run" || checkpoint?.phase === "pre-run") &&
+      anchor &&
+      coveredPartCount !== undefined
+    ) {
+      inlineCompactions.push({
+        boundaryIndex: anchor.partOffset + coveredPartCount,
+        checkpoint,
+        messageIndex: anchor.messageIndex,
+        rawOrder,
+        serviceMessageId: message.id,
+      });
+      inlineCompactionMessageIds.add(message.id);
+      return;
+    }
+    const continuationTargetId = readContinuationTargetMessageId(message);
+    if (continuationTargetId && isHiddenNcpMessage(message)) {
+      pendingContinuationTargetId = continuationTargetId;
+      return;
+    }
+    if (!isVisibleChatMessage(message)) {
+      return;
+    }
+    const targetIndex = pendingContinuationTargetId && message.role === "assistant"
+      ? projectedIndexByMessageId.get(pendingContinuationTargetId)
+      : undefined;
+    if (targetIndex !== undefined && messages[targetIndex]?.role === "assistant") {
+      const partOffset = messages[targetIndex]!.parts.length;
+      messages[targetIndex] = mergeAssistantContinuation(
+        messages[targetIndex]!,
+        message,
+      );
+      projectedIndexByMessageId.set(message.id, targetIndex);
+      partAnchorByMessageId.set(message.id, {
+        messageIndex: targetIndex,
+        partOffset,
+      });
+      pendingContinuationTargetId = null;
+      return;
+    }
+    pendingContinuationTargetId = null;
+    projectedIndexByMessageId.set(message.id, messages.length);
+    partAnchorByMessageId.set(message.id, {
+      messageIndex: messages.length,
+      partOffset: 0,
+    });
+    messages.push(message);
+  });
+
+  const placementsByMessageIndex = new Map<number, InlineCompactionPlacement[]>();
+  for (const placement of inlineCompactions) {
+    const placements = placementsByMessageIndex.get(placement.messageIndex) ?? [];
+    placements.push(placement);
+    placementsByMessageIndex.set(placement.messageIndex, placements);
+  }
+  for (const [messageIndex, placements] of placementsByMessageIndex) {
+    const message = messages[messageIndex];
+    if (!message) continue;
+    const parts = [...message.parts];
+    let insertedCount = 0;
+    placements
+      .sort((left, right) =>
+        left.boundaryIndex - right.boundaryIndex || left.rawOrder - right.rawOrder,
+      )
+      .forEach((placement) => {
+        if (
+          !Number.isSafeInteger(placement.boundaryIndex) ||
+          placement.boundaryIndex < 0 ||
+          placement.boundaryIndex > message.parts.length
+        ) {
+          inlineCompactionMessageIds.delete(placement.serviceMessageId);
+          return;
+        }
+        parts.splice(placement.boundaryIndex + insertedCount, 0, {
+          type: "extension",
+          extensionType: CONTEXT_COMPACTION_PART_EXTENSION_TYPE,
+          data: {
+            id: placement.serviceMessageId,
+            checkpoint: placement.checkpoint,
+          } satisfies ContextCompactionPartData,
+        });
+        insertedCount += 1;
+      });
+    messages[messageIndex] = { ...message, parts };
+  }
+
+  const pendingTargetIndex = pendingContinuationTargetId
+    ? projectedIndexByMessageId.get(pendingContinuationTargetId)
+    : undefined;
+  if (options.continuationRunning && pendingTargetIndex !== undefined) {
+    messages[pendingTargetIndex] = {
+      ...messages[pendingTargetIndex]!,
+      status: "pending",
+    };
+  }
+  return { messages, inlineCompactionMessageIds };
+}
+
+export function projectVisibleChatMessages(
+  rawMessages: readonly NcpMessage[],
+  options: { continuationRunning?: boolean } = {},
+): NcpMessage[] {
+  return projectVisibleChatMessageState(rawMessages, options).messages;
+}
+
 function resolveCompactionBoundaryIndex(params: {
   rawMessages: readonly NcpMessage[];
   visibleRawMessages: readonly NcpMessage[];
@@ -65,9 +260,7 @@ function resolveCompactionBoundaryIndex(params: {
   if (physicalIndex < 0) {
     return visibleRawMessages.length - 1;
   }
-  return (
-    rawMessages.slice(0, physicalIndex).filter(isVisibleChatMessage).length - 1
-  );
+  return projectVisibleChatMessages(rawMessages.slice(0, physicalIndex)).length - 1;
 }
 
 function resolveContextInheritanceBoundary(
@@ -84,7 +277,7 @@ function resolveContextInheritanceBoundary(
     return null;
   }
   return {
-    boundaryIndex: messages.slice(0, boundaryIndex).filter(isVisibleChatMessage)
+    boundaryIndex: projectVisibleChatMessages(messages.slice(0, boundaryIndex))
       .length,
     sourceSessionId,
     inheritedMessageCount: messages.filter(
@@ -97,7 +290,8 @@ export function buildChatMessageTimelineItems(params: {
   rawMessages: readonly NcpMessage[];
   messages: ChatMessageViewModel[];
 }): ChatTimelineItem[] {
-  const visibleRawMessages = params.rawMessages.filter(isVisibleChatMessage);
+  const projection = projectVisibleChatMessageState(params.rawMessages);
+  const visibleRawMessages = projection.messages;
   const checkpoints = params.rawMessages
     .map((message) => ({
       rawMessageId: message.id,
@@ -109,7 +303,10 @@ export function buildChatMessageTimelineItems(params: {
       ): entry is {
         rawMessageId: string;
         checkpoint: ContextCompactionTimelineView;
-      } => Boolean(entry.checkpoint),
+      } => Boolean(
+        entry.checkpoint &&
+        !projection.inlineCompactionMessageIds.has(entry.rawMessageId),
+      ),
     )
     .map((entry) => ({
       key: `compaction:${entry.rawMessageId}`,