feat(codex): submit thread feedback to OpenAI

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

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

@@ -552,7 +552,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
  if (inFlightThreadIdsRef.current.has(threadKey)) return;
  inFlightThreadIdsRef.current.add(threadKey);
  try {
- await onSendMessage();
+ const messageId = await onSendMessage();
+ if (messageId === null) {
+ return;
+ }
  // Sending a prompt starts agent work: arm the lock-screen card while the
  // app is foregrounded and the activity token can be registered. Armed
  // after the send so its preference read and native Activity start don't

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vite-plus/test";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
 
 import {
  EventId,
@@ -22,6 +23,34 @@ import {
  type ThreadFeedEntry,
 } from "./threadActivity";
 
+describe("Codex feedback pseudo-messages", () => {
+ it("keeps pending and completed feedback messages in the mobile thread body", () => {
+ const pending = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:00.000Z",
+ status: "uploading" as const,
+ };
+ const entries = [codexFeedbackMessage(pending), codexFeedbackMessage(pending, "assistant")].map(
+ (message) => ({
+ type: "message" as const,
+ id: message.id,
+ createdAt: message.createdAt,
+ message,
+ }),
+ );
+
+ expect(deriveThreadFeedPresentation(entries, null, new Set())).toEqual(entries);
+ expect(entries[1]?.message.text).toBe("Sending feedback to OpenAI...");
+
+ const completed = codexFeedbackMessage(
+ { ...pending, status: "sent", feedbackId: "codex-thread-1" },
+ "assistant",
+ );
+ expect(completed.text).toContain("codex-thread-1");
+ });
+});
+
 const singleSelectQuestion = {
  id: "runtime",
  header: "Runtime",
@@ -151,6 +180,44 @@ function makeThread(
 }
 
 describe("buildThreadFeed", () => {
+ it("keeps older local feedback before newer messages returned by the server", () => {
+ const submission = {
+ id: MessageId.make("feedback-command-ordering"),
+ command: "/feedback The agent stopped early.",
+ createdAt: "2026-08-23T00:00:01.000Z",
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const laterMessage = {
+ id: MessageId.make("later-server-message"),
+ role: "assistant" as const,
+ text: "Newer server response",
+ turnId: null,
+ createdAt: "2026-08-23T00:00:02.000Z",
+ updatedAt: "2026-08-23T00:00:02.000Z",
+ streaming: false,
+ };
+ const thread = makeThread({
+ id: ThreadId.make("thread-feedback-ordering"),
+ projectId: ProjectId.make("project-1"),
+ title: "Feedback ordering",
+ messages: [laterMessage],
+ });
+
+ const feed = buildThreadFeed(thread, {
+ localMessages: [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ],
+ });
+
+ expect(feed.map((entry) => entry.id)).toEqual([
+ "feedback-command-ordering",
+ "feedback-command-ordering:feedback",
+ "later-server-message",
+ ]);
+ });
+
  it("keeps historic work entries attributed to their turns", () => {
  const thread = makeThread({
  id: ThreadId.make("thread-1"),

apps/mobile/src/lib/threadActivity.ts

@@ -1526,15 +1526,19 @@ export function buildThreadFeed(
  thread: OrchestrationThread,
  options?: {
  readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
+ readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
  },
 ): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;
+ const messages = options?.localMessages
+ ? [...loadedMessages, ...options.localMessages]
+ : loadedMessages;
  const oldestLoadedMessageCreatedAt =
  options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
  const workLogEntries = deriveWorkLogEntries(thread.activities);
  const entries = Arr.sortWith(
  [
- ...loadedMessages.map<RawThreadFeedEntry>((message) => ({
+ ...messages.map<RawThreadFeedEntry>((message) => ({
  type: "message",
  id: message.id,
  createdAt: message.createdAt,

apps/mobile/src/state/use-thread-composer-state.ts

@@ -1,5 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Alert } from "react-native";
+import * as Cause from "effect/Cause";
 
 import {
  CommandId,
@@ -11,6 +13,13 @@ import {
  type ThreadId,
 } from "@t3tools/contracts";
 import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
+import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
 
 import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
@@ -21,6 +30,7 @@ import {
 } from "../lib/composerImages";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import { scopedThreadKey } from "../lib/scopedEntities";
+import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import { buildThreadFeed } from "../lib/threadActivity";
 import { appAtomRegistry } from "../state/atom-registry";
 import {
@@ -41,6 +51,8 @@ import { useSelectedThreadDetail } from "../state/use-thread-detail";
 import { useThreadSelection } from "../state/use-thread-selection";
 import { enqueueThreadOutboxMessage } from "./thread-outbox";
 import { useThreadOutboxMessages } from "./use-thread-outbox";
+import { threadEnvironment } from "./threads";
+import { useAtomCommand } from "./use-atom-command";
 
 export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
@@ -74,10 +86,16 @@ export function useThreadDraftForThread(input: {
 }
 
 export function useThreadComposerState() {
- const { selectedThread: selectedThreadShell } = useThreadSelection();
+ const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
  const selectedThreadDetail = useSelectedThreadDetail();
  const composerDrafts = useAtomValue(composerDraftsAtom);
  const queuedMessagesByThreadKey = useThreadOutboxMessages();
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record<string, ReadonlyArray<CodexFeedbackSubmission>>
+ >({});
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
 
  useEffect(() => {
  ensureComposerDraftsLoaded();
@@ -90,10 +108,21 @@ export function useThreadComposerState() {
  () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
  [queuedMessagesByThreadKey, selectedThreadKey],
  );
- const selectedThreadFeed = useMemo(
- () => (selectedThreadDetail ? buildThreadFeed(selectedThreadDetail) : []),
- [selectedThreadDetail],
- );
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadDetail) {
+ return [];
+ }
+ const submissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
+ : [];
+ return buildThreadFeed(selectedThreadDetail, {
+ localMessages: submissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ });
+ }, [feedbackSubmissionsByThreadKey, selectedThreadDetail, selectedThreadKey]);
 
  const selectedDraft = selectedThreadKey ? composerDrafts[selectedThreadKey] : null;
  const draftMessage = selectedDraft?.text ?? "";
@@ -143,6 +172,70 @@ export function useThreadComposerState() {
  return null;
  }
 
+ const provider = selectedEnvironmentRuntime?.serverConfig?.providers.find(
+ (entry) => entry.instanceId === thread.modelSelection.instanceId,
+ );
+ const feedbackCommand =
+ attachments.length === 0 &&
+ (provider?.driver === "codex" || thread.session?.providerName === "codex")
+ ? parseCodexFeedbackCommand(text)
+ : null;
+ if (feedbackCommand) {
+ if (thread.session === null) {
+ Alert.alert("Start a Codex thread first", "Send a message before you submit feedback.");
+ return null;
+ }
+ const metadata = makeQueuedMessageMetadata();
+ const result = await submitCodexFeedback({
+ submission: {
+ id: MessageId.make(metadata.messageId),
+ command: text,
+ createdAt: metadata.createdAt,
+ },
+ clearDraft: () => clearComposerDraftContent(threadKey),
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[threadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [threadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId: selectedThreadShell.environmentId,
+ input: {
+ threadId: selectedThreadShell.id,
+ ...feedbackCommand,
+ },
+ }),
+ });
+ if (result._tag === "Failure") {
+ if (isAtomCommandInterrupted(result)) {
+ return null;
+ }
+ const error = Cause.squash(result.cause);
+ Alert.alert(
+ "Could not send feedback to OpenAI",
+ error instanceof Error ? error.message : "An error occurred.",
+ );
+ return null;
+ }
+ const feedbackId = result.value.feedbackId;
+ Alert.alert("Feedback sent to OpenAI", `Thread ID: ${feedbackId}`, [
+ { text: "OK", style: "cancel" },
+ {
+ text: "Copy ID",
+ onPress: () => copyTextWithHaptic(feedbackId, { target: "Codex feedback thread ID" }),
+ },
+ ]);
+ return null;
+ }
+
  const metadata = makeQueuedMessageMetadata();
  const messageId = MessageId.make(metadata.messageId);
  // Enqueue publishes the queued atom synchronously (the durable write
@@ -175,7 +268,12 @@ export function useThreadComposerState() {
  );
  });
  return messageId;
- }, [selectedThreadDetail, selectedThreadShell]);
+ }, [
+ selectedEnvironmentRuntime?.serverConfig?.providers,
+ selectedThreadDetail,
+ selectedThreadShell,
+ uploadThreadFeedback,
+ ]);
 
  const onChangeDraftMessage = useCallback(
  (value: string) => {

apps/server/integration/orphanedProviderSessionStartup.integration.test.ts

@@ -116,6 +116,7 @@ const startupDependencies = Layer.mergeAll(
  getCapabilities: () => Effect.die("unused"),
  getInstanceInfo: () => Effect.die("unused"),
  rollbackConversation: () => Effect.die("unused"),
+ uploadFeedback: () => Effect.die("unused"),
  streamEvents: Stream.empty,
  }),
 );

apps/server/src/auth/RpcAuthorization.test.ts

@@ -37,6 +37,12 @@ describe("RPC authorization scopes", () => {
  expect(requiredScopeForRpcMethod(WS_METHODS.cloudInstallRelayClient)).toBe(AuthRelayWriteScope);
  });
 
+ it("requires permission to operate on a thread before uploading feedback", () => {
+ expect(requiredScopeForRpcMethod(WS_METHODS.providerUploadFeedback)).toBe(
+ AuthOrchestrationOperateScope,
+ );
+ });
+
  it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
  // The candidate list is a read like the detail beside it, and asking somebody for a review is
  // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -84,6 +84,7 @@ export const RPC_REQUIRED_SCOPES = {
  [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
  [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
  [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,
+ [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
  [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
  [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
  [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness(
  },
  }),
  rollbackConversation,
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -340,6 +340,7 @@ describe("ProviderCommandReactor", () => {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts

@@ -125,6 +125,7 @@ function createProviderServiceHarness() {
  });
  },
  rollbackConversation: () => unsupported(),
+ uploadFeedback: () => unsupported(),
  get streamEvents() {
  return Stream.fromPubSub(runtimeEventPubSub);
  },