chore(foundry): improve sandbox impl + status pill (#252)

* Improve Daytona sandbox provisioning and frontend UI

Refactor git clone script in Daytona provider to use cleaner shell logic for GitHub token authentication and branch checkout. Add support for private repository clones with token-based auth. Improve Daytona provider error handling and git configuration setup.

Frontend improvements include enhanced dev panel, workspace dashboard, sidebar navigation, and UI components for better task/session management. Update interest manager and backend client to support improved session state handling.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

* Add header status pill showing task/session/sandbox state

Surface aggregate status (error, provisioning, running, ready, no sandbox)
as a colored pill in the transcript panel header. Integrates task runtime
status, session status, and sandbox availability via the sandboxProcesses
interest topic so the pill accurately reflects unreachable sandboxes.

Includes mock tasks demonstrating error, provisioning, and running states,
unit tests for deriveHeaderStatus, and workspace-dashboard integration.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>

foundry/packages/frontend/src/features/tasks/model.test.ts

@@ -10,7 +10,7 @@ const base: TaskRecord = {
   branchName: "feature/one",
   title: "Feature one",
   task: "Ship one",
-  providerId: "daytona",
+  providerId: "local",
   status: "running",
   statusMessage: null,
   activeSandboxId: "sandbox-1",
@@ -18,9 +18,9 @@ const base: TaskRecord = {
   sandboxes: [
     {
       sandboxId: "sandbox-1",
-      providerId: "daytona",
+      providerId: "local",
       sandboxActorId: null,
-      switchTarget: "daytona://sandbox-1",
+      switchTarget: "sandbox://local/sandbox-1",
       cwd: null,
       createdAt: 10,
       updatedAt: 10,

foundry/packages/frontend/src/features/tasks/status.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import { TaskStatusSchema } from "@sandbox-agent/foundry-shared";
+import { defaultTaskStatusMessage, deriveHeaderStatus, describeTaskState, isProvisioningTaskStatus, resolveTaskStateDetail } from "./status";
+
+describe("defaultTaskStatusMessage", () => {
+  it("covers every backend task status", () => {
+    for (const status of [...TaskStatusSchema.options, "new"] as const) {
+      expect(defaultTaskStatusMessage(status)).toMatch(/\S/);
+    }
+  });
+
+  it("returns the expected copy for init_ensure_name", () => {
+    expect(defaultTaskStatusMessage("init_ensure_name")).toBe("Determining title and branch.");
+  });
+});
+
+describe("resolveTaskStateDetail", () => {
+  it("prefers the backend status message when present", () => {
+    expect(resolveTaskStateDetail("init_ensure_name", "determining title and branch")).toBe("determining title and branch");
+  });
+
+  it("falls back to the default copy when the backend message is empty", () => {
+    expect(resolveTaskStateDetail("init_complete", "  ")).toBe("Finalizing task initialization.");
+  });
+});
+
+describe("describeTaskState", () => {
+  it("includes the raw backend status code in the title", () => {
+    expect(describeTaskState("kill_destroy_sandbox", null)).toEqual({
+      title: "Task state: kill_destroy_sandbox",
+      detail: "Destroying sandbox resources.",
+    });
+  });
+});
+
+describe("isProvisioningTaskStatus", () => {
+  it("treats all init states as provisioning", () => {
+    expect(isProvisioningTaskStatus("init_bootstrap_db")).toBe(true);
+    expect(isProvisioningTaskStatus("init_ensure_name")).toBe(true);
+    expect(isProvisioningTaskStatus("init_complete")).toBe(true);
+  });
+
+  it("does not treat steady-state or terminal states as provisioning", () => {
+    expect(isProvisioningTaskStatus("running")).toBe(false);
+    expect(isProvisioningTaskStatus("archived")).toBe(false);
+    expect(isProvisioningTaskStatus("killed")).toBe(false);
+  });
+});
+
+describe("deriveHeaderStatus", () => {
+  it("returns error variant when session has error", () => {
+    const result = deriveHeaderStatus("running", null, "error", "Sandbox crashed");
+    expect(result.variant).toBe("error");
+    expect(result.label).toBe("Session error");
+    expect(result.tooltip).toBe("Sandbox crashed");
+    expect(result.spinning).toBe(false);
+  });
+
+  it("returns error variant when task has error", () => {
+    const result = deriveHeaderStatus("error", "session:error", null, null);
+    expect(result.variant).toBe("error");
+    expect(result.label).toBe("Error");
+    expect(result.spinning).toBe(false);
+  });
+
+  it("returns warning variant with spinner for provisioning task", () => {
+    const result = deriveHeaderStatus("init_enqueue_provision", null, null, null);
+    expect(result.variant).toBe("warning");
+    expect(result.label).toBe("Provisioning");
+    expect(result.spinning).toBe(true);
+  });
+
+  it("returns warning variant for pending_provision session", () => {
+    const result = deriveHeaderStatus("running", null, "pending_provision", null);
+    expect(result.variant).toBe("warning");
+    expect(result.label).toBe("Provisioning");
+    expect(result.spinning).toBe(true);
+  });
+
+  it("returns warning variant for pending_session_create session", () => {
+    const result = deriveHeaderStatus("running", null, "pending_session_create", null);
+    expect(result.variant).toBe("warning");
+    expect(result.label).toBe("Creating session");
+    expect(result.spinning).toBe(true);
+  });
+
+  it("returns success variant with spinner for running session", () => {
+    const result = deriveHeaderStatus("running", null, "running", null);
+    expect(result.variant).toBe("success");
+    expect(result.label).toBe("Running");
+    expect(result.spinning).toBe(true);
+  });
+
+  it("returns success variant for idle/ready state", () => {
+    const result = deriveHeaderStatus("idle", null, "idle", null);
+    expect(result.variant).toBe("success");
+    expect(result.label).toBe("Ready");
+    expect(result.spinning).toBe(false);
+  });
+
+  it("returns neutral variant for archived task", () => {
+    const result = deriveHeaderStatus("archived", null, null, null);
+    expect(result.variant).toBe("neutral");
+    expect(result.label).toBe("Archived");
+  });
+
+  it("session error takes priority over task error", () => {
+    const result = deriveHeaderStatus("error", "session:error", "error", "Sandbox OOM");
+    expect(result.variant).toBe("error");
+    expect(result.label).toBe("Session error");
+    expect(result.tooltip).toBe("Sandbox OOM");
+  });
+
+  it("returns warning when no sandbox is available", () => {
+    const result = deriveHeaderStatus("idle", null, "idle", null, false);
+    expect(result.variant).toBe("warning");
+    expect(result.label).toBe("No sandbox");
+    expect(result.spinning).toBe(false);
+  });
+
+  it("still shows provisioning when no sandbox but task is provisioning", () => {
+    const result = deriveHeaderStatus("init_enqueue_provision", null, null, null, false);
+    expect(result.variant).toBe("warning");
+    expect(result.label).toBe("Provisioning");
+    expect(result.spinning).toBe(true);
+  });
+
+  it("shows error over no-sandbox when session has error", () => {
+    const result = deriveHeaderStatus("idle", null, "error", "Connection lost", false);
+    expect(result.variant).toBe("error");
+    expect(result.label).toBe("Session error");
+  });
+});

foundry/packages/frontend/src/features/tasks/status.ts

@@ -0,0 +1,179 @@
+import type { TaskStatus, WorkbenchSessionStatus } from "@sandbox-agent/foundry-shared";
+import type { HeaderStatusInfo } from "../../components/mock-layout/ui";
+
+export type TaskDisplayStatus = TaskStatus | "new";
+
+export interface TaskStateDescriptor {
+  title: string;
+  detail: string;
+}
+
+export function isProvisioningTaskStatus(status: TaskDisplayStatus | null | undefined): boolean {
+  return (
+    status === "new" ||
+    status === "init_bootstrap_db" ||
+    status === "init_enqueue_provision" ||
+    status === "init_ensure_name" ||
+    status === "init_assert_name" ||
+    status === "init_complete"
+  );
+}
+
+export function defaultTaskStatusMessage(status: TaskDisplayStatus | null | undefined): string {
+  switch (status) {
+    case "new":
+      return "Task created. Waiting to initialize.";
+    case "init_bootstrap_db":
+      return "Creating task records.";
+    case "init_enqueue_provision":
+      return "Queueing sandbox provisioning.";
+    case "init_ensure_name":
+      return "Determining title and branch.";
+    case "init_assert_name":
+      return "Validating title and branch.";
+    case "init_complete":
+      return "Finalizing task initialization.";
+    case "running":
+      return "Agent session is actively running.";
+    case "idle":
+      return "Sandbox is ready for the next prompt.";
+    case "archive_stop_status_sync":
+      return "Stopping sandbox status sync before archiving.";
+    case "archive_release_sandbox":
+      return "Releasing sandbox resources.";
+    case "archive_finalize":
+      return "Finalizing archive.";
+    case "archived":
+      return "Task has been archived.";
+    case "kill_destroy_sandbox":
+      return "Destroying sandbox resources.";
+    case "kill_finalize":
+      return "Finalizing task termination.";
+    case "killed":
+      return "Task has been terminated.";
+    case "error":
+      return "Task entered an error state.";
+    case null:
+    case undefined:
+      return "Task state unavailable.";
+  }
+}
+
+export function resolveTaskStateDetail(status: TaskDisplayStatus | null | undefined, statusMessage: string | null | undefined): string {
+  const normalized = statusMessage?.trim();
+  return normalized && normalized.length > 0 ? normalized : defaultTaskStatusMessage(status);
+}
+
+export function describeTaskState(status: TaskDisplayStatus | null | undefined, statusMessage: string | null | undefined): TaskStateDescriptor {
+  return {
+    title: status ? `Task state: ${status}` : "Task state unavailable",
+    detail: resolveTaskStateDetail(status, statusMessage),
+  };
+}
+
+/**
+ * Derives the header status pill state from the combined task + active session + sandbox state.
+ * Priority: session error > task error > no sandbox > provisioning > running > ready/idle > neutral.
+ */
+export function deriveHeaderStatus(
+  taskStatus: TaskDisplayStatus | null | undefined,
+  taskStatusMessage: string | null | undefined,
+  sessionStatus: WorkbenchSessionStatus | null | undefined,
+  sessionErrorMessage: string | null | undefined,
+  hasSandbox?: boolean,
+): HeaderStatusInfo {
+  // Session error takes priority
+  if (sessionStatus === "error") {
+    return {
+      variant: "error",
+      label: "Session error",
+      spinning: false,
+      tooltip: sessionErrorMessage ?? "Session failed to start.",
+    };
+  }
+
+  // Task error
+  if (taskStatus === "error") {
+    return {
+      variant: "error",
+      label: "Error",
+      spinning: false,
+      tooltip: taskStatusMessage ?? "Task entered an error state.",
+    };
+  }
+
+  // No sandbox available (not provisioning, not errored — just missing)
+  if (hasSandbox === false && !isProvisioningTaskStatus(taskStatus)) {
+    return {
+      variant: "warning",
+      label: "No sandbox",
+      spinning: false,
+      tooltip: taskStatusMessage ?? "Sandbox is not available for this task.",
+    };
+  }
+
+  // Task provisioning (init_* states)
+  if (isProvisioningTaskStatus(taskStatus)) {
+    return {
+      variant: "warning",
+      label: "Provisioning",
+      spinning: true,
+      tooltip: resolveTaskStateDetail(taskStatus, taskStatusMessage),
+    };
+  }
+
+  // Session pending states
+  if (sessionStatus === "pending_provision") {
+    return {
+      variant: "warning",
+      label: "Provisioning",
+      spinning: true,
+      tooltip: "Provisioning sandbox...",
+    };
+  }
+
+  if (sessionStatus === "pending_session_create") {
+    return {
+      variant: "warning",
+      label: "Creating session",
+      spinning: true,
+      tooltip: "Creating agent session...",
+    };
+  }
+
+  // Running
+  if (sessionStatus === "running") {
+    return {
+      variant: "success",
+      label: "Running",
+      spinning: true,
+      tooltip: "Agent is actively running.",
+    };
+  }
+
+  // Ready / idle
+  if (sessionStatus === "ready" || sessionStatus === "idle" || taskStatus === "idle" || taskStatus === "running") {
+    return {
+      variant: "success",
+      label: "Ready",
+      spinning: false,
+      tooltip: "Sandbox is ready.",
+    };
+  }
+
+  // Terminal states
+  if (taskStatus === "archived" || taskStatus === "killed") {
+    return {
+      variant: "neutral",
+      label: taskStatus === "archived" ? "Archived" : "Terminated",
+      spinning: false,
+    };
+  }
+
+  // Fallback
+  return {
+    variant: "neutral",
+    label: taskStatus ?? "Unknown",
+    spinning: false,
+  };
+}