Separate user conversation from agent coordination

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

@@ -156,6 +156,9 @@ export function NewTaskDraftScreen(props: {
   const [creationMetadata] = useState(makeTurnCommandMetadata);
   const projects = useProjects();
   const flow = useNewTaskFlow();
+  const [communicationLanesOptIn, setCommunicationLanesOptIn] = useState(
+    flow.editingPendingTask?.creation?.communicationLanesEnabled === true,
+  );
   const navigation = useNavigation();
   const goBack = useWorkspaceBackNavigation("threads");
   const {
@@ -183,6 +186,13 @@ export function NewTaskDraftScreen(props: {
   const selectedEnvironmentServerConfig = useEnvironmentServerConfig(
     selectedProject?.environmentId ?? null,
   );
+  const supportsCommunicationLanes =
+    selectedEnvironmentServerConfig?.environment.capabilities.communicationLanes === true &&
+    selectedEnvironmentServerConfig.providers.some(
+      (provider) =>
+        provider.instanceId === flow.selectedModel?.instanceId &&
+        provider.communicationLanes === true,
+    );
   const environmentConnected = connectionState === "connected";
   const canOperate = useEnvironmentScope(
     selectedProject?.environmentId ?? null,
@@ -913,12 +923,36 @@ export function NewTaskDraftScreen(props: {
     const message = flow.buildPendingTaskMessage(metadata, {
       currentCheckoutBranch: queuesInsteadOfStarting ? null : flow.currentCheckoutBranchName,
     });
-    if (!message) {
+    const creation = message?.creation;
+    if (!message || !creation) {
+      return null;
+    }
+    const selectedProviderSupportsCommunicationLanes =
+      selectedEnvironmentServerConfig?.environment.capabilities.communicationLanes === true &&
+      selectedEnvironmentServerConfig.providers.some(
+        (provider) =>
+          provider.instanceId === modelSelection.instanceId && provider.communicationLanes === true,
+      );
+    if (communicationLanesOptIn && !selectedProviderSupportsCommunicationLanes) {
+      Dialog.alert(
+        "Agent messages can't be separated",
+        "The selected provider can't keep agent-to-agent messages in the work log. Choose another provider or turn the switch off.",
+      );
       return null;
     }
     // Persist locally before clearing or leaving the draft; server setup runs on the thread.
     flow.setSubmitting(true);
-    const queued = await settlePromise(() => enqueueThreadOutboxMessage(message));
+    const queued = await settlePromise(() =>
+      enqueueThreadOutboxMessage({
+        ...message,
+        creation: {
+          ...creation,
+          ...(selectedProviderSupportsCommunicationLanes && communicationLanesOptIn
+            ? { communicationLanesEnabled: true }
+            : {}),
+        },
+      }),
+    );
     flow.setSubmitting(false);
     if (AsyncResult.isFailure(queued)) {
       const error = squashAtomCommandFailure(queued);
@@ -1186,6 +1220,16 @@ export function NewTaskDraftScreen(props: {
                 </View>
               ) : null}
               {flow.canChooseWorkspace ? workspaceControls : null}
+              {supportsCommunicationLanes ? (
+                <ComposerInlineControl
+                  accessibilityLabel="Keep agent-to-agent messages in the work log"
+                  label={`Agent messages: ${communicationLanesOptIn ? "Work log" : "Chat"}`}
+                  selected={communicationLanesOptIn}
+                  disabled={isComposerInteractionLocked}
+                  showChevron={false}
+                  onPress={() => setCommunicationLanesOptIn((enabled) => !enabled)}
+                />
+              ) : null}
             </View>
           ),
           editorRef: promptInputRef,

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

@@ -223,6 +223,7 @@ export interface ThreadDetailScreenProps {
   readonly feedbackSubmissions: ReadonlyArray<CodexFeedbackSubmission>;
   readonly onDismissFeedback: (id: MessageId) => void;
   readonly selectedThreadFeed: ReadonlyArray<ThreadFeedEntry>;
+  readonly finishedWithoutUserUpdate?: boolean;
   readonly pendingHandoff?: HandoffEndpoints | null;
   readonly activityRun: ThreadFeedLatestRun | null;
   readonly activeWorkStartedAt: string | null;
@@ -1292,6 +1293,7 @@ function ThreadDetailBody(props: ThreadDetailScreenProps) {
               threadId={props.selectedThread.id}
               workspaceRoot={props.threadCwd}
               feed={props.selectedThreadFeed}
+              finishedWithoutUserUpdate={props.finishedWithoutUserUpdate === true}
               pendingHandoff={props.pendingHandoff}
               worktreeSetup={props.worktreeSetup}
               setupWorkingStartedAt={props.setupWorkingStartedAt}

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

@@ -35,6 +35,10 @@ import {
   resolveUserMessagePresentation,
 } from "@t3tools/client-runtime/user-message";
 import { canForkProjectedAssistantItem } from "@t3tools/client-runtime/state/thread-workflows";
+import {
+  FINISHED_WITHOUT_USER_UPDATE_NOTICE,
+  pendingDeliveryLabel,
+} from "@t3tools/client-runtime/state/thread-communication";
 import type { ThreadCheckpointSummary } from "@t3tools/client-runtime/state/thread-checkpoints";
 import { formatDiffCount } from "@t3tools/client-runtime/diff-count";
 import type { WorkflowOpening } from "@t3tools/client-runtime/state/subagentRuntime";
@@ -335,6 +339,7 @@ export interface ThreadFeedProps {
   readonly threadTitle: string;
   readonly workspaceRoot?: string | null;
   readonly feed: ReadonlyArray<ThreadFeedEntry>;
+  readonly finishedWithoutUserUpdate?: boolean;
   readonly pendingHandoff?: HandoffEndpoints | null;
   readonly contentPresentation: ThreadContentPresentation;
   readonly agentLabel: string;
@@ -1523,6 +1528,9 @@ function renderFeedEntry(
       const foldExpanded = foldRowId !== null && (props.expandedWorkRows[foldRowId] ?? false);
       const bubbleBodyVisible = foldRowId === null || foldExpanded;
       const intentBadge = resolveUserMessageIntentBadge(message.inputIntent);
+      const deliveryLabel = pendingDeliveryLabel(
+        message.projectedItem?.item.communication?.delivery,
+      );
       const referenceIds = new Set(
         collectComposerContextReferences(message.text).map((reference) => reference.contextId),
       );
@@ -1697,7 +1705,9 @@ function renderFeedEntry(
                 </Text>
               ) : null}
               <Text className="font-t3-medium text-xs tabular-nums text-foreground-secondary">
-                {entry.pendingMessage && !entry.acknowledged ? "Pending" : timestampLabel}
+                {entry.pendingMessage && !entry.acknowledged
+                  ? "Pending on device"
+                  : (deliveryLabel ?? timestampLabel)}
               </Text>
               {props.onEditPendingMessage !== null &&
               entry.pendingMessage &&
@@ -3252,15 +3262,22 @@ export const ThreadFeed = memo(function ThreadFeed({
               </>
             }
             ListFooterComponent={
-              props.pendingHandoff ? (
-                <ThreadHandoffDivider
-                  environmentId={props.environmentId}
-                  endpoints={props.pendingHandoff}
-                  iconColor={iconSubtleColor}
-                  surfaceColor={screenColor}
-                  label="Context handoff pending"
-                />
-              ) : null
+              <>
+                {props.pendingHandoff ? (
+                  <ThreadHandoffDivider
+                    environmentId={props.environmentId}
+                    endpoints={props.pendingHandoff}
+                    iconColor={iconSubtleColor}
+                    surfaceColor={screenColor}
+                    label="Context handoff pending"
+                  />
+                ) : null}
+                {props.finishedWithoutUserUpdate ? (
+                  <Text className="py-2 text-xs text-foreground-muted">
+                    {FINISHED_WITHOUT_USER_UPDATE_NOTICE}
+                  </Text>
+                ) : null}
+              </>
             }
             contentContainerStyle={{
               paddingTop: FEED_PADDING_TOP,

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

@@ -198,7 +198,13 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
               if (busyRef.current) return;
               busyRef.current = true;
               setResuming(true);
-              await resume({ ...target, input: { threadId: target.threadId } });
+              const heldRun = queuedRuns.find(({ run }) => run.queueHeld === true);
+              if (heldRun) {
+                await resume({
+                  ...target,
+                  input: { threadId: target.threadId, runId: heldRun.run.id },
+                });
+              }
               busyRef.current = false;
               setResuming(false);
             }}

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

@@ -636,7 +636,12 @@ function ThreadRouteContent(
     if (!selectedThread) return;
     await resumeThreadQueue({
       environmentId: selectedThread.environmentId,
-      input: { threadId: selectedThread.id },
+      input: {
+        threadId: selectedThread.id,
+        ...(composer.communicationLanesEnabled && composer.heldUserRunId
+          ? { runId: composer.heldUserRunId }
+          : {}),
+      },
     });
   };
 
@@ -978,6 +983,7 @@ function ThreadRouteContent(
           feedbackSubmissions={composer.feedbackSubmissions}
           onDismissFeedback={composer.dismissFeedback}
           selectedThreadFeed={composer.selectedThreadFeed}
+          finishedWithoutUserUpdate={composer.selectedThreadFinishedWithoutUserUpdate}
           pendingHandoff={composer.pendingHandoff}
           activityRun={composer.selectedThreadActivityRun}
           activeWorkStartedAt={

apps/mobile/src/features/threads/thread-work-log.tsx

@@ -89,6 +89,7 @@ import {
 } from "@t3tools/client-runtime/work-log/presentation";
 import { resolveWorkGroupScrollAnchor } from "@t3tools/client-runtime/work-log/scroll-anchor";
 import { notificationChildThreadId } from "@t3tools/client-runtime/state/thread-execution";
+import { coordinationNotificationWithDetail } from "@t3tools/client-runtime/state/thread-communication";
 import type { MarkdownImageRenderer } from "../../native/SelectableMarkdownText";
 import type { FilePreviewSource } from "../../components/FilePreviewModal";
 import { FilePreviewGallery } from "../../components/FilePreviewGallery";
@@ -974,16 +975,19 @@ const ThreadWorkLogRow = function ThreadWorkLogRow(
     call && shownItem.type === "command_execution" && shownItem.exitCode
       ? shownItem.exitCode
       : null;
+  const coordinationItem = coordinationNotificationWithDetail(row.projectedItem.item, fetchedItem);
   const fullDetail =
     expanded && !reasoning && !call
-      ? fetchedItem && !isRead
-        ? formatItemFullDetail(row.projectedItem, fetchedItem)
-        : row.getFullDetail()
+      ? coordinationItem?.type === "notification"
+        ? (coordinationItem.detail ?? null)
+        : fetchedItem && !isRead
+          ? formatItemFullDetail(row.projectedItem, fetchedItem)
+          : row.getFullDetail()
       : null;
   const outputImages = expanded && fetchedItem ? turnItemOutputImages(fetchedItem) : [];
   const viewedImagePath = workEntryViewedImagePath(row.workEntry);
   const fetchedOutput =
-    !expanded || streamsOutput
+    !expanded || streamsOutput || coordinationItem
       ? null
       : shownItem.type === "file_search" || shownItem.type === "web_search"
         ? turnItemOutputText(shownItem)

apps/mobile/src/lib/projectThreadStartTurn.test.ts

@@ -52,10 +52,12 @@ describe("project thread title", () => {
       worktreePath: null,
       startFromOrigin: false,
       worktreeBranchName: "unused",
+      communicationLanesEnabled: true,
     } satisfies ProjectThreadStartTurnSpec;
     const input = buildProjectThreadStartTurnInput(spec);
 
     expect(input.titleSeed).toBe(title);
+    expect(input.communicationLanesEnabled).toBe(true);
     expect(input.bootstrap.createThread.title).toBe(input.titleSeed);
     expect(input.message.attachments).toEqual(uploadedAttachments);
     expect(input.message.text).toBe(wire.text);

apps/mobile/src/lib/projectThreadStartTurn.ts

@@ -17,6 +17,7 @@ import {
 import type { UploadedMobileAttachment } from "./attachmentUpload";
 
 export interface ProjectThreadStartTurnSpec {
+  readonly communicationLanesEnabled?: boolean;
   readonly projectId: ProjectId;
   readonly projectCwd: string;
   readonly threadId: string;
@@ -44,6 +45,7 @@ export function buildProjectThreadStartTurnInput(spec: ProjectThreadStartTurnSpe
   });
   const isWorktree = spec.workspaceMode === "worktree";
   return {
+    ...(spec.communicationLanesEnabled === true ? { communicationLanesEnabled: true } : {}),
     commandId: CommandId.make(spec.commandId),
     creationSource: "mobile" as const,
     threadId: ThreadId.make(spec.threadId),

apps/mobile/src/lib/threadActivity.test.ts

@@ -283,6 +283,51 @@ function assistantMessage(updatedAt = "2026-06-20T00:00:03.000Z") {
 }
 
 describe("buildThreadFeed", () => {
+  it("keeps unaddressed and internal messages in the work log of enabled threads", () => {
+    const user = projected(
+      {
+        ...userMessage(),
+        communication: { route: { port: "user.in" } },
+      } as unknown as OrchestrationV2TurnItem,
+      0,
+    );
+    const internal = projected(
+      {
+        ...assistantMessage(),
+        communication: { route: { port: "internal.out" } },
+      } as unknown as OrchestrationV2TurnItem,
+      1,
+    );
+    const unclassified = projected(
+      {
+        ...assistantMessage(),
+        id: TurnItemId.make("unclassified"),
+        messageId: MessageId.make("unclassified"),
+      },
+      2,
+    );
+    const rows = [user, internal, unclassified];
+
+    const enabledFeed = buildThreadFeed(rows, {
+      communicationLanesEnabled: true,
+      anchoredMessages: [
+        {
+          id: MessageId.make("local-assistant"),
+          role: "assistant",
+          text: "Unaddressed local output",
+          streaming: false,
+          createdAt: "2026-06-20T00:00:00.000Z",
+          updatedAt: "2026-06-20T00:00:00.000Z",
+        },
+      ],
+    });
+    expect(
+      enabledFeed.filter((entry) => entry.type === "message").map((entry) => entry.id),
+    ).toEqual([MessageId.make("message-user")]);
+    expect(enabledFeed.some((entry) => entry.type !== "message")).toBe(true);
+    expect(buildThreadFeed(rows).filter((entry) => entry.type === "message")).toHaveLength(3);
+  });
+
   it("keeps async answers in question history instead of user bubbles", () => {
     const requestId = RuntimeRequestId.make("question");
     const question: OrchestrationV2TurnItem = {