feat: chat-first architecture + bud-parity workspace

Flip from project-first to chat-first (bud-exact). A prompt creates a
project-less chat (/chats/{id}; v2_threads.project_id nullable +
launch_intent); the project is created lazily and atomically on the first
run (SELECT ... FOR UPDATE) and named from a prompt slug. Single
POST /v1/threads creation path + createChat() client. Removed
bootstrapProjectThread / createProjectThread / private createProject and
the /projects ?thread= workspace mode; deleted dead thread-header.tsx;
"New chat" naming throughout (no more "Untitled").

DB:
- 0009: v2_threads.project_id DROP NOT NULL + launch_intent jsonb
- startRunWithLazyProject (atomic create+attach+sandbox+run) + shared
  active-project limit; full nullable-thread audit (projects/runs/search)

Web:
- app/(app)/chats/[chatId] route; ProjectsShell keyed by threadId with
  refetch-after-attach (Computer panel appears once the project attaches)
- home-composer: authed -> createChat + /chats/{id}; unauthed -> in-place
  AuthModal preserving the prompt handoff
- sidebar / command-palette / nav -> /chats; active-chat via pathname
- wired the dead ChatContextRow "New chat in {project}" button

Plus accumulated bud-parity workspace work (preview/Computer panel,
replay, settings, greeting) verified but previously uncommitted.

Verified end-to-end live on local + real Daytona.

Author: iamjr15

.gitignore

