feat(v2): show provider limit stops as Limited

apps/mobile/src/features/threads/thread-list-v2-items.tsx

@@ -70,6 +70,7 @@ const STATUS_LABEL_BY_STATUS: Partial<
   input: { label: "Input", className: "text-adaptive-indigo-600-300" },
   working: { label: "Working", className: "text-adaptive-sky-600-400" },
   failed: { label: "Failed", className: "text-danger-foreground" },
+  limited: { label: "Limited", className: "text-warning-foreground" },
 };
 
 function threadTimeLabel(thread: EnvironmentThreadShell): string {
@@ -914,13 +915,15 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         </View>
       ) : null}
       <View className="mt-1 flex-row items-center gap-2">
-        {status === "failed" && thread.runtime?.lastError ? (
+        {(status === "failed" || status === "limited") && thread.runtime?.lastError ? (
           <Text
             className={cn(
               "flex-1 text-xs",
               selected
                 ? selectedThreadRowColors.mutedForegroundClassName
-                : "text-danger-foreground",
+                : status === "limited"
+                  ? "text-warning-foreground"
+                  : "text-danger-foreground",
             )}
             numberOfLines={1}
           >

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

@@ -888,7 +888,12 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
   const accessiblePreview = [previewText, answerPreview].filter(Boolean).join(": ");
   const displayText = workEntryRowLabel(row.workEntry, expanded);
   const isSystemNotice = row.projectedItem.item.type === "system_notice";
-  const iconIsDestructive = !isSystemNotice && (row.icon === "alert" || row.icon === "warning");
+  const isUsageLimit =
+    row.projectedItem.item.type === "error" &&
+    row.projectedItem.item.failure.class === "usage_limit" &&
+    row.projectedItem.item.status !== "completed";
+  const iconIsDestructive =
+    !isSystemNotice && !isUsageLimit && (row.icon === "alert" || row.icon === "warning");
   const failed = row.status === "failure";
   const toolIcon = row.workEntry.toolIcon ?? row.workEntry.toolSource?.icon;
   const icon = reasoning ? "brain" : (toolPresentation?.icon ?? workRowSymbolName(row.icon));
@@ -942,16 +947,20 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
                   icon={icon}
                   color={props.iconSubtleColor}
                   colorClassName={
-                    iconIsDestructive
-                      ? "accent-adaptive-rose-600-400"
-                      : failed
-                        ? "accent-danger-foreground/40"
-                        : undefined
+                    isUsageLimit
+                      ? "accent-warning-foreground"
+                      : iconIsDestructive
+                        ? "accent-adaptive-rose-600-400"
+                        : failed
+                          ? "accent-danger-foreground/40"
+                          : undefined
                   }
                 />
               )}
             </WorkLogIconSlot>
-            <WorkLogLabel tone={iconIsDestructive ? "danger" : "default"}>
+            <WorkLogLabel
+              tone={isUsageLimit ? "warning" : iconIsDestructive ? "danger" : "default"}
+            >
               {isSystemNotice ? row.summary : displayText}
               {answerPreview ? (
                 <Text

apps/mobile/src/features/threads/threadListV2.test.ts

@@ -128,6 +128,35 @@ describe("resolveThreadListV2Enabled", () => {
 });
 
 describe("resolveThreadListV2Status", () => {
+  it("distinguishes usage limits from ordinary failures and clears the label after recovery", () => {
+    const thread = makeThread({
+      id: ThreadId.make("limited"),
+      title: "Limited",
+      runtime: {
+        status: "failed",
+        activeRunId: null,
+        providerInstanceId: ProviderInstanceId.make("codex"),
+        providerName: "Codex",
+        lastError: "Plan limit reached",
+        lastErrorClass: "usage_limit",
+        updatedAt: NOW,
+      },
+    });
+    expect(resolveThreadListV2Status(thread)).toBe("limited");
+    expect(
+      resolveThreadListV2Status({
+        ...thread,
+        runtime: { ...thread.runtime!, lastErrorClass: null },
+      }),
+    ).toBe("failed");
+    expect(
+      resolveThreadListV2Status({
+        ...thread,
+        runtime: { ...thread.runtime!, status: "completed" },
+      }),
+    ).toBe("ready");
+  });
+
   it("prioritizes approval over a running runtime", () => {
     const thread = makeThread({
       id: ThreadId.make("t"),

apps/mobile/src/features/threads/threadListV2.ts

@@ -59,7 +59,14 @@ export function resolveThreadListV2ProviderDrivers(
  * The orchestrator v2 presentation bridge parks runtime at idle when the
  * post-settlement background roster is nonempty.
  */
-export type ThreadListV2Status = "approval" | "input" | "working" | "waiting" | "failed" | "ready";
+export type ThreadListV2Status =
+  | "approval"
+  | "input"
+  | "working"
+  | "waiting"
+  | "failed"
+  | "limited"
+  | "ready";
 export type ThreadListV2SwipeAction = "archive" | "settle" | "unsettle" | "snooze" | "unsnooze";
 
 export function resolveThreadListV2SnoozeMenuSelection(input: {
@@ -197,7 +204,7 @@ export function resolveThreadListV2Status(
     return "waiting";
   }
   if (thread.runtime?.status === "failed") {
-    return "failed";
+    return thread.runtime.lastErrorClass === "usage_limit" ? "limited" : "failed";
   }
   return "ready";
 }

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

@@ -55,7 +55,7 @@ export function WorkLogLabel({
   tone = "default",
 }: {
   children: ReactNode;
-  tone?: "default" | "danger";
+  tone?: "default" | "danger" | "warning";
 }) {
   return (
     <Text
@@ -65,6 +65,7 @@ export function WorkLogLabel({
       className={cn(
         "min-w-0 flex-1 text-sm text-foreground-muted",
         tone === "danger" && "font-t3-medium text-adaptive-rose-600-400",
+        tone === "warning" && "font-t3-medium text-warning-foreground",
       )}
     >
       {children}

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

@@ -338,89 +338,123 @@ describe("buildThreadFeed", () => {
     expect(presented.some((entry) => entry.type === "run-fold")).toBe(false);
   });
 
-  it("presents provider retries as visible work-log activity", () => {
-    const retryBase = {
-      ...base("item-provider-retry", "2026-06-20T00:00:02.000Z", 1),
-      type: "error" as const,
-      failure: {
-        class: "transport_error" as const,
-        message: "The response stream disconnected.",
-        code: "responseStreamDisconnected",
-        retryable: true,
-      },
-      retry: {
-        attempt: 2,
-        maxAttempts: 5,
-        retryDelayMs: null,
-      },
-    };
-    const runningFeed = buildThreadFeed([
-      projected(
-        {
-          ...retryBase,
-          status: "running",
-          title: "Provider retry",
-          completedAt: null,
-        },
-        0,
-      ),
-    ]);
-    const recoveredFeed = buildThreadFeed([
-      projected(
-        {
-          ...retryBase,
-          status: "completed",
-          title: "Provider recovered",
-        },
-        0,
-      ),
-    ]);
-    const failedFeed = buildThreadFeed([
+  it("presents a usage-limit stop as a warning while preserving its explanation", () => {
+    const message = "Plan usage limit reached. Try again after reset.";
+    const entries = buildThreadFeed([
       projected(
         {
-          ...retryBase,
+          ...base("item-limit", "2026-06-20T00:00:02.000Z", 1),
+          type: "error",
           status: "failed",
-          title: "Provider retry failed",
+          title: "Usage limit reached",
+          failure: { class: "usage_limit", message, code: "usageLimitExceeded", retryable: null },
         },
         0,
       ),
-      projected(command("2026-06-20T00:00:03.000Z"), 1),
     ]);
-    const runningActivity = runningFeed.find((entry) => entry.type === "activity-group")
-      ?.activities[0];
-    const recoveredActivity = recoveredFeed.find((entry) => entry.type === "activity-group")
-      ?.activities[0];
-    if (runningActivity === undefined || recoveredActivity === undefined) {
-      throw new Error("Expected provider retry work-log activities.");
-    }
-
-    expect(runningActivity).toMatchObject({
-      summary: "Provider retry",
+    const activity = entries.flatMap((entry) =>
+      entry.type === "activity-group" ? entry.activities : [],
+    )[0];
+    expect(activity).toMatchObject({
+      summary: "Usage limit reached",
       status: "neutral",
-      toolLike: false,
-    });
-    expect(threadFeedActivityIsVisible(runningActivity)).toBe(true);
-    expect(recoveredActivity).toMatchObject({
-      summary: "Provider recovered",
-      status: "success",
-      toolLike: false,
+      icon: "warning",
     });
-    const failedPresentation = deriveThreadFeedPresentation(
-      failedFeed,
-      { runId, status: "running", startedAt: null, completedAt: null },
-      new Set(),
-    );
-    expect(failedPresentation.map((entry) => entry.type)).toEqual([
-      "activity-group",
-      "work-toggle",
-    ]);
-    expect(
-      failedPresentation[0]?.type === "activity-group"
-        ? failedPresentation[0].activities[0]?.summary
-        : null,
-    ).toBe("Provider retry failed");
+    expect(activity?.getFullDetail()).toContain(message);
   });
 
+  it.each(["transport_error", "usage_limit"] as const)(
+    "presents %s retries and clears warning markers on recovery",
+    (failureClass) => {
+      const retryBase = {
+        ...base("item-provider-retry", "2026-06-20T00:00:02.000Z", 1),
+        type: "error" as const,
+        failure: {
+          class: failureClass,
+          message: "The response stream disconnected.",
+          code: "responseStreamDisconnected",
+          retryable: true,
+        },
+        retry: {
+          attempt: 2,
+          maxAttempts: 5,
+          retryDelayMs: null,
+        },
+      };
+      const runningFeed = buildThreadFeed([
+        projected(
+          {
+            ...retryBase,
+            status: "running",
+            title: "Provider retry",
+            completedAt: null,
+          },
+          0,
+        ),
+      ]);
+      const recoveredFeed = buildThreadFeed([
+        projected(
+          {
+            ...retryBase,
+            status: "completed",
+            title: "Provider recovered",
+          },
+          0,
+        ),
+      ]);
+      if (failureClass === "usage_limit") {
+        const recoveredActivity = recoveredFeed.flatMap((entry) =>
+          entry.type === "activity-group" ? entry.activities : [],
+        )[0];
+        expect(recoveredActivity).toMatchObject({ status: "success", icon: "check" });
+      }
+      const failedFeed = buildThreadFeed([
+        projected(
+          {
+            ...retryBase,
+            status: "failed",
+            title: "Provider retry failed",
+          },
+          0,
+        ),
+        projected(command("2026-06-20T00:00:03.000Z"), 1),
+      ]);
+      const runningActivity = runningFeed.find((entry) => entry.type === "activity-group")
+        ?.activities[0];
+      const recoveredActivity = recoveredFeed.find((entry) => entry.type === "activity-group")
+        ?.activities[0];
+      if (runningActivity === undefined || recoveredActivity === undefined) {
+        throw new Error("Expected provider retry work-log activities.");
+      }
+
+      expect(runningActivity).toMatchObject({
+        summary: "Provider retry",
+        status: "neutral",
+        toolLike: false,
+      });
+      expect(threadFeedActivityIsVisible(runningActivity)).toBe(true);
+      expect(recoveredActivity).toMatchObject({
+        summary: "Provider recovered",
+        status: "success",
+        toolLike: false,
+      });
+      const failedPresentation = deriveThreadFeedPresentation(
+        failedFeed,
+        { runId, status: "running", startedAt: null, completedAt: null },
+        new Set(),
+      );
+      expect(failedPresentation.map((entry) => entry.type)).toEqual([
+        "activity-group",
+        "work-toggle",
+      ]);
+      expect(
+        failedPresentation[0]?.type === "activity-group"
+          ? failedPresentation[0].activities[0]?.summary
+          : null,
+      ).toBe("Provider retry failed");
+    },
+  );
+
   it.each(["pending", "running", "completed"] as const)(
     "omits %s task progress without hiding adjacent conversation items",
     (stepStatus) => {

apps/mobile/src/lib/threadActivity.ts

@@ -362,7 +362,8 @@ function itemIsProminent(item: OrchestrationV2TurnItem): boolean {
 function itemStatus(item: OrchestrationV2TurnItem): ThreadFeedActivity["status"] {
   if (item.type === "notification") return item.outcome === "failed" ? "failure" : null;
   if (item.type === "error") {
-    if (item.status === "failed") return "failure";
+    if (item.status === "failed")
+      return item.failure.class === "usage_limit" ? "neutral" : "failure";
     return item.status === "completed" ? "success" : "neutral";
   }
   if (!itemIsToolLike(item)) return null;
@@ -432,7 +433,11 @@ function itemIcon(item: OrchestrationV2TurnItem): ThreadFeedActivity["icon"] {
     case "system_notice":
       return "warning";
     case "error":
-      return "alert";
+      return item.failure.class === "usage_limit"
+        ? item.status === "completed"
+          ? "check"
+          : "warning"
+        : "alert";
     case "checkpoint":
     case "proposed_plan":
     case "todo_list":
@@ -486,7 +491,7 @@ function itemSummary(
     case "run_interrupt_result":
       return "Run interrupted";
     case "error":
-      return "Provider error";
+      return item.failure.class === "usage_limit" ? "Usage limit reached" : "Provider error";
     case "handoff":
       return "Context handed off";
     case "fork":
@@ -671,7 +676,12 @@ function toFeedActivity(
     logo: toolPresentation?.logo ?? null,
     toolLike: itemIsToolLike(item),
     prominent: itemIsProminent(item),
-    status: workEntryDisplayIndicatesToolFailure(workEntry) ? "failure" : itemStatus(item),
+    status:
+      item.type === "error" && item.failure.class === "usage_limit"
+        ? itemStatus(item)
+        : workEntryDisplayIndicatesToolFailure(workEntry)
+          ? "failure"
+          : itemStatus(item),
     lifecycleStatus: itemLifecycleStatus(item),
     workEntry,
     projectedItem: row,