feat(web): redesign composer and conversation timeline

apps/mobile/src/features/threads/ComposerCommandPopover.tsx

@@ -143,7 +143,7 @@ function groupLabel(
 ): string | null {
   switch (triggerKind) {
     case "pull-request":
-      return "Pull requests";
+      return "Pull requests and threads";
     case "slash-command":
       return "Commands";
     case "skill":
@@ -161,7 +161,7 @@ function emptyText(triggerKind: ComposerTriggerKind | null, isLoading: boolean):
   }
   switch (triggerKind) {
     case "pull-request":
-      return "No matching pull requests.";
+      return "No matching pull requests or threads.";
     case "path":
       return "No matching mentions.";
     case "skill":

apps/mobile/src/features/threads/PendingApprovalCard.tsx

@@ -43,7 +43,26 @@ export function PendingApprovalCard(props: PendingApprovalCardProps) {
       <Text className="font-t3-medium text-sm text-foreground-secondary">
         {props.approval.appName ?? props.approval.requestKind}
       </Text>
-      {props.approval.detail ? (
+      {props.approval.files && props.approval.files.length > 0 ? (
+        <View className="gap-1">
+          {props.approval.files.map((file) => (
+            <View key={`${file.operation ?? ""}:${file.path}`} className="flex-row gap-2">
+              <Text
+                className="flex-1 font-sans text-sm text-foreground-secondary"
+                numberOfLines={1}
+                ellipsizeMode="middle"
+              >
+                {file.path}
+              </Text>
+              {file.additions !== undefined || file.deletions !== undefined ? (
+                <Text className="font-mono text-xs text-foreground-secondary">
+                  +{file.additions ?? 0} −{file.deletions ?? 0}
+                </Text>
+              ) : null}
+            </View>
+          ))}
+        </View>
+      ) : props.approval.detail ? (
         <Text className="font-sans text-sm leading-normal text-foreground-secondary">
           {props.approval.detail}
         </Text>

apps/mobile/src/features/threads/use-composer-command-menu.ts

@@ -339,10 +339,11 @@ export function useComposerCommandMenu({
     cwd: trigger?.kind === "path" ? projectCwd : null,
     query: trigger?.kind === "path" ? trigger.query : null,
   });
+  const isThreadTrigger = trigger?.kind === "path" || trigger?.kind === "pull-request";
   // Mounts older settled threads matching the mention, which shells may leave out.
   useThreadSearch(
-    trigger?.kind === "path" && environmentId ? [environmentId] : [],
-    trigger?.kind === "path" ? trigger.query : "",
+    isThreadTrigger && environmentId ? [environmentId, ...linkedEnvironments.keys()] : [],
+    trigger?.query ?? "",
     { titlesOnly: true },
   );
   const pullRequestSearch = useComposerPullRequestSearch({
@@ -357,9 +358,21 @@ export function useComposerCommandMenu({
     if (!trigger) return [];
 
     if (trigger.kind === "pull-request") {
-      return pullRequestSearch.entries.map((entry) => ({
+      // `#` lists pull requests, then threads; a bare `#` offers the most recent threads.
+      const threadItems = environmentId
+        ? matchComposerThreadItems({
+            shells: threadShells,
+            environmentId,
+            linkedEnvironments,
+            excludeThreadId: currentThreadId,
+            query: trigger.query,
+            allowEmptyQuery: true,
+            now,
+          })
+        : [];
+      const pullRequestItems = pullRequestSearch.entries.map((entry) => ({
         id: `pr:${entry.projectId}:${entry.repository}:${entry.number}`,
-        type: "pull-request",
+        type: "pull-request" as const,
         pullRequest: {
           number: entry.number,
           title: entry.title,
@@ -376,6 +389,7 @@ export function useComposerCommandMenu({
             : `${entry.repository} · `
         }${entry.title}`,
       }));
+      return [...pullRequestItems, ...threadItems];
     }
 
     if (trigger.kind === "slash-command") {
@@ -564,7 +578,7 @@ export function useComposerCommandMenu({
       return;
     }
     if (item.type === "thread") {
-      if (!ownerKey || trigger.kind !== "path") return;
+      if (!ownerKey || (trigger.kind !== "path" && trigger.kind !== "pull-request")) return;
       const shell = threadShells.find(
         (candidate) =>
           candidate.environmentId === item.thread.environmentId &&

apps/server/src/guest/GuestShareService.ts

@@ -22,6 +22,11 @@ import {
 } from "@t3tools/contracts";
 import { chatMarkdownImageSources } from "@t3tools/shared/markdownPipeline";
 import { htmlRenderFromToolItem } from "@t3tools/shared/toolOutput";
+import {
+  projectTurnItemForDetail,
+  projectTurnItemForWire,
+  threadStreamEventItem,
+} from "@t3tools/shared/wireProjection";
 import * as Context from "effect/Context";
 import * as SecureRandom from "effect/crypto/SecureRandom";
 import * as DateTime from "effect/DateTime";
@@ -50,11 +55,6 @@ import { GUEST_FAILURE } from "../orchestration-v2/GuestShareDecider.ts";
 import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
 import { coalesceThreadLiveStream } from "../orchestration-v2/ThreadLiveEventCoalescer.ts";
 import { buildBoundedThreadStreamSnapshot } from "../orchestration-v2/ThreadStream.ts";
-import {
-  projectTurnItemForDetail,
-  projectTurnItemForWire,
-  threadStreamEventItem,
-} from "../orchestration-v2/WireProjection.ts";
 import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as AnalyticsService from "../telemetry/AnalyticsService.ts";

apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts

@@ -2830,89 +2830,140 @@ describe("CodexAdapterV2 post-settle continuation", () => {
     ),
   );
 
-  it.effect("compacts Codex with the native RPC and completes the compaction turn", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const nativeThreadId = "compact-thread";
-        const nativeTurnId = "compact-turn";
-        const item = { type: "contextCompaction", id: "compact-item" };
-        const transcript = makeCodexReplayTranscript({
-          scenario: "native-compaction",
-          entries: [
-            ...codexReplayPreamble({ nativeThreadId, nativeTurnId, prompt: "unused" }).slice(0, 5),
-            {
-              type: "expect_outbound",
-              label: "compact",
-              frame: {
-                id: 3,
-                method: "thread/compact/start",
-                params: { threadId: nativeThreadId },
+  it.effect.each(["reset", "billable-only", "missing", "other-turn-reset", "late-reset"] as const)(
+    "compacts Codex with %s token telemetry",
+    (usageKind) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const nativeThreadId = "compact-thread";
+          const nativeTurnId = "compact-turn";
+          const item = { type: "contextCompaction", id: "compact-item" };
+          const usageFrame = (tokens: number, inputTokens: number, turnId = nativeTurnId) => ({
+            type: "emit_inbound" as const,
+            label: "usage",
+            frame: {
+              method: "thread/tokenUsage/updated",
+              params: {
+                threadId: nativeThreadId,
+                turnId,
+                tokenUsage: {
+                  total: {
+                    totalTokens: 9437579,
+                    inputTokens: 9408294,
+                    cachedInputTokens: 8982400,
+                    outputTokens: 29285,
+                    reasoningOutputTokens: 8756,
+                  },
+                  last: {
+                    totalTokens: tokens,
+                    inputTokens,
+                    cachedInputTokens: 0,
+                    outputTokens: 0,
+                    reasoningOutputTokens: 0,
+                  },
+                  modelContextWindow: 258400,
+                },
               },
             },
-            { type: "emit_inbound", label: "compact", frame: { id: 3, result: {} } },
-            {
-              type: "emit_inbound",
-              label: "start",
-              frame: {
-                method: "turn/started",
-                params: {
-                  threadId: nativeThreadId,
-                  turn: makeCodexReplayTurn({ id: nativeTurnId, status: "inProgress" }),
+          });
+          const transcript = makeCodexReplayTranscript({
+            scenario: "native-compaction",
+            entries: [
+              ...codexReplayPreamble({ nativeThreadId, nativeTurnId, prompt: "unused" }).slice(
+                0,
+                5,
+              ),
+              {
+                type: "expect_outbound",
+                label: "compact",
+                frame: {
+                  id: 3,
+                  method: "thread/compact/start",
+                  params: { threadId: nativeThreadId },
                 },
               },
-            },
-            ...(["item/started", "item/completed"] as const).map((method) => ({
-              type: "emit_inbound" as const,
-              label: method,
-              frame: { method, params: { threadId: nativeThreadId, turnId: nativeTurnId, item } },
-            })),
-            {
-              type: "emit_inbound",
-              label: "complete",
-              frame: {
-                method: "turn/completed",
-                params: {
-                  threadId: nativeThreadId,
-                  turn: makeCodexReplayTurn({ id: nativeTurnId, status: "completed" }),
+              { type: "emit_inbound", label: "compact", frame: { id: 3, result: {} } },
+              {
+                type: "emit_inbound",
+                label: "start",
+                frame: {
+                  method: "turn/started",
+                  params: {
+                    threadId: nativeThreadId,
+                    turn: makeCodexReplayTurn({ id: nativeTurnId, status: "inProgress" }),
+                  },
                 },
               },
-            },
-          ],
-        });
-        const harness = yield* makeCodexReplayHarness(transcript);
-        assert.isDefined(harness.runtime.compactThread);
-        yield* harness.runtime.compactThread!(
-          makeCodexTestTurnInput({
-            threadId: harness.threadId,
-            providerThread: harness.providerThread,
-            now: yield* DateTime.now,
-            attemptId: RunAttemptId.make("compact-attempt"),
-            text: "/compact",
-          }),
-        );
-        yield* harness.firstTerminal;
-        const items = harness.events.flatMap((event) =>
-          event.type === "turn_item.updated" && event.turnItem.type === "compaction"
-            ? [event.turnItem]
-            : [],
-        );
-        assert.deepEqual(
-          items.map((entry) => entry.status),
-          ["running", "completed"],
-        );
-        assert.equal(items[0]?.id, items[1]?.id);
-        assert.equal(harness.terminalEvents()[0]?.status, "completed");
-      }).pipe(
-        Effect.provide(
-          Layer.mergeAll(
-            IdAllocator.layer,
-            McpProviderSessions.layer,
-            NodeServices.layer,
-            NodeCrypto.layer,
+              ...(usageKind === "missing" ? [] : [usageFrame(223313, 222435)]),
+              {
+                type: "emit_inbound",
+                label: "compaction-start",
+                frame: {
+                  method: "item/started",
+                  params: { threadId: nativeThreadId, turnId: nativeTurnId, item },
+                },
+              },
+              ...(usageKind === "missing" ? [] : [usageFrame(226619, 223200)]),
+              ...(usageKind === "reset" ? [usageFrame(21607, 0)] : []),
+              ...(usageKind === "other-turn-reset" ? [usageFrame(21607, 0, "other-turn")] : []),
+              {
+                type: "emit_inbound",
+                label: "compaction-complete",
+                frame: {
+                  method: "item/completed",
+                  params: { threadId: nativeThreadId, turnId: nativeTurnId, item },
+                },
+              },
+              ...(usageKind === "late-reset" ? [usageFrame(21607, 0)] : []),
+              {
+                type: "emit_inbound",
+                label: "complete",
+                frame: {
+                  method: "turn/completed",
+                  params: {
+                    threadId: nativeThreadId,
+                    turn: makeCodexReplayTurn({ id: nativeTurnId, status: "completed" }),
+                  },
+                },
+              },
+            ],
+          });
+          const harness = yield* makeCodexReplayHarness(transcript);
+          assert.isDefined(harness.runtime.compactThread);
+          yield* harness.runtime.compactThread!(
+            makeCodexTestTurnInput({
+              threadId: harness.threadId,
+              providerThread: harness.providerThread,
+              now: yield* DateTime.now,
+              attemptId: RunAttemptId.make("compact-attempt"),
+              text: "/compact",
+            }),
+          );
+          yield* harness.firstTerminal;
+          const items = harness.events.flatMap((event) =>
+            event.type === "turn_item.updated" && event.turnItem.type === "compaction"
+              ? [event.turnItem]
+              : [],
+          );
+          assert.deepEqual(
+            items.map((entry) => entry.status),
+            ["running", "completed"],
+          );
+          assert.equal(items[0]?.id, items[1]?.id);
+          assert.equal(items[1]?.beforeTokenCount, usageKind === "missing" ? undefined : 223313);
+          assert.equal(items[1]?.afterTokenCount, usageKind === "reset" ? 21607 : undefined);
+          assert.equal(harness.terminalEvents()[0]?.status, "completed");
+        }).pipe(
+          Effect.provide(
+            Layer.mergeAll(
+              IdAllocator.layer,
+              McpProviderSessions.layer,
+              NodeServices.layer,
+              NodeCrypto.layer,
+            ),
           ),
         ),
       ),
-    ),
   );
 
   it.effect.each(["failed", "interrupted", "Stop"] as const)(