@@ -31,5 +31,9 @@ packages/skills/src/generated.ts
 /*.png
 .gemini-clipboard/
 
+# Local agent tooling + QA artifacts (not product code)
+/.agents/
+/.codex/
+
 # Claude Code transient session state
 .claude/last-session.json

apps/agent-worker/src/agent-routing.ts

@@ -55,6 +55,7 @@ export interface RunEntitlementPolicy {
   dailyCostCapUsd?: number;
   dailyCostUsdAtRunStart: number;
   maxConcurrentSandboxes: number;
+  maxProjects: number;
   quotaPeriodEnd: string;
   quotaWarning?: SandboxHoursQuotaWarning;
   researchFanoutSubagentLimit: number;
@@ -76,6 +77,12 @@ export async function sandboxForThread(
     if (!thread) {
       throw new APIError(404, "not_found_thread", "Thread not found", { retriable: false });
     }
+    if (!thread.projectId) {
+      throw new APIError(404, "not_found_project", "This chat has no workspace yet", {
+        hint: "Send a message to start the first run, which creates the project sandbox.",
+        retriable: false,
+      });
+    }
     return sandboxForProject(env, userId, thread.projectId);
   } finally {
     await close();
@@ -89,7 +96,7 @@ export async function sandboxForProject(
 ): Promise<DurableObjectStub<ProjectSandbox>> {
   const sandboxName = await projectSandboxName(userId, projectId);
   const sandbox = env.PROJECT_SANDBOX.get(env.PROJECT_SANDBOX.idFromName(sandboxName));
-  await sandbox.registerOwner(userId);
+  await sandbox.registerOwner(userId, sandboxName);
   return sandbox;
 }
 
@@ -109,6 +116,10 @@ export async function requireWritableThreadProject(
       if (!thread) {
         throw new APIError(404, "not_found_thread", "Thread not found", { retriable: false });
       }
+      if (!thread.projectId) {
+        // Project-less chat (no first run yet): nothing to gate — the run creates it.
+        return;
+      }
       const state = await getProjectWriteState(tx, {
         projectId: thread.projectId,
         userId: parsedUserId,
@@ -212,6 +223,7 @@ export async function runEntitlementPolicy(
         dailyCostUsdAtRunStart,
         ...(limits.dailyCostCapUsd === null ? {} : { dailyCostCapUsd: limits.dailyCostCapUsd }),
         maxConcurrentSandboxes: entitlement.maxConcurrentSandboxes,
+        maxProjects: entitlement.maxProjects,
         quotaPeriodEnd: periodEnd.toISOString(),
         ...(quotaWarning ? { quotaWarning } : {}),
         researchFanoutSubagentLimit: Math.min(
@@ -490,7 +502,7 @@ async function sandboxForLegacyThread(
 ): Promise<DurableObjectStub<ProjectSandbox>> {
   const sandboxName = await projectSandboxName(userId, threadId);
   const sandbox = env.PROJECT_SANDBOX.get(env.PROJECT_SANDBOX.idFromName(sandboxName));
-  await sandbox.registerOwner(userId);
+  await sandbox.registerOwner(userId, sandboxName);
   return sandbox;
 }
 

apps/agent-worker/src/durable-objects/mastra-stream-chunks.ts

@@ -55,8 +55,8 @@ export function mastraChunkToUiChunks(chunk: unknown): UIMessageChunk[] {
     return textDeltaChunks(record);
   }
 
-  if (chunkType === "tool-call" && isSandboxToolChunk(record)) {
-    return [sandboxStatusChunk("starting")];
+  if (chunkType === "tool-call") {
+    return toolCallChunks(record);
   }
 
   if (chunkType === "tool-result" && isSandboxToolChunk(record)) {
@@ -219,6 +219,67 @@ function sandboxStatusChunk(status: "ready" | "starting", previewUrl?: string):
   };
 }
 
+const MAX_TOOL_INPUT_KEYS = 8;
+const MAX_TOOL_INPUT_STRING = 256;
+
+// Surface every tool call as a transcript row (bud parity). Sandbox tools also drive
+// the Computer-panel status; non-sandbox tools only get the row.
+function toolCallChunks(record: Record<string, unknown>): UIMessageChunk[] {
+  const payload = chunkPayload(record);
+  const toolName = stringField(payload, "toolName");
+  if (!toolName) {
+    return [];
+  }
+  const chunks: UIMessageChunk[] = [toolActivityChunk(payload, toolName)];
+  if (SANDBOX_TOOL_NAMES.has(toolName)) {
+    chunks.push(sandboxStatusChunk("starting"));
+  }
+  return chunks;
+}
+
+function toolActivityChunk(payload: Record<string, unknown>, toolName: string): UIMessageChunk {
+  const toolCallId = stringField(payload, "toolCallId");
+  const input = toolInputFromPayload(payload);
+  return {
+    type: "data-tool",
+    data: {
+      v: 1,
+      toolName,
+      ...(toolCallId ? { toolCallId } : {}),
+      ...(input ? { input } : {}),
+    },
+  };
+}
+
+// Keep the persisted part small: only scalar args, capped count + string length. The
+// transcript row needs the path/command/url/query, not the full (possibly huge) payload.
+function toolInputFromPayload(
+  payload: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  for (const key of ["args", "input", "toolInput", "arguments"]) {
+    const raw = asRecord(payload[key]);
+    if (Object.keys(raw).length > 0) {
+      return truncateToolInput(raw);
+    }
+  }
+  return undefined;
+}
+
+function truncateToolInput(input: Record<string, unknown>): Record<string, unknown> {
+  const output: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input).slice(0, MAX_TOOL_INPUT_KEYS)) {
+    if (typeof value === "string") {
+      output[key] =
+        value.length > MAX_TOOL_INPUT_STRING ? `${value.slice(0, MAX_TOOL_INPUT_STRING)}…` : value;
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      output[key] = value;
+    } else if (Array.isArray(value)) {
+      output[key] = `[${value.length} item(s)]`;
+    }
+  }
+  return output;
+}
+
 function asRecord(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
 }

apps/agent-worker/src/durable-objects/project-sandbox.ts

@@ -99,6 +99,7 @@ const ENSURE_STARTED_DELAY_MS = 2_000;
 const SANDBOX_OWNER_USER_ID_KEY = "sandbox_owner_user_id";
 const DAYTONA_ID_KEY = "daytona_sandbox_id";
 const RUN_LEASES_KEY = "run_leases";
+const SANDBOX_NAME_KEY = "sandbox_name";
 const PROC_PREFIX = "proc:";
 
 const OwnerUserIdSchema = z.string().uuid();
@@ -117,10 +118,37 @@ export class ProjectSandbox extends DurableObject<ProjectSandboxEnv> {
   private daytonaClient: DaytonaClient | undefined;
   private daytonaId: string | undefined;
   private startedVerifiedAtMs = 0;
+  private cachedSandboxName: string | undefined;
+
+  constructor(ctx: DurableObjectState, env: ProjectSandboxEnv) {
+    super(ctx, env);
+    // `ctx.id.name` is only populated when the DO is addressed via idFromName, and the
+    // runtime drops it when it reconstructs the object (alarm wake / eviction / local
+    // restart). Persist the name once we ever see it so sandboxName() can recover it on
+    // those reconstructions instead of throwing and 500-ing every files/metering call.
+    void ctx.blockConcurrencyWhile(async () => {
+      const stored = await ctx.storage.get<string>(SANDBOX_NAME_KEY);
+      const fromId = ctx.id.name;
+      if (fromId) {
+        this.cachedSandboxName = fromId;
+        if (stored !== fromId) {
+          await ctx.storage.put(SANDBOX_NAME_KEY, fromId);
+        }
+      } else if (typeof stored === "string") {
+        this.cachedSandboxName = stored;
+      }
+    });
+  }
 
   // ----- ownership + quota -----
 
-  public async registerOwner(userId: string): Promise<void> {
+  public async registerOwner(userId: string, sandboxName?: string): Promise<void> {
+    // The caller addressed us via idFromName(sandboxName); persist it so a later
+    // alarm-/eviction-reconstructed instance (which loses ctx.id.name) recovers the name.
+    if (sandboxName && this.cachedSandboxName !== sandboxName) {
+      this.cachedSandboxName = sandboxName;
+      await this.ctx.storage.put(SANDBOX_NAME_KEY, sandboxName);
+    }
     const parsedUserId = OwnerUserIdSchema.parse(userId);
     const existingUserId = await this.ownerUserId();
     if (existingUserId && existingUserId !== parsedUserId) {
@@ -753,7 +781,7 @@ export class ProjectSandbox extends DurableObject<ProjectSandboxEnv> {
   }
 
   private sandboxName(): string {
-    const name = this.ctx.id.name;
+    const name = this.cachedSandboxName ?? this.ctx.id.name;
     if (!name) {
       throw new Error("ProjectSandbox must be addressed with idFromName().");
     }

apps/agent-worker/src/index.ts

@@ -357,14 +357,14 @@ agentApp.post("/v1/threads/:threadId/runs", async (c) => {
     if (!thread) {
       throw new APIError(404, "not_found_thread", "Thread not found", { retriable: false });
     }
-    const sandboxName = await projectSandboxName(userId, thread.projectId);
     const policy = await runEntitlementPolicy(c.env, userId);
     const result = await withUserContext(db, UserId(userId), (tx) =>
       createAgentRunForThread(tx, {
         agentName: body.agentName ?? DEFAULT_AGENT_NAME,
+        maxActiveProjects: policy.maxProjects,
         maxConcurrentSandboxes: policy.maxConcurrentSandboxes,
         personalization,
-        sandboxId: sandboxName,
+        resolveSandboxName: (projectId) => projectSandboxName(userId, projectId),
         source: "web",
         threadId: parsedThreadId,
         userId: parsedUserId,
@@ -399,6 +399,13 @@ agentApp.post("/v1/threads/:threadId/runs", async (c) => {
         retriable: false,
       });
     }
+    if (result.type === "project-limit-reached") {
+      throw new APIError(403, "permission_plan_required", "Active project limit reached", {
+        details: { limit: result.limit, used: result.used },
+        hint: "Upgrade your plan or archive an existing project before starting another one.",
+        retriable: false,
+      });
+    }
     await withUserContext(db, UserId(userId), (tx) =>
       createThreadMessage(tx, {
         agentRunId: result.run.runId,
@@ -408,6 +415,7 @@ agentApp.post("/v1/threads/:threadId/runs", async (c) => {
         userId: UserId(userId),
       }),
     );
+    const sandboxName = await projectSandboxName(userId, result.run.projectId);
     const warmedSandbox = await sandboxForProject(c.env, userId, result.run.projectId);
     c.executionCtx.waitUntil(syncSandboxQuotaPeriod(warmedSandbox, policy.quotaPeriodEnd));
     const response = await startAgentRun(

apps/gateway-worker/src/greeting-routes.ts

@@ -1,7 +1,12 @@
+import { createDb, sumWorkedMinutesToday, withUserContext } from "@cheatcode/db";
 import { createLogger } from "@cheatcode/observability";
-import { type GreetingResponse, GreetingResponseSchema } from "@cheatcode/types";
+import { type GreetingResponse, GreetingResponseSchema, type UserId } from "@cheatcode/types";
 import { z } from "zod";
 
+export interface GreetingRouteEnv {
+  HYPERDRIVE: Hyperdrive;
+}
+
 const OPEN_METEO_FORECAST_URL = "https://api.open-meteo.com/v1/forecast";
 const WEATHER_FETCH_TIMEOUT_MS = 1_500;
 const WEATHER_CACHE_MAX_AGE_SECONDS = 900;
@@ -42,17 +47,52 @@ interface ResolvedGeo {
  * failure degrades to `weather: null` while still answering HTTP 200; the client
  * falls back to a time-only greeting. Never returns a server clock.
  */
