fix(mobile): show agent activity in the iOS home screen widget

apps/mobile/app.config.ts

@@ -195,7 +195,10 @@ const widgetsPlugin: NonNullable<ExpoConfig["plugins"]>[number] = [
         displayName: "Agent Activity",
         description: "Shows the current state of active T3 Code agents.",
         android: null,
-        ios: { supportedFamilies: ["systemSmall", "systemMedium", "accessoryRectangular"] },
+        ios: {
+          supportedFamilies: ["systemSmall", "systemMedium", "systemLarge", "accessoryRectangular"],
+          initialLayout: "./src/widgets/AgentActivityWidget.tsx",
+        },
       },
     ],
   },

apps/mobile/fingerprint.config.js

@@ -14,5 +14,9 @@ if (!majorVersion) {
 
 module.exports = {
   nativeModuleSourceType: "files",
-  extraSources: [{ type: "contents", id: "appMajorVersion", contents: majorVersion }],
+  extraSources: [
+    { type: "contents", id: "appMajorVersion", contents: majorVersion },
+    // Expo embeds this layout in the extension, outside its native module sources.
+    { type: "file", filePath: "src/widgets/AgentActivityWidget.tsx" },
+  ],
 };

apps/mobile/src/features/agent-awareness/remoteRegistration.ts

@@ -37,6 +37,8 @@ import {
   saveAgentAwarenessRegistrationRecord,
 } from "../../persistence/imperative";
 import type { AgentActivityProps } from "../../widgets/AgentActivity";
+import type { AgentActivityWidgetSource } from "../../widgets/agentActivityWidgetTimeline";
+import { publishAgentActivityWidget } from "../../widgets/publishAgentActivityWidget";
 import {
   dismissEndedAgentLiveActivities,
   getAgentLiveActivities,
@@ -89,6 +91,9 @@ const ACTIVITY_TOKEN_REREGISTER_INTERVAL_MS = 60_000;
 const LIVE_ACTIVITY_STALE_AFTER_MS = 10 * 60_000;
 const liveActivityStaleDate = () => new Date(Date.now() + LIVE_ACTIVITY_STALE_AFTER_MS);
 const registeredActivityPushTokens = new Map<string, number>();
+// Refreshes can overlap (sign-in, foreground, retry); only the newest read may
+// repaint, so a slow older response never overwrites newer rows.
+let widgetSnapshotReads = 0;
 let androidDeviceReplayedAt: number | null = null;
 let pushTokenSubscription: { remove: () => void } | null = null;
 let appStateSubscription: { remove: () => void } | null = null;
@@ -181,6 +186,9 @@ export function setAgentAwarenessRelayTokenProvider(
     if (relayTokenProviderIdentity && identity !== relayTokenProviderIdentity) {
       clearAndroidAgentNotifications();
     }
+    if (provider) {
+      publishWidget({ kind: "loading" }, identity ?? null);
+    }
     androidDeviceReplayedAt = null;
     deviceRegistrationGeneration++;
     activeDeviceRegistration = null;
@@ -201,6 +209,7 @@ export function setAgentAwarenessRelayTokenProvider(
     }
     // Signed-out activities would be orphaned because the relay can no longer update or end them.
     endLocalLiveActivities("live activity cleanup after cloud sign-out failed");
+    publishWidget({ kind: "signed-out" });
     setRegistrationStatus("unknown");
     void clearAgentAwarenessRegistrationRecord().catch((error: unknown) => {
       logRegistrationError("clear registration record on sign-out failed", error);
@@ -737,6 +746,18 @@ function ensureAppStateListener(): void {
   });
 }
 
+function publishWidget(
+  source: AgentActivityWidgetSource,
+  accountId = relayTokenProviderIdentity,
+): void {
+  if (!canRegisterRemoteLiveActivities()) {
+    return;
+  }
+  publishAgentActivityWidget(source, accountId).catch((error: unknown) => {
+    logRegistrationError("agent activity widget publish failed", error);
+  });
+}
+
 // Binaries built before the native dismissEnded method throw here.
 function dismissEndedLocalLiveActivities(): void {
   try {
@@ -813,6 +834,7 @@ export function __resetAgentAwarenessRemoteRegistrationForTest(): void {
   registrationStatusListeners.clear();
   registeredActivityPushTokens.clear();
   activityPushTokenLocks.clear();
+  widgetSnapshotReads = 0;
 }
 
 export const unregisterAgentAwarenessDeviceForCurrentUser: (
@@ -933,13 +955,43 @@ function scheduleActiveLiveActivityRegistrationRetry(): void {
   }, REMOTE_ACTIVITY_REGISTRATION_RETRY_MS);
 }
 
-const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
+export const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
   "remoteRegistration.refreshActiveLiveActivityRemoteRegistration",
 )(function* (): Effect.fn.Return<void, never, ManagedRelay.ManagedRelayClient> {
   if (!canRegisterRemoteLiveActivities() || !relayTokenProvider) {
     return;
   }
 
+  // The home-screen widget has no push path of its own, so every foreground
+  // refresh repaints it from one snapshot read. Yields undefined once the
+  // account changed or a newer read started, so a stale result is never
+  // shown or primed.
+  const identity = relayTokenProviderIdentity;
+  const generation = deviceRegistrationGeneration;
+  const isCurrentAccount = () =>
+    relayTokenProvider !== null &&
+    relayTokenProviderIdentity === identity &&
+    deviceRegistrationGeneration === generation;
+  let read = 0;
+  const isNewestRead = () => isCurrentAccount() && read === widgetSnapshotReads;
+  const refreshWidget = Effect.gen(function* () {
+    // An obsolete refresh must not supersede the current account's read.
+    if (!isCurrentAccount()) {
+      return undefined;
+    }
+    read = ++widgetSnapshotReads;
+    const snapshot = yield* readAgentActivitySnapshot();
+    if (!isNewestRead()) {
+      return undefined;
+    }
+    if (snapshot) {
+      publishWidget({ kind: "snapshot", aggregate: snapshot.aggregate });
+    } else {
+      publishWidget({ kind: "unavailable" });
+    }
+    return { snapshot };
+  });
+
   dismissEndedLocalLiveActivities();
   let activities = yield* Effect.try({
     try: () => getAgentLiveActivities(),
@@ -959,6 +1011,7 @@ const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
 
   // The relay tracks exactly one card per device; if concurrent arming ever
   // produced extras, end them so only one keeps receiving updates.
+  const hadActivities = activities.length > 0;
   if (activities.length > 1) {
     for (const extra of activities.slice(1)) {
       extra.end("immediate").catch((error: unknown) => {
@@ -972,7 +1025,12 @@ const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
   // update token can be observed and registered immediately — the relay never
   // remote-starts one (background push-to-start wakes proved too unreliable
   // to hand the token over).
-  if (activities.length === 0) {
+  if (!hadActivities) {
+    const widgetRead = yield* refreshWidget;
+    if (!widgetRead) {
+      return;
+    }
+    const { snapshot } = widgetRead;
     const preferences = yield* Effect.tryPromise({
       try: () => loadPreferences(),
       catch: (cause) =>
@@ -981,10 +1039,14 @@ const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
           cause,
         }),
     }).pipe(Effect.orElseSucceed(() => null));
+    // A sign-out, account switch, or newer read during the preference read
+    // makes this snapshot stale; priming now could bring old rows back.
+    if (!isNewestRead()) {
+      return;
+    }
     if (preferences?.liveActivitiesEnabled !== false) {
-      const snapshot = yield* readAgentActivitySnapshot();
-      // The snapshot request yields; an arm-on-send may have created the
-      // card in the meantime. Re-check so two cards are never started.
+      // The snapshot and preference reads yield; an arm-on-send may have
+      // created the card in the meantime. Re-check so two cards are never started.
       const armedMeanwhile = yield* Effect.try({
         try: () => getAgentLiveActivities(),
         catch: () => [] as ReadonlyArray<LiveActivity<AgentActivityProps>>,
@@ -1025,6 +1087,11 @@ const refreshActiveLiveActivityRemoteRegistration = Effect.fn(
     }
   }
 
+  if (hadActivities) {
+    yield* refreshWidget;
+    if (!isCurrentAccount()) return;
+  }
+
   const registrationResults = yield* Effect.forEach(activities, (activity) =>
     registerLiveActivityPushToken({ activity }).pipe(
       Effect.map((registered) => !registered),

apps/mobile/src/widgets/AgentActivityWidget.test.mjs

@@ -0,0 +1,201 @@
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodeModule from "node:module";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+import * as NodeVM from "node:vm";
+import { expect, it } from "vite-plus/test";
+
+const require = NodeModule.createRequire(import.meta.url);
+const { getConfig } = require("expo/config");
+
+it("embeds an Agent Activity Home Screen layout and initial data independently of Live Activities", () => {
+  const projectRoot = NodePath.resolve(import.meta.dirname, "../..");
+  const { exp } = getConfig(projectRoot, { skipSDKVersionRequirement: true });
+  const plugin = exp.plugins.find((entry) => Array.isArray(entry) && entry[0] === "expo-widgets");
+  const widget = plugin[1].widgets.find((entry) => entry.name === "AgentActivity");
+  expect(widget.ios.initialLayout).toBeDefined();
+  const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-activity-layout-"));
+  try {
+    const configPath = NodePath.join(directory, "config.json");
+    const outputPath = NodePath.join(directory, "registry.json");
+    NodeFS.writeFileSync(
+      configPath,
+      JSON.stringify({ widgets: [{ name: widget.name, initialLayout: widget.ios.initialLayout }] }),
+    );
+    NodeChildProcess.execFileSync(
+      process.execPath,
+      [
+        require.resolve("expo-widgets/scripts/build-layout-registry.mjs"),
+        projectRoot,
+        "ios",
+        outputPath,
+        configPath,
+      ],
+      { cwd: projectRoot, stdio: "pipe" },
+    );
+    const { widgets } = JSON.parse(NodeFS.readFileSync(outputPath, "utf8"));
+    expect(widgets.AgentActivity.initialProps).toMatchObject({ activeCount: 0, activities: [] });
+    const runtimePath = NodePath.join(directory, "runtime.js");
+    NodeChildProcess.execFileSync(
+      process.execPath,
+      [require.resolve("expo-widgets/scripts/build-bundle.mjs"), projectRoot, "ios", runtimePath],
+      { cwd: projectRoot, stdio: "pipe" },
+    );
+    const context = NodeVM.createContext({ console, process: { env: {} } });
+    NodeVM.runInContext("Date.now = () => 2000", context);
+    NodeVM.runInContext(NodeFS.readFileSync(runtimePath, "utf8"), context);
+    context.__expoWidgetLayout = NodeVM.runInContext(`(${widgets.AgentActivity.layout})`, context);
+    const props = {
+      ...widgets.AgentActivity.initialProps,
+      activeCount: 1,
+      freshUntil: 3_000,
+      source: "snapshot",
+      baseUrl: "t3code-dev:///",
+      activities: [
+        {
+          environmentId: "environment",
+          threadId: "thread",
+          threadTitle: "Review the task",
+          projectTitle: "Project",
+          status: "Input",
+          phase: "waiting_for_input",
+          deepLink: "/threads/environment/mcp%3Atask",
+        },
+      ],
+    };
+    for (const widgetFamily of widget.ios.supportedFamilies) {
+      const environment = { widgetFamily, colorScheme: "dark", widgetRenderingMode: "fullColor" };
+      const initial = JSON.stringify(
+        context.__expoWidgetRender(widgets.AgentActivity.initialProps, environment),
+      );
+      expect(initial).toContain("Open T3 Code");
+      const active = JSON.stringify(context.__expoWidgetRender(props, environment));
+      expect(active).toContain("1 active");
+      expect(active).toContain("Review the task");
+      expect(active).toContain("Input");
+      expect(active).toContain("t3code-dev:///threads/environment/mcp%3Atask");
+      for (const [source, subtitle] of [
+        ["loading", "Loading agents…"],
+        ["signed-out", "Sign in to T3 Connect to see agents"],
+        ["unavailable", "Couldn't reach T3 Connect"],
+        ["snapshot", "No active agents"],
+      ]) {
+        const empty = JSON.stringify(
+          context.__expoWidgetRender(
+            { activeCount: 0, activities: [], source, subtitle },
+            environment,
+          ),
+        );
+        expect(empty).toContain(subtitle);
+        expect(empty).not.toContain("Review the task");
+      }
+      const expired = JSON.stringify(
+        context.__expoWidgetRender({ ...props, freshUntil: 1_000 }, environment),
+      );
+      expect(expired).toContain("Out of date");
+      expect(expired).not.toContain("Input");
+      const scheduled = JSON.stringify(
+        context.__expoWidgetRender(props, { ...environment, timestamp: 3_000 }),
+      );
+      expect(scheduled).toContain("Out of date");
+      expect(scheduled).not.toContain("Input");
+    }
+    const aggregate = {
+      ...props,
+      activeCount: 10,
+      activities: Array.from({ length: 5 }, (_, index) => ({
+        ...props.activities[0],
+        threadId: `thread-${index}`,
+        threadTitle: `Relay task ${index + 1}`,
+        deepLink: `/threads/environment/task%3A${index + 1}`,
+        phase: "running",
+        status: "Working",
+      })),
+    };
+    for (const widgetFamily of ["systemSmall", "systemMedium", "systemLarge"]) {
+      const supplemented = JSON.stringify(
+        context.__expoWidgetRender(
+          {
+            ...aggregate,
+            supplementalActivities: [
+              aggregate.activities[0],
+              ...Array.from({ length: 7 }, (_, i) => ({
+                ...props.activities[0],
+                threadId: `local-${i}`,
+                threadTitle: `Local task ${i + 1}`,
+                phase: "completed",
+                status: "Done",
+                deepLink: `/threads/environment/local%3A${i + 1}`,
+              })),
+            ],
+          },
+          { widgetFamily, colorScheme: "light", widgetRenderingMode: "fullColor" },
+        ),
+      );
+      expect(supplemented).toContain("10 active");
+      if (widgetFamily === "systemLarge") {
+        expect(supplemented).toContain("Local task 2");
+        expect(supplemented).not.toContain("Local task 3");
+        expect(supplemented).toContain("t3code-dev:///threads/environment/local%3A2");
+      } else {
+        expect(supplemented).not.toContain("Local task");
+      }
+    }
+    const localOnly = JSON.stringify(
+      context.__expoWidgetRender(
+        {
+          ...props,
+          activeCount: 0,
+          activities: [],
+          supplementalActivities: [props.activities[0]],
+        },
+        { widgetFamily: "systemLarge", colorScheme: "light", widgetRenderingMode: "fullColor" },
+      ),
+    );
+    expect(localOnly).toContain("Review the task");
+    expect(localOnly).toContain("0 active");
+    for (const [widgetFamily, dynamicTypeSize, visibleRows] of [
+      ["systemMedium", "large", 5],
+      ["systemMedium", "xxLarge", 4],
+      ["systemMedium", "xxxLarge", 3],
+      ["systemMedium", "accessibility5", 1],
+      ["systemLarge", "large", 5],
+      ["systemLarge", "xLarge", 4],
+      ["systemLarge", "xxxLarge", 3],
+      ["systemLarge", "accessibility5", 2],
+    ]) {
+      const aggregateLayout = JSON.stringify(
+        context.__expoWidgetRender(aggregate, {
+          widgetFamily,
+          dynamicTypeSize,
+          colorScheme: "light",
+          widgetRenderingMode: "fullColor",
+        }),
+      );
+      expect(aggregateLayout).toContain(`Relay task ${visibleRows}`);
+      if (visibleRows < 5) {
+        expect(aggregateLayout).not.toContain(`Relay task ${visibleRows + 1}`);
+      }
+      expect(aggregateLayout).toContain("10 active");
+      expect(aggregateLayout).toContain(`t3code-dev:///threads/environment/task%3A${visibleRows}`);
+      expect(aggregateLayout).toContain("LinkView");
+      const waitingLayout = JSON.stringify(
+        context.__expoWidgetRender(
+          {
+            ...aggregate,
+            activities: aggregate.activities.map((row, index) =>
+              index === 0 ? { ...row, phase: "stale", status: "Waiting" } : row,
+            ),
+          },
+          { widgetFamily, dynamicTypeSize, colorScheme: "light", widgetRenderingMode: "fullColor" },
+        ),
+      );
+      expect(waitingLayout).toContain("Waiting");
+      expect(waitingLayout).toContain("10 active");
+      expect(waitingLayout).not.toContain("Out of date");
+    }
+  } finally {
+    NodeFS.rmSync(directory, { recursive: true, force: true });
+  }
+});