fix(sandbox): stop hard-failing threads when no sandbox image is configured

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

@@ -24,6 +24,7 @@ export function SandboxDesktopPanel(props: {
   const exportBranch = useAtomCommand(threadEnvironment.exportSandboxBranch, {
     reportFailure: false,
   });
+  const stop = useAtomCommand(threadEnvironment.stopSandbox, { reportFailure: false });
   const viewerTicket = useAtomCommand(threadEnvironment.requestSandboxViewerTicket, {
     reportFailure: false,
   });
@@ -45,6 +46,11 @@ export function SandboxDesktopPanel(props: {
   );
   const target = { environmentId: props.environmentId } as const;
   const human = sandbox?.controller.kind === "human" ? sandbox.controller : null;
+  // Headless deployments run the sandbox with no desktop, so there is nothing
+  // to view or take control of -- but stopping and exporting still apply.
+  const desktopUnavailable = sandbox != null && sandbox.desktop.status === "unavailable";
+  const stoppable =
+    sandbox != null && !["stopped", "expired", "deleted"].includes(sandbox.lifecycle);
   const openViewer = async () => {
     if (busy) return;
     setBusy(true);
@@ -67,7 +73,9 @@ export function SandboxDesktopPanel(props: {
     <View className="border-t border-border bg-card px-4 py-2">
       <View className="flex-row items-center gap-2">
         <View className="min-w-0 flex-1">
-          <Text className="text-xs font-t3-bold text-foreground">Isolated desktop</Text>
+          <Text className="text-xs font-t3-bold text-foreground">
+            {desktopUnavailable ? "Isolated sandbox" : "Isolated desktop"}
+          </Text>
           <Text className="text-xs text-foreground-muted" numberOfLines={1}>
             {sandbox
               ? `${sandbox.lifecycle.replaceAll("-", " ")} · ${sandbox.branch.branchName}`
@@ -90,7 +98,7 @@ export function SandboxDesktopPanel(props: {
             <Text className="text-sm font-t3-bold text-accent">Open</Text>
           </Pressable>
         ) : null}
-        {sandbox && human === null && sandbox.lifecycle === "ready" ? (
+        {sandbox && human === null && sandbox.lifecycle === "ready" && !desktopUnavailable ? (
           <Pressable
             disabled={busy}
             onPress={() =>
@@ -135,6 +143,16 @@ export function SandboxDesktopPanel(props: {
             <Text className="text-sm font-t3-bold text-accent">Export</Text>
           </Pressable>
         ) : null}
+        {stoppable ? (
+          <Pressable
+            disabled={busy || human !== null}
+            onPress={() =>
+              void run(() => stop({ ...target, input: { threadId: props.thread.id } }))
+            }
+          >
+            <Text className="text-sm font-t3-bold text-danger-foreground">Stop</Text>
+          </Pressable>
+        ) : null}
       </View>
       {sandbox ? (
         <Text className="mt-1 text-[11px] text-foreground-muted">

apps/server/src/checkpointing/CheckpointStore.ts

@@ -172,6 +172,10 @@ export const make = Effect.gen(function* () {
         args,
         cwd,
         ...(options?.env === undefined ? {} : { env: options.env }),
+        // Without this the backend throws on any non-zero exit and the
+        // `allowNonZero` branch below is unreachable -- so a `rev-parse` probe
+        // for an absent ref failed the turn instead of answering "no".
+        ...(options?.allowNonZero === true ? { allowNonZeroExit: true } : {}),
         timeoutMs: 30_000,
       })
       .pipe(

apps/server/src/orchestration/CommandDispatcher.ts

@@ -21,6 +21,11 @@ import * as ServerConfig from "../config.ts";
 import { resolveInteractiveEfficiency } from "../efficiency/EfficiencyRouting.ts";
 import * as GitWorkflowService from "../git/GitWorkflowService.ts";
 import { ProviderRegistry } from "../provider/Services/ProviderRegistry.ts";
+import { T3ProjectFileLoader } from "../project/T3ProjectFileLoader.ts";
+import {
+  resolveSandboxImage,
+  resolveSandboxPreviewProxyImage,
+} from "../sandbox/SandboxRuntimeManager.ts";
 import { ServerSettingsService } from "../serverSettings.ts";
 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
 import { normalizeDispatchCommand } from "./Normalizer.ts";
@@ -100,6 +105,7 @@ export const make = Effect.gen(function* () {
   const providerRegistry = yield* ProviderRegistry;
   const serverSettings = yield* ServerSettingsService;
   const gitWorkflow = yield* GitWorkflowService.GitWorkflowService;
+  const projectFileLoader = yield* T3ProjectFileLoader;
   const setupScriptRunner = yield* ProjectSetupScriptRunner.ProjectSetupScriptRunner;
   const vcsStatusBroadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
   const fileSystem = yield* FileSystem.FileSystem;
@@ -410,6 +416,14 @@ export const make = Effect.gen(function* () {
         return yield* new OrchestrationDispatchCommandError({
           message: `Project '${create.projectId}' was not found.`,
         });
+      const projectFile = Option.getOrUndefined(
+        yield* projectFileLoader.load(project.workspaceRoot),
+      );
+      if (
+        resolveSandboxImage(projectFile) === undefined ||
+        resolveSandboxPreviewProxyImage() === undefined
+      )
+        return resolvedCommand;
       const local = yield* gitWorkflow
         .localStatus({ cwd: project.workspaceRoot })
         .pipe(

apps/server/src/orchestration/Layers/OrchestrationReactor.ts

@@ -10,6 +10,7 @@ import { ProviderCommandReactor } from "../Services/ProviderCommandReactor.ts";
 import { ProviderRuntimeIngestionService } from "../Services/ProviderRuntimeIngestion.ts";
 import { ThreadDeletionReactor } from "../Services/ThreadDeletionReactor.ts";
 import { SandboxLifecycleReactor } from "../Services/SandboxLifecycleReactor.ts";
+import { SandboxSettleCleanupReactor } from "../Services/SandboxSettleCleanupReactor.ts";
 import * as AgentAwarenessRelay from "../../relay/AgentAwarenessRelay.ts";
 
 export const makeOrchestrationReactor = Effect.gen(function* () {
@@ -18,6 +19,7 @@ export const makeOrchestrationReactor = Effect.gen(function* () {
   const checkpointReactor = yield* CheckpointReactor;
   const threadDeletionReactor = yield* ThreadDeletionReactor;
   const sandboxLifecycleReactor = yield* SandboxLifecycleReactor;
+  const sandboxSettleCleanupReactor = yield* SandboxSettleCleanupReactor;
   const agentAwarenessRelay = yield* AgentAwarenessRelay.AgentAwarenessRelay;
 
   const start: OrchestrationReactorShape["start"] = Effect.fn("start")(function* () {
@@ -26,6 +28,7 @@ export const makeOrchestrationReactor = Effect.gen(function* () {
     yield* checkpointReactor.start();
     yield* threadDeletionReactor.start();
     yield* sandboxLifecycleReactor.start();
+    yield* sandboxSettleCleanupReactor.start();
     yield* agentAwarenessRelay.start();
   });
 
@@ -35,6 +38,7 @@ export const makeOrchestrationReactor = Effect.gen(function* () {
     yield* checkpointReactor.drain;
     yield* threadDeletionReactor.drain;
     yield* sandboxLifecycleReactor.drain;
+    yield* sandboxSettleCleanupReactor.drain;
   });
 
   return {