diff --git a/apps/mobile/src/components/BrandMark.tsx b/apps/mobile/src/components/BrandMark.tsx
index c8f1d438551..1643f3f6fde 100644
--- a/apps/mobile/src/components/BrandMark.tsx
+++ b/apps/mobile/src/components/BrandMark.tsx
@@ -3,14 +3,9 @@ import { Image } from "expo-image";
import { View } from "react-native";
import { AppText as Text } from "./AppText";
+import { T3_CODE_BRAND_MARK_SOURCE } from "./brandAssets";
const appVariant = Constants.expoConfig?.extra?.appVariant;
-const BRAND_MARK_SOURCE =
- appVariant === "development"
- ? require("../../../../assets/dev/blueprint-ios-1024.png")
- : appVariant === "preview"
- ? require("../../../../assets/nightly/nightly-ios-1024.png")
- : require("../../../../assets/prod/black-ios-1024.png");
const DEFAULT_STAGE_LABEL =
appVariant === "development" ? "Dev" : appVariant === "preview" ? "Preview" : "Alpha";
@@ -22,7 +17,7 @@ export function BrandMark(props: { readonly compact?: boolean; readonly stageLab
return (
();
+ const schemaVersions = new Map();
const removed: Array = [];
const database = MobileDatabase.of({
loadCache: (environmentId, kind, cacheKey) =>
Effect.succeed(Option.fromUndefinedOr(values.get(cacheId(environmentId, kind, cacheKey)))),
- saveCache: (environmentId, kind, cacheKey, _schemaVersion, payload) =>
+ saveCache: (environmentId, kind, cacheKey, schemaVersion, payload) =>
Effect.sync(() => {
- values.set(cacheId(environmentId, kind, cacheKey), payload);
+ const id = cacheId(environmentId, kind, cacheKey);
+ values.set(id, payload);
+ schemaVersions.set(id, schemaVersion);
}),
removeCache: (environmentId, kind, cacheKey) =>
Effect.sync(() => {
@@ -59,10 +186,37 @@ function makeDatabase() {
loadPreferencesJson: Effect.succeed(Option.none()),
savePreferencesJson: () => Effect.void,
});
- return { database, removed, values };
+ return { database, removed, schemaVersions, values };
}
describe("mobile SQLite environment cache store", () => {
+ it.effect("round-trips V2 shell and thread DateTime fields with the shared cache schema", () =>
+ Effect.gen(function* () {
+ const memory = makeDatabase();
+ const store = yield* make().pipe(Effect.provideService(MobileDatabase, memory.database));
+
+ yield* store.saveShell(ENVIRONMENT_ID, SHELL_SNAPSHOT);
+ yield* store.saveThread(ENVIRONMENT_ID, THREAD_SNAPSHOT);
+
+ const shell = Option.getOrThrow(yield* store.loadShell(ENVIRONMENT_ID));
+ const thread = Option.getOrThrow(yield* store.loadThread(ENVIRONMENT_ID, THREAD_ID));
+
+ expect(DateTime.formatIso(shell.threads[0]!.updatedAt)).toBe("2026-07-29T12:00:00.000Z");
+ expect(DateTime.formatIso(shell.threads[0]!.latestUserMessageAt!)).toBe(
+ "2026-07-29T12:00:00.000Z",
+ );
+ expect(DateTime.formatIso(thread.projection.thread.updatedAt)).toBe(
+ "2026-07-29T12:00:00.000Z",
+ );
+ expect(memory.schemaVersions.get(cacheId(ENVIRONMENT_ID, "shell", "snapshot"))).toBe(
+ ORCHESTRATION_CACHE_SCHEMA_VERSION,
+ );
+ expect(memory.schemaVersions.get(cacheId(ENVIRONMENT_ID, "thread", THREAD_ID))).toBe(
+ ORCHESTRATION_CACHE_SCHEMA_VERSION,
+ );
+ }),
+ );
+
it.effect("round-trips schema-validated VCS refs", () =>
Effect.gen(function* () {
const memory = makeDatabase();
diff --git a/apps/mobile/src/connection/environment-cache-store.ts b/apps/mobile/src/connection/environment-cache-store.ts
index ad5ef13b62d..1942cb7cc35 100644
--- a/apps/mobile/src/connection/environment-cache-store.ts
+++ b/apps/mobile/src/connection/environment-cache-store.ts
@@ -1,14 +1,11 @@
import {
ConnectionPersistenceError,
EnvironmentCacheStore,
+ ORCHESTRATION_CACHE_SCHEMA_VERSION,
+ StoredOrchestrationShellSnapshot,
+ StoredOrchestrationThreadSnapshot,
} from "@t3tools/client-runtime/platform";
-import {
- type EnvironmentId,
- OrchestrationShellSnapshot,
- OrchestrationThreadDetailSnapshot,
- ServerConfig,
- VcsListRefsResult,
-} from "@t3tools/contracts";
+import { type EnvironmentId, ServerConfig, VcsListRefsResult } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
@@ -16,25 +13,9 @@ import * as Schema from "effect/Schema";
import * as MobileDatabase from "../persistence/mobile-database";
-const SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION = 1;
-// v3 adds windowed (paginated) snapshots carrying `page` metadata; the bump
-// makes pre-pagination clients discard the record instead of decoding a
-// partial thread as complete (rollback safety).
-const THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION = 3;
const SERVER_CONFIG_CACHE_SCHEMA_VERSION = 1;
const VCS_REFS_CACHE_SCHEMA_VERSION = 1;
-const StoredShellSnapshot = Schema.Struct({
- schemaVersion: Schema.Literal(SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION),
- environmentId: Schema.String,
- snapshot: OrchestrationShellSnapshot,
-});
-const StoredThreadSnapshot = Schema.Struct({
- schemaVersion: Schema.Literal(THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION),
- environmentId: Schema.String,
- threadId: Schema.String,
- snapshot: OrchestrationThreadDetailSnapshot,
-});
const StoredServerConfig = Schema.Struct({
schemaVersion: Schema.Literal(SERVER_CONFIG_CACHE_SCHEMA_VERSION),
environmentId: Schema.String,
@@ -48,13 +29,17 @@ const StoredVcsRefs = Schema.Struct({
});
const decodeStoredShellSnapshot = Schema.decodeUnknownEffect(
- Schema.fromJsonString(StoredShellSnapshot),
+ Schema.fromJsonString(StoredOrchestrationShellSnapshot),
+);
+const encodeStoredShellSnapshot = Schema.encodeEffect(
+ Schema.fromJsonString(StoredOrchestrationShellSnapshot),
);
-const encodeStoredShellSnapshot = Schema.encodeEffect(Schema.fromJsonString(StoredShellSnapshot));
const decodeStoredThreadSnapshot = Schema.decodeUnknownEffect(
- Schema.fromJsonString(StoredThreadSnapshot),
+ Schema.fromJsonString(StoredOrchestrationThreadSnapshot),
+);
+const encodeStoredThreadSnapshot = Schema.encodeEffect(
+ Schema.fromJsonString(StoredOrchestrationThreadSnapshot),
);
-const encodeStoredThreadSnapshot = Schema.encodeEffect(Schema.fromJsonString(StoredThreadSnapshot));
const decodeStoredServerConfig = Schema.decodeUnknownEffect(
Schema.fromJsonString(StoredServerConfig),
);
@@ -130,12 +115,12 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
),
saveShell: Effect.fn("MobileEnvironmentCache.saveShell")(function* (environmentId, snapshot) {
const payload = yield* encodeStoredShellSnapshot({
- schemaVersion: SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION,
+ schemaVersion: ORCHESTRATION_CACHE_SCHEMA_VERSION,
environmentId,
snapshot,
}).pipe(Effect.mapError((cause) => persistenceError("save-shell", cause)));
yield* database
- .saveCache(environmentId, "shell", "snapshot", SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION, payload)
+ .saveCache(environmentId, "shell", "snapshot", ORCHESTRATION_CACHE_SCHEMA_VERSION, payload)
.pipe(Effect.mapError(mapDatabaseError("save-shell")));
}),
loadThread: Effect.fn("MobileEnvironmentCache.loadThread")((environmentId, threadId) =>
@@ -153,15 +138,15 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
}),
),
saveThread: Effect.fn("MobileEnvironmentCache.saveThread")(function* (environmentId, snapshot) {
- const threadId = snapshot.thread.id;
+ const threadId = snapshot.projection.thread.id;
const payload = yield* encodeStoredThreadSnapshot({
- schemaVersion: THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION,
+ schemaVersion: ORCHESTRATION_CACHE_SCHEMA_VERSION,
environmentId,
threadId,
snapshot,
}).pipe(Effect.mapError((cause) => persistenceError("save-thread", cause)));
yield* database
- .saveCache(environmentId, "thread", threadId, THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION, payload)
+ .saveCache(environmentId, "thread", threadId, ORCHESTRATION_CACHE_SCHEMA_VERSION, payload)
.pipe(Effect.mapError(mapDatabaseError("save-thread")));
}),
removeThread: Effect.fn("MobileEnvironmentCache.removeThread")((environmentId, threadId) =>
diff --git a/apps/mobile/src/connection/storage.ts b/apps/mobile/src/connection/storage.ts
index e844181673d..b043a3b414b 100644
--- a/apps/mobile/src/connection/storage.ts
+++ b/apps/mobile/src/connection/storage.ts
@@ -17,6 +17,7 @@ import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
+
import * as CatalogStore from "./catalog-store";
function targetPersistenceError(
diff --git a/apps/mobile/src/features/archive/archivedThreadList.test.ts b/apps/mobile/src/features/archive/archivedThreadList.test.ts
index 697d13e7c47..77e45963b83 100644
--- a/apps/mobile/src/features/archive/archivedThreadList.test.ts
+++ b/apps/mobile/src/features/archive/archivedThreadList.test.ts
@@ -1,9 +1,11 @@
import type { ArchivedSnapshotEntry } from "@t3tools/client-runtime/state/threads";
-import type { OrchestrationProjectShell, OrchestrationThreadShell } from "@t3tools/contracts";
-import { EnvironmentId, ProjectId, ProviderInstanceId, ThreadId } from "@t3tools/contracts";
+import type { OrchestrationProjectShell, OrchestrationV2ThreadShell } from "@t3tools/contracts";
+import { EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
+import * as DateTime from "effect/DateTime";
import { buildArchivedThreadGroups } from "./archivedThreadList";
+import { makeRawThreadShell } from "../../test-fixtures";
const environmentId = EnvironmentId.make("environment-1");
@@ -22,42 +24,30 @@ function makeProject(
}
function makeThread(
- input: Partial &
- Pick,
-): OrchestrationThreadShell {
- return {
- modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
- runtimeMode: "full-access",
- interactionMode: "default",
- branch: null,
- worktreePath: null,
- latestTurn: null,
- createdAt: "2026-06-01T00:00:00.000Z",
- updatedAt: "2026-06-01T00:00:00.000Z",
- archivedAt: "2026-06-02T00:00:00.000Z",
- session: null,
- latestUserMessageAt: null,
- hasPendingApprovals: false,
- hasPendingUserInput: false,
- hasActionableProposedPlan: false,
+ input: Pick & {
+ readonly branch?: string | null;
+ readonly archivedAt?: string | null;
+ },
+): OrchestrationV2ThreadShell {
+ const archivedAt = input.archivedAt === undefined ? "2026-06-02T00:00:00.000Z" : input.archivedAt;
+ return makeRawThreadShell({
...input,
- settledOverride: input.settledOverride ?? null,
- settledAt: input.settledAt ?? null,
- };
+ archivedAt: archivedAt === null ? null : DateTime.makeUnsafe(archivedAt),
+ });
}
function makeSnapshot(
projects: ReadonlyArray,
- threads: ReadonlyArray,
+ threads: ReadonlyArray,
targetEnvironmentId = environmentId,
): ArchivedSnapshotEntry {
return {
environmentId: targetEnvironmentId,
snapshot: {
+ schemaVersion: 1,
snapshotSequence: 1,
projects,
threads,
- updatedAt: "2026-06-04T00:00:00.000Z",
},
};
}
diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsx
index ba32dc6b609..f303c407e27 100644
--- a/apps/mobile/src/features/home/HomeScreen.tsx
+++ b/apps/mobile/src/features/home/HomeScreen.tsx
@@ -187,7 +187,7 @@ function deriveEmptyState(props: {
return {
title: "No threads yet",
- detail: "Create a task to start a new coding session in one of your connected projects.",
+ detail: "Create a task to start a new coding runtime in one of your connected projects.",
loading: false,
};
}
@@ -762,7 +762,7 @@ export function HomeScreen(props: HomeScreenProps) {
?.providers.find(
(provider) =>
provider.instanceId ===
- (thread.session?.providerInstanceId ?? thread.modelSelection.instanceId),
+ (thread.runtime?.providerInstanceId ?? thread.modelSelection.instanceId),
)?.driver ?? null
}
environmentLabel={
@@ -1062,7 +1062,7 @@ export function HomeScreen(props: HomeScreenProps) {
detail="Choose another environment or create a new task."
/>
) : (
- & Pick,
@@ -30,25 +31,21 @@ function makeThread(
input: Partial &
Pick,
): EnvironmentThreadShell {
- return {
+ return makeThreadShellFixture({
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
- latestTurn: null,
createdAt: "2026-06-01T00:00:00.000Z",
updatedAt: "2026-06-01T00:00:00.000Z",
archivedAt: null,
- session: null,
latestUserMessageAt: null,
hasPendingApprovals: false,
hasPendingUserInput: false,
hasActionableProposedPlan: false,
...input,
- settledOverride: input.settledOverride ?? null,
- settledAt: input.settledAt ?? null,
- };
+ });
}
const NOW = Date.parse("2026-06-29T00:00:00.000Z");
diff --git a/apps/mobile/src/features/home/threadArchive.test.ts b/apps/mobile/src/features/home/threadArchive.test.ts
new file mode 100644
index 00000000000..5f1320b7624
--- /dev/null
+++ b/apps/mobile/src/features/home/threadArchive.test.ts
@@ -0,0 +1,40 @@
+import { ProviderInstanceId, RunId } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import type { ThreadRuntimeSummary } from "@t3tools/client-runtime/state/models";
+import { threadCanArchive } from "./threadArchive";
+
+function runtime(
+ status: ThreadRuntimeSummary["status"],
+ activeRunId: ThreadRuntimeSummary["activeRunId"],
+): ThreadRuntimeSummary {
+ return {
+ status,
+ activeRunId,
+ providerInstanceId: ProviderInstanceId.make("codex"),
+ providerName: "codex",
+ lastError: null,
+ updatedAt: "2026-07-28T10:00:00.000Z",
+ };
+}
+
+describe("threadCanArchive", () => {
+ it("blocks provider-active work", () => {
+ const activeRunId = RunId.make("run-live");
+ expect(threadCanArchive(runtime("preparing", activeRunId))).toBe(false);
+ expect(threadCanArchive(runtime("starting", activeRunId))).toBe(false);
+ expect(threadCanArchive(runtime("running", activeRunId))).toBe(false);
+ });
+
+ it("only allows queued work when no provider run remains active", () => {
+ const activeRunId = RunId.make("run-live");
+ expect(threadCanArchive(runtime("queued", null))).toBe(true);
+ expect(threadCanArchive(runtime("queued", activeRunId))).toBe(false);
+ });
+
+ it("allows post-provider waiting work despite a retained active run id", () => {
+ const staleActiveRunId = RunId.make("run-finished");
+ expect(threadCanArchive(runtime("waiting", null))).toBe(true);
+ expect(threadCanArchive(runtime("waiting", staleActiveRunId))).toBe(true);
+ });
+});
diff --git a/apps/mobile/src/features/home/threadArchive.ts b/apps/mobile/src/features/home/threadArchive.ts
new file mode 100644
index 00000000000..8eaf9fa541d
--- /dev/null
+++ b/apps/mobile/src/features/home/threadArchive.ts
@@ -0,0 +1,16 @@
+import type { ThreadRuntimeSummary } from "@t3tools/client-runtime/state/models";
+
+/**
+ * Archiving may discard queued work, but it must not detach a provider while
+ * that provider is still executing a turn.
+ */
+export function threadCanArchive(runtime: ThreadRuntimeSummary | null | undefined): boolean {
+ if (runtime?.status === "queued") {
+ return runtime.activeRunId === null;
+ }
+ return (
+ runtime?.status !== "preparing" &&
+ runtime?.status !== "starting" &&
+ runtime?.status !== "running"
+ );
+}
diff --git a/apps/mobile/src/features/home/useThreadListActions.ts b/apps/mobile/src/features/home/useThreadListActions.ts
index dcea2b6791b..21422d01943 100644
--- a/apps/mobile/src/features/home/useThreadListActions.ts
+++ b/apps/mobile/src/features/home/useThreadListActions.ts
@@ -12,6 +12,7 @@ import { appAtomRegistry } from "../../state/atom-registry";
import { environmentServerConfigsAtom } from "../../state/server";
import { threadEnvironment } from "../../state/threads";
import { useAtomCommand } from "../../state/use-atom-command";
+import { threadCanArchive } from "./threadArchive";
/** Version skew: never send settle/unsettle to a server that predates them
(capability defaults false on decode for older servers). */
@@ -107,13 +108,9 @@ function useThreadActionExecutor(
);
return false;
}
- // Archive keeps its original, narrower guard: never interrupt a
- // thread mid-turn.
- if (
- action === "archive" &&
- thread.session?.status === "running" &&
- thread.session.activeTurnId != null
- ) {
+ // The server cancels queued runs on archive. Only an actual provider
+ // turn still needs the user to interrupt it first.
+ if (action === "archive" && !threadCanArchive(thread.runtime)) {
Alert.alert(
actionFailureTitle(action),
"This thread is working. Interrupt it first, then try again.",
diff --git a/apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts b/apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts
index 300434eb736..28a8d6c7230 100644
--- a/apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts
+++ b/apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts
@@ -55,7 +55,10 @@ export function subscribeToHardwareKeyboardCommandRegistrations(listener: () =>
export function dispatchHardwareKeyboardCommand(command: HardwareKeyboardCommand): boolean {
const commandHandlers = handlers.get(command);
if (!commandHandlers) return false;
- for (const handler of [...commandHandlers].toReversed()) {
+ const handlersInRegistrationOrder = Array.from(commandHandlers);
+ for (let index = handlersInRegistrationOrder.length - 1; index >= 0; index -= 1) {
+ const handler = handlersInRegistrationOrder[index];
+ if (!handler) continue;
if (handler() !== false) return true;
}
return false;
diff --git a/apps/mobile/src/features/projects/AddProjectScreen.tsx b/apps/mobile/src/features/projects/AddProjectScreen.tsx
index 39e6bda3c44..fc941fd7e32 100644
--- a/apps/mobile/src/features/projects/AddProjectScreen.tsx
+++ b/apps/mobile/src/features/projects/AddProjectScreen.tsx
@@ -561,7 +561,6 @@ function useCreateProject(environment: EnvironmentOption | null) {
commandId: CommandId.make(uuidv4()),
projectId,
workspaceRoot,
- createdAt: new Date().toISOString(),
});
const result = await createProject({
environmentId: environment.environmentId,
diff --git a/apps/mobile/src/features/review/reviewModel.test.ts b/apps/mobile/src/features/review/reviewModel.test.ts
index 3390afd9ff2..770a6561360 100644
--- a/apps/mobile/src/features/review/reviewModel.test.ts
+++ b/apps/mobile/src/features/review/reviewModel.test.ts
@@ -1,11 +1,7 @@
import { describe, expect, it } from "vite-plus/test";
-import {
- MessageId,
- TurnId,
- type OrchestrationCheckpointSummary,
- type ReviewDiffPreviewSource,
-} from "@t3tools/contracts";
+import { MessageId, RunId, type ReviewDiffPreviewSource } from "@t3tools/contracts";
+import type { ThreadCheckpointSummary } from "@t3tools/client-runtime/state/thread-checkpoints";
import {
buildReviewListItems,
@@ -18,9 +14,9 @@ import {
} from "./reviewModel";
function makeCheckpoint(
- input: Partial &
- Pick,
-): OrchestrationCheckpointSummary {
+ input: Partial &
+ Pick,
+): ThreadCheckpointSummary {
return {
checkpointRef: `refs/t3/checkpoints/thread/${input.checkpointTurnCount}` as any,
status: "ready",
@@ -52,12 +48,12 @@ describe("buildReviewSectionItems", () => {
it("keeps one chip per checkpoint and appends git sources", () => {
const checkpoints = [
makeCheckpoint({
- turnId: TurnId.make("turn-1"),
+ runId: RunId.make("run-1"),
checkpointTurnCount: 1,
completedAt: "2026-04-01T00:00:00.000Z",
}),
makeCheckpoint({
- turnId: TurnId.make("turn-2"),
+ runId: RunId.make("run-2"),
checkpointTurnCount: 2,
completedAt: "2026-04-02T00:00:00.000Z",
}),
diff --git a/apps/mobile/src/features/review/reviewModel.ts b/apps/mobile/src/features/review/reviewModel.ts
index 9459d41872d..5e1ae6bac5a 100644
--- a/apps/mobile/src/features/review/reviewModel.ts
+++ b/apps/mobile/src/features/review/reviewModel.ts
@@ -1,6 +1,7 @@
import { parsePatchFiles } from "@pierre/diffs/utils/parsePatchFiles";
import type { ChangeTypes, FileDiffMetadata } from "@pierre/diffs/types";
-import type { OrchestrationCheckpointSummary, ReviewDiffPreviewSource } from "@t3tools/contracts";
+import type { ThreadCheckpointSummary } from "@t3tools/client-runtime/state/thread-checkpoints";
+import type { ReviewDiffPreviewSource } from "@t3tools/contracts";
import * as Arr from "effect/Array";
import { pipe } from "effect/Function";
import * as Order from "effect/Order";
@@ -128,11 +129,11 @@ export type ReviewParsedDiff =
readonly notice: string | null;
};
-function checkpointTitle(checkpoint: OrchestrationCheckpointSummary): string {
+function checkpointTitle(checkpoint: ThreadCheckpointSummary): string {
return `Turn ${checkpoint.checkpointTurnCount}`;
}
-function checkpointSubtitle(checkpoint: OrchestrationCheckpointSummary): string {
+function checkpointSubtitle(checkpoint: ThreadCheckpointSummary): string {
const fileCount = checkpoint.files.length;
if (checkpoint.status !== "ready") {
return `Diff ${checkpoint.status}`;
@@ -141,8 +142,8 @@ function checkpointSubtitle(checkpoint: OrchestrationCheckpointSummary): string
}
function compareCheckpointTurnCountDescending(
- left: OrchestrationCheckpointSummary,
- right: OrchestrationCheckpointSummary,
+ left: ThreadCheckpointSummary,
+ right: ThreadCheckpointSummary,
): -1 | 0 | 1 {
if (left.checkpointTurnCount === right.checkpointTurnCount) {
return 0;
@@ -151,7 +152,7 @@ function compareCheckpointTurnCountDescending(
return left.checkpointTurnCount > right.checkpointTurnCount ? -1 : 1;
}
-const readyCheckpointOrder = Order.make(
+const readyCheckpointOrder = Order.make(
compareCheckpointTurnCountDescending,
);
@@ -510,14 +511,14 @@ function mapRenderableFile(file: FileDiffMetadata): ReviewRenderableFile {
}
export function getReviewSectionIdForCheckpoint(
- checkpoint: Pick,
+ checkpoint: Pick,
): string {
return `turn:${checkpoint.checkpointTurnCount}`;
}
export function getReadyReviewCheckpoints(
- checkpoints: ReadonlyArray,
-): ReadonlyArray {
+ checkpoints: ReadonlyArray,
+): ReadonlyArray {
return pipe(
checkpoints,
Arr.filter((checkpoint) => checkpoint.status === "ready"),
@@ -526,7 +527,7 @@ export function getReadyReviewCheckpoints(
}
export function buildReviewSectionItems(input: {
- readonly checkpoints: ReadonlyArray;
+ readonly checkpoints: ReadonlyArray;
readonly gitSections: ReadonlyArray;
readonly turnDiffById: Readonly>;
readonly loadingTurnIds: Readonly>;
diff --git a/apps/mobile/src/features/review/useReviewSections.ts b/apps/mobile/src/features/review/useReviewSections.ts
index 87325490990..b8a00280197 100644
--- a/apps/mobile/src/features/review/useReviewSections.ts
+++ b/apps/mobile/src/features/review/useReviewSections.ts
@@ -1,11 +1,15 @@
import { useCallback, useEffect, useMemo } from "react";
-import type { EnvironmentId, OrchestrationCheckpointSummary, ThreadId } from "@t3tools/contracts";
+import {
+ deriveThreadCheckpointSummaries,
+ type ThreadCheckpointSummary,
+} from "@t3tools/client-runtime/state/thread-checkpoints";
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
import { useCheckpointDiff } from "../../state/queries";
import { useEnvironmentQuery } from "../../state/query";
import { reviewEnvironment } from "../../state/review";
-import { useSelectedThreadDetail } from "../../state/use-thread-detail";
+import { useSelectedThreadProjection } from "../../state/use-thread-detail";
import { useSelectedThreadWorktree } from "../../state/use-selected-thread-worktree";
import {
buildReviewSectionItems,
@@ -30,7 +34,7 @@ export function useReviewSections(input: {
}) {
const { environmentId, reviewCache, threadId } = input;
const enabled = input.enabled ?? true;
- const selectedThread = useSelectedThreadDetail();
+ const selectedThread = useSelectedThreadProjection();
const { selectedThreadCwd } = useSelectedThreadWorktree();
const diffPreview = useEnvironmentQuery(
enabled && environmentId !== undefined && selectedThreadCwd !== null
@@ -49,8 +53,11 @@ export function useReviewSections(input: {
}, [diffPreview.data, reviewCache.threadKey]);
const readyCheckpoints = useMemo(
- () => getReadyReviewCheckpoints(selectedThread?.checkpoints ?? []),
- [selectedThread?.checkpoints],
+ () =>
+ getReadyReviewCheckpoints(
+ selectedThread === null ? [] : deriveThreadCheckpointSummaries(selectedThread.projection),
+ ),
+ [selectedThread],
);
const checkpointBySectionId = useMemo(
() =>
@@ -59,7 +66,7 @@ export function useReviewSections(input: {
getReviewSectionIdForCheckpoint(checkpoint),
checkpoint,
]),
- ) as Record,
+ ) as Record,
[readyCheckpoints],
);
const reviewSections = useMemo(
diff --git a/apps/mobile/src/features/terminal/ThreadTerminalRouteScreen.tsx b/apps/mobile/src/features/terminal/ThreadTerminalRouteScreen.tsx
index cb281bf4aed..072aec2c04b 100644
--- a/apps/mobile/src/features/terminal/ThreadTerminalRouteScreen.tsx
+++ b/apps/mobile/src/features/terminal/ThreadTerminalRouteScreen.tsx
@@ -40,7 +40,7 @@ import {
useKnownTerminalSessions,
} from "../../state/use-terminal-session";
import { useThreadSelection } from "../../state/use-thread-selection";
-import { useSelectedThreadDetail } from "../../state/use-thread-detail";
+import { useSelectedThreadProjection } from "../../state/use-thread-detail";
import { EnvironmentConnectionNotice } from "../connection/EnvironmentConnectionNotice";
import { useAdaptiveWorkspaceLayout } from "../layout/AdaptiveWorkspaceLayout";
import { TerminalSurface } from "./NativeTerminalSurface";
@@ -172,7 +172,9 @@ export function ThreadTerminalRouteScreen(props: ThreadTerminalRouteScreenProps)
const params = props.route.params;
const { selectedThread, selectedThreadProject, selectedEnvironmentConnection } =
useThreadSelection();
- const selectedThreadDetail = useSelectedThreadDetail();
+ const selectedThreadDetail = useSelectedThreadProjection();
+ const selectedThreadDetailWorktreePath =
+ selectedThreadDetail?.projection.thread.worktreePath ?? null;
const routeEnvironmentIdRaw = firstRouteParam(params.environmentId);
const routeThreadIdRaw = firstRouteParam(params.threadId);
const routeEnvironmentId = routeEnvironmentIdRaw
@@ -283,13 +285,13 @@ export function ThreadTerminalRouteScreen(props: ThreadTerminalRouteScreenProps)
activeSessionLocation: activeKnownSession?.state.summary ?? null,
workspaceRoot: selectedThreadProject.workspaceRoot,
threadShellWorktreePath: selectedThread.worktreePath ?? null,
- threadDetailWorktreePath: selectedThreadDetail?.worktreePath ?? null,
+ threadDetailWorktreePath: selectedThreadDetailWorktreePath,
});
}, [
activeKnownSession?.state.summary,
pendingLaunch,
selectedThread,
- selectedThreadDetail?.worktreePath,
+ selectedThreadDetailWorktreePath,
selectedThreadProject?.workspaceRoot,
]);
const [initialLaunchLocationEntry, setInitialLaunchLocationEntry] = useState(() => ({
diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
index 6b121d85108..2e0c73ccfce 100644
--- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
@@ -12,6 +12,7 @@ import {
isAtomCommandInterrupted,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
+import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
import { ComposerEditor, type ComposerEditorHandle } from "../../components/ComposerEditor";
import {
@@ -44,7 +45,6 @@ import {
} from "../../state/use-composer-drafts";
import { useEnvironmentServerConfig, useProjects } from "../../state/entities";
import { buildModelMenuActions, resolveSelectableModelSelection } from "../../lib/modelOptions";
-import { deriveThreadTitleFromPrompt } from "../../lib/projectThreadStartTurn";
import { armAgentAwarenessLiveActivityForLocalWork } from "../agent-awareness/remoteRegistration";
import { enqueueThreadOutboxMessage, removeThreadOutboxMessage } from "../../state/thread-outbox";
import { useRemoteConnectionStatus } from "../../state/use-remote-environment-registry";
@@ -855,7 +855,10 @@ export function NewTaskDraftScreen(props: {
// -only Activity start. If creation fails, the token registration's replay
// finds no work and ends the card within seconds.
armAgentAwarenessLiveActivityForLocalWork({
- threadTitle: deriveThreadTitleFromPrompt(initialMessageText),
+ threadTitle: deriveThreadTitleSeed({
+ text: initialMessageText,
+ attachments: draft.attachments,
+ }),
projectTitle: selectedProject.title,
});
const result = await createProjectThread({
diff --git a/apps/mobile/src/features/threads/PendingApprovalCard.tsx b/apps/mobile/src/features/threads/PendingApprovalCard.tsx
index 377ae82aba8..dbb59a99f24 100644
--- a/apps/mobile/src/features/threads/PendingApprovalCard.tsx
+++ b/apps/mobile/src/features/threads/PendingApprovalCard.tsx
@@ -1,4 +1,4 @@
-import type { ApprovalRequestId, ProviderApprovalDecision } from "@t3tools/contracts";
+import type { ProviderApprovalDecision, RuntimeRequestId } from "@t3tools/contracts";
import { Pressable, View } from "react-native";
import { AppText as Text } from "../../components/AppText";
@@ -6,9 +6,9 @@ import type { PendingApproval } from "../../lib/threadActivity";
export interface PendingApprovalCardProps {
readonly approval: PendingApproval;
- readonly respondingApprovalId: ApprovalRequestId | null;
+ readonly respondingApprovalId: RuntimeRequestId | null;
readonly onRespond: (
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
decision: ProviderApprovalDecision,
) => Promise;
}
@@ -16,6 +16,8 @@ export interface PendingApprovalCardProps {
export function PendingApprovalCard(props: PendingApprovalCardProps) {
// Opaque for the same reason as PendingUserInputCard: nothing blurs the feed
// behind this card, so a translucent surface bleeds messages through it.
+ const canRespond = props.approval.responseCapability === "live";
+ const disabled = !canRespond || props.respondingApprovalId === props.approval.requestId;
return (
@@ -29,17 +31,23 @@ export function PendingApprovalCard(props: PendingApprovalCardProps) {
{props.approval.detail}
) : null}
+ {!canRespond ? (
+
+ The provider process for this request is no longer available. Interrupt or restart the run
+ to continue.
+
+ ) : null}
void props.onRespond(props.approval.requestId, "accept")}
>
Allow once
void props.onRespond(props.approval.requestId, "acceptForSession")}
>
@@ -48,7 +56,7 @@ export function PendingApprovalCard(props: PendingApprovalCardProps) {
void props.onRespond(props.approval.requestId, "decline")}
>
Decline
diff --git a/apps/mobile/src/features/threads/PendingUserInputCard.tsx b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
index c3c9b4e7ce8..ec0cfdb7c97 100644
--- a/apps/mobile/src/features/threads/PendingUserInputCard.tsx
+++ b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
@@ -1,4 +1,4 @@
-import type { ApprovalRequestId } from "@t3tools/contracts";
+import type { RuntimeRequestId } from "@t3tools/contracts";
import { Pressable, View } from "react-native";
import { AppText as Text, AppTextInput as TextInput } from "../../components/AppText";
@@ -9,14 +9,10 @@ export interface PendingUserInputCardProps {
readonly pendingUserInput: PendingUserInput;
readonly drafts: Record;
readonly answers: Record | null;
- readonly respondingUserInputId: ApprovalRequestId | null;
- readonly onSelectOption: (
- requestId: ApprovalRequestId,
- questionId: string,
- label: string,
- ) => void;
+ readonly respondingUserInputId: RuntimeRequestId | null;
+ readonly onSelectOption: (requestId: RuntimeRequestId, questionId: string, label: string) => void;
readonly onChangeCustomAnswer: (
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
questionId: string,
customAnswer: string,
) => void;
@@ -27,6 +23,7 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
// The surface is opaque on purpose: the card floats over the thread feed
// with no blur behind it, so a translucent background renders the questions
// on top of whatever message happens to sit underneath.
+ const canRespond = props.pendingUserInput.responseCapability === "live";
return (
@@ -35,6 +32,12 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
Fill in the pending answers
+ {!canRespond ? (
+
+ The provider process for this request is no longer available. Interrupt or restart the run
+ to continue.
+
+ ) : null}
{props.pendingUserInput.questions.map((question) => {
const draft = props.drafts[question.id];
return (
@@ -52,6 +55,7 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
return (
props.onChangeCustomAnswer(props.pendingUserInput.requestId, question.id, value)
@@ -97,7 +102,9 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
props.answers ? "bg-blue-500" : "bg-neutral-200 dark:bg-neutral-700/60",
)}
disabled={
- props.answers === null || props.respondingUserInputId === props.pendingUserInput.requestId
+ !canRespond ||
+ props.answers === null ||
+ props.respondingUserInputId === props.pendingUserInput.requestId
}
onPress={() => void props.onSubmit()}
>
diff --git a/apps/mobile/src/features/threads/ThreadActivityInspector.tsx b/apps/mobile/src/features/threads/ThreadActivityInspector.tsx
new file mode 100644
index 00000000000..97d38e9ee30
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadActivityInspector.tsx
@@ -0,0 +1,203 @@
+import * as Haptics from "expo-haptics";
+import { SymbolView } from "expo-symbols";
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { useNavigation } from "@react-navigation/native";
+import { useMemo, useState } from "react";
+import { Linking, Pressable, ScrollView, type ColorValue, View } from "react-native";
+
+import { AppText as Text } from "../../components/AppText";
+import type { ThreadFeedActivity } from "../../lib/threadActivity";
+import { buildThreadActivityInspector } from "../../lib/threadActivityInspector";
+import { resolveWorkspaceRelativeFilePath } from "../files/filePath";
+import { threadEnvironment } from "../../state/threads";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { useV2ItemSupport } from "../../state/v2-item-support";
+import { buildThreadActivityFileParams } from "./threadActivityFileNavigation";
+
+export function ThreadActivityInspector(props: {
+ readonly activity: ThreadFeedActivity;
+ readonly currentThreadId: ThreadId;
+ readonly environmentId: EnvironmentId;
+ readonly iconColor: ColorValue;
+ readonly workspaceRoot?: string | null;
+}) {
+ const navigation = useNavigation();
+ const row = props.activity.projectedItem;
+ const support = useV2ItemSupport({
+ environmentId: props.environmentId,
+ sourceThreadId: row.sourceThreadId,
+ sourceItemId: row.sourceItemId,
+ });
+ const model = useMemo(
+ () => buildThreadActivityInspector(props.activity, support, props.currentThreadId),
+ [props.activity, props.currentThreadId, support],
+ );
+ const revertCheckpoint = useAtomCommand(threadEnvironment.revertCheckpoint, {
+ label: "checkpoint rollback",
+ reportFailure: true,
+ });
+ const [rollingBack, setRollingBack] = useState(false);
+
+ return (
+
+
+ {model.fields.map((field) => (
+
+
+ {field.label}
+
+
+ {field.value}
+
+
+ ))}
+
+
+ {model.blocks.map((block) => (
+
+
+ {block.label}
+
+
+
+ {block.value}
+
+
+
+ ))}
+
+ {model.fileLinks.length > 0 ? (
+
+
+ Files
+
+ {model.fileLinks.map((link) => {
+ const relativePath =
+ resolveWorkspaceRelativeFilePath(props.workspaceRoot, link.path) ??
+ (link.path.startsWith("/") ? null : link.path);
+ return (
+ {
+ if (!relativePath) return;
+ void Haptics.selectionAsync();
+ navigation.navigate(
+ "ThreadFile",
+ buildThreadActivityFileParams({
+ environmentId: props.environmentId,
+ currentThreadId: props.currentThreadId,
+ activitySourceThreadId: row.sourceThreadId,
+ relativePath,
+ line: link.line,
+ }),
+ );
+ }}
+ className="min-h-9 flex-row items-center gap-2 rounded-md border border-neutral-300/50 px-2.5 py-1.5 dark:border-white/[0.1]"
+ >
+
+ {link.label}
+
+
+ );
+ })}
+
+ ) : null}
+
+ {model.webLinks.length > 0 ? (
+
+
+ Sources
+
+ {model.webLinks.map((link) => (
+ void Linking.openURL(link.url)}
+ className="min-h-9 flex-row items-center gap-2 rounded-md border border-neutral-300/50 px-2.5 py-1.5 dark:border-white/[0.1]"
+ >
+
+ {link.label}
+
+
+ ))}
+
+ ) : null}
+
+ {model.rollbackTarget ? (
+ {
+ setRollingBack(true);
+ void Haptics.selectionAsync();
+ void revertCheckpoint({
+ environmentId: props.environmentId,
+ input: {
+ threadId: model.rollbackTarget!.threadId,
+ checkpointId: model.rollbackTarget!.checkpointId,
+ scopeId: model.rollbackTarget!.scopeId,
+ },
+ }).finally(() => setRollingBack(false));
+ }}
+ className="min-h-10 flex-row items-center justify-center gap-2 rounded-lg border border-neutral-300/60 px-3 py-2 dark:border-white/[0.12]"
+ >
+
+ {rollingBack ? "Rolling back…" : "Roll back to checkpoint"}
+
+
+ ) : null}
+
+
+
+ Structured details
+
+
+
+ {model.structuredDetails}
+
+
+
+
+ );
+}
diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx
index 1b026964c92..e92b0613d3b 100644
--- a/apps/mobile/src/features/threads/ThreadComposer.tsx
+++ b/apps/mobile/src/features/threads/ThreadComposer.tsx
@@ -1,9 +1,9 @@
import { isLiquidGlassSupported, LiquidGlassView } from "@callstack/liquid-glass";
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
import type {
EnvironmentId,
MessageId,
ModelSelection,
- OrchestrationThreadShell,
ProviderInteractionMode,
RuntimeMode,
ServerConfig as T3ServerConfig,
@@ -98,10 +98,11 @@ export interface ThreadComposerProps {
* are on screen while they reconcile with the server.
*/
readonly threadSyncPhase?: "loading" | "syncing" | null;
- readonly selectedThread: OrchestrationThreadShell;
+ readonly selectedThread: EnvironmentThreadShell;
readonly serverConfig: T3ServerConfig | null;
readonly queueCount: number;
readonly activeThreadBusy: boolean;
+ readonly canStopThread: boolean;
readonly environmentId: EnvironmentId;
readonly projectCwd: string | null;
readonly editorRef?: RefObject;
@@ -306,9 +307,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
setIsFocused(false);
onExpandedChange?.(false);
}, [onExpandedChange]);
- const showStopAction =
- props.selectedThread.session?.status === "running" ||
- props.selectedThread.session?.status === "starting";
+ const showStopAction = props.canStopThread;
const sendLabel =
props.connectionState !== "connected" || props.activeThreadBusy || props.queueCount > 0
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index 3d83c837500..eb254734664 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -1,16 +1,16 @@
import { type EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
import type { EnvironmentThreadStatus } from "@t3tools/client-runtime/state/threads";
import { useKeyboardChatComposerInset, useKeyboardScrollToEnd } from "@legendapp/list/keyboard";
import type { LegendListRef } from "@legendapp/list/react-native";
import type {
- ApprovalRequestId,
EnvironmentId,
MessageId,
ModelSelection,
- OrchestrationThreadShell,
ProviderApprovalDecision,
ProviderInteractionMode,
RuntimeMode,
+ RuntimeRequestId,
ServerConfig as T3ServerConfig,
ThreadId,
} from "@t3tools/contracts";
@@ -26,11 +26,14 @@ import type { StatusTone } from "../../components/StatusPill";
import type { DraftComposerImageAttachment } from "../../lib/composerImages";
import { CHAT_CONTENT_MAX_WIDTH, type LayoutVariant } from "../../lib/layout";
import { scopedThreadKey } from "../../lib/scopedEntities";
+import { threadEnvironment } from "../../state/threads";
+import { useAtomCommand } from "../../state/use-atom-command";
import type {
PendingApproval,
PendingUserInput,
PendingUserInputDraftAnswer,
ThreadFeedEntry,
+ ThreadFeedLatestRun,
} from "../../lib/threadActivity";
import { PendingApprovalCard } from "./PendingApprovalCard";
import { PendingUserInputCard } from "./PendingUserInputCard";
@@ -40,30 +43,32 @@ import {
ThreadComposer,
} from "./ThreadComposer";
import { ThreadFeed } from "./ThreadFeed";
+import { ThreadRelationshipsBanner } from "./ThreadRelationshipsBanner";
+import { ThreadQueueControl } from "./ThreadQueueControl";
import type { ThreadContentPresentation } from "./threadContentPresentation";
export interface ThreadDetailScreenProps {
- readonly selectedThread: OrchestrationThreadShell;
+ readonly selectedThread: EnvironmentThreadShell;
readonly contentPresentation: ThreadContentPresentation;
readonly screenTone: StatusTone;
readonly connectionError: string | null;
readonly environmentLabel: string | null;
readonly selectedThreadFeed: ReadonlyArray;
+ readonly activityRun: ThreadFeedLatestRun | null;
readonly activeWorkStartedAt: string | null;
readonly activePendingApproval: PendingApproval | null;
- readonly respondingApprovalId: ApprovalRequestId | null;
+ readonly respondingApprovalId: RuntimeRequestId | null;
readonly activePendingUserInput: PendingUserInput | null;
readonly activePendingUserInputDrafts: Record;
readonly activePendingUserInputAnswers: Record | null;
- readonly respondingUserInputId: ApprovalRequestId | null;
+ readonly respondingUserInputId: RuntimeRequestId | null;
readonly draftMessage: string;
readonly draftAttachments: ReadonlyArray;
readonly connectionStateLabel: EnvironmentConnectionPhase;
/** Message sync status for the selected thread (drives the composer status pill). */
readonly threadSyncStatus?: EnvironmentThreadStatus;
- /** Non-null when older turns exist beyond the loaded window. */
- readonly loadEarlier?: { readonly loading: boolean; readonly onLoadEarlier: () => void } | null;
readonly activeThreadBusy: boolean;
+ readonly canStopThread: boolean;
readonly environmentId: EnvironmentId;
readonly projectWorkspaceRoot: string | null;
readonly threadCwd: string | null;
@@ -84,16 +89,16 @@ export interface ThreadDetailScreenProps {
readonly onUpdateThreadRuntimeMode: (runtimeMode: RuntimeMode) => void;
readonly onUpdateThreadInteractionMode: (interactionMode: ProviderInteractionMode) => void;
readonly onRespondToApproval: (
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
decision: ProviderApprovalDecision,
) => Promise;
readonly onSelectUserInputOption: (
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
questionId: string,
label: string,
) => void;
readonly onChangeUserInputCustomAnswer: (
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
questionId: string,
customAnswer: string,
) => void;
@@ -238,6 +243,39 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
selectedThreadKeyRef.current = selectedThreadKey;
}, [selectedThreadKey]);
+ const visitThread = useAtomCommand(threadEnvironment.visit, { reportFailure: false });
+ const lastDispatchedVisitRef = useRef(null);
+ const selectedThreadId = props.selectedThread.id;
+ const selectedThreadUpdatedAt = props.selectedThread.updatedAt;
+ const selectedThreadLastVisitedAt = props.selectedThread.lastVisitedAt;
+ useEffect(() => {
+ // Records the server-side visited watermark while the thread is on
+ // screen (mirror of web ChatView), so the "Done" marker clears on every
+ // device. Field absent → the server predates visited tracking.
+ if (selectedThreadLastVisitedAt === undefined) return;
+ const threadUpdatedAtMs = Date.parse(selectedThreadUpdatedAt);
+ if (Number.isNaN(threadUpdatedAtMs)) return;
+ const lastVisitedAtMs = selectedThreadLastVisitedAt
+ ? Date.parse(selectedThreadLastVisitedAt)
+ : NaN;
+ if (!Number.isNaN(lastVisitedAtMs) && lastVisitedAtMs >= threadUpdatedAtMs) return;
+ // Dedupe per watermark — the effect re-runs before the command echo lands.
+ const dispatchKey = `${selectedThreadKey}:${selectedThreadUpdatedAt}`;
+ if (lastDispatchedVisitRef.current === dispatchKey) return;
+ lastDispatchedVisitRef.current = dispatchKey;
+ void visitThread({
+ environmentId: props.environmentId,
+ input: { threadId: selectedThreadId, visitedAt: selectedThreadUpdatedAt },
+ });
+ }, [
+ props.environmentId,
+ selectedThreadId,
+ selectedThreadKey,
+ selectedThreadLastVisitedAt,
+ selectedThreadUpdatedAt,
+ visitThread,
+ ]);
+
useEffect(() => {
setAnchorMessageId(null);
lastScrolledAnchorMessageIdRef.current = null;
@@ -360,7 +398,8 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
feed={props.selectedThreadFeed}
contentPresentation={props.contentPresentation}
agentLabel={agentLabel}
- latestTurn={props.selectedThread.latestTurn}
+ threadTitle={props.selectedThread.title}
+ latestRun={props.activityRun}
activeWorkStartedAt={props.activeWorkStartedAt}
listRef={listRef}
freeze={freeze}
@@ -369,11 +408,16 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
contentTopInset={0}
contentBottomInset={estimatedOverlayHeight}
contentMaxWidth={contentMaxWidth}
+ topAccessory={
+
) : (
@@ -391,6 +435,11 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
pushes the resting content floor up by the same amount. */}
+ ;
readonly contentPresentation: ThreadContentPresentation;
readonly agentLabel: string;
- readonly latestTurn: ThreadFeedLatestTurn | null;
+ readonly latestRun: ThreadFeedLatestRun | null;
readonly activeWorkStartedAt: string | null;
readonly listRef: RefObject;
readonly freeze: SharedValue;
@@ -144,16 +177,96 @@ export interface ThreadFeedProps {
readonly contentInsetEndAdjustment: SharedValue;
readonly contentTopInset?: number;
readonly contentBottomInset?: number;
+ readonly topAccessory?: ReactNode;
readonly contentMaxWidth?: number;
readonly layoutVariant?: LayoutVariant;
readonly usesAutomaticContentInsets?: boolean;
readonly onHeaderMaterialVisibilityChange?: (visible: boolean) => void;
readonly skills?: ReadonlyArray;
- /** Non-null when older turns exist beyond the loaded window. */
- readonly loadEarlier?: {
- readonly loading: boolean;
- readonly onLoadEarlier: () => void;
- } | null;
+}
+
+async function waitForThreadShell(
+ environmentId: EnvironmentId,
+ threadId: ThreadId,
+): Promise {
+ const atom = environmentThreadShells.threadShellAtom(scopeThreadRef(environmentId, threadId));
+ return waitForThreadShellReady({
+ read: () => appAtomRegistry.get(atom) !== null,
+ });
+}
+
+function AssistantForkButton(props: {
+ readonly environmentId: EnvironmentId;
+ readonly iconColor: ColorValue;
+ readonly projectedItem: OrchestrationV2ProjectedTurnItem;
+ readonly sourceTitle: string;
+}) {
+ const support = useV2ItemSupport({
+ environmentId: props.environmentId,
+ sourceThreadId: props.projectedItem.sourceThreadId,
+ sourceItemId: props.projectedItem.sourceItemId,
+ });
+ const forkFromRun = useAtomCommand(threadEnvironment.forkFromRun, "fork from response");
+ const navigation = useNavigation();
+ const [busy, setBusy] = useState(false);
+ const canFork = canForkProjectedAssistantItem({
+ projectedItem: props.projectedItem,
+ capabilities: support.providerSession?.capabilities,
+ });
+ const runId = props.projectedItem.item.runId;
+
+ if (!canFork || runId === null) return null;
+
+ return (
+ {
+ const targetThreadId = ThreadId.make(uuidv4());
+ setBusy(true);
+ void Haptics.selectionAsync();
+ void forkFromRun({
+ environmentId: props.environmentId,
+ input: {
+ sourceThreadId: props.projectedItem.sourceThreadId,
+ targetThreadId,
+ runId,
+ title: `${props.sourceTitle} fork`,
+ creationSource: "mobile",
+ },
+ })
+ .then(async (result) => {
+ if (result._tag !== "Success") return;
+ const targetThreadReady = await waitForThreadShell(props.environmentId, targetThreadId);
+ if (!targetThreadReady) {
+ Alert.alert(
+ "Fork created",
+ "Its thread data did not reach this client. Reconnect and try opening it from the thread list.",
+ );
+ return;
+ }
+ navigation.navigate("Thread", {
+ environmentId: props.environmentId,
+ threadId: targetThreadId,
+ });
+ })
+ .finally(() => setBusy(false));
+ }}
+ className="h-7 w-7 items-center justify-center disabled:opacity-40"
+ >
+ {busy ? (
+
+ );
}
function MessageAttachmentImage(props: {
@@ -809,15 +922,16 @@ function useMarkdownStyles(onLinkPress: (href: string) => void): MarkdownStyleSe
function renderFeedEntry(
info: { item: ThreadFeedEntry; index: number },
- props: Pick & {
+ props: Pick & {
readonly copiedRowId: string | null;
+ readonly expandedWorkGroups: Record;
readonly expandedWorkRows: Record;
readonly terminalAssistantMessageIds: ReadonlySet;
- readonly unsettledTurnId: TurnId | null;
+ readonly unsettledTurnId: RunId | null;
readonly onCopyWorkRow: (rowId: string, value: string) => void;
readonly onToggleWorkGroup: (groupId: string) => void;
- readonly onToggleWorkRow: (rowId: string) => void;
- readonly onToggleTurnFold: (turnId: TurnId) => void;
+ readonly onToggleWorkRow: (rowId: string, anchorKey?: string) => void;
+ readonly onToggleTurnFold: (runId: RunId) => void;
readonly onPressImage: (uri: string, headers?: Record) => void;
readonly onMarkdownLinkPress: (href: string) => void;
readonly iconSubtleColor: string | import("react-native").ColorValue;
@@ -826,6 +940,7 @@ function renderFeedEntry(
readonly reviewCommentColors: ReviewCommentColors;
readonly reviewCommentBubbleWidth: number;
readonly userBubbleMaxWidth: number;
+ readonly threadTitle: string;
},
) {
const entry = info.item;
@@ -835,12 +950,12 @@ function renderFeedEntry(
return props.onToggleTurnFold(entry.turnId)}
+ onPress={() => props.onToggleTurnFold(entry.runId)}
hitSlop={4}
className="mb-3 min-h-11 flex-row items-center gap-2 border-b border-neutral-200/80 px-2 dark:border-white/[0.08]"
>
@@ -879,7 +994,7 @@ function renderFeedEntry(
const assistantTurnStillInProgress =
message.role === "assistant" &&
props.unsettledTurnId !== null &&
- message.turnId === props.unsettledTurnId;
+ message.runId === props.unsettledTurnId;
const showAssistantMeta =
message.role === "assistant" &&
props.terminalAssistantMessageIds.has(message.id) &&
@@ -888,11 +1003,17 @@ function renderFeedEntry(
if (isUser) {
const enterAnimated = isFreshTimestamp(message.createdAt);
+ const intentBadge = resolveUserMessageIntentBadge(message.inputIntent);
return (
+ {message.createdBy === "agent" ? (
+
+ Sent by another agent
+
+ ) : null}
+ {intentBadge ? (
+
+
+ {intentBadge.label}
+
+
+ ) : null}
{timestampLabel}
@@ -984,6 +1129,12 @@ function renderFeedEntry(
})}
{showAssistantMeta ? (
+ props.onToggleWorkGroup(entry.id)}
+ onToggleRow={(rowId) => props.onToggleWorkRow(rowId, entry.id)}
+ workspaceRoot={props.workspaceRoot}
/>
);
}
@@ -1310,9 +1466,9 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
const copyFeedbackTimeoutRef = useRef | null>(null);
const foldSettleFrameRef = useRef(null);
const foldSettleSecondFrameRef = useRef(null);
+ const previousLatestTurnRef = useRef(props.latestRun);
const disclosureAnchorKeyRef = useRef(null);
const headerMaterialVisibleRef = useRef(false);
- const previousLatestTurnRef = useRef(props.latestTurn);
const { width: windowWidth } = useWindowDimensions();
const { appearance } = useAppearancePreferences();
const [viewportWidth, setViewportWidth] = useState(() =>
@@ -1320,11 +1476,11 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
);
const [viewportHeight, setViewportHeight] = useState(0);
const [disclosureToggleSettling, setDisclosureToggleSettling] = useState(false);
- // Live-follow latch. LegendList's maintainScrollAtEnd alone re-pins the feed
- // whenever the viewport drifts back inside its geometric threshold, which
- // yanked users off history they were reading every time a stream chunk grew
- // a row. Follow breaks when the user scrolls up and away, and re-arms only
- // when the list actually returns to the end (or on send / thread switch).
+ // Live-follow latch (#5566). LegendList's maintainScrollAtEnd alone re-pins
+ // the feed whenever the viewport drifts back inside its geometric threshold,
+ // which yanked users off history they were reading every time a stream chunk
+ // grew a row. Follow breaks when the user scrolls up and away, and re-arms
+ // only when the list actually returns to the end (or on send / thread switch).
const [endFollowEnabled, setEndFollowEnabled] = useState(true);
const endFollowEnabledRef = useRef(true);
// A "user scroll session" spans from drag start through the end of its
@@ -1342,7 +1498,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
readonly copiedRowId: string | null;
readonly expandedWorkGroups: Record;
readonly expandedWorkRows: Record;
- readonly expandedTurnIds: ReadonlySet;
+ readonly expandedTurnIds: ReadonlySet;
}>({
copiedRowId: null,
expandedWorkGroups: {},
@@ -1415,6 +1571,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
const listAppearanceData = useMemo(
() => ({
copiedRowId,
+ expandedWorkGroups,
expandedWorkRows,
iconSubtleColor,
markdownStyles,
@@ -1424,6 +1581,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
}),
[
copiedRowId,
+ expandedWorkGroups,
expandedWorkRows,
iconSubtleColor,
markdownStyles,
@@ -1442,6 +1600,11 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
},
[props.onHeaderMaterialVisibilityChange],
);
+ // True while the viewport sits within ~one screen of the list end — the
+ // only region where layout shifts should animate. Starts true because the
+ // list opens pinned to the end.
+ const nearListEnd = useSharedValue(true);
+
const handleScroll = useCallback(
(event: NativeSyntheticEvent) => {
// anchorTopInset, not topContentInset: under automatic insets the list
@@ -1449,6 +1612,9 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
// UIKit's adjustedContentInset, so topContentInset is 0 here). Add the
// header height back or the material toggles a full header too late.
reportHeaderMaterialVisibility(event.nativeEvent.contentOffset.y + anchorTopInset > 6);
+ const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
+ nearListEnd.value =
+ contentSize.height - layoutMeasurement.height - contentOffset.y < layoutMeasurement.height;
// Latch bookkeeping. LegendList recomputes its inset-aware end distance
// before invoking this handler, so getState() is current. Returning to
// the end re-arms follow no matter who scrolled (the user, or our own
@@ -1464,7 +1630,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
}
}
},
- [reportHeaderMaterialVisibility, anchorTopInset, props.listRef, setEndFollow],
+ [reportHeaderMaterialVisibility, anchorTopInset, nearListEnd, props.listRef, setEndFollow],
);
const handleScrollBeginDrag = useCallback(() => {
userScrollSessionRef.current = true;
@@ -1483,18 +1649,6 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
const handleMomentumScrollEnd = useCallback(() => {
userScrollSessionRef.current = false;
}, []);
-
- const handleViewportLayout = useCallback((event: LayoutChangeEvent) => {
- const nextWidth = Math.round(event.nativeEvent.layout.width);
- const nextHeight = Math.round(event.nativeEvent.layout.height);
- setViewportWidth((current) => (Math.abs(current - nextWidth) > 1 ? nextWidth : current));
- setViewportHeight((current) => (Math.abs(current - nextHeight) > 1 ? nextHeight : current));
- }, []);
-
- useEffect(() => {
- reportHeaderMaterialVisibility(false);
- }, [props.threadId, reportHeaderMaterialVisibility]);
-
// 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.
@@ -1509,31 +1663,58 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
}
}, [props.anchorMessageId, setEndFollow]);
- const expandedWorkGroupIds = useMemo(() => {
- const ids = new Set();
- for (const [groupId, expanded] of Object.entries(expandedWorkGroups)) {
- if (expanded) {
- ids.add(groupId);
- }
- }
- return ids;
- }, [expandedWorkGroups]);
+ // Gated variant of the 180ms feed layout slide. Instant while browsing
+ // history: maintainVisibleContentPosition compensates the scroll offset in
+ // the same frame a row's measured size lands, so an instant reposition is
+ // invisible — animating it is exactly what made cold upward scrolls slide
+ // and jump. Near the end the slide stays on: streaming growth and sends
+ // shift rows at rest, where the animation is the thing preventing a hard
+ // visual snap.
+ const feedItemLayoutTransition = useMemo(() => {
+ return (values: LayoutAnimationsValues) => {
+ "worklet";
+ const duration = nearListEnd.value ? FEED_ITEM_LAYOUT_DURATION_MS : 0;
+ return {
+ initialValues: {
+ originX: values.currentOriginX,
+ originY: values.currentOriginY,
+ width: values.currentWidth,
+ height: values.currentHeight,
+ },
+ animations: {
+ originX: withTiming(values.targetOriginX, { duration }),
+ originY: withTiming(values.targetOriginY, { duration }),
+ width: withTiming(values.targetWidth, { duration }),
+ height: withTiming(values.targetHeight, { duration }),
+ },
+ };
+ };
+ }, [nearListEnd]);
+ const handleViewportLayout = useCallback((event: LayoutChangeEvent) => {
+ const nextWidth = Math.round(event.nativeEvent.layout.width);
+ const nextHeight = Math.round(event.nativeEvent.layout.height);
+ setViewportWidth((current) => (Math.abs(current - nextWidth) > 1 ? nextWidth : current));
+ setViewportHeight((current) => (Math.abs(current - nextHeight) > 1 ? nextHeight : current));
+ }, []);
+
+ useEffect(() => {
+ reportHeaderMaterialVisibility(false);
+ }, [props.threadId, reportHeaderMaterialVisibility]);
+
const presentedFeed = useMemo(
() =>
deriveThreadFeedPresentation(
props.feed,
- props.latestTurn,
+ props.latestRun,
expandedTurnIds,
- expandedWorkGroupIds,
+ new Set(
+ Object.entries(expandedWorkGroups)
+ .filter(([, expanded]) => expanded)
+ .map(([groupId]) => groupId),
+ ),
props.activeWorkStartedAt,
),
- [
- expandedTurnIds,
- expandedWorkGroupIds,
- props.activeWorkStartedAt,
- props.feed,
- props.latestTurn,
- ],
+ [expandedTurnIds, expandedWorkGroups, props.activeWorkStartedAt, props.feed, props.latestRun],
);
// The empty↔filled key below remounts the list, which resets its imperative
@@ -1562,29 +1743,25 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
[presentedFeed, props.anchorMessageId, anchorTopInset],
);
const terminalAssistantMessageIds = useMemo(() => {
- const terminalIdsByTurn = new Map();
+ const terminalIdsByTurn = new Map();
for (const entry of props.feed) {
- if (entry.type === "message" && entry.message.role === "assistant" && entry.message.turnId) {
- terminalIdsByTurn.set(entry.message.turnId, entry.message.id);
+ if (entry.type === "message" && entry.message.role === "assistant" && entry.message.runId) {
+ terminalIdsByTurn.set(entry.message.runId, entry.message.id);
}
}
return new Set(terminalIdsByTurn.values());
}, [props.feed]);
- const unsettledTurnId =
- props.latestTurn &&
- (props.latestTurn.completedAt === null || props.latestTurn.state === "running")
- ? props.latestTurn.turnId
- : null;
+ const unsettledTurnId = threadFeedRunIsUnsettled(props.latestRun) ? props.latestRun.runId : null;
useEffect(() => {
const previous = previousLatestTurnRef.current;
- previousLatestTurnRef.current = props.latestTurn;
- if (!props.latestTurn || !previous) {
+ previousLatestTurnRef.current = props.latestRun;
+ if (!props.latestRun || !previous) {
return;
}
- if (props.latestTurn.turnId === previous.turnId) {
- if (previous.state === "running" && props.latestTurn.state === "interrupted") {
- const interruptedTurnId = props.latestTurn.turnId;
+ if (props.latestRun.runId === previous.runId) {
+ if (previous.status === "running" && props.latestRun.status === "interrupted") {
+ const interruptedTurnId = props.latestRun.runId;
setInteractionState((current) => ({
...current,
expandedTurnIds: new Set(current.expandedTurnIds).add(interruptedTurnId),
@@ -1593,14 +1770,14 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
return;
}
setInteractionState((current) => {
- if (!current.expandedTurnIds.has(previous.turnId)) {
+ if (!current.expandedTurnIds.has(previous.runId)) {
return current;
}
const next = new Set(current.expandedTurnIds);
- next.delete(previous.turnId);
+ next.delete(previous.runId);
return { ...current, expandedTurnIds: next };
});
- }, [props.latestTurn]);
+ }, [props.latestRun]);
useEffect(() => {
return () => {
@@ -1681,8 +1858,8 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
);
const onToggleWorkRow = useCallback(
- (rowId: string) => {
- suspendEndScrollMaintenanceForDisclosure(rowId);
+ (rowId: string, anchorKey?: string) => {
+ suspendEndScrollMaintenanceForDisclosure(anchorKey ?? null);
setInteractionState((current) => ({
...current,
expandedWorkRows: {
@@ -1695,14 +1872,14 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
);
const onToggleTurnFold = useCallback(
- (turnId: TurnId) => {
- suspendEndScrollMaintenanceForDisclosure(`turn-fold:${turnId}`);
+ (runId: RunId) => {
+ suspendEndScrollMaintenanceForDisclosure(`run-fold:${runId}`);
setInteractionState((current) => {
const next = new Set(current.expandedTurnIds);
- if (next.has(turnId)) {
- next.delete(turnId);
+ if (next.has(runId)) {
+ next.delete(runId);
} else {
- next.add(turnId);
+ next.add(runId);
}
return { ...current, expandedTurnIds: next };
});
@@ -1727,7 +1904,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
const getFixedItemSize = useCallback(
(entry: ThreadFeedEntry) => {
switch (entry.type) {
- case "turn-fold":
+ case "run-fold":
return TURN_FOLD_HEIGHT;
case "work-toggle":
return WORK_GROUP_TOGGLE_HEIGHT;
@@ -1750,7 +1927,9 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
(info: { item: ThreadFeedEntry; index: number }) =>
renderFeedEntry(info, {
environmentId: props.environmentId,
+ threadId: props.threadId,
copiedRowId,
+ expandedWorkGroups,
expandedWorkRows,
terminalAssistantMessageIds,
unsettledTurnId,
@@ -1766,10 +1945,13 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
reviewCommentColors,
reviewCommentBubbleWidth,
userBubbleMaxWidth,
+ threadTitle: props.threadTitle,
skills: props.skills,
+ workspaceRoot: props.workspaceRoot,
}),
[
copiedRowId,
+ expandedWorkGroups,
expandedWorkRows,
terminalAssistantMessageIds,
unsettledTurnId,
@@ -1786,7 +1968,10 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
onToggleWorkGroup,
onToggleWorkRow,
props.environmentId,
+ props.threadId,
+ props.threadTitle,
props.skills,
+ props.workspaceRoot,
],
);
@@ -1835,6 +2020,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
}
: { scrollIndicatorInsets: { top: topContentInset, bottom: 0 } })}
{...(anchoredEndSpace ? { anchoredEndSpace } : {})}
+ itemLayoutAnimation={feedItemLayoutTransition}
// Patched LegendList prop (patches/@legendapp__list@3.2.0.patch):
// lets its scroll math clamp programmatic scrolls to -headerInset
// instead of 0, so initialScrollAtEnd/maintainScrollAtEnd on short
@@ -1915,17 +2101,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
ListHeaderComponent={
<>
{usesNativeAutomaticInsets ? null :
-
- {props.loadEarlier.loading ? "Loading earlier turns…" : "Load earlier turns"}
-
-
- ) : null}
+ {props.topAccessory}
}
contentContainerStyle={{
diff --git a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
index 322ac60759d..282566beb34 100644
--- a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
+++ b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
@@ -902,7 +902,7 @@ function ThreadNavigationSidebarPane(
?.providers.find(
(provider) =>
provider.instanceId ===
- (thread.session?.providerInstanceId ?? thread.modelSelection.instanceId),
+ (thread.runtime?.providerInstanceId ?? thread.modelSelection.instanceId),
)?.driver ?? null
}
environmentLabel={
diff --git a/apps/mobile/src/features/threads/ThreadQueueControl.tsx b/apps/mobile/src/features/threads/ThreadQueueControl.tsx
new file mode 100644
index 00000000000..4be3711867d
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadQueueControl.tsx
@@ -0,0 +1,149 @@
+import * as Haptics from "expo-haptics";
+import { SymbolView } from "expo-symbols";
+import { deriveThreadQueueWorkflowState } from "@t3tools/client-runtime/state/thread-workflows";
+import type { EnvironmentId, RunId, ThreadId } from "@t3tools/contracts";
+import { useMemo, useState } from "react";
+import { Pressable, ScrollView, View } from "react-native";
+
+import { AppText as Text } from "../../components/AppText";
+import { useThemeColor } from "../../lib/useThemeColor";
+import { threadEnvironment } from "../../state/threads";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { useThreadProjection } from "../../state/use-thread-detail";
+import {
+ buildCancelQueuedRunCommand,
+ resolveThreadQueueRowControls,
+} from "./threadQueueControlPresentation";
+
+export function ThreadQueueControl(props: {
+ readonly environmentId: EnvironmentId;
+ readonly threadId: ThreadId;
+}) {
+ const scoped = useThreadProjection(props);
+ const workflow = useMemo(
+ () => (scoped ? deriveThreadQueueWorkflowState(scoped.projection) : null),
+ [scoped],
+ );
+ const reorder = useAtomCommand(threadEnvironment.reorderQueuedRun, "reorder queued message");
+ const promote = useAtomCommand(threadEnvironment.promoteQueuedRun, "promote queued message");
+ const cancel = useAtomCommand(threadEnvironment.cancelQueuedRun, "cancel queued message");
+ const [busyRunId, setBusyRunId] = useState(null);
+ const iconColor = useThemeColor("--color-icon-subtle");
+
+ if (!workflow || workflow.queuedRuns.length === 0) return null;
+
+ const move = async (runId: RunId, beforeRunId: RunId | null) => {
+ setBusyRunId(runId);
+ void Haptics.selectionAsync();
+ await reorder({
+ environmentId: props.environmentId,
+ input: { threadId: props.threadId, runId, beforeRunId },
+ });
+ setBusyRunId(null);
+ };
+
+ const steer = async (queuedRunId: RunId) => {
+ if (!workflow.activeRun || !workflow.canPromoteToSteer) return;
+ setBusyRunId(queuedRunId);
+ void Haptics.selectionAsync();
+ await promote({
+ environmentId: props.environmentId,
+ input: {
+ threadId: props.threadId,
+ queuedRunId,
+ targetRunId: workflow.activeRun.id,
+ },
+ });
+ setBusyRunId(null);
+ };
+
+ const dismiss = async (runId: RunId) => {
+ setBusyRunId(runId);
+ void Haptics.selectionAsync();
+ await cancel(
+ buildCancelQueuedRunCommand({
+ environmentId: props.environmentId,
+ runId,
+ threadId: props.threadId,
+ }),
+ );
+ setBusyRunId(null);
+ };
+
+ return (
+
+
+ Queue
+
+ {workflow.queuedRuns.length}
+
+
+
+ {workflow.queuedRuns.map(({ run, text }, index) => {
+ const controls = resolveThreadQueueRowControls({
+ busy: busyRunId !== null,
+ canPromoteToSteer: workflow.canPromoteToSteer,
+ canReorder: workflow.canReorder,
+ index,
+ queuedCount: workflow.queuedRuns.length,
+ text,
+ });
+
+ return (
+
+
+ {index + 1}
+
+
+ {controls.displayText}
+
+ void move(run.id, workflow.queuedRuns[index - 1]?.run.id ?? null)}
+ className="h-9 w-9 items-center justify-center disabled:opacity-30"
+ >
+
+ void move(run.id, workflow.queuedRuns[index + 2]?.run.id ?? null)}
+ className="h-9 w-9 items-center justify-center disabled:opacity-30"
+ >
+
+ void steer(run.id)}
+ className="min-h-8 flex-row items-center gap-1 rounded-lg border border-neutral-300/60 px-2 disabled:opacity-30 dark:border-white/[0.1]"
+ >
+ Steer
+
+ void dismiss(run.id)}
+ className="h-9 w-9 items-center justify-center disabled:opacity-30"
+ >
+
+
+ );
+ })}
+
+
+ );
+}
diff --git a/apps/mobile/src/features/threads/ThreadRelationshipsBanner.tsx b/apps/mobile/src/features/threads/ThreadRelationshipsBanner.tsx
new file mode 100644
index 00000000000..569093d3c44
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadRelationshipsBanner.tsx
@@ -0,0 +1,303 @@
+import * as Haptics from "expo-haptics";
+import { SymbolView, type SFSymbol } from "expo-symbols";
+import {
+ deriveThreadRelationshipGraph,
+ immediateThreadRelationships,
+ resolveMergeBackTargetThreadId,
+ type ThreadRelationshipEdge,
+} from "@t3tools/client-runtime/state/thread-relationships";
+import {
+ canDetachThreadProviderSession,
+ resolveLatestMergeBackRun,
+} from "@t3tools/client-runtime/state/thread-workflows";
+import type { EnvironmentId, OrchestrationV2ThreadShell, ThreadId } from "@t3tools/contracts";
+import { copySorted } from "@t3tools/shared/Array";
+import { useNavigation } from "@react-navigation/native";
+import { useMemo, useState } from "react";
+import { ActivityIndicator, Modal, Pressable, ScrollView, View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { AppText as Text } from "../../components/AppText";
+import { useThemeColor } from "../../lib/useThemeColor";
+import { useThreadShells } from "../../state/entities";
+import { threadEnvironment } from "../../state/threads";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { useThreadProjection } from "../../state/use-thread-detail";
+import { useArchivedThreadSnapshots } from "../archive/useArchivedThreadSnapshots";
+
+function relationshipLabel(edge: ThreadRelationshipEdge, currentThreadId: ThreadId): string {
+ if (edge.kind === "transfer") {
+ return edge.sourceThreadId === currentThreadId ? "Context sent to" : "Context received from";
+ }
+ if (edge.kind === "subagent") {
+ return edge.sourceThreadId === currentThreadId ? "Subagent" : "Parent agent";
+ }
+ return edge.sourceThreadId === currentThreadId ? "Fork" : "Forked from";
+}
+
+function relationshipSymbol(edge: ThreadRelationshipEdge): SFSymbol {
+ if (edge.kind === "subagent") return "person.2";
+ if (edge.kind === "transfer") return "arrow.left.arrow.right";
+ return "arrow.triangle.branch";
+}
+
+function threadAvailability(
+ thread: OrchestrationV2ThreadShell | null,
+ missing: boolean,
+): string | null {
+ if (missing) return "Unavailable";
+ if (thread?.deletedAt !== null && thread?.deletedAt !== undefined) return "Deleted";
+ if (thread?.archivedAt !== null && thread?.archivedAt !== undefined) return "Archived";
+ return null;
+}
+
+const EMPTY_THREAD_SHELLS: ReadonlyArray = [];
+
+export function ThreadRelationshipsBanner(props: {
+ readonly environmentId: EnvironmentId;
+ readonly threadId: ThreadId;
+}) {
+ const scopedProjection = useThreadProjection(props);
+ const projection = scopedProjection?.projection ?? null;
+ const threadShells = useThreadShells();
+ const environmentIds = useMemo(() => [props.environmentId], [props.environmentId]);
+ const archived = useArchivedThreadSnapshots(environmentIds);
+ const archivedShells =
+ archived.snapshots.find((entry) => entry.environmentId === props.environmentId)?.snapshot
+ .threads ?? EMPTY_THREAD_SHELLS;
+ const shells = useMemo>(() => {
+ const environmentShells: OrchestrationV2ThreadShell[] = [];
+ for (const thread of threadShells) {
+ if (thread.environmentId === props.environmentId) {
+ environmentShells.push(thread.source);
+ }
+ }
+ environmentShells.push(...archivedShells);
+ return environmentShells;
+ }, [archivedShells, props.environmentId, threadShells]);
+ const graph = useMemo(
+ () => deriveThreadRelationshipGraph({ threads: shells, projection }),
+ [projection, shells],
+ );
+ const mergeTargetThreadId = resolveMergeBackTargetThreadId(projection);
+ const rows = useMemo(
+ () =>
+ copySorted(
+ immediateThreadRelationships(graph, props.threadId),
+ (left, right) =>
+ Number(right.threadId === mergeTargetThreadId) -
+ Number(left.threadId === mergeTargetThreadId),
+ ),
+ [graph, mergeTargetThreadId, props.threadId],
+ );
+ const latestMergeBackRun = projection === null ? null : resolveLatestMergeBackRun(projection);
+ const canMerge = mergeTargetThreadId !== null && latestMergeBackRun !== null;
+ const canDetach = projection ? canDetachThreadProviderSession(projection) : false;
+ const [visible, setVisible] = useState(false);
+ const [busyAction, setBusyAction] = useState<"merge" | "detach" | null>(null);
+ const navigation = useNavigation();
+ const mergeBack = useAtomCommand(threadEnvironment.mergeBack, "merge thread back");
+ const stopSession = useAtomCommand(threadEnvironment.stopSession, "thread session stop");
+ const insets = useSafeAreaInsets();
+ const backdropColor = useThemeColor("--color-backdrop");
+ const sheetColor = useThemeColor("--color-sheet");
+ const iconColor = useThemeColor("--color-icon-subtle");
+
+ if (rows.length === 0 && !canDetach) return null;
+
+ const primaryParent = rows.find(({ edge }) => edge.targetThreadId === props.threadId) ?? rows[0];
+ const primaryNode = primaryParent ? graph.nodes.get(primaryParent.threadId) : null;
+ const summary = primaryParent
+ ? `${relationshipLabel(primaryParent.edge, props.threadId)}: ${primaryNode?.thread?.title ?? "related thread"}`
+ : "Agent session connected";
+
+ const openThread = (threadId: ThreadId, archivedThread: boolean) => {
+ setVisible(false);
+ void Haptics.selectionAsync();
+ if (archivedThread) {
+ navigation.navigate("SettingsSheet", { screen: "SettingsArchive" });
+ return;
+ }
+ navigation.navigate("Thread", {
+ environmentId: props.environmentId,
+ threadId,
+ });
+ };
+
+ const merge = async () => {
+ if (!canMerge || mergeTargetThreadId === null || latestMergeBackRun === null) return;
+ setBusyAction("merge");
+ const result = await mergeBack({
+ environmentId: props.environmentId,
+ input: {
+ sourceThreadId: props.threadId,
+ targetThreadId: mergeTargetThreadId,
+ runId: latestMergeBackRun.id,
+ creationSource: "mobile",
+ },
+ });
+ setBusyAction(null);
+ if (result._tag === "Success") openThread(mergeTargetThreadId, false);
+ };
+
+ const detach = async () => {
+ if (!canDetach) return;
+ setBusyAction("detach");
+ await stopSession({
+ environmentId: props.environmentId,
+ input: { threadId: props.threadId },
+ });
+ setBusyAction(null);
+ };
+
+ return (
+ <>
+ {
+ void Haptics.selectionAsync();
+ setVisible(true);
+ }}
+ className="mb-4 min-h-11 flex-row items-center gap-2 rounded-xl border border-neutral-300/60 bg-card px-3 py-2.5 dark:border-white/[0.1]"
+ >
+
+ {summary}
+
+ {rows.length > 1 ? (
+ +{rows.length - 1}
+ ) : null}
+
+
+ setVisible(false)}
+ >
+
+ setVisible(false)} />
+
+
+
+ Thread lineage
+
+ {rows.length} related {rows.length === 1 ? "thread" : "threads"}
+
+
+ setVisible(false)}
+ className="h-10 w-10 items-center justify-center rounded-full bg-neutral-200/70 dark:bg-white/[0.07]"
+ >
+
+
+
+
+ {rows.map(({ threadId, edge }) => {
+ const node = graph.nodes.get(threadId);
+ const availability = threadAvailability(
+ node?.thread ?? null,
+ node?.missing ?? true,
+ );
+ const archivedThread = availability === "Archived";
+ const disabled = availability === "Unavailable" || availability === "Deleted";
+ return (
+ openThread(threadId, archivedThread)}
+ className="min-h-14 flex-row items-center gap-3 rounded-2xl border border-neutral-300/50 bg-card px-3 py-2.5 dark:border-white/[0.08]"
+ >
+
+
+
+
+ {relationshipLabel(edge, props.threadId)}
+
+
+ {node?.thread?.title ?? threadId}
+
+
+ {availability ? (
+ {availability}
+ ) : (
+
+ );
+ })}
+
+
+ {canMerge || canDetach ? (
+
+ {canMerge ? (
+ void merge()}
+ className="min-h-11 flex-row items-center justify-center gap-2 rounded-xl bg-primary px-3"
+ >
+ {busyAction === "merge" ? (
+
+ Merge back to source
+
+
+ ) : null}
+ {canDetach ? (
+ void detach()}
+ className="min-h-11 flex-row items-center justify-center gap-2 rounded-xl border border-neutral-300/60 px-3 dark:border-white/[0.1]"
+ >
+ {busyAction === "detach" ?
+ Disconnect agent session
+
+
+ ) : null}
+
+ ) : null}
+
+
+
+
+ );
+}
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index d7754b7d78f..713f4b3acee 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -8,10 +8,6 @@ import {
import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
import * as Option from "effect/Option";
import { EnvironmentId, ThreadId, type ProjectScript } from "@t3tools/contracts";
-import {
- requestOlderThreadTurns,
- threadHasOlderTurns,
-} from "@t3tools/client-runtime/state/threads";
import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
import { Platform, ScrollView, View } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";
@@ -194,20 +190,6 @@ function ThreadRouteContent(
useThreadSelection();
const selectedThreadDetailState = props.selectedThreadDetailState;
const selectedThreadDetail = Option.getOrNull(selectedThreadDetailState.data);
- // "Load earlier turns" header state for windowed (paginated) thread loads.
- const loadEarlierTurns = useMemo(() => {
- if (selectedThread === null || !threadHasOlderTurns(selectedThreadDetailState)) {
- return null;
- }
- return {
- loading:
- selectedThreadDetailState.page._tag === "Some" &&
- selectedThreadDetailState.page.value.loadingOlder,
- onLoadEarlier: () => {
- requestOlderThreadTurns(selectedThread.environmentId, selectedThread.id);
- },
- };
- }, [selectedThread, selectedThreadDetailState]);
const { selectedThreadCwd } = useSelectedThreadWorktree();
const composer = useThreadComposerState();
const gitState = useSelectedThreadGitState();
@@ -325,7 +307,7 @@ function ThreadRouteContent(
}),
[knownTerminalSessions, selectedThreadProject?.workspaceRoot],
);
- const selectedThreadDetailWorktreePath = selectedThreadDetail?.worktreePath ?? null;
+ const selectedThreadDetailWorktreePath = selectedThreadDetail?.thread.worktreePath ?? null;
const handleReconnectEnvironment = useCallback(() => {
if (!environmentId) {
return;
@@ -479,23 +461,17 @@ function ThreadRouteContent(
void navigation.navigate("Connections");
}, [navigation]);
const handleStopThread = useCallback(() => {
- if (
- !selectedThread ||
- (selectedThread.session?.status !== "running" &&
- selectedThread.session?.status !== "starting")
- ) {
+ if (!selectedThread || composer.interruptibleRunId === null) {
return;
}
return interruptThreadTurn({
environmentId: selectedThread.environmentId,
input: {
threadId: selectedThread.id,
- ...(selectedThread.session.activeTurnId
- ? { turnId: selectedThread.session.activeTurnId }
- : {}),
+ runId: composer.interruptibleRunId,
},
});
- }, [interruptThreadTurn, selectedThread]);
+ }, [composer.interruptibleRunId, interruptThreadTurn, selectedThread]);
const handleOpenTerminal = useCallback(
(nextTerminalId?: string | null) => {
@@ -773,6 +749,7 @@ function ThreadRouteContent(
connectionError={routeConnectionError}
environmentLabel={selectedEnvironmentConnection?.environmentLabel ?? null}
selectedThreadFeed={composer.selectedThreadFeed}
+ activityRun={composer.selectedThreadActivityRun}
activeWorkStartedAt={composer.activeWorkStartedAt}
activePendingApproval={requests.activePendingApproval}
respondingApprovalId={requests.respondingApprovalId}
@@ -784,8 +761,8 @@ function ThreadRouteContent(
draftAttachments={composer.draftAttachments}
connectionStateLabel={routeConnectionState}
threadSyncStatus={selectedThreadDetailState.status}
- loadEarlier={loadEarlierTurns}
activeThreadBusy={composer.activeThreadBusy}
+ canStopThread={composer.interruptibleRunId !== null}
environmentId={selectedThread.environmentId}
projectWorkspaceRoot={selectedThreadProject?.workspaceRoot ?? null}
threadCwd={selectedThreadCwd}
diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
index 24f7166916b..b571c02bbc9 100644
--- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx
+++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
@@ -28,10 +28,11 @@ import type { PendingNewTask } from "../../state/use-pending-new-tasks";
import { useThreadPr } from "../../state/use-thread-pr";
import { ThreadSwipeable } from "../home/thread-swipe-actions";
import {
- resolveThreadListV2SnoozeMenuSelection,
resolveThreadListV2SnoozeGateExpiryMs,
+ resolveThreadListV2SnoozeMenuSelection,
resolveThreadListV2Status,
resolveThreadListV2SwipeActions,
+ threadHasUnseenCompletion,
type ThreadListV2Status,
} from "./threadListV2";
import { ThreadSearchMatchExcerpt } from "./thread-search-match";
@@ -58,6 +59,8 @@ const STATUS_LABEL_BY_STATUS: Partial<
approval: { label: "Approval", className: "text-amber-700 dark:text-amber-300" },
input: { label: "Input", className: "text-indigo-600 dark:text-indigo-300" },
working: { label: "Working", className: "text-sky-600 dark:text-sky-400" },
+ // Colorless like the web sidebar: parked on background work, not "act now".
+ waiting: { label: "Waiting", className: "text-foreground-tertiary" },
failed: { label: "Failed", className: "text-red-700 dark:text-red-300" },
};
@@ -403,7 +406,13 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
const selected = props.selected === true;
const status = resolveThreadListV2Status(thread);
- const statusLabel = STATUS_LABEL_BY_STATUS[status];
+ // "Done" marks a completion the user has not opened yet — same emerald
+ // label as the web sidebar, sourced from the server-side visited watermark
+ // so checking a thread on any device clears it everywhere.
+ const isUnread = status === "ready" && threadHasUnseenCompletion(thread);
+ const statusLabel =
+ STATUS_LABEL_BY_STATUS[status] ??
+ (isUnread ? { label: "Done", className: "text-emerald-700 dark:text-emerald-300" } : undefined);
const timeLabel = threadTimeLabel(thread);
const handleDelete = useCallback(() => onDeleteThread(thread), [onDeleteThread, thread]);
@@ -632,7 +641,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
) : null}
- {status === "failed" && thread.session?.lastError ? (
+ {status === "failed" && thread.runtime?.lastError ? (
- {thread.session.lastError}
+ {thread.runtime.lastError}
) : thread.branch || props.environmentLabel ? (
/* "branch · machine" share one truncating line. The machine sits
diff --git a/apps/mobile/src/features/threads/thread-work-log-labels.test.ts b/apps/mobile/src/features/threads/thread-work-log-labels.test.ts
new file mode 100644
index 00000000000..eb4d621abb4
--- /dev/null
+++ b/apps/mobile/src/features/threads/thread-work-log-labels.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { threadWorkLogOverflowNoun } from "./thread-work-log-labels";
+
+describe("thread work log overflow labels", () => {
+ it("describes tool-only groups as tool calls", () => {
+ expect(threadWorkLogOverflowNoun(true, 1)).toBe("tool call");
+ expect(threadWorkLogOverflowNoun(true, 2)).toBe("tool calls");
+ });
+
+ it("describes mixed groups as log entries", () => {
+ expect(threadWorkLogOverflowNoun(false, 1)).toBe("log entry");
+ expect(threadWorkLogOverflowNoun(false, 2)).toBe("log entries");
+ });
+});
diff --git a/apps/mobile/src/features/threads/thread-work-log-labels.ts b/apps/mobile/src/features/threads/thread-work-log-labels.ts
new file mode 100644
index 00000000000..bff7f22fc48
--- /dev/null
+++ b/apps/mobile/src/features/threads/thread-work-log-labels.ts
@@ -0,0 +1,9 @@
+export function threadWorkLogOverflowNoun(
+ onlyToolRows: boolean,
+ count: number,
+): "tool call" | "tool calls" | "log entry" | "log entries" {
+ if (onlyToolRows) {
+ return count === 1 ? "tool call" : "tool calls";
+ }
+ return count === 1 ? "log entry" : "log entries";
+}
diff --git a/apps/mobile/src/features/threads/thread-work-log.tsx b/apps/mobile/src/features/threads/thread-work-log.tsx
index 529adac1db3..1b759d5183b 100644
--- a/apps/mobile/src/features/threads/thread-work-log.tsx
+++ b/apps/mobile/src/features/threads/thread-work-log.tsx
@@ -1,14 +1,22 @@
import * as Haptics from "expo-haptics";
+import { Image } from "expo-image";
import { type AppSymbolName, SymbolView } from "../../components/AppSymbol";
-import { LayoutAnimation, Pressable, ScrollView, useColorScheme, View } from "react-native";
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { useNavigation } from "@react-navigation/native";
+import { LayoutAnimation, Pressable, useColorScheme, View } from "react-native";
import { AppText as Text } from "../../components/AppText";
+import { T3_CODE_BRAND_MARK_SOURCE } from "../../components/brandAssets";
import { scaledTypographyLineHeight } from "../../lib/appearancePreferences";
import { cn } from "../../lib/cn";
import type { ThreadFeedActivity } from "../../lib/threadActivity";
import { MOBILE_TYPOGRAPHY } from "../../lib/typography";
import Animated, { FadeIn } from "react-native-reanimated";
+import { useV2ItemSupport } from "../../state/v2-item-support";
+import { ThreadActivityInspector } from "./ThreadActivityInspector";
+import { threadWorkLogOverflowNoun } from "./thread-work-log-labels";
+const MAX_VISIBLE_WORK_LOG_ENTRIES = 1;
const WORK_LOG_LAYOUT_ANIMATION = {
duration: 180,
create: {
@@ -71,6 +79,87 @@ function workRowSymbolName(icon: ThreadFeedActivity["icon"]): AppSymbolName {
}
}
+function WorkRowIcon(props: {
+ readonly row: ThreadFeedActivity;
+ readonly iconSubtleColor: import("react-native").ColorValue;
+}) {
+ const iconIsDestructive = props.row.icon === "alert" || props.row.icon === "warning";
+ if (props.row.logo === "t3-code") {
+ return (
+ {
+ void Haptics.selectionAsync();
+ navigation.navigate("Thread", {
+ environmentId: props.environmentId,
+ threadId: targetThreadId,
+ });
+ }}
+ className="mx-2 mb-2 min-h-9 flex-row items-center justify-center gap-1.5 rounded-lg border border-neutral-300/50 px-2 dark:border-white/[0.08]"
+ >
+ {label}
+
+ );
+}
+
// Entering fades only for rows created moments ago: rows remount whenever the
// list scrolls them back into view, and old rows must not replay an entrance.
const FRESH_ROW_WINDOW_MS = 3_000;
@@ -122,10 +211,15 @@ export function collapsedWorkLogHeight(
export function ThreadWorkLog(props: {
readonly activities: ReadonlyArray;
readonly copiedRowId: string | null;
+ readonly currentThreadId: ThreadId;
+ readonly environmentId: EnvironmentId;
+ readonly expanded: boolean;
readonly expandedRows: Readonly>;
readonly iconSubtleColor: import("react-native").ColorValue;
readonly onCopyRow: (rowId: string, value: string) => void;
+ readonly onToggleGroup: () => void;
readonly onToggleRow: (rowId: string) => void;
+ readonly workspaceRoot?: string | null;
}) {
const colorScheme = useColorScheme();
const pressedBackground = colorScheme === "dark" ? "rgba(255,255,255,0.05)" : "rgba(0,0,0,0.035)";
@@ -138,10 +232,15 @@ export function ThreadWorkLog(props: {
return null;
}
+ const hasOverflow = rows.length > MAX_VISIBLE_WORK_LOG_ENTRIES;
+ const visibleRows =
+ hasOverflow && !props.expanded ? rows.slice(-MAX_VISIBLE_WORK_LOG_ENTRIES) : rows;
+ const hiddenCount = rows.length - visibleRows.length;
const onlyToolRows = rows.every((row) => row.toolLike);
+ const overflowNoun = threadWorkLogOverflowNoun(onlyToolRows, hiddenCount);
return (
-
+
{!onlyToolRows ? (
work log
@@ -149,17 +248,21 @@ export function ThreadWorkLog(props: {
) : null}
- {rows.map((row) => {
+ {visibleRows.map((row) => {
const expanded = props.expandedRows[row.id] ?? false;
const canExpand = row.canExpand;
- const fullDetail = expanded ? row.getFullDetail() : null;
- const displayText = row.detail ? `${row.summary} ${row.detail}` : row.summary;
- const iconIsDestructive = row.icon === "alert" || row.icon === "warning";
+ const detail = compactActivityDetail(row.detail);
+ const displayText = detail ? `${row.summary} ${detail}` : row.summary;
+ const textIsDestructive = row.icon === "alert" || row.icon === "warning";
return (
({
backgroundColor: pressed ? pressedBackground : "transparent",
})}
- className="rounded-md px-0.5 py-0"
+ className="rounded-md px-0.5 py-0.5"
>
-
-
-
+
+
{row.summary}
- {row.detail ? (
- {row.detail}
+ {detail ? (
+ {detail}
) : null}
@@ -248,28 +345,63 @@ export function ThreadWorkLog(props: {
- {fullDetail ? (
-
-
-
- {fullDetail}
-
-
+ {expanded && canExpand ? (
+
+
) : null}
+ {row.prominent ? (
+
);
})}
+
+ {hasOverflow ? (
+ {
+ triggerDisclosureFeedback();
+ props.onToggleGroup();
+ }}
+ style={({ pressed }) => ({
+ backgroundColor: pressed ? pressedBackground : "transparent",
+ })}
+ className="min-h-9 flex-row items-center gap-1.5 rounded-md px-0.5 py-0.5"
+ >
+
+
+
+ {props.expanded
+ ? `Show fewer ${overflowNoun}`
+ : `+${hiddenCount} previous ${overflowNoun}`}
+
+
+ ) : null}
);
}
@@ -283,48 +415,36 @@ export function ThreadWorkGroupToggle(props: {
}) {
const colorScheme = useColorScheme();
const pressedBackground = colorScheme === "dark" ? "rgba(255,255,255,0.05)" : "rgba(0,0,0,0.035)";
- const noun = props.onlyToolActivities
- ? props.hiddenCount === 1
- ? "tool call"
- : "tool calls"
- : props.hiddenCount === 1
- ? "log entry"
- : "log entries";
- const collapsedLabel = `Show ${props.hiddenCount} previous ${noun}`;
- const expandedLabel = props.onlyToolActivities
- ? "Show fewer tool calls"
- : "Show fewer log entries";
+ const noun = threadWorkLogOverflowNoun(props.onlyToolActivities, props.hiddenCount);
return (
-
+
{
- void Haptics.selectionAsync();
+ triggerDisclosureFeedback();
props.onToggle();
}}
style={({ pressed }) => ({
backgroundColor: pressed ? pressedBackground : "transparent",
})}
- className="min-h-8 flex-row items-center gap-1.5 rounded-md px-0.5 py-0"
+ className="min-h-8 flex-row items-center gap-1.5 rounded-md px-0.5"
>
- {props.expanded ? expandedLabel : `+${props.hiddenCount} previous ${noun}`}
+ {props.expanded ? `Show fewer ${noun}` : `+${props.hiddenCount} previous ${noun}`}
diff --git a/apps/mobile/src/features/threads/threadActivityFileNavigation.test.ts b/apps/mobile/src/features/threads/threadActivityFileNavigation.test.ts
new file mode 100644
index 00000000000..a8f9343085b
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadActivityFileNavigation.test.ts
@@ -0,0 +1,26 @@
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+
+import { buildThreadActivityFileParams } from "./threadActivityFileNavigation";
+
+describe("thread activity file navigation", () => {
+ it("keeps inherited activity file links on the currently selected thread", () => {
+ const sourceThreadId = ThreadId.make("source-thread");
+ const currentThreadId = ThreadId.make("current-thread");
+
+ const params = buildThreadActivityFileParams({
+ environmentId: EnvironmentId.make("environment"),
+ currentThreadId,
+ activitySourceThreadId: sourceThreadId,
+ relativePath: "apps/mobile/src/index.ts",
+ line: 12,
+ });
+
+ expect(params).toEqual({
+ environmentId: "environment",
+ threadId: "current-thread",
+ path: ["apps", "mobile", "src", "index.ts"],
+ line: "12",
+ });
+ });
+});
diff --git a/apps/mobile/src/features/threads/threadActivityFileNavigation.ts b/apps/mobile/src/features/threads/threadActivityFileNavigation.ts
new file mode 100644
index 00000000000..21dfc44c026
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadActivityFileNavigation.ts
@@ -0,0 +1,22 @@
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
+
+interface ThreadActivityFileContext {
+ readonly environmentId: EnvironmentId;
+ readonly currentThreadId: ThreadId;
+ readonly activitySourceThreadId: ThreadId;
+ readonly relativePath: string;
+ readonly line?: number | null;
+}
+
+export function buildThreadActivityFileParams(input: ThreadActivityFileContext) {
+ // Activity provenance may come from a parent thread, but file routes stay scoped
+ // to the thread whose workspace is currently selected.
+ return {
+ environmentId: String(input.environmentId),
+ threadId: String(input.currentThreadId),
+ path: input.relativePath.split("/").filter((segment) => segment.length > 0),
+ ...(Number.isFinite(input.line) && Number(input.line) > 0
+ ? { line: String(Math.floor(Number(input.line))) }
+ : {}),
+ };
+}
diff --git a/apps/mobile/src/features/threads/threadForkNavigation.test.ts b/apps/mobile/src/features/threads/threadForkNavigation.test.ts
new file mode 100644
index 00000000000..a56cb3da2e3
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadForkNavigation.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { waitForThreadShellReady } from "./threadForkNavigation";
+
+describe("waitForThreadShellReady", () => {
+ it("returns true when the forked thread shell arrives before the deadline", async () => {
+ let elapsedMs = 0;
+
+ const ready = await waitForThreadShellReady({
+ read: () => elapsedMs >= 80,
+ timeoutMs: 120,
+ pollIntervalMs: 40,
+ now: () => elapsedMs,
+ delay: async (durationMs) => {
+ elapsedMs += durationMs;
+ },
+ });
+
+ expect(ready).toBe(true);
+ });
+
+ it("returns false instead of navigating when the shell never arrives", async () => {
+ let elapsedMs = 0;
+
+ const ready = await waitForThreadShellReady({
+ read: () => false,
+ timeoutMs: 80,
+ pollIntervalMs: 40,
+ now: () => elapsedMs,
+ delay: async (durationMs) => {
+ elapsedMs += durationMs;
+ },
+ });
+
+ expect(ready).toBe(false);
+ expect(elapsedMs).toBe(80);
+ });
+});
diff --git a/apps/mobile/src/features/threads/threadForkNavigation.ts b/apps/mobile/src/features/threads/threadForkNavigation.ts
new file mode 100644
index 00000000000..97ebf9c97bc
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadForkNavigation.ts
@@ -0,0 +1,26 @@
+const DEFAULT_TIMEOUT_MS = 2_000;
+const DEFAULT_POLL_INTERVAL_MS = 40;
+
+export async function waitForThreadShellReady(input: {
+ readonly read: () => boolean;
+ readonly timeoutMs?: number;
+ readonly pollIntervalMs?: number;
+ readonly now?: () => number;
+ readonly delay?: (durationMs: number) => Promise;
+}): Promise {
+ const now = input.now ?? Date.now;
+ const delay =
+ input.delay ??
+ ((durationMs: number) =>
+ new Promise((resolve) => {
+ setTimeout(resolve, durationMs);
+ }));
+ const deadline = now() + (input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+ const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+
+ while (!input.read() && now() < deadline) {
+ await delay(Math.min(pollIntervalMs, deadline - now()));
+ }
+
+ return input.read();
+}
diff --git a/apps/mobile/src/features/threads/threadListV2.test.ts b/apps/mobile/src/features/threads/threadListV2.test.ts
index 1316b3480c0..adc9cf78115 100644
--- a/apps/mobile/src/features/threads/threadListV2.test.ts
+++ b/apps/mobile/src/features/threads/threadListV2.test.ts
@@ -7,12 +7,13 @@ import {
MessageId,
ProjectId,
ProviderInstanceId,
+ RunId,
ThreadId,
- TurnId,
} from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
import type { PendingNewTask } from "../../state/use-pending-new-tasks";
+import { makeThreadShellFixture } from "../../test-fixtures";
import {
buildThreadListV2Items,
buildThreadListV2ListItems,
@@ -29,27 +30,10 @@ const environmentId = EnvironmentId.make("environment-1");
function makeThread(
input: Partial & Pick,
): EnvironmentThreadShell {
- return {
+ return makeThreadShellFixture({
environmentId,
- projectId: ProjectId.make("project-1"),
- modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
- runtimeMode: "full-access",
- interactionMode: "default",
- branch: null,
- worktreePath: null,
- latestTurn: null,
- createdAt: "2026-06-01T00:00:00.000Z",
- updatedAt: "2026-06-01T00:00:00.000Z",
- archivedAt: null,
- settledOverride: null,
- settledAt: null,
- session: null,
- latestUserMessageAt: null,
- hasPendingApprovals: false,
- hasPendingUserInput: false,
- hasActionableProposedPlan: false,
...input,
- };
+ });
}
const NOW = "2026-06-02T00:00:00.000Z";
@@ -122,18 +106,16 @@ describe("resolveThreadListV2Enabled", () => {
});
describe("resolveThreadListV2Status", () => {
- it("prioritizes approval over a running session", () => {
+ it("prioritizes approval over a running runtime", () => {
const thread = makeThread({
id: ThreadId.make("t"),
title: "t",
hasPendingApprovals: true,
- session: {
- threadId: ThreadId.make("t"),
+ runtime: {
status: "running",
+ activeRunId: RunId.make("run-t"),
providerName: "Codex",
providerInstanceId: ProviderInstanceId.make("codex"),
- runtimeMode: "full-access",
- activeTurnId: null,
lastError: null,
updatedAt: NOW,
},
@@ -141,6 +123,26 @@ describe("resolveThreadListV2Status", () => {
expect(resolveThreadListV2Status(thread)).toBe("approval");
});
+ it("reports waiting when presentation parks runtime idle for background tasks", () => {
+ expect(
+ resolveThreadListV2Status(
+ makeThread({
+ id: ThreadId.make("t"),
+ title: "t",
+ pendingBackgroundTasks: [{ taskId: "bg-1", description: "Run Codex review" }],
+ runtime: {
+ status: "idle",
+ activeRunId: null,
+ providerInstanceId: ProviderInstanceId.make("codex"),
+ providerName: "Codex",
+ lastError: null,
+ updatedAt: NOW,
+ },
+ }),
+ ),
+ ).toBe("waiting");
+ });
+
it("resolves ready for quiescent threads", () => {
expect(resolveThreadListV2Status(makeThread({ id: ThreadId.make("t"), title: "t" }))).toBe(
"ready",
@@ -259,6 +261,68 @@ describe("sortThreadsForListV2", () => {
});
describe("buildThreadListV2Items", () => {
+ it("excludes subagent child threads from top-level rows and counts", () => {
+ const rootThreadId = ThreadId.make("root");
+ const activeChildId = ThreadId.make("active-child");
+ const forkId = ThreadId.make("fork");
+ const settledChildId = ThreadId.make("settled-child");
+ const snoozedChildId = ThreadId.make("snoozed-child");
+ const layout = buildThreadListV2Items({
+ threads: [
+ makeThread({ id: rootThreadId, title: "Root" }),
+ makeThread({
+ id: forkId,
+ title: "Fork",
+ lineage: {
+ rootThreadId,
+ parentThreadId: rootThreadId,
+ relationshipToParent: "fork",
+ },
+ }),
+ makeThread({
+ id: activeChildId,
+ title: "Active child",
+ lineage: {
+ rootThreadId,
+ parentThreadId: rootThreadId,
+ relationshipToParent: "subagent",
+ },
+ }),
+ makeThread({
+ id: settledChildId,
+ title: "Settled child",
+ lineage: {
+ rootThreadId,
+ parentThreadId: rootThreadId,
+ relationshipToParent: "subagent",
+ },
+ settledOverride: "settled",
+ settledAt: "2026-06-01T12:00:00.000Z",
+ }),
+ makeThread({
+ id: snoozedChildId,
+ title: "Snoozed child",
+ lineage: {
+ rootThreadId,
+ parentThreadId: rootThreadId,
+ relationshipToParent: "subagent",
+ },
+ snoozedUntil: "2026-06-03T09:00:00.000Z",
+ snoozedAt: "2026-06-01T12:00:00.000Z",
+ }),
+ ],
+ environmentId: null,
+ searchQuery: "",
+ now: NOW,
+ settledLimit: 0,
+ });
+
+ expect(layout.items.map((item) => item.thread.id)).toEqual([forkId, rootThreadId]);
+ expect(layout.hiddenSettledCount).toBe(0);
+ expect(layout.snoozedCount).toBe(0);
+ expect(layout.nextSnoozeWakeAt).toBeNull();
+ });
+
it("hides snoozed threads and counts them — visibility parity with web", () => {
const layout = buildThreadListV2Items({
threads: [
@@ -626,10 +690,11 @@ describe("buildThreadListV2Items", () => {
});
it("scopes the flat list to one project", () => {
+ const projectId = ProjectId.make("project-1");
const otherProjectId = ProjectId.make("project-2");
const { items } = buildThreadListV2Items({
threads: [
- makeThread({ id: ThreadId.make("included"), title: "Included" }),
+ makeThread({ id: ThreadId.make("included"), projectId, title: "Included" }),
makeThread({
id: ThreadId.make("excluded"),
projectId: otherProjectId,
@@ -637,7 +702,7 @@ describe("buildThreadListV2Items", () => {
}),
],
environmentId: null,
- projectRefs: [{ environmentId, projectId: ProjectId.make("project-1") }],
+ projectRefs: [{ environmentId, projectId }],
searchQuery: "",
now: NOW,
});
@@ -647,19 +712,21 @@ describe("buildThreadListV2Items", () => {
it("scopes the flat list to every environment member of a logical project", () => {
const remoteEnvironmentId = EnvironmentId.make("environment-remote");
+ const projectId = ProjectId.make("project-1");
const { items } = buildThreadListV2Items({
threads: [
- makeThread({ id: ThreadId.make("local"), title: "Local" }),
+ makeThread({ id: ThreadId.make("local"), projectId, title: "Local" }),
makeThread({
environmentId: remoteEnvironmentId,
id: ThreadId.make("remote"),
+ projectId,
title: "Remote",
}),
],
environmentId: null,
projectRefs: [
- { environmentId, projectId: ProjectId.make("project-1") },
- { environmentId: remoteEnvironmentId, projectId: ProjectId.make("project-1") },
+ { environmentId, projectId },
+ { environmentId: remoteEnvironmentId, projectId },
],
searchQuery: "",
now: NOW,
@@ -682,9 +749,9 @@ describe("buildThreadListV2Items settled paging", () => {
latestUserMessageAt: `2026-06-01T0${index}:00:00.000Z`,
// A turn adopted the message (same requestedAt): without it the
// thread reads as a queued turn start, which never settles.
- latestTurn: {
- turnId: TurnId.make(`turn-${index}`),
- state: "completed",
+ latestRun: {
+ runId: RunId.make(`run-${index}`),
+ status: "completed",
requestedAt: `2026-06-01T0${index}:00:00.000Z`,
startedAt: `2026-06-01T0${index}:00:00.000Z`,
completedAt: `2026-06-01T0${index}:10:00.000Z`,
diff --git a/apps/mobile/src/features/threads/threadListV2.ts b/apps/mobile/src/features/threads/threadListV2.ts
index fa5f58d5d0e..1c318300144 100644
--- a/apps/mobile/src/features/threads/threadListV2.ts
+++ b/apps/mobile/src/features/threads/threadListV2.ts
@@ -19,11 +19,13 @@ export { snoozeWakeLabel };
* Thread List v2 model, ported from the web sidebar v2
* (apps/web/src/components/Sidebar.logic.ts + SidebarV2.tsx).
*
- * Four visual states, three colors: color is reserved for "act now"
- * (approval), "in motion" (working), and "broken" (failed). Ready is the
- * unlabeled resting state.
+ * Six visual states. Color distinguishes approval, input, active work, and
+ * failures. Ready is the unlabeled resting state; waiting (runtime status "idle") is the agent
+ * parked on open background tasks, grey like working rather than a false Done.
+ * The orchestrator v2 presentation bridge parks runtime at idle when the
+ * post-settlement background roster is nonempty.
*/
-export type ThreadListV2Status = "approval" | "input" | "working" | "failed" | "ready";
+export type ThreadListV2Status = "approval" | "input" | "working" | "waiting" | "failed" | "ready";
export type ThreadListV2SwipeAction = "archive" | "settle" | "unsettle" | "snooze" | "unsnooze";
export function resolveThreadListV2SnoozeMenuSelection(input: {
@@ -84,7 +86,7 @@ export function resolveThreadListV2SwipeActions(input: {
export function resolveThreadListV2SnoozeGateExpiryMs(
thread: Pick<
EnvironmentThreadShell,
- "hasPendingApprovals" | "hasPendingUserInput" | "latestUserMessageAt" | "latestTurn" | "session"
+ "hasPendingApprovals" | "hasPendingUserInput" | "latestRun" | "latestUserMessageAt" | "runtime"
>,
options: { readonly now: string },
): number | null {
@@ -121,8 +123,29 @@ export function resolveThreadListV2Enabled(input: {
return input.preference ?? true;
}
+/**
+ * Completed-but-not-yet-seen, mirroring the web sidebar's
+ * hasUnseenCompletion. The visited watermark is server state
+ * (thread.lastVisitedAt), so the marker agrees across web and mobile.
+ * Never-visited threads count as read — a fresh environment must not light
+ * up its whole history — and pre-tracking servers (field absent) never
+ * report unread.
+ */
+export function threadHasUnseenCompletion(
+ thread: Pick,
+): boolean {
+ const completedAt = thread.latestRun?.completedAt;
+ if (!completedAt) return false;
+ const completedAtMs = Date.parse(completedAt);
+ if (Number.isNaN(completedAtMs)) return false;
+ if (!thread.lastVisitedAt) return false;
+ const lastVisitedAtMs = Date.parse(thread.lastVisitedAt);
+ if (Number.isNaN(lastVisitedAtMs)) return true;
+ return completedAtMs > lastVisitedAtMs;
+}
+
export function resolveThreadListV2Status(
- thread: Pick,
+ thread: Pick,
): ThreadListV2Status {
if (thread.hasPendingApprovals) {
return "approval";
@@ -130,10 +153,16 @@ export function resolveThreadListV2Status(
if (thread.hasPendingUserInput) {
return "input";
}
- if (thread.session?.status === "running" || thread.session?.status === "starting") {
+ if (
+ thread.runtime !== null &&
+ ["preparing", "queued", "starting", "running", "waiting"].includes(thread.runtime.status)
+ ) {
return "working";
}
- if (thread.session?.status === "error") {
+ if (thread.runtime?.status === "idle") {
+ return "waiting";
+ }
+ if (thread.runtime?.status === "failed") {
return "failed";
}
return "ready";
@@ -359,6 +388,7 @@ export function buildThreadListV2Items(input: {
const snoozed: EnvironmentThreadShell[] = [];
let nextSnoozeWakeAt: string | null = null;
for (const thread of input.threads) {
+ if (thread.lineage.relationshipToParent === "subagent") continue;
// Callers pass live (unarchived) shells; settled threads are among them
// and partition into the tail via effectiveSettled.
if (input.environmentId !== null && thread.environmentId !== input.environmentId) continue;
diff --git a/apps/mobile/src/features/threads/threadPresentation.ts b/apps/mobile/src/features/threads/threadPresentation.ts
index 9de3d4d3089..531b9bd7fa4 100644
--- a/apps/mobile/src/features/threads/threadPresentation.ts
+++ b/apps/mobile/src/features/threads/threadPresentation.ts
@@ -1,6 +1,8 @@
import type { StatusTone } from "../../components/StatusPill";
-import type { OrchestrationLatestTurn, OrchestrationSession } from "@t3tools/contracts";
-import { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
+import {
+ threadRuntimeIsActive,
+ type EnvironmentThreadShell,
+} from "@t3tools/client-runtime/state/shell";
export function threadSortValue(thread: EnvironmentThreadShell): number {
const candidate = Date.parse(thread.updatedAt ?? thread.createdAt);
@@ -31,14 +33,10 @@ export const THREAD_STATUS_NEUTRAL_ICON = {
iconBackground: "rgba(142,142,147,0.22)",
} as const;
-function isLatestTurnSettled(
- latestTurn: OrchestrationLatestTurn | null,
- session: OrchestrationSession | null,
-): boolean {
- if (!latestTurn?.startedAt) return false;
- if (!latestTurn.completedAt) return false;
- if (!session) return true;
- return session.status !== "running";
+function isLatestRunSettled(thread: EnvironmentThreadShell): boolean {
+ if (!thread.latestRun?.startedAt) return false;
+ if (!thread.latestRun.completedAt) return false;
+ return !threadRuntimeIsActive(thread.runtime);
}
/**
@@ -73,7 +71,9 @@ export function resolveThreadStatus(
};
}
- if (thread.session?.status === "running") {
+ const runtimeStatus = thread.runtime?.status;
+
+ if (runtimeStatus === "running" || runtimeStatus === "waiting") {
return {
kind: "working",
label: "Working",
@@ -85,7 +85,7 @@ export function resolveThreadStatus(
};
}
- if (thread.session?.status === "starting") {
+ if (runtimeStatus === "preparing" || runtimeStatus === "queued" || runtimeStatus === "starting") {
return {
kind: "connecting",
label: "Connecting",
@@ -97,7 +97,7 @@ export function resolveThreadStatus(
};
}
- if (thread.session?.status === "error" || thread.latestTurn?.state === "error") {
+ if (runtimeStatus === "failed" || thread.latestRun?.status === "failed") {
return {
kind: "error",
label: "Error",
@@ -111,7 +111,7 @@ export function resolveThreadStatus(
const hasPlanReadyPrompt =
thread.interactionMode === "plan" &&
- isLatestTurnSettled(thread.latestTurn, thread.session) &&
+ isLatestRunSettled(thread) &&
thread.hasActionableProposedPlan;
if (hasPlanReadyPrompt) {
return {
diff --git a/apps/mobile/src/features/threads/threadQueueControlPresentation.test.ts b/apps/mobile/src/features/threads/threadQueueControlPresentation.test.ts
new file mode 100644
index 00000000000..5e4593557b3
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadQueueControlPresentation.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+ REMOVE_QUEUED_MESSAGE_ACCESSIBILITY_LABEL,
+ buildCancelQueuedRunCommand,
+ resolveThreadQueueRowControls,
+} from "./threadQueueControlPresentation";
+
+describe("threadQueueControlPresentation", () => {
+ it("preserves queue reorder and steer controls with removal", () => {
+ const controls = resolveThreadQueueRowControls({
+ busy: false,
+ canPromoteToSteer: true,
+ canReorder: true,
+ index: 1,
+ queuedCount: 3,
+ text: "Please review the follow-up change.",
+ });
+
+ expect(controls.displayText).toBe("Please review the follow-up change.");
+ expect(controls.canMoveUp).toBe(true);
+ expect(controls.canMoveDown).toBe(true);
+ expect(controls.canSteer).toBe(true);
+ expect(controls.canDismiss).toBe(true);
+ expect(controls.dismissAccessibilityLabel).toBe(REMOVE_QUEUED_MESSAGE_ACCESSIBILITY_LABEL);
+ });
+
+ it("disables edge reorder controls and busy dismissal", () => {
+ const first = resolveThreadQueueRowControls({
+ busy: false,
+ canPromoteToSteer: false,
+ canReorder: true,
+ index: 0,
+ queuedCount: 2,
+ text: "First",
+ });
+ const busy = resolveThreadQueueRowControls({
+ busy: true,
+ canPromoteToSteer: true,
+ canReorder: true,
+ index: 0,
+ queuedCount: 1,
+ text: "Queued message",
+ });
+
+ expect(first.canMoveUp).toBe(false);
+ expect(first.canMoveDown).toBe(true);
+ expect(first.canSteer).toBe(false);
+ expect(busy.canDismiss).toBe(false);
+ expect(busy.canMoveUp).toBe(false);
+ expect(busy.canSteer).toBe(false);
+ });
+
+ it("builds cancelQueuedRun command arguments for removal", () => {
+ expect(
+ buildCancelQueuedRunCommand({
+ environmentId: "environment:test" as never,
+ runId: "run:queued" as never,
+ threadId: "thread:test" as never,
+ }),
+ ).toEqual({
+ environmentId: "environment:test",
+ input: {
+ runId: "run:queued",
+ threadId: "thread:test",
+ },
+ });
+ });
+});
diff --git a/apps/mobile/src/features/threads/threadQueueControlPresentation.ts b/apps/mobile/src/features/threads/threadQueueControlPresentation.ts
new file mode 100644
index 00000000000..def490455d9
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadQueueControlPresentation.ts
@@ -0,0 +1,52 @@
+import type { EnvironmentId, RunId, ThreadId } from "@t3tools/contracts";
+
+export const REMOVE_QUEUED_MESSAGE_ACCESSIBILITY_LABEL = "Remove queued message";
+
+export interface ThreadQueueRowControls {
+ readonly canDismiss: boolean;
+ readonly canMoveDown: boolean;
+ readonly canMoveUp: boolean;
+ readonly canSteer: boolean;
+ readonly dismissAccessibilityLabel: string;
+ readonly displayText: string;
+}
+
+export function resolveThreadQueueRowControls(input: {
+ readonly busy: boolean;
+ readonly canPromoteToSteer: boolean;
+ readonly canReorder: boolean;
+ readonly index: number;
+ readonly queuedCount: number;
+ readonly text: string;
+}): ThreadQueueRowControls {
+ const mutationEnabled = !input.busy;
+
+ return {
+ canDismiss: !input.busy,
+ canMoveDown: mutationEnabled && input.canReorder && input.index < input.queuedCount - 1,
+ canMoveUp: mutationEnabled && input.canReorder && input.index > 0,
+ canSteer: mutationEnabled && input.canPromoteToSteer,
+ dismissAccessibilityLabel: REMOVE_QUEUED_MESSAGE_ACCESSIBILITY_LABEL,
+ displayText: input.text,
+ };
+}
+
+export function buildCancelQueuedRunCommand(input: {
+ readonly environmentId: EnvironmentId;
+ readonly runId: RunId;
+ readonly threadId: ThreadId;
+}): {
+ readonly environmentId: EnvironmentId;
+ readonly input: {
+ readonly runId: RunId;
+ readonly threadId: ThreadId;
+ };
+} {
+ return {
+ environmentId: input.environmentId,
+ input: {
+ runId: input.runId,
+ threadId: input.threadId,
+ },
+ };
+}
diff --git a/apps/mobile/src/features/threads/userMessageIntentBadge.test.ts b/apps/mobile/src/features/threads/userMessageIntentBadge.test.ts
new file mode 100644
index 00000000000..f29c4bba164
--- /dev/null
+++ b/apps/mobile/src/features/threads/userMessageIntentBadge.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "@effect/vitest";
+
+import { resolveUserMessageIntentBadge } from "./userMessageIntentBadge";
+
+describe("user message intent badge", () => {
+ it("does not label ordinary turn-start messages", () => {
+ expect(resolveUserMessageIntentBadge(undefined)).toBeNull();
+ expect(resolveUserMessageIntentBadge("turn_start")).toBeNull();
+ });
+
+ it("labels messages waiting behind the active turn", () => {
+ expect(resolveUserMessageIntentBadge("queued_turn")).toEqual({
+ label: "queued",
+ accessibilityLabel: "Queued behind the active turn",
+ tone: "queued",
+ });
+ });
+
+ it("labels messages that steer the active turn", () => {
+ expect(resolveUserMessageIntentBadge("steer")).toEqual({
+ label: "steer",
+ accessibilityLabel: "Steered the active turn",
+ tone: "steer",
+ });
+ });
+
+ it("preserves the queued origin after promotion to steer", () => {
+ expect(resolveUserMessageIntentBadge("promoted_queued_to_steer")).toEqual({
+ label: "queued → steer",
+ accessibilityLabel: "Originally queued, then promoted to steer the active turn",
+ tone: "steer",
+ });
+ });
+});
diff --git a/apps/mobile/src/features/threads/userMessageIntentBadge.ts b/apps/mobile/src/features/threads/userMessageIntentBadge.ts
new file mode 100644
index 00000000000..c72c1c342d8
--- /dev/null
+++ b/apps/mobile/src/features/threads/userMessageIntentBadge.ts
@@ -0,0 +1,35 @@
+import type { OrchestrationV2UserMessageInputIntent } from "@t3tools/contracts";
+
+export interface UserMessageIntentBadgePresentation {
+ readonly label: string;
+ readonly accessibilityLabel: string;
+ readonly tone: "queued" | "steer";
+}
+
+export function resolveUserMessageIntentBadge(
+ intent: OrchestrationV2UserMessageInputIntent | undefined,
+): UserMessageIntentBadgePresentation | null {
+ switch (intent) {
+ case "queued_turn":
+ return {
+ label: "queued",
+ accessibilityLabel: "Queued behind the active turn",
+ tone: "queued",
+ };
+ case "steer":
+ return {
+ label: "steer",
+ accessibilityLabel: "Steered the active turn",
+ tone: "steer",
+ };
+ case "promoted_queued_to_steer":
+ return {
+ label: "queued → steer",
+ accessibilityLabel: "Originally queued, then promoted to steer the active turn",
+ tone: "steer",
+ };
+ case "turn_start":
+ case undefined:
+ return null;
+ }
+}
diff --git a/apps/mobile/src/lib/projectThreadStartTurn.ts b/apps/mobile/src/lib/projectThreadStartTurn.ts
index 85523175a2f..f8461e494b2 100644
--- a/apps/mobile/src/lib/projectThreadStartTurn.ts
+++ b/apps/mobile/src/lib/projectThreadStartTurn.ts
@@ -7,19 +7,10 @@ import {
type ProviderInteractionMode,
type RuntimeMode,
} from "@t3tools/contracts";
+import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
import { toUploadChatImageAttachments, type DraftComposerImageAttachment } from "./composerImages";
-export function deriveThreadTitleFromPrompt(value: string): string {
- const trimmed = value.trim();
- if (trimmed.length === 0) {
- return "New thread";
- }
-
- const compact = trimmed.replace(/\s+/g, " ");
- return compact.length <= 72 ? compact : `${compact.slice(0, 69).trimEnd()}...`;
-}
-
export interface ProjectThreadStartTurnSpec {
readonly projectId: ProjectId;
readonly projectCwd: string;
@@ -46,10 +37,11 @@ export interface ProjectThreadStartTurnSpec {
* offline outbox drain so both deliver identical commands.
*/
export function buildProjectThreadStartTurnInput(spec: ProjectThreadStartTurnSpec) {
- const title = deriveThreadTitleFromPrompt(spec.text);
+ const title = deriveThreadTitleSeed({ text: spec.text, attachments: spec.attachments });
const isWorktree = spec.workspaceMode === "worktree";
return {
commandId: CommandId.make(spec.commandId),
+ creationSource: "mobile" as const,
threadId: ThreadId.make(spec.threadId),
message: {
messageId: MessageId.make(spec.messageId),
diff --git a/apps/mobile/src/lib/scopedEntities.ts b/apps/mobile/src/lib/scopedEntities.ts
index 34709957fd4..6464b356191 100644
--- a/apps/mobile/src/lib/scopedEntities.ts
+++ b/apps/mobile/src/lib/scopedEntities.ts
@@ -1,4 +1,4 @@
-import { ApprovalRequestId, EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";
+import { EnvironmentId, ProjectId, RuntimeRequestId, ThreadId } from "@t3tools/contracts";
export function scopedProjectKey(environmentId: EnvironmentId, projectId: ProjectId): string {
return `${environmentId}:${projectId}`;
@@ -10,7 +10,7 @@ export function scopedThreadKey(environmentId: EnvironmentId, threadId: ThreadId
export function scopedRequestKey(
environmentId: EnvironmentId,
- requestId: ApprovalRequestId,
+ requestId: RuntimeRequestId,
): string {
return `${environmentId}:${requestId}`;
}
diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts
index ae9a93e9fc3..38e15e46197 100644
--- a/apps/mobile/src/lib/threadActivity.test.ts
+++ b/apps/mobile/src/lib/threadActivity.test.ts
@@ -1,466 +1,323 @@
-import { describe, expect, it } from "vite-plus/test";
-
import {
- EventId,
MessageId,
- ProjectId,
- ProviderInstanceId,
+ RunId,
ThreadId,
- TurnId,
- type OrchestrationThread,
- type OrchestrationThreadActivity,
+ TurnItemId,
+ type OrchestrationV2ProjectedTurnItem,
+ type OrchestrationV2TurnItem,
} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import { describe, expect, it } from "vite-plus/test";
import {
buildThreadFeed,
deriveThreadFeedPresentation,
+ threadFeedRunIsUnsettled,
type ThreadFeedActivity,
type ThreadFeedEntry,
} from "./threadActivity";
-function makeActivity(
- input: Partial &
- Pick,
-): OrchestrationThreadActivity {
+const threadId = ThreadId.make("thread-1");
+const sourceThreadId = ThreadId.make("thread-source");
+const runId = RunId.make("run-1");
+
+function base(id: string, updatedAt: string, ordinal: number) {
+ const timestamp = DateTime.makeUnsafe(updatedAt);
return {
- tone: "info",
- payload: {},
- turnId: null,
- ...input,
+ id: TurnItemId.make(id),
+ threadId,
+ runId,
+ nodeId: null,
+ providerThreadId: null,
+ providerTurnId: null,
+ nativeItemRef: null,
+ parentItemId: null,
+ ordinal,
+ status: "completed" as const,
+ title: null,
+ startedAt: timestamp,
+ completedAt: timestamp,
+ updatedAt: timestamp,
};
}
-function makeThread(
- input: Partial & Pick,
-): OrchestrationThread {
+function projected(
+ item: OrchestrationV2TurnItem,
+ position: number,
+ visibility: OrchestrationV2ProjectedTurnItem["visibility"] = "local",
+): OrchestrationV2ProjectedTurnItem {
return {
- modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
- runtimeMode: "full-access",
- interactionMode: "default",
- branch: null,
- worktreePath: null,
- latestTurn: null,
- createdAt: "2026-04-01T00:00:00.000Z",
- updatedAt: "2026-04-01T00:00:00.000Z",
- archivedAt: null,
- deletedAt: null,
- messages: [],
- proposedPlans: [],
- activities: [],
- checkpoints: [],
- session: null,
- ...input,
- settledOverride: input.settledOverride ?? null,
- settledAt: input.settledAt ?? null,
+ position,
+ visibility,
+ sourceThreadId: visibility === "local" ? threadId : sourceThreadId,
+ sourceItemId: item.id,
+ item,
};
}
-describe("buildThreadFeed", () => {
- it("keeps historic work entries attributed to their turns", () => {
- const thread = makeThread({
- id: ThreadId.make("thread-1"),
- projectId: ProjectId.make("project-1"),
- title: "Runtime warning thread",
- latestTurn: {
- turnId: TurnId.make("turn-latest"),
- state: "running",
- requestedAt: "2026-04-01T00:00:00.000Z",
- startedAt: "2026-04-01T00:00:01.000Z",
- completedAt: null,
- assistantMessageId: null,
- },
- activities: [
- makeActivity({
- id: EventId.make("activity-old"),
- kind: "runtime.warning",
- summary: "Runtime warning",
- createdAt: "2026-04-01T00:00:02.000Z",
- turnId: TurnId.make("turn-old"),
- payload: {
- message: "Old warning",
- },
- }),
- makeActivity({
- id: EventId.make("activity-latest"),
- kind: "runtime.warning",
- summary: "Runtime warning",
- createdAt: "2026-04-01T00:00:03.000Z",
- turnId: TurnId.make("turn-latest"),
- payload: {
- message: "Latest warning",
- },
- }),
- ],
- });
+function userMessage(updatedAt = "2026-06-20T00:00:01.000Z") {
+ return {
+ ...base("item-user", updatedAt, 0),
+ type: "user_message" as const,
+ messageId: MessageId.make("message-user"),
+ createdBy: "user" as const,
+ creationSource: "mobile" as const,
+ inputIntent: "turn_start" as const,
+ text: "Run checks",
+ attachments: [],
+ };
+}
- const feed = buildThreadFeed(thread);
- expect(feed).toMatchObject([
- {
- type: "activity-group",
- turnId: "turn-old",
- activities: [{ id: "activity-old", turnId: "turn-old" }],
- },
+function command(updatedAt = "2026-06-20T00:00:02.000Z") {
+ return {
+ ...base("item-command", updatedAt, 1),
+ type: "command_execution" as const,
+ input: "vp check",
+ output: "ok",
+ exitCode: 0,
+ };
+}
+
+function assistantMessage(updatedAt = "2026-06-20T00:00:03.000Z") {
+ return {
+ ...base("item-assistant", updatedAt, 2),
+ type: "assistant_message" as const,
+ messageId: MessageId.make("message-assistant"),
+ text: "Done",
+ streaming: false,
+ };
+}
+
+describe("buildThreadFeed", () => {
+ it("hides synthetic workspace preparation activity", () => {
+ const workspacePreparation = projected(
{
- type: "activity-group",
- turnId: "turn-latest",
- activities: [{ id: "activity-latest", turnId: "turn-latest" }],
+ ...command(),
+ title: "Workspace ready",
+ input: "Preparing workspace",
+ output: "Workspace preparation completed.",
},
- ]);
+ 0,
+ );
+
+ expect(buildThreadFeed([workspacePreparation])).toEqual([]);
});
- it("collapses matching tool lifecycle rows like desktop", () => {
- const thread = makeThread({
- id: ThreadId.make("thread-2"),
- projectId: ProjectId.make("project-1"),
- title: "Collapsed tools",
- latestTurn: {
- turnId: TurnId.make("turn-1"),
- state: "completed",
- requestedAt: "2026-04-01T00:00:00.000Z",
- startedAt: "2026-04-01T00:00:01.000Z",
- completedAt: "2026-04-01T00:00:03.000Z",
- assistantMessageId: null,
- },
- activities: [
- makeActivity({
- id: EventId.make("tool-updated"),
- kind: "tool.updated",
- tone: "tool",
- summary: "Run tests",
- createdAt: "2026-04-01T00:00:01.000Z",
- turnId: TurnId.make("turn-1"),
- payload: {
- title: "Run tests",
- itemType: "command_execution",
- detail: "/bin/zsh -lc 'bun run test'",
- },
- }),
- makeActivity({
- id: EventId.make("tool-completed"),
- kind: "tool.completed",
- tone: "tool",
- summary: "Run tests completed",
- createdAt: "2026-04-01T00:00:02.000Z",
- turnId: TurnId.make("turn-1"),
- payload: {
- title: "Run tests",
- itemType: "command_execution",
- detail: "/bin/zsh -lc 'bun run test'",
- },
- }),
- ],
- });
+ it("does not treat a queued-only run as live feed activity", () => {
+ expect(
+ threadFeedRunIsUnsettled({
+ runId,
+ status: "queued",
+ startedAt: null,
+ completedAt: null,
+ }),
+ ).toBe(false);
+ expect(
+ threadFeedRunIsUnsettled({
+ runId,
+ status: "running",
+ startedAt: "2026-06-20T00:00:01.000Z",
+ completedAt: null,
+ }),
+ ).toBe(true);
+ });
- const feed = buildThreadFeed(thread);
- const group = feed[0];
+ it("adds queued input only after dispatch creates its turn item", () => {
+ const dispatchedRunId = RunId.make("run-dispatched-queued");
+ const dispatchedMessageId = MessageId.make("message-dispatched-queued");
+ expect(buildThreadFeed([])).toEqual([]);
- expect(group).toMatchObject({
- type: "activity-group",
- });
- if (!group || group.type !== "activity-group") {
- return;
- }
-
- expect(group.activities).toHaveLength(1);
- expect(group.activities[0]).toMatchObject({
- id: "tool-completed",
- createdAt: "2026-04-01T00:00:02.000Z",
- turnId: "turn-1",
- summary: "Run tests",
- detail: "bun run test",
- canExpand: true,
- icon: "command",
- toolLike: true,
- status: "success",
- });
- expect(group.activities[0]?.getFullDetail()).toBe("/bin/zsh -lc 'bun run test'");
- expect(group.activities[0]?.getCopyText()).toBe(
- "Run tests\nbun run test\n/bin/zsh -lc 'bun run test'",
- );
+ const promotedEntries = buildThreadFeed([
+ projected(
+ {
+ ...userMessage(),
+ id: TurnItemId.make("item-dispatched-queued"),
+ runId: dispatchedRunId,
+ messageId: dispatchedMessageId,
+ inputIntent: "turn_start",
+ },
+ 0,
+ ),
+ ]);
+ expect(promotedEntries.map((entry) => entry.id)).toEqual([dispatchedMessageId]);
+ expect(
+ promotedEntries[0]?.type === "message" ? promotedEntries[0].message.inputIntent : undefined,
+ ).toBe("turn_start");
});
- it("keeps MCP inputs available to expanded mobile work rows", () => {
- const turnId = TurnId.make("turn-mcp");
- const thread = makeThread({
- id: ThreadId.make("thread-mcp"),
- projectId: ProjectId.make("project-1"),
- title: "Expandable MCP call",
- latestTurn: {
- turnId,
- state: "completed",
- requestedAt: "2026-04-01T00:00:00.000Z",
- startedAt: "2026-04-01T00:00:01.000Z",
- completedAt: "2026-04-01T00:00:03.000Z",
- assistantMessageId: null,
+ it("hides the interruption request and keeps the terminal result", () => {
+ const request = projected(
+ {
+ ...base("item-interrupt-request", "2026-06-20T00:00:02.000Z", 1),
+ type: "run_interrupt_request",
+ message: "Interrupt requested",
},
- activities: [
- makeActivity({
- id: EventId.make("mcp-completed"),
- kind: "tool.completed",
- tone: "tool",
- summary: "Call repository tool",
- createdAt: "2026-04-01T00:00:02.000Z",
- turnId,
- payload: {
- title: "Call repository tool",
- itemType: "mcp_tool_call",
- detail: "repository.search",
- status: "completed",
- data: {
- item: {
- server: "repository",
- tool: "search",
- arguments: { query: "work log" },
- },
- },
- },
- }),
- ],
- });
+ 0,
+ );
+ const result = projected(
+ {
+ ...base("item-interrupt-result", "2026-06-20T00:00:03.000Z", 2),
+ type: "run_interrupt_result",
+ message: "Run interrupted before provider start",
+ },
+ 1,
+ );
- const group = buildThreadFeed(thread)[0];
- expect(group).toMatchObject({ type: "activity-group" });
- if (!group || group.type !== "activity-group") {
- return;
- }
+ const activities = buildThreadFeed([request, result]).flatMap((entry) =>
+ entry.type === "activity-group" ? entry.activities : [],
+ );
- expect(group.activities[0]?.icon).toBe("wrench");
- expect(group.activities[0]?.getFullDetail()).toContain('"query": "work log"');
- expect(group.activities[0]?.getFullDetail()).toContain("repository.search");
+ expect(activities).toHaveLength(1);
+ expect(activities[0]?.summary).toBe("Run interrupted");
+ expect(activities[0]?.detail).toBe("Run interrupted before provider start");
});
- it("defers large tool output expansion until a work row is opened or copied", () => {
- let serializedToolOutputs = 0;
- const activities = Array.from({ length: 5_000 }, (_, index) =>
- makeActivity({
- id: EventId.make(`large-tool-${index}`),
- kind: "tool.completed",
- tone: "tool",
- summary: `Tool ${index}`,
- createdAt: new Date(Date.UTC(2026, 3, 1, 0, 0, index)).toISOString(),
- payload: {
- title: `Tool ${index}`,
- itemType: "mcp_tool_call",
- status: "completed",
- data: {
- item: {
- toJSON: () => {
- serializedToolOutputs += 1;
- return { output: "x".repeat(32_768) };
- },
- },
- },
- },
- }),
- );
- const thread = makeThread({
- id: ThreadId.make("thread-large-tools"),
- projectId: ProjectId.make("project-1"),
- title: "Large tools",
- activities,
- });
+ it("preserves authoritative V2 order instead of sorting reconstructed collections", () => {
+ const rows = [
+ projected(userMessage("2026-06-20T00:00:03.000Z"), 0),
+ projected(command("2026-06-20T00:00:01.000Z"), 1),
+ projected(assistantMessage("2026-06-20T00:00:02.000Z"), 2),
+ ];
- const feed = buildThreadFeed(thread);
- expect(serializedToolOutputs).toBe(0);
+ const feed = buildThreadFeed(rows);
+ expect(feed.map((entry) => entry.type)).toEqual(["message", "activity-group", "message"]);
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "message-user",
+ "local:thread-1:item-command",
+ "message-assistant",
+ ]);
+ const activity = feed.find((entry) => entry.type === "activity-group")?.activities[0];
+ expect(activity?.projectedItem).toBe(rows[1]);
+ expect(activity?.getFullDetail()).toContain('"input": "vp check"');
+ });
- const group = feed[0];
- expect(group).toMatchObject({ type: "activity-group" });
- if (!group || group.type !== "activity-group") {
- return;
- }
+ it("retains inherited and synthetic rows with their original projected identity", () => {
+ const inherited = projected(command(), 0, "inherited");
+ const { providerThreadId: _providerThreadId, ...forkBase } = base(
+ "item-fork",
+ "2026-06-20T00:00:03.000Z",
+ 2,
+ );
+ const synthetic = projected(
+ {
+ ...forkBase,
+ type: "fork",
+ source: { type: "run", threadId: sourceThreadId, runId },
+ targetThreadId: threadId,
+ },
+ 1,
+ "synthetic",
+ );
- expect(group.activities).toHaveLength(5_000);
- expect(group.activities[0]?.getFullDetail()).toContain('"output"');
- expect(serializedToolOutputs).toBe(1);
- expect(group.activities[0]?.getCopyText()).toContain('"output"');
- expect(serializedToolOutputs).toBe(1);
+ const feed = buildThreadFeed([inherited, synthetic]);
+ const activities = feed.flatMap((entry) =>
+ entry.type === "activity-group" ? entry.activities : [],
+ );
+ expect(activities.map((activity) => activity.projectedItem)).toEqual([inherited, synthetic]);
+ expect(activities.map((activity) => activity.projectedItem.visibility)).toEqual([
+ "inherited",
+ "synthetic",
+ ]);
+ expect(activities.at(-1)?.prominent).toBe(true);
});
- it("folds settled turn work while leaving the terminal answer visible", () => {
- const turnId = TurnId.make("turn-1");
- const thread = makeThread({
- id: ThreadId.make("thread-3"),
- projectId: ProjectId.make("project-1"),
- title: "Folded work",
- latestTurn: {
- turnId,
- state: "completed",
- requestedAt: "2026-04-01T00:00:00.000Z",
- startedAt: "2026-04-01T00:00:01.000Z",
- completedAt: "2026-04-01T00:00:18.000Z",
- assistantMessageId: MessageId.make("assistant-final"),
- },
- messages: [
- {
- id: MessageId.make("assistant-commentary"),
- role: "assistant",
- text: "I am checking.",
- turnId,
- streaming: false,
- createdAt: "2026-04-01T00:00:02.000Z",
- updatedAt: "2026-04-01T00:00:03.000Z",
- },
+ it("keeps orchestration relationship cards visible when a completed run is folded", () => {
+ const { providerThreadId: _providerThreadId, ...forkBase } = base(
+ "item-fork",
+ "2026-06-20T00:00:02.500Z",
+ 2,
+ );
+ const feed = buildThreadFeed([
+ projected(userMessage(), 0),
+ projected(command(), 1),
+ projected(
{
- id: MessageId.make("assistant-final"),
- role: "assistant",
- text: "Done.",
- turnId,
- streaming: false,
- createdAt: "2026-04-01T00:00:17.000Z",
- updatedAt: "2026-04-01T00:00:18.000Z",
+ ...forkBase,
+ type: "fork",
+ source: { type: "run", threadId, runId },
+ targetThreadId: sourceThreadId,
},
- ],
- activities: [
- makeActivity({
- id: EventId.make("tool-completed"),
- kind: "tool.completed",
- tone: "tool",
- summary: "Read files",
- createdAt: "2026-04-01T00:00:05.000Z",
- turnId,
- payload: {
- title: "Read files",
- itemType: "file_read",
- status: "completed",
- },
- }),
- ],
- });
+ 2,
+ ),
+ projected(assistantMessage(), 3),
+ ]);
- const feed = buildThreadFeed(thread);
- const collapsed = deriveThreadFeedPresentation(feed, thread.latestTurn, new Set());
- expect(collapsed.map((entry) => entry.id)).toEqual(["turn-fold:turn-1", "assistant-final"]);
- expect(collapsed[0]).toMatchObject({
- type: "turn-fold",
- label: "Worked for 17s",
- expanded: false,
- });
+ const collapsed = deriveThreadFeedPresentation(
+ feed,
+ {
+ runId,
+ status: "completed",
+ startedAt: "2026-06-20T00:00:01.000Z",
+ completedAt: "2026-06-20T00:00:03.000Z",
+ },
+ new Set(),
+ );
- const expanded = deriveThreadFeedPresentation(feed, thread.latestTurn, new Set([turnId]));
- expect(expanded.map((entry) => entry.id)).toEqual([
- "turn-fold:turn-1",
- "assistant-commentary",
- "tool-completed",
- "assistant-final",
- ]);
+ expect(
+ collapsed.some(
+ (entry) =>
+ entry.type === "activity-group" &&
+ entry.activities.some((activity) => activity.projectedItem.item.type === "fork"),
+ ),
+ ).toBe(true);
+ expect(
+ collapsed.some(
+ (entry) =>
+ entry.type === "activity-group" &&
+ entry.activities.some(
+ (activity) => activity.projectedItem.item.type === "command_execution",
+ ),
+ ),
+ ).toBe(false);
});
- it("measures a steer-superseded turn from its user boundary through trailing work", () => {
- const firstTurnId = TurnId.make("turn-1");
- const secondTurnId = TurnId.make("turn-2");
- const thread = makeThread({
- id: ThreadId.make("thread-steered"),
- projectId: ProjectId.make("project-1"),
- title: "Steered work",
- latestTurn: {
- turnId: secondTurnId,
- state: "running",
- requestedAt: "2026-04-01T00:00:14.000Z",
- startedAt: "2026-04-01T00:00:14.000Z",
- completedAt: null,
- assistantMessageId: MessageId.make("assistant-next"),
- },
- messages: [
- {
- id: MessageId.make("user-1"),
- role: "user",
- text: "Do it once more.",
- turnId: null,
- streaming: false,
- createdAt: "2026-04-01T00:00:00.000Z",
- updatedAt: "2026-04-01T00:00:00.000Z",
- },
- {
- id: MessageId.make("assistant-commentary"),
- role: "assistant",
- text: "Kicking off call 1.",
- turnId: firstTurnId,
- streaming: false,
- createdAt: "2026-04-01T00:00:09.000Z",
- updatedAt: "2026-04-01T00:00:09.000Z",
- },
- {
- id: MessageId.make("user-2"),
- role: "user",
- text: "Actually do 15.",
- turnId: null,
- streaming: false,
- createdAt: "2026-04-01T00:00:14.000Z",
- updatedAt: "2026-04-01T00:00:14.000Z",
- },
- {
- id: MessageId.make("assistant-next"),
- role: "assistant",
- text: "One down - adjusting.",
- turnId: secondTurnId,
- streaming: true,
- createdAt: "2026-04-01T00:00:17.000Z",
- updatedAt: "2026-04-01T00:00:17.000Z",
- },
- ],
- activities: [
- makeActivity({
- id: EventId.make("work-1"),
- kind: "tool.completed",
- tone: "tool",
- summary: "Ran command",
- createdAt: "2026-04-01T00:00:12.000Z",
- turnId: firstTurnId,
- payload: {
- title: "Ran command",
- itemType: "command_execution",
- status: "completed",
- },
- }),
- ],
- });
+ it("folds settled V2 run work while keeping the terminal assistant message visible", () => {
+ const feed = buildThreadFeed([
+ projected(userMessage(), 0),
+ projected(command(), 1),
+ projected(assistantMessage(), 2),
+ ]);
+ const latestRun = {
+ runId,
+ status: "completed" as const,
+ startedAt: "2026-06-20T00:00:01.000Z",
+ completedAt: "2026-06-20T00:00:03.000Z",
+ };
- const feed = buildThreadFeed(thread);
- const collapsed = deriveThreadFeedPresentation(feed, thread.latestTurn, new Set());
- expect(collapsed.find((entry) => entry.type === "turn-fold")).toMatchObject({
- turnId: firstTurnId,
- label: "Worked for 12s",
- });
+ const collapsed = deriveThreadFeedPresentation(feed, latestRun, new Set());
+ expect(collapsed.map((entry) => entry.type)).toEqual(["message", "run-fold", "message"]);
+
+ const expanded = deriveThreadFeedPresentation(feed, latestRun, new Set([runId]));
+ expect(expanded.map((entry) => entry.type)).toEqual([
+ "message",
+ "run-fold",
+ "activity-group",
+ "message",
+ ]);
});
- it("keeps an active turn expanded and classifies error-shaped tool output", () => {
- const turnId = TurnId.make("turn-running");
- const thread = makeThread({
- id: ThreadId.make("thread-4"),
- projectId: ProjectId.make("project-1"),
- title: "Running work",
- latestTurn: {
- turnId,
- state: "running",
- requestedAt: "2026-04-01T00:00:00.000Z",
- startedAt: "2026-04-01T00:00:01.000Z",
+ it("keeps an active run expanded and marks failed tools as failures", () => {
+ const failedCommand: OrchestrationV2TurnItem = {
+ ...command(),
+ status: "failed",
+ completedAt: DateTime.makeUnsafe("2026-06-20T00:00:02.000Z"),
+ };
+ const feed = buildThreadFeed([projected(userMessage(), 0), projected(failedCommand, 1)]);
+ const presented = deriveThreadFeedPresentation(
+ feed,
+ {
+ runId,
+ status: "running",
+ startedAt: "2026-06-20T00:00:01.000Z",
completedAt: null,
- assistantMessageId: null,
},
- activities: [
- makeActivity({
- id: EventId.make("tool-failed"),
- kind: "tool.completed",
- tone: "tool",
- summary: "Run command",
- createdAt: "2026-04-01T00:00:05.000Z",
- turnId,
- payload: {
- title: "Run command",
- itemType: "command_execution",
- detail: "zsh: command not found: nope",
- status: "completed",
- },
- }),
- ],
- });
+ new Set(),
+ );
- const feed = buildThreadFeed(thread);
- expect(deriveThreadFeedPresentation(feed, thread.latestTurn, new Set())).toEqual(feed);
- expect(feed[0]).toMatchObject({
- type: "activity-group",
- activities: [{ status: "failure" }],
- });
+ expect(presented.some((entry) => entry.type === "run-fold")).toBe(false);
+ expect(presented.find((entry) => entry.type === "activity-group")?.activities[0]?.status).toBe(
+ "failure",
+ );
});
it("appends active work as a normal timeline row", () => {
@@ -485,22 +342,25 @@ describe("buildThreadFeed", () => {
): ThreadFeedActivity => ({
id,
createdAt,
- turnId: null,
+ runId: null,
summary: `Tool ${id}`,
detail: null,
canExpand: false,
getFullDetail: () => null,
getCopyText: () => id,
icon: "command",
+ logo: null,
toolLike: true,
+ prominent: false,
status,
+ projectedItem: projected(command(createdAt), 0),
});
const feed: ThreadFeedEntry[] = [
{
type: "activity-group",
id: "work-group-1",
createdAt: "2026-04-01T00:00:01.000Z",
- turnId: null,
+ runId: null,
activities: [
activity("activity-1", "2026-04-01T00:00:01.000Z"),
activity("activity-neutral", "2026-04-01T00:00:02.000Z", "neutral"),
@@ -531,40 +391,21 @@ describe("buildThreadFeed", () => {
expanded: true,
});
});
-});
-describe("quiet timeline: nested agents", () => {
- it("keeps a nested agent's terminal row but hides its background work", () => {
- const thread = makeThread({
- id: ThreadId.make("thread-nested"),
- projectId: ProjectId.make("project-1"),
- title: "Nested agents",
- activities: [
- // A subagent's own shell: internal, covered by the owner's liveness.
- makeActivity({
- id: EventId.make("shell-done"),
- kind: "task.completed",
- summary: "Task completed",
- createdAt: "2026-04-01T00:00:02.000Z",
- payload: { taskId: "sh-1", agentId: "owner", agentKind: "background" },
- }),
- // A nested AGENT's completion: mobile has no Agents sheet, so this
- // terminal row is the only signal it ever finished.
- makeActivity({
- id: EventId.make("nested-done"),
- kind: "task.completed",
- summary: "Task completed",
- createdAt: "2026-04-01T00:00:03.000Z",
- payload: { taskId: "n-1", agentId: "owner", agentKind: "agent" },
- }),
- ],
- });
+ it("pretty prints T3 MCP dynamic tool activities and attaches the product logo", () => {
+ const toolItem: OrchestrationV2TurnItem = {
+ ...base("item-t3-tool", "2026-06-20T00:00:04.000Z", 3),
+ type: "dynamic_tool",
+ toolName: "mcp__t3-code__t3_thread_read",
+ input: { threadId: "thread-child" },
+ output: { messages: [] },
+ };
- const feed = buildThreadFeed(thread);
- const ids = feed.flatMap((entry) =>
- entry.type === "activity-group" ? entry.activities.map((row) => row.id) : [],
- );
- expect(ids).toContain("nested-done");
- expect(ids).not.toContain("shell-done");
+ const feed = buildThreadFeed([projected(toolItem, 0)]);
+ const activity = feed[0]?.type === "activity-group" ? feed[0].activities[0] : null;
+
+ expect(activity?.summary).toBe("Read a T3 thread");
+ expect(activity?.logo).toBe("t3-code");
+ expect(activity?.getCopyText().split("\n")[0]).toBe("Read a T3 thread");
});
});
diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts
index 886644bf83e..6742b60bf06 100644
--- a/apps/mobile/src/lib/threadActivity.ts
+++ b/apps/mobile/src/lib/threadActivity.ts
@@ -1,29 +1,33 @@
-import { ApprovalRequestId, isToolLifecycleItemType } from "@t3tools/contracts";
import type {
- OrchestrationLatestTurn,
- OrchestrationThread,
- OrchestrationThreadActivity,
- ToolLifecycleItemType,
- TurnId,
- UserInputQuestion,
+ ThreadPendingApproval,
+ ThreadPendingUserInput,
+ ThreadUserInputQuestion,
+} from "@t3tools/client-runtime/state/thread-requests";
+import { turnItemIsWorkspacePreparation } from "@t3tools/client-runtime/state/turn-item-presentation";
+import {
+ resolveT3McpToolPresentation,
+ type T3McpToolLogo,
+ type T3McpToolPresentation,
+} from "@t3tools/shared/t3McpToolPresentation";
+import type {
+ ChatAttachment,
+ MessageId,
+ OrchestrationV2Actor,
+ OrchestrationV2CreationSource,
+ OrchestrationV2ProjectedTurnItem,
+ OrchestrationV2RunStatus,
+ OrchestrationV2TurnItem,
+ OrchestrationV2UserMessageInputIntent,
+ RunId,
+ ThreadId,
} from "@t3tools/contracts";
import { formatDuration } from "@t3tools/shared/orchestrationTiming";
+import * as DateTime from "effect/DateTime";
-import * as Arr from "effect/Array";
-import * as Order from "effect/Order";
-
-export interface PendingApproval {
- readonly requestId: ApprovalRequestId;
- readonly requestKind: "command" | "file-read" | "file-change";
- readonly createdAt: string;
- readonly detail?: string;
-}
+export type PendingApproval = ThreadPendingApproval;
+export type PendingUserInput = ThreadPendingUserInput;
-export interface PendingUserInput {
- readonly requestId: ApprovalRequestId;
- readonly createdAt: string;
- readonly questions: ReadonlyArray;
-}
+const MAX_VISIBLE_WORK_LOG_ENTRIES = 1;
export interface PendingUserInputDraftAnswer {
readonly selectedOptionLabel?: string;
@@ -33,7 +37,7 @@ export interface PendingUserInputDraftAnswer {
export interface ThreadFeedActivity {
readonly id: string;
readonly createdAt: string;
- readonly turnId: TurnId | null;
+ readonly runId: RunId | null;
readonly summary: string;
readonly detail: string | null;
readonly canExpand: boolean;
@@ -52,36 +56,28 @@ export interface ThreadFeedActivity {
| "warning"
| "wrench"
| "zap";
+ readonly logo: T3McpToolLogo | null;
readonly toolLike: boolean;
+ readonly prominent: boolean;
readonly status: "success" | "failure" | "neutral" | null;
-}
-
-const MAX_VISIBLE_WORK_LOG_ENTRIES = 1;
-
-type WorkLogToolLifecycleStatus = "inProgress" | "completed" | "failed" | "declined" | "stopped";
-
-interface WorkLogEntry {
- id: string;
- createdAt: string;
- turnId: TurnId | null;
- label: string;
- detail?: string;
- command?: string;
- rawCommand?: string;
- changedFiles?: ReadonlyArray;
- tone: "thinking" | "tool" | "info" | "error";
- toolTitle?: string;
- itemType?: ToolLifecycleItemType;
- requestKind?: PendingApproval["requestKind"];
- toolLifecycleStatus?: WorkLogToolLifecycleStatus;
- toolData?: unknown;
-}
-
-interface DerivedWorkLogEntry extends WorkLogEntry {
- activityKind: OrchestrationThreadActivity["kind"];
- collapseKey?: string;
- /** Grouping key for subagent lifecycle rows (one row per agent). */
- taskId?: string;
+ readonly projectedItem: OrchestrationV2ProjectedTurnItem;
+}
+
+export interface ThreadFeedMessage {
+ readonly id: MessageId;
+ readonly role: "user" | "assistant";
+ readonly text: string;
+ readonly attachments: ReadonlyArray;
+ readonly runId: RunId | null;
+ readonly streaming: boolean;
+ readonly inputIntent?: OrchestrationV2UserMessageInputIntent;
+ readonly createdBy?: OrchestrationV2Actor;
+ readonly creationSource?: OrchestrationV2CreationSource;
+ readonly visibility: OrchestrationV2ProjectedTurnItem["visibility"];
+ readonly sourceThreadId: ThreadId;
+ readonly createdAt: string;
+ readonly updatedAt: string;
+ readonly projectedItem: OrchestrationV2ProjectedTurnItem;
}
type RawThreadFeedEntry =
@@ -89,13 +85,13 @@ type RawThreadFeedEntry =
readonly type: "message";
readonly id: string;
readonly createdAt: string;
- readonly message: OrchestrationThread["messages"][number];
+ readonly message: ThreadFeedMessage;
}
| {
readonly type: "activity";
readonly id: string;
readonly createdAt: string;
- readonly turnId: TurnId | null;
+ readonly runId: RunId | null;
readonly activity: ThreadFeedActivity;
};
@@ -110,119 +106,37 @@ export type ThreadFeedEntry =
readonly type: "activity-group";
readonly id: string;
readonly createdAt: string;
- readonly turnId: TurnId | null;
+ readonly runId: RunId | null;
readonly activities: ReadonlyArray;
}
| {
readonly type: "work-toggle";
readonly id: string;
readonly createdAt: string;
- readonly turnId: TurnId | null;
+ readonly runId: RunId | null;
readonly groupId: string;
readonly hiddenCount: number;
readonly expanded: boolean;
readonly onlyToolActivities: boolean;
}
| {
- readonly type: "turn-fold";
+ readonly type: "run-fold";
readonly id: string;
readonly createdAt: string;
- readonly turnId: TurnId;
+ readonly runId: RunId;
readonly label: string;
readonly expanded: boolean;
};
-export type ThreadFeedLatestTurn = Pick<
- OrchestrationLatestTurn,
- "turnId" | "state" | "startedAt" | "completedAt"
->;
-
-function requestKindFromRequestType(requestType: unknown): PendingApproval["requestKind"] | null {
- switch (requestType) {
- case "command_execution_approval":
- case "exec_command_approval":
- return "command";
- case "file_read_approval":
- return "file-read";
- case "file_change_approval":
- case "apply_patch_approval":
- return "file-change";
- default:
- return null;
- }
-}
-
-function isStalePendingRequestFailureDetail(detail: string | undefined): boolean {
- const normalized = detail?.toLowerCase();
- if (!normalized) {
- return false;
- }
- return (
- normalized.includes("stale pending approval request") ||
- normalized.includes("stale pending user-input request") ||
- normalized.includes("unknown pending approval request") ||
- normalized.includes("unknown pending permission request") ||
- normalized.includes("unknown pending user-input request")
- );
-}
-
-function parseApprovalRequestId(value: unknown): ApprovalRequestId | null {
- return typeof value === "string" && value.length > 0 ? ApprovalRequestId.make(value) : null;
-}
-
-function parseUserInputQuestions(
- payload: Record | null,
-): ReadonlyArray | null {
- const questions = payload?.questions;
- if (!Array.isArray(questions)) {
- return null;
- }
-
- const parsed = questions
- .map((entry) => {
- if (!entry || typeof entry !== "object") return null;
- const question = entry as Record;
- if (
- typeof question.id !== "string" ||
- typeof question.header !== "string" ||
- typeof question.question !== "string" ||
- !Array.isArray(question.options)
- ) {
- return null;
- }
- const options = question.options
- .map((option) => {
- if (!option || typeof option !== "object") return null;
- const record = option as Record;
- if (typeof record.label !== "string" || typeof record.description !== "string") {
- return null;
- }
- return {
- label: record.label,
- description: record.description,
- };
- })
- .filter((option): option is UserInputQuestion["options"][number] => option !== null);
- if (options.length === 0) {
- return null;
- }
- return {
- id: question.id,
- header: question.header,
- question: question.question,
- options,
- multiSelect: question.multiSelect === true,
- };
- })
- .filter((question): question is UserInputQuestion => question !== null);
-
- return parsed.length > 0 ? parsed : null;
+export interface ThreadFeedLatestRun {
+ readonly runId: RunId;
+ readonly status: OrchestrationV2RunStatus;
+ readonly startedAt: string | null;
+ readonly completedAt: string | null;
}
function normalizeDraftAnswer(value: string | undefined): string | null {
- if (typeof value !== "string") {
- return null;
- }
+ if (typeof value !== "string") return null;
const trimmed = value.trim();
return trimmed.length > 0 ? trimmed : null;
}
@@ -230,430 +144,14 @@ function normalizeDraftAnswer(value: string | undefined): string | null {
function resolvePendingUserInputAnswer(
draft: PendingUserInputDraftAnswer | undefined,
): string | null {
- const customAnswer = normalizeDraftAnswer(draft?.customAnswer);
- if (customAnswer) {
- return customAnswer;
- }
- return normalizeDraftAnswer(draft?.selectedOptionLabel);
-}
-
-/** Codex children settle via task.updated (idle/failed/interrupted), never
- * task.completed — these rows are mobile's only terminal signal for them. */
-const MOBILE_TERMINAL_UPDATE_STATUSES: ReadonlySet = new Set([
- "idle",
- "completed",
- "failed",
- "cancelled",
- "interrupted",
-]);
-
-function isTerminalBypassUpdate(activity: OrchestrationThreadActivity): boolean {
- if (activity.kind !== "task.updated") {
- return false;
- }
- const payload =
- activity.payload && typeof activity.payload === "object"
- ? (activity.payload as Record)
- : null;
return (
- payload?.timelineBypass === true &&
- typeof payload.status === "string" &&
- MOBILE_TERMINAL_UPDATE_STATUSES.has(payload.status)
+ normalizeDraftAnswer(draft?.customAnswer) ?? normalizeDraftAnswer(draft?.selectedOptionLabel)
);
}
-/**
- * Quiet-timeline guarantee (mirrors web's session-logic): agent-internal
- * activity lives in the Agents sheet, not the work log. Terminal rows are
- * kept — with no Agents surface on mobile they are the terminal signal
- * (a surface that hides rows must keep its own terminal signal). That means
- * task.completed (Claude) AND terminal bypassed task.updated (Codex, whose
- * children never emit task.completed — review finding).
- */
-function isAgentInternalActivity(activity: OrchestrationThreadActivity): boolean {
- const payload =
- activity.payload && typeof activity.payload === "object"
- ? (activity.payload as Record)
- : null;
- if (!payload) {
- return false;
- }
- const isTerminalTaskRow = activity.kind === "task.completed" || isTerminalBypassUpdate(activity);
- if (payload.timelineBypass === true && !isTerminalTaskRow) {
- return true;
- }
- // agentId marks ownership, not "hide me": a NESTED AGENT's terminal row is
- // the only signal mobile gets (no Agents sheet), so it stays. Only an
- // agent's own background work (stamped "background") is internal — same
- // rule as web (review finding: hiding on agentId alone dropped nested
- // completions with no replacement UI).
- const ownedByAgent = typeof payload.agentId === "string" && payload.agentId.trim().length > 0;
- if (!ownedByAgent) {
- return false;
- }
- return !(isTerminalTaskRow && payload.agentKind === "agent");
-}
-
-function deriveWorkLogEntries(
- activities: ReadonlyArray,
-): DerivedWorkLogEntry[] {
- const ordered = Arr.sort(activities, activityOrder);
- const entries: DerivedWorkLogEntry[] = [];
- for (const activity of ordered) {
- if (activity.kind === "tool.started") continue;
- if (activity.kind === "task.started") continue;
- // Terminal bypassed updates pass: Codex children's only terminal signal.
- if (activity.kind === "task.updated" && !isTerminalBypassUpdate(activity)) continue;
- if (activity.kind === "tool.progress") continue;
- if (activity.kind === "context-window.updated") continue;
- if (activity.summary === "Checkpoint captured") continue;
- if (isPlanBoundaryToolActivity(activity)) continue;
- if (isAgentInternalActivity(activity)) continue;
- entries.push(toDerivedWorkLogEntry(activity));
- }
- return collapseDerivedWorkLogEntries(entries);
-}
-
-function isPlanBoundaryToolActivity(activity: OrchestrationThreadActivity): boolean {
- if (activity.kind !== "tool.updated" && activity.kind !== "tool.completed") {
- return false;
- }
-
- const payload =
- activity.payload && typeof activity.payload === "object"
- ? (activity.payload as Record)
- : null;
- return typeof payload?.detail === "string" && payload.detail.startsWith("ExitPlanMode:");
-}
-
-function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWorkLogEntry {
- const payload =
- activity.payload && typeof activity.payload === "object"
- ? (activity.payload as Record)
- : null;
- const commandPreview = extractToolCommand(payload);
- const changedFiles = extractChangedFiles(payload);
- const title = extractToolTitle(payload);
- // task.updated included: terminal bypassed updates (Codex children's only
- // terminal signal) must carry task identity so they collapse per child
- // instead of stacking anonymous "Task idle" rows.
- const isTaskActivity =
- activity.kind === "task.progress" ||
- activity.kind === "task.completed" ||
- activity.kind === "task.updated";
- const taskSummary =
- isTaskActivity && typeof payload?.summary === "string" && payload.summary.length > 0
- ? payload.summary
- : null;
- const taskDetailAsLabel =
- isTaskActivity &&
- !taskSummary &&
- typeof payload?.detail === "string" &&
- payload.detail.length > 0
- ? payload.detail
- : null;
- const taskLabel = taskSummary || taskDetailAsLabel;
- const taskId =
- isTaskActivity && typeof payload?.taskId === "string" && payload.taskId.length > 0
- ? payload.taskId
- : undefined;
- const entry: DerivedWorkLogEntry = {
- id: activity.id,
- createdAt: activity.createdAt,
- turnId: activity.turnId,
- ...(taskId ? { taskId } : {}),
- label: taskLabel || activity.summary,
- tone:
- activity.kind === "task.progress"
- ? "thinking"
- : activity.tone === "approval"
- ? "info"
- : activity.tone,
- activityKind: activity.kind,
- };
- const itemType = extractWorkLogItemType(payload);
- const requestKind = extractWorkLogRequestKind(payload);
- if (
- !taskDetailAsLabel &&
- payload &&
- typeof payload.detail === "string" &&
- payload.detail.length > 0
- ) {
- const detail = stripTrailingExitCode(payload.detail).output;
- if (detail) {
- entry.detail = detail;
- }
- }
- if (commandPreview.command) {
- entry.command = commandPreview.command;
- }
- if (commandPreview.rawCommand) {
- entry.rawCommand = commandPreview.rawCommand;
- }
- if (changedFiles.length > 0) {
- entry.changedFiles = changedFiles;
- }
- if (title) {
- entry.toolTitle = title;
- }
- if (itemType === "mcp_tool_call") {
- const data = asRecord(payload?.data);
- if (data?.item !== undefined) {
- entry.toolData = data.item;
- }
- }
- if (itemType) {
- entry.itemType = itemType;
- }
- if (requestKind) {
- entry.requestKind = requestKind;
- }
- let toolLifecycleStatus = extractWorkLogToolLifecycleStatus(payload);
- if (!toolLifecycleStatus && activity.kind === "tool.completed") {
- toolLifecycleStatus = "completed";
- }
- if (toolLifecycleStatus) {
- entry.toolLifecycleStatus = toolLifecycleStatus;
- }
- const collapseKey = deriveToolLifecycleCollapseKey(entry);
- if (collapseKey) {
- entry.collapseKey = collapseKey;
- }
- return entry;
-}
-
-function collapseDerivedWorkLogEntries(
- entries: ReadonlyArray,
-): DerivedWorkLogEntry[] {
- const collapsed: DerivedWorkLogEntry[] = [];
- // Subagent rows collapse by identity, not adjacency (quiet-timeline
- // guarantee; mirrors web's session-logic).
- const taskRowIndex = new Map();
- for (const entry of entries) {
- const isTaskRow =
- entry.taskId !== undefined &&
- (entry.activityKind === "task.progress" ||
- entry.activityKind === "task.completed" ||
- entry.activityKind === "task.updated");
- if (isTaskRow && entry.taskId !== undefined) {
- const existingIndex = taskRowIndex.get(entry.taskId);
- if (existingIndex !== undefined) {
- collapsed[existingIndex] = mergeDerivedWorkLogEntries(collapsed[existingIndex]!, entry);
- continue;
- }
- taskRowIndex.set(entry.taskId, collapsed.length);
- collapsed.push(entry);
- continue;
- }
- const previous = collapsed.at(-1);
- if (previous && shouldCollapseToolLifecycleEntries(previous, entry)) {
- collapsed[collapsed.length - 1] = mergeDerivedWorkLogEntries(previous, entry);
- continue;
- }
- collapsed.push(entry);
- }
- return collapsed;
-}
-
-function shouldCollapseToolLifecycleEntries(
- previous: DerivedWorkLogEntry,
- next: DerivedWorkLogEntry,
-): boolean {
- if (previous.activityKind !== "tool.updated" && previous.activityKind !== "tool.completed") {
- return false;
- }
- if (next.activityKind !== "tool.updated" && next.activityKind !== "tool.completed") {
- return false;
- }
- if (previous.activityKind === "tool.completed") {
- return false;
- }
- return previous.collapseKey !== undefined && previous.collapseKey === next.collapseKey;
-}
-
-function mergeDerivedWorkLogEntries(
- previous: DerivedWorkLogEntry,
- next: DerivedWorkLogEntry,
-): DerivedWorkLogEntry {
- const changedFiles = mergeChangedFiles(previous.changedFiles, next.changedFiles);
- const detail = next.detail ?? previous.detail;
- const command = next.command ?? previous.command;
- const rawCommand = next.rawCommand ?? previous.rawCommand;
- const toolTitle = next.toolTitle ?? previous.toolTitle;
- const itemType = next.itemType ?? previous.itemType;
- const requestKind = next.requestKind ?? previous.requestKind;
- const collapseKey = next.collapseKey ?? previous.collapseKey;
- const toolLifecycleStatus = next.toolLifecycleStatus ?? previous.toolLifecycleStatus;
- const toolData = next.toolData ?? previous.toolData;
- return {
- ...previous,
- ...next,
- ...(detail ? { detail } : {}),
- ...(command ? { command } : {}),
- ...(rawCommand ? { rawCommand } : {}),
- ...(changedFiles.length > 0 ? { changedFiles } : {}),
- ...(toolTitle ? { toolTitle } : {}),
- ...(itemType ? { itemType } : {}),
- ...(requestKind ? { requestKind } : {}),
- ...(collapseKey ? { collapseKey } : {}),
- ...(toolLifecycleStatus ? { toolLifecycleStatus } : {}),
- ...(toolData !== undefined ? { toolData } : {}),
- };
-}
-
-function mergeChangedFiles(
- previous: ReadonlyArray | undefined,
- next: ReadonlyArray | undefined,
-): string[] {
- const merged = [...(previous ?? []), ...(next ?? [])];
- if (merged.length === 0) {
- return [];
- }
- return [...new Set(merged)];
-}
-
-function deriveToolLifecycleCollapseKey(entry: DerivedWorkLogEntry): string | undefined {
- if (entry.activityKind !== "tool.updated" && entry.activityKind !== "tool.completed") {
- return undefined;
- }
- const normalizedLabel = normalizeCompactToolLabel(entry.toolTitle ?? entry.label);
- const detail = entry.detail?.trim() ?? "";
- const itemType = entry.itemType ?? "";
- if (normalizedLabel.length === 0 && detail.length === 0 && itemType.length === 0) {
- return undefined;
- }
- return [itemType, normalizedLabel, detail].join("\u001f");
-}
-
-function normalizeCompactToolLabel(value: string): string {
- return value.replace(/\s+(?:complete|completed)\s*$/i, "").trim();
-}
-
-function workLogEntryIsToolLike(entry: WorkLogEntry): boolean {
- if (entry.tone === "tool" || entry.tone === "thinking" || entry.tone === "error") {
- return true;
- }
- if (entry.command !== undefined && entry.command.trim().length > 0) {
- return true;
- }
- if (entry.requestKind !== undefined) {
- return true;
- }
- return entry.itemType !== undefined && isToolLifecycleItemType(entry.itemType);
-}
-
-function toolDetailTextLooksLikeFailure(text: string): boolean {
- const normalized = text.toLowerCase();
- return (
- normalized.includes("file not found") ||
- normalized.includes("no files found") ||
- normalized.includes("enoent") ||
- normalized.includes("no such file or directory") ||
- normalized.includes("no such file") ||
- normalized.includes("commandnotfoundexception") ||
- normalized.includes("command not found") ||
- (normalized.includes("cannot find path") && normalized.includes("because it does not exist")) ||
- (normalized.includes("is not recognized") && normalized.includes("the term '")) ||
- //i.test(text) ||
- /exit(?:ed)? with exit code\s+[1-9]\d*/i.test(text) ||
- /exit code\s*[:\s]\s*[1-9]\d*\b/i.test(text)
- );
-}
-
-function workEntryIndicatesToolFailure(entry: WorkLogEntry): boolean {
- if (entry.tone === "error") {
- return true;
- }
- if (entry.toolLifecycleStatus === "failed" || entry.toolLifecycleStatus === "declined") {
- return true;
- }
- if (!workLogEntryIsToolLike(entry)) {
- return false;
- }
- return toolDetailTextLooksLikeFailure([entry.detail, entry.command].filter(Boolean).join("\n"));
-}
-
-function workEntryIndicatesToolSuccess(entry: WorkLogEntry): boolean {
- if (!workLogEntryIsToolLike(entry) || workEntryIndicatesToolFailure(entry)) {
- return false;
- }
- if (entry.tone === "thinking") {
- return false;
- }
- return (
- entry.toolLifecycleStatus !== "inProgress" &&
- entry.toolLifecycleStatus !== "stopped" &&
- entry.toolLifecycleStatus !== "failed" &&
- entry.toolLifecycleStatus !== "declined"
- );
-}
-
-function workEntryStatus(entry: WorkLogEntry): ThreadFeedActivity["status"] {
- if (!workLogEntryIsToolLike(entry)) {
- return null;
- }
- if (workEntryIndicatesToolFailure(entry)) {
- return "failure";
- }
- if (workEntryIndicatesToolSuccess(entry)) {
- return "success";
- }
- return "neutral";
-}
-
-function workEntryIcon(entry: DerivedWorkLogEntry): ThreadFeedActivity["icon"] {
- if (
- entry.activityKind === "user-input.requested" ||
- entry.activityKind === "user-input.resolved"
- ) {
- return "message";
- }
- if (entry.activityKind === "runtime.warning") return "warning";
- if (entry.requestKind === "command") return "command";
- if (entry.requestKind === "file-read") return "eye";
- if (entry.requestKind === "file-change") return "edit";
- if (entry.itemType === "command_execution" || entry.command) return "command";
- if (entry.itemType === "file_change" || (entry.changedFiles?.length ?? 0) > 0) return "edit";
- if (entry.itemType === "web_search") return "globe";
- if (entry.itemType === "image_view") return "eye";
- if (entry.itemType === "mcp_tool_call") return "wrench";
- if (entry.itemType === "dynamic_tool_call" || entry.itemType === "collab_agent_tool_call") {
- return "hammer";
- }
- if (entry.tone === "error") return "alert";
- if (entry.tone === "thinking") return "agent";
- if (entry.tone === "info") return "check";
- return "zap";
-}
-
-function buildWorkEntryExpandedBody(entry: WorkLogEntry): string | null {
- const blocks: string[] = [];
- const appendUniqueBlock = (value: string | null | undefined) => {
- const trimmed = value?.trim();
- if (trimmed && !blocks.includes(trimmed)) {
- blocks.push(trimmed);
- }
- };
-
- if (entry.itemType === "mcp_tool_call" && entry.toolData !== undefined) {
- appendUniqueBlock(`MCP call\n${JSON.stringify(entry.toolData, null, 2)}`);
- }
- appendUniqueBlock(entry.rawCommand ?? entry.command);
- appendUniqueBlock(entry.detail);
- if ((entry.changedFiles?.length ?? 0) > 0) {
- appendUniqueBlock(entry.changedFiles!.join("\n"));
- }
-
- return blocks.length > 0 ? blocks.join("\n\n") : null;
-}
-
-function workEntryHasExpandedBody(entry: WorkLogEntry): boolean {
- return (
- (entry.itemType === "mcp_tool_call" && entry.toolData !== undefined) ||
- Boolean((entry.rawCommand ?? entry.command)?.trim()) ||
- Boolean(entry.detail?.trim()) ||
- (entry.changedFiles?.some((path) => path.trim().length > 0) ?? false)
- );
+function capitalizePhrase(value: string): string {
+ const trimmed = value.trim();
+ return trimmed.length === 0 ? value : `${trimmed.charAt(0).toUpperCase()}${trimmed.slice(1)}`;
}
function memoizeValue(build: () => T): () => T {
@@ -668,383 +166,222 @@ function memoizeValue(build: () => T): () => T {
};
}
-function workEntryPreview(
- workEntry: Pick,
-): string | null {
- if (workEntry.command) return workEntry.command;
- if (workEntry.detail) return workEntry.detail;
- if ((workEntry.changedFiles?.length ?? 0) === 0) return null;
- const [firstPath] = workEntry.changedFiles ?? [];
- if (!firstPath) return null;
- return workEntry.changedFiles!.length === 1
- ? firstPath
- : `${firstPath} +${workEntry.changedFiles!.length - 1} more`;
-}
-
-function capitalizePhrase(value: string): string {
- const trimmed = value.trim();
- if (trimmed.length === 0) {
- return value;
- }
- return `${trimmed.charAt(0).toUpperCase()}${trimmed.slice(1)}`;
-}
-
-function workEntryHeading(workEntry: WorkLogEntry): string {
- if (!workEntry.toolTitle) {
- return capitalizePhrase(normalizeCompactToolLabel(workEntry.label));
- }
- return capitalizePhrase(normalizeCompactToolLabel(workEntry.toolTitle));
-}
-
-function asRecord(value: unknown): Record | null {
- return value && typeof value === "object" ? (value as Record) : null;
-}
-
-function asTrimmedString(value: unknown): string | null {
- if (typeof value !== "string") {
- return null;
- }
- const trimmed = value.trim();
- return trimmed.length > 0 ? trimmed : null;
+function itemIsToolLike(item: OrchestrationV2TurnItem): boolean {
+ return (
+ item.type === "reasoning" ||
+ item.type === "command_execution" ||
+ item.type === "file_change" ||
+ item.type === "file_search" ||
+ item.type === "web_search" ||
+ item.type === "approval_request" ||
+ item.type === "user_input_request" ||
+ item.type === "dynamic_tool" ||
+ item.type === "subagent" ||
+ item.type === "error"
+ );
}
-function trimMatchingOuterQuotes(value: string): string {
- const trimmed = value.trim();
- if (
- (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
- (trimmed.startsWith('"') && trimmed.endsWith('"'))
- ) {
- const unquoted = trimmed.slice(1, -1).trim();
- return unquoted.length > 0 ? unquoted : trimmed;
- }
- return trimmed;
+function itemIsProminent(item: OrchestrationV2TurnItem): boolean {
+ return item.type === "fork" || item.type === "thread_created" || item.type === "subagent";
}
-function executableBasename(value: string): string | null {
- const trimmed = trimMatchingOuterQuotes(value);
- if (trimmed.length === 0) {
- return null;
- }
- const normalized = trimmed.replace(/\\/g, "/");
- const segments = normalized.split("/");
- const last = segments.at(-1)?.trim() ?? "";
- return last.length > 0 ? last.toLowerCase() : null;
+function itemStatus(item: OrchestrationV2TurnItem): ThreadFeedActivity["status"] {
+ if (!itemIsToolLike(item)) return null;
+ if (item.type === "error" || item.status === "failed") return "failure";
+ return item.status === "completed" ? "success" : "neutral";
}
-function splitExecutableAndRest(value: string): { executable: string; rest: string } | null {
- const trimmed = value.trim();
- if (trimmed.length === 0) {
+function itemIcon(item: OrchestrationV2TurnItem): ThreadFeedActivity["icon"] {
+ switch (item.type) {
+ case "reasoning":
+ return "agent";
+ case "command_execution":
+ return "command";
+ case "file_change":
+ return "edit";
+ case "file_search":
+ return "eye";
+ case "web_search":
+ return "globe";
+ case "approval_request":
+ case "user_input_request":
+ case "user_message":
+ case "assistant_message":
+ return "message";
+ case "dynamic_tool":
+ return "wrench";
+ case "subagent":
+ return "hammer";
+ case "run_interrupt_request":
+ case "run_interrupt_result":
+ return "warning";
+ case "error":
+ return "alert";
+ case "checkpoint":
+ case "proposed_plan":
+ case "todo_list":
+ return "check";
+ case "compaction":
+ case "handoff":
+ case "fork":
+ case "thread_created":
+ return "zap";
+ }
+}
+
+function itemToolPresentation(item: OrchestrationV2TurnItem): T3McpToolPresentation | null {
+ if (item.type !== "dynamic_tool") {
return null;
}
-
- if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
- const quote = trimmed.charAt(0);
- const closeIndex = trimmed.indexOf(quote, 1);
- if (closeIndex <= 0) {
+ return resolveT3McpToolPresentation(item.toolName) ?? resolveT3McpToolPresentation(item.title);
+}
+
+function itemSummary(
+ item: OrchestrationV2TurnItem,
+ toolPresentation: T3McpToolPresentation | null = null,
+): string {
+ const title = item.title?.trim();
+ if (title) return toolPresentation?.displayName ?? capitalizePhrase(title);
+ switch (item.type) {
+ case "reasoning":
+ return "Thinking";
+ case "command_execution":
+ return "Command";
+ case "file_change":
+ return `Changed ${item.fileName}`;
+ case "file_search":
+ return "Searched files";
+ case "web_search":
+ return "Searched the web";
+ case "approval_request":
+ return "Approval requested";
+ case "user_input_request":
+ return "Input requested";
+ case "checkpoint":
+ return "Checkpoint captured";
+ case "run_interrupt_request":
+ return "Interrupt requested";
+ case "run_interrupt_result":
+ return "Run interrupted";
+ case "error":
+ return "Provider error";
+ case "compaction":
+ return "Context compacted";
+ case "handoff":
+ return "Context handed off";
+ case "fork":
+ return "Thread forked";
+ case "thread_created":
+ return "Thread created";
+ case "subagent":
+ return "Subagent";
+ case "dynamic_tool":
+ return toolPresentation?.displayName ?? item.toolName ?? "Tool call";
+ case "proposed_plan":
+ return "Proposed plan";
+ case "todo_list":
+ return "Plan updated";
+ case "user_message":
+ return "User message";
+ case "assistant_message":
+ return "Assistant message";
+ }
+}
+
+function itemPreview(item: OrchestrationV2TurnItem): string | null {
+ switch (item.type) {
+ case "reasoning":
+ return item.text || null;
+ case "command_execution":
+ return item.input || null;
+ case "file_change":
+ return item.fileName;
+ case "file_search":
+ return item.pattern ?? null;
+ case "web_search":
+ return item.patterns?.join(", ") ?? null;
+ case "approval_request":
+ return item.prompt ?? null;
+ case "user_input_request":
+ return item.questions.map((question) => question.question).join(" · ") || null;
+ case "checkpoint":
+ return item.files.length === 1
+ ? (item.files[0]?.path ?? null)
+ : `${item.files.length} changed files`;
+ case "run_interrupt_request":
+ case "run_interrupt_result":
+ return item.message || null;
+ case "error":
+ return item.failure.message;
+ case "compaction":
+ case "handoff":
+ return item.summary ?? null;
+ case "fork":
+ case "thread_created":
+ return item.targetThreadId;
+ case "subagent":
+ return item.result ?? item.progress ?? item.prompt;
+ case "dynamic_tool":
return null;
- }
- return {
- executable: trimmed.slice(0, closeIndex + 1),
- rest: trimmed.slice(closeIndex + 1).trim(),
- };
- }
-
- const firstWhitespace = trimmed.search(/\s/);
- if (firstWhitespace < 0) {
- return {
- executable: trimmed,
- rest: "",
- };
- }
-
- return {
- executable: trimmed.slice(0, firstWhitespace),
- rest: trimmed.slice(firstWhitespace).trim(),
- };
-}
-
-const SHELL_WRAPPER_SPECS = [
- {
- executables: ["pwsh", "pwsh.exe", "powershell", "powershell.exe"],
- wrapperFlagPattern: /(?:^|\s)-command\s+/i,
- },
- {
- executables: ["cmd", "cmd.exe"],
- wrapperFlagPattern: /(?:^|\s)\/c\s+/i,
- },
- {
- executables: ["bash", "sh", "zsh"],
- wrapperFlagPattern: /(?:^|\s)-(?:l)?c\s+/i,
- },
-] as const;
-
-function findShellWrapperSpec(shell: string) {
- return SHELL_WRAPPER_SPECS.find((spec) =>
- (spec.executables as ReadonlyArray).includes(shell),
+ case "proposed_plan":
+ return item.markdown || null;
+ case "todo_list":
+ return `${item.steps.filter((step) => step.status === "completed").length}/${item.steps.length} completed`;
+ case "user_message":
+ case "assistant_message":
+ return item.text || null;
+ }
+}
+
+function toFeedActivity(row: OrchestrationV2ProjectedTurnItem): ThreadFeedActivity {
+ const item = row.item;
+ const toolPresentation = itemToolPresentation(item);
+ const summary = itemSummary(item, toolPresentation);
+ const detail = itemPreview(item);
+ const getFullDetail = memoizeValue(() =>
+ JSON.stringify(
+ {
+ visibility: row.visibility,
+ sourceThreadId: row.sourceThreadId,
+ sourceItemId: row.sourceItemId,
+ item,
+ },
+ null,
+ 2,
+ ),
);
-}
-
-function unwrapCommandRemainder(value: string, wrapperFlagPattern: RegExp): string | null {
- const match = wrapperFlagPattern.exec(value);
- if (!match) {
- return null;
- }
-
- const command = value.slice(match.index + match[0].length).trim();
- if (command.length === 0) {
- return null;
- }
-
- const unwrapped = trimMatchingOuterQuotes(command);
- return unwrapped.length > 0 ? unwrapped : null;
-}
-
-function unwrapKnownShellCommandWrapper(value: string): string {
- const split = splitExecutableAndRest(value);
- if (!split || split.rest.length === 0) {
- return value;
- }
-
- const shell = executableBasename(split.executable);
- if (!shell) {
- return value;
- }
-
- const spec = findShellWrapperSpec(shell);
- if (!spec) {
- return value;
- }
-
- return unwrapCommandRemainder(split.rest, spec.wrapperFlagPattern) ?? value;
-}
-
-function formatCommandArrayPart(value: string): string {
- return /[\s"'`]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
-}
-
-function formatCommandValue(value: unknown): string | null {
- const direct = asTrimmedString(value);
- if (direct) {
- return direct;
- }
- if (!Array.isArray(value)) {
- return null;
- }
- const parts: Array = [];
- for (const entry of value) {
- const part = asTrimmedString(entry);
- if (part !== null) {
- parts.push(part);
- }
- }
- if (parts.length === 0) {
- return null;
- }
- return parts.map((part) => formatCommandArrayPart(part)).join(" ");
-}
-
-function normalizeCommandValue(value: unknown): string | null {
- const formatted = formatCommandValue(value);
- return formatted ? unwrapKnownShellCommandWrapper(formatted) : null;
-}
-
-function toRawToolCommand(value: unknown, normalizedCommand: string | null): string | null {
- const formatted = formatCommandValue(value);
- if (!formatted || normalizedCommand === null) {
- return null;
- }
- return formatted === normalizedCommand ? null : formatted;
-}
-
-function extractToolCommand(payload: Record | null): {
- command: string | null;
- rawCommand: string | null;
-} {
- const data = asRecord(payload?.data);
- const item = asRecord(data?.item);
- const itemResult = asRecord(item?.result);
- const itemInput = asRecord(item?.input);
- const itemType = asTrimmedString(payload?.itemType);
- const detail = asTrimmedString(payload?.detail);
- const candidates: unknown[] = [
- item?.command,
- itemInput?.command,
- itemResult?.command,
- data?.command,
- itemType === "command_execution" && detail ? stripTrailingExitCode(detail).output : null,
- ];
-
- for (const candidate of candidates) {
- const command = normalizeCommandValue(candidate);
- if (!command) {
- continue;
- }
- return {
- command,
- rawCommand: toRawToolCommand(candidate, command),
- };
- }
-
- return {
- command: null,
- rawCommand: null,
- };
-}
-
-function extractToolTitle(payload: Record | null): string | null {
- return asTrimmedString(payload?.title);
-}
-
-function extractWorkLogToolLifecycleStatus(
- payload: Record | null,
-): WorkLogToolLifecycleStatus | undefined {
- const status = payload?.status;
- if (
- status === "inProgress" ||
- status === "completed" ||
- status === "failed" ||
- status === "declined" ||
- status === "stopped"
- ) {
- return status;
- }
- return undefined;
-}
-
-function stripTrailingExitCode(value: string): {
- output: string | null;
- exitCode?: number | undefined;
-} {
- const trimmed = value.trim();
- const match = /^(?