lael-labs/t3code

apps/mobile/src/features/threads/ThreadFeed.tsx+38−7

 import { useUniwindTheme } from "../../lib/useUniwindTheme";
 import { IOS_NAV_BAR_HEIGHT } from "../../lib/layoutMetrics";
 import { useFontFamily } from "../../lib/useFontFamily";
+import { renderAssistantCitationsAsText } from "@t3tools/shared/assistantCitations";
 import { scopedThreadKey } from "../../lib/scopedEntities";
 import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic";
 import { tryOpenExternalUrl } from "../../lib/openExternalUrl";
 } from "../review/nativeReviewDiffAdapter";
 import { buildReviewParsedDiff } from "../review/reviewModel";
 import { cn } from "../../lib/cn";
-import { deriveCenteredContentHorizontalPadding, type LayoutVariant } from "../../lib/layout";
+import {
+  deriveCenteredContentHorizontalPadding,
+  deriveThreadWorkLogSizing,
+  type LayoutVariant,
+} from "../../lib/layout";
 import { uuidv4 } from "../../lib/uuid";
 import {
   resolveMarkdownFontSizes,
 import {
   resolveThreadFeedLiveFollow,
   type ThreadFeedLiveFollowEvent,
+  type ThreadWorkGroupScrollPosition,
 } from "./thread-feed-live-follow";
 import {
   ThreadDisclosureChevron,
 import { environmentThreadShells, threadEnvironment } from "../../state/threads";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { useV2ItemSupport } from "../../state/v2-item-support";
-import { resolveWorkspaceRelativeFilePath } from "../files/filePath";
+import {
+  basename,
+  fileRoutePathSegments,
+  isAbsolutePath,
+  resolveWorkspaceRelativeFilePath,
+} from "../files/filePath";
 import { waitForThreadShellReady } from "./threadForkNavigation";
 import { resolveUserMessageIntentBadge } from "./userMessageIntentBadge";
       activities={entry.activities}
       anchorKey={entry.id}
       copiedRowId={props.copiedRowId}
-      currentThreadId={props.threadId}
-      environmentId={props.environmentId}
       expandedRows={props.expandedWorkRows}
       rowSizing={props.workRowSizing}
       scrollPositions={props.workGroupScrollPositions}
       iconSubtleColor={iconSubtleColor}
       onCopyRow={props.onCopyWorkRow}
-      onToggleRow={(rowId) => props.onToggleWorkRow(rowId, entry.id)}
+      onToggleRow={props.onToggleWorkRow}
-      workspaceRoot={props.workspaceRoot}
       renderImage={props.renderViewedImage}
     />
   );
   const previousLatestTurnRef = useRef(props.latestRun);
   const userScrollSettleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const headerMaterialVisibleRef = useRef(false);
-  const { width: windowWidth } = useWindowDimensions();
+  const { width: windowWidth, fontScale } = useWindowDimensions();
+  const { appearance } = useAppearancePreferences();
+  const workRowSizing = useMemo(
+    () => deriveThreadWorkLogSizing({ baseFontSize: appearance.baseFontSize, fontScale }),
+    [appearance.baseFontSize, fontScale],
+  );
+  const previousTextSize = useRef(workRowSizing.textSizeKey);
+  useLayoutEffect(() => {
+    if (previousTextSize.current === workRowSizing.textSizeKey) {
+      return;
+    }
+    previousTextSize.current = workRowSizing.textSizeKey;
+    // Text-size changes invalidate the outer list's fixed-height cache too.
+    // This never runs for scrolling, streamed output, or disclosure toggles.
+    props.listRef.current?.clearCaches({ mode: "sizes" });
+  }, [workRowSizing.textSizeKey, props.listRef]);
   const [viewportWidth, setViewportWidth] = useState(() =>
     props.layoutVariant === "split" ? 0 : windowWidth,
   );
   // ThreadId, and keying resets (or the list mount) on the bare id would
   // carry stale scroll/follow state across an environment switch.
   const feedThreadKey = scopedThreadKey(props.environmentId, props.threadId);
+  // Virtualized groups can unmount without losing the reader's place. This cache
+  // belongs to this thread view only and never causes per-scroll React updates.
+  const workGroupScrollPositions = useMemo(
+    () => new Map<string, ThreadWorkGroupScrollPosition>(),
+    [feedThreadKey],
+  );
   // A thread switch opens pinned to the end; a send explicitly returns to the
   // live edge (ThreadDetailScreen scrolls the new message into place). Both
   // re-arm follow regardless of where the user had scrolled before.
             threadId: props.threadId,
             copiedRowId,
             expandedWorkRows,
+            workRowSizing,
+            workGroupScrollPositions,
             terminalAssistantMessageIds,
             unsettledTurnId,
             onCopyWorkRow,

apps/mobile/src/features/threads/threadPresentation.ts+0−11

   type EnvironmentThreadShell,
 } from "@t3tools/client-runtime/state/shell";
-export function threadSortValue(thread: EnvironmentThreadShell): number {
-  const candidate = Date.parse(thread.updatedAt ?? thread.createdAt);
-  return Number.isNaN(candidate) ? 0 : candidate;
-}
 export type ThreadStatusKind =
   | "pending-approval"
   | "awaiting-input"
   readonly pulse: boolean;
 }
-/** Neutral icon colors for threads with no actionable status. */
-export const THREAD_STATUS_NEUTRAL_ICON = {
-  iconColor: "#8e8e93",
-  iconBackground: "rgba(142,142,147,0.22)",
-} as const;
 function isLatestRunSettled(thread: EnvironmentThreadShell): boolean {
   if (!thread.latestRun?.startedAt) return false;
   if (!thread.latestRun.completedAt) return false;

apps/mobile/src/lib/projectThreadStartTurn.test.ts+1−1

@@ -26,7 +26,7 @@ describe("project thread title", () => { · 25 unmodified lines
26	},	26	},
27	{	27	{
28	comment: 'Why "shared"?',	28	comment: 'Why "shared"?',
29	title: 'Keep `cache[key]` & <parser> shared. Retry! Comment: Why "shared"?',	29	title: "Keep `cache[key]` & <parser> shared. Retry! Commen...",
30	},	30	},
31	])("uses readable titles and intact links with comment $comment", ({ comment, title }) => {	31	])("uses readable titles and intact links with comment $comment", ({ comment, title }) => {
32	const quoteText = "Keep `cache[key]` & <parser> shared.\n Retry!";	32	const quoteText = "Keep `cache[key]` & <parser> shared.\n Retry!";

apps/mobile/src/lib/projectThreadStartTurn.ts+2−1

   type RuntimeMode,
 } from "@t3tools/contracts";
 import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
+import { assistantCitationsToPlainText } from "@t3tools/shared/assistantCitations";
 import type { UploadedMobileAttachment } from "./attachmentUpload";
 }
 export function deriveThreadTitleFromPrompt(value: string): string {
-  const trimmed = value.trim();
+  const trimmed = assistantCitationsToPlainText(value).trim();
   if (trimmed.length === 0) {
     return "New thread";
   }

apps/mobile/src/lib/threadActivity.test.ts+1−3

     );
     expect(expanded.map((entry) => entry.id)).toEqual([
       "work-toggle:work-group:activity-neutral",
-      "activity-1",
+      "work-details:work-group:activity-neutral",
-      "activity-2",
-      "activity-3",
     ]);
     expect(expanded[0]).toMatchObject({
       type: "work-toggle",

apps/mobile/src/lib/threadActivity.ts+42−23

 import { turnItemIsWorkspacePreparation } from "@t3tools/client-runtime/state/turn-item-presentation";
 import { commandProgramName } from "@t3tools/client-runtime/work-log/command-label";
 import {
+  workEntryDisplayIndicatesToolFailure,
+  resolveWorkEntryToolPresentation,
   summarizeToolGroup,
   toolGroupSummaryKind,
   type ToolGroupSummaryKind,
     : (latestInProgressActivity ?? activities.at(-1)!);
   const groupSummary = summarizeToolGroup(activities.map((activity) => activity.workEntry));
   const summary = live
-    ? liveToolActivitySummary(latestActivity)
+    ? liveToolActivitySummary(latestActivity, latestInProgressActivity !== undefined)
     : activities.length === 1 && !activities[0]!.toolLike
       ? activities[0]!.workEntry.label
       : groupSummary.summary;
     summaryKind: toolGroupSummaryKind(
       (live ? [latestActivity] : activities).map((activity) => activity.workEntry),
     ),
-    hasFailure: groupSummary.hasFailure,
+    hasFailure: (() => {
+      const lastToolLike = activities.findLast((activity) => activity.toolLike);
+      return (
+        lastToolLike !== undefined && workEntryDisplayIndicatesToolFailure(lastToolLike.workEntry)
+      );
+    })(),
     live,
     shimmer:
       isWorking &&
       latestActivity.runId === activeRunId,
   });
   if (!expanded) return;
-  for (const activity of activities) {
+  result.push({
-    result.push({
+    type: "activity-group",
-      type: "activity-group",
+    id: `work-details:${groupId}`,
-      id: activity.id,
+    createdAt: activities[0]!.createdAt,
-      createdAt: activity.createdAt,
+    runId: activities[0]!.runId,
-      runId: activity.runId,
+    activities: activities.map((activity) => ({
-      activities: [
+      ...activity,
-        {
+      groupedToolDetail: true,
-          ...activity,
+      live:
-          groupedToolDetail: true,
+        isWorking &&
-          live:
+        activity.id === latestActivity.id &&
-            isWorking &&
+        activity.lifecycleStatus === "inProgress" &&
-            activity.id === latestActivity.id &&
+        activity.runId === activeRunId,
-            activity.lifecycleStatus === "inProgress" &&
+    })),
-            activity.runId === activeRunId,
+  });
-        },
-      ],
-    });
-  }
 }
-function liveToolActivitySummary(activity: ThreadFeedActivity): string {
+function liveToolActivitySummary(activity: ThreadFeedActivity, active: boolean): string {
+  const presentation = resolveWorkEntryToolPresentation(
+    activity.workEntry,
+    active ? "inProgress" : "completed",
+  );
+  if (presentation) return presentation.displayName;
   const command = activity.workEntry.command?.trim();
   if (command) {
     const program = commandProgramName(command);
-    return program ? `Running ${program}` : "Running command";
+    const status = activity.lifecycleStatus ?? (active ? "inProgress" : "completed");
+    const verb =
+      status === "inProgress"
+        ? "Running"
+        : status === "failed"
+          ? "Failed"
+          : status === "declined"
+            ? "Declined"
+            : status === "stopped"
+              ? "Stopped"
+              : "Ran";
+    return `${verb} ${program ?? "command"}`;
   }
   return activity.detail ?? activity.summary;
 }

apps/server/scripts/acp-mock-agent.ts+15−5

 // "grok-build" product name, and it rejects unknown ids in session/set_model.
 const grokAcpModels: ReadonlyArray<AcpSchema.ModelInfo> = [
   {
-    modelId: "grok-build",
+    modelId: "grok-4.6",
-    name: "Grok Build",
+    name: "Grok 4.6",
-    ...(initialGrokReasoningEffort
+    _meta: {
-      ? { _meta: { reasoningEffort: initialGrokReasoningEffort } }
+      totalContextTokens: 500_000,
-      : {}),
+      supportsReasoningEffort: true,
+      reasoningEffort: initialGrokReasoningEffort ?? "high",
+      reasoningEfforts: [
+        { id: "xhigh", value: "xhigh", label: "Extra High Effort", default: false },
+        { id: "high", value: "high", label: "High Effort", default: true },
+        { id: "low", value: "low", label: "Low Effort", default: false },
+      ],
+    },
   },
   { modelId: "grok-mock-alt", name: "Grok Mock Alt" },
 ];
         request.clientCapabilities?._meta?.parameterizedModelPicker === true;
       return {
         protocolVersion: 1,
+        // Grok advertises model state before any session exists; the provider
+        // health check reads it from here without authenticating.
+        _meta: { modelState: modelState() },
         agentCapabilities: {
           loadSession: true,
           ...(supportsSessionLifecycle

apps/server/src/httpCors.ts+2−7

+import { ORCHESTRATION_PROTOCOL_HEADER } from "@t3tools/contracts";
 export const browserApiCorsAllowedMethods = ["GET", "POST", "OPTIONS"] as const;
 export const browserApiCorsAllowedHeaders = [
   "authorization",
   "dpop",
   ORCHESTRATION_PROTOCOL_HEADER,
 ] as const;
-export const browserApiCorsHeaders = {
-  "access-control-allow-origin": "*",
-  "access-control-allow-methods": browserApiCorsAllowedMethods.join(", "),
-  "access-control-allow-headers": browserApiCorsAllowedHeaders.join(", "),
-} as const;
-import { ORCHESTRATION_PROTOCOL_HEADER } from "@t3tools/contracts";

apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts+1−1

@@ -1406,7 +1406,7 @@ describe("AcpAdapterV2", () => { · 1405 unmodified lines
1406	instanceId,	1406	instanceId,
1407	model: "grok-mock-alt",	1407	model: "grok-mock-alt",
1408	} satisfies ModelSelection;	1408	} satisfies ModelSelection;
1409	const originalSelection = { instanceId, model: "grok-build" } satisfies ModelSelection;	1409	const originalSelection = { instanceId, model: "grok-4.6" } satisfies ModelSelection;
1410	const runtime = yield* adapter.openSession({	1410	const runtime = yield* adapter.openSession({
1411	threadId: firstThreadId,	1411	threadId: firstThreadId,
1412	providerSessionId: ProviderSessionId.make("provider-session-acp-active-setup"),	1412	providerSessionId: ProviderSessionId.make("provider-session-acp-active-setup"),

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts+14−0

           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           queryRunner: {
             allocateSessionId: Effect.succeed("native-thread-claude-resume"),
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           queryRunner: {
             allocateSessionId: Effect.succeed("native-thread-claude-attachments"),
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           queryRunner: {
             allocateSessionId: Effect.succeed("native-thread-claude-unsupported-attachment"),
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           queryRunner: {
             allocateSessionId: Effect.succeed("source-native-session"),
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           queryRunner: {
             allocateSessionId: Effect.succeed("native-session-identity"),
         environment: {},
         attachmentsDir,
         fileSystem,
+        path: yield* Path.Path,
         idAllocator,
         continuationRequests: {
           offer: (request) =>
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           continuationRequests: { offer: () => Effect.void },
           queryRunner: {
             environment: {},
             attachmentsDir,
             fileSystem,
+            path: yield* Path.Path,
             idAllocator,
             continuationRequests: {
               offer: () => Effect.void,
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           continuationRequests: {
             offer: (request) =>
             environment: {},
             attachmentsDir,
             fileSystem,
+            path: yield* Path.Path,
             idAllocator,
             continuationRequests: {
               offer: (request) =>
             environment: {},
             attachmentsDir,
             fileSystem,
+            path: yield* Path.Path,
             idAllocator,
             continuationRequests: {
               offer: (request) =>
             environment: {},
             attachmentsDir,
             fileSystem,
+            path: yield* Path.Path,
             idAllocator,
             continuationRequests: {
               offer: () => Effect.void,
             environment: {},
             attachmentsDir,
             fileSystem,
+            path: yield* Path.Path,
             idAllocator,
             continuationRequests: {
               offer: (request) =>
           environment: {},
           attachmentsDir,
           fileSystem,
+          path: yield* Path.Path,
           idAllocator,
           continuationRequests: {
             offer: () => Effect.void,

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts+67−4

 import * as Stream from "effect/Stream";
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
+import { planClaudeSkillDispatch } from "../../provider/Drivers/ClaudeSkillDispatch.ts";
+import { discoverClaudeSkills } from "../../provider/Drivers/ClaudeSkills.ts";
 import { compileClaudeModelSelection } from "../../claudeModelOptions.ts";
 import { ServerConfig } from "../../config.ts";
 import { makeClaudeEnvironment } from "../../provider/Drivers/ClaudeHome.ts";
 export function makeClaudeUserMessage(input: {
   readonly text: string;
   readonly priority?: SDKUserMessage["priority"];
+  readonly skillNames?: ReadonlySet<string>;
 }): SDKUserMessage {
+  // Claude Code expands a skill only from the LAST text block, and only when
+  // `/name` is its first character. A `$skill` chip anywhere in the prompt is
+  // therefore split into [leading text, "/name trailing text"] so the CLI
+  // runs it natively and the prose around it survives. See ClaudeSkillDispatch.
+  const dispatch =
+    input.skillNames === undefined
+      ? undefined
+      : planClaudeSkillDispatch(input.text, input.skillNames);
   return {
     type: "user",
     message: {
       role: "user",
-      content: input.text,
+      content: dispatch
+        ? [
+            ...(dispatch.leadingText === undefined
+              ? []
+              : [{ type: "text" as const, text: dispatch.leadingText }]),
+            { type: "text" as const, text: dispatch.commandText },
+          ]
+        : input.text,
     },
     parent_tool_use_id: null,
     ...(input.priority === undefined ? {} : { priority: input.priority }),
   readonly priority?: SDKUserMessage["priority"];
   readonly attachmentsDir: string;
   readonly fileSystem: FileSystem.FileSystem;
+  readonly skillNames?: ReadonlySet<string>;
 }) {
   if (input.attachments.length === 0) {
     return makeClaudeUserMessage({
       text: input.text,
+      ...(input.skillNames === undefined ? {} : { skillNames: input.skillNames }),
       ...(input.priority === undefined ? {} : { priority: input.priority }),
     });
   }
     attachmentsDir: input.attachmentsDir,
   });
+  const dispatch =
+    input.skillNames === undefined
+      ? undefined
+      : planClaudeSkillDispatch(textWithAttachmentPaths, input.skillNames);
   const content: Array<ClaudeUserContentBlock> = [];
-  if (textWithAttachmentPaths.length > 0) {
+  if (dispatch) {
+    if (dispatch.leadingText !== undefined) {
+      content.push({ type: "text", text: dispatch.leadingText });
+    }
+  } else if (textWithAttachmentPaths.length > 0) {
     content.push({ type: "text", text: textWithAttachmentPaths });
   }
     });
   }
+  // Images go before the command block: a text block after them still
+  // expands, a command block followed by an image does not.
+  if (dispatch) {
+    content.push({ type: "text", text: dispatch.commandText });
+  }
   return {
     type: "user",
     message: {
   readonly environment: NodeJS.ProcessEnv;
   readonly attachmentsDir: string;
   readonly fileSystem: FileSystem.FileSystem;
+  readonly path: Path.Path;
   readonly idAllocator: IdAllocatorV2Shape;
   readonly queryRunner: ClaudeAgentSdkQueryRunnerShape;
   /** Sink for wake-turn continuation requests; defaults to dropping them. */
 export function makeClaudeAdapterV2(
   adapterOptions: ClaudeAdapterV2Options,
 ): ProviderAdapterV2Shape {
-  const { attachmentsDir, fileSystem, idAllocator, queryRunner } = adapterOptions;
+  const { attachmentsDir, fileSystem, path, idAllocator, queryRunner } = adapterOptions;
   const continuationRequests = adapterOptions.continuationRequests ?? {
     offer: () => Effect.void,
   };
+  // Re-scan on every send: skills are added and switched off mid-session, and
+  // the scan is a few directory reads. A skill switched off via skillOverrides,
+  // or reserved for the agent with `user-invocable: false`, is left as prose:
+  // the CLI would answer `/name` with a notice instead of running it.
+  const userInvocableSkillNames = (cwd: string | null) =>
+    discoverClaudeSkills(
+      adapterOptions.settings,
+      cwd ?? undefined,
+      adapterOptions.environment,
+    ).pipe(
+      Effect.map(
+        (skills) =>
+          new Set(
+            skills
+              .filter((skill) => skill.enabled && skill.userInvocable !== false)
+              .map((skill) => skill.name),
+          ),
+      ),
+      Effect.provideService(FileSystem.FileSystem, fileSystem),
+      Effect.provideService(Path.Path, path),
+    );
   return ProviderAdapterV2.of({
     instanceId: adapterOptions.instanceId,
     driver: CLAUDE_PROVIDER,
                   attachments: turnInput.message.attachments,
                   attachmentsDir,
                   fileSystem,
+                  skillNames: yield* userInvocableSkillNames(turnInput.runtimePolicy.cwd),
                 });
             const querySession = yield* openQuery(turnInput, nativeThreadId);
             yield* Ref.set(activeTurn, context);
               priority: "now",
               attachmentsDir,
               fileSystem,
+              skillNames: yield* userInvocableSkillNames(currentTurn.input.runtimePolicy.cwd),
             });
             yield* Ref.update(steeredTurns, (current) => {
               const next = new Set(current);
       const continuationRequests = yield* ProviderContinuationRequests;
       const baseEnvironment = mergeProviderInstanceEnvironment(environment, hostEnvironment);
       const claudeEnvironment = yield* makeClaudeEnvironment(config, baseEnvironment);
+      const path = yield* Path.Path;
       return makeClaudeAdapterV2({
         instanceId,
         settings: { ...config, enabled },
         environment: claudeEnvironment,
         attachmentsDir: serverConfig.attachmentsDir,
         fileSystem,
+        path,
         idAllocator,
         queryRunner,
         continuationRequests,
 const makeDefaultClaudeAdapterV2 = Effect.fn("ClaudeAdapterV2.layer")(function* () {
   const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
   const hostEnvironment = yield* HostProcessEnvironment;
   const idAllocator = yield* IdAllocatorV2;
   const queryRunner = yield* ClaudeAgentSdkQueryRunner;
     environment: hostEnvironment,
     attachmentsDir: serverConfig.attachmentsDir,
     fileSystem,
+    path,
     idAllocator,
     queryRunner,
     continuationRequests,
 export const layer: Layer.Layer<
   ProviderAdapterV2,
   never,
-  ClaudeAgentSdkQueryRunner | FileSystem.FileSystem | IdAllocatorV2 | ServerConfig
+  ClaudeAgentSdkQueryRunner | FileSystem.FileSystem | IdAllocatorV2 | Path.Path | ServerConfig
 > = Layer.effect(ProviderAdapterV2, makeDefaultClaudeAdapterV2());

apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.testkit.ts+14−0

@@ -342,6 +342,20 @@ function makeOpenCodeReplayRuntimeLayer(transcript: OpenCodeSdkReplayTranscript) · 341 unmodified lines
342	detail: "OpenCode replay does not load inventory.",	342	detail: "OpenCode replay does not load inventory.",
343	}),	343	}),
344	),	344	),
		345	loadOpenCodeSkills: () =>
		346	Effect.fail(
		347	new OpenCodeRuntimeError({
		348	operation: "loadOpenCodeSkills",
		349	detail: "OpenCode replay does not load skills.",
		350	}),
		351	),
		352	loadSkillsFromCli: () =>
		353	Effect.fail(
		354	new OpenCodeRuntimeError({
		355	operation: "loadSkillsFromCli",
		356	detail: "OpenCode replay does not load skills.",
		357	}),
		358	),
345	} satisfies OpenCodeRuntimeShape);	359	} satisfies OpenCodeRuntimeShape);
346	}),	360	}),
347	);	361	);

apps/server/src/orchestration/Layers/OrchestrationEngine.ts+3−0

           );
         commandReadModel = committedCommand.nextCommandReadModel;
+        for (const cleanup of committedCommand.attachmentCleanups) {
+          yield* cleanup;
+        }
         yield* eventStore.publishCommitted(
           committedCommand.committedEvents.filter(
             (event) =>

apps/server/src/provider/Drivers/AcpRegistryDriver.ts+2−2

apps/server/src/provider/Drivers/CodexDriver.ts+35−1

@@ -40,7 +40,12 @@ import { · 39 unmodified lines
40	} from "../../orchestration-v2/Adapters/CodexAdapterV2.ts";	40	} from "../../orchestration-v2/Adapters/CodexAdapterV2.ts";
41	import { ServerSettingsService } from "../../serverSettings.ts";	41	import { ServerSettingsService } from "../../serverSettings.ts";
42	import { ProviderDriverError } from "../Errors.ts";	42	import { ProviderDriverError } from "../Errors.ts";
43	import { checkCodexProviderStatus, makePendingCodexProvider } from "../Layers/CodexProvider.ts";	43	import {
		44	checkCodexProviderStatus,
		45	makePendingCodexProvider,
		46	probeCodexSkillsForCwd,
		47	} from "../Layers/CodexProvider.ts";
		48	import { resolveCodexLaunchArgs } from "../Layers/codexLaunchArgs.ts";
44	import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";	49	import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
45	import * as ModelManifest from "../ModelManifest.ts";	50	import * as ModelManifest from "../ModelManifest.ts";
46	import type { ProviderDriver, ProviderInstance } from "../ProviderDriver.ts";	51	import type { ProviderDriver, ProviderInstance } from "../ProviderDriver.ts";
@@ -237,6 +242,34 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = { · 190 unmodified lines
237	}),	242	}),
238	),	243	),
239	);	244	);
		245	const snapshotForCwd = (cwd: string) =>
		246	!effectiveConfig.enabled
		247	? snapshot.getSnapshot
		248	: Effect.all([
		249	snapshot.getSnapshot,
		250	probeCodexSkillsForCwd({
		251	binaryPath: effectiveConfig.binaryPath,
		252	homePath: effectiveConfig.homePath,
		253	launchArgs: resolveCodexLaunchArgs(effectiveConfig.launchArgs, processEnv),
		254	cwd,
		255	environment: processEnv,
		256	}).pipe(
		257	Effect.scoped,
		258	Effect.timeout("20 seconds"),
		259	Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
		260	),
		261	]).pipe(
		262	Effect.map(([machineSnapshot, skills]) => ({ ...machineSnapshot, skills })),
		263	Effect.mapError(
		264	(cause) =>
		265	new ProviderDriverError({
		266	driver: DRIVER_KIND,
		267	instanceId,
		268	detail: `Failed to probe Codex skills for '${cwd}'`,
		269	cause,
		270	}),
		271	),
		272	);
240		273
241	return {	274	return {
242	instanceId,	275	instanceId,
@@ -246,6 +279,7 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = { · 3 unmodified lines
246	accentColor,	279	accentColor,
247	enabled,	280	enabled,
248	snapshot,	281	snapshot,
		282	snapshotForCwd,
249	orchestrationAdapter,	283	orchestrationAdapter,
250	textGeneration,	284	textGeneration,
251	} satisfies ProviderInstance;	285	} satisfies ProviderInstance;

apps/server/src/provider/Drivers/CursorDriver.ts+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	*	7	*
8	* @module provider/Drivers/CursorDriver	8	* @module provider/Drivers/CursorDriver
9	*/	9	*/
10	import { CursorSettings, ProviderDriverKind, type ServerProvider } from "@t3tools/contracts";	10	import { CursorSettings, ProviderDriverKind } from "@t3tools/contracts";
11	import * as Effect from "effect/Effect";	11	import * as Effect from "effect/Effect";
12	import * as Schema from "effect/Schema";	12	import * as Schema from "effect/Schema";
13		13

apps/server/src/provider/Drivers/OpenCodeDriver.ts+50−0

@@ -33,6 +33,7 @@ import { ProviderDriverError } from "../Errors.ts"; · 32 unmodified lines
33	import {	33	import {
34	checkOpenCodeProviderStatus,	34	checkOpenCodeProviderStatus,
35	makePendingOpenCodeProvider,	35	makePendingOpenCodeProvider,
		36	openCodeSkillsToServerProviderSkills,
36	} from "../Layers/OpenCodeProvider.ts";	37	} from "../Layers/OpenCodeProvider.ts";
37	import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";	38	import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
38	import { OpenCodeRuntime } from "../opencodeRuntime.ts";	39	import { OpenCodeRuntime } from "../opencodeRuntime.ts";
@@ -169,6 +170,34 @@ export const OpenCodeDriver: ProviderDriver<OpenCodeSettings, OpenCodeDriverEnv> · 130 unmodified lines
169	Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),	170	Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),
170	Effect.provideService(OpenCodeRuntime, openCodeRuntime),	171	Effect.provideService(OpenCodeRuntime, openCodeRuntime),
171	);	172	);
		173	const loadSkillsForCwd = (cwd: string) =>
		174	effectiveConfig.serverUrl.trim().length > 0
		175	? Effect.scoped(
		176	Effect.gen(function* () {
		177	const server = yield* openCodeRuntime.connectToOpenCodeServer({
		178	binaryPath: effectiveConfig.binaryPath,
		179	directory: cwd,
		180	serverUrl: effectiveConfig.serverUrl,
		181	...(effectiveConfig.serverPassword
		182	? { serverPassword: effectiveConfig.serverPassword }
		183	: {}),
		184	environment: processEnv,
		185	});
		186	const client = openCodeRuntime.createOpenCodeSdkClient({
		187	baseUrl: server.url,
		188	directory: cwd,
		189	...(effectiveConfig.serverPassword
		190	? { serverPassword: effectiveConfig.serverPassword }
		191	: {}),
		192	});
		193	return yield* openCodeRuntime.loadOpenCodeSkills(client);
		194	}),
		195	)
		196	: openCodeRuntime.loadSkillsFromCli({
		197	binaryPath: effectiveConfig.binaryPath,
		198	cwd,
		199	environment: processEnv,
		200	});
