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

@@ -340,10 +340,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({
@@ -358,9 +359,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}:${threadPullRequestKeyOf(entry)}`,
-        type: "pull-request",
+        type: "pull-request" as const,
         pullRequest: {
           number: entry.number,
           title: entry.title,
@@ -377,6 +390,7 @@ export function useComposerCommandMenu({
             : `${entry.repository} · `
         }${entry.title}`,
       }));
+      return [...pullRequestItems, ...threadItems];
     }
 
     if (trigger.kind === "slash-command") {
@@ -565,7 +579,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 DocumentText from "../provider/DocumentText.ts";
 import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import * as ServerSettings from "../serverSettings.ts";

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

@@ -3229,87 +3229,135 @@ describe("CodexAdapterV2 post-settle continuation", () => {
     ),
   );
 
-  it.effect("compacts Codex with the native RPC and completes the compaction turn", () =>
-    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.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([