Rename Foundry handoffs to tasks (#239)

* Restore foundry onboarding stack

* Consolidate foundry rename

* Create foundry tasks without prompts

* Rename Foundry handoffs to tasks

foundry/packages/client/src/mock-app.ts

@@ -0,0 +1,697 @@
+import { injectMockLatency } from "./mock/latency.js";
+
+export type MockBillingPlanId = "free" | "team";
+export type MockBillingStatus = "active" | "trialing" | "past_due" | "scheduled_cancel";
+export type MockGithubInstallationStatus = "connected" | "install_required" | "reconnect_required";
+export type MockGithubSyncStatus = "pending" | "syncing" | "synced" | "error";
+export type MockOrganizationKind = "personal" | "organization";
+export type MockStarterRepoStatus = "pending" | "starred" | "skipped";
+
+export interface MockFoundryUser {
+  id: string;
+  name: string;
+  email: string;
+  githubLogin: string;
+  roleLabel: string;
+  eligibleOrganizationIds: string[];
+}
+
+export interface MockFoundryOrganizationMember {
+  id: string;
+  name: string;
+  email: string;
+  role: "owner" | "admin" | "member";
+  state: "active" | "invited";
+}
+
+export interface MockFoundryInvoice {
+  id: string;
+  label: string;
+  issuedAt: string;
+  amountUsd: number;
+  status: "paid" | "open";
+}
+
+export interface MockFoundryBillingState {
+  planId: MockBillingPlanId;
+  status: MockBillingStatus;
+  seatsIncluded: number;
+  trialEndsAt: string | null;
+  renewalAt: string | null;
+  stripeCustomerId: string;
+  paymentMethodLabel: string;
+  invoices: MockFoundryInvoice[];
+}
+
+export interface MockFoundryGithubState {
+  connectedAccount: string;
+  installationStatus: MockGithubInstallationStatus;
+  syncStatus: MockGithubSyncStatus;
+  importedRepoCount: number;
+  lastSyncLabel: string;
+  lastSyncAt: number | null;
+}
+
+export interface MockFoundryOrganizationSettings {
+  displayName: string;
+  slug: string;
+  primaryDomain: string;
+  seatAccrualMode: "first_prompt";
+  defaultModel: "claude-sonnet-4" | "claude-opus-4" | "gpt-4o" | "o3";
+  autoImportRepos: boolean;
+}
+
+export interface MockFoundryOrganization {
+  id: string;
+  workspaceId: string;
+  kind: MockOrganizationKind;
+  settings: MockFoundryOrganizationSettings;
+  github: MockFoundryGithubState;
+  billing: MockFoundryBillingState;
+  members: MockFoundryOrganizationMember[];
+  seatAssignments: string[];
+  repoCatalog: string[];
+}
+
+export interface MockFoundryAppSnapshot {
+  auth: {
+    status: "signed_out" | "signed_in";
+    currentUserId: string | null;
+  };
+  activeOrganizationId: string | null;
+  onboarding: {
+    starterRepo: {
+      repoFullName: string;
+      repoUrl: string;
+      status: MockStarterRepoStatus;
+      starredAt: number | null;
+      skippedAt: number | null;
+    };
+  };
+  users: MockFoundryUser[];
+  organizations: MockFoundryOrganization[];
+}
+
+export interface UpdateMockOrganizationProfileInput {
+  organizationId: string;
+  displayName: string;
+  slug: string;
+  primaryDomain: string;
+}
+
+export interface MockFoundryAppClient {
+  getSnapshot(): MockFoundryAppSnapshot;
+  subscribe(listener: () => void): () => void;
+  signInWithGithub(userId: string): Promise<void>;
+  signOut(): Promise<void>;
+  skipStarterRepo(): Promise<void>;
+  starStarterRepo(organizationId: string): Promise<void>;
+  selectOrganization(organizationId: string): Promise<void>;
+  updateOrganizationProfile(input: UpdateMockOrganizationProfileInput): Promise<void>;
+  triggerGithubSync(organizationId: string): Promise<void>;
+  completeHostedCheckout(organizationId: string, planId: MockBillingPlanId): Promise<void>;
+  openBillingPortal(organizationId: string): Promise<void>;
+  cancelScheduledRenewal(organizationId: string): Promise<void>;
+  resumeSubscription(organizationId: string): Promise<void>;
+  reconnectGithub(organizationId: string): Promise<void>;
+  recordSeatUsage(workspaceId: string): void;
+}
+
+const STORAGE_KEY = "sandbox-agent-foundry:mock-app:v1";
+
+function isoDate(daysFromNow: number): string {
+  const value = new Date();
+  value.setDate(value.getDate() + daysFromNow);
+  return value.toISOString();
+}
+
+function syncStatusFromLegacy(value: unknown): MockGithubSyncStatus {
+  switch (value) {
+    case "ready":
+    case "synced":
+      return "synced";
+    case "importing":
+    case "syncing":
+      return "syncing";
+    case "error":
+      return "error";
+    default:
+      return "pending";
+  }
+}
+
+function buildDefaultSnapshot(): MockFoundryAppSnapshot {
+  return {
+    auth: {
+      status: "signed_out",
+      currentUserId: null,
+    },
+    activeOrganizationId: null,
+    onboarding: {
+      starterRepo: {
+        repoFullName: "rivet-dev/sandbox-agent",
+        repoUrl: "https://github.com/rivet-dev/sandbox-agent",
+        status: "pending",
+        starredAt: null,
+        skippedAt: null,
+      },
+    },
+    users: [
+      {
+        id: "user-nathan",
+        name: "Nathan",
+        email: "nathan@acme.dev",
+        githubLogin: "nathan",
+        roleLabel: "Founder",
+        eligibleOrganizationIds: ["personal-nathan", "acme", "rivet"],
+      },
+      {
+        id: "user-maya",
+        name: "Maya",
+        email: "maya@acme.dev",
+        githubLogin: "maya",
+        roleLabel: "Staff Engineer",
+        eligibleOrganizationIds: ["acme"],
+      },
+      {
+        id: "user-jamie",
+        name: "Jamie",
+        email: "jamie@rivet.dev",
+        githubLogin: "jamie",
+        roleLabel: "Platform Lead",
+        eligibleOrganizationIds: ["personal-jamie", "rivet"],
+      },
+    ],
+    organizations: [
+      {
+        id: "personal-nathan",
+        workspaceId: "personal-nathan",
+        kind: "personal",
+        settings: {
+          displayName: "Nathan",
+          slug: "nathan",
+          primaryDomain: "personal",
+          seatAccrualMode: "first_prompt",
+          defaultModel: "claude-sonnet-4",
+          autoImportRepos: true,
+        },
+        github: {
+          connectedAccount: "nathan",
+          installationStatus: "connected",
+          syncStatus: "synced",
+          importedRepoCount: 1,
+          lastSyncLabel: "Synced just now",
+          lastSyncAt: Date.now() - 60_000,
+        },
+        billing: {
+          planId: "free",
+          status: "active",
+          seatsIncluded: 1,
+          trialEndsAt: null,
+          renewalAt: null,
+          stripeCustomerId: "cus_mock_personal_nathan",
+          paymentMethodLabel: "No card required",
+          invoices: [],
+        },
+        members: [{ id: "member-nathan", name: "Nathan", email: "nathan@acme.dev", role: "owner", state: "active" }],
+        seatAssignments: ["nathan@acme.dev"],
+        repoCatalog: ["nathan/personal-site"],
+      },
+      {
+        id: "acme",
+        workspaceId: "acme",
+        kind: "organization",
+        settings: {
+          displayName: "Acme",
+          slug: "acme",
+          primaryDomain: "acme.dev",
+          seatAccrualMode: "first_prompt",
+          defaultModel: "claude-sonnet-4",
+          autoImportRepos: true,
+        },
+        github: {
+          connectedAccount: "acme",
+          installationStatus: "connected",
+          syncStatus: "pending",
+          importedRepoCount: 3,
+          lastSyncLabel: "Waiting for first import",
+          lastSyncAt: null,
+        },
+        billing: {
+          planId: "team",
+          status: "active",
+          seatsIncluded: 5,
+          trialEndsAt: null,
+          renewalAt: isoDate(18),
+          stripeCustomerId: "cus_mock_acme_team",
+          paymentMethodLabel: "Visa ending in 4242",
+          invoices: [
+            { id: "inv-acme-001", label: "March 2026", issuedAt: "2026-03-01", amountUsd: 240, status: "paid" },
+            { id: "inv-acme-000", label: "February 2026", issuedAt: "2026-02-01", amountUsd: 240, status: "paid" },
+          ],
+        },
+        members: [
+          { id: "member-acme-nathan", name: "Nathan", email: "nathan@acme.dev", role: "owner", state: "active" },
+          { id: "member-acme-maya", name: "Maya", email: "maya@acme.dev", role: "admin", state: "active" },
+          { id: "member-acme-priya", name: "Priya", email: "priya@acme.dev", role: "member", state: "active" },
+          { id: "member-acme-devon", name: "Devon", email: "devon@acme.dev", role: "member", state: "invited" },
+        ],
+        seatAssignments: ["nathan@acme.dev", "maya@acme.dev"],
+        repoCatalog: ["acme/backend", "acme/frontend", "acme/infra"],
+      },
+      {
+        id: "rivet",
+        workspaceId: "rivet",
+        kind: "organization",
+        settings: {
+          displayName: "Rivet",
+          slug: "rivet",
+          primaryDomain: "rivet.dev",
+          seatAccrualMode: "first_prompt",
+          defaultModel: "o3",
+          autoImportRepos: true,
+        },
+        github: {
+          connectedAccount: "rivet-dev",
+          installationStatus: "reconnect_required",
+          syncStatus: "error",
+          importedRepoCount: 4,
+          lastSyncLabel: "Sync stalled 2 hours ago",
+          lastSyncAt: Date.now() - 2 * 60 * 60_000,
+        },
+        billing: {
+          planId: "team",
+          status: "trialing",
+          seatsIncluded: 5,
+          trialEndsAt: isoDate(12),
+          renewalAt: isoDate(12),
+          stripeCustomerId: "cus_mock_rivet_team",
+          paymentMethodLabel: "Visa ending in 4242",
+          invoices: [{ id: "inv-rivet-001", label: "Team pilot", issuedAt: "2026-03-04", amountUsd: 0, status: "paid" }],
+        },
+        members: [
+          { id: "member-rivet-jamie", name: "Jamie", email: "jamie@rivet.dev", role: "owner", state: "active" },
+          { id: "member-rivet-nathan", name: "Nathan", email: "nathan@acme.dev", role: "member", state: "active" },
+          { id: "member-rivet-lena", name: "Lena", email: "lena@rivet.dev", role: "admin", state: "active" },
+        ],
+        seatAssignments: ["jamie@rivet.dev"],
+        repoCatalog: ["rivet/dashboard", "rivet/agents", "rivet/billing", "rivet/infrastructure"],
+      },
+      {
+        id: "personal-jamie",
+        workspaceId: "personal-jamie",
+        kind: "personal",
+        settings: {
+          displayName: "Jamie",
+          slug: "jamie",
+          primaryDomain: "personal",
+          seatAccrualMode: "first_prompt",
+          defaultModel: "claude-opus-4",
+          autoImportRepos: true,
+        },
+        github: {
+          connectedAccount: "jamie",
+          installationStatus: "connected",
+          syncStatus: "synced",
+          importedRepoCount: 1,
+          lastSyncLabel: "Synced yesterday",
+          lastSyncAt: Date.now() - 24 * 60 * 60_000,
+        },
+        billing: {
+          planId: "free",
+          status: "active",
+          seatsIncluded: 1,
+          trialEndsAt: null,
+          renewalAt: null,
+          stripeCustomerId: "cus_mock_personal_jamie",
+          paymentMethodLabel: "No card required",
+          invoices: [],
+        },
+        members: [{ id: "member-jamie", name: "Jamie", email: "jamie@rivet.dev", role: "owner", state: "active" }],
+        seatAssignments: ["jamie@rivet.dev"],
+        repoCatalog: ["jamie/demo-app"],
+      },
+    ],
+  };
+}
+
+function parseStoredSnapshot(): MockFoundryAppSnapshot | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+
+  const raw = window.localStorage.getItem(STORAGE_KEY);
+  if (!raw) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as MockFoundryAppSnapshot & {
+      organizations?: Array<MockFoundryOrganization & { repoImportStatus?: string }>;
+    };
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return {
+      ...parsed,
+      onboarding: {
+        starterRepo: {
+          repoFullName: parsed.onboarding?.starterRepo?.repoFullName ?? "rivet-dev/sandbox-agent",
+          repoUrl: parsed.onboarding?.starterRepo?.repoUrl ?? "https://github.com/rivet-dev/sandbox-agent",
+          status: parsed.onboarding?.starterRepo?.status ?? "pending",
+          starredAt: parsed.onboarding?.starterRepo?.starredAt ?? null,
+          skippedAt: parsed.onboarding?.starterRepo?.skippedAt ?? null,
+        },
+      },
+      organizations: (parsed.organizations ?? []).map((organization: MockFoundryOrganization & { repoImportStatus?: string }) => ({
+        ...organization,
+        github: {
+          ...organization.github,
+          syncStatus: syncStatusFromLegacy(organization.github?.syncStatus ?? organization.repoImportStatus),
+          lastSyncAt: organization.github?.lastSyncAt ?? null,
+        },
+      })),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function saveSnapshot(snapshot: MockFoundryAppSnapshot): void {
+  if (typeof window === "undefined") {
+    return;
+  }
+
+  window.localStorage.setItem(STORAGE_KEY, JSON.stringify(snapshot));
+}
+
+function planSeatsIncluded(planId: MockBillingPlanId): number {
+  switch (planId) {
+    case "free":
+      return 1;
+    case "team":
+      return 5;
+  }
+}
+
+class MockFoundryAppStore implements MockFoundryAppClient {
+  private snapshot = parseStoredSnapshot() ?? buildDefaultSnapshot();
+  private listeners = new Set<() => void>();
+  private importTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  getSnapshot(): MockFoundryAppSnapshot {
+    return this.snapshot;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  async signInWithGithub(userId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    const user = this.snapshot.users.find((candidate) => candidate.id === userId);
+    if (!user) {
+      throw new Error(`Unknown mock user ${userId}`);
+    }
+
+    this.updateSnapshot((current) => {
+      const activeOrganizationId = user.eligibleOrganizationIds.length === 1 ? (user.eligibleOrganizationIds[0] ?? null) : null;
+      return {
+        ...current,
+        auth: {
+          status: "signed_in",
+          currentUserId: userId,
+        },
+        activeOrganizationId,
+      };
+    });
+
+    if (user.eligibleOrganizationIds.length === 1) {
+      await this.selectOrganization(user.eligibleOrganizationIds[0]!);
+    }
+  }
+
+  async signOut(): Promise<void> {
+    await this.injectAsyncLatency();
+    this.updateSnapshot((current) => ({
+      ...current,
+      auth: {
+        status: "signed_out",
+        currentUserId: null,
+      },
+      activeOrganizationId: null,
+      onboarding: {
+        starterRepo: {
+          ...current.onboarding.starterRepo,
+          status: "pending",
+          starredAt: null,
+          skippedAt: null,
+        },
+      },
+    }));
+  }
+
+  async skipStarterRepo(): Promise<void> {
+    await this.injectAsyncLatency();
+    this.updateSnapshot((current) => ({
+      ...current,
+      onboarding: {
+        starterRepo: {
+          ...current.onboarding.starterRepo,
+          status: "skipped",
+          skippedAt: Date.now(),
+          starredAt: null,
+        },
+      },
+    }));
+  }
+
+  async starStarterRepo(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    this.updateSnapshot((current) => ({
+      ...current,
+      onboarding: {
+        starterRepo: {
+          ...current.onboarding.starterRepo,
+          status: "starred",
+          starredAt: Date.now(),
+          skippedAt: null,
+        },
+      },
+    }));
+  }
+
+  async selectOrganization(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    const org = this.requireOrganization(organizationId);
+    this.updateSnapshot((current) => ({
+      ...current,
+      activeOrganizationId: organizationId,
+    }));
+
+    if (org.github.syncStatus !== "synced") {
+      await this.triggerGithubSync(organizationId);
+    }
+  }
+
+  async updateOrganizationProfile(input: UpdateMockOrganizationProfileInput): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(input.organizationId);
+    this.updateOrganization(input.organizationId, (organization) => ({
+      ...organization,
+      settings: {
+        ...organization.settings,
+        displayName: input.displayName.trim() || organization.settings.displayName,
+        slug: input.slug.trim() || organization.settings.slug,
+        primaryDomain: input.primaryDomain.trim() || organization.settings.primaryDomain,
+      },
+    }));
+  }
+
+  async triggerGithubSync(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    const existingTimer = this.importTimers.get(organizationId);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+
+    this.updateOrganization(organizationId, (organization) => ({
+      ...organization,
+      github: {
+        ...organization.github,
+        syncStatus: "syncing",
+        lastSyncLabel: "Syncing repositories...",
+      },
+    }));
+
+    const timer = setTimeout(() => {
+      this.updateOrganization(organizationId, (organization) => ({
+        ...organization,
+        github: {
+          ...organization.github,
+          importedRepoCount: organization.repoCatalog.length,
+          installationStatus: "connected",
+          syncStatus: "synced",
+          lastSyncLabel: "Synced just now",
+          lastSyncAt: Date.now(),
+        },
+      }));
+      this.importTimers.delete(organizationId);
+    }, 1_250);
+
+    this.importTimers.set(organizationId, timer);
+  }
+
+  async completeHostedCheckout(organizationId: string, planId: MockBillingPlanId): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    this.updateOrganization(organizationId, (organization) => ({
+      ...organization,
+      billing: {
+        ...organization.billing,
+        planId,
+        status: "active",
+        seatsIncluded: planSeatsIncluded(planId),
+        trialEndsAt: null,
+        renewalAt: isoDate(30),
+        paymentMethodLabel: "Visa ending in 4242",
+        invoices: [
+          {
+            id: `inv-${organizationId}-${Date.now()}`,
+            label: `${organization.settings.displayName} ${planId} upgrade`,
+            issuedAt: new Date().toISOString().slice(0, 10),
+            amountUsd: planId === "team" ? 240 : 0,
+            status: "paid",
+          },
+          ...organization.billing.invoices,
+        ],
+      },
+    }));
+  }
+
+  async openBillingPortal(_organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+  }
+
+  async cancelScheduledRenewal(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    this.updateOrganization(organizationId, (organization) => ({
+      ...organization,
+      billing: {
+        ...organization.billing,
+        status: "scheduled_cancel",
+      },
+    }));
+  }
+
+  async resumeSubscription(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    this.updateOrganization(organizationId, (organization) => ({
+      ...organization,
+      billing: {
+        ...organization.billing,
+        status: "active",
+      },
+    }));
+  }
+
+  async reconnectGithub(organizationId: string): Promise<void> {
+    await this.injectAsyncLatency();
+    this.requireOrganization(organizationId);
+    this.updateOrganization(organizationId, (organization) => ({
+      ...organization,
+      github: {
+        ...organization.github,
+        installationStatus: "connected",
+        syncStatus: "pending",
+        lastSyncLabel: "Reconnected just now",
+        lastSyncAt: Date.now(),
+      },
+    }));
+  }
+
+  recordSeatUsage(workspaceId: string): void {
+    const org = this.snapshot.organizations.find((candidate) => candidate.workspaceId === workspaceId);
+    const currentUser = currentMockUser(this.snapshot);
+    if (!org || !currentUser) {
+      return;
+    }
+
+    if (org.seatAssignments.includes(currentUser.email)) {
+      return;
+    }
+
+    this.updateOrganization(org.id, (organization) => ({
+      ...organization,
+      seatAssignments: [...organization.seatAssignments, currentUser.email],
+    }));
+  }
+
+  private injectAsyncLatency(): Promise<void> {
+    return injectMockLatency();
+  }
+
+  private updateOrganization(organizationId: string, updater: (organization: MockFoundryOrganization) => MockFoundryOrganization): void {
+    this.updateSnapshot((current) => ({
+      ...current,
+      organizations: current.organizations.map((organization) => (organization.id === organizationId ? updater(organization) : organization)),
+    }));
+  }
+
+  private updateSnapshot(updater: (current: MockFoundryAppSnapshot) => MockFoundryAppSnapshot): void {
+    this.snapshot = updater(this.snapshot);
+    saveSnapshot(this.snapshot);
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+
+  private requireOrganization(organizationId: string): MockFoundryOrganization {
+    const organization = this.snapshot.organizations.find((candidate) => candidate.id === organizationId);
+    if (!organization) {
+      throw new Error(`Unknown mock organization ${organizationId}`);
+    }
+    return organization;
+  }
+}
+
+function currentMockUser(snapshot: MockFoundryAppSnapshot): MockFoundryUser | null {
+  if (!snapshot.auth.currentUserId) {
+    return null;
+  }
+  return snapshot.users.find((candidate) => candidate.id === snapshot.auth.currentUserId) ?? null;
+}
+
+const mockFoundryAppStore = new MockFoundryAppStore();
+
+export function getMockFoundryAppClient(): MockFoundryAppClient {
+  return mockFoundryAppStore;
+}
+
+export function currentMockFoundryUser(snapshot: MockFoundryAppSnapshot): MockFoundryUser | null {
+  return currentMockUser(snapshot);
+}
+
+export function currentMockFoundryOrganization(snapshot: MockFoundryAppSnapshot): MockFoundryOrganization | null {
+  if (!snapshot.activeOrganizationId) {
+    return null;
+  }
+  return snapshot.organizations.find((candidate) => candidate.id === snapshot.activeOrganizationId) ?? null;
+}
+
+export function eligibleMockOrganizations(snapshot: MockFoundryAppSnapshot): MockFoundryOrganization[] {
+  const user = currentMockUser(snapshot);
+  if (!user) {
+    return [];
+  }
+
+  const eligible = new Set(user.eligibleOrganizationIds);
+  return snapshot.organizations.filter((organization) => eligible.has(organization.id));
+}