172		201
173	const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);	202	const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
174	const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<OpenCodeSettings>>(	203	const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<OpenCodeSettings>>(
@@ -213,6 +242,27 @@ export const OpenCodeDriver: ProviderDriver<OpenCodeSettings, OpenCodeDriverEnv> · 38 unmodified lines
213	accentColor,	242	accentColor,
214	enabled,	243	enabled,
215	snapshot,	244	snapshot,
		245	snapshotForCwd: (cwd) =>
		246	!effectiveConfig.enabled
		247	? snapshot.getSnapshot
		248	: Effect.all([
		249	snapshot.getSnapshot,
		250	loadSkillsForCwd(cwd).pipe(Effect.timeout("20 seconds")),
		251	]).pipe(
		252	Effect.map(([machineSnapshot, skills]) => ({
		253	...machineSnapshot,
		254	skills: openCodeSkillsToServerProviderSkills(skills),
		255	})),
		256	Effect.mapError(
		257	(cause) =>
		258	new ProviderDriverError({
		259	driver: DRIVER_KIND,
		260	instanceId,
		261	detail: `Failed to probe OpenCode skills for '${cwd}'`,
		262	cause,
		263	}),
		264	),
		265	),
216	orchestrationAdapter,	266	orchestrationAdapter,
217	textGeneration,	267	textGeneration,
218	} satisfies ProviderInstance;	268	} satisfies ProviderInstance;

apps/server/src/provider/Layers/ProviderRegistry.test.ts+195−0

@@ -1,6 +1,7 @@
1	import * as NodeServices from "@effect/platform-node/NodeServices";	1	import * as NodeServices from "@effect/platform-node/NodeServices";
2	import { describe, it, assert } from "@effect/vitest";	2	import { describe, it, assert } from "@effect/vitest";
3	import * as DateTime from "effect/DateTime";	3	import * as DateTime from "effect/DateTime";
		4	import * as Deferred from "effect/Deferred";
4	import * as Effect from "effect/Effect";	5	import * as Effect from "effect/Effect";
5	import * as Path from "effect/Path";	6	import * as Path from "effect/Path";
6	import * as Exit from "effect/Exit";	7	import * as Exit from "effect/Exit";
@@ -43,6 +44,7 @@ import { · 36 unmodified lines
43	haveProvidersChanged,	44	haveProvidersChanged,
44	mergeProviderSnapshot,	45	mergeProviderSnapshot,
45	mergeProviderSnapshots,	46	mergeProviderSnapshots,
		47	upsertProviderWorkspaceSnapshot,
46	ProviderRegistryLive,	48	ProviderRegistryLive,
47	selectProvidersByKind,	49	selectProvidersByKind,
48	} from "./ProviderRegistry.ts";	50	} from "./ProviderRegistry.ts";
@@ -581,6 +583,41 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te · 532 unmodified lines
581	assert.strictEqual(haveProvidersChanged(providers, [...providers]), false);	583	assert.strictEqual(haveProvidersChanged(providers, [...providers]), false);
582	});	584	});
583		585
		586	it("stores workspace skills and commands without changing machine metadata", () => {
		587	const provider = {
		588	instanceId: ProviderInstanceId.make("codex"),
		589	driver: ProviderDriverKind.make("codex"),
		590	status: "ready",
		591	enabled: true,
		592	installed: true,
		593	auth: { status: "authenticated" },
		594	checkedAt: "2026-03-25T00:00:00.000Z",
		595	version: "1.0.0",
		596	models: [],
		597	slashCommands: [{ name: "global" }],
		598	skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }],
		599	} satisfies ServerProvider;
		600	const scopedSnapshot = {
		601	...provider,
		602	checkedAt: "2026-03-25T00:01:00.000Z",
		603	slashCommands: [{ name: "project" }],
		604	skills: [{ name: "project", path: "/project/SKILL.md", enabled: true }],
		605	} satisfies ServerProvider;
		606
		607	const result = upsertProviderWorkspaceSnapshot(provider, "/project", scopedSnapshot);
		608
		609	assert.deepStrictEqual(result.slashCommands, provider.slashCommands);
		610	assert.deepStrictEqual(result.skills, provider.skills);
		611	assert.deepStrictEqual(result.workspaceSnapshots, [
		612	{
		613	cwd: "/project",
		614	checkedAt: scopedSnapshot.checkedAt,
		615	slashCommands: scopedSnapshot.slashCommands,
		616	skills: scopedSnapshot.skills,
		617	},
		618	]);
		619	});
		620
584	it("preserves previously discovered provider models when a refresh returns none", () => {	621	it("preserves previously discovered provider models when a refresh returns none", () => {
585	const previousProvider = {	622	const previousProvider = {
586	instanceId: ProviderInstanceId.make("cursor"),	623	instanceId: ProviderInstanceId.make("cursor"),
@@ -1004,6 +1041,164 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te · 417 unmodified lines
1004	}),	1041	}),
1005	);	1042	);
1006		1043
		1044	it.effect("deduplicates cwd probes and clears snapshots when an instance rebuilds", () =>
		1045	Effect.gen(function* () {
		1046	const driver = ProviderDriverKind.make("codex");
		1047	const instanceId = ProviderInstanceId.make("codex");
		1048	const machineProvider = {
		1049	instanceId,
		1050	driver,
		1051	status: "ready",
		1052	enabled: true,
		1053	installed: true,
		1054	auth: { status: "authenticated" },
		1055	checkedAt: "2026-06-10T00:00:00.000Z",
		1056	version: "1.0.0",
		1057	models: [],
		1058	slashCommands: [{ name: "global" }],
		1059	skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }],
		1060	} as const satisfies ServerProvider;
		1061	const scopedProvider = {
		1062	...machineProvider,
		1063	checkedAt: "2026-06-10T00:01:00.000Z",
		1064	slashCommands: [{ name: "project" }],
		1065	skills: [{ name: "project", path: "/workspace/SKILL.md", enabled: true }],
		1066	} as const satisfies ServerProvider;
		1067	const pendingScopedProvider = {
		1068	...scopedProvider,
		1069	status: "error",
		1070	installed: false,
		1071	slashCommands: [],
		1072	} as const satisfies ServerProvider;
		1073	const snapshotCalls = yield* Ref.make(0);
		1074	const returnPendingSnapshot = yield* Ref.make(true);
		1075	const probeStarted = yield* Deferred.make<void>();
		1076	const releaseProbe = yield* Deferred.make<void>();
		1077	const makeInstance = (
		1078	provider: ServerProvider,
		1079	snapshotForCwd: NonNullable<ProviderInstance["snapshotForCwd"]>,
		1080	): ProviderInstance => ({
		1081	instanceId,
		1082	driverKind: driver,
		1083	continuationIdentity: {
		1084	driverKind: driver,
		1085	continuationKey: "codex:instance:codex",
		1086	},
		1087	displayName: undefined,
		1088	enabled: true,
		1089	snapshot: {
		1090	maintenanceCapabilities: makeManualOnlyProviderMaintenanceCapabilities({
		1091	provider: driver,
		1092	packageName: null,
		1093	}),
		1094	getSnapshot: Effect.succeed(provider),
		1095	refresh: Effect.succeed(provider),
		1096	streamChanges: Stream.empty,
		1097	},
		1098	snapshotForCwd,
		1099	orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
		1100	textGeneration: {} as ProviderInstance["textGeneration"],
		1101	});
		1102	const firstInstance = makeInstance(machineProvider, () =>
		1103	Effect.gen(function* () {
		1104	yield* Ref.update(snapshotCalls, (count) => count + 1);
		1105	if (yield* Ref.get(returnPendingSnapshot)) return pendingScopedProvider;
		1106	yield* Deferred.succeed(probeStarted, undefined);
		1107	yield* Deferred.await(releaseProbe);
		1108	return scopedProvider;
		1109	}),
		1110	);
		1111	const rebuiltProvider = {
		1112	...machineProvider,
		1113	checkedAt: "2026-06-10T00:02:00.000Z",
		1114	status: "warning",
		1115	installed: false,
		1116	auth: { status: "unknown" },
		1117	} satisfies ServerProvider;
		1118	const rebuiltInstance = makeInstance(rebuiltProvider, () =>
		1119	Ref.update(snapshotCalls, (count) => count + 1).pipe(Effect.as(scopedProvider)),
		1120	);
		1121	const registryChanges = yield* PubSub.unbounded<void>();
		1122	const instancesRef = yield* Ref.make<ReadonlyArray<ProviderInstance>>([firstInstance]);
		1123	const instanceRegistryLayer = Layer.succeed(
		1124	ProviderInstanceRegistry.ProviderInstanceRegistry,
		1125	{
		1126	getInstance: (requestedId) =>
		1127	Ref.get(instancesRef).pipe(
		1128	Effect.map((instances) =>
		1129	instances.find((instance) => instance.instanceId === requestedId),
		1130	),
		1131	),
		1132	listInstances: Ref.get(instancesRef),
		1133	listUnavailable: Effect.succeed([]),
		1134	streamChanges: Stream.fromPubSub(registryChanges),
		1135	subscribeChanges: PubSub.subscribe(registryChanges),
		1136	},
		1137	);
		1138	const scope = yield* Scope.make();
		1139	yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
		1140	const runtimeServices = yield* Layer.build(
		1141	ProviderRegistryLive.pipe(
		1142	Layer.provideMerge(instanceRegistryLayer),
		1143	Layer.provideMerge(
		1144	ServerConfig.layerTest(process.cwd(), {
		1145	prefix: "t3-provider-registry-workspace-snapshot-",
		1146	}),
		1147	),
		1148	Layer.provideMerge(NodeServices.layer),
		1149	),
		1150	).pipe(Scope.provide(scope));
		1151
		1152	yield* Effect.gen(function* () {
		1153	const registry = yield* ProviderRegistry.ProviderRegistry;
		1154	yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" });
		1155	assert.strictEqual((yield* registry.getProviders)[0]?.workspaceSnapshots, undefined);
		1156	yield* Ref.set(returnPendingSnapshot, false);
		1157	const workspaceUpdate = yield* registry.streamChanges.pipe(
		1158	Stream.runHead,
		1159	Effect.forkChild,
		1160	);
		1161	yield* Effect.yieldNow;
		1162	const firstRefresh = yield* registry
		1163	.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" })
		1164	.pipe(Effect.forkChild);
		1165	yield* Deferred.await(probeStarted);
		1166	const duplicateRefresh = yield* registry
		1167	.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" })
		1168	.pipe(Effect.forkChild);
		1169	yield* Effect.yieldNow;
		1170	assert.strictEqual(yield* Ref.get(snapshotCalls), 2);
		1171	yield* Deferred.succeed(releaseProbe, undefined);
		1172	yield* Fiber.join(firstRefresh);
		1173	yield* Fiber.join(duplicateRefresh);
		1174	const published = yield* Fiber.join(workspaceUpdate);
		1175	assert.strictEqual(published._tag, "Some");
		1176	const providers = yield* registry.getProviders;
		1177	assert.deepStrictEqual(providers[0]?.skills, machineProvider.skills);
		1178	assert.deepStrictEqual(
		1179	providers[0]?.workspaceSnapshots?.[0]?.skills,
		1180	scopedProvider.skills,
		1181	);
		1182	yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" });
		1183	assert.strictEqual(yield* Ref.get(snapshotCalls), 2);
		1184
		1185	yield* Ref.set(instancesRef, [rebuiltInstance]);
		1186	yield* PubSub.publish(registryChanges, undefined);
		1187	let rebuilt = yield* registry.getProviders;
		1188	for (
		1189	let attempt = 0;
		1190	attempt < 50 && rebuilt[0]?.checkedAt !== rebuiltProvider.checkedAt;
		1191	attempt += 1
		1192	) {
		1193	yield* Effect.yieldNow;
		1194	rebuilt = yield* registry.getProviders;
		1195	}
		1196	assert.strictEqual(rebuilt[0]?.checkedAt, rebuiltProvider.checkedAt);
		1197	assert.strictEqual(rebuilt[0]?.workspaceSnapshots, undefined);
		1198	}).pipe(Effect.provide(runtimeServices));
		1199	}),
		1200	);
		1201
