Merge posthog-code/finalize-mobile-portability-boundary

Generated-By: PostHog Code
Task-Id: c1bbe3cf-742b-4b24-bf96-d11a18b4cf22

Author: richardsolomou

apps/mobile/src/features/tasks/hooks/useCloudTaskConfigOptions.test.ts

@@ -106,6 +106,32 @@ describe("useCloudTaskConfigOptions", () => {
     expect(mockGetCloudTaskConfigOptions).toHaveBeenCalledWith("claude");
   });
 
+  it("replaces a hidden GLM current model with a visible model", async () => {
+    mockGetCloudTaskConfigOptions.mockResolvedValue([
+      {
+        id: "model",
+        name: "Model",
+        type: "select",
+        currentValue: "@cf/zai-org/glm-5.2",
+        options: [
+          { value: "@cf/zai-org/glm-5.2", name: "GLM-5.2" },
+          { value: "claude-sonnet-5", name: "Claude Sonnet 5" },
+        ],
+        category: "model",
+        description: "Choose a model",
+      },
+    ] satisfies CloudTaskConfigOption[]);
+
+    const result = await renderHook();
+    await waitForAssertion(() => {
+      const modelOption = getModelConfigOption(result.current.configOptions);
+      expect(modelOption.currentValue).toBe("claude-sonnet-5");
+      expect(modelOption.options.map((option) => option.value)).toEqual([
+        "claude-sonnet-5",
+      ]);
+    });
+  });
+
   it("keeps the shared fallback when unauthenticated", async () => {
     mockUseAuthStore.mockImplementation((selector) =>
       selector({ oauthAccessToken: null }),

apps/mobile/src/features/tasks/hooks/useCloudTaskConfigOptions.ts

@@ -4,6 +4,7 @@ import {
   type CloudTaskConfigOption,
   GLM_MODEL_FLAG,
   isGlmModelId,
+  isRestrictedModelOption,
 } from "@posthog/shared";
 import { useQuery } from "@tanstack/react-query";
 import { useFeatureFlag } from "posthog-react-native";
@@ -35,12 +36,21 @@ export function useCloudTaskConfigOptions(adapter: Adapter = "claude") {
     ? configOptions
     : configOptions.map((option) =>
         option.category === "model"
-          ? {
-              ...option,
-              options: option.options.filter(
+          ? (() => {
+              const options = option.options.filter(
                 (model) => !isGlmModelId(model.value),
-              ),
-            }
+              );
+              const currentValue = options.some(
+                (model) =>
+                  model.value === option.currentValue &&
+                  !isRestrictedModelOption(model._meta),
+              )
+                ? option.currentValue
+                : (options.find(
+                    (model) => !isRestrictedModelOption(model._meta),
+                  )?.value ?? option.currentValue);
+              return { ...option, currentValue, options };
+            })()
           : option,
       );
 

packages/core/src/cloud-task/cloud-task-engine.ts

@@ -81,6 +81,7 @@ class BackendStreamError extends Error {
 
 interface TaskRunResponse {
   id: string;
+  log_url?: string | null;
   status: TaskRunStatus;
   stage?: string | null;
   output?: Record<string, unknown> | null;
@@ -1106,7 +1107,10 @@ export class CloudTaskEngine extends TypedEventEmitter<CloudTaskEvents> {
     }
 
     if (isTerminalStatus(run.status)) {
-      const historicalEntries = await this.fetchAllSessionLogs(watcher);
+      let historicalEntries = await this.fetchAllSessionLogs(watcher);
+      if (historicalEntries?.length === 0 && run.log_url) {
+        historicalEntries = await this.fetchArchivedLogs(run.log_url);
+      }
       const terminalWatcher = this.watchers.get(key);
       if (!terminalWatcher || terminalWatcher !== watcher) return;
       if (watcher.failed) return;
@@ -2154,6 +2158,24 @@ export class CloudTaskEngine extends TypedEventEmitter<CloudTaskEvents> {
     }
   }
 
+  private async fetchArchivedLogs(
+    logUrl: string,
+  ): Promise<StoredLogEntry[] | null> {
+    try {
+      const response = await this.streamFetch(logUrl);
+      if (!response.ok) return null;
+      const content = await response.text();
+      if (!content.trim()) return [];
+      return content
+        .trim()
+        .split("\n")
+        .map((line) => JSON.parse(line) as StoredLogEntry);
+    } catch (error) {
+      this.log.warn("Cloud task archived logs fetch error", { logUrl, error });
+      return null;
+    }
+  }
+
   private async resolveStreamTarget(watcher: WatcherState): Promise<void> {
     const url = `${watcher.apiHost}/api/projects/${watcher.teamId}/tasks/${watcher.taskId}/runs/${watcher.runId}/stream_token/`;
     try {

packages/core/src/cloud-task/cloud-task.test.ts

@@ -2532,6 +2532,54 @@ describe("CloudTaskEngine", () => {
     expect(statusFetchCount).toBeLessThanOrEqual(2);
   });
 
+  it("loads archived logs when a terminal run has no persisted session logs", async () => {
+    const updates: unknown[] = [];
+    service.on(CloudTaskEvent.Update, (payload) => updates.push(payload));
+    const archivedEntry = {
+      type: "notification",
+      timestamp: "2026-01-01T00:00:00Z",
+    };
+
+    mockNetFetch.mockImplementation((input: string | Request) => {
+      const url = typeof input === "string" ? input : input.url;
+      if (url.includes("/session_logs/")) {
+        return Promise.resolve(
+          createJsonResponse([], 200, { "X-Has-More": "false" }),
+        );
+      }
+      if (url === "https://logs.example.com/run-1.jsonl") {
+        return Promise.resolve(
+          new Response(`${JSON.stringify(archivedEntry)}\n`, { status: 200 }),
+        );
+      }
+      return Promise.resolve(
+        createJsonResponse({
+          id: "run-1",
+          status: "completed",
+          log_url: "https://logs.example.com/run-1.jsonl",
+          updated_at: "2026-01-01T00:00:00Z",
+        }),
+      );
+    });
+
+    service.watch({
+      taskId: "task-1",
+      runId: "run-1",
+      apiHost: "https://app.example.com",
+      teamId: 2,
+    });
+
+    await waitFor(() => updates.length === 1);
+    expect(updates[0]).toEqual(
+      expect.objectContaining({
+        kind: "snapshot",
+        newEntries: [archivedEntry],
+        totalEntryCount: 1,
+        status: "completed",
+      }),
+    );
+  });
+
   const guardedFetchStatusExpectations = [
     [
       401,

packages/core/src/inbox/engagement.ts

@@ -199,19 +199,27 @@ export type InboxViewedFilterState =
   | DesktopInboxViewedFilterState
   | MobileInboxViewedFilterState;
 
-export interface BuildInboxViewedInput {
+interface BuildInboxViewedInputBase {
   /**
    * Reports currently visible to the user (after reviewer scope + search), used
    * for `report_count`, `ready_count`, and the priority/actionability breakdown.
    */
   visibleReports: SignalReport[];
   /** Server-reported total of reports matching the active query — the headline inbox number. */
   totalCount: number;
-  /** Tab badge counts shown in the v2 header (the numbers the user actually sees). */
-  tabCounts?: { pulls: number; reports: number };
-  filters: InboxViewedFilterState;
 }
 
+export type BuildInboxViewedInput =
+  | (BuildInboxViewedInputBase & {
+      filters: DesktopInboxViewedFilterState;
+      /** Tab badge counts shown in the desktop header. */
+      tabCounts: { pulls: number; reports: number };
+    })
+  | (BuildInboxViewedInputBase & {
+      filters: MobileInboxViewedFilterState;
+      tabCounts?: never;
+    });
+
 /**
  * Build the property payload for the `Inbox viewed` analytics event from the
  * v2 inbox state. Pure so it can be unit-tested and reused across hosts.