@sentry/junior 0.177.0 → 0.178.0

package/dist/{chunk-LPMLAJYR.js → chunk-XCNS3CXE.js}

@@ -1,4 +1,5 @@
 import {
+  conversationReadColumns,
   createJuniorSqlExecutor,
   juniorConversationAnnotations,
   juniorConversationBindings,
@@ -7,12 +8,12 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-WCQUKX74.js";
+} from "./chunk-ZCHHVTMF.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-3ZZEPLLB.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -23,7 +24,7 @@ import {
 } from "./chunk-M63DETLL.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-7CVYXUOJ.js";
+} from "./chunk-UGWBJAGN.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -240,7 +241,8 @@ async function recordConversationParticipant(executor, args) {
       juniorConversationParticipants.rootConversationId
     ],
     set: {
-      lastMessageAt: sql2`greatest(${juniorConversationParticipants.lastMessageAt}, excluded.last_message_at)`
+      lastMessageAt: sql2`greatest(${juniorConversationParticipants.lastMessageAt}, excluded.last_message_at)`,
+      ...args.restoreArchive ? { archivedAt: null } : {}
     }
   });
 }
@@ -596,7 +598,6 @@ function conversationFromRow(readRow) {
     ...destination ? { destination } : {},
     ...location ? { location } : {},
     ...actor ? { actor } : {},
-    ...msFromDate(row.archivedAt) !== void 0 ? { archivedAtMs: msFromDate(row.archivedAt) } : {},
     ...row.channelName ? { channelName: row.channelName } : {},
     ...source ? { source } : {},
     ...sessionSource ? { sessionSource } : {},
@@ -813,7 +814,7 @@ var SqlStore = class {
   }
   async listByActivity(args = {}) {
     const rows = await this.executor.db().select({
-      conversation: juniorConversations,
+      conversation: conversationReadColumns(),
       destination: juniorDestinations,
       actorIdentity: juniorIdentities,
       actorUserDisplayName: juniorUsers.displayName
@@ -896,7 +897,7 @@ var SqlStore = class {
   }
   async readConversationRow(conversationId) {
     const rows = await this.executor.db().select({
-      conversation: juniorConversations,
+      conversation: conversationReadColumns(),
       destination: juniorDestinations,
       actorIdentity: juniorIdentities,
       actorUserDisplayName: juniorUsers.displayName
@@ -1053,7 +1054,6 @@ import {
   gt,
   gte,
   inArray as inArray2,
-  isNotNull,
   lt,
   lte,
   sql as sql6
@@ -1757,14 +1757,6 @@ var SqlConversationEventStore = class {
         newestCreatedAtMs,
         options
       );
-      if (options.activity !== "preserve" && pending.some((event) => eventUnarchivesConversation(event.data))) {
-        await this.executor.db().update(juniorConversations).set({ archivedAt: null }).where(
-          and6(
-            eq6(juniorConversations.conversationId, conversationId),
-            isNotNull(juniorConversations.archivedAt)
-          )
-        );
-      }
       const cursor = await this.readCursor(conversationId);
       const historyVersion = cursor.maxHistoryVersion ?? 0;
       let seq = cursor.nextSeq;
@@ -1791,7 +1783,8 @@ var SqlConversationEventStore = class {
           await recordConversationParticipant(this.executor, {
             actorIdentityId,
             conversationId,
-            atMs: event.createdAtMs
+            atMs: event.createdAtMs,
+            restoreArchive: eventUnarchivesConversation(event.data)
           });
         }
       }
@@ -2156,6 +2149,7 @@ export {
   upsertIdentity,
   upsertLinkedIdentity,
   deleteProviderIdentityForSlackUser,
+  resolveRootConversationId,
   parseSessionSource,
   bindProviderConversation,
   locationFromRow,

package/dist/{chunk-PA7QDS7P.js → chunk-XWUJWHFD.js}

@@ -5,7 +5,7 @@ import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-LPMLAJYR.js";
+} from "./chunk-XCNS3CXE.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
@@ -14,23 +14,25 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-WCQUKX74.js";
+} from "./chunk-ZCHHVTMF.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
+  getVercelSandboxCredentials,
   hash,
+  isSandboxMissingError,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-Q362TECJ.js";
+} from "./chunk-AQHSXA3J.js";
 import {
   getStateAdapter
-} from "./chunk-VGDOEKO2.js";
+} from "./chunk-H6ZXBFGX.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-3ZZEPLLB.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -46,7 +48,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-7CVYXUOJ.js";
+} from "./chunk-UGWBJAGN.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -1664,15 +1666,65 @@ function workspaceRepoCheckoutPath(repo) {
 }
 
 // src/chat/workspaces/store.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { and as and5, asc as asc2, eq as eq5, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+import { and as and5, asc as asc3, eq as eq5, sql as sql2 } from "drizzle-orm";
+
+// src/chat/sandbox/snapshot/builder-sandbox.ts
+import { Sandbox } from "@vercel/sandbox";
+async function getWorkspaceSnapshotBuilder(name, signal) {
+  const credentials = getVercelSandboxCredentials();
+  return await Sandbox.get({
+    name,
+    resume: true,
+    signal,
+    ...credentials ?? {}
+  });
+}
+async function deleteWorkspaceSnapshotBuilders(names) {
+  const credentials = getVercelSandboxCredentials();
+  let hasError = false;
+  let firstError;
+  for (const name of new Set(names)) {
+    try {
+      const sandbox = await Sandbox.get({
+        name,
+        resume: false,
+        ...credentials ?? {}
+      });
+      await sandbox.delete();
+    } catch (error) {
+      if (!isSandboxMissingError(error)) {
+        if (!hasError) firstError = error;
+        hasError = true;
+      }
+    }
+  }
+  if (hasError) throw firstError;
+}
 
 // src/chat/sandbox/snapshot/runtime.ts
 var SANDBOX_RUNTIME = "node22";
 
 // src/chat/sandbox/snapshot/store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { and as and4, desc as desc2, eq as eq4, ne } from "drizzle-orm";
+import { and as and4, asc as asc2, desc as desc2, eq as eq4, ne, or } from "drizzle-orm";
+function builderNames(rows) {
+  return [
+    ...new Set(
+      rows.map((row) => row.sandboxName).filter((name) => Boolean(name))
+    )
+  ];
+}
+function sameWorkspaceRecipe(stored, expected) {
+  if (stored.setupScript !== expected.setupScript || stored.repos.length !== expected.repos.length) {
+    return false;
+  }
+  const expectedRepos = new Set(
+    expected.repos.map((repo) => JSON.stringify([repo.provider, repo.repo]))
+  );
+  return stored.repos.every(
+    (repo) => expectedRepos.has(JSON.stringify([repo.provider, repo.repo]))
+  );
+}
 function snapshotFromRow(row) {
   if (row.status !== "ready" || !row.snapshotId || !row.generatedAt || row.buildDurationMs == null) {
     throw new Error(`Invalid ready Workspace snapshot row: ${row.id}`);
@@ -1689,6 +1741,7 @@ function snapshotBuildFromRow(row) {
     throw new Error(`Invalid Workspace snapshot build row: ${row.id}`);
   }
   return {
+    id: row.id,
     status: row.status,
     phase: row.buildPhase,
     profileHash: row.profileHash,
@@ -1710,99 +1763,131 @@ async function loadSnapshotsForProfile(db, workspaceId, profileHash) {
   ];
   const [readyRows, buildRows] = await Promise.all([
     db.select().from(juniorSnapshots).where(and4(profile, eq4(juniorSnapshots.status, "ready"))).orderBy(...order).limit(1),
-    db.select().from(juniorSnapshots).where(and4(profile, ne(juniorSnapshots.status, "ready"))).orderBy(...order).limit(1)
+    db.select().from(juniorSnapshots).where(and4(profile, ne(juniorSnapshots.status, "ready"))).orderBy(asc2(juniorSnapshots.status), ...order).limit(1)
   ]);
   return {
     ready: readyRows[0] ? snapshotFromRow(readyRows[0]) : null,
     build: buildRows[0] ? snapshotBuildFromRow(buildRows[0]) : null
   };
 }
-async function clearNonReadySnapshots(db, workspaceId) {
-  const deleted = await db.delete(juniorSnapshots).where(
-    and4(
-      eq4(juniorSnapshots.workspaceId, workspaceId),
-      ne(juniorSnapshots.status, "ready")
-    )
-  ).returning({
-    sandboxName: juniorSnapshots.buildSandboxName
-  });
-  return deleted.map((row) => row.sandboxName).filter((name) => Boolean(name));
+async function clearWorkspaceSnapshots(db, workspaceId) {
+  await db.select({ id: juniorWorkspaces.id }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
+  const deleted = await db.delete(juniorSnapshots).where(eq4(juniorSnapshots.workspaceId, workspaceId)).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+  return builderNames(deleted);
 }
-async function setWorkspaceSnapshot(workspaceId, snapshot) {
+async function invalidateReadySnapshot(params) {
   const executor = getSqlExecutor();
-  await executor.transaction(async () => {
+  return await executor.transaction(async () => {
     const db = executor.db();
-    const workspaceRows = await db.select({ id: juniorWorkspaces.id }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).limit(1);
-    if (!workspaceRows[0]) return;
-    const now = /* @__PURE__ */ new Date();
-    const existing = await db.select().from(juniorSnapshots).where(
+    const deleted = await db.delete(juniorSnapshots).where(
       and4(
-        eq4(juniorSnapshots.workspaceId, workspaceId),
-        eq4(juniorSnapshots.profileHash, snapshot.profileHash)
+        eq4(juniorSnapshots.workspaceId, params.workspaceId),
+        eq4(juniorSnapshots.profileHash, params.profileHash),
+        eq4(juniorSnapshots.status, "ready"),
+        eq4(juniorSnapshots.snapshotId, params.snapshotId)
       )
-    ).orderBy(desc2(juniorSnapshots.updatedAt), desc2(juniorSnapshots.createdAt)).limit(1);
-    const current = existing[0];
-    if (current && current.status !== "ready") {
-      await db.update(juniorSnapshots).set({
-        status: "ready",
-        snapshotId: snapshot.id,
-        buildDurationMs: snapshot.buildDurationMs,
-        generatedAt: snapshot.generatedAt,
-        buildStartedAt: null,
-        buildPhase: null,
-        buildSandboxName: null,
-        buildCommandId: null,
-        buildError: null,
-        updatedAt: now
-      }).where(eq4(juniorSnapshots.id, current.id));
-      return;
-    }
-    if (current && current.status === "ready" && current.snapshotId === snapshot.id) {
-      await db.update(juniorSnapshots).set({
-        buildDurationMs: snapshot.buildDurationMs,
-        generatedAt: snapshot.generatedAt,
-        buildStartedAt: null,
-        buildPhase: null,
-        buildSandboxName: null,
-        buildCommandId: null,
-        buildError: null,
-        updatedAt: now
-      }).where(eq4(juniorSnapshots.id, current.id));
-      return;
-    }
-    await db.insert(juniorSnapshots).values({
-      id: randomUUID2(),
-      workspaceId,
-      profileHash: snapshot.profileHash,
+    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+    return deleted[0]?.sandboxName ?? null;
+  });
+}
+async function setWorkspaceSnapshot(workspaceId, snapshot, options) {
+  const executor = getSqlExecutor();
+  return await executor.transaction(async () => {
+    const db = executor.db();
+    const now = /* @__PURE__ */ new Date();
+    const updated = await db.update(juniorSnapshots).set({
       status: "ready",
       snapshotId: snapshot.id,
       buildDurationMs: snapshot.buildDurationMs,
       generatedAt: snapshot.generatedAt,
       buildStartedAt: null,
-      buildSandboxName: null,
+      buildPhase: null,
       buildCommandId: null,
       buildError: null,
-      createdAt: now,
       updatedAt: now
-    });
+    }).where(
+      and4(
+        eq4(juniorSnapshots.id, options.buildId),
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
+        eq4(juniorSnapshots.status, "building")
+      )
+    ).returning({ id: juniorSnapshots.id });
+    if (updated.length === 0) {
+      return { written: false, replacedBuilderNames: [] };
+    }
+    const replaced = await db.delete(juniorSnapshots).where(
+      and4(
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
+        ne(juniorSnapshots.id, options.buildId),
+        or(
+          eq4(juniorSnapshots.status, "failed"),
+          eq4(juniorSnapshots.status, "ready")
+        )
+      )
+    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+    return {
+      written: true,
+      replacedBuilderNames: builderNames(replaced)
+    };
   });
 }
-async function recordResolvedWorkspaceSnapshot(workspaceId, snapshot) {
-  if (!snapshot.snapshotId || !snapshot.profileHash || snapshot.createdAtMs == null || snapshot.buildDurationMs == null) {
-    return;
-  }
-  try {
-    await setWorkspaceSnapshot(workspaceId, {
-      id: snapshot.snapshotId,
-      generatedAt: new Date(snapshot.createdAtMs),
-      buildDurationMs: snapshot.buildDurationMs,
-      profileHash: snapshot.profileHash
-    });
-  } catch (error) {
-    logException(error, "sandbox.workspace_snapshot.persist.failed", {
-      "app.workspace.id": workspaceId
-    });
-  }
+async function setWorkspaceSnapshotBuild(workspaceId, build, options = {}) {
+  const executor = getSqlExecutor();
+  return await executor.transaction(async () => {
+    const db = executor.db();
+    const now = /* @__PURE__ */ new Date();
+    const updated = await db.update(juniorSnapshots).set({
+      status: build.status,
+      buildStartedAt: build.startedAt,
+      buildPhase: build.phase,
+      buildSandboxName: build.sandboxName,
+      buildCommandId: build.commandId,
+      buildError: build.error,
+      updatedAt: now
+    }).where(
+      and4(
+        eq4(juniorSnapshots.id, build.id),
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, build.profileHash),
+        eq4(juniorSnapshots.status, "building")
+      )
+    ).returning({ id: juniorSnapshots.id });
+    if (updated.length > 0) {
+      return true;
+    }
+    if (!options.insertIfMissing) return false;
+    const workspaceRows = await db.select({ setupScript: juniorWorkspaces.setupScript }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
+    const workspace = workspaceRows[0];
+    if (!workspace) return false;
+    if (options.expectedRecipe) {
+      const repos = await db.select({
+        provider: juniorWorkspaceRepos.provider,
+        repo: juniorWorkspaceRepos.repo
+      }).from(juniorWorkspaceRepos).where(eq4(juniorWorkspaceRepos.workspaceId, workspaceId));
+      if (!sameWorkspaceRecipe({ ...workspace, repos }, options.expectedRecipe)) {
+        return false;
+      }
+    }
+    const inserted = await db.insert(juniorSnapshots).values({
+      id: build.id,
+      workspaceId,
+      profileHash: build.profileHash,
+      status: build.status,
+      snapshotId: null,
+      buildDurationMs: null,
+      generatedAt: null,
+      buildStartedAt: build.startedAt,
+      buildPhase: build.phase,
+      buildSandboxName: build.sandboxName,
+      buildCommandId: build.commandId,
+      buildError: build.error,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoNothing().returning({ id: juniorSnapshots.id });
+    return inserted.length > 0;
+  });
 }
 
 // src/chat/workspaces/validation.ts
@@ -1914,8 +1999,8 @@ async function workspaceWithSnapshot(db, row, repos) {
 }
 async function loadWorkspaceRepos(db, workspaceId) {
   return await db.select().from(juniorWorkspaceRepos).where(eq5(juniorWorkspaceRepos.workspaceId, workspaceId)).orderBy(
-    asc2(juniorWorkspaceRepos.provider),
-    asc2(juniorWorkspaceRepos.repo)
+    asc3(juniorWorkspaceRepos.provider),
+    asc3(juniorWorkspaceRepos.repo)
   );
 }
 async function replaceWorkspaceRepos(db, workspaceId, repos) {
@@ -1946,13 +2031,24 @@ function isUniqueViolation(error) {
   }
   return false;
 }
+async function cleanupSnapshotBuilders(workspaceId, names) {
+  if (names.length === 0) return;
+  try {
+    await deleteWorkspaceSnapshotBuilders(names);
+  } catch (error) {
+    logException(error, "sandbox.workspace_snapshot.builder.delete_failed", {
+      "app.workspace.id": workspaceId,
+      "app.sandbox.snapshot.builder_count": names.length
+    });
+  }
+}
 async function listWorkspaces(db) {
   const [workspaces, repos] = await Promise.all([
-    db.select().from(juniorWorkspaces).orderBy(asc2(juniorWorkspaces.name)),
+    db.select().from(juniorWorkspaces).orderBy(asc3(juniorWorkspaces.name)),
     db.select().from(juniorWorkspaceRepos).orderBy(
-      asc2(juniorWorkspaceRepos.workspaceId),
-      asc2(juniorWorkspaceRepos.provider),
-      asc2(juniorWorkspaceRepos.repo)
+      asc3(juniorWorkspaceRepos.workspaceId),
+      asc3(juniorWorkspaceRepos.provider),
+      asc3(juniorWorkspaceRepos.repo)
     )
   ]);
   return workspaces.map(
@@ -1975,7 +2071,7 @@ async function listWorkspaceNamesByRepository(db, input) {
       // Recipes store the provided repo casing; identity is case-insensitive.
       sql2`lower(${juniorWorkspaceRepos.repo}) = lower(${repo})`
     )
-  ).orderBy(asc2(juniorWorkspaces.name));
+  ).orderBy(asc3(juniorWorkspaces.name));
   return rows.map((row) => row.name);
 }
 async function getWorkspaceByName(db, name) {
@@ -2002,7 +2098,7 @@ async function createWorkspace(input) {
   const recipe = normalizeWorkspaceRecipe(input);
   const executor = getSqlExecutor();
   const now = /* @__PURE__ */ new Date();
-  const id = randomUUID3();
+  const id = randomUUID2();
   try {
     await executor.transaction(async () => {
       const db = executor.db();
@@ -2030,7 +2126,7 @@ async function updateWorkspace(id, input) {
   const executor = getSqlExecutor();
   const now = /* @__PURE__ */ new Date();
   try {
-    const updated = await executor.transaction(async () => {
+    const result = await executor.transaction(async () => {
       const db = executor.db();
       const existingRows = await db.select().from(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).limit(1);
       const existing = existingRows[0];
@@ -2043,12 +2139,11 @@ async function updateWorkspace(id, input) {
         updatedAt: now
       }).where(eq5(juniorWorkspaces.id, id)).returning();
       await replaceWorkspaceRepos(db, id, recipe.repos);
-      if (snapshotChanged) {
-        await clearNonReadySnapshots(db, id);
-      }
-      return rows[0];
+      const builderNames2 = snapshotChanged ? await clearWorkspaceSnapshots(db, id) : [];
+      return { builderNames: builderNames2, workspace: rows[0] };
     });
-    if (!updated) return void 0;
+    if (!result) return void 0;
+    await cleanupSnapshotBuilders(id, result.builderNames);
   } catch (error) {
     if (isUniqueViolation(error)) {
       throw new WorkspaceValidationError(
@@ -2061,10 +2156,14 @@ async function updateWorkspace(id, input) {
 }
 async function deleteWorkspace(id) {
   const executor = getSqlExecutor();
-  return await executor.transaction(async () => {
-    const rows = await executor.db().delete(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).returning({ id: juniorWorkspaces.id });
-    return rows.length > 0;
+  const result = await executor.transaction(async () => {
+    const db = executor.db();
+    const builderNames2 = await clearWorkspaceSnapshots(db, id);
+    const rows = await db.delete(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).returning({ id: juniorWorkspaces.id });
+    return { builderNames: builderNames2, deleted: rows.length > 0 };
   });
+  await cleanupSnapshotBuilders(id, result.builderNames);
+  return result.deleted;
 }
 
 // src/chat/plugins/agent-hooks.ts
@@ -3341,8 +3440,13 @@ export {
   resolveChannelCapabilities,
   tryWorkspaceRepoCheckoutPath,
   workspaceRepoCheckoutPath,
+  getWorkspaceSnapshotBuilder,
+  deleteWorkspaceSnapshotBuilders,
   SANDBOX_RUNTIME,
-  recordResolvedWorkspaceSnapshot,
+  loadSnapshotsForProfile,
+  invalidateReadySnapshot,
+  setWorkspaceSnapshot,
+  setWorkspaceSnapshotBuild,
   WorkspaceValidationError,
   listWorkspaces,
   getWorkspaceByName,

package/dist/{chunk-WCQUKX74.js → chunk-ZCHHVTMF.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_SQL_STATEMENT_TIMEOUT_MS
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-3ZZEPLLB.js";
 import {
   juniorDestinations,
   timestamptz
@@ -56,7 +56,7 @@ var juniorArtifacts = pgTable(
 import { index as index4, integer as integer3, pgTable as pgTable5, text as text5 } from "drizzle-orm/pg-core";
 
 // src/db/schema/conversations.ts
-import { sql as sql2 } from "drizzle-orm";
+import { getTableColumns, sql as sql2 } from "drizzle-orm";
 import {
   index as index3,
   integer as integer2,
@@ -181,7 +181,8 @@ var juniorConversations = pgTable4(
     executionDurationMs: integer2("execution_duration_ms").notNull().default(0),
     executionUsage: jsonb2("execution_usage_json").$type(),
     metricRunId: text4("metric_run_id"),
-    archivedAt: timestamptz("archived_at")
+    // Keep the legacy column in the schema. Runtime code must not read or write it.
+    legacyArchivedAt: timestamptz("archived_at")
   },
   (table) => [
     index3("junior_conversations_last_activity_idx").on(
@@ -210,6 +211,11 @@ var juniorConversations = pgTable4(
     index3("junior_conversations_root_idx").on(table.rootConversationId)
   ]
 );
+function conversationReadColumns() {
+  const { legacyArchivedAt, ...columns } = getTableColumns(juniorConversations);
+  void legacyArchivedAt;
+  return columns;
+}
 
 // src/db/schema/attachments.ts
 var juniorAttachments = pgTable5(
@@ -387,7 +393,8 @@ var juniorConversationParticipants = pgTable10(
   {
     userId: text10("user_id").notNull().references(() => juniorUsers.id),
     rootConversationId: text10("root_conversation_id").notNull().references(() => juniorConversations.conversationId),
-    lastMessageAt: timestamptz("last_message_at").notNull()
+    lastMessageAt: timestamptz("last_message_at").notNull(),
+    archivedAt: timestamptz("archived_at")
   },
   (table) => [
     primaryKey4({
@@ -693,7 +700,7 @@ var juniorSnapshots = pgTable18(
     snapshotId: text18("snapshot_id"),
     buildDurationMs: integer6("build_duration_ms"),
     generatedAt: timestamptz("generated_at"),
-    // In-flight builder references for check-in across execution slices.
+    // Builder references for check-in and snapshot-owner cleanup.
     buildStartedAt: timestamptz("build_started_at"),
     buildPhase: text18("build_phase").$type(),
     buildSandboxName: text18("build_sandbox_name"),
@@ -731,6 +738,7 @@ var juniorSnapshots = pgTable18(
       table.profileHash,
       table.status
     ),
+    uniqueIndex8("junior_snapshots_active_build_uidx").on(table.workspaceId, table.profileHash).where(sql6`${table.status} = 'building'`),
     index13("junior_snapshots_workspace_status_idx").on(
       table.workspaceId,
       table.status
@@ -1018,6 +1026,7 @@ export {
   juniorUsers,
   juniorIdentities,
   juniorConversations,
+  conversationReadColumns,
   juniorAttachments,
   juniorConversationAnnotations,
   juniorApiTokens,