-export async function greetingRoute(ctx: ExecutionContext, request: Request): Promise<Response> {
+export async function greetingRoute(
+  env: GreetingRouteEnv,
+  ctx: ExecutionContext,
+  request: Request,
+  userId: UserId,
+): Promise<Response> {
   const geo = resolveGeo(request);
-  const weather = await resolveWeather(ctx, geo);
+  const [weather, workedMinutesToday] = await Promise.all([
+    resolveWeather(ctx, geo),
+    resolveWorkedMinutesToday(env, ctx, userId, geo.timezone),
+  ]);
   const response: GreetingResponse = {
     city: geo.city,
     timezone: geo.timezone,
     weather,
+    workedMinutesToday,
   };
   return Response.json(GreetingResponseSchema.parse(response));
 }
 
+/**
+ * Best-effort daily run-minutes total for the home headline. Any DB failure
+ * degrades to 0 (the headline falls back to "ready to build") rather than
+ * failing the greeting — mirrors the weather path's resilience.
+ */
+async function resolveWorkedMinutesToday(
+  env: GreetingRouteEnv,
+  ctx: ExecutionContext,
+  userId: UserId,
+  timezone: string | null,
+): Promise<number> {
+  const { db, close } = createDb(env.HYPERDRIVE);
+  try {
+    return await withUserContext(db, userId, (tx) =>
+      sumWorkedMinutesToday(tx, userId, timezone ?? "UTC"),
+    );
+  } catch (error) {
+    createLogger().warn("greeting_worked_minutes_failed", {
+      reason: error instanceof Error ? error.message : "unknown",
+    });
+    return 0;
+  } finally {
+    ctx.waitUntil(close());
+  }
+}
+
 function resolveGeo(request: Request): ResolvedGeo {
   const cf: unknown = request.cf;
   const parsed = CfGeoSchema.safeParse(cf);

apps/gateway-worker/src/index.ts

@@ -77,9 +77,10 @@ import { listAgentsRoute, listToolsRoute } from "./metadata-routes";
 import { OPENAPI_DOCUMENT, openApiDocsHtml } from "./openapi";
 import { getMyProfileRoute, updateMyProfileRoute } from "./profile-routes";
 import {
+  createChatRoute,
   createProjectRoute,
-  createThreadRoute,
   deleteProjectRoute,
+  deleteThreadRoute,
   getProjectRoute,
   getThreadRoute,
   listProjectsRoute,
@@ -88,6 +89,7 @@ import {
   parseProjectParam,
   parseThreadParam,
   updateProjectRoute,
+  updateThreadRoute,
 } from "./project-routes";
 import { ensureFallbackRateLimitHeaders, rateLimit, withRateLimitHeaders } from "./rate-limit";
 import { featuredReplaysRoute, replayByIdRoute } from "./replay-routes";
@@ -388,7 +390,7 @@ export const gatewayRoutes = gatewayApp
   .get("/v1/greeting", async (c) => {
     const userId = await authenticate(c.req.raw, c.env, c.executionCtx);
     await rateLimit(c, userId, "GET /v1/greeting");
-    return greetingRoute(c.executionCtx, c.req.raw);
+    return greetingRoute(c.env, c.executionCtx, c.req.raw, userId);
   })
 
   .get("/v1/projects", async (c) => {
@@ -449,22 +451,39 @@ export const gatewayRoutes = gatewayApp
     );
   })
 
-  .post("/v1/projects/:projectId/threads", async (c) => {
+  .post("/v1/threads", async (c) => {
     const userId = await authenticate(c.req.raw, c.env, c.executionCtx);
-    await rateLimit(c, userId, "POST /v1/projects/:projectId/threads");
-    return createThreadRoute(
+    await rateLimit(c, userId, "POST /v1/threads");
+    return createChatRoute(c.env, c.executionCtx, c.req.raw, userId);
+  })
+
+  .get("/v1/threads/:threadId", async (c) => {
+    const userId = await authenticate(c.req.raw, c.env, c.executionCtx);
+    await rateLimit(c, userId, "GET /v1/threads/:threadId");
+    return getThreadRoute(c.env, c.executionCtx, parseThreadParam(c.req.param("threadId")), userId);
+  })
+
+  .patch("/v1/threads/:threadId", async (c) => {
+    const userId = await authenticate(c.req.raw, c.env, c.executionCtx);
+    await rateLimit(c, userId, "PATCH /v1/threads/:threadId");
+    return updateThreadRoute(
       c.env,
       c.executionCtx,
       c.req.raw,
-      parseProjectParam(c.req.param("projectId")),
+      parseThreadParam(c.req.param("threadId")),
       userId,
     );
   })
 
-  .get("/v1/threads/:threadId", async (c) => {
+  .delete("/v1/threads/:threadId", async (c) => {
     const userId = await authenticate(c.req.raw, c.env, c.executionCtx);
-    await rateLimit(c, userId, "GET /v1/threads/:threadId");
-    return getThreadRoute(c.env, c.executionCtx, parseThreadParam(c.req.param("threadId")), userId);
+    await rateLimit(c, userId, "DELETE /v1/threads/:threadId");
+    return deleteThreadRoute(
+      c.env,
+      c.executionCtx,
+      parseThreadParam(c.req.param("threadId")),
+      userId,
+    );
   })
 
   .get("/v1/threads/:threadId/messages", async (c) => {

apps/gateway-worker/src/openapi-discovery-routes.ts

@@ -79,8 +79,8 @@ export const discoverySchemas: Record<string, JsonValue> = {
     additionalProperties: false,
     properties: {
       id: stringSchema({ format: "uuid" }),
-      projectId: stringSchema({ format: "uuid" }),
-      projectName: stringSchema(),
+      projectId: nullableStringSchema({ format: "uuid" }),
+      projectName: nullableStringSchema(),
       title: stringSchema(),
       type: { const: "thread", type: "string" },
       updatedAt: stringSchema({ format: "date-time" }),