@sentry/junior 0.162.0 → 0.163.0

package/dist/{chunk-EHQLTK3X.js → chunk-IX4XI42N.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-K7IV6UV3.js";
+} from "./chunk-XY2IVIAY.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -32,7 +32,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-OBFRMQBY.js";
+} from "./chunk-RTPJRLOP.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -48,7 +48,7 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-O6P7DZ6O.js";
+} from "./chunk-3OZNFCPR.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -57,8 +57,6 @@ import {
 } from "./chunk-7MA4HV4W.js";
 import {
   bindSandboxFileSystem,
-  buildCommandScript,
-  buildNonInteractiveShellScript,
   createSandboxSession,
   ensureDockerDaemon,
   getSandboxResources,
@@ -71,10 +69,10 @@ import {
   isSandboxUnavailableError,
   isSnapshottingError,
   resolve,
-  runNonInteractiveCommand,
+  stopSession,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-6BJFIWEV.js";
+} from "./chunk-THS4CKN4.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -107,10 +105,10 @@ import {
   scheduledTaskAttributes,
   storeAttachments,
   writableEventTask
-} from "./chunk-4WYGQ47U.js";
+} from "./chunk-FEIHINKR.js";
 import {
   parseSlackThreadId
-} from "./chunk-WHAJ3QVY.js";
+} from "./chunk-ICJ3KCA2.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -181,7 +179,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-V7QL4QMW.js";
+} from "./chunk-MXFL7LNZ.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
@@ -203,8 +201,10 @@ import {
   normalizeSlackConversationId,
   readActorIdentity,
   resolveChannelCapabilities,
-  withSlackRetries
-} from "./chunk-QHCIZLIX.js";
+  tryWorkspaceRepoCheckoutPath,
+  withSlackRetries,
+  workspaceRepoCheckoutPath
+} from "./chunk-ZF6IC27P.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -216,23 +216,29 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-DDQ43S5Q.js";
+} from "./chunk-JI5EPI3O.js";
 import {
   juniorArtifacts,
-  juniorIdentities
-} from "./chunk-CZ6EHOU5.js";
+  juniorIdentities,
+  juniorWorkspaceRepos,
+  juniorWorkspaces
+} from "./chunk-ATWHPSMF.js";
 import {
   SANDBOX_DATA_ROOT,
+  SANDBOX_REPOS_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
+  buildCommandScript,
+  buildNonInteractiveShellScript,
+  runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-EM225ITJ.js";
+} from "./chunk-BVREIWBD.js";
 import {
   getStateAdapter
-} from "./chunk-DZC3F2UI.js";
+} from "./chunk-TPDNZCZU.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -265,7 +271,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-MNCEGXEH.js";
+} from "./chunk-YAUQXZVT.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -275,16 +281,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-7DTPFFQX.js";
+} from "./chunk-3T7RJVDJ.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-FEWT5KPP.js";
+} from "./chunk-4P2XNVTO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-FESUWAYU.js";
+} from "./chunk-RK7KPI6G.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -292,7 +298,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-EBEHJPFF.js";
+} from "./chunk-O4IK4O7C.js";
 import {
   credentialUserSubjectId
 } from "./chunk-BDUENQD3.js";
@@ -320,7 +326,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-Y75ZDQB5.js";
+} from "./chunk-TPT6EF7K.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -2935,6 +2941,33 @@ async function resolveSandboxCommandEnvironment() {
 import { randomUUID as randomUUID2 } from "crypto";
 import { Sandbox } from "@vercel/sandbox";
 
