fix(server): recover remote delegated launches after source restart

apps/mobile/src/features/threads/subagent-card-presentation.test.ts

@@ -1,13 +1,43 @@
 import * as DateTime from "effect/DateTime";
 import { describe, expect, it } from "vite-plus/test";
 import { subagentCardElapsed } from "./subagent-card-presentation";
+import { resolveSubagentRowPresentation, subagentThreadTarget } from "./threadAgentsPresentation";
 
 describe("subagent card", () => {
   const start = DateTime.makeUnsafe("2026-09-21T12:00:00Z");
   const end = DateTime.makeUnsafe("2026-09-21T12:01:00Z");
   const later = DateTime.makeUnsafe("2026-09-21T12:02:00Z");
   const done = { status: "completed" as const, startedAt: start, completedAt: end };
 
+  it("keeps a pending remote launch visible without opening a nonexistent thread", () => {
+    const pending = {
+      title: null,
+      prompt: "Audit the timestamps",
+      status: "running" as const,
+      result: null,
+      childThreadId: null,
+      remoteChild: { environmentId: "environment-box" as never, label: "Box" },
+    };
+    expect(resolveSubagentRowPresentation(pending, true)).toMatchObject({
+      runsOn: "Box",
+      statusLabel: "Launching",
+      canOpenThread: false,
+    });
+    expect(subagentThreadTarget(pending, "environment-here" as never, () => true)).toBeNull();
+    const launchError = "Launch unconfirmed; work may still be running on Box.";
+    expect(
+      resolveSubagentRowPresentation(
+        {
+          ...pending,
+          status: "cancelled",
+          result: "Cancelled.",
+          remoteChild: { ...pending.remoteChild, launchError },
+        },
+        true,
+      ),
+    ).toMatchObject({ statusLabel: "Cancelled", detail: launchError, canOpenThread: false });
+  });
+
   it("counts live work but never uses a settled agent's age as its duration", () => {
     const unfinished = { ...done, completedAt: null };
     expect(subagentCardElapsed([unfinished], DateTime.toEpochMillis(later))).toBeNull();

apps/mobile/src/features/threads/thread-subagent-group.tsx

@@ -127,6 +127,7 @@ export function ThreadSubagentGroup(props: {
       completedAt: live?.completedAt ?? item.completedAt,
       result: live?.result ?? item.result,
       progress: live?.progress ?? item.progress,
+      remoteChild: live?.remoteChild ?? item.remoteChild,
       model: live?.model ?? null,
       modelSelection: live?.modelSelection,
     };
@@ -152,7 +153,7 @@ export function ThreadSubagentGroup(props: {
           <View className="flex-row items-center">
             {agents.slice(0, 3).map((agent, index) => (
               <View key={agent.item.id} style={{ marginLeft: index === 0 ? 0 : -7 }}>
-                <SubagentAvatar item={agent.item} config={configOf(agent.item)} />
+                <SubagentAvatar item={agent} config={configOf(agent)} />
               </View>
             ))}
             {agents.length > 3 ? (

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

@@ -47,7 +47,9 @@ export function subagentThreadTarget(
     return { environmentId, threadId: subagent.childThreadId };
   }
   const remote = subagent.remoteChild;
-  return remote !== undefined && isKnownEnvironment(remote.environmentId)
+  return remote !== undefined &&
+    remote.threadId !== undefined &&
+    isKnownEnvironment(remote.environmentId)
     ? { environmentId: remote.environmentId, threadId: remote.threadId }
     : null;
 }
@@ -99,12 +101,19 @@ export function resolveSubagentRowPresentation(
   const live = isActiveSubagentStatus(subagent.status);
   return {
     title: rowTitle(subagent),
-    detail: subagentDetailPreview(subagent),
-    statusLabel: rowStatusLabel(subagent.status),
+    detail: subagentDetailPreview({
+      ...subagent,
+      result: subagent.remoteChild?.launchError ?? subagent.result,
+    }),
+    statusLabel:
+      live && subagent.remoteChild !== undefined && subagent.remoteChild.threadId === undefined
+        ? "Launching"
+        : rowStatusLabel(subagent.status),
     tone: rowTone(subagent.status),
     live,
     canOpenThread:
-      subagent.childThreadId !== null || (subagent.remoteChild !== undefined && canOpenRemote),
+      subagent.childThreadId !== null ||
+      (subagent.remoteChild?.threadId !== undefined && canOpenRemote),
     runsOn: subagent.remoteChild?.label ?? null,
   };
 }

apps/server/src/mcp/OrchestratorMcpService.ts

@@ -1971,8 +1971,27 @@ const make = Effect.gen(function* () {
       ...(task.remoteChild === undefined
         ? {}
         : {
-            remoteChild: task.remoteChild,
-            link: formatThreadLink(task.remoteChild, task.remoteChild.title),
+            ...(task.remoteChild.threadId === undefined
+              ? {}
+              : {
+                  link: formatThreadLink(
+                    {
+                      environmentId: task.remoteChild.environmentId,
+                      threadId: task.remoteChild.threadId,
+                    },
+                    task.remoteChild.title,
+                  ),
+                }),
+            remoteChild: {
+              environmentId: task.remoteChild.environmentId,
+              label: task.remoteChild.label,
+              ...(task.remoteChild.launchError === undefined
+                ? {}
+                : { launchError: task.remoteChild.launchError }),
+              ...(task.remoteChild.threadId === undefined
+                ? {}
+                : { threadId: task.remoteChild.threadId }),
+            },
           }),
       childRunId: null,
       childNodeId: task.id,

apps/server/src/mcp/toolkits/project/handlers.test.ts

@@ -61,6 +61,7 @@ const clientLaunchHarness = (input: {
   readonly hostedAppUrl?: string;
   /** The orchestrator refuses the new thread's mode, as under a managed ceiling. */
   readonly refusedByCeiling?: true;
+  readonly launchFailure?: "missing" | "lookup";
 }) => {
   const projectId = ProjectId.make("project:client-target");
   const modelSelection = {
@@ -125,6 +126,18 @@ const clientLaunchHarness = (input: {
       checkWorktreeBase: input.checkWorktreeBase ?? (() => Effect.void),
       launch: (launch) => {
         input.launched.push(launch);
+        if (input.launchFailure)
+          return Effect.fail(
+            new ThreadLaunch.ThreadLaunchError({
+              operation: "resolve-project",
+              commandId: launch.commandId,
+              projectId: launch.projectId,
+              cause:
+                input.launchFailure === "missing"
+                  ? new Project.ProjectNotFoundError({ projectId: launch.projectId })
+                  : new Error("Project storage unavailable"),
+            }),
+          );
         if (input.refusedByCeiling) {
           return Effect.fail(
             new ThreadLaunch.ThreadLaunchError({
@@ -934,6 +947,31 @@ it.effect("deleting a project through MCP also discards its clone record", () =>
   }),
 );
 
+it.effect.each(["missing", "lookup"] as const)(
+  "classifies %s project launch failures",
+  (launchFailure) =>
+    Effect.gen(function* () {
+      const { projectId, dependencies } = clientLaunchHarness({
+        runtimeModeCeiling: "full-access",
+        launched: [],
+        launchFailure,
+      });
+      const toolkit = yield* ProjectToolkit.pipe(
+        Effect.provide(
+          McpToolAccess.HandlersLayer.layer(ProjectHandlers.layer).pipe(
+            Layer.provide(dependencies),
+          ),
+        ),
+      );
+      const result = yield* toolkit
+        .handle("t3_thread_launch", { projectId, title: "Missing project" })
+        .pipe(Stream.unwrap, Stream.runCollect, Effect.provide(dependencies));
+      expect(result.at(-1)?.result).toMatchObject({
+        code: launchFailure === "missing" ? "invalid_request" : "orchestration_error",
+      });
+    }),
+);
+
 it.effect("an agent cannot delete the built-in scratch project, even with force", () =>
   Effect.gen(function* () {
     const deleted: Array<ProjectId> = [];

apps/server/src/mcp/toolkits/project/handlers.ts

@@ -33,6 +33,8 @@ import * as OrchestrationMcp from "../../OrchestratorMcpService.ts";
 import { newCommandId, readCaller, resolveProjectId, unavailable } from "../../threadAccess.ts";
 import { ProjectToolkit } from "./tools.ts";
 
+const isProjectNotFoundError = Schema.is(Project.ProjectNotFoundError);
+
 const isAboveCeilingError = Schema.is(OrchestratorRuntimeModeAboveCeilingError);
 
 function projectFailure(error: Project.ProjectServiceError) {
@@ -303,6 +305,12 @@ export const layer = McpToolAccess.toLayer(ProjectToolkit, {
                 message: error.message,
               });
             }
+            if (error._tag === "ThreadLaunchError" && isProjectNotFoundError(error.cause)) {
+              return new OrchestratorMcpFailure({
+                code: "invalid_request",
+                message: error.cause.message,
+              });
+            }
             // The administrator's ceiling refuses the mode; say so rather than "unavailable".
             if (error._tag === "ThreadLaunchError" && isAboveCeilingError(error.cause)) {
               return new OrchestratorMcpFailure({