1007	it.effect("refreshes OpenCode catalogs and preserves other providers", () =>	1202	it.effect("refreshes OpenCode catalogs and preserves other providers", () =>
1008	Effect.gen(function* () {	1203	Effect.gen(function* () {
1009	const codexDriver = ProviderDriverKind.make("codex");	1204	const codexDriver = ProviderDriverKind.make("codex");

apps/server/src/provider/Layers/ProviderRegistry.ts+24−0

@@ -188,6 +188,30 @@ export const mergeProviderSnapshot = ( · 187 unmodified lines
188	: {}),	188	: {}),
189	};	189	};
190		190
		191	export const mergeProviderSnapshots = (
		192	previousProviders: ReadonlyArray<ServerProvider>,
		193	nextProviders: ReadonlyArray<ServerProvider>,
		194	): ReadonlyArray<ServerProvider> => {
		195	const mergedProviders = new Map(
		196	previousProviders.map((provider) => [snapshotInstanceKey(provider), provider] as const),
		197	);
		198
		199	for (const provider of nextProviders) {
		200	mergedProviders.set(
		201	snapshotInstanceKey(provider),
		202	mergeProviderSnapshot(mergedProviders.get(snapshotInstanceKey(provider)), provider),
		203	);
		204	}
		205
		206	return orderProviderSnapshots([...mergedProviders.values()]);
		207	};
		208
		209	export const selectProvidersByKind = (
		210	providers: ReadonlyArray<ServerProvider>,
		211	providerKinds: ReadonlySet<ProviderDriverKind>,
		212	): ReadonlyArray<ServerProvider> =>
		213	providers.filter((provider) => providerKinds.has(provider.driver));
		214
191	export const haveProvidersChanged = (	215	export const haveProvidersChanged = (
192	previousProviders: ReadonlyArray<ServerProvider>,	216	previousProviders: ReadonlyArray<ServerProvider>,
193	nextProviders: ReadonlyArray<ServerProvider>,	217	nextProviders: ReadonlyArray<ServerProvider>,

apps/server/src/provider/ProviderDriver.ts+4−2

   ProviderDriverKind,
   ProviderInstanceEnvironment,
   ProviderInstanceId,
+  ServerProvider,
 } from "@t3tools/contracts";
 import type * as Effect from "effect/Effect";
 import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
-import type { TextGenerationShape } from "../textGeneration/TextGeneration.ts";
+import type { TextGeneration } from "../textGeneration/TextGeneration.ts";
 import type { ProviderAdapterV2Shape } from "../orchestration-v2/ProviderAdapter.ts";
 import type { ProviderDriverError } from "./Errors.ts";
 import type { ServerProviderShape } from "./Services/ServerProvider.ts";
   readonly accentColor?: string | undefined;
   readonly enabled: boolean;
   readonly snapshot: ServerProviderShape;
+  readonly snapshotForCwd?: (cwd: string) => Effect.Effect<ServerProvider, ProviderDriverError>;
   readonly orchestrationAdapter: ProviderAdapterV2Shape;
-  readonly textGeneration: TextGenerationShape;
+  readonly textGeneration: TextGeneration["Service"];
 }
 export interface ProviderContinuationIdentity {

apps/server/src/provider/acp/AcpSessionRuntime.ts+18−3

      * @see https://agentclientprotocol.com/protocol/extensibility
      */
     readonly handleExtNotification: EffectAcpClient.AcpClient["Service"]["handleExtNotification"];
+    /**
+     * Sends only `initialize` and returns the agent's response. Health probes use this to read
+     * advertised capabilities without authenticating or opening a session, so a probe can never
+     * start an interactive login or boot MCP servers.
+     * @see https://agentclientprotocol.com/protocol/schema#initialize
+     */
+    readonly initialize: () => Effect.Effect<
+      EffectAcpSchema.InitializeResponse,
+      EffectAcpErrors.AcpError
+    >;
     /**
      * Initializes the ACP connection, authenticates, and loads, resumes, or creates the session.
      * Concurrent calls share the same in-flight startup and a failed startup may be retried.
       sessionId?: string,
     ) => Effect.Effect<EffectAcpSchema.CloseSessionResponse, EffectAcpErrors.AcpError>;
     /**
-     * Sends a prompt turn to the active session.
+     * Sends a prompt turn to the active session. `options.dispatched` settles once the
+     * `session/prompt` RPC is registered as the active prompt, so a caller that forks this
+     * effect knows when a later `cancel` will target this prompt.
      * @see https://agentclientprotocol.com/protocol/schema#session/prompt
      */
     readonly prompt: (
       payload: Omit<EffectAcpSchema.PromptRequest, "sessionId">,
+      options?: { readonly dispatched?: Deferred.Deferred<void> },
     ) => Effect.Effect<EffectAcpSchema.PromptResponse, EffectAcpErrors.AcpError>;
     /**
      * Sends a real ACP `session/cancel` notification for the active session.
             );
           }),
         ),
-      prompt: (payload) =>
+      prompt: (payload, promptOptions?) =>
         promptSerializationSemaphore.withPermit(
           Effect.gen(function* () {
             const started = yield* getStartedState;
                 if (Option.isSome(activePromptFiber)) {
                   yield* Fiber.interrupt(activePromptFiber.value).pipe(Effect.ignore);
                 }
+                // Await the notification write so a replacement session/prompt
+                // cannot race ahead of session/cancel on the wire.
                 yield* acp.agent
                   .cancel({
                     sessionId: started.sessionId,
                     ...(options.cancelMeta === undefined ? {} : { _meta: options.cancelMeta }),
                   })
-                  .pipe(Effect.ignore, Effect.forkIn(runtimeScope));
+                  .pipe(Effect.ignore);
               }),
         ),
       ),

apps/server/src/provider/acp/GrokAcpSupport.ts+5−3

   readonly requestedReasoningEffort?: string | undefined;
   readonly mapError: (cause: EffectAcpErrors.AcpError) => E;
 }): Effect.Effect<string | undefined, E> {
-  const modelChanged =
+  // The product slug is never sent over the wire; it keeps the session's current model.
-    input.requestedModelId !== undefined && input.requestedModelId !== input.currentModelId;
+  const requestedModelId =
+    input.requestedModelId === GROK_DEFAULT_MODEL_SLUG ? undefined : input.requestedModelId;
+  const modelChanged = requestedModelId !== undefined && requestedModelId !== input.currentModelId;
   const reasoningProvided = input.requestedReasoningEffort !== undefined;
   const reasoningEffort = reasoningProvided
     ? normalizeGrokReasoningEffort(input.requestedReasoningEffort)
     : undefined;
   const reasoningEffortChanged =
     reasoningProvided && reasoningEffort !== input.currentReasoningEffort;
-  const targetModelId = input.requestedModelId ?? input.currentModelId;
+  const targetModelId = requestedModelId ?? input.currentModelId;
   if ((!modelChanged && !reasoningEffortChanged) || targetModelId === undefined) {
     return Effect.succeed(input.currentModelId);
   }

apps/server/src/provider/acp/XAiAcpExtension.ts+11−8

     return {
       ...runtime,
-      prompt: (payload) =>
+      prompt: (payload, promptOptions?) =>
         Effect.gen(function* () {
           const started = yield* runtime.start();
           const promptId = yield* allocatePromptFallbackId;
             agentResult: null,
           });
           const promptRpcFiber = yield* runtime
-            .prompt({
+            .prompt(
-              ...payload,
+              {
-              _meta: {
+                ...payload,
-                ...payload._meta,
+                _meta: {
-                promptId: fallback.promptId,
+                  ...payload._meta,
-                requestId: fallback.promptId,
+                  promptId: fallback.promptId,
+                  requestId: fallback.promptId,
+                },
               },
-            })
+              promptOptions,
+            )
             .pipe(Effect.forkChild);
           return yield* Effect.raceFirst(
             Fiber.join(promptRpcFiber).pipe(

apps/server/src/ws.ts+37−2

@@ -387,6 +387,10 @@ const ServerWsRpcGroup = WsRpcGroup; · 386 unmodified lines
387	// past this gap a single O(active-threads) snapshot is cheaper and bounded.	387	// past this gap a single O(active-threads) snapshot is cheaper and bounded.
388	// Matches the event store's default page size (DEFAULT_READ_FROM_SEQUENCE_LIMIT).	388	// Matches the event store's default page size (DEFAULT_READ_FROM_SEQUENCE_LIMIT).
389	const SHELL_RESUME_MAX_GAP = 1_000;	389	const SHELL_RESUME_MAX_GAP = 1_000;
		390	// Row count alone does not bound replay memory: a few events with large tool
		391	// payloads can decode to gigabytes. Before replaying, sum the serialized
		392	// payload bytes of the range in SQL and reset with a snapshot past this budget.
		393	const ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES = 8 * 1024 * 1024;
390		394
391	function toAuthAccessStreamEvent(	395	function toAuthAccessStreamEvent(
392	change: PairingGrantStore.BootstrapCredentialChange \| SessionStore.SessionCredentialChange,	396	change: PairingGrantStore.BootstrapCredentialChange \| SessionStore.SessionCredentialChange,
@@ -523,6 +527,32 @@ const makeWsRpcLayer = ( · 130 unmodified lines
523	const threadManagement = yield* ThreadManagementService.ThreadManagementService;	527	const threadManagement = yield* ThreadManagementService.ThreadManagementService;
524	const applicationEvents = yield* OrchestrationEventStore.OrchestrationEventStore;	528	const applicationEvents = yield* OrchestrationEventStore.OrchestrationEventStore;
525	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;	529	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;
		530	const canReplayPersistedRange = Effect.fnUntraced(function* (
		531	afterSequence: number,
		532	headSequence: number,
		533	maxGap: number,
		534	) {
		535	const replayGap = headSequence - afterSequence;
		536	if (replayGap < 0 \|\| replayGap > maxGap) {
		537	return false;
		538	}
		539	const stats = yield* projectionSnapshotQuery.getEventReplayStats({
		540	fromSequenceExclusive: afterSequence,
		541	toSequenceInclusive: headSequence,
		542	});
		543	if (stats.payloadBytes > ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES) {
		544	yield* Effect.logDebug("orchestration replay replaced by snapshot", {
		545	afterSequence,
		546	headSequence,
		547	replayGap,
		548	eventCount: stats.eventCount,
		549	payloadBytes: stats.payloadBytes,
		550	payloadBudgetBytes: ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES,
		551	});
		552	return false;
		553	}
		554	return true;
		555	});
526	const providerSessionsV2 = yield* ProviderSessionManagerV2;	556	const providerSessionsV2 = yield* ProviderSessionManagerV2;
527	const analytics = yield* AnalyticsService.AnalyticsService;	557	const analytics = yield* AnalyticsService.AnalyticsService;
528	// Client-origin attribution (#7774): every thread/turn the connecting	558	// Client-origin attribution (#7774): every thread/turn the connecting
@@ -1065,8 +1095,13 @@ const makeWsRpcLayer = ( · 536 unmodified lines
1065	}	1095	}
1066		1096
1067	const highWater = yield* applicationEvents.latestApplicationSequence;	1097	const highWater = yield* applicationEvents.latestApplicationSequence;
1068	const replayGap = highWater - input.afterSequence;	1098	if (
1069	if (replayGap < 0 \|\| replayGap > SHELL_RESUME_MAX_GAP) {	1099	!(yield* canReplayPersistedRange(
		1100	input.afterSequence,
		1101	highWater,
		1102	SHELL_RESUME_MAX_GAP,
		1103	))
		1104	) {
1070	const loaded = yield* loadSnapshot();	1105	const loaded = yield* loadSnapshot();
1071	return composeShellStreamWithEnrichment({	1106	return composeShellStreamWithEnrichment({
1072	initial: initialSnapshotItems(loaded),	1107	initial: initialSnapshotItems(loaded),

apps/web/src/components/ChatView.logic.test.ts+1−1

@@ -10,7 +10,7 @@ import { · 9 unmodified lines
10	} from "@t3tools/contracts";	10	} from "@t3tools/contracts";
11	import type { CodexArtifactTemplate } from "@t3tools/client-runtime/codex-artifact-templates";	11	import type { CodexArtifactTemplate } from "@t3tools/client-runtime/codex-artifact-templates";
12	import * as DateTime from "effect/DateTime";	12	import * as DateTime from "effect/DateTime";
13	import { describe, expect, it } from "vite-plus/test";	13	import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
14		14
15	import type { Thread } from "../types";	15	import type { Thread } from "../types";
16	import { makeThreadFixture } from "../test-fixtures";	16	import { makeThreadFixture } from "../test-fixtures";

apps/web/src/components/ChatView.logic.ts+16−0

@@ -87,6 +87,22 @@ export function shouldDockDraftHeroForSubmission(input: { · 86 unmodified lines
87	);	87	);
88	}	88	}
89		89
		90	export function toolGroupConsumesUpwardNavigation(target: EventTarget \| null): boolean {
		91	const elementTarget = target instanceof Element ? target : null;
		92	const group = elementTarget?.closest<HTMLElement>("[data-tool-group-scroll]");
		93	if (!group) return false;
		94
		95	// A nested result or the group itself can consume an upward scroll.
		96	for (let element = elementTarget; element; element = element.parentElement) {
		97	if (element.scrollTop > 0) {
		98	const overflowY = getComputedStyle(element).overflowY;
		99	if (overflowY === "auto" \|\| overflowY === "scroll") return true;
		100	}
		101	if (element === group) break;
		102	}
		103	return false;
		104	}
		105
90	export function resolveDraftHeroState(input: {	106	export function resolveDraftHeroState(input: {
91	isLocalDraftThread: boolean;	107	isLocalDraftThread: boolean;
92	hasTimelineEntries: boolean;	108	hasTimelineEntries: boolean;

apps/web/src/components/ChatView.tsx+67−16

 import {
+  type AssistantCitation,
   type ApprovalRequestId,
   type ChatFileAttachment,
   DEFAULT_MODEL,
 } from "../state/server";
 import { terminalEnvironment } from "../state/terminal";
 import { threadEnvironment } from "../state/threads";
+import { resolveProviderSkillsForCwd } from "@t3tools/client-runtime/providerSkills";
 import { vcsEnvironment } from "../state/vcs";
 import { useEnvironments, usePrimaryEnvironment } from "../state/environments";
 import {
 import { DraftHeroHeadline } from "./chat/DraftHeroHeadline";
 import { ExpandedImageDialog } from "./chat/ExpandedImageDialog";
 import { PullRequestThreadDialog } from "./PullRequestThreadDialog";
+import type { AssistantCitationRequest } from "./chat/AssistantCitationSource";
 import { MessagesTimeline, type MessagesTimelineHistoryControls } from "./chat/MessagesTimeline";
 import { resolveTimelineIsAtEnd } from "./chat/MessagesTimeline.logic";
 import { ChatHeader } from "./chat/ChatHeader";
   shouldShowComposerContextStrip,
   startNewThreadForProject,
   codexArtifactTemplatePromptToAppend,
+  toolGroupConsumesUpwardNavigation,
   waitForStartedServerThread,
 } from "./ChatView.logic";
 import { useLocalStorage } from "~/hooks/useLocalStorage";
     shellExists: serverThread !== null,
     status: threadStatus,
   });
+  const threadDetailLoading = threadSyncPhase === "loading";
   // Latest provider-reported context usage (#8144): the newest turn that has
   // a report wins; stale turns keep the meter alive between turns.
   const activeThreadLiveTokenUsage = useMemo(() => {
   const composerElementContextsRef = useRef<ElementContextDraft[]>([]);
   const localComposerRef = useRef<ChatComposerHandle | null>(null);
   const composerRef = useComposerHandleContext() ?? localComposerRef;
+  const citeAssistantText = useCallback(
+    (citation: AssistantCitation, sourceAnchor: AssistantCitationSourceAnchor) => {
+      const inserted = composerRef.current?.citeAssistantText(citation, sourceAnchor) ?? false;
+      if (!inserted) {
+        toastManager.add({
+          type: "warning",
+          title: "The composer is not ready",
+          description:
+            "Try citing the selection after the connection or pending input is resolved.",
+        });
+      }
+      return inserted;
+    },
+    [composerRef],
+  );
   const [showScrollToBottom, setShowScrollToBottom] = useState(false);
   const [isWorkspaceFileDragActive, setIsWorkspaceFileDragActive] = useState(false);
   const [expandedImage, setExpandedImage] = useState<ExpandedImagePreview | null>(null);
   }, [setDismissedVersionMismatchKey, versionMismatchDismissKey]);
   const serverUpdateEnvironmentId = activeThread?.environmentId ?? null;
   const versionMismatchSelfUpdate = resolveServerSelfUpdateCapability(serverConfig);
+  const versionMismatchDesktopAppUpdate = supportsDesktopAppUpdate(serverConfig);
   const serverUpdateState = useAtomValue(
     serverEnvironment.updateStateAtom(serverUpdateEnvironmentId),
   );
             />
           ),
           title: `${unavailableConnection.phase === "connecting" ? "Connecting" : "Reconnecting"} to ${activeEnvironmentUnavailableState.label}`,
-          description: "It may be finishing an update. One moment.",
+          description: "Finishing an update",
         });
       } else {
         items.push({
           id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`,
           variant: unavailableConnection.phase === "error" ? "error" : "warning",
           icon: <WifiOffIcon />,
-          title: `${activeEnvironmentUnavailableState.label}: ${connectionStatusTitle(unavailableConnection)}`,
+          title: `${activeEnvironmentUnavailableState.label} is ${environmentReconnecting ? "reconnecting" : "offline"}`,
-          description:
+          description: environmentReconnecting ? "Trying again" : "Reconnect to continue",
-            unavailableConnection.error ??
-            "Reconnect this environment before sending messages or running actions.",
           actions: (
             <>
               <Button
                 size="xs"
+                variant="ghost"
                 disabled={environmentReconnecting}
                 onClick={() =>
                   void handleReconnectActiveEnvironment(
               </Button>
               <Button
                 size="xs"
-                variant="outline"
+                variant="ghost"
                 onClick={() => void navigate({ to: "/settings/connections" })}
               >
                 Connections
             "Server update available"
           ),
         description:
-          !updateInProgress && !updateFailed && versionMismatchSelfUpdate === "desktop-managed"
+          !updateInProgress &&
-            ? serverUpdateGuidance(versionMismatchSelfUpdate, versionMismatchServerLabel)
+          !updateFailed &&
+          versionMismatchSelfUpdate !== null &&
+          (versionMismatchSelfUpdate !== "desktop-managed" || !versionMismatchDesktopAppUpdate)
+            ? serverUpdateGuidance(versionMismatchSelfUpdate)
             : undefined,
-        // The desktop-managed guidance is already the description; the action
-        // slot would only repeat it.
         actions:
           updateInProgress ||
           !versionMismatch ||
-          versionMismatchSelfUpdate === "desktop-managed" ? undefined : (
+          (versionMismatchSelfUpdate === "desktop-managed" &&
+            !versionMismatchDesktopAppUpdate) ? undefined : (
             <ServerUpdateAction
               environmentId={serverUpdateEnvironmentId}
               serverLabel={versionMismatchServerLabel}
               selfUpdate={versionMismatchSelfUpdate}
+              desktopAppUpdate={versionMismatchDesktopAppUpdate}
               targetVersion={versionMismatch.clientVersion}
               label={updateFailed ? "Retry" : "Update"}
+              variant="ghost"
             />
           ),
         ...(updateInProgress || (!updateFailed && !versionMismatchDismissKey)
     versionMismatchDismissKey,
     serverUpdateEnvironmentId,
     versionMismatchSelfUpdate,
+    versionMismatchDesktopAppUpdate,
     versionMismatchServerLabel,
   ]);
   const providerStatuses = serverConfig?.providers ?? EMPTY_PROVIDERS;
         // Only an upward wheel is a navigation intent; wheeling down while
         // following either does nothing (at the end) or moves toward it.
         const handleWheel = (event: WheelEvent) => {
-          if (event.deltaY < 0 && contentScrollsUp()) {
+          if (
+            event.deltaY < 0 &&
+            contentScrollsUp() &&
+            !toolGroupConsumesUpwardNavigation(event.target)
+          ) {
             handleManualNavigation();
           }
         };
             case "PageUp":
             case "Home":
             case "ArrowUp":
-              if (contentScrollsUp()) {
+              if (contentScrollsUp() && !toolGroupConsumesUpwardNavigation(event.target)) {
                 handleManualNavigation();
               }
               break;
   // The stack renders items[0] front-most and tucks the rest behind hover, so
   // ordering is priority: system banners, then the branch-mismatch notice,
   // and the informational parked-thread banner last — it must never cover another.
+  // A woken thread announces itself in the open view, not just the sidebar
+  // pill. Dismissing marks the wake as seen (same acknowledgment as the
+  // pill); sending a message clears it as a side effect of the send path.
+  const wokeThreadBannerItem = useMemo<ComposerBannerStackItem | null>(() => {
+    if (!activeThreadWokeVisible) {
+      return null;
+    }
+    return {
+      id: `thread-woke:${activeThread?.id ?? "unknown"}`,
+      variant: "info",
+      icon: <AlarmClockIcon />,
+      title: "Thread woke from snooze",
+      description: "Send a message to continue",
+      dismissLabel: "Dismiss Woke notification",
+      onDismiss: acknowledgeActiveThreadWoke,
+    };
+  }, [acknowledgeActiveThreadWoke, activeThread?.id, activeThreadWokeVisible]);
   const parkedThreadBannerItem = useMemo<ComposerBannerStackItem | null>(() => {
     if (!activeThreadSnoozed && !activeThreadSettled) {
       return null;
             <div className="relative flex min-h-0 flex-1 flex-col">
               {/* Messages — LegendList handles virtualization and scrolling internally */}
               <MessagesTimeline
+                citationRequest={citationRequest}
+                citationHistoryLoading={threadDetailLoading}
+                onCiteAssistantText={citeAssistantText}
                 key={activeThread.id}
                 isWorking={isWorking}
                 activeTurnInProgress={isWorking || !latestRunSettled}
                 resolvedTheme={resolvedTheme}
                 timestampFormat={timestampFormat}
                 workspaceRoot={activeWorkspaceRoot}
-                skills={activeProviderStatus?.skills ?? EMPTY_PROVIDER_SKILLS}
+                skills={
-                providerStatuses={providerStatuses}
+                  activeProviderStatus
-                runs={serverProjection?.runs ?? EMPTY_PROJECTION_RUNS}
+                    ? resolveProviderSkillsForCwd(activeProviderStatus, gitCwd)
+                    : EMPTY_PROVIDER_SKILLS
+                }
                 anchorMessageId={timelineAnchorMessageId}
                 onAnchorReady={onTimelineAnchorReady}
                 onAnchorSizeChanged={onTimelineAnchorSizeChanged}

apps/web/src/components/DiffPanel.tsx+7−0

@@ -330,6 +330,13 @@ export default function DiffPanel({ · 329 unmodified lines
330	cacheKey: selectedGitSource.diffHash,	330	cacheKey: selectedGitSource.diffHash,
331	});	331	});
332	}, [activeThread, branchDiffPreview.data, getDiffFileContents, selectedGitSource, selectedRunId]);	332	}, [activeThread, branchDiffPreview.data, getDiffFileContents, selectedGitSource, selectedRunId]);
		333	const loadDiffFilesRef = useRef(currentLoadDiffFiles);
		334	loadDiffFilesRef.current = currentLoadDiffFiles;
		335	const loadDiffFiles = useCallback<FileDiffContentsLoader>(async (fileDiff) => {
		336	const loader = loadDiffFilesRef.current;
		337	if (!loader) throw new Error("Diff file contents are unavailable for this selection.");
		338	return loader(fileDiff);
		339	}, []);
333	const localBranchRefs = useEnvironmentQuery(	340	const localBranchRefs = useEnvironmentQuery(
334	selectedRunId === null &&	341	selectedRunId === null &&
335	selectedGitScope === "branch" &&	342	selectedGitScope === "branch" &&

apps/web/src/components/GitActionsControl.tsx+14−7

 } from "@t3tools/contracts";
 import { useNavigate } from "@tanstack/react-router";
 import * as Option from "effect/Option";
-import { useCallback, useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
+import {
+  type MouseEvent,
+  useCallback,
+  useEffect,
+  useEffectEvent,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { flushSync } from "react-dom";
 import {
   CheckIcon,
 import { Spinner } from "~/components/ui/spinner";
 import { toggleVariants } from "~/components/ui/toggle";
 import { cn } from "~/lib/utils";
-import { openPullRequestLink } from "~/lib/openPullRequestLink";
+import { openPullRequestLink, useOpenPrLink } from "~/lib/openPullRequestLink";
 import {
   buildMenuItems,
   formatGitActionElapsed,
     [activeThreadRef],
   );
   const activeServerThread = useThreadShell(activeThreadRef);
+  const openPrLink = useOpenPrLink(activeThreadRef ?? undefined);
   const activeDraftThread = useComposerDraftStore((store) =>
     draftId
       ? store.getDraftSession(draftId)
       const toastCta = actionResult.toast.cta;
       let toastActionProps: {
         children: string;
-        onClick: () => void;
+        onClick: (event: MouseEvent<HTMLButtonElement>) => void;
       } | null = null;
       if (toastCta.kind === "run_action") {
         toastActionProps = {
       } else if (toastCta.kind === "open_pr") {
         toastActionProps = {
           children: toastCta.label,
-          onClick: () => {
+          onClick: (event) => {
-            const api = readLocalApi();
-            if (!api) return;
             closeResultToast();
-            void api.shell.openExternal(toastCta.url);
+            openPrLink(event, toastCta.url);
           },
         };
       }

apps/web/src/components/Sidebar.tsx+11−4

   sortPinnedThreadsForSidebar,
   sortSettledThreadsForSidebar,
   sortThreadsForSidebar,
+  useRetainedValue,
+  useSidebarRowSubscriptionLease,
 } from "./Sidebar.logic";
 import { resolveLocalCheckoutBranchMismatch } from "./BranchToolbar.logic";
 import {
     [thread.environmentId, thread.id],
   );
   const threadKey = scopedThreadKey(threadRef);
+  const { leaseLiveStatus, rowRef } = useSidebarRowSubscriptionLease(props.isActive);
   const isRegeneratingTitle = thread.titleRegeneration != null;
   const lastVisitedAt = useUiStateStore((state) => state.threadLastVisitedAtById[threadKey]);
   const isSelected = useThreadSelectionStore((state) => state.selectedThreadKeys.has(threadKey));
         })
       : null,
   );
+  const visibleGitStatus = useRetainedValue(
+    JSON.stringify([thread.environmentId, gitCwd]),
+    gitStatus.data,
+  );
   const retainTerminalOnBranchMismatch = thread.worktreePath === null;
   const pr = resolveDisplayedThreadPr({
     threadBranch: thread.branch,
-    gitStatus: gitStatus.data,
+    gitStatus: visibleGitStatus,
     snapshot: changeRequestSnapshot,
     retainTerminalOnBranchMismatch,
   });
   });
   const prProvider = resolveDisplayedThreadPrProvider({
     threadBranch: thread.branch,
-    gitStatus: gitStatus.data,
+    gitStatus: visibleGitStatus,
     snapshot: changeRequestSnapshot,
     retainTerminalOnBranchMismatch,
   });
   useEffect(() => {
     const nextSnapshot = nextThreadChangeRequestSnapshot({
       threadBranch: thread.branch,
-      gitStatus: gitStatus.data,
+      gitStatus: visibleGitStatus,
       snapshot: changeRequestSnapshot,
       retainTerminalOnBranchMismatch,
     });
     onChangeRequestSnapshot(threadKey, nextSnapshot);
   }, [
     changeRequestSnapshot,
-    gitStatus.data,
+    visibleGitStatus,
     onChangeRequestSnapshot,
     retainTerminalOnBranchMismatch,
     thread.branch,

apps/web/src/components/chat/ChatComposer.tsx+156−39

 import type {
+  AssistantCitation,
   ChatAttachment as ContractChatAttachment,
   EnvironmentId,
   ModelSelection,
   composerSubmissionIntentForEnter,
   detectComposerTrigger,
   expandCollapsedComposerCursor,
+  formatAssistantCitationForComposer,
   replaceTextRange,
 } from "../../composer-logic";
 import { DISCONNECTED_COMPOSER_PLACEHOLDER } from "../../composerPlaceholder";
 } from "../../lib/attachmentUploadState";
 import { isCommandPaletteOpen } from "../../commandPaletteBus";
 import { getTerminalFocusOwner } from "../../lib/terminalFocus";
+import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
 import { resolveShortcutCommand, shortcutLabelForCommand } from "../../keybindings";
 import {
   type TerminalContextDraft,
   formatProviderSkillDisplayName,
   getProviderSlashCommandsForSlashMenu,
   getProviderSkillsForSlashMenu,
+  resolveProviderSkillsForCwd,
+  resolveProviderSlashCommandsForCwd,
 } from "@t3tools/client-runtime/providerSkills";
 import { searchProviderSkills } from "../../providerSkillSearch";
 import { useMediaQuery } from "../../hooks/useMediaQuery";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { serverEnvironment } from "../../state/server";
 import type { ReviewCommentContext } from "../../reviewCommentContext";
 const runtimeModeConfig: Record<
   focusAt: (cursor: number) => void;
   addDroppedFiles: (files: File[]) => void;
   insertTextAtEnd: (text: string, options?: { ensureLeadingBoundary?: boolean }) => boolean;
+  citeAssistantText: (
+    citation: AssistantCitation,
+    sourceAnchor: AssistantCitationSourceAnchor,
+  ) => boolean;
   openModelPicker: () => void;
   toggleModelPicker: () => void;
   isModelPickerOpen: () => boolean;
     () => selectedProviderEntry?.snapshot ?? null,
     [selectedProviderEntry],
   );
+  const selectedProviderSkills = selectedProviderStatus
+    ? resolveProviderSkillsForCwd(selectedProviderStatus, gitCwd)
+    : [];
+  const selectedProviderSlashCommands = selectedProviderStatus
+    ? resolveProviderSlashCommandsForCwd(selectedProviderStatus, gitCwd)
+    : [];
+  const refreshProviders = useAtomCommand(serverEnvironment.refreshProviders, {
+    reportFailure: false,
+  });
+  const workspaceRefreshKeyRef = useRef<string | null>(null);
+  const hadWorkspaceSnapshotRef = useRef(false);
+  useEffect(() => {
+    const hasWorkspaceSnapshot = Boolean(
+      gitCwd &&
+      selectedProviderStatus?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === gitCwd),
+    );
+    if (hadWorkspaceSnapshotRef.current && !hasWorkspaceSnapshot) {
+      workspaceRefreshKeyRef.current = null;
+    }
+    hadWorkspaceSnapshotRef.current = hasWorkspaceSnapshot;
+  }, [gitCwd, selectedProviderStatus]);
+  useEffect(() => {
+    if (!gitCwd || !selectedProviderEntry) return;
+    const key = `${environmentId}:${selectedProviderEntry.instanceId}:${gitCwd}`;
+    const hasWorkspaceSnapshot = selectedProviderStatus?.workspaceSnapshots?.some(
+      (snapshot) => snapshot.cwd === gitCwd,
+    );
+    if (workspaceRefreshKeyRef.current === key) return;
+    if (hasWorkspaceSnapshot) {
+      workspaceRefreshKeyRef.current = key;
+      return;
+    }
+    workspaceRefreshKeyRef.current = key;
+    void refreshProviders({
+      environmentId,
+      input: { instanceId: selectedProviderEntry.instanceId, cwd: gitCwd },
+    }).then(
+      (result) => {
+        const hasWorkspaceSnapshot =
+          result._tag === "Success" &&
+          result.value.providers
+            .find((provider) => provider.instanceId === selectedProviderEntry.instanceId)
+            ?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === gitCwd);
+        if (!hasWorkspaceSnapshot && workspaceRefreshKeyRef.current === key) {
+          workspaceRefreshKeyRef.current = null;
+        }
+      },
+      () => {
+        if (workspaceRefreshKeyRef.current === key) workspaceRefreshKeyRef.current = null;
+      },
+    );
+  }, [environmentId, gitCwd, refreshProviders, selectedProviderEntry]);
   const selectedProviderModels = useMemo<ReadonlyArray<ServerProvider["models"][number]>>(
     () => selectedProviderEntry?.models ?? [],
     [selectedProviderEntry],
         },
       ] satisfies ReadonlyArray<Extract<ComposerCommandItem, { type: "slash-command" }>>;
       const slashMenuSkills = getProviderSkillsForSlashMenu(
-        selectedProviderStatus?.skills ?? [],
+        selectedProviderSkills,
         settings.showSkillsInSlashMenu,
       );
       const providerSlashCommandItems = getProviderSlashCommandsForSlashMenu(
-        selectedProviderStatus?.slashCommands ?? [],
+        selectedProviderSlashCommands,
         slashMenuSkills,
       ).map((command) => ({
         id: `provider-slash-command:${selectedProvider}:${command.name}`,
       return searchSlashCommandItems(slashCommandItems, query);
     }
     if (composerTrigger.kind === "skill") {
-      return searchProviderSkills(selectedProviderStatus?.skills ?? [], composerTrigger.query).map(
+      return searchProviderSkills(selectedProviderSkills, composerTrigger.query).map((skill) => ({
-        (skill) => ({
+        id: `skill:${selectedProvider}:${skill.name}`,
-          id: `skill:${selectedProvider}:${skill.name}`,
+        type: "skill" as const,
-          type: "skill" as const,
+        provider: selectedProvider,
-          provider: selectedProvider,
+        skill,
-          skill,
+        label: formatProviderSkillDisplayName(skill),
-          label: formatProviderSkillDisplayName(skill),
+        description:
-          description:
+          skill.shortDescription ??
-            skill.shortDescription ??
+          skill.description ??
-            skill.description ??
+          (skill.scope ? `${skill.scope} skill` : "Run provider skill"),
-            (skill.scope ? `${skill.scope} skill` : "Run provider skill"),
+      }));
-        }),
-      );
     }
     return [];
   }, [
     composerTrigger,
     planModeUiEnabled,
     selectedProvider,
+    selectedProviderSkills,
+    selectedProviderSlashCommands,
     selectedProviderStatus,
     settings.showSkillsInSlashMenu,
     workspaceEntries.entries,
       rangeStart: number,
       rangeEnd: number,
       replacement: string,
-      options?: { expectedText?: string; focusEditorAfterReplace?: boolean },
+      options?: {
+        expectedText?: string;
+        focusEditorAfterReplace?: boolean;
+        citationComment?: { start: number; sourceAnchor: AssistantCitationSourceAnchor };
+      },
     ): boolean => {
       const currentText = promptRef.current;
       const safeStart = Math.max(0, Math.min(currentText.length, rangeStart));
       const next = replaceTextRange(promptRef.current, rangeStart, rangeEnd, replacement);
       const nextCursor = collapseExpandedComposerCursor(next.text, next.cursor);
       const nextExpandedCursor = expandCollapsedComposerCursor(next.text, nextCursor);
+      if (options?.citationComment) {
+        composerEditorRef.current?.requestCitationComment({
+          previousValue: currentText,
+          value: next.text,
+          citationStart: options.citationComment.start,
+          sourceAnchor: options.citationComment.sourceAnchor,
+        });
+      }
       promptRef.current = next.text;
       const activePendingQuestion = activePendingProgress?.activeQuestion;
       if (activePendingQuestion && activePendingUserInput) {
     void addComposerAttachments(files);
   };
-  const insertComposerTextAtEnd = (
+  const insertComposerText = useCallback(
-    text: string,
+    (
-    options?: { ensureLeadingBoundary?: boolean },
+      text: string,
-  ): boolean => {
+      position: "cursor" | "end",
-    if (
+      options?: {
-      text.length === 0 ||
+        ensureLeadingBoundary?: boolean;
-      isConnecting ||
+        citationCommentAnchor?: AssistantCitationSourceAnchor;
-      isComposerApprovalState ||
+      },
-      pendingUserInputs.length > 0 ||
+    ): boolean => {
-      projectSelectionRequired
+      if (
-    ) {
+        text.length === 0 ||
-      return false;
+        isConnecting ||
-    }
+        isComposerApprovalState ||
-    const prompt = promptRef.current;
+        pendingUserInputs.length > 0 ||
-    const needsLeadingSpace =
+        projectSelectionRequired ||
-      (options?.ensureLeadingBoundary ?? false) && prompt.length > 0 && !/\s$/.test(prompt);
+        (options?.citationCommentAnchor && !composerEditorRef.current)
-    return applyPromptReplacement(
+      ) {
-      prompt.length,
+        return false;
-      prompt.length,
+      }
-      needsLeadingSpace ? ` ${text}` : text,
+      const prompt = promptRef.current;
-    );
+      const cursor = position === "cursor" ? readComposerSnapshot().expandedCursor : prompt.length;
-  };
+      const needsLeadingSpace =
+        (options?.ensureLeadingBoundary ?? false) &&
+        cursor > 0 &&
+        !/\s/.test(prompt[cursor - 1] ?? "");
+      const rangeEnd = extendReplacementRangeForTrailingSpace(prompt, cursor, text);
+      return applyPromptReplacement(
+        cursor,
+        rangeEnd,
+        needsLeadingSpace ? ` ${text}` : text,
+        options?.citationCommentAnchor
+          ? {
+              citationComment: {
+                start: cursor + (needsLeadingSpace ? 1 : 0),
+                sourceAnchor: options.citationCommentAnchor,
+              },
+              focusEditorAfterReplace: false,
+            }
+          : undefined,
+      );
+    },
+    [
+      applyPromptReplacement,
+      isComposerApprovalState,
+      isConnecting,
+      pendingUserInputs.length,
+      projectSelectionRequired,
+      promptRef,
+      readComposerSnapshot,
+    ],
+  );
+  const insertComposerTextAtEnd = useCallback<ChatComposerHandle["insertTextAtEnd"]>(
+    (text, options) => insertComposerText(text, "end", options),
+    [insertComposerText],
+  );
   // File-tree drags land as mentions. Handled in the capture phase so the
   // editor never sees the drop; the load-bearing rules (native stop, "move"
         focusComposer();
       },
       insertTextAtEnd: insertComposerTextAtEnd,
+      citeAssistantText: (citation, sourceAnchor) =>
+        insertComposerText(
+          formatAssistantCitationForComposer(citation, citation.comment),
+          "cursor",
+          { ensureLeadingBoundary: true, citationCommentAnchor: sourceAnchor },
+        ),
       openModelPicker: () => {
         setIsComposerModelPickerOpen(true);
       },
       composerCursor,
       composerTerminalContexts,
       insertComposerDraftTerminalContext,
+      insertComposerText,
+      insertComposerTextAtEnd,
       promptRef,
       composerImagesRef,
       composerFilesRef,
                       ? composerTerminalContexts
                       : []
                   }
-                  skills={selectedProviderStatus?.skills ?? []}
+                  skills={selectedProviderSkills}
                   {...(showMobilePendingAnswerActions ? { className: "max-sm:pb-11" } : {})}
                   onRemoveTerminalContext={removeComposerTerminalContextFromDraft}
                   onChange={onPromptChange}

apps/web/src/components/chat/ComposerBannerStack.tsx+1−0

@@ -1,3 +1,4 @@
		1	import { InfoIcon } from "lucide-react";
1	import { useEffect, useId, useLayoutEffect, useRef, useState, type ReactNode } from "react";	2	import { useEffect, useId, useLayoutEffect, useRef, useState, type ReactNode } from "react";
2		3
3	import { cn } from "~/lib/utils";	4	import { cn } from "~/lib/utils";

apps/web/src/components/chat/ComposerPrimaryActions.test.tsx+0−21

@@ -44,27 +44,6 @@ function renderPendingActions(isRunning: boolean) { · 43 unmodified lines
44	);	44	);
45	}	45	}
46		46
47	function renderStandaloneStop() {
48	return renderToStaticMarkup(
49	createElement(ComposerPrimaryActions, {
50	compact: true,
51	pendingAction: null,
52	isRunning: true,
53	showPlanFollowUpPrompt: false,
54	promptHasText: false,
55	isSendBusy: false,
56	sendDisabledReason: null,
57	isConnecting: false,
58	isEnvironmentUnavailable: false,
59	isPreparingWorktree: false,
60	hasSendableContent: false,
61	onPreviousPendingQuestion: () => {},
62	onInterrupt: () => {},
63	onImplementPlanInNewThread: () => {},
64	}),
65	);
66	}
67
68	function renderSendButton(sendDisabledReason: string \| null = null) {	47	function renderSendButton(sendDisabledReason: string \| null = null) {
69	return renderToStaticMarkup(	48	return renderToStaticMarkup(
70	createElement(ComposerPrimaryActions, {	49	createElement(ComposerPrimaryActions, {

apps/web/src/components/chat/ComposerStashBadge.tsx+6−1

   }
   return (
-    <ComposerBanner.Root width="content" data-composer-shoulder-tab className="ml-auto">
+    <ComposerBanner.Root
+      density="comfortable"
+      width="content"
+      data-composer-shoulder-tab
+      className="ml-auto"
+    >
       <ComposerBanner.Row
         render={<button type="button" />}
         data-prompt-stash-badge="true"

apps/web/src/components/chat/MessagesTimeline.logic.test.ts+315−57

@@ -11,8 +11,11 @@ import { · 10 unmodified lines
11	normalizeCompactToolLabel,	11	normalizeCompactToolLabel,
12	resolveAssistantMessageCopyState,	12	resolveAssistantMessageCopyState,
13	resolveTimelineToolPresentation,	13	resolveTimelineToolPresentation,
		14	resolveWorkGroupScrollIndex,
		15	shouldFollowWorkGroupAppend,
14	shouldPreserveAssistantLineBreaks,	16	shouldPreserveAssistantLineBreaks,
15	summarizeToolGroup,	17	summarizeToolGroup,
		18	workEntryDisplayLabel,
16	} from "./MessagesTimeline.logic";	19	} from "./MessagesTimeline.logic";
17	import {	20	import {
18	createMessageAttachmentPreviewProjector,	21	createMessageAttachmentPreviewProjector,
@@ -355,6 +358,171 @@ describe("streaming row projection", () => { · 336 unmodified lines
355	});	358	});
356	});	359	});
357		360
		361	describe("expanded tool group scrolling", () => {
		362	const entries = [{ id: "first" }, { id: "second" }];
		363
		364	it("follows appended calls only at the hard end", () => {
		365	const appended = [...entries, { id: "third" }];
		366	expect(shouldFollowWorkGroupAppend(entries, appended, 0)).toBe(true);
		367	expect(shouldFollowWorkGroupAppend(entries, appended, 0.5)).toBe(true);
		368	expect(shouldFollowWorkGroupAppend(entries, appended, 1)).toBe(true);
		369	expect(shouldFollowWorkGroupAppend(entries, appended, 1.01)).toBe(false);
		370	expect(shouldFollowWorkGroupAppend(entries, appended, 10)).toBe(false);
		371	expect(shouldFollowWorkGroupAppend(entries, appended, Infinity)).toBe(false);
		372	});
		373
		374	it("does not follow output updates, prepends, or replacements", () => {
		375	expect(
		376	shouldFollowWorkGroupAppend(
		377	entries,
		378	entries.map((entry) => ({ ...entry })),
		379	0,
		380	),
		381	).toBe(false);
		382	expect(shouldFollowWorkGroupAppend(entries, [{ id: "older" }, ...entries], 0)).toBe(false);
		383	expect(
		384	shouldFollowWorkGroupAppend(
		385	entries,
		386	[{ id: "replacement" }, entries[1]!, { id: "third" }],
		387	0,
		388	),
		389	).toBe(false);
		390	expect(shouldFollowWorkGroupAppend([], entries, 0)).toBe(false);
		391	});
		392
		393	it("restores the visible tool and its offset inside expanded output", () => {
		394	const anchor = { entryId: "second", offset: 120 };
		395	expect(resolveWorkGroupScrollIndex(entries, anchor)).toEqual({ index: 1, viewOffset: -120 });
		396	expect(resolveWorkGroupScrollIndex([{ id: "older" }, ...entries], anchor)).toEqual({
		397	index: 2,
		398	viewOffset: -120,
		399	});
		400	});
		401
		402	it("starts normally when the saved tool no longer exists", () => {
		403	expect(resolveWorkGroupScrollIndex(entries, undefined)).toBeUndefined();
		404	expect(
		405	resolveWorkGroupScrollIndex(entries, { entryId: "removed", offset: 120 }),
		406	).toBeUndefined();
		407	});
		408	});
		409
		410	describe("work entry labels", () => {
		411	const entry = {
		412	id: "tool-1",
		413	createdAt: "2026-09-01T12:00:00Z",
		414	label: "Tool call",
		415	tone: "tool" as const,
		416	};
		417
		418	it.each([
		419	["inProgress", "Clicking in the preview browser"],
		420	["completed", "Clicked in the preview browser"],
		421	["failed", "Failed to click in the preview browser"],
		422	["declined", "Declined to click in the preview browser"],
		423	["stopped", "Stopped clicking in the preview browser"],
		424	] as const)("uses the same friendly %s label in both views", (toolLifecycleStatus, label) => {
		425	const browserEntry = {
		426	...entry,
		427	toolTitle: "T3-code.preview_click",
		428	detail: '{"ok":true}',
		429	toolLifecycleStatus,
		430	};
		431	expect(liveWorkEntryLabel(browserEntry, undefined, toolLifecycleStatus === "inProgress")).toBe(
		432	label,
		433	);
		434	expect(workEntryDisplayLabel(browserEntry, undefined)).toBe(label);
		435	});
		436
		437	it("uses the active summary state for legacy tools without a lifecycle status", () => {
		438	const browserEntry = { ...entry, toolTitle: "T3-code.preview_click" };
		439	expect(liveWorkEntryLabel(browserEntry, undefined, true)).toBe(
		440	"Clicking in the preview browser",
		441	);
		442	expect(liveWorkEntryLabel(browserEntry, undefined, false)).toBe(
		443	"Clicked in the preview browser",
		444	);
		445	});
		446
		447	it("does not describe a finished call as still running while the turn continues", () => {
		448	const browserEntry = {
		449	...entry,
		450	toolTitle: "T3-code.preview_click",
		451	toolLifecycleStatus: "completed" as const,
		452	};
		453	expect(liveWorkEntryLabel(browserEntry, undefined, true)).toBe(
		454	"Clicked in the preview browser",
		455	);
		456	});
		457
		458	it("keeps custom titles and output for unrecognized tools", () => {
		459	const unknownEntry = { ...entry, toolTitle: "mcp__github__search_issues" };
		460	expect(liveWorkEntryLabel(unknownEntry, undefined, true)).toBe("Mcp__github__search_issues");
		461	expect(workEntryDisplayLabel({ ...unknownEntry, detail: "Found 3 issues" }, undefined)).toBe(
		462	"Found 3 issues",
		463	);
		464	});
		465
		466	it("keeps command summaries compact without replacing the full command in expanded rows", () => {
		467	const commandEntry = { ...entry, command: "vp test run", detail: "All tests passed" };
		468	expect(liveWorkEntryLabel(commandEntry, undefined, true)).toBe("Running vp");
		469	expect(liveWorkEntryLabel(commandEntry, undefined, false)).toBe("Ran vp");
		470	expect(workEntryDisplayLabel(commandEntry, undefined)).toBe("vp test run");
		471	});
		472
		473	it("summarizes the program inside a shell wrapper while preserving the expanded command", () => {
		474	const command = "/bin/zsh -lc 'vp test run apps/web/src/session-logic.test.ts'";
		475	const commandEntry = { ...entry, command };
		476	expect(liveWorkEntryLabel(commandEntry, undefined, true)).toBe("Running vp");
		477	expect(liveWorkEntryLabel(commandEntry, undefined, false)).toBe("Ran vp");
		478	expect(workEntryDisplayLabel(commandEntry, undefined)).toBe(command);
		479	});
		480
		481	it.each([
		482	["inProgress", "Running vp"],
		483	["completed", "Ran vp"],
		484	["failed", "Failed vp"],
		485	["declined", "Declined vp"],
		486	["stopped", "Stopped vp"],
		487	] as const)(
		488	"uses the command's %s outcome even while the turn continues",
		489	(toolLifecycleStatus, label) => {
		490	const commandEntry = {
		491	...entry,
		492	command: "/bin/bash -lc 'vp test run'",
		493	toolLifecycleStatus,
		494	};
		495	expect(liveWorkEntryLabel(commandEntry, undefined, true)).toBe(label);
		496	expect(liveWorkEntryLabel(commandEntry, undefined, false)).toBe(label);
		497	},
		498	);
		499
		500	it("gives a completed browser group its own count and summary icon category", () => {
		501	const rows = deriveMessagesTimelineRows({
		502	timelineEntries: [
		503	{
		504	id: "browser-entry",
		505	kind: "work",
		506	createdAt: entry.createdAt,
		507	entry: {
		508	...entry,
		509	itemType: "dynamic_tool",
		510	toolLifecycleStatus: "completed",
		511	toolData: { server: "t3-code", tool: "preview_click" },
		512	},
		513	},
		514	],
		515	isWorking: false,
		516	activeTurnStartedAt: null,
		517	turnDiffSummaryByAssistantMessageId: new Map(),
		518	revertTurnCountByUserMessageId: new Map(),
		519	});
		520	expect(rows).toMatchObject([
		521	{ kind: "work-toggle", summary: "Used browser 1 time", summaryKind: "browser" },
		522	]);
		523	});
		524	});
		525
358	describe("summarizeToolGroup", () => {	526	describe("summarizeToolGroup", () => {
359	const now = DateTime.makeUnsafe("2026-08-29T00:00:00Z");	527	const now = DateTime.makeUnsafe("2026-08-29T00:00:00Z");
360	function work(overrides: Partial<WorkLogEntry> = {}): WorkLogEntry {	528	function work(overrides: Partial<WorkLogEntry> = {}): WorkLogEntry {
@@ -1682,6 +1850,67 @@ describe("deriveMessagesTimelineRows", () => { · 1321 unmodified lines
1682	expect(liveRow?.kind === "work-live" ? liveRow.entry.id : null).toBe("work-1");	1850	expect(liveRow?.kind === "work-live" ? liveRow.entry.id : null).toBe("work-1");
1683	});	1851	});
1684		1852
		1853	it("reuses one activity row for initial thinking and the latest tool", () => {
		1854	const deriveRows = (
		1855	toolLifecycleStatus: "inProgress" \| "completed" \| "failed" \| "declined" \| null,
		1856	) =>
		1857	deriveMessagesTimelineRows({
		1858	timelineEntries:
		1859	toolLifecycleStatus === null
		1860	? []
		1861	: [
		1862	{
		1863	id: "latest-command-entry",
		1864	kind: "work",
		1865	createdAt: "2026-01-01T00:00:05Z",
		1866	entry: {
		1867	id: "latest-command",
		1868	createdAt: "2026-01-01T00:00:05Z",
		1869	runId: "run-1" as never,
		1870	label: toolLifecycleStatus === "inProgress" ? "Running rg" : "Ran rg",
		1871	command: "rg toolCall",
		1872	requestKind: "command",
		1873	tone: "tool" as const,
		1874	toolLifecycleStatus,
		1875	...(toolLifecycleStatus === "inProgress" ? { detail: "exit code 1" } : {}),
		1876	},
		1877	},
		1878	],
		1879	latestRun: {
		1880	runId: "run-1" as never,
		1881	status: "running" as const,
		1882	startedAt: "2026-01-01T00:00:00Z",
		1883	completedAt: null,
		1884	},
		1885	isWorking: true,
		1886	activeTurnStartedAt: "2026-01-01T00:00:00Z",
		1887	turnDiffSummaryByAssistantMessageId: new Map(),
		1888	revertTurnCountByUserMessageId: new Map(),
		1889	});
		1890
		1891	const initialRows = deriveRows(null);
		1892	const runningRows = deriveRows("inProgress");
		1893	const completedRows = deriveRows("completed");
		1894	const failedRows = deriveRows("failed");
		1895	const declinedRows = deriveRows("declined");
		1896	const initialActivityRow = initialRows.find((row) => row.id === "live-activity-row");
		1897	const runningActivityRow = runningRows.find((row) => row.id === "live-activity-row");
		1898	const completedActivityRow = completedRows.find((row) => row.id === "live-activity-row");
		1899
		1900	expect(initialActivityRow).toMatchObject({ kind: "thinking" });
		1901	expect(runningActivityRow).toMatchObject({ kind: "work-live", active: true });
		1902	expect(completedActivityRow).toMatchObject({ kind: "work-live", active: true });
		1903	expect(failedRows.some((row) => row.kind === "work-live")).toBe(false);
		1904	expect(failedRows.at(-1)).toMatchObject({ kind: "thinking", id: "live-activity-row" });
		1905	expect(declinedRows.find((row) => row.kind === "work-live")).toMatchObject({ active: false });
		1906	expect(declinedRows.at(-1)).toMatchObject({ kind: "thinking", id: "live-activity-row" });
		1907	expect(initialRows.filter((row) => row.id === "live-activity-row")).toHaveLength(1);
		1908	expect(runningRows.filter((row) => row.id === "live-activity-row")).toHaveLength(1);
		1909	expect(completedRows.filter((row) => row.id === "live-activity-row")).toHaveLength(1);
		1910	expect(failedRows.filter((row) => row.id === "live-activity-row")).toHaveLength(1);
		1911	expect(declinedRows.filter((row) => row.id === "live-activity-row")).toHaveLength(1);
		1912	});
		1913
1685	it("only shows assistant metadata on the terminal assistant message", () => {	1914	it("only shows assistant metadata on the terminal assistant message", () => {
1686	const rows = deriveMessagesTimelineRows({	1915	const rows = deriveMessagesTimelineRows({
1687	timelineEntries: [	1916	timelineEntries: [
@@ -1766,52 +1995,6 @@ describe("deriveMessagesTimelineRows", () => { · 78 unmodified lines
1766	expect(assistantRow?.showAssistantCopyButton).toBe(false);	1995	expect(assistantRow?.showAssistantCopyButton).toBe(false);
1767	});	1996	});
1768		1997
1769	it("retains a failed command in the summary after a later command succeeds", () => {
1770	const rows = deriveMessagesTimelineRows({
1771	timelineEntries: [
1772	{
1773	id: "work-entry-failed",
1774	kind: "work" as const,
1775	createdAt: "2026-01-01T00:00:01Z",
1776	entry: {
1777	id: "work-failed",
1778	createdAt: "2026-01-01T00:00:01Z",
1779	label: "Ran command",
1780	command: "ssh host true",
1781	detail: "connection refused",
1782	tone: "tool" as const,
1783	itemType: "command_execution" as const,
1784	toolLifecycleStatus: "failed" as const,
1785	},
1786	},
1787	{
1788	id: "work-entry-ok",
1789	kind: "work" as const,
1790	createdAt: "2026-01-01T00:00:02Z",
1791	entry: {
1792	id: "work-ok",
1793	createdAt: "2026-01-01T00:00:02Z",
1794	label: "Ran command",
1795	command: "true",
1796	tone: "tool" as const,
1797	itemType: "command_execution" as const,
1798	toolLifecycleStatus: "completed" as const,
1799	},
1800	},
1801	],
1802	isWorking: false,
1803	turnDiffSummaryByAssistantMessageId: new Map(),
1804	revertTurnCountByUserMessageId: new Map(),
1805	});
1806
1807	expect(rows).toHaveLength(1);
1808	expect(rows[0]).toMatchObject({
1809	kind: "work-toggle",
1810	summary: "Ran 2 commands",
1811	hasFailure: true,
1812	});
1813	});
1814
1815	it("collapses contiguous settled tool entries behind a summary toggle", () => {	1998	it("collapses contiguous settled tool entries behind a summary toggle", () => {
1816	const timelineEntries = [	1999	const timelineEntries = [
1817	{	2000	{
@@ -1885,19 +2068,94 @@ describe("deriveMessagesTimelineRows", () => { · 67 unmodified lines
1885	});	2068	});
1886	expect(expandedRows.map((row) => row.id)).toEqual([	2069	expect(expandedRows.map((row) => row.id)).toEqual([
1887	"work-toggle:work-entry-1",	2070	"work-toggle:work-entry-1",
1888	"work-1",	2071	"work-group:work-entry-1:details",
1889	"work-2",
1890	"work-3",
1891	]);	2072	]);
1892	expect(expandedRows[1]).toMatchObject({	2073	expect(expandedRows.find((row) => row.kind === "work")).toMatchObject({
1893	kind: "work",	2074	isExpandedToolGroup: true,
1894	isExpandedToolGroupEntry: true,	2075	groupedEntries: timelineEntries.map(({ entry }) => entry),
1895	isLastExpandedToolGroupEntry: false,	2076	});
		2077	expect(expandedRows.find((row) => row.kind === "work-toggle")).toMatchObject({
		2078	expanded: true,
		2079	});
		2080	});
		2081
		2082	it.each([true, false])(
		2083	"keeps a large expanded tool run inside one timeline item, live=%s",
		2084	(isWorking) => {
		2085	const runId = RunId.make("run-many-tools");
		2086	const createdAt = "2026-09-01T12:00:00Z";
		2087	const timelineEntries = Array.from({ length: 1_000 }, (_, index) => ({
		2088	id: `tool-entry-${index}`,
		2089	kind: "work" as const,
		2090	createdAt,
		2091	entry: {
		2092	id: `tool-${index}`,
		2093	createdAt,
		2094	runId,
		2095	label: "t3-code.preview_snapshot",
		2096	tone: "tool" as const,
		2097	toolLifecycleStatus:
		2098	isWorking && index === 999 ? ("inProgress" as const) : ("completed" as const),
		2099	},
		2100	}));
		2101	const groupId = "work-group:tool-entry-0";
		2102	const input = {
		2103	timelineEntries,
		2104	isWorking,
		2105	expandedRunIds: new Set([runId]),
		2106	latestRun: {
		2107	runId,
		2108	status: isWorking ? ("running" as const) : ("completed" as const),
		2109	startedAt: createdAt,
		2110	completedAt: isWorking ? null : createdAt,
		2111	},
		2112	activeTurnStartedAt: isWorking ? createdAt : null,
		2113	turnDiffSummaryByAssistantMessageId: new Map(),
		2114	revertTurnCountByUserMessageId: new Map(),
		2115	};
		2116	const expandedRows = deriveMessagesTimelineRows({
		2117	...input,
		2118	expandedWorkGroupIds: new Set([groupId]),
		2119	});
		2120	const groupRows = expandedRows.filter((row) => row.kind === "work");
		2121	expect(groupRows).toHaveLength(1);
		2122	expect(groupRows[0]?.groupedEntries.map(({ id }) => id)).toEqual(
		2123	timelineEntries.map(({ entry }) => entry.id),
		2124	);
		2125	expect(groupRows[0]?.id).toBe(`${groupId}:details`);
		2126	expect(deriveMessagesTimelineRows(input).some((row) => row.kind === "work")).toBe(false);
		2127	},
		2128	);
		2129
		2130	it.each([
		2131	["recovered", ["failed", "completed"], false],
		2132	["ending in failure", ["completed", "failed"], true],
		2133	["failed", ["failed", "failed"], true],
		2134	] as const)("uses the final call for %s tool groups", (_, statuses, hasFailure) => {
		2135	const timelineEntries = statuses.map((status, index) => ({
		2136	id: `work-entry-${index}`,
		2137	kind: "work" as const,
		2138	createdAt: `2026-01-01T00:00:0${index}Z`,
		2139	entry: {
		2140	id: `work-${index}`,
		2141	createdAt: `2026-01-01T00:00:0${index}Z`,
		2142	label: "Ran command",
		2143	tone: "tool" as const,
		2144	itemType: "command_execution" as const,
		2145	toolLifecycleStatus: status,
		2146	},
		2147	}));
		2148
		2149	const rows = deriveMessagesTimelineRows({
		2150	timelineEntries,
		2151	isWorking: false,
		2152	turnDiffSummaryByAssistantMessageId: new Map(),
		2153	revertTurnCountByUserMessageId: new Map(),
1896	});	2154	});
1897	expect(expandedRows[3]).toMatchObject({	2155
1898	kind: "work",	2156	expect(rows.find((row) => row.kind === "work-toggle")).toMatchObject({
1899	isExpandedToolGroupEntry: true,	2157	hiddenCount: 2,
1900	isLastExpandedToolGroupEntry: true,	2158	hasFailure,
1901	});	2159	});
1902	});	2160	});
1903	});	2161	});

apps/web/src/components/chat/MessagesTimeline.logic.ts+119−40

 import * as Equal from "effect/Equal";
 import { renderCodexDirectivesForCopy } from "@t3tools/client-runtime/codex-markdown-directives";
+import { commandProgramName } from "@t3tools/client-runtime/work-log/command-label";
 import {
+  normalizeCompactToolLabel,
+  resolveWorkEntryToolPresentation,
   summarizeToolGroup,
   toolGroupSummaryKind,
   type ToolGroupSummaryKind,
   type T3McpToolPresentation,
   type T3McpToolSummaryAction,
 } from "@t3tools/shared/t3McpToolPresentation";
+import { formatWorkspaceRelativePath } from "../../filePathDisplay";
 function timelineEntryRunId(entry: TimelineEntry): RunId | null {
   if (entry.kind === "message") {
   );
 }
+export function workEntryDisplayLabel(entry: WorkLogEntry, workspaceRoot: string | undefined) {
+  const toolPresentation = resolveWorkEntryToolPresentation(entry);
+  if (toolPresentation) return toolPresentation.displayName;
+  if (entry.command) return entry.command;
+  if (entry.detail) return entry.detail;
+  const [firstPath] = entry.changedFiles ?? [];
+  if (firstPath) {
+    const path = formatWorkspaceRelativePath(firstPath, workspaceRoot);
+    return entry.changedFiles!.length === 1
+      ? path
+      : `${path} +${entry.changedFiles!.length - 1} more`;
+  }
+  const heading = normalizeCompactToolLabel(entry.toolTitle || entry.label);
+  return `${heading.charAt(0).toUpperCase()}${heading.slice(1)}`;
+}
+export function liveWorkEntryLabel(
+  entry: WorkLogEntry,
+  workspaceRoot: string | undefined,
+  active: boolean,
+) {
+  const toolPresentation = resolveWorkEntryToolPresentation(
+    entry,
+    active ? "inProgress" : "completed",
+  );
+  if (toolPresentation) return toolPresentation.displayName;
+  const command = entry.command?.trim();
+  if (command) {
+    const status = entry.toolLifecycleStatus ?? (active ? "inProgress" : "completed");
+    const verb =
+      status === "inProgress"
+        ? "Running"
+        : status === "failed"
+          ? "Failed"
+          : status === "declined"
+            ? "Declined"
+            : status === "stopped"
+              ? "Stopped"
+              : "Ran";
+    return `${verb} ${commandProgramName(command) ?? "command"}`;
+  }
+  return workEntryDisplayLabel(entry, workspaceRoot);
+}
 export function workEntryIsVisibleInGroup(
   entry: WorkLogEntry,
   expandedToolGroupEntry = false,
 export const TIMELINE_CONTENT_MAX_WIDTH = 768;
 export const TIMELINE_MINIMAP_PERSISTENT_GUTTER = 48;
+export interface WorkGroupScrollAnchor {
+  readonly entryId: string;
+  readonly offset: number;
+}
+/** Restore a visible tool, including a position partway through its expanded output. */
+export function resolveWorkGroupScrollIndex(
+  entries: ReadonlyArray<{ readonly id: string }>,
+  anchor: WorkGroupScrollAnchor | undefined,
+): { index: number; viewOffset: number } | undefined {
+  if (!anchor) return undefined;
+  const index = entries.findIndex((entry) => entry.id === anchor.entryId);
+  return index < 0 ? undefined : { index, viewOffset: -anchor.offset };
+}
+/** Only newly appended calls may follow the end, never status or output updates. */
+export function shouldFollowWorkGroupAppend(
+  previous: ReadonlyArray<{ readonly id: string }>,
+  entries: ReadonlyArray<{ readonly id: string }>,
+  distanceFromEnd: number,
+): boolean {
+  return (
+    previous.length > 0 &&
+    entries.length > previous.length &&
+    distanceFromEnd <= 1 &&
+    previous.every((entry, index) => entry.id === entries[index]?.id)
+  );
+}
 export interface TimelineEndState {
   readonly isAtEnd?: boolean;
   readonly isNearEnd?: boolean;
       id: string;
       createdAt: string;
       groupedEntries: WorkLogEntry[];
-      isExpandedToolGroupEntry: boolean;
+      isExpandedToolGroup: boolean;
-      isLastExpandedToolGroupEntry: boolean;
     }
   | {
       kind: "work-live";
 export type TimelineToolPresentation = T3McpToolPresentation;
 export const resolveTimelineToolPresentation = resolveT3McpToolPresentation;
+function expandedWorkGroupRow(
+  groupId: string,
+  createdAt: string,
+  groupedEntries: WorkLogEntry[],
+): Extract<MessagesTimelineRow, { kind: "work" }> {
+  return {
+    kind: "work",
+    id: `${groupId}:details`,
+    createdAt,
+    groupedEntries,
+    isExpandedToolGroup: true,
+  };
+}
 export function resolveAssistantMessageCopyState({
   text,
   showCopyButton,
     latestRunningToolEntry !== undefined ||
     (latestVisibleToolEntry !== undefined &&
       workEntryIndicatesToolSuccess(latestVisibleToolEntry.entry));
+  const latestToolFailed =
+    latestRunningToolEntry === undefined &&
+    latestVisibleToolEntry !== undefined &&
+    latestVisibleToolEntry.entry.toolLifecycleStatus !== "declined" &&
+    workEntryDisplayIndicatesToolFailure(latestVisibleToolEntry.entry);
   const activeWorkPlacementEntryId = latestVisibleToolEntry?.id;
   const activeWorkRow =
-    activeWorkAnchor && latestVisibleToolEntry
+    activeWorkAnchor && latestVisibleToolEntry && !latestToolFailed
       ? (() => {
           const groupId = workGroupId(activeWorkAnchor.id);
           return {
         })()
       : null;
   const activeWorkEntryIds = new Set(
-    activeWorkRow === null ? [] : activeToolEntries.map((entry) => entry.id),
+    activeWorkRow !== null || latestToolFailed ? activeToolEntries.map((entry) => entry.id) : [],
   );
   const appendWorkingRow = () => {
     nextRows.push({
     nextRows.push(activeWorkRow);
     hasActivityRow ||= activeWorkRow.active;
     if (!activeWorkRow.expanded) return;
-    for (const [entryIndex, workEntry] of activeWorkRow.groupedEntries.entries()) {
+    nextRows.push(
-      nextRows.push({
+      expandedWorkGroupRow(
-        kind: "work",
+        activeWorkRow.groupId,
-        id: workEntry.id,
+        activeWorkRow.createdAt,
-        createdAt: workEntry.createdAt,
+        activeWorkRow.groupedEntries,
-        groupedEntries: [workEntry],
+      ),
-        isExpandedToolGroupEntry: true,
+    );
-        isLastExpandedToolGroupEntry: entryIndex === activeWorkRow.groupedEntries.length - 1,
-      });
-    }
   };
   for (let index = 0; index < input.timelineEntries.length; index += 1) {
           id: timelineEntry.id,
           createdAt: timelineEntry.createdAt,
           groupedEntries: [timelineEntry.entry],
-          isExpandedToolGroupEntry: false,
+          isExpandedToolGroup: false,
-          isLastExpandedToolGroupEntry: false,
         });
         continue;
       }
           });
           hasActivityRow = true;
           if (expanded) {
-            for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {
+            nextRows.push(
-              nextRows.push({
+              expandedWorkGroupRow(groupId, timelineEntry.createdAt, visibleGroupedEntries),
-                kind: "work",
+            );
-                id: workEntry.id,
-                createdAt: workEntry.createdAt,
-                groupedEntries: [workEntry],
-                isExpandedToolGroupEntry: true,
-                isLastExpandedToolGroupEntry: entryIndex === visibleGroupedEntries.length - 1,
-              });
-            }
           }
         } else {
           const groupId = workGroupId(timelineEntry.id);
           const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;
           const summaryKind = toolGroupSummaryKind(visibleGroupedEntries);
           const groupSummary = summarizeToolGroup(visibleGroupedEntries);
+          const latestToolEntry = visibleGroupedEntries.findLast(workLogEntryIsToolLike);
           nextRows.push({
             kind: "work-toggle",
             id: `work-toggle:${timelineEntry.id}`,
                 ? visibleGroupedEntries[0]!.label
                 : groupSummary.summary,
             summaryKind,
-            hasFailure: groupSummary.hasFailure,
+            hasFailure:
+              latestToolEntry !== undefined &&
+              workEntryDisplayIndicatesToolFailure(latestToolEntry),
           });
           if (expanded) {
-            for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {
+            nextRows.push(
-              nextRows.push({
+              expandedWorkGroupRow(groupId, timelineEntry.createdAt, visibleGroupedEntries),
-                kind: "work",
+            );
-                id: workEntry.id,
-                createdAt: workEntry.createdAt,
-                groupedEntries: [workEntry],
-                isExpandedToolGroupEntry: true,
-                isLastExpandedToolGroupEntry: entryIndex === visibleGroupedEntries.length - 1,
-              });
-            }
           }
         }
       }
   if (input.isWorking && activeTurnHeaderIndex === input.timelineEntries.length) {
     appendWorkingRow();
   }
-  if (input.isWorking && !hasActivityRow) {
+  if (input.isWorking && (!hasActivityRow || latestToolFailed)) {
     nextRows.push({
       kind: "thinking",
       id: LIVE_ACTIVITY_ROW_ID,
     case "work": {
       const bw = b as typeof a;
       return (
-        a.isExpandedToolGroupEntry === bw.isExpandedToolGroupEntry &&
+        a.isExpandedToolGroup === bw.isExpandedToolGroup &&
-        a.isLastExpandedToolGroupEntry === bw.isLastExpandedToolGroupEntry &&
         Equal.equals(a.groupedEntries, bw.groupedEntries)
       );
     }

apps/web/src/components/chat/MessagesTimeline.test.tsx+35−21

             layout?: boolean;
           };
         };
+    maintainVisibleContentPosition?:
+      | boolean
+      | {
+          data?: boolean;
+          size?: boolean;
+          shouldRestorePosition?: boolean;
+        };
+    className?: string;
+    contentInsetEndAdjustment?: number;
     ref?: Ref<LegendListRef>;
   }) => {
     if (props.anchoredEndSpace) {
     return (
       <div
         data-testid={legendListTestId}
+        data-class-name={props.className}
         data-anchor-index={props.anchoredEndSpace?.anchorIndex}
+        data-anchor-max-size={props.anchoredEndSpace?.anchorMaxSize}
+        data-anchor-offset={props.anchoredEndSpace?.anchorOffset}
+        data-anchor-on-ready={Boolean(props.anchoredEndSpace?.onReady)}
+        data-content-inset-end={props.contentInsetEndAdjustment}
+        data-maintain-visible-content-position={
+          typeof props.maintainVisibleContentPosition === "object"
+            ? "object"
+            : props.maintainVisibleContentPosition
+        }
+        data-maintain-visible-content-position-data={
+          typeof props.maintainVisibleContentPosition === "object"
+            ? props.maintainVisibleContentPosition.data
+            : undefined
+        }
+        data-maintain-visible-content-position-size={
+          typeof props.maintainVisibleContentPosition === "object"
+            ? props.maintainVisibleContentPosition.size
+            : undefined
+        }
+        data-maintain-visible-content-position-restore={
+          typeof props.maintainVisibleContentPosition === "object"
+            ? Boolean(props.maintainVisibleContentPosition.shouldRestorePosition)
+            : undefined
+        }
         data-maintain-scroll-at-end={props.maintainScrollAtEnd ? "enabled" : undefined}
         data-maintain-scroll-at-end-animated={
           typeof props.maintainScrollAtEnd === "object"
             ? props.maintainScrollAtEnd.on?.layout
             : undefined
         }
-        data-maintain-visible-content-position={
-          typeof props.maintainVisibleContentPosition === "object"
-            ? "object"
-            : props.maintainVisibleContentPosition
-        }
-        data-maintain-visible-content-position-data={
-          typeof props.maintainVisibleContentPosition === "object"
-            ? props.maintainVisibleContentPosition.data
-            : undefined
-        }
-        data-maintain-visible-content-position-size={
-          typeof props.maintainVisibleContentPosition === "object"
-            ? props.maintainVisibleContentPosition.size
-            : undefined
-        }
-        data-maintain-visible-content-position-restore={
-          typeof props.maintainVisibleContentPosition === "object"
-            ? Boolean(props.maintainVisibleContentPosition.shouldRestorePosition)
-            : undefined
-        }
       >
         {props.ListHeaderComponent}
         {props.data.map((item) => (
     );
     expect(markup).toContain('data-anchor-index="1"');
-    expect(markup).toContain('data-anchor-offset="16"');
+    expect(markup).toContain('data-anchor-offset="24"');
     expect(markup).toContain('data-anchor-on-ready="true"');
     expect(markup).not.toContain("data-anchor-max-size=");
     expect(markup).toContain('data-content-inset-end="144"');

apps/web/src/components/chat/MessagesTimeline.tsx+381−109

@@ -1,4 +1,5 @@
1	import {	1	import {
		2	type AssistantCitation,
2	type ChatFileAttachment,	3	type ChatFileAttachment,
3	type EnvironmentId,	4	type EnvironmentId,
4	type MessageId,	5	type MessageId,
@@ -15,9 +16,15 @@ import { canForkProjectedAssistantItem } from "@t3tools/client-runtime/state/thr · 10 unmodified lines
15	import { commandProgramName } from "@t3tools/client-runtime/work-log/command-label";	16	import { commandProgramName } from "@t3tools/client-runtime/work-log/command-label";
16	import { formatWorkingTimerNow } from "./ComposerActivityStatus";	17	import { formatWorkingTimerNow } from "./ComposerActivityStatus";
17	import {	18	import {
		19	CHAT_TIMELINE_ANCHOR_OFFSET,
		20	keepTimelineEndVisibleAfterOverlayGrowth,
		21	} from "./timelineScrollAnchoring";
		22	import {
		23	resolveWorkEntryToolPresentation,
18	resolveViewedImageAsset,	24	resolveViewedImageAsset,
19	workEntryViewedImagePath,	25	workEntryViewedImagePath,
20	} from "@t3tools/client-runtime/work-log/presentation";	26	} from "@t3tools/client-runtime/work-log/presentation";
		27	import { resolveWorkGroupScrollAnchor } from "@t3tools/client-runtime/work-log/scroll-anchor";
21	const NOOP_USE_ARTIFACT_TEMPLATE = () => {};	28	const NOOP_USE_ARTIFACT_TEMPLATE = () => {};
22	const NOOP_OPEN_ATTACHMENT = (_attachment: ChatFileAttachment) => {};	29	const NOOP_OPEN_ATTACHMENT = (_attachment: ChatFileAttachment) => {};
23		30
@@ -29,6 +36,7 @@ import { · 5 unmodified lines
29	use,	36	use,
30	useCallback,	37	useCallback,
31	useEffect,	38	useEffect,
		39	useLayoutEffect,
32	useMemo,	40	useMemo,
33	useRef,	41	useRef,
34	useState,	42	useState,
@@ -61,7 +69,9 @@ import { · 26 unmodified lines
61	resolveDiffThemeName,	69	resolveDiffThemeName,
62	resolveFileDiffPath,	70	resolveFileDiffPath,
63	} from "../../lib/diffRendering";	71	} from "../../lib/diffRendering";
		72	import { PREFERRED_HIGHLIGHTER } from "../../lib/syntaxHighlighting";
64	import ChatMarkdown, { ChatMarkdownAssetImage } from "../ChatMarkdown";	73	import ChatMarkdown, { ChatMarkdownAssetImage } from "../ChatMarkdown";
		74	import { T3Wordmark } from "../T3Wordmark";
65	import {	75	import {
66	BotIcon,	76	BotIcon,
67	BrainIcon,	77	BrainIcon,
@@ -92,14 +102,24 @@ import { · 24 unmodified lines
92	ZapIcon,	102	ZapIcon,
93	} from "lucide-react";	103	} from "lucide-react";
94	import { Button } from "../ui/button";	104	import { Button } from "../ui/button";
		105	import { getVirtualizedScrollFadeClassName } from "../ui/scroll-area";
95	import { buildExpandedImagePreview, ExpandedImagePreview } from "./ExpandedImagePreview";	106	import { buildExpandedImagePreview, ExpandedImagePreview } from "./ExpandedImagePreview";
96	import { ProposedPlanCard } from "./ProposedPlanCard";	107	import { ProposedPlanCard } from "./ProposedPlanCard";
97	import { ChangedFilesCard } from "./ChangedFilesTree";	108	import { ChangedFilesCard } from "./ChangedFilesTree";
98	import { shouldAutoExpandChangedFiles } from "./changedFilesPresentation";	109	import { shouldAutoExpandChangedFiles } from "./changedFilesPresentation";
99	import { MessageCopyButton } from "./MessageCopyButton";	110	import { MessageCopyButton } from "./MessageCopyButton";
		111	import { AssistantSelectionToolbar } from "./AssistantSelectionToolbar";
		112	import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
		113	import {
		114	AssistantCitationSource,
		115	type AssistantCitationRequest,
		116	type AssistantCitationTarget,
		117	} from "./AssistantCitationSource";
		118	import { useAssistantCitationTarget, type CitationHistoryPage } from "./useAssistantCitationTarget";
100	import {	119	import {
101	computeStableMessagesTimelineRows,	120	computeStableMessagesTimelineRows,
102	deriveMessagesTimelineRows,	121	deriveMessagesTimelineRows,
		122	liveWorkEntryLabel,
103	normalizeCompactToolLabel,	123	normalizeCompactToolLabel,
104	resolveTimelineToolPresentation,	124	resolveTimelineToolPresentation,
105	resolveAssistantMessageCopyState,	125	resolveAssistantMessageCopyState,
@@ -110,12 +130,17 @@ import { · 4 unmodified lines
110	resolveTimelineMinimapIndexFromPointer,	130	resolveTimelineMinimapIndexFromPointer,
111	resolveTimelineMinimapInteractiveWidth,	131	resolveTimelineMinimapInteractiveWidth,
112	resolveTimelineMinimapTopPercent,	132	resolveTimelineMinimapTopPercent,
		133	resolveWorkGroupScrollIndex,
		134	shouldFollowWorkGroupAppend,
113	shouldPreserveAssistantLineBreaks,	135	shouldPreserveAssistantLineBreaks,
		136	toolGroupAction,
		137	workEntryDisplayLabel,
114	workEntryIsVisibleInGroup,	138	workEntryIsVisibleInGroup,
115	type StableMessagesTimelineRowsState,	139	type StableMessagesTimelineRowsState,
116	type MessagesTimelineRow,	140	type MessagesTimelineRow,
117	TIMELINE_MINIMAP_MIN_ITEMS,	141	TIMELINE_MINIMAP_MIN_ITEMS,
118	type TimelineLatestRun,	142	type TimelineLatestRun,
		143	type WorkGroupScrollAnchor,
119	} from "./MessagesTimeline.logic";	144	} from "./MessagesTimeline.logic";
120	import { TerminalContextInlineChip } from "./TerminalContextInlineChip";	145	import { TerminalContextInlineChip } from "./TerminalContextInlineChip";
121	import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";	146	import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
@@ -163,6 +188,8 @@ import { · 41 unmodified lines
163	// ---------------------------------------------------------------------------	188	// ---------------------------------------------------------------------------
164		189
165	interface TimelineRowSharedState {	190	interface TimelineRowSharedState {
		191	citationRequest: AssistantCitationTarget \| null;
		192	listRef: React.RefObject<LegendListRef \| null>;
166	timestampFormat: TimestampFormat;	193	timestampFormat: TimestampFormat;
167	routeThreadKey: string;	194	routeThreadKey: string;
168	threadRef: ScopedThreadRef \| null;	195	threadRef: ScopedThreadRef \| null;
@@ -193,6 +220,8 @@ interface TimelineRowSharedState { · 24 unmodified lines
193	openingVideoAttachmentId: string \| null;	220	openingVideoAttachmentId: string \| null;
194	onUseArtifactTemplate: (template: CodexArtifactTemplate) => void;	221	onUseArtifactTemplate: (template: CodexArtifactTemplate) => void;
195	onToggleWorkGroup: (groupId: string, anchorKey: string) => void;	222	onToggleWorkGroup: (groupId: string, anchorKey: string) => void;
		223	onToggleWorkEntry: (anchorKey: string) => void;
		224	workGroupViewState: WorkGroupViewState;
196	}	225	}
197		226
198	interface TimelineRowActivityState {	227	interface TimelineRowActivityState {
@@ -205,6 +234,16 @@ interface TimelineRowActivityState { · 6 unmodified lines
205		234
206	const TimelineRowCtx = createContext<TimelineRowSharedState>(null!);	235	const TimelineRowCtx = createContext<TimelineRowSharedState>(null!);
207	const TimelineRowActivityCtx = createContext<TimelineRowActivityState>(null!);	236	const TimelineRowActivityCtx = createContext<TimelineRowActivityState>(null!);
		237
		238	interface WorkGroupViewState {
		239	scrollPositions: Map<string, WorkGroupScrollAnchor>;
		240	expandedEntries: Set<string>;
		241	}
		242
		243	const WorkGroupViewCtx = createContext<{
		244	state: WorkGroupViewState;
		245	onToggleEntry: () => void;
		246	} \| null>(null);
208	const TIMELINE_LIST_HEADER = <div className="h-3 sm:h-4" />;	247	const TIMELINE_LIST_HEADER = <div className="h-3 sm:h-4" />;
209	const TIMELINE_LIST_FADE_HEADER = (	248	const TIMELINE_LIST_FADE_HEADER = (
210	<div className="h-[var(--workspace-titlebar-scroll-fade-height)]" />	249	<div className="h-[var(--workspace-titlebar-scroll-fade-height)]" />
@@ -234,6 +273,12 @@ export interface MessagesTimelineHistoryControls { · 23 unmodified lines
234	}	273	}
235		274
236	interface MessagesTimelineProps {	275	interface MessagesTimelineProps {
		276	citationRequest?: AssistantCitationRequest \| null;
		277	citationHistoryLoading?: boolean;
		278	onCiteAssistantText?: (
		279	citation: AssistantCitation,
		280	sourceAnchor: AssistantCitationSourceAnchor,
		281	) => boolean;
237	isWorking: boolean;	282	isWorking: boolean;
238	activeTurnInProgress: boolean;	283	activeTurnInProgress: boolean;
239	activeTurnStartedAt?: string \| null;	284	activeTurnStartedAt?: string \| null;
@@ -288,6 +333,8 @@ interface MessagesTimelineProps { · 48 unmodified lines
288	hideEmptyPlaceholder?: boolean;	333	hideEmptyPlaceholder?: boolean;
289	topFadeEnabled?: boolean;	334	topFadeEnabled?: boolean;
290	historyControls?: MessagesTimelineHistoryControls;	335	historyControls?: MessagesTimelineHistoryControls;
		336	/** Non-null when older turns exist beyond the loaded window. */
		337	loadEarlier?: CitationHistoryPage \| null;
291	}	338	}
292		339
293	// ---------------------------------------------------------------------------	340	// ---------------------------------------------------------------------------
@@ -295,6 +342,9 @@ interface MessagesTimelineProps { · 1 unmodified line
295	// ---------------------------------------------------------------------------	342	// ---------------------------------------------------------------------------
296		343
297	export const MessagesTimeline = memo(function MessagesTimeline({	344	export const MessagesTimeline = memo(function MessagesTimeline({
		345	citationRequest = null,
		346	citationHistoryLoading = false,
		347	onCiteAssistantText,
298	isWorking,	348	isWorking,
299	activeTurnInProgress,	349	activeTurnInProgress,
300	activeTurnStartedAt = null,	350	activeTurnStartedAt = null,
@@ -334,17 +384,28 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 33 unmodified lines
334	hideEmptyPlaceholder = false,	384	hideEmptyPlaceholder = false,
335	topFadeEnabled = false,	385	topFadeEnabled = false,
336	historyControls,	386	historyControls,
		387	loadEarlier = null,
337	}: MessagesTimelineProps) {	388	}: MessagesTimelineProps) {
338	const [expandedRunIds, setExpandedRunIds] = useState<ReadonlySet<RunId>>(new Set());	389	const [expandedRunIds, setExpandedRunIds] = useState<ReadonlySet<RunId>>(new Set());
339	const [expandedAttemptIds, setExpandedAttemptIds] = useState<ReadonlySet<RunAttemptId>>(	390	const [expandedAttemptIds, setExpandedAttemptIds] = useState<ReadonlySet<RunAttemptId>>(
340	new Set(),	391	new Set(),
341	);	392	);
		393	const citationThreadRef = useMemo(() => parseScopedThreadKey(routeThreadKey), [routeThreadKey]);
		394	const expandCitedRun = useCallback((runId: RunId) => {
		395	setExpandedRunIds((current) => (current.has(runId) ? current : new Set([...current, runId])));
		396	}, []);
342	const [expandedWorkGroupIds, setExpandedWorkGroupIds] = useState<ReadonlySet<string>>(new Set());	397	const [expandedWorkGroupIds, setExpandedWorkGroupIds] = useState<ReadonlySet<string>>(new Set());
		398	// Scroll/disclosure state outlives virtualized rows, but never the current thread.
		399	const workGroupViewState = useMemo<WorkGroupViewState>(
		400	() => ({ scrollPositions: new Map(), expandedEntries: new Set() }),
		401	[routeThreadKey],
		402	);
343	const [minimapStripMap] = useState(() => new Map<string, HTMLSpanElement>());	403	const [minimapStripMap] = useState(() => new Map<string, HTMLSpanElement>());
344	const [disclosureToggleSettling, setDisclosureToggleSettling] = useState(false);	404	const [disclosureToggleSettling, setDisclosureToggleSettling] = useState(false);
345	const disclosureAnchorKeyRef = useRef<string \| null>(null);	405	const disclosureAnchorKeyRef = useRef<string \| null>(null);
346	const disclosureSettleFrameRef = useRef<number \| null>(null);	406	const disclosureSettleFrameRef = useRef<number \| null>(null);
347	const disclosureSettleSecondFrameRef = useRef<number \| null>(null);	407	const disclosureSettleSecondFrameRef = useRef<number \| null>(null);
		408	const previousContentInsetEndAdjustmentRef = useRef(contentInsetEndAdjustment);
348		409
349	useEffect(() => {	410	useEffect(() => {
350	return () => {	411	return () => {
@@ -499,6 +560,31 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 148 unmodified lines
499	const [timelineViewportElement, setTimelineViewportElement] = useState<HTMLDivElement \| null>(	560	const [timelineViewportElement, setTimelineViewportElement] = useState<HTMLDivElement \| null>(
500	null,	561	null,
501	);	562	);
		563	const {
		564	target: readyCitationRequest,
		565	positioning: citationPositioning,
		566	onListLoad: onCitationListLoad,
		567	alwaysRender: citationAlwaysRender,
		568	} = useAssistantCitationTarget({
		569	request: citationRequest,
		570	entries: timelineEntries,
		571	rows,
		572	listRef,
		573	viewport: timelineViewportElement,
		574	historyLoading: citationHistoryLoading,
		575	loadEarlier,
		576	onExpandTurn: expandCitedRun,
		577	onManualNavigation,
		578	});
		579	useLayoutEffect(() => {
		580	keepTimelineEndVisibleAfterOverlayGrowth({
		581	timeline: listRef.current,
		582	previousOverlayHeight: previousContentInsetEndAdjustmentRef.current,
		583	overlayHeight: contentInsetEndAdjustment,
		584	followingEnd: liveFollowEnabled && anchorMessageId === null && !citationPositioning,
		585	});
		586	previousContentInsetEndAdjustmentRef.current = contentInsetEndAdjustment;
		587	}, [anchorMessageId, citationPositioning, contentInsetEndAdjustment, listRef, liveFollowEnabled]);
502	const [minimapHasPersistentGutter, setMinimapHasPersistentGutter] = useState(false);	588	const [minimapHasPersistentGutter, setMinimapHasPersistentGutter] = useState(false);
503	const [minimapHitStripWidth, setMinimapHitStripWidth] = useState(0);	589	const [minimapHitStripWidth, setMinimapHitStripWidth] = useState(0);
504	const handleAnchorReady = useCallback(	590	const handleAnchorReady = useCallback(
@@ -518,8 +604,11 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 13 unmodified lines
518	[anchorMessageId, onAnchorSizeChanged],	604	[anchorMessageId, onAnchorSizeChanged],
519	);	605	);
520	const anchoredEndSpace = useMemo(() => {	606	const anchoredEndSpace = useMemo(() => {
521	const config = resolveChatListAnchoredEndSpace(rows, anchorMessageId, (row) =>	607	const config = resolveChatListAnchoredEndSpace(
522	row.kind === "message" && row.message.role === "user" ? row.message.id : null,	608	rows,
		609	anchorMessageId,
		610	(row) => (row.kind === "message" && row.message.role === "user" ? row.message.id : null),
		611	{ anchorOffset: CHAT_TIMELINE_ANCHOR_OFFSET },
523	);	612	);
524	return config	613	return config
525	? { ...config, onReady: handleAnchorReady, onSizeChanged: handleAnchorSizeChanged }	614	? { ...config, onReady: handleAnchorReady, onSizeChanged: handleAnchorSizeChanged }
@@ -537,7 +626,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 11 unmodified lines
537	const handleScroll = useCallback(() => {	626	const handleScroll = useCallback(() => {
538	const state = listRef.current?.getState?.();	627	const state = listRef.current?.getState?.();
539	const isAtEnd = resolveTimelineIsAtEnd(state, contentInsetEndAdjustment);	628	const isAtEnd = resolveTimelineIsAtEnd(state, contentInsetEndAdjustment);
540	if (isAtEnd !== undefined) {	629	if (isAtEnd !== undefined && !citationPositioning) {
541	onIsAtEndChange(isAtEnd);	630	onIsAtEndChange(isAtEnd);
542	}	631	}
543	if (!state \|\| minimapItems.length === 0) {	632	if (!state \|\| minimapItems.length === 0) {
@@ -567,7 +656,14 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 23 unmodified lines
567	strip.dataset.inView = next;	656	strip.dataset.inView = next;
568	}	657	}
569	}	658	}
570	}, [listRef, minimapItems, minimapStripMap, onIsAtEndChange, contentInsetEndAdjustment]);	659	}, [
		660	citationPositioning,
		661	contentInsetEndAdjustment,
		662	listRef,
		663	minimapItems,
		664	minimapStripMap,
		665	onIsAtEndChange,
		666	]);
571		667
572	useEffect(() => {	668	useEffect(() => {
573	const frame = requestAnimationFrame(handleScroll);	669	const frame = requestAnimationFrame(handleScroll);
@@ -601,6 +697,8 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 27 unmodified lines
601		697
602	const sharedState = useMemo<TimelineRowSharedState>(	698	const sharedState = useMemo<TimelineRowSharedState>(
603	() => ({	699	() => ({
		700	citationRequest: readyCitationRequest,
		701	listRef,
604	timestampFormat,	702	timestampFormat,
605	routeThreadKey,	703	routeThreadKey,
606	threadRef: parseScopedThreadKey(routeThreadKey),	704	threadRef: parseScopedThreadKey(routeThreadKey),
@@ -623,8 +721,12 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 16 unmodified lines
623	onToggleTurnFold,	721	onToggleTurnFold,
624	onToggleAttemptFold,	722	onToggleAttemptFold,
625	onToggleWorkGroup,	723	onToggleWorkGroup,
		724	onToggleWorkEntry: suspendEndScrollMaintenanceForDisclosure,
		725	workGroupViewState,
626	}),	726	}),
627	[	727	[
		728	readyCitationRequest,
		729	listRef,
628	timestampFormat,	730	timestampFormat,
629	routeThreadKey,	731	routeThreadKey,
630	markdownCwd,	732	markdownCwd,
@@ -646,6 +748,8 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 15 unmodified lines
646	onToggleTurnFold,	748	onToggleTurnFold,
647	onToggleAttemptFold,	749	onToggleAttemptFold,
648	onToggleWorkGroup,	750	onToggleWorkGroup,
		751	suspendEndScrollMaintenanceForDisclosure,
		752	workGroupViewState,
649	],	753	],
650	);	754	);
651	const activityState = useMemo<TimelineRowActivityState>(	755	const activityState = useMemo<TimelineRowActivityState>(
@@ -722,7 +826,18 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 70 unmodified lines
722	return (	826	return (
723	<TimelineRowCtx value={sharedState}>	827	<TimelineRowCtx value={sharedState}>
724	<TimelineRowActivityCtx value={activityState}>	828	<TimelineRowActivityCtx value={activityState}>
725	<div ref={setTimelineViewportElement} className="relative h-full min-h-0">	829	<div
		830	ref={setTimelineViewportElement}
		831	className="relative h-full min-h-0"
		832	data-assistant-citation-viewport="true"
		833	>
		834	{onCiteAssistantText && citationThreadRef ? (
		835	<AssistantSelectionToolbar
		836	viewport={timelineViewportElement}
		837	threadRef={citationThreadRef}
		838	onCite={onCiteAssistantText}
		839	/>
		840	) : null}
726	<LegendList<MessagesTimelineRow>	841	<LegendList<MessagesTimelineRow>
727	ref={listRef}	842	ref={listRef}
728	data={rows}	843	data={rows}
@@ -730,7 +845,11 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 1 unmodified line
730	getItemType={getItemType}	845	getItemType={getItemType}
731	renderItem={renderItem}	846	renderItem={renderItem}
732	estimatedItemSize={90}	847	estimatedItemSize={90}
733	initialScrollAtEnd	848	initialScrollAtEnd={citationRequest === null}
		849	// Legend needs a data refresh to mount new pins without a scroll event.
		850	{...(readyCitationRequest ? { dataVersion: readyCitationRequest.key } : {})}
		851	{...(citationAlwaysRender ? { alwaysRender: citationAlwaysRender } : {})}
		852	onLoad={onCitationListLoad}
734	{...(anchoredEndSpace ? { anchoredEndSpace } : {})}	853	{...(anchoredEndSpace ? { anchoredEndSpace } : {})}
735	contentInsetEndAdjustment={contentInsetEndAdjustment}	854	contentInsetEndAdjustment={contentInsetEndAdjustment}
736	// LegendList owns ordinary end-follow (#5449): the app only turns	855	// LegendList owns ordinary end-follow (#5449): the app only turns
@@ -738,11 +857,16 @@ export const MessagesTimeline = memo(function MessagesTimeline({ · 1 unmodified line
738	// sent turn anchors near the top (anchoredEndSpace), or for the	857	// sent turn anchors near the top (anchoredEndSpace), or for the
739	// two-frame settle window of a fold toggle.	858	// two-frame settle window of a fold toggle.
740	maintainScrollAtEnd={	859	maintainScrollAtEnd={
741	anchoredEndSpace \|\| !liveFollowEnabled \|\| disclosureToggleSettling	860	citationPositioning \|\|
		861	anchoredEndSpace \|\|
		862	!liveFollowEnabled \|\|
		863	disclosureToggleSettling
742	? false	864	? false
743	: TIMELINE_MAINTAIN_SCROLL_AT_END	865	: TIMELINE_MAINTAIN_SCROLL_AT_END
744	}	866	}
745	maintainVisibleContentPosition={maintainVisibleContentPosition}	867	maintainVisibleContentPosition={
		868	citationPositioning ? false : maintainVisibleContentPosition
		869	}
746	onScroll={handleScroll}	870	onScroll={handleScroll}
747	className={cn(	871	className={cn(
748	"messages-timeline-scroll scrollbar-gutter-both h-full min-h-0 overflow-x-hidden overscroll-y-contain px-3 [overflow-anchor:none] sm:px-5",	872	"messages-timeline-scroll scrollbar-gutter-both h-full min-h-0 overflow-x-hidden overscroll-y-contain px-3 [overflow-anchor:none] sm:px-5",
@@ -1101,8 +1225,7 @@ type TimelineWorkEntry = Extract<MessagesTimelineRow, { kind: "work" }>["grouped · 352 unmodified lines
1101	type TimelineRow = MessagesTimelineRow;	1225	type TimelineRow = MessagesTimelineRow;
1102		1226
1103	const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: TimelineRow }) {	1227	const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: TimelineRow }) {
1104	const isExpandedToolGroupEntry = row.kind === "work" && row.isExpandedToolGroupEntry;	1228	const isExpandedToolGroup = row.kind === "work" && row.isExpandedToolGroup;
1105	const isLastExpandedToolGroupEntry = row.kind === "work" && row.isLastExpandedToolGroupEntry;
1106	const isExpandedToolGroupHeader =	1229	const isExpandedToolGroupHeader =
1107	(row.kind === "work-toggle" && row.expanded) \|\| (row.kind === "work-live" && row.expanded);	1230	(row.kind === "work-toggle" && row.expanded) \|\| (row.kind === "work-live" && row.expanded);
1108		1231
@@ -1111,10 +1234,8 @@ const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: Time · 2 unmodified lines
1111	className={cn(	1234	className={cn(
1112	// Commentary (non-terminal assistant) rows carry no metadata row, so	1235	// Commentary (non-terminal assistant) rows carry no metadata row, so
1113	// they sit closer to the work that follows them.	1236	// they sit closer to the work that follows them.
1114	isExpandedToolGroupEntry	1237	isExpandedToolGroup
1115	? isLastExpandedToolGroupEntry	1238	? "pb-1"
1116	? "pb-1"
1117	: "pb-0"
1118	: isExpandedToolGroupHeader	1239	: isExpandedToolGroupHeader
1119	? "pb-0"	1240	? "pb-0"
1120	: row.kind === "turn-fold"	1241	: row.kind === "turn-fold"
@@ -1141,8 +1262,9 @@ const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: Time · 20 unmodified lines
1141	>	1262	>
1142	{row.kind === "work" ? (	1263	{row.kind === "work" ? (
1143	<WorkGroupSection	1264	<WorkGroupSection
		1265	anchorKey={row.id}
1144	groupedEntries={row.groupedEntries}	1266	groupedEntries={row.groupedEntries}
1145	isExpandedToolGroupEntry={row.isExpandedToolGroupEntry}	1267	isExpandedToolGroup={row.isExpandedToolGroup}
1146	/>	1268	/>
1147	) : null}	1269	) : null}
1148	{row.kind === "work-live" ? <LiveWorkEntryTimelineRow row={row} /> : null}	1270	{row.kind === "work-live" ? <LiveWorkEntryTimelineRow row={row} /> : null}
@@ -1486,16 +1608,24 @@ function AssistantTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "mess · 337 unmodified lines
1486	return (	1608	return (
1487	<>	1609	<>
1488	<div className="relative min-w-0 px-1 py-0.5">	1610	<div className="relative min-w-0 px-1 py-0.5">
1489	<ChatMarkdown	1611	<AssistantCitationSource
1490	text={messageText}	1612	messageId={row.message.id}
1491	cwd={ctx.markdownCwd}	1613	{...(ctx.threadRef ? { threadRef: ctx.threadRef } : {})}
1492	threadRef={ctx.threadRef ?? undefined}	1614	itemKey={row.id}
1493	isStreaming={Boolean(row.message.streaming)}	1615	request={ctx.citationRequest}
1494	lineBreaks={shouldPreserveAssistantLineBreaks(messageText)}	1616	listRef={ctx.listRef}
1495	skills={ctx.skills}	1617	>
1496	onUseArtifactTemplate={ctx.onUseArtifactTemplate}	1618	<ChatMarkdown
1497	onImageExpand={ctx.onImageExpand}	1619	text={messageText}
1498	/>	1620	cwd={ctx.markdownCwd}
		1621	threadRef={ctx.threadRef ?? undefined}
		1622	isStreaming={Boolean(row.message.streaming)}
		1623	lineBreaks={shouldPreserveAssistantLineBreaks(messageText)}
		1624	skills={ctx.skills}
		1625	onUseArtifactTemplate={ctx.onUseArtifactTemplate}
		1626	onImageExpand={ctx.onImageExpand}
		1627	/>
		1628	</AssistantCitationSource>
1499	<AssistantChangedFilesSection	1629	<AssistantChangedFilesSection
1500	turnSummary={row.assistantTurnDiffSummary}	1630	turnSummary={row.assistantTurnDiffSummary}
1501	routeThreadKey={ctx.routeThreadKey}	1631	routeThreadKey={ctx.routeThreadKey}
@@ -1989,40 +2119,47 @@ const TurnPlanTimelineRow = memo(function TurnPlanTimelineRow({ · 487 unmodified lines
1989	// re-render only the affected row, not the entire list.	2119	// re-render only the affected row, not the entire list.
1990	// ---------------------------------------------------------------------------	2120	// ---------------------------------------------------------------------------
1991		2121
1992	/** Renders one or more already-derived work log rows. Overflow expansion is modeled as list data. */	2122	/** Renders standalone activity or one bounded, virtualized expanded tool group. */
1993	const WorkGroupSection = memo(function WorkGroupSection({	2123	const WorkGroupSection = memo(function WorkGroupSection({
		2124	anchorKey,
1994	groupedEntries,	2125	groupedEntries,
1995	isExpandedToolGroupEntry,	2126	isExpandedToolGroup,
1996	}: {	2127	}: {
		2128	anchorKey: string;
1997	groupedEntries: Extract<MessagesTimelineRow, { kind: "work" }>["groupedEntries"];	2129	groupedEntries: Extract<MessagesTimelineRow, { kind: "work" }>["groupedEntries"];
1998	isExpandedToolGroupEntry: boolean;	2130	isExpandedToolGroup: boolean;
1999	}) {	2131	}) {
2000	const { workspaceRoot } = use(TimelineRowCtx);	2132	const { workspaceRoot, routeThreadKey } = use(TimelineRowCtx);
2001	const nonEmptyEntries = useMemo(	2133	const nonEmptyEntries = useMemo(
2002	() =>	2134	() => groupedEntries.filter((entry) => workEntryIsVisibleInGroup(entry, isExpandedToolGroup)),
2003	groupedEntries.filter((entry) => workEntryIsVisibleInGroup(entry, isExpandedToolGroupEntry)),	2135	[groupedEntries, isExpandedToolGroup],
2004	[groupedEntries, isExpandedToolGroupEntry],
2005	);	2136	);
2006	const GroupContainer = isExpandedToolGroupEntry ? "div" : "section";
2007		2137
2008	if (nonEmptyEntries.length === 0) return null;	2138	if (nonEmptyEntries.length === 0) return null;
		2139	if (isExpandedToolGroup) {
		2140	return (
		2141	<ExpandedWorkGroupEntries
		2142	key={`${routeThreadKey}:${anchorKey}`}
		2143	anchorKey={anchorKey}
		2144	entries={nonEmptyEntries}
		2145	workspaceRoot={workspaceRoot}
		2146	/>
		2147	);
		2148	}
2009		2149
2010	return (	2150	return (
2011	<GroupContainer	2151	<section className="-mx-1 space-y-0.5 px-1 py-0.5" aria-label="Activity">
2012	className={cn("-mx-1 px-1", isExpandedToolGroupEntry ? "py-0" : "space-y-0.5 py-0.5")}
2013	aria-label={isExpandedToolGroupEntry ? undefined : "Activity"}
2014	>
2015	<div className="space-y-px">	2152	<div className="space-y-px">
2016	{nonEmptyEntries.map((workEntry) => (	2153	{nonEmptyEntries.map((workEntry) => (
2017	<SimpleWorkEntryRow	2154	<SimpleWorkEntryRow
2018	key={workEntry.id}	2155	key={workEntry.id}
2019	workEntry={workEntry}	2156	workEntry={workEntry}
2020	workspaceRoot={workspaceRoot}	2157	workspaceRoot={workspaceRoot}
2021	isExpandedToolGroupEntry={isExpandedToolGroupEntry}	2158	isExpandedToolGroupEntry={false}
2022	/>	2159	/>
2023	))}	2160	))}
2024	</div>	2161	</div>
2025	</GroupContainer>	2162	</section>
2026	);	2163	);
2027	});	2164	});
2028		2165
@@ -2048,6 +2185,145 @@ function WorkingTimer({ createdAt }: { createdAt: string }) { · 19 unmodified lines
2048	);	2185	);
2049	}	2186	}
2050		2187
		2188	function ExpandedWorkGroupEntries({
		2189	anchorKey,
		2190	entries,
		2191	workspaceRoot,
		2192	}: {
		2193	anchorKey: string;
		2194	entries: TimelineWorkEntry[];
		2195	workspaceRoot: string \| undefined;
		2196	}) {
		2197	const { workGroupViewState: viewState, onToggleWorkEntry } = use(TimelineRowCtx);
		2198	const [initialScrollIndex] = useState(() =>
		2199	resolveWorkGroupScrollIndex(entries, viewState.scrollPositions.get(anchorKey)),
		2200	);
		2201	const [restoringPosition, setRestoringPosition] = useState(initialScrollIndex !== undefined);
		2202	const listRef = useRef<LegendListRef>(null);
		2203	const [fades, setFades] = useState({ top: false, bottom: false, viewportHeight: 0 });
		2204	const [appendState, setAppendState] = useState({ entries, follow: false });
		2205	// Capture the pre-change edge once per incoming array, before new layout
		2206	// metrics arrive. Edge/viewport changes never turn a status update into a follow.
		2207	if (appendState.entries !== entries) {
		2208	setAppendState({
		2209	entries,
		2210	follow:
		2211	fades.viewportHeight > 0 &&
		2212	shouldFollowWorkGroupAppend(appendState.entries, entries, fades.bottom ? Infinity : 0),
		2213	});
		2214	}
		2215
		2216	const groupView = useMemo(
		2217	() => ({ state: viewState, onToggleEntry: () => onToggleWorkEntry(anchorKey) }),
		2218	[anchorKey, onToggleWorkEntry, viewState],
		2219	);
		2220	const updateScrollFades = useCallback(() => {
		2221	const element = listRef.current?.getScrollableNode();
		2222	if (!element) return;
		2223	const distanceFromEnd = element.scrollHeight - element.clientHeight - element.scrollTop;
		2224	const viewportHeight = element.clientHeight;
		2225	const top = element.scrollTop > 1;
		2226	const bottom = distanceFromEnd > 1;
		2227	setFades((previous) =>
		2228	previous.top === top &&
		2229	previous.bottom === bottom &&
		2230	previous.viewportHeight === viewportHeight
		2231	? previous
		2232	: { top, bottom, viewportHeight },
		2233	);
		2234	}, []);
		2235
		2236	const handleScroll = useCallback(() => {
		2237	const state = listRef.current?.getState();
		2238	const position = state && resolveWorkGroupScrollAnchor(state);
		2239	if (position) {
		2240	viewState.scrollPositions.set(anchorKey, {
		2241	entryId: position.rowId,
		2242	offset: position.offsetWithinRow,
		2243	});
		2244	}
		2245	updateScrollFades();
		2246	}, [anchorKey, updateScrollFades, viewState]);
		2247
		2248	const handleLoad = useCallback(() => {
		2249	const list = listRef.current;
		2250	const element = list?.getScrollableNode();
		2251	if (initialScrollIndex && list && element) {
		2252	// Bootstrap can report the restored target before the DOM has applied it.
		2253	// Reconcile once at load, before releasing the measured anchor row.
		2254	const offset = Math.max(
		2255	0,
		2256	Math.min(list.getState().scroll, element.scrollHeight - element.clientHeight),
		2257	);
		2258	if (Math.abs(element.scrollTop - offset) > 1) {
		2259	void list.scrollToOffset({ offset, animated: false });
		2260	}
		2261	}
		2262	setRestoringPosition(false);
		2263	}, [initialScrollIndex]);
		2264
		2265	useLayoutEffect(() => {
		2266	const element = listRef.current?.getScrollableNode();
		2267	if (!element) return;
		2268	updateScrollFades();
		2269	const observer = new ResizeObserver(updateScrollFades);
		2270	observer.observe(element);
		2271	if (element.firstElementChild) observer.observe(element.firstElementChild);
		2272	return () => observer.disconnect();
		2273	}, [updateScrollFades]);
		2274
		2275	const renderEntry = useCallback(
		2276	({ item }: { item: TimelineWorkEntry }) => (
		2277	<SimpleWorkEntryRow
		2278	key={item.id}
		2279	workEntry={item}
		2280	workspaceRoot={workspaceRoot}
		2281	isExpandedToolGroupEntry
		2282	/>
		2283	),
		2284	[workspaceRoot],
		2285	);
		2286
		2287	return (
		2288	<WorkGroupViewCtx value={groupView}>
		2289	<LegendList
		2290	ref={listRef}
		2291	data={entries}
		2292	extraData={workspaceRoot}
		2293	keyExtractor={workEntryKey}
		2294	renderItem={renderEntry}
		2295	estimatedItemSize={24}
		2296	drawDistance={240}
		2297	recycleItems
		2298	{...(initialScrollIndex ? { initialScrollIndex } : {})}
		2299	maintainScrollAtEnd={
		2300	appendState.follow ? { animated: false, on: { dataChange: true } } : false
		2301	}
		2302	maintainScrollAtEndThreshold={1 / Math.max(1, fades.viewportHeight)}
		2303	// Measure the restored row even when an intra-row offset puts its
		2304	// estimated bounds outside the list's small bootstrap render window.
		2305	{...(restoringPosition && initialScrollIndex
		2306	? { alwaysRender: { indices: [initialScrollIndex.index] } }
		2307	: {})}
		2308	maintainVisibleContentPosition
		2309	onLoad={handleLoad}
		2310	onScroll={handleScroll}
		2311	onLayout={updateScrollFades}
		2312	tabIndex={0}
		2313	role="region"
		2314	aria-label="Tool calls"
		2315	data-tool-group-scroll
		2316	className={cn(
		2317	"scrollbar-gutter-stable max-h-[min(18rem,50dvh)] scroll-py-6 overflow-x-hidden rounded-md focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70",
		2318	getVirtualizedScrollFadeClassName(fades),
		2319	)}
		2320	/>
		2321	</WorkGroupViewCtx>
		2322	);
		2323	}
		2324
		2325	const workEntryKey = (entry: TimelineWorkEntry) => entry.id;
		2326
2051	function ActivityShimmerOverlay({ children }: { children: ReactNode }) {	2327	function ActivityShimmerOverlay({ children }: { children: ReactNode }) {
2052	return (	2328	return (
2053	<span	2329	<span
@@ -2142,10 +2418,11 @@ function LiveActivityContent({ · 88 unmodified lines
2142	announceFailure?: boolean;	2418	announceFailure?: boolean;
2143	highlighted?: boolean;	2419	highlighted?: boolean;
2144	}) {	2420	}) {
2145	const resolvedIconName = failed ? "circle-alert" : iconName;	2421	const isSpecialToolIcon = iconName === "browser" \|\| iconName === "t3-code";
		2422	const resolvedIconName = failed && !isSpecialToolIcon ? "circle-alert" : iconName;
2146		2423
2147	return (	2424	return (
2148	<div	2425	<span
2149	className={cn(	2426	className={cn(
2150	"flex min-h-6 min-w-0 items-center gap-1.5 py-0.5",	2427	"flex min-h-6 min-w-0 items-center gap-1.5 py-0.5",
2151	resolvedIconName ? "px-0.5" : "px-1",	2428	resolvedIconName ? "px-0.5" : "px-1",
@@ -2161,14 +2438,15 @@ function LiveActivityContent({ · 9 unmodified lines
2161	role={announceFailure ? "img" : undefined}	2438	role={announceFailure ? "img" : undefined}
2162	aria-label={announceFailure ? "Tool call failed" : undefined}	2439	aria-label={announceFailure ? "Tool call failed" : undefined}
2163	>	2440	>
2164	<WorkEntryIconSvg	2441	<WorkEntryIcon
2165	name={resolvedIconName}	2442	name={resolvedIconName}
2166	className={cn("block size-4 shrink-0 stroke-[1.8]", !highlighted && "opacity-70")}	2443	className={cn("block size-4 shrink-0 stroke-[1.8]", !highlighted && "opacity-70")}
2167	/>	2444	/>
2168	</span>	2445	</span>
2169	) : null}	2446	) : null}
2170	<span className="min-w-0 flex-1 truncate">{label}</span>	2447	<span className="min-w-0 flex-1 truncate">{label}</span>
2171	</div>	2448	{failed && isSpecialToolIcon ? <XIcon aria-hidden className="size-3 shrink-0" /> : null}
		2449	</span>
2172	);	2450	);
2173	}	2451	}
2174		2452
@@ -2211,6 +2489,8 @@ function toolGroupSummaryIconName( · 36 unmodified lines
2211	return "square-pen";	2489	return "square-pen";
2212	case "command":	2490	case "command":
2213	return "terminal";	2491	return "terminal";
		2492	case "browser":
		2493	return "browser";
2214	case "search":	2494	case "search":
2215	return "globe";	2495	return "globe";
2216	case "code-search":	2496	case "code-search":
@@ -2244,7 +2524,7 @@ function WorkGroupToggleTimelineRow({ · 27 unmodified lines
2244	onClick={() => ctx.onToggleWorkGroup(row.groupId, row.id)}	2524	onClick={() => ctx.onToggleWorkGroup(row.groupId, row.id)}
2245	>	2525	>
2246	<span className="flex size-6 shrink-0 items-center justify-center text-icon-muted">	2526	<span className="flex size-6 shrink-0 items-center justify-center text-icon-muted">
2247	<WorkEntryIconSvg	2527	<WorkEntryIcon
2248	name={toolGroupSummaryIconName(row.summaryKind)}	2528	name={toolGroupSummaryIconName(row.summaryKind)}
2249	className="size-4 shrink-0 stroke-[1.8] opacity-70"	2529	className="size-4 shrink-0 stroke-[1.8] opacity-70"
2250	/>	2530	/>
@@ -2709,6 +2989,7 @@ function UserMessageReviewCommentCard({ comment }: { comment: ReviewCommentConte · 458 unmodified lines
2709	collapsed: false,	2989	collapsed: false,
2710	diffStyle: "unified",	2990	diffStyle: "unified",
2711	theme: resolveDiffThemeName(ctx.resolvedTheme),	2991	theme: resolveDiffThemeName(ctx.resolvedTheme),
		2992	preferredHighlighter: PREFERRED_HIGHLIGHTER,
2712	}}	2993	}}
2713	/>	2994	/>
2714	))}	2995	))}
@@ -2780,6 +3061,7 @@ function useStableRows(rows: MessagesTimelineRow[]): MessagesTimelineRow[] { · 65 unmodified lines
2780	type WorkEntryIconName =	3061	type WorkEntryIconName =
2781	\| "bot"	3062	\| "bot"
2782	\| "brain"	3063	\| "brain"
		3064	\| "browser"
2783	\| "check"	3065	\| "check"
2784	\| "circle-alert"	3066	\| "circle-alert"
2785	\| "eye"	3067	\| "eye"
@@ -2789,16 +3071,21 @@ type WorkEntryIconName = · 3 unmodified lines
2789	\| "search"	3071	\| "search"
2790	\| "square-pen"	3072	\| "square-pen"
2791	\| "terminal"	3073	\| "terminal"
		3074	\| "t3-code"
2792	\| "wrench"	3075	\| "wrench"
2793	\| "x"	3076	\| "x"
2794	\| "zap";	3077	\| "zap";
2795		3078
2796	function WorkEntryIconSvg({ name, className }: { name: WorkEntryIconName; className: string }) {	3079	function WorkEntryIcon({ name, className }: { name: WorkEntryIconName; className: string }) {
2797	switch (name) {	3080	switch (name) {
2798	case "bot":	3081	case "bot":
2799	return <BotIcon className={className} aria-hidden />;	3082	return <BotIcon className={className} aria-hidden />;
2800	case "brain":	3083	case "brain":
2801	return <BrainIcon className={className} aria-hidden />;	3084	return <BrainIcon className={className} aria-hidden />;
		3085	case "browser":
		3086	return <GlobeIcon className={className} aria-hidden />;
		3087	case "t3-code":
		3088	return <T3Wordmark className={className} aria-hidden />;
2802	case "check":	3089	case "check":
2803	return <CheckIcon className={className} aria-hidden />;	3090	return <CheckIcon className={className} aria-hidden />;
2804	case "circle-alert":	3091	case "circle-alert":
@@ -2869,33 +3156,6 @@ function workToneIcon(tone: TimelineWorkEntry["tone"]): { · 64 unmodified lines
2869	};	3156	};
2870	}	3157	}
2871		3158
2872	function workEntryPreview(
2873	workEntry: Pick<TimelineWorkEntry, "detail" \| "command" \| "changedFiles">,
2874	workspaceRoot: string \| undefined,
2875	) {
2876	// Collapsed rows show the tool's INPUT (command, touched files, search
2877	// pattern); outputs like stdout and diffs stay behind the expander.
2878	if (workEntry.command) return workEntry.command;
2879	const [firstPath] = workEntry.changedFiles ?? [];
2880	if (firstPath) {
2881	const displayPath = formatWorkspaceRelativePath(firstPath, workspaceRoot);
2882	return workEntry.changedFiles!.length === 1
2883	? displayPath
2884	: `${displayPath} +${workEntry.changedFiles!.length - 1} more`;
2885	}
2886	if (workEntry.detail?.trim()) {
2887	const lines = workEntry.detail
2888	.trim()
2889	.split(/\r?\n/)
2890	.map((line) => line.trim())
2891	.filter((line) => line.length > 0);
2892	if (lines.length > 0) {
2893	return lines.slice(0, 3).join(" · ");
2894	}
2895	}
2896	return null;
2897	}
2898
2899	function workEntryRawCommand(	3159	function workEntryRawCommand(
2900	workEntry: Pick<TimelineWorkEntry, "command" \| "rawCommand">,	3160	workEntry: Pick<TimelineWorkEntry, "command" \| "rawCommand">,
2901	): string \| null {	3161	): string \| null {
@@ -2951,42 +3211,14 @@ function buildToolCallExpandedBody( · 49 unmodified lines
2951	const toolCallExpandedBodyClassName =	3211	const toolCallExpandedBodyClassName =
2952	"max-h-64 cursor-text overflow-auto whitespace-pre-wrap break-words font-mono text-secondary-label text-[length:var(--font-size-code,0.6875rem)] leading-relaxed select-text";	3212	"max-h-64 cursor-text overflow-auto whitespace-pre-wrap break-words font-mono text-secondary-label text-[length:var(--font-size-code,0.6875rem)] leading-relaxed select-text";
2953		3213
2954	function liveWorkEntryLabel(
2955	workEntry: TimelineWorkEntry,
2956	workspaceRoot: string \| undefined,
2957	active: boolean,
2958	): string {
2959	const command = workEntry.command?.trim();
2960	if (command) {
2961	const program = commandProgramName(command);
2962	const verb = active
2963	? "Running"
2964	: workEntry.toolLifecycleStatus === "declined"
2965	? "Declined"
2966	: "Ran";
2967	if (program) return `${verb} ${program}`;
2968	return `${verb} command`;
2969	}
2970
2971	return workEntryPreview(workEntry, workspaceRoot) ?? toolWorkEntryHeading(workEntry);
2972	}
2973
2974	function workEntryIconName(workEntry: TimelineWorkEntry): WorkEntryIconName {	3214	function workEntryIconName(workEntry: TimelineWorkEntry): WorkEntryIconName {
2975	if (workEntry.itemType === "user_input_request") {	3215	if (workEntry.itemType === "user_input_request") {
2976	return "message-circle";	3216	return "message-circle";
2977	}	3217	}
2978	if (workEntry.requestKind === "command") return "terminal";	3218	const toolPresentation = resolveWorkEntryToolPresentation(workEntry);
2979	if (workEntry.requestKind === "file-read") return "eye";	3219	if (toolPresentation) return toolPresentation.icon;
2980	if (workEntry.requestKind === "file-change") return "square-pen";	3220	const action = toolGroupAction(workEntry);
2981		3221	if (action !== "other") return toolGroupSummaryIconName(action);
2982	if (workEntry.itemType === "command_execution" \|\| workEntry.command) {
2983	return "terminal";
2984	}
2985	if (workEntry.itemType === "file_change" \|\| (workEntry.changedFiles?.length ?? 0) > 0) {
2986	return "square-pen";
2987	}
2988	if (workEntry.itemType === "web_search") return "globe";
2989	if (workEntry.itemType === "file_search") return "eye";
2990		3222
2991	switch (workEntry.itemType) {	3223	switch (workEntry.itemType) {
2992	case "dynamic_tool":	3224	case "dynamic_tool":
@@ -3013,6 +3245,33 @@ function toolWorkEntryHeading(workEntry: TimelineWorkEntry): string { · 20 unmodified lines
3013	return capitalizePhrase(normalizeCompactToolLabel(workEntry.toolTitle));	3245	return capitalizePhrase(normalizeCompactToolLabel(workEntry.toolTitle));
3014	}	3246	}
3015		3247
		3248	function workEntryPreview(
		3249	workEntry: Pick<TimelineWorkEntry, "detail" \| "command" \| "changedFiles">,
		3250	workspaceRoot: string \| undefined,
		3251	) {
		3252	// Collapsed rows show the tool's INPUT (command, touched files, search
		3253	// pattern); outputs like stdout and diffs stay behind the expander.
		3254	if (workEntry.command) return workEntry.command;
		3255	const [firstPath] = workEntry.changedFiles ?? [];
		3256	if (firstPath) {
		3257	const displayPath = formatWorkspaceRelativePath(firstPath, workspaceRoot);
		3258	return workEntry.changedFiles!.length === 1
		3259	? displayPath
		3260	: `${displayPath} +${workEntry.changedFiles!.length - 1} more`;
		3261	}
		3262	if (workEntry.detail?.trim()) {
		3263	const lines = workEntry.detail
		3264	.trim()
		3265	.split(/\r?\n/)
		3266	.map((line) => line.trim())
		3267	.filter((line) => line.length > 0);
		3268	if (lines.length > 0) {
		3269	return lines.slice(0, 3).join(" · ");
		3270	}
		3271	}
		3272	return null;
		3273	}
		3274
3016	const stopRowToggle = (e: { stopPropagation: () => void }) => e.stopPropagation();	3275	const stopRowToggle = (e: { stopPropagation: () => void }) => e.stopPropagation();
3017		3276
3018	const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: {	3277	const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: {
@@ -3023,7 +3282,19 @@ const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: { · 4 unmodified lines
3023	const { workEntry, workspaceRoot, isExpandedToolGroupEntry = false } = props;	3282	const { workEntry, workspaceRoot, isExpandedToolGroupEntry = false } = props;
3024	const activity = use(TimelineRowActivityCtx);	3283	const activity = use(TimelineRowActivityCtx);
3025	const ctx = use(TimelineRowCtx);	3284	const ctx = use(TimelineRowCtx);
3026	const [expanded, setExpanded] = useState(false);	3285	const groupView = use(WorkGroupViewCtx);
		3286	const [expanded, setExpanded] = useState(
		3287	() => groupView?.state.expandedEntries.has(workEntry.id) ?? false,
		3288	);
		3289	const toggleExpanded = () => {
		3290	const next = !expanded;
		3291	if (groupView) {
		3292	groupView.onToggleEntry();
		3293	if (next) groupView.state.expandedEntries.add(workEntry.id);
		3294	else groupView.state.expandedEntries.delete(workEntry.id);
		3295	}
		3296	setExpanded(next);
		3297	};
3027	const iconConfig = workToneIcon(workEntry.tone);	3298	const iconConfig = workToneIcon(workEntry.tone);
3028	const showWarningIndicator = false;	3299	const showWarningIndicator = false;
3029	const entryIconName = showWarningIndicator ? "circle-alert" : workEntryIconName(workEntry);	3300	const entryIconName = showWarningIndicator ? "circle-alert" : workEntryIconName(workEntry);
@@ -3083,12 +3354,13 @@ const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: { · 53 unmodified lines
3083	? {	3354	? {
3084	role: "button" as const,	3355	role: "button" as const,
3085	tabIndex: 0 as const,	3356	tabIndex: 0 as const,
3086	"aria-label": displayText,	3357	"aria-label": showFailedIndicator ? `${displayText}, tool call failed` : displayText,
3087	onClick: () => setExpanded((v) => !v),	3358	"aria-expanded": expanded,
		3359	onClick: toggleExpanded,
3088	onKeyDown: (e: KeyboardEvent<HTMLDivElement>) => {	3360	onKeyDown: (e: KeyboardEvent<HTMLDivElement>) => {
3089	if (e.key === "Enter" \|\| e.key === " ") {	3361	if (e.key === "Enter" \|\| e.key === " ") {
3090	e.preventDefault();	3362	e.preventDefault();
3091	setExpanded((v) => !v);	3363	toggleExpanded();
3092	}	3364	}
3093	},	3365	},
3094	}	3366	}
@@ -3115,7 +3387,7 @@ const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: { · 20 unmodified lines
3115	{toolPresentation?.logo === "t3-code" ? (	3387	{toolPresentation?.logo === "t3-code" ? (
3116	<T3CodeToolLogo />	3388	<T3CodeToolLogo />
3117	) : (	3389	) : (
3118	<WorkEntryIconSvg	3390	<WorkEntryIcon
3119	name={entryIconName}	3391	name={entryIconName}
3120	className="block size-3.5 shrink-0 stroke-[1.8] opacity-80"	3392	className="block size-3.5 shrink-0 stroke-[1.8] opacity-80"
3121	/>	3393	/>

apps/web/src/components/chat/useAssistantCitationTarget.ts+3−3

@@ -1,5 +1,5 @@
1	import type { LegendListRef } from "@legendapp/list/react";	1	import type { LegendListRef } from "@legendapp/list/react";
2	import type { TurnId } from "@t3tools/contracts";	2	import type { RunId } from "@t3tools/contracts";
3	import { useCallback, useEffect, useRef, useState, type RefObject } from "react";	3	import { useCallback, useEffect, useRef, useState, type RefObject } from "react";
4	import type { TimelineEntry } from "../../session-logic";	4	import type { TimelineEntry } from "../../session-logic";
5	import type { MessagesTimelineRow } from "./MessagesTimeline.logic";	5	import type { MessagesTimelineRow } from "./MessagesTimeline.logic";
@@ -31,7 +31,7 @@ export function useAssistantCitationTarget({ · 25 unmodified lines
31	viewport: HTMLElement \| null;	31	viewport: HTMLElement \| null;
32	historyLoading: boolean;	32	historyLoading: boolean;
33	loadEarlier: CitationHistoryPage \| null;	33	loadEarlier: CitationHistoryPage \| null;
34	onExpandTurn: (turnId: TurnId) => void;	34	onExpandTurn: (runId: RunId) => void;
35	onManualNavigation: () => void;	35	onManualNavigation: () => void;
36	}) {	36	}) {
37	const [ready, setReady] = useState<AssistantCitationTarget \| null>(null);	37	const [ready, setReady] = useState<AssistantCitationTarget \| null>(null);
@@ -119,7 +119,7 @@ export function useAssistantCitationTarget({ · 81 unmodified lines
119	(row) => row.kind === "message" && row.message.id === navigation.target.citation.messageId,	119	(row) => row.kind === "message" && row.message.id === navigation.target.citation.messageId,
120	);	120	);
121	if (index < 0) {	121	if (index < 0) {
122	if (source.message.turnId) onExpandTurn(source.message.turnId);	122	if (source.message.runId) onExpandTurn(source.message.runId);
123	return;	123	return;
124	}	124	}
125	if (listLoaded && listRef.current) setReady(navigation.target);	125	if (listLoaded && listRef.current) setReady(navigation.target);

apps/web/src/components/pullRequest/pullRequestDetail.logic.ts+1−0

@@ -13,6 +13,7 @@ import type { · 12 unmodified lines
13	PullRequestReviewThread,	13	PullRequestReviewThread,
14	PullRequestState,	14	PullRequestState,
15	PullRequestUpdateMethod,	15	PullRequestUpdateMethod,
		16	SourceControlProviderKind,
16	VcsRef,	17	VcsRef,
17	} from "@t3tools/contracts";	18	} from "@t3tools/contracts";
18		19

apps/web/src/index.css+8−2

   margin-left: var(--live-activity-focus-width);
 }
+@property --assistant-citation-highlight-opacity {
+  syntax: "<number>";
+  inherits: true;
+  initial-value: 0;
+}
 @layer base {
   ::highlight(t3-assistant-citation) {
     background-color: color-mix(
     /* Keep controls and floating surfaces close to the neutral-black canvas.
        Borders and hover states provide separation without milky gray fills. */
     --background: var(--color-neutral-950);
-    --surface-raised: var(--secondary);
+    --surface-raised: color-mix(in srgb, var(--background) 97%, var(--color-white));
     --foreground: var(--color-neutral-100);
     --card: color-mix(in srgb, var(--background) 97%, var(--color-white));
     --card-foreground: var(--color-neutral-100);
     --popover: color-mix(in srgb, var(--background) 97%, var(--color-white));
     --popover-foreground: var(--color-neutral-100);
     --primary: oklch(0.571 0.21 264);
-    --secondary: --alpha(var(--color-white) / 4%);
+    --secondary: --alpha(var(--color-white) / 3%);
     --secondary-foreground: var(--color-neutral-100);
     --muted: --alpha(var(--color-white) / 3%);
     --muted-foreground: color-mix(in srgb, var(--color-neutral-500) 90%, var(--color-white));

apps/web/src/lib/contextWindow.ts+0−22

@@ -22,28 +22,6 @@ export type ContextWindowSnapshot = NullableContextWindowUsage & { · 21 unmodified lines
22	readonly updatedAt: string;	22	readonly updatedAt: string;
23	};	23	};
24		24
25	/** Map a provider driver kind to a user-facing display name. */
26	export function formatProviderDisplayName(provider: string \| null \| undefined): string {
27	if (!provider) return "This agent";
28	switch (provider) {
29	case "claudeAgent":
30	case "claude":
31	return "Claude";
32	case "codex":
33	return "Codex";
34	case "cursor":
35	return "Cursor";
36	case "opencode":
37	return "OpenCode";
38	default: {
39	// Title-case unknown driver kinds so they read reasonably.
40	const trimmed = provider.replace(/Agent$/i, "").trim();
41	if (trimmed.length === 0) return provider;
42	return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
43	}
44	}
45	}
46
47	/** Prefers the provider's live usage report (#8144); falls back to the last compaction item. */	25	/** Prefers the provider's live usage report (#8144); falls back to the last compaction item. */
48	export function deriveLatestContextWindowSnapshot(	26	export function deriveLatestContextWindowSnapshot(
49	entries: ReadonlyArray<{	27	entries: ReadonlyArray<{

apps/web/src/state/entities.ts+0−34

@@ -22,16 +22,12 @@ import { · 21 unmodified lines
22	import { environmentThreadDetails, environmentThreadShells } from "./threads";	22	import { environmentThreadDetails, environmentThreadShells } from "./threads";
23	import { waitForAtomValue } from "./waitForAtomValue";	23	import { waitForAtomValue } from "./waitForAtomValue";
24		24
25	const EMPTY_PROJECT_REFS: ReadonlyArray<ScopedProjectRef> = Object.freeze([]);
26	const EMPTY_THREAD_REFS: ReadonlyArray<ScopedThreadRef> = Object.freeze([]);	25	const EMPTY_THREAD_REFS: ReadonlyArray<ScopedThreadRef> = Object.freeze([]);
27	const EMPTY_VISIBLE_TURN_ITEMS: ReadonlyArray<OrchestrationV2ProjectedTurnItem> = Object.freeze([]);	26	const EMPTY_VISIBLE_TURN_ITEMS: ReadonlyArray<OrchestrationV2ProjectedTurnItem> = Object.freeze([]);
28		27
29	const EMPTY_PROJECT_ATOM = Atom.make<EnvironmentProject \| null>(null).pipe(	28	const EMPTY_PROJECT_ATOM = Atom.make<EnvironmentProject \| null>(null).pipe(
30	Atom.withLabel("web-project:empty"),	29	Atom.withLabel("web-project:empty"),
31	);	30	);
32	const EMPTY_PROJECT_REFS_ATOM = Atom.make(EMPTY_PROJECT_REFS).pipe(
33	Atom.withLabel("web-project-refs:empty"),
34	);
35	const EMPTY_THREAD_REFS_ATOM = Atom.make(EMPTY_THREAD_REFS).pipe(	31	const EMPTY_THREAD_REFS_ATOM = Atom.make(EMPTY_THREAD_REFS).pipe(
36	Atom.withLabel("web-thread-refs:empty"),	32	Atom.withLabel("web-thread-refs:empty"),
37	);	33	);
@@ -60,32 +56,14 @@ export function useActiveEnvironmentId(): EnvironmentId \| null { · 22 unmodified lines
60	return useAtomValue(activeEnvironmentIdAtom);	56	return useAtomValue(activeEnvironmentIdAtom);
61	}	57	}
62		58
63	export function readActiveEnvironmentId(): EnvironmentId \| null {
64	return appAtomRegistry.get(activeEnvironmentIdAtom);
65	}
66
67	export function setActiveEnvironmentId(environmentId: EnvironmentId \| null): void {	59	export function setActiveEnvironmentId(environmentId: EnvironmentId \| null): void {
68	appAtomRegistry.set(activeEnvironmentIdAtom, environmentId);	60	appAtomRegistry.set(activeEnvironmentIdAtom, environmentId);
69	}	61	}
70		62
71	export function useProjectRefs(): ReadonlyArray<ScopedProjectRef> {
72	return useAtomValue(environmentProjects.projectRefsAtom);
73	}
74
75	export function useThreadRefs(): ReadonlyArray<ScopedThreadRef> {	63	export function useThreadRefs(): ReadonlyArray<ScopedThreadRef> {
76	return useAtomValue(environmentThreadShells.threadRefsAtom);	64	return useAtomValue(environmentThreadShells.threadRefsAtom);
77	}	65	}
78		66
79	export function useEnvironmentProjectRefs(
80	environmentId: EnvironmentId \| null,
81	): ReadonlyArray<ScopedProjectRef> {
82	return useAtomValue(
83	environmentId === null
84	? EMPTY_PROJECT_REFS_ATOM
85	: environmentProjects.environmentProjectRefsAtom(environmentId),
86	);
87	}
88
89	export function useEnvironmentThreadRefs(	67	export function useEnvironmentThreadRefs(
90	environmentId: EnvironmentId \| null,	68	environmentId: EnvironmentId \| null,
91	): ReadonlyArray<ScopedThreadRef> {	69	): ReadonlyArray<ScopedThreadRef> {
@@ -283,18 +261,6 @@ export function readEnvironmentThreadRefs( · 191 unmodified lines
283	return appAtomRegistry.get(environmentThreadShells.environmentThreadRefsAtom(environmentId));	261	return appAtomRegistry.get(environmentThreadShells.environmentThreadRefsAtom(environmentId));
284	}	262	}
285		263
286	export function readThreadRefs(): ReadonlyArray<ScopedThreadRef> {
287	return appAtomRegistry.get(environmentThreadShells.threadRefsAtom);
288	}
289
290	export function readThreadShells(): ReadonlyArray<EnvironmentThreadShell> {	264	export function readThreadShells(): ReadonlyArray<EnvironmentThreadShell> {
291	return appAtomRegistry.get(environmentThreadShells.threadShellsAtom);	265	return appAtomRegistry.get(environmentThreadShells.threadShellsAtom);
292	}	266	}
293
294	export function findThreadRef(threadId: ThreadId): ScopedThreadRef \| null {
295	return (
296	appAtomRegistry
297	.get(environmentThreadShells.threadRefsAtom)
298	.find((ref) => ref.threadId === threadId) ?? null
299	);
300	}

packages/client-runtime/package.json+4−0

     "./work-log/command-label": {
       "types": "./src/work-log/commandLabel.ts",
       "default": "./src/work-log/commandLabel.ts"
+    },
+    "./work-log/scroll-anchor": {
+      "types": "./src/work-log/scrollAnchor.ts",
+      "default": "./src/work-log/scrollAnchor.ts"
     }
   },
   "scripts": {

packages/client-runtime/src/connection/registry.test.ts+1−0

@@ -50,6 +50,7 @@ import * as EnvironmentRegistry from "./registry.ts"; · 49 unmodified lines
50	import * as RpcSession from "../rpc/session.ts";	50	import * as RpcSession from "../rpc/session.ts";
51	import * as EnvironmentSupervisor from "./supervisor.ts";	51	import * as EnvironmentSupervisor from "./supervisor.ts";
52	import * as ConnectionWakeups from "./wakeups.ts";	52	import * as ConnectionWakeups from "./wakeups.ts";
		53	import { runDesktopCommitWithReconnectObserver } from "../state/server.ts";
53	import { v2ShellSnapshot } from "../state/orchestrationV2TestFixtures.ts";	54	import { v2ShellSnapshot } from "../state/orchestrationV2TestFixtures.ts";
54		55
55	const TARGET = new PrimaryConnectionTarget({	56	const TARGET = new PrimaryConnectionTarget({

packages/client-runtime/src/operations/threadTitle.ts+2−1

+import { assistantCitationsToPlainText } from "@t3tools/shared/assistantCitations";
 import { truncate } from "@t3tools/shared/String";
 export interface ThreadTitleSeedInput {
 }
 function normalizeTitleSeed(value: string): string {
-  return value.trim().replace(/\s+/gu, " ");
+  return assistantCitationsToPlainText(value).trim().replace(/\s+/gu, " ");
 }
 export function deriveThreadTitleSeed(input: ThreadTitleSeedInput): string {

packages/client-runtime/src/state/models.ts+0−10

@@ -4,7 +4,6 @@ import type { · 3 unmodified lines
4	MessageId,	4	MessageId,
5	OrchestrationProjectShell,	5	OrchestrationProjectShell,
6	OrchestrationV2RunStatus,	6	OrchestrationV2RunStatus,
7	OrchestrationV2ShellSnapshot,
8	OrchestrationV2ThreadProjection,	7	OrchestrationV2ThreadProjection,
9	OrchestrationV2ThreadShell,	8	OrchestrationV2ThreadShell,
10	PlanId,	9	PlanId,
@@ -237,12 +236,3 @@ export function presentThreadShell( · 226 unmodified lines
237	}	236	}
238		237
239	export const scopeThreadShell = presentThreadShell;	238	export const scopeThreadShell = presentThreadShell;
240
241	export function selectEnvironmentThreadShell(
242	snapshot: OrchestrationV2ShellSnapshot \| null,
243	environmentId: EnvironmentId,
244	threadId: ThreadId,
245	): EnvironmentThreadShell \| null {
246	const thread = snapshot?.threads.find((candidate) => candidate.id === threadId) ?? null;
247	return thread ? presentThreadShell(environmentId, thread) : null;
248	}

packages/client-runtime/src/work-log/commandLabel.ts+24−1

@@ -1,5 +1,21 @@
1	type CommandWrapper = "env" \| "sudo";	1	type CommandWrapper = "env" \| "sudo";
2		2
		3	const SHELL_PROGRAMS = new Set(["sh", "bash", "zsh", "dash", "ash", "ksh", "fish"]);
		4	const SHELL_OPTIONS_WITH_VALUE = new Set(["-o", "-O", "--rcfile", "--init-file"]);
		5
		6	function shellCommandArgumentIndex(tokens: ReadonlyArray<string>, start: number): number \| null {
		7	for (let index = start; index < tokens.length; index += 1) {
		8	const option = tokens[index]!;
		9	if (option === "--" \|\| !option.startsWith("-")) return null;
		10	if (SHELL_OPTIONS_WITH_VALUE.has(option)) {
		11	index += 1;
		12	continue;
		13	}
		14	if (option === "--command" \|\| /^-[a-zA-Z]c[a-zA-Z]$/.test(option)) return index + 1;
		15	}
		16	return null;
		17	}
		18
3	const COMMAND_WRAPPER_OPTIONS_WITH_VALUE: Record<CommandWrapper, ReadonlySet<string>> = {	19	const COMMAND_WRAPPER_OPTIONS_WITH_VALUE: Record<CommandWrapper, ReadonlySet<string>> = {
4	env: new Set(["-C", "--chdir", "-S", "--split-string", "-u", "--unset"]),	20	env: new Set(["-C", "--chdir", "-S", "--split-string", "-u", "--unset"]),
5	sudo: new Set(["-C", "--close-from", "-D", "--chdir", "-g", "--group", "-u", "--user"]),	21	sudo: new Set(["-C", "--close-from", "-D", "--chdir", "-g", "--group", "-u", "--user"]),
@@ -162,7 +178,14 @@ export function commandProgramName(command: string, depth = 0): string \| null { · 156 unmodified lines
162	}	178	}
163	return null;	179	return null;
164	}	180	}
165	return token.split(/[\\/]/).at(-1) \|\| null;	181	if (tokenProgram && SHELL_PROGRAMS.has(tokenProgram.replace(/\.exe$/i, "").toLowerCase())) {
		182	const scriptIndex = shellCommandArgumentIndex(tokens, index + 1);
		183	if (scriptIndex !== null) {
		184	const script = tokens[scriptIndex];
		185	return script ? commandProgramName(script, depth + 1) : null;
		186	}
		187	}
		188	return tokenProgram \|\| null;
166	}	189	}
167		190
168	return null;	191	return null;

packages/client-runtime/src/work-log/presentation.test.ts+44−92

   toolGroupAction,
   toolGroupSummaryKind,
   type WorkLogPresentationEntry,
+  type WorkLogToolLifecycleStatus,
   workEntryViewedImagePath,
 } from "./presentation.js";
-describe("summarizeToolGroup", () => {
-  it.each(["command", "file-read", "file-change"])(
-    "keeps %s approvals out of tool execution counts",
-    (requestKind) => {
-      const approvals = [
-        {
-          label: "Approval requested",
-          sourceActivityKind: "approval.requested",
-          tone: "info",
-          requestKind,
-        },
-        {
-          label: "Approval resolved",
-          sourceActivityKind: "approval.resolved",
-          tone: "info",
-          requestKind,
-        },
-        {
-          label: "Provider approval response failed",
-          sourceActivityKind: "provider.approval.respond.failed",
-          tone: "error",
-        },
-      ] satisfies WorkLogPresentationEntry[];
-      expect(
-        summarizeToolGroup([
-          ...approvals,
-          { label: "Read", tone: "tool", itemType: "dynamic_tool_call" },
-        ]),
-      ).toBe("Received 3 updates and used 1 tool");
-      expect(summarizeToolGroup(approvals)).toBe("Received 3 updates");
-      expect(toolGroupSummaryKind(approvals)).toBe("update");
-    },
-  );
-  it("deduplicates named sources ahead of ordinary actions", () => {
-    const source = { key: "browser-use:chrome", name: "Chrome", kind: "integration" as const };
-    expect(
-      summarizeToolGroup([
-        { label: "Open page", tone: "tool", toolSource: source },
-        { label: "Inspect page", tone: "tool", toolSource: source },
-        {
-          label: "Ran command",
-          tone: "tool",
-          itemType: "command_execution",
-          command: "git status",
-        },
-      ]),
-    ).toBe("Used Chrome integration and ran 1 command");
-  });
-  it("omits the integration suffix for special browser and computer sources", () => {
-    expect(
-      summarizeToolGroup([
-        {
-          label: "Inspect page",
-          tone: "tool",
-          toolSource: { key: "browser-use", name: "Browser", kind: "browser" },
-        },
-        {
-          label: "Click",
-          tone: "tool",
-          toolSource: { key: "computer-use", name: "Computer Use", kind: "computer" },
-        },
-      ]),
-    ).toBe("Used Browser and Computer Use");
-  });
-});
 describe("resolveWorkEntryToolPresentation", () => {
   it.each([
     "mcp__t3-code__preview_click",
     "preview_click",
   ])("recognizes browser tool names across providers: %s", (label) => {
     expect(resolveWorkEntryToolPresentation({ label })).toEqual({
-      displayName: "Clicking in the preview browser",
+      displayName: "Click in the preview browser",
       icon: "browser",
     });
   });
         toolTitle: "Inspect the current page",
         toolData: { server: "t3-code", tool: "preview_snapshot", result: { title: "Example" } },
       }),
-    ).toEqual({ displayName: "Taking a snapshot of the preview page", icon: "browser" });
+    ).toEqual({ displayName: "Take a snapshot of the preview page", icon: "browser" });
   });
   it.each([
     ["failed", "Failed to click in the preview browser"],
     ["declined", "Declined to click in the preview browser"],
     ["stopped", "Stopped clicking in the preview browser"],
-    ["unknown", "Clicking in the preview browser"],
+    ["unknown", "Click in the preview browser"],
-  ])("describes the tool's own %s state", (toolLifecycleStatus, displayName) => {
+  ] as const)("describes the tool's own %s state", (toolLifecycleStatus, displayName) => {
     expect(
       resolveWorkEntryToolPresentation({
         label: "T3-code.preview_click",
-        toolLifecycleStatus,
+        toolLifecycleStatus: toolLifecycleStatus as WorkLogToolLifecycleStatus,
       }),
     ).toEqual({ displayName, icon: "browser" });
   });
         label: "mcp__t3_code__task_status",
         toolTitle: "Check the child task",
       }),
-    ).toEqual({ displayName: "Getting delegated task status", icon: "t3-code" });
+    ).toEqual({ displayName: "Get delegated task status", icon: "t3-code" });
   });
   it("does not brand unknown tools or another server's matching tool name", () => {
 });
 describe("browser group summaries", () => {
+  const summarizeGroupLabel = (entries: ReadonlyArray<WorkLogPresentationEntry>) =>
+    summarizeToolGroup(entries).summary;
   const browserEntry: WorkLogPresentationEntry = {
+    id: "browser",
+    createdAt: "2026-09-01T00:00:00Z",
     label: "MCP tool call",
     toolData: { server: "t3-code", tool: "preview_click" },
-    itemType: "mcp_tool_call",
+    itemType: "dynamic_tool",
     toolLifecycleStatus: "completed",
     tone: "tool",
   };
   const commandEntry: WorkLogPresentationEntry = {
+    id: "command",
+    createdAt: "2026-09-01T00:00:00Z",
     label: "Ran command",
     command: "/bin/bash -lc 'vp test run'",
     itemType: "command_execution",
       ...browserEntry,
       toolCallId: `browser-${index}`,
     }));
-    expect(summarizeToolGroup(entries)).toBe(
+    expect(summarizeGroupLabel(entries)).toBe(
       `Used browser ${count} ${count === 1 ? "time" : "times"}`,
     );
     expect(toolGroupSummaryKind(entries)).toBe("browser");
       ...Array.from({ length: 4 }, () => commandEntry),
       ...Array.from({ length: 15 }, () => browserEntry),
     ];
-    expect(summarizeToolGroup(entries)).toBe("Ran 4 commands and used browser 15 times");
+    expect(summarizeGroupLabel(entries)).toBe("Ran 4 commands and used browser 15 times");
     expect(toolGroupSummaryKind(entries)).toBe("mixed");
   });
   it("preserves first-seen action ordering alongside non-browser tools", () => {
     expect(
-      summarizeToolGroup([
+      summarizeGroupLabel([
         browserEntry,
         commandEntry,
         {
           toolData: { server: "t3-code", tool: "task_status" },
         },
       ]),
-    ).toBe("Used browser 1 time, ran 1 command, and used 1 tool");
+    ).toBe("Used browser 1 time, ran 1 command, and performed 1 other action");
   });
   it("recognizes Claude browser identity without treating script metadata as a shell command", () => {
     expect(
-      summarizeToolGroup([
+      summarizeGroupLabel([
         {
           ...browserEntry,
           command: "node inspect-page.js",
   it("keeps foreign tools and web searches out of the browser count", () => {
     expect(
-      summarizeToolGroup([
+      summarizeGroupLabel([
         browserEntry,
         {
           ...browserEntry,
           label: "preview_click",
           toolData: { server: "another-server", tool: "preview_click" },
         },
-        { label: "Search", tone: "tool", itemType: "web_search" },
+        {
+          id: "search",
+          createdAt: "2026-09-01T00:00:00Z",
+          label: "Search",
+          tone: "tool",
+          itemType: "web_search",
+        },
       ]),
-    ).toBe("Used browser 1 time, used 1 tool, and searched the web 1 time");
+    ).toBe("Used browser 1 time, searched the web 1 time, and performed 1 other action");
   });
   it("keeps browser screenshots in the browser count while preserving their image path", () => {
     const entry = { ...browserEntry, viewedImagePath: "/workspace/page.png" };
-    expect(summarizeToolGroup([entry])).toBe("Used browser 1 time");
+    expect(summarizeGroupLabel([entry])).toBe("Used browser 1 time");
     expect(workEntryViewedImagePath(entry)).toBe("/workspace/page.png");
   });
 });
     expect(
       workEntryViewedImagePath({
         ...entry,
-        itemType: "dynamic_tool_call",
+        itemType: "dynamic_tool",
         detail: 'Read: {"file_path":"truncated..."}',
         viewedImagePath: " /workspace/reference image.webp ",
       }),
   it("groups legacy Claude image reads with other reads", () => {
     expect(
       toolGroupAction({
+        id: "legacy-read",
+        createdAt: "2026-09-01T00:00:00Z",
         label: "Tool call",
         tone: "tool",
-        itemType: "dynamic_tool_call",
+        itemType: "dynamic_tool",
         viewedImagePath: "/workspace/reference.png",
       }),
     ).toBe("read");
 describe("resolveViewedImageAsset", () => {
   const threadId = ThreadId.make("thread-1");
-  it("serves t3 attachment paths in place like any other host path", () => {
+  it("loads t3 attachment paths as attachments", () => {
-    const path = "/Users/demo/.t3/dev/attachments/11111111-1111-4111-8111-111111111111.png";
+    const attachmentId =
-    expect(resolveViewedImageAsset(path, { threadId, workspaceRoot: "/workspace" })).toEqual({
+      "11111111-1111-4111-8111-111111111111-22222222-2222-4222-8222-222222222222";
-      resource: { _tag: "media-file", threadId, path },
+    expect(
-      alt: "11111111-1111-4111-8111-111111111111.png",
+      resolveViewedImageAsset(`/Users/demo/.t3/dev/attachments/${attachmentId}.png`, {
+        threadId,
+        workspaceRoot: "/workspace",
+      }),
+    ).toEqual({
+      resource: { _tag: "attachment", attachmentId },
+      alt: `${attachmentId}.png`,
       srcFragment: "",
     });
   });

packages/client-runtime/src/work-log/presentation.ts+261−8

@@ -1,4 +1,9 @@
1	import type { AssetResource, OrchestrationV2TurnItem, ThreadId } from "@t3tools/contracts";	1	import {
		2	isToolLifecycleItemType,
		3	type AssetResource,
		4	type OrchestrationV2TurnItem,
		5	type ThreadId,
		6	} from "@t3tools/contracts";
2	import {	7	import {
3	resolveT3McpToolSummaryAction,	8	resolveT3McpToolSummaryAction,
4	type T3McpToolSummaryAction,	9	type T3McpToolSummaryAction,
@@ -27,6 +32,7 @@ export interface WorkLogPresentationEntry { · 22 unmodified lines
27	readonly command?: string;	32	readonly command?: string;
28	readonly rawCommand?: string;	33	readonly rawCommand?: string;
29	readonly detail?: string;	34	readonly detail?: string;
		35	readonly viewedImagePath?: string;
30	readonly changedFiles?: ReadonlyArray<string>;	36	readonly changedFiles?: ReadonlyArray<string>;
31	readonly toolTitle?: string;	37	readonly toolTitle?: string;
32	readonly toolData?: unknown;	38	readonly toolData?: unknown;
@@ -40,6 +46,7 @@ export type ToolGroupAction = · 7 unmodified lines
40	\| "read"	46	\| "read"
41	\| "edit"	47	\| "edit"
42	\| "command"	48	\| "command"
		49	\| "browser"
43	\| "code-search"	50	\| "code-search"
44	\| "search"	51	\| "search"
45	\| "other"	52	\| "other"
@@ -56,16 +63,251 @@ export function normalizeCompactToolLabel(value: string): string { · 10 unmodified lines
56	return value.replace(/\s+(?:complete\|completed)\s*$/i, "").trim();	63	return value.replace(/\s+(?:complete\|completed)\s*$/i, "").trim();
57	}	64	}
58		65
59	export function workLogEntryIsToolLike(entry: WorkLogPresentationEntry): boolean {	66	const T3_MCP_TOOL_LABELS: Record<
		67	string,
		68	readonly [action: string, running: string, completed: string, detail: string]
		69	> = {
		70	orchestrator_capabilities: ["Get", "Getting", "Got", "orchestration capabilities"],
		71	delegate_task: ["Delegate", "Delegating", "Delegated", "a child task"],
		72	task_status: ["Get", "Getting", "Got", "delegated task status"],
		73	task_cancel: ["Cancel", "Canceling", "Canceled", "delegated task"],
		74	schedule_task: ["Schedule", "Scheduling", "Scheduled", "a recurring task"],
		75	list_scheduled_tasks: ["List", "Listing", "Listed", "scheduled tasks"],
		76	update_scheduled_task: ["Update", "Updating", "Updated", "a scheduled task"],
		77	delete_scheduled_task: ["Delete", "Deleting", "Deleted", "a scheduled task"],
		78	create_threads: ["Create", "Creating", "Created", "T3 threads"],
		79	t3_thread_start: ["Start", "Starting", "Started", "a T3 thread"],
		80	t3_thread_list: ["List", "Listing", "Listed", "T3 threads"],
		81	t3_thread_read: ["Read", "Reading", "Read", "a T3 thread"],
		82	t3_thread_send: ["Send", "Sending", "Sent", "to a T3 thread"],
		83	t3_thread_wait: ["Wait", "Waiting", "Waited", "for a T3 thread"],
		84	t3_thread_interrupt: ["Interrupt", "Interrupting", "Interrupted", "a T3 thread"],
		85	t3_worktree_handoff: ["Hand off", "Handing off", "Handed off", "thread to a git worktree"],
		86	t3_worktree_status: ["Get", "Getting", "Got", "thread worktree status"],
		87	preview_status: ["Get", "Getting", "Got", "preview browser status"],
		88	preview_open: ["Open", "Opening", "Opened", "a page in the preview browser"],
		89	preview_navigate: ["Navigate", "Navigating", "Navigated", "the preview browser"],
		90	preview_snapshot: [
		91	"Take a snapshot of",
		92	"Taking a snapshot of",
		93	"Took a snapshot of",
		94	"the preview page",
		95	],
		96	preview_click: ["Click", "Clicking", "Clicked", "in the preview browser"],
		97	preview_press: ["Press", "Pressing", "Pressed", "a key in the preview browser"],
		98	preview_type: ["Type", "Typing", "Typed", "in the preview browser"],
		99	preview_scroll: ["Scroll", "Scrolling", "Scrolled", "the preview browser"],
		100	preview_resize: ["Resize", "Resizing", "Resized", "the preview browser"],
		101	preview_evaluate: ["Evaluate", "Evaluating", "Evaluated", "script in the preview browser"],
		102	preview_wait_for: ["Wait", "Waiting", "Waited", "for the preview page"],
		103	preview_set_appearance: ["Set", "Setting", "Set", "preview browser appearance"],
		104	preview_recording_start: ["Start", "Starting", "Started", "recording the preview browser"],
		105	preview_recording_stop: ["Stop", "Stopping", "Stopped", "recording the preview browser"],
		106	};
		107
		108	function resolveT3McpToolPresentation(value: string \| undefined, status: string \| undefined) {
		109	if (!value) return null;
		110	const name = normalizeCompactToolLabel(value).replace(
		111	/^(?:mcp__(?:t3-code\|t3_code\|t3code)__\|(?:t3-code\|t3_code\|t3code)(?:[.:/]\|\s·\s))/i,
		112	"",
		113	);
		114	if (!Object.hasOwn(T3_MCP_TOOL_LABELS, name)) return null;
		115
		116	const [action, running, completed, detail] = T3_MCP_TOOL_LABELS[name]!;
		117	const verb =
		118	status === "inProgress"
		119	? running
		120	: status === "completed"
		121	? completed
		122	: status === "failed"
		123	? `Failed to ${action.toLowerCase()}`
		124	: status === "declined"
		125	? `Declined to ${action.toLowerCase()}`
		126	: status === "stopped"
		127	? `Stopped ${running.toLowerCase()}`
		128	: action;
		129
		130	return {
		131	displayName: `${verb} ${detail}`,
		132	icon: name.startsWith("preview_") ? ("browser" as const) : ("t3-code" as const),
		133	};
		134	}
		135
		136	/** Resolves tool identity before choosing labels or icons in either client. */
		137	export function resolveWorkEntryToolPresentation(
		138	entry: Pick<WorkLogPresentationEntry, "label" \| "toolTitle" \| "toolData" \| "toolLifecycleStatus">,
		139	fallbackStatus?: "inProgress" \| "completed",
		140	) {
		141	const status = entry.toolLifecycleStatus ?? fallbackStatus;
		142	const data = entry.toolData;
		143	if (data !== null && typeof data === "object") {
		144	if (
		145	"server" in data &&
		146	typeof data.server === "string" &&
		147	"tool" in data &&
		148	typeof data.tool === "string"
		149	) {
		150	return resolveT3McpToolPresentation(`${data.server}.${data.tool}`, status);
		151	}
		152	if ("toolName" in data && typeof data.toolName === "string") {
		153	return resolveT3McpToolPresentation(data.toolName, status);
		154	}
		155	}
		156
60	return (	157	return (
61	entry.tone === "tool" \|\|	158	resolveT3McpToolPresentation(entry.toolTitle, status) ??
62	entry.tone === "thinking" \|\|	159	resolveT3McpToolPresentation(entry.label, status)
63	entry.tone === "error" \|\|
64	entry.command !== undefined \|\|
65	entry.requestKind !== undefined
66	);	160	);
67	}	161	}
68		162
		163	function asRecord(value: unknown): Record<string, unknown> \| null {
		164	return value !== null && typeof value === "object" && !Array.isArray(value)
		165	? (value as Record<string, unknown>)
		166	: null;
		167	}
		168
		169	function nonEmptyString(value: unknown): string \| null {
		170	return typeof value === "string" && value.trim().length > 0 ? value : null;
		171	}
		172
		173	function commandResultContent(value: unknown): string \| null {
		174	const direct = nonEmptyString(value);
		175	if (direct) return direct;
		176
		177	const directContent = Array.isArray(value) ? value : null;
		178	const record = asRecord(value);
		179	const content = record?.content;
		180	const contentText = nonEmptyString(content);
		181	if (contentText) return contentText;
		182	const blocks = directContent ?? (Array.isArray(content) ? content : null);
		183	if (!blocks) return null;
		184
		185	const chunks = blocks.flatMap((entry) => {
		186	const text = nonEmptyString(entry) ?? nonEmptyString(asRecord(entry)?.text);
		187	return text ? [text] : [];
		188	});
		189	return chunks.length > 0 ? chunks.join("\n") : null;
		190	}
		191
		192	/** Returns provider command output before it is formatted for a work-log row. */
		193	export function extractCommandOutputText(dataValue: unknown): string \| null {
		194	const data = asRecord(dataValue);
		195	const item = asRecord(data?.item);
		196	const itemResult = asRecord(item?.result);
		197	const rawOutput = asRecord(data?.rawOutput);
		198	const outputStreams = [
		199	nonEmptyString(rawOutput?.stdout),
		200	nonEmptyString(rawOutput?.stderr),
		201	].filter((value): value is string => value !== null);
		202	const acpContent = Array.isArray(data?.content)
		203	? data.content
		204	.flatMap((entryValue) => {
		205	const entry = asRecord(entryValue);
		206	const content = asRecord(entry?.content);
		207	const text = entry?.type === "content" ? nonEmptyString(content?.text) : null;
		208	return text ? [text] : [];
		209	})
		210	.join("\n")
		211	: null;
		212
		213	const candidates = [
		214	item?.aggregatedOutput,
		215	itemResult?.content,
		216	data?.rawOutput,
		217	rawOutput?.content,
		218	outputStreams.length > 0 ? outputStreams.join("\n") : null,
		219	rawOutput?.output,
		220	acpContent,
		221	data?.result,
		222	];
		223	for (const candidate of candidates) {
		224	const text = commandResultContent(candidate);
		225	if (text) return text;
		226	}
		227	return null;
		228	}
		229
		230	/**
		231	* Ingestion caps tool details at 180 chars and appends "...", so a long command
		232	* echo no longer equals the command it repeats. Treat a truncated prefix of the
		233	* command as the same echo.
		234	*/
		235	function textRepeatsCommand(text: string, commands: ReadonlyArray<string \| null>): boolean {
		236	const truncated = text.endsWith("...")
		237	? text.slice(0, -3)
		238	: text.endsWith("\u2026")
		239	? text.slice(0, -1)
		240	: null;
		241	return commands.some((candidate) => {
		242	const command = candidate?.trim();
		243	if (!command) return false;
		244	if (command === text) return true;
		245	return (
		246	truncated !== null &&
		247	truncated.length > 0 &&
		248	command.length > truncated.length &&
		249	command.startsWith(truncated)
		250	);
		251	});
		252	}
		253
		254	/**
		255	* Decides whether a command row's `detail` is a synthetic echo of the command
		256	* rather than real output. OpenCode stores completed output in `detail` with no
		257	* other output channel, so plain equality is only treated as synthetic when the
		258	* payload shape shows the detail came from the command: Codex item metadata,
		259	* an ACP tool call (`data.toolCallId`, `kind: "execute"`), a Claude tool-name
		260	* prefix, or no structured command at all.
		261	*/
		262	export function commandDetailRepeatsCommand(input: {
		263	readonly detail: string;
		264	readonly command: string \| null;
		265	readonly rawCommand: string \| null;
		266	readonly toolName: unknown;
		267	readonly data: unknown;
		268	}): boolean {
		269	const toolName = nonEmptyString(input.toolName)?.trim();
		270	const detail = input.detail.trim();
		271	const commands = [input.command, input.rawCommand];
		272	if (toolName) {
		273	const prefix = `${toolName}:`;
		274	if (detail.toLowerCase().startsWith(prefix.toLowerCase())) {
		275	const unprefixed = detail.slice(prefix.length).trim();
		276	if (textRepeatsCommand(unprefixed, commands)) return true;
		277	}
		278	}
		279
		280	if (!textRepeatsCommand(detail, commands)) return false;
		281
		282	const data = asRecord(input.data);
		283	const item = asRecord(data?.item);
		284	const itemInput = asRecord(item?.input);
		285	const itemResult = asRecord(item?.result);
		286	const hasStructuredCommand = [
		287	item?.command,
		288	itemInput?.command,
		289	itemResult?.command,
		290	data?.command,
		291	].some((value) =>
		292	Array.isArray(value)
		293	? value.some((part) => nonEmptyString(part) !== null)
		294	: nonEmptyString(value) !== null,
		295	);
		296	return (
		297	!hasStructuredCommand \|\|
		298	item !== null \|\|
		299	data?.toolCallId !== undefined \|\|
		300	nonEmptyString(data?.kind)?.toLowerCase() === "execute"
		301	);
		302	}
		303
		304	export function workLogEntryIsToolLike(entry: WorkLogPresentationEntry): boolean {
		305	if (entry.tone === "tool" \|\| entry.tone === "thinking" \|\| entry.tone === "error") return true;
		306	if (entry.command !== undefined && entry.command.trim().length > 0) return true;
		307	if (entry.requestKind !== undefined) return true;
		308	return entry.itemType !== undefined && isToolLifecycleItemType(entry.itemType);
		309	}
		310
69	function toolDetailTextLooksLikeFailure(text: string): boolean {	311	function toolDetailTextLooksLikeFailure(text: string): boolean {
70	const normalized = text.toLowerCase();	312	const normalized = text.toLowerCase();
71	return (	313	return (
@@ -110,7 +352,8 @@ export function workLogEntryIsLocalCodeSearch(entry: WorkLogPresentationEntry): · 38 unmodified lines
110	}	352	}
111		353
112	export function toolGroupAction(entry: WorkLogPresentationEntry): ToolGroupAction {	354	export function toolGroupAction(entry: WorkLogPresentationEntry): ToolGroupAction {
113	if (entry.requestKind === "file-read") return "read";	355	if (resolveWorkEntryToolPresentation(entry)?.icon === "browser") return "browser";
		356	if (entry.requestKind === "file-read" \|\| entry.viewedImagePath !== undefined) return "read";
114	if (	357	if (
115	entry.itemType === "dynamic_tool" &&	358	entry.itemType === "dynamic_tool" &&
116	/^read(?:\s+file)?$/i.test(normalizeCompactToolLabel(entry.toolTitle ?? entry.label))	359	/^read(?:\s+file)?$/i.test(normalizeCompactToolLabel(entry.toolTitle ?? entry.label))
@@ -125,6 +368,14 @@ export function toolGroupAction(entry: WorkLogPresentationEntry): ToolGroupActio · 8 unmodified lines
125	}	368	}
126		369
127	export function workEntryViewedImagePath(entry: WorkLogPresentationEntry): string \| null {	370	export function workEntryViewedImagePath(entry: WorkLogPresentationEntry): string \| null {
		371	const viewedImagePath = entry.viewedImagePath?.trim();
		372	if (
		373	viewedImagePath !== undefined &&
		374	!/[\r\n]/.test(viewedImagePath) &&
		375	isWorkspaceImagePreviewPath(viewedImagePath)
		376	) {
		377	return viewedImagePath;
		378	}
128	const detail = entry.detail?.trim();	379	const detail = entry.detail?.trim();
129	return toolGroupAction(entry) === "read" &&	380	return toolGroupAction(entry) === "read" &&
130	detail !== undefined &&	381	detail !== undefined &&
@@ -196,6 +447,8 @@ function toolGroupActionLabel(action: ToolGroupAction, count: number): string { · 65 unmodified lines
196	return `Changed ${count} ${count === 1 ? "file" : "files"}`;	447	return `Changed ${count} ${count === 1 ? "file" : "files"}`;
197	case "command":	448	case "command":
198	return `Ran ${count} ${count === 1 ? "command" : "commands"}`;	449	return `Ran ${count} ${count === 1 ? "command" : "commands"}`;
		450	case "browser":
		451	return `Used browser ${count} ${count === 1 ? "time" : "times"}`;
199	case "search":	452	case "search":
200	return `Searched the web ${count} ${count === 1 ? "time" : "times"}`;	453	return `Searched the web ${count} ${count === 1 ? "time" : "times"}`;
201	case "code-search":	454	case "code-search":

packages/effect-acp/src/protocol.ts+19−1

@@ -779,7 +779,25 @@ export const makeAcpPatchedProtocol = Effect.fn("makeAcpPatchedProtocol")(functi · 778 unmodified lines
779	}	779	}
780	const encoded = `${exit.value}\n`;	780	const encoded = `${exit.value}\n`;
781	yield* logProtocol({ direction: "outgoing", stage: "raw", payload: encoded });	781	yield* logProtocol({ direction: "outgoing", stage: "raw", payload: encoded });
782	yield* Queue.offer(outgoing, encoded);	782	// FIFO queue admission preserves wire ordering against later requests
		783	// (a session/prompt sent after session/cancel cannot overtake it).
		784	yield* Queue.offer(outgoing, { payload: encoded }).pipe(
		785	Effect.mapError(
		786	(cause) =>
		787	new AcpError.AcpTransportError({
		788	detail: "Failed to queue an outgoing ACP notification",
		789	cause,
		790	}),
		791	),
		792	Effect.filterOrFail(
		793	(accepted) => accepted,
		794	() =>
		795	new AcpError.AcpTransportError({
		796	detail: "The ACP output queue was closed before accepting a notification",
		797	cause: "Output queue closed",
		798	}),
		799	),
		800	);
783	});	801	});
784		802
785	const sendRequest = Effect.fn("sendRequest")(function* (method: string, payload: unknown) {	803	const sendRequest = Effect.fn("sendRequest")(function* (method: string, payload: unknown) {

@@ -13,7 +13,7 @@ import { · 12 unmodified lines
13	AcpRegistryAdapterV2Driver,	13	AcpRegistryAdapterV2Driver,
14	type AcpRegistryAdapterV2DriverEnv,	14	type AcpRegistryAdapterV2DriverEnv,
15	} from "../../orchestration-v2/Adapters/AcpRegistryAdapterV2.ts";	15	} from "../../orchestration-v2/Adapters/AcpRegistryAdapterV2.ts";
16	import type { TextGenerationShape } from "../../textGeneration/TextGeneration.ts";	16	import type { TextGeneration } from "../../textGeneration/TextGeneration.ts";
17	import { ProviderDriverError } from "../Errors.ts";	17	import { ProviderDriverError } from "../Errors.ts";
18	import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";	18	import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";
19	import {	19	import {
@@ -25,7 +25,7 @@ import { · 5 unmodified lines
25	const DRIVER_KIND = ProviderDriverKind.make("acpRegistry");	25	const DRIVER_KIND = ProviderDriverKind.make("acpRegistry");
26	const decodeSettings = Schema.decodeSync(AcpRegistrySettings);	26	const decodeSettings = Schema.decodeSync(AcpRegistrySettings);
27		27
28	const makeUnsupportedTextGeneration = (): TextGenerationShape => {	28	const makeUnsupportedTextGeneration = (): TextGeneration["Service"] => {
29	const unsupported = (operation: string) =>	29	const unsupported = (operation: string) =>
30	Effect.fail(	30	Effect.fail(
31	new TextGenerationError({	31	new TextGenerationError({