+// src/chat/sandbox/prepare-workspace.ts
+async function prepareWorkspaceSnapshot(params) {
+  const { sandbox, workspace, signal } = params;
+  signal?.throwIfAborted();
+  await params.applyNetworkPolicy(sandbox);
+  await params.prepareRepositories?.(sandbox, workspace, signal);
+  if (params.removeCredentialRoute) {
+    await sandbox.update({ networkPolicy: "allow-all" });
+  }
+  if (!workspace.setupScript.trim()) return;
+  const result = await sandbox.runCommand({
+    cmd: "bash",
+    args: ["-euo", "pipefail", "-c", workspace.setupScript],
+    cwd: SANDBOX_WORKSPACE_ROOT,
+    env: {
+      JUNIOR_REPOS_ROOT: SANDBOX_REPOS_ROOT,
+      JUNIOR_WORKSPACE_ROOT: SANDBOX_WORKSPACE_ROOT
+    },
+    signal
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Workspace setup failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`
+    );
+  }
+}
+
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
 import path3 from "path";
@@ -3130,9 +3163,7 @@ var SANDBOX_NAME_PREFIX = "junior-";
 var MAX_KEEPALIVE_INTERVAL_MS = 3e4;
 var MIN_KEEPALIVE_INTERVAL_MS = 1e3;
 function sandboxFetchOptions(signal) {
-  if (!signal) {
-    return {};
-  }
+  if (!signal) return {};
   return {
     fetch: (input, init) => {
       const requestSignal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
@@ -3144,14 +3175,11 @@ function sandboxFetchOptions(signal) {
   };
 }
 function truncateOutput(output, maxLength) {
-  if (output.length <= maxLength) {
-    return { value: output, truncated: false };
-  }
-  const truncatedLength = output.length - maxLength;
+  if (output.length <= maxLength) return { value: output, truncated: false };
   return {
     value: `${output.slice(0, maxLength)}
 
-[output truncated: ${truncatedLength} characters removed]`,
+[output truncated: ${output.length - maxLength} characters removed]`,
     truncated: true
   };
 }
@@ -3183,13 +3211,12 @@ function createSandboxRuntime(options) {
   let closed = false;
   const timeoutMs = options.timeoutMs ?? 1e3 * 60 * 30;
   const traceContext = options.traceContext ?? {};
-  const dependencyProfileHash = hash(SANDBOX_RUNTIME);
+  let activeWorkspace = options.workspace;
+  let dependencyProfileHash = hash(SANDBOX_RUNTIME, activeWorkspace);
   const resolveCommandEnv = options.commandEnv ?? (async () => ({}));
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
   const invalidateSession = (sessionId) => {
-    if (sessionId && activeSandbox && activeSandbox.session.sessionId !== sessionId) {
-      return;
-    }
+    if (sessionId && activeSandbox?.session.sessionId !== sessionId) return;
     activeSandbox = null;
     if (keepAliveTimer) {
       clearTimeout(keepAliveTimer);
@@ -3200,21 +3227,21 @@ function createSandboxRuntime(options) {
     onUnavailable: invalidateSession
   });
   const createSandboxName = () => `${SANDBOX_NAME_PREFIX}${randomUUID2()}`;
-  const preflightNetworkPolicy = (sandboxName) => {
-    return options.createNetworkPolicy?.(sandboxName);
-  };
-  const reportSandboxRef = async (nextSandbox) => {
-    const nextRef = {
-      id: nextSandbox.sandboxId,
-      ...dependencyProfileHash ? { profileHash: dependencyProfileHash } : {}
-    };
-    sandboxRef = nextRef;
-    if (reportedSandboxRef?.id === nextRef.id && reportedSandboxRef.profileHash === nextRef.profileHash) {
+  const preflightNetworkPolicy = (sandboxName) => options.createNetworkPolicy?.(sandboxName);
+  const persistSandboxRef = async (nextRef) => {
+    if (reportedSandboxRef?.id === nextRef.id && reportedSandboxRef.profileHash === nextRef.profileHash && reportedSandboxRef.workspaceId === nextRef.workspaceId) {
+      sandboxRef = nextRef;
       return;
     }
     await options.onSandboxRefChanged?.(nextRef);
+    sandboxRef = nextRef;
     reportedSandboxRef = nextRef;
   };
+  const sandboxReference = (session, workspace, hash2) => ({
+    id: session.sandboxId,
+    ...hash2 ? { profileHash: hash2 } : {},
+    ...workspace?.id ? { workspaceId: workspace.id } : {}
+  });
   const rememberSandbox = (nextSandbox, networkPolicyKey) => {
     activeSandbox = { session: nextSandbox, networkPolicyKey };
     return nextSandbox;
@@ -3327,7 +3354,15 @@ function createSandboxRuntime(options) {
     });
   };
   const createSandboxFromResolvedSnapshot = async (params) => {
-    const { runtime, snapshot, sandboxCredentials, sandboxName, signal } = params;
+    const {
+      runtime,
+      snapshot,
+      sandboxCredentials,
+      sandboxName,
+      signal,
+      workspace,
+      prepareWorkspace
+    } = params;
     signal?.throwIfAborted();
     if (!snapshot.snapshotId) {
       const networkPolicy = preflightNetworkPolicy(sandboxName);
@@ -3362,7 +3397,9 @@ function createSandboxRuntime(options) {
         timeoutMs,
         forceRebuild: true,
         staleSnapshotId: snapshot.snapshotId,
-        signal
+        signal,
+        workspace,
+        prepareWorkspace
       });
       if (!rebuiltSnapshot.snapshotId) {
         throw error;
@@ -3376,10 +3413,18 @@ function createSandboxRuntime(options) {
       );
     }
   };
-  const createFreshSandbox = async (signal) => {
+  const createSandboxCandidate = async (workspace, hash2, signal) => {
     const runtime = SANDBOX_RUNTIME;
     const sandboxCredentials = getVercelSandboxCredentials();
     const sandboxName = createSandboxName();
+    const prepareWorkspace = workspace ? async (sandbox) => await prepareWorkspaceSnapshot({
+      sandbox,
+      workspace,
+      signal,
+      applyNetworkPolicy,
+      prepareRepositories: options.onWorkspacePrepare,
+      removeCredentialRoute: Boolean(options.createNetworkPolicy)
+    }) : void 0;
     let createdSandbox;
     try {
       createdSandbox = await withSandboxSpan(
@@ -3394,7 +3439,9 @@ function createSandboxRuntime(options) {
           const snapshot = await resolve({
             runtime,
             timeoutMs,
-            signal
+            signal,
+            workspace,
+            prepareWorkspace
           });
           signal?.throwIfAborted();
           setSnapshotAttributes(snapshot);
@@ -3403,47 +3450,74 @@ function createSandboxRuntime(options) {
             snapshot,
             sandboxCredentials,
             sandboxName,
-            signal
+            signal,
+            workspace,
+            prepareWorkspace
           });
         }
       );
     } catch (error) {
       return failSetup(error);
     }
-    await reportSandboxRef(createdSandbox);
+    const ref = sandboxReference(createdSandbox, workspace, hash2);
+    if (!workspace) {
+      try {
+        await persistSandboxRef(ref);
+      } catch (error) {
+        await stopSession(createdSandbox);
+        throw error;
+      }
+    }
     let networkPolicyKey;
     try {
       networkPolicyKey = await applyNetworkPolicy(createdSandbox);
       await prepareSandbox(createdSandbox);
     } catch (error) {
+      if (workspace) await stopSession(createdSandbox);
       return failSetup(error);
     }
-    return rememberSandbox(createdSandbox, networkPolicyKey);
+    return {
+      session: createdSandbox,
+      networkPolicyKey,
+      profileHash: hash2,
+      ref,
+      workspace
+    };
+  };
+  const createFreshSandbox = async (signal) => {
+    const candidate = await createSandboxCandidate(
+      activeWorkspace,
+      dependencyProfileHash,
+      signal
+    );
+    try {
+      await persistSandboxRef(candidate.ref);
+      return rememberSandbox(candidate.session, candidate.networkPolicyKey);
+    } catch (error) {
+      await stopSession(candidate.session);
+      throw error;
+    }
   };
   const discardHintIfProfileChanged = () => {
     if (activeSandbox || !sandboxRef || dependencyProfileHash === sandboxRef.profileHash) {
       return;
     }
+    const attrs = {
+      ...sandboxRef.profileHash ? { "app.sandbox.previous_profile_hash": sandboxRef.profileHash } : {},
+      ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+    };
     setSpanAttributes({
       "app.sandbox.reused": false,
       "app.sandbox.recreate.reason": "dependency_profile_mismatch",
-      ...sandboxRef.profileHash ? {
-        "app.sandbox.previous_profile_hash": sandboxRef.profileHash
-      } : {},
-      ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+      ...attrs
     });
     logInfo("sandbox.hint.discarded", {
       "app.decision.reason": "dependency_profile_mismatch",
-      ...sandboxRef.profileHash ? {
-        "app.sandbox.previous_profile_hash": sandboxRef.profileHash
-      } : {},
-      ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+      ...attrs
     });
     sandboxRef = void 0;
   };
-  const tryReuseCachedSandbox = async () => {
-    return activeSandbox?.session ?? null;
-  };
+  const tryReuseCachedSandbox = () => activeSandbox?.session ?? null;
   const tryRestoreHintedSandbox = async (signal) => {
     const ref = sandboxRef;
     if (!ref) {
@@ -3481,9 +3555,9 @@ function createSandboxRuntime(options) {
     }
     let networkPolicyKey;
     try {
-      await reportSandboxRef(hintedSandbox);
       networkPolicyKey = await applyNetworkPolicy(hintedSandbox);
       await prepareSandbox(hintedSandbox);
+      await persistSandboxRef({ ...ref, id: hintedSandbox.sandboxId });
       return rememberSandbox(hintedSandbox, networkPolicyKey);
     } catch (error) {
       if (isSandboxUnavailableError(error)) {
@@ -3589,33 +3663,25 @@ function createSandboxRuntime(options) {
       stderrTruncated: stderr.truncated
     };
   };
-  const extendKeepAlive = async (activeSandbox2) => {
+  const extendKeepAlive = async (session) => {
     const keepAliveMs = parseKeepAliveMs();
-    if (keepAliveMs === 0) {
-      return;
-    }
+    if (keepAliveMs === 0) return;
     try {
       await withSandboxSpan(
         "sandbox.keepalive.extend",
         "sandbox.keepalive",
-        {
-          "app.sandbox.keepalive_ms": keepAliveMs
-        },
+        { "app.sandbox.keepalive_ms": keepAliveMs },
         async () => {
-          await activeSandbox2.extendTimeout(keepAliveMs);
+          await session.extendTimeout(keepAliveMs);
         }
       );
     } catch (error) {
-      if (isSandboxUnavailableError(error)) {
-        throw error;
-      }
+      if (isSandboxUnavailableError(error)) throw error;
     }
   };
   const startKeepAlive = (session) => {
     const keepAliveMs = parseKeepAliveMs();
-    if (keepAliveMs === 0 || closed || keepAliveTimer) {
-      return;
-    }
+    if (keepAliveMs === 0 || closed || keepAliveTimer) return;
     const intervalMs = Math.max(
       MIN_KEEPALIVE_INTERVAL_MS,
       Math.min(MAX_KEEPALIVE_INTERVAL_MS, Math.floor(keepAliveMs / 2))
@@ -3623,18 +3689,14 @@ function createSandboxRuntime(options) {
     const schedule = () => {
       keepAliveTimer = setTimeout(async () => {
         keepAliveTimer = void 0;
-        if (closed || activeSandbox?.session !== session) {
-          return;
-        }
+        if (closed || activeSandbox?.session !== session) return;
         try {
           await extendKeepAlive(session);
         } catch {
           invalidateSession(session.sessionId);
           return;
         }
-        if (closed || activeSandbox?.session !== session) {
-          return;
-        }
+        if (closed || activeSandbox?.session !== session) return;
         schedule();
       }, intervalMs);
       keepAliveTimer.unref?.();
@@ -3714,18 +3776,57 @@ function createSandboxRuntime(options) {
     };
   };
   const ensureReadySandbox = async (signal) => {
-    const activeSandbox2 = await getOrAcquireSandbox(signal);
+    const session = await getOrAcquireSandbox(signal);
     signal?.throwIfAborted();
-    await probeSession(activeSandbox2);
+    await probeSession(session);
     signal?.throwIfAborted();
-    await extendKeepAlive(activeSandbox2);
-    startKeepAlive(activeSandbox2);
-    return activeSandbox2;
+    await extendKeepAlive(session);
+    startKeepAlive(session);
+    return session;
   };
   return {
     sandboxRef() {
       return sandboxRef ? { ...sandboxRef } : void 0;
     },
+    async switchWorkspace(workspace, signal) {
+      signal?.throwIfAborted();
+      const nextProfileHash = hash(SANDBOX_RUNTIME, workspace);
+      if (activeWorkspace?.id === workspace.id && dependencyProfileHash === nextProfileHash) {
+        return;
+      }
+      if (acquiringSandbox) {
+        await getOrAcquireSandbox(signal);
+      }
+      const previous = activeSandbox;
+      let candidate;
+      try {
+        candidate = await createSandboxCandidate(
+          workspace,
+          nextProfileHash,
+          signal
+        );
+        await probeSession(candidate.session);
+        signal?.throwIfAborted();
+        await extendKeepAlive(candidate.session);
+        signal?.throwIfAborted();
+        await persistSandboxRef(candidate.ref);
+      } catch (error) {
+        await stopSession(candidate?.session);
+        throw error;
+      }
+      if (keepAliveTimer) {
+        clearTimeout(keepAliveTimer);
+        keepAliveTimer = void 0;
+      }
+      activeWorkspace = candidate.workspace;
+      dependencyProfileHash = candidate.profileHash;
+      activeSandbox = {
+        session: candidate.session,
+        networkPolicyKey: candidate.networkPolicyKey
+      };
+      startKeepAlive(candidate.session);
+      await stopSession(previous?.session);
+    },
     async acquire(signal) {
       return await getOrAcquireSandbox(signal);
     },
@@ -4965,8 +5066,10 @@ function createSandbox(options) {
       ...permissionDenied ? { permissionDenied } : {}
     };
   };
+  let activeWorkspace = options.workspace;
   const runtime = createSandboxRuntime({
     sandboxRef: options.sandboxRef,
+    workspace: options.workspace,
     skills: options.skills,
     referenceFiles: options.referenceFiles,
     timeoutMs: options.timeoutMs,
@@ -4980,6 +5083,7 @@ function createSandbox(options) {
       traceHeaders
     }) : void 0,
     onSandboxPrepare: options.prepare,
+    onWorkspacePrepare: options.prepareWorkspace,
     onSandboxRefChanged: options.onSandboxRefChanged
   });
   const createToolCallContext = (signal, setToolCallSpanAttributes) => {
@@ -5422,7 +5526,9 @@ function createSandbox(options) {
         return void 0;
       }
       const { fs: fs5 } = await runtime.tools();
-      const selected = await findSingleRepositoryDirectory(fs5);
+      const primary = activeWorkspace?.repos.find((repo) => repo.isPrimary);
+      const primaryPath = primary ? tryWorkspaceRepoCheckoutPath(primary.repo) : void 0;
+      const selected = primaryPath ? `${SANDBOX_WORKSPACE_ROOT}/${primaryPath}` : await findSingleRepositoryDirectory(fs5);
       if (!selected) return void 0;
       return await resolveRepositoryInstructions({
         cwd: selected,
@@ -5430,6 +5536,10 @@ function createSandbox(options) {
       });
     },
     workspace,
+    async switchWorkspace(recipe, signal) {
+      await runtime.switchWorkspace(recipe, signal);
+      activeWorkspace = recipe;
+    },
     tools: {
       supports(toolName) {
         return SANDBOX_TOOL_NAMES.has(toolName);
@@ -5851,6 +5961,7 @@ function bashCommand(input) {
 function createAgentSandbox(options) {
   const sandbox = createSandbox({
     sandboxRef: options.sandboxRef,
+    workspace: options.workspace,
     skills: options.skills,
     referenceFiles: listReferenceFiles(),
     traceContext: options.traceContext,
@@ -5858,6 +5969,7 @@ function createAgentSandbox(options) {
     egressSignals: options.egressSignals,
     credentialEgress: options.credentialEgress,
     prepare: options.prepareSandbox,
+    prepareWorkspace: options.prepareWorkspace,
     onSandboxRefChanged: async (sandboxRef) => {
       options.onSandboxRefChanged(sandboxRef);
       await options.persistSandboxRef?.(sandboxRef);
@@ -5867,6 +5979,7 @@ function createAgentSandbox(options) {
     captureRepositoryInstructions: sandbox.captureRepositoryInstructions,
     workspace: sandbox.workspace,
     sandboxRef: sandbox.sandboxRef,
+    switchWorkspace: sandbox.switchWorkspace,
     close: sandbox.close,
     tools: {
       supports: sandbox.tools.supports,
@@ -13554,6 +13667,133 @@ function createWriteFileTool() {
   });
 }
 
+// src/chat/workspaces/tools.ts
+import { z as z63 } from "zod";
+
+// src/chat/workspaces/store.ts
+import { asc, eq as eq3 } from "drizzle-orm";
+function workspaceFromRows(row, repos) {
+  return {
+    id: row.id,
+    name: row.name,
+    setupScript: row.setupScript,
+    repos: repos.map((repo) => ({
+      provider: repo.provider,
+      repo: repo.repo,
+      isPrimary: repo.isPrimary
+    }))
+  };
+}
+async function listWorkspaces(db) {
+  const [workspaces, repos] = await Promise.all([
+    db.select().from(juniorWorkspaces).orderBy(asc(juniorWorkspaces.name)),
+    db.select().from(juniorWorkspaceRepos).orderBy(
+      asc(juniorWorkspaceRepos.workspaceId),
+      asc(juniorWorkspaceRepos.provider),
+      asc(juniorWorkspaceRepos.repo)
+    )
+  ]);
+  return workspaces.map(
+    (workspace) => workspaceFromRows(
+      workspace,
+      repos.filter((repo) => repo.workspaceId === workspace.id)
+    )
+  );
+}
+async function getWorkspaceByName(db, name) {
+  const rows = await db.select().from(juniorWorkspaces).where(eq3(juniorWorkspaces.name, name)).limit(1);
+  const workspace = rows[0];
+  if (!workspace) return void 0;
+  const repos = await db.select().from(juniorWorkspaceRepos).where(eq3(juniorWorkspaceRepos.workspaceId, workspace.id)).orderBy(
+    asc(juniorWorkspaceRepos.provider),
+    asc(juniorWorkspaceRepos.repo)
+  );
+  return workspaceFromRows(workspace, repos);
+}
+async function getWorkspace(db, id) {
+  const rows = await db.select().from(juniorWorkspaces).where(eq3(juniorWorkspaces.id, id)).limit(1);
+  const workspace = rows[0];
+  if (!workspace) return void 0;
+  const repos = await db.select().from(juniorWorkspaceRepos).where(eq3(juniorWorkspaceRepos.workspaceId, workspace.id)).orderBy(
+    asc(juniorWorkspaceRepos.provider),
+    asc(juniorWorkspaceRepos.repo)
+  );
+  return workspaceFromRows(workspace, repos);
+}
+
+// src/chat/workspaces/tools.ts
+var repoSchema = z63.object({
+  provider: z63.string(),
+  repo: z63.string(),
+  checkout_path: z63.string(),
+  is_primary: z63.boolean()
+});
+var workspaceSchema = z63.object({
+  id: z63.string(),
+  name: z63.string(),
+  repos: z63.array(repoSchema)
+});
+function view(workspace) {
+  return {
+    id: workspace.id,
+    name: workspace.name,
+    repos: workspace.repos.map((repo) => ({
+      provider: repo.provider,
+      repo: repo.repo,
+      checkout_path: workspaceRepoCheckoutPath(repo.repo),
+      is_primary: repo.isPrimary
+    }))
+  };
+}
+function createWorkspaceTools(context) {
+  if (!context.workspaces) return {};
+  return {
+    listWorkspaces: zodTool({
+      annotations: {
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+        readOnlyHint: true
+      },
+      description: "List named repository workspaces that can replace the current sandbox.",
+      inputSchema: z63.object({}).strict(),
+      outputSchema: juniorToolOutputSchema.extend({
+        active_workspace_id: z63.string().nullable(),
+        workspaces: z63.array(workspaceSchema)
+      }),
+      async execute() {
+        return {
+          active_workspace_id: context.workspaces.activeWorkspaceId() ?? null,
+          workspaces: (await listWorkspaces(getDb())).map(view)
+        };
+      }
+    }),
+    switchWorkspace: zodTool({
+      executionMode: "sequential",
+      annotations: {
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+        readOnlyHint: false
+      },
+      description: "Replace the current sandbox with a named preconfigured repository workspace. Files in the prior sandbox do not carry over.",
+      inputSchema: z63.object({
+        name: z63.string().trim().min(1).describe("Exact workspace name.")
+      }).strict(),
+      outputSchema: juniorToolOutputSchema.extend({
+        workspace: workspaceSchema
+      }),
+      async execute({ name }, options) {
+        const workspace = await getWorkspaceByName(getDb(), name);
+        if (!workspace)
+          throw new ToolInputError(`Workspace not found: ${name}`);
+        await context.workspaces.switch(workspace, options.signal);
+        return { workspace: view(workspace) };
+      }
+    })
+  };
+}
+
 // src/chat/tools/index.ts
 function createToolState() {
   const operationResultCache = /* @__PURE__ */ new Map();
@@ -13596,7 +13836,8 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
     }),
     ...createResourceEventTools(context, resourceEventCatalog),
     ...createEventTaskTools(context, resourceEventCatalog),
-    ...createScheduledTaskTools(context)
+    ...createScheduledTaskTools(context),
+    ...createWorkspaceTools(context)
   };
   if (context.conversationId) {
     tools.searchConversationEvents = createSearchConversationEventsTool(context);
@@ -14278,7 +14519,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -14290,11 +14531,11 @@ function createExecuteToolTool() {
     },
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z63.object({
-      tool_name: z63.string().min(1).describe(
+    inputSchema: z64.object({
+      tool_name: z64.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z63.record(z63.string(), z63.unknown()).describe(
+      arguments: z64.record(z64.string(), z64.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -14334,7 +14575,7 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
@@ -14379,29 +14620,29 @@ var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
   "you",
   "your"
 ]);
-var searchToolsSourceSchema = z64.object({
-  id: z64.string(),
-  description: z64.string()
+var searchToolsSourceSchema = z65.object({
+  id: z65.string(),
+  description: z65.string()
 }).strict();
-var searchToolsToolSchema = z64.object({
-  tool_name: z64.string(),
-  description: z64.string(),
-  exposure: z64.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z64.string().optional(),
-  input_schema: z64.unknown(),
-  call_notes: z64.array(z64.string()),
-  annotations: z64.record(z64.string(), z64.unknown())
+var searchToolsToolSchema = z65.object({
+  tool_name: z65.string(),
+  description: z65.string(),
+  exposure: z65.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z65.string().optional(),
+  input_schema: z65.unknown(),
+  call_notes: z65.array(z65.string()),
+  annotations: z65.record(z65.string(), z65.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z64.string().nullable(),
-  source: z64.string().nullable(),
-  sources: z64.array(searchToolsSourceSchema),
-  total_catalog_tools: z64.number().int().nonnegative(),
-  total_eligible_tools: z64.number().int().nonnegative(),
-  total_matches: z64.number().int().nonnegative(),
-  returned_tools: z64.number().int().nonnegative(),
-  execution_tool: z64.literal("executeTool"),
-  tools: z64.array(searchToolsToolSchema)
+  query: z65.string().nullable(),
+  source: z65.string().nullable(),
+  sources: z65.array(searchToolsSourceSchema),
+  total_catalog_tools: z65.number().int().nonnegative(),
+  total_eligible_tools: z65.number().int().nonnegative(),
+  total_matches: z65.number().int().nonnegative(),
+  returned_tools: z65.number().int().nonnegative(),
+  execution_tool: z65.literal("executeTool"),
+  tools: z65.array(searchToolsToolSchema)
 }).strict();
 function terms(value) {
   const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
@@ -14612,14 +14853,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z64.object({
-      query: z64.string().nullable().describe(
+    inputSchema: z65.object({
+      query: z65.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z64.string().nullable().describe(
+      source: z65.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z64.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z65.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -15878,7 +16119,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -15946,17 +16187,17 @@ Assess the exact action's intrinsic risk and whether the user's intent authorize
 - Keep the reason to one concise, specific sentence grounded in the main risk or authorization fact. For ask, name the exact action, target, and material side effects the user must confirm.`;
 
 // src/chat/services/guardian-action-review.ts
-var guardianDecisionSchema = z65.object({
-  decision: z65.enum(["allow", "ask", "deny"]),
-  reason: z65.string().trim().min(1).max(500),
-  riskLevel: z65.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z65.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z66.object({
+  decision: z66.enum(["allow", "ask", "deny"]),
+  reason: z66.string().trim().min(1).max(500),
+  riskLevel: z66.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z66.enum(["high", "medium", "low", "unknown"])
 }).strict();
 var GUARDIAN_REVIEW_TIMEOUT_MS = 6e4;
 var GUARDIAN_REVIEW_MAX_TOKENS = 2e3;
 var MAX_PROPOSAL_CHARS = 192e3;
 function guardianPrompt(proposal) {
-  const proposalJson = JSON.stringify(z65.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z66.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -16241,8 +16482,10 @@ async function wireAgentTools(args) {
     actor: args.currentActor,
     actors: args.currentActors
   });
+  const workspace = args.state.sandboxRef?.workspaceId ? await getWorkspace(getDb(), args.state.sandboxRef.workspaceId) : void 0;
   const agentSandbox = createAgentSandbox({
     sandboxRef: args.state.sandboxRef,
+    workspace,
     skills: args.availableSkills,
     traceContext: args.spanContext,
     tracePropagation: args.run.environment?.sandboxTracePropagation,
@@ -16253,6 +16496,7 @@ async function wireAgentTools(args) {
     configurationValues: args.configurationValues,
     getActiveSkill: () => args.skillSandbox.getActiveSkill(),
     prepareSandbox: pluginHooks.prepareSandbox,
+    prepareWorkspace: async (sandbox, recipe, signal) => await pluginHooks.prepareWorkspace(sandbox, recipe.repos, signal),
     onSandboxRefChanged: args.onSandboxRefChanged,
     persistSandboxRef: args.durability.onSandboxRefChanged
   });
@@ -16356,7 +16600,11 @@ async function wireAgentTools(args) {
   const toolRuntimeContext = {
     ...commonToolRuntimeContext,
     ...toolRoute,
-    attachmentStorage: args.run.environment?.attachmentStorage
+    attachmentStorage: args.run.environment?.attachmentStorage,
+    workspaces: {
+      activeWorkspaceId: () => agentSandbox.sandboxRef()?.workspaceId,
+      switch: agentSandbox.switchWorkspace
+    }
   };
   const actionReview = createToolActionReview({
     context: {