@sentry/junior 0.162.0 → 0.164.0

package/dist/{catalog-runtime-IGSMIADJ.js → catalog-runtime-CZ2SQINY.js}

@@ -1,15 +1,15 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-FESUWAYU.js";
-import "./chunk-EBEHJPFF.js";
+} from "./chunk-RULIISEI.js";
+import "./chunk-VV2DN24T.js";
 import "./chunk-BDUENQD3.js";
 import "./chunk-V7YE4WCP.js";
-import "./chunk-Y75ZDQB5.js";
+import "./chunk-VHSEMJTS.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-THXMSSFZ.js";
-import "./chunk-BPZQWAZJ.js";
+import "./chunk-26JYGL2L.js";
+import "./chunk-5GLGQHO3.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/agent/sandbox.d.ts

@@ -18,9 +18,11 @@ import type { RepositoryInstructions } from "@/chat/repository-instructions";
 import { type SandboxTools } from "@/chat/sandbox/sandbox";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { Skill, SkillMetadata } from "@/chat/skills";
+import type { Workspace } from "@/chat/workspaces/types";
 import type { GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
 export interface AgentSandboxOptions {
     sandboxRef?: SandboxRef;
+    workspace?: Workspace;
     skills: SkillMetadata[];
     traceContext: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
@@ -31,6 +33,7 @@ export interface AgentSandboxOptions {
     configurationValues: Record<string, unknown>;
     getActiveSkill(): Skill | null;
     prepareSandbox(workspace: SandboxWorkspace): void | Promise<void>;
+    prepareWorkspace?(workspace: SandboxWorkspace, recipe: Workspace, signal?: AbortSignal): Promise<void>;
     onSandboxRefChanged(sandboxRef: SandboxRef): void;
     persistSandboxRef?(sandboxRef: SandboxRef): void | Promise<void>;
 }
@@ -40,6 +43,7 @@ export interface AgentSandbox {
     readonly tools: SandboxTools;
     readonly workspace: SandboxWorkspace;
     sandboxRef(): SandboxRef | undefined;
+    switchWorkspace(workspace: Workspace, signal?: AbortSignal): Promise<void>;
     close(): void;
     writeGeneratedArtifacts(files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;
 }

package/dist/chat/api-turns/cancellation.d.ts

@@ -0,0 +1,27 @@
+/** App-scoped control for one active API Turn per Conversation. */
+export interface ApiTurnCancellation {
+    begin(conversationId: string): AbortSignal | undefined;
+    cancel(conversationId: string): boolean;
+    disconnect(conversationId: string, signal: AbortSignal): void;
+    finish(conversationId: string, signal: AbortSignal): void;
+    park(conversationId: string, signal: AbortSignal): void;
+    signal(conversationId: string): AbortSignal | undefined;
+}
+/** Create in-process cancellation state for active API Turns. */
+export declare function createApiTurnCancellation(): ApiTurnCancellation;
+/** Close one cancelled API Turn without a failure reply or retry. */
+export declare function completeCancelledApiTurn(args: {
+    acknowledge(): Promise<void>;
+    actorId: string;
+    cancellation?: ApiTurnCancellation;
+    conversation: ThreadConversationState;
+    conversationId: string;
+    lifecycle: ConversationTurnLifecycle;
+    sandboxRef?: SandboxRef;
+    signal?: AbortSignal;
+    turnId: string;
+    userMessageId: string;
+}): Promise<void>;
+import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
+import type { SandboxRef } from "@/chat/sandbox/ref";
+import type { ThreadConversationState } from "@/chat/state/conversation";

package/dist/chat/api-turns/routing.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import type { InboundMessage } from "@/chat/task-execution/store";
+import type { ConversationWorkerContext } from "@/chat/task-execution/worker";
+declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
+    authorEmail: z.ZodString;
+    authorFullName: z.ZodOptional<z.ZodString>;
+    authorUserId: z.ZodString;
+    authorUserName: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"api_turn">;
+    messageId: z.ZodString;
+}, z.core.$strict>;
+export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+/**
+ * Resolve API Turn work from mailbox metadata or an active checkpoint.
+ *
+ * Empty resume wakes after yield carry no mailbox rows. Use durable active
+ * Turn state so these wakes do not fall through to Slack.
+ */
+export declare function resolveApiTurnWork(context: ConversationWorkerContext): Promise<{
+    kind: "mailbox";
+    batch: Array<{
+        message: InboundMessage;
+        metadata: ApiTurnMailboxMetadata;
+    }>;
+} | {
+    kind: "resume";
+    turnId: string;
+} | undefined>;
+/** Return whether the leased attempt belongs to an API Turn. */
+export declare function isApiTurnWork(context: ConversationWorkerContext): Promise<boolean>;
+export {};

package/dist/chat/api-turns/work.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import type { StateAdapter } from "chat";
 import { type Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
@@ -9,15 +8,8 @@ import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
-declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
-    authorEmail: z.ZodString;
-    authorFullName: z.ZodOptional<z.ZodString>;
-    authorUserId: z.ZodString;
-    authorUserName: z.ZodOptional<z.ZodString>;
-    kind: z.ZodLiteral<"api_turn">;
-    messageId: z.ZodString;
-}, z.core.$strict>;
-type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+import { type ApiTurnCancellation } from "@/chat/api-turns/cancellation";
+export { resolveApiTurnWork } from "@/chat/api-turns/routing";
 type EnqueueOptions = {
     conversationStore?: ConversationStore;
     nowMs?: number;
@@ -73,31 +65,23 @@ export declare function buildApiTurnInboundMessage(args: {
     messageId: string;
     nowMs?: number;
 }): InboundMessage;
+/** Record web activity and materialize a new API Conversation root when needed. */
+export declare function recordApiConversationActivity(args: {
+    actor: WebActor;
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    nowMs: number;
+    /** Applied only when this call creates the conversation root. */
+    rootVisibility?: ConversationPrivacy;
+}): Promise<Destination>;
 /** Create a dashboard root conversation and enqueue its first message. */
 export declare function createAndEnqueueApiConversation(input: CreateApiConversationInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
 /** Append one API message to an existing conversation and wake the worker. */
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
-/**
- * Resolve API turn work from mailbox metadata or an active API turn checkpoint.
- *
- * Empty resume wakes after yield carry no mailbox rows; match agent-invocation
- * and look up durable active turn state instead of falling through to Slack.
- */
-export declare function resolveApiTurnWork(context: ConversationWorkerContext): Promise<{
-    kind: "mailbox";
-    batch: Array<{
-        message: InboundMessage;
-        metadata: ApiTurnMailboxMetadata;
-    }>;
-} | {
-    kind: "resume";
-    turnId: string;
-} | undefined>;
-/** True when this leased attempt is API-authored root work. */
-export declare function isApiTurnWork(context: ConversationWorkerContext): Promise<boolean>;
 /** Build the mailbox consumer for API-authored root turns. */
 export declare function createApiTurnWorker(options: {
     agentRunner: AgentRunner;
+    cancellation?: ApiTurnCancellation;
     turnLifecycle?: ConversationTurnLifecycle;
 }): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Route API turn work before falling through to other consumers. */
@@ -105,4 +89,3 @@ export declare function routeApiTurnWork(options: {
     apiTurnWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
     fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 }): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
-export {};

package/dist/chat/app/conversation-work.d.ts

@@ -4,6 +4,7 @@ import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
+import { type ApiTurnCancellation } from "@/chat/api-turns/cancellation";
 import { createSlackRuntime } from "./factory";
 import type { JuniorRuntimeServiceOverrides } from "./services";
 interface ConversationWorkOptions {
@@ -14,11 +15,15 @@ interface ConversationWorkOptions {
     services?: JuniorRuntimeServiceOverrides;
     state?: StateAdapter;
 }
+export type ConversationWorkCallbackOptions = VercelConversationWorkCallbackOptions & {
+    /** App-scoped control required by the experimental ACP route. */
+    apiTurnCancellation?: ApiTurnCancellation;
+};
 /**
  * Compose conversation work once for production and integration tests.
  * Environment-specific queue, state, Slack, and agent adapters stop here.
  */
-export declare function createConversationWork(options: ConversationWorkOptions): VercelConversationWorkCallbackOptions & {
+export declare function createConversationWork(options: ConversationWorkOptions): ConversationWorkCallbackOptions & {
     runtime: ReturnType<typeof createSlackRuntime>;
 };
 export {};

package/dist/chat/app/production.d.ts

@@ -2,9 +2,9 @@ import type { SlackAdapter } from "@chat-adapter/slack";
 import { createSlackRuntime } from "@/chat/app/factory";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { SlackWebhookServices } from "@/chat/ingress/slack-webhook";
-import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
 import type { ConversationStore } from "@/chat/conversations/store";
+import { type ConversationWorkCallbackOptions } from "@/chat/app/conversation-work";
 /** Return the lazily initialized production Slack adapter. */
 export declare function getProductionSlackAdapter(): SlackAdapter;
 /** Return the lazily initialized production Slack runtime. */
@@ -21,4 +21,4 @@ export declare function getProductionSlackWebhookServices(): SlackWebhookService
 export declare function createProductionConversationWorkOptions(options: {
     agentRunner: AgentRunner;
     services?: JuniorRuntimeServiceOverrides;
-}): VercelConversationWorkCallbackOptions;
+}): ConversationWorkCallbackOptions;

package/dist/chat/conversations/history.d.ts

@@ -342,6 +342,7 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     outcome: z.ZodEnum<{
         success: "success";
         no_reply: "no_reply";
+        cancelled: "cancelled";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"turn_failed">;
@@ -657,6 +658,7 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         outcome: z.ZodEnum<{
             success: "success";
             no_reply: "no_reply";
+            cancelled: "cancelled";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_failed">;
@@ -995,6 +997,7 @@ export declare const newConversationEventSchema: z.ZodObject<{
         outcome: z.ZodEnum<{
             success: "success";
             no_reply: "no_reply";
+            cancelled: "cancelled";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_failed">;

package/dist/chat/conversations/turn-lifecycle.d.ts

@@ -11,7 +11,7 @@ export interface StartConversationTurnInput {
 export interface CompleteConversationTurnInput {
     conversationId: string;
     createdAtMs: number;
-    outcome: "success" | "no_reply";
+    outcome: "success" | "no_reply" | "cancelled";
     turnId: string;
 }
 /** Privacy-safe inputs for failing one correlated conversation turn. */

package/dist/chat/experimental.d.ts

@@ -3,7 +3,7 @@
  * Add new keys here as features graduate from private experiments; remove them
  * once they become stable defaults.
  */
-export declare const EXPERIMENTAL_FEATURES: readonly ["subagents"];
+export declare const EXPERIMENTAL_FEATURES: readonly ["acp", "subagents"];
 /** One known experimental feature name. */
 export type ExperimentalFeature = (typeof EXPERIMENTAL_FEATURES)[number];
 /** App-level opt-ins for unstable product features. */

package/dist/chat/plugins/agent-hooks.d.ts

@@ -36,6 +36,10 @@ export interface PluginHookRunner {
     afterMcpTool(input: AfterMcpToolHookInput): Promise<void>;
     beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
     prepareSandbox(workspace: SandboxWorkspace): Promise<void>;
+    prepareWorkspace(workspace: SandboxWorkspace, repos: Array<{
+        provider: string;
+        repo: string;
+    }>, signal?: AbortSignal): Promise<void>;
 }
 /** Validate plugin identity before it can affect process-wide hooks. */
 export declare function validatePlugins(plugins: PluginRegistration[]): void;

package/dist/chat/repository-instructions.d.ts

@@ -20,7 +20,7 @@ export type VisibleAgentsInstructions = {
     directory?: string;
     text: string;
 };
-/** Return the only direct-child Git worktree, without guessing when ambiguous. */
+/** Return the only Git worktree under repos/, without guessing when ambiguous. */
 export declare function findSingleRepositoryDirectory(fs: SandboxFileSystem): Promise<string | undefined>;
 /** Resolve the effective root-to-cwd AGENTS.md bundle for one selected directory. */
 export declare function resolveRepositoryInstructions(args: {

package/dist/chat/sandbox/paths.d.ts

@@ -1,4 +1,5 @@
 export declare const SANDBOX_WORKSPACE_ROOT: string;
+export declare const SANDBOX_REPOS_ROOT: string;
 export declare const SANDBOX_SKILLS_ROOT: string;
 export declare const SANDBOX_DATA_ROOT: string;
 export declare function sandboxSkillDir(skillName: string): string;

package/dist/chat/sandbox/prepare-workspace.d.ts

@@ -0,0 +1,11 @@
+import type { SandboxSession } from "@/chat/sandbox/workspace";
+import type { Workspace } from "@/chat/workspaces/types";
+/** Prepare repositories and setup state before a Workspace snapshot is captured. */
+export declare function prepareWorkspaceSnapshot(params: {
+    sandbox: SandboxSession;
+    workspace: Workspace;
+    signal?: AbortSignal;
+    applyNetworkPolicy(sandbox: SandboxSession): Promise<unknown>;
+    prepareRepositories?(sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal): Promise<void>;
+    removeCredentialRoute: boolean;
+}): Promise<void>;

package/dist/chat/sandbox/ref.d.ts

@@ -2,4 +2,5 @@
 export interface SandboxRef {
     id: string;
     profileHash?: string;
+    workspaceId?: string;
 }

package/dist/chat/sandbox/sandbox.d.ts

@@ -6,6 +6,7 @@ import { type RepositoryInstructions } from "@/chat/repository-instructions";
 import type { SandboxRef } from "@/chat/sandbox/ref";
 import { type SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
+import type { Workspace } from "@/chat/workspaces/types";
 export interface SandboxToolCall {
     toolName: string;
     input: unknown;
@@ -23,10 +24,12 @@ export interface SandboxAccess {
     readonly tools: SandboxTools;
     readonly workspace: SandboxWorkspace;
     sandboxRef(): SandboxRef | undefined;
+    switchWorkspace(workspace: Workspace, signal?: AbortSignal): Promise<void>;
     close(): void;
 }
 export interface SandboxOptions {
     sandboxRef?: SandboxRef;
+    workspace?: Workspace;
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
@@ -35,6 +38,7 @@ export interface SandboxOptions {
     credentialEgress?: CredentialContext;
     egressSignals?: SandboxEgressSignalTransport;
     prepare?: (workspace: SandboxWorkspace) => void | Promise<void>;
+    prepareWorkspace?: (workspace: SandboxWorkspace, recipe: Workspace, signal?: AbortSignal) => Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
 }
 /** Create lazy run-scoped access to a conversation's durable sandbox. */

package/dist/chat/sandbox/session.d.ts

@@ -3,6 +3,7 @@ import { type LogContext, type TracePropagationHeaders } from "@/chat/logging";
 import { type SandboxFileSystem, type SandboxSession } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 import type { SandboxRef } from "@/chat/sandbox/ref";
+import type { Workspace } from "@/chat/workspaces/types";
 interface SandboxToolExecutors {
     sessionId: string;
     bash: (input: {
@@ -25,6 +26,7 @@ interface SandboxToolExecutors {
 }
 interface SandboxRuntime {
     sandboxRef(): SandboxRef | undefined;
+    switchWorkspace(workspace: Workspace, signal?: AbortSignal): Promise<void>;
     acquire(signal?: AbortSignal): Promise<SandboxSession>;
     tools(signal?: AbortSignal): Promise<SandboxToolExecutors>;
     refreshNetworkPolicy(traceHeaders?: TracePropagationHeaders): Promise<void>;
@@ -32,6 +34,7 @@ interface SandboxRuntime {
 }
 interface SandboxRuntimeOptions {
     sandboxRef?: SandboxRef;
+    workspace?: Workspace;
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
@@ -39,6 +42,7 @@ interface SandboxRuntimeOptions {
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;
     onSandboxPrepare?: (sandbox: SandboxSession) => void | Promise<void>;
+    onWorkspacePrepare?: (sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal) => Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
 }
 /** Own sandbox acquisition, preparation, and session-scoped tool caching. */

package/dist/chat/sandbox/snapshot/profile.d.ts

@@ -1,3 +1,4 @@
+import type { Workspace } from "@/chat/workspaces/types";
 import type { PluginRuntimeDependency, PluginRuntimePostinstallCommand } from "@/chat/plugins/types";
 export type Profile = {
     hash: string;
@@ -6,9 +7,9 @@ export type Profile = {
     dependencies: PluginRuntimeDependency[];
     postinstall: PluginRuntimePostinstallCommand[];
 };
-/** Build the dependency profile that selects a reusable sandbox snapshot. */
-export declare function create(runtime: string): Profile | null;
+/** Build the complete profile that selects one reusable sandbox snapshot. */
+export declare function create(runtime: string, workspace?: Workspace): Profile | null;
 /** Return the current dependency profile hash without building its snapshot. */
-export declare function hash(runtime: string): string | undefined;
+export declare function hash(runtime: string, workspace?: Workspace): string | undefined;
 /** Decide whether a cached snapshot has outlived a floating profile. */
 export declare function isStale(profile: Profile, createdAtMs: number): boolean;

package/dist/chat/sandbox/snapshot/resolve.d.ts

@@ -1,3 +1,5 @@
+import { type SandboxSession } from "@/chat/sandbox/workspace";
+import type { Workspace } from "@/chat/workspaces/types";
 export type ResolveOutcome = "no_profile" | "cache_hit" | "cache_hit_after_lock_wait" | "rebuilt" | "forced_rebuild";
 export type RebuildReason = "cache_miss" | "floating_stale" | "force_rebuild" | "snapshot_missing";
 /** Result of resolving the reusable snapshot for one dependency profile. */
@@ -18,6 +20,8 @@ export declare function resolve(params: {
     staleSnapshotId?: string;
     onProgress?: (phase: ProgressPhase) => void | Promise<void>;
     signal?: AbortSignal;
+    workspace?: Workspace;
+    prepareWorkspace?: (sandbox: SandboxSession) => Promise<void>;
 }): Promise<Snapshot>;
 /** Identify provider errors that mean a referenced snapshot no longer exists. */
 export declare function isMissingError(error: unknown): boolean;

package/dist/chat/sandbox/workspace.d.ts

@@ -66,3 +66,7 @@ export interface SandboxSession extends SandboxWorkspace {
 export declare function createSandboxSession(sandbox: VercelSandbox, options?: {
     onUnavailable?: (sessionId: string) => void;
 }): SandboxSession;
+/** Best-effort stop; ignore secondary stop failures during cleanup. */
+export declare function stopSession(session: {
+    stop: () => Promise<unknown>;
+} | null | undefined): Promise<void>;

package/dist/chat/tools/types.d.ts

@@ -11,6 +11,7 @@ import type { ModelProfile } from "@/chat/model-profile";
 import type { GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
 import type { SpawnAgent } from "@/chat/agent/types";
 import type { AttachmentStorage } from "@/chat/attachments/storage";
+import type { Workspace } from "@/chat/workspaces/types";
 interface HandoffControl {
     /** Non-empty catalog of configured targets. */
     profiles: readonly [ModelProfile, ...ModelProfile[]];
@@ -79,6 +80,10 @@ interface BaseToolRuntimeContext {
     egress: PluginEgress;
     mcpToolManager?: McpToolManager;
     workspace: SandboxWorkspace;
+    workspaces?: {
+        activeWorkspaceId(): string | undefined;
+        switch(workspace: Workspace, signal?: AbortSignal): Promise<void>;
+    };
     /** Report whether the model currently executing the turn accepts images. */
     supportsImageInput?: () => boolean;
 }

package/dist/chat/workspaces/checkout-path.d.ts

@@ -0,0 +1,4 @@
+/** Derive the fixed sandbox checkout path for one repository, or undefined when invalid. */
+export declare function tryWorkspaceRepoCheckoutPath(repo: string): string | undefined;
+/** Derive the fixed sandbox checkout path for one repository. */
+export declare function workspaceRepoCheckoutPath(repo: string): string;

package/dist/chat/workspaces/store.d.ts

@@ -0,0 +1,37 @@
+import type { JuniorDatabase } from "@/db/db";
+import type { Workspace } from "./types";
+import { WorkspaceValidationError } from "./validation";
+/** List Workspace recipes by stable name. */
+export declare function listWorkspaces(db: JuniorDatabase): Promise<Workspace[]>;
+/** Find Workspace names that include one provider repository. */
+export declare function listWorkspaceNamesByRepository(db: JuniorDatabase, input: {
+    provider: string;
+    repo: string;
+}): Promise<string[]>;
+/** Resolve one Workspace recipe by name. */
+export declare function getWorkspaceByName(db: JuniorDatabase, name: string): Promise<Workspace | undefined>;
+/** Resolve one Workspace recipe by id. */
+export declare function getWorkspace(db: JuniorDatabase, id: string): Promise<Workspace | undefined>;
+/** Create one install-wide Workspace recipe. */
+export declare function createWorkspace(input: {
+    name: string;
+    setupScript?: string;
+    repos: Array<{
+        provider: string;
+        repo: string;
+        isPrimary?: boolean;
+    }>;
+}): Promise<Workspace>;
+/** Replace one install-wide Workspace recipe. */
+export declare function updateWorkspace(id: string, input: {
+    name: string;
+    setupScript?: string;
+    repos: Array<{
+        provider: string;
+        repo: string;
+        isPrimary?: boolean;
+    }>;
+}): Promise<Workspace | undefined>;
+/** Delete one install-wide Workspace recipe. */
+export declare function deleteWorkspace(id: string): Promise<boolean>;
+export { WorkspaceValidationError };

package/dist/chat/workspaces/tools.d.ts

@@ -0,0 +1,4 @@
+import type { ToolRegistry } from "@/chat/tools/definition";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+/** Build tools for listing and selecting registered workspaces. */
+export declare function createWorkspaceTools(context: ToolRuntimeContext): ToolRegistry;

package/dist/chat/workspaces/types.d.ts

@@ -0,0 +1,13 @@
+/** Provider-owned repository included in one Workspace recipe. */
+export interface WorkspaceRepo {
+    provider: string;
+    repo: string;
+    isPrimary: boolean;
+}
+/** Named recipe used to prepare reusable sandbox contents. */
+export interface Workspace {
+    id: string;
+    name: string;
+    setupScript: string;
+    repos: WorkspaceRepo[];
+}

package/dist/chat/workspaces/validation.d.ts

@@ -0,0 +1,21 @@
+import type { WorkspaceRepo } from "./types";
+/** Normalized recipe fields accepted by Workspace write paths. */
+export interface WorkspaceRecipeInput {
+    name: string;
+    setupScript: string;
+    repos: WorkspaceRepo[];
+}
+/** Validation failure for one Workspace recipe write. */
+export declare class WorkspaceValidationError extends Error {
+    constructor(message: string);
+}
+/** Normalize and validate one Workspace recipe write payload. */
+export declare function normalizeWorkspaceRecipe(input: {
+    name: string;
+    setupScript?: string;
+    repos: Array<{
+        provider: string;
+        repo: string;
+        isPrimary?: boolean;
+    }>;
+}): WorkspaceRecipeInput;

package/dist/{chunk-THXMSSFZ.js → chunk-26JYGL2L.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-BPZQWAZJ.js";
+} from "./chunk-5GLGQHO3.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-OPNJRQDP.js → chunk-2K25MRZK.js}

@@ -1,18 +1,18 @@
 import {
   persistConversationMessages
-} from "./chunk-V7QL4QMW.js";
+} from "./chunk-HHW6ZVIZ.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
   getDb
-} from "./chunk-DDQ43S5Q.js";
+} from "./chunk-LPLVNMVN.js";
 import {
   juniorLocationConfigurations
-} from "./chunk-CZ6EHOU5.js";
+} from "./chunk-ZSNABC2E.js";
 import {
   getStateAdapter
-} from "./chunk-DZC3F2UI.js";
+} from "./chunk-BXBZDV3C.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-Y75ZDQB5.js";
+} from "./chunk-VHSEMJTS.js";
 
 // src/chat/conversations/turn-lifecycle.ts
 var ConversationTurnLifecycleService = class {
@@ -468,6 +468,7 @@ function buildThreadStatePayload(patch) {
   if (patch.sandboxRef !== void 0) {
     payload.app_sandbox_id = patch.sandboxRef?.id ?? "";
     payload.app_sandbox_dependency_profile_hash = patch.sandboxRef?.profileHash ?? "";
+    payload.app_sandbox_workspace_id = patch.sandboxRef?.workspaceId ?? "";
   }
   return payload;
 }
@@ -492,9 +493,11 @@ function getPersistedSandboxState(state) {
   const profileHash = toOptionalString(
     state.app_sandbox_dependency_profile_hash
   );
+  const workspaceId = toOptionalString(state.app_sandbox_workspace_id);
   return {
     id,
-    ...profileHash ? { profileHash } : {}
+    ...profileHash ? { profileHash } : {},
+    ...workspaceId ? { workspaceId } : {}
   };
 }
 async function persistThreadState(thread, patch) {