Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🛤️ feat: Route Linked Worktree Requests into Per-Worktree Lanes (#16477)

Danny Avila867fd5eac5e3
diff --git a/api/server/services/Files/Code/process.js b/api/server/services/Files/Code/process.js
index a5c2bbdfe9..6f0409ba0d 100644
--- a/api/server/services/Files/Code/process.js
+++ b/api/server/services/Files/Code/process.js
@@ -1068,6 +1068,7 @@ async function readSandboxFile({
* @param {string} params.file_path
* @param {string} params.workspace_id
* @param {string} [params.workspace_instance_id]
+ * @param {boolean} [params.linked_worktrees]
* @param {number} params.start_line
* @param {number} params.max_lines
* @param {string} params.codeApiBaseUrl
@@ -1080,6 +1081,7 @@ async function readWorkspaceFile({
file_path,
workspace_id,
workspace_instance_id,
+ linked_worktrees,
start_line,
max_lines,
codeApiBaseUrl,
@@ -1093,6 +1095,7 @@ async function readWorkspaceFile({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
@@ -1122,6 +1125,7 @@ async function readWorkspaceFile({
* @param {string} params.query
* @param {string} params.workspace_id
* @param {string} [params.workspace_instance_id]
+ * @param {boolean} [params.linked_worktrees]
* @param {string} [params.path]
* @param {number} params.max_results
* @param {string} params.codeApiBaseUrl
@@ -1134,6 +1138,7 @@ async function searchWorkspace({
query,
workspace_id,
workspace_instance_id,
+ linked_worktrees,
path,
max_results,
codeApiBaseUrl,
@@ -1147,6 +1152,7 @@ async function searchWorkspace({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
@@ -1175,6 +1181,7 @@ async function searchWorkspace({
* @param {Object} params
* @param {string} params.workspace_id
* @param {string} [params.workspace_instance_id]
+ * @param {boolean} [params.linked_worktrees]
* @param {string} [params.path]
* @param {string} [params.after_path]
* @param {number} params.max_results
@@ -1187,6 +1194,7 @@ async function searchWorkspace({
async function listWorkspaceFiles({
workspace_id,
workspace_instance_id,
+ linked_worktrees,
path,
after_path,
max_results,
@@ -1201,6 +1209,7 @@ async function listWorkspaceFiles({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
@@ -1230,6 +1239,7 @@ async function writeWorkspaceFile({
overwrite,
workspace_id,
workspace_instance_id,
+ linked_worktrees,
codeApiBaseUrl,
executionProfile,
bridgeWorkerId,
@@ -1241,6 +1251,7 @@ async function writeWorkspaceFile({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
@@ -1270,6 +1281,7 @@ async function editWorkspaceFile({
expected_base_sha256,
workspace_id,
workspace_instance_id,
+ linked_worktrees,
codeApiBaseUrl,
executionProfile,
bridgeWorkerId,
@@ -1281,6 +1293,7 @@ async function editWorkspaceFile({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
@@ -1309,6 +1322,7 @@ async function previewWorkspaceEdit({
edits,
workspace_id,
workspace_instance_id,
+ linked_worktrees,
codeApiBaseUrl,
executionProfile,
bridgeWorkerId,
@@ -1320,6 +1334,7 @@ async function previewWorkspaceEdit({
}) {
return executeWorkspaceTool({
baseURL: codeApiBaseUrl,
+ linkedWorktrees: linked_worktrees,
maxQueueWaitMs,
codeApiMaxRetryWaitMs: req?.config?.endpoints?.agents?.codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
diff --git a/api/server/services/Files/Code/process.spec.js b/api/server/services/Files/Code/process.spec.js
index 65175294c0..54564260f1 100644
--- a/api/server/services/Files/Code/process.spec.js
+++ b/api/server/services/Files/Code/process.spec.js
@@ -2199,6 +2199,7 @@ describe('Code Process', () => {
await expect(
listWorkspaceFiles({
workspace_id: 'primary',
+ linked_worktrees: true,
path: 'src',
after_path: 'src/app.ts',
max_results: 20,
@@ -2226,6 +2227,7 @@ describe('Code Process', () => {
expect(getCodeApiAuthHeaders).toHaveBeenNthCalledWith(2, mockReq, 'worker-user-1');
expect(mockExecuteWorkspaceTool).toHaveBeenCalledWith({
baseURL: 'https://attached-code.example.com/v1',
+ linkedWorktrees: true,
authHeaders: expect.any(Function),
maxQueueWaitMs: 0,
codeApiMaxRetryWaitMs: undefined,
diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.js
index 5ce4e4d603..51b97957ce 100644
--- a/api/server/services/ToolService.js
+++ b/api/server/services/ToolService.js
@@ -2308,6 +2308,7 @@ async function loadToolsForExecution({
baseUrl: codeExecutionContext.baseUrl,
workspaceId: codeExecutionContext.codeWorkspace.workspaceId,
workspaceInstanceId: codeExecutionContext.codeWorkspace.workspaceInstanceId,
+ linkedWorktrees: codeExecutionContext.codeWorkspace.linkedWorktrees,
environment: codeExecutionContext.codeWorkspace.environment,
gitIdentity: agent?.git_identity,
maxTimeoutMs: resolveAttachedWorkspaceCommandTimeoutMax(
diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.ts
index 43bac3fd1d..c20c0af9e5 100644
--- a/packages/api/src/agents/__tests__/initialize.test.ts
+++ b/packages/api/src/agents/__tests__/initialize.test.ts
@@ -3020,6 +3020,7 @@ describe('initializeAgent — execute_code capability expansion', () => {
workspaceId: 'project-a',
operations: ['read_file', 'list_files', 'execute_command'],
environment: { fingerprint: 'a'.repeat(64), repo: 'owner/project', actions: ['check'] },
+ linkedWorktrees: true,
},
};
if (protectedEdit) codeExecutionContext.codeWorkspace!.operations.push('edit_file');
@@ -3063,6 +3064,10 @@ describe('initializeAgent — execute_code capability expansion', () => {
(bashTool?.parameters as { properties?: { timeoutMs?: { maximum?: number } } })?.properties
?.timeoutMs?.maximum,
).toBe(120_000);
+ expect(
+ (bashTool?.parameters as { properties?: { cwd?: { description?: string } } })?.properties
+ ?.cwd?.description,
+ ).toContain('.worktrees/<name>');
},
);
diff --git a/packages/api/src/agents/execution.ts b/packages/api/src/agents/execution.ts
index bf1768815b..431beecfc8 100644
--- a/packages/api/src/agents/execution.ts
+++ b/packages/api/src/agents/execution.ts
@@ -44,6 +44,8 @@ export interface CodeExecutionContext {
codeWorkspace?: CodeWorkspaceSelection & {
operations: CodeWorkspaceOperation[];
workspaceInstanceId?: string;
+ /** The worker schedules each `.worktrees/<name>` of this root as its own lane. */
+ linkedWorktrees?: boolean;
/** Live Code API execution ceiling. Omitted by older deployments. */
maxCommandTimeoutMs?: number;
instructions?: CodeWorkspaceDescriptor['instructions'];
diff --git a/packages/api/src/agents/handlers.ts b/packages/api/src/agents/handlers.ts
index a239557eb9..0afc2299db 100644
--- a/packages/api/src/agents/handlers.ts
+++ b/packages/api/src/agents/handlers.ts
@@ -563,6 +563,7 @@ export interface ToolExecuteOptions {
file_path: string;
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
start_line: number;
max_lines: number;
codeApiBaseUrl: string;
@@ -579,6 +580,7 @@ export interface ToolExecuteOptions {
query: string;
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
path?: string;
max_results: number;
codeApiBaseUrl: string;
@@ -594,6 +596,7 @@ export interface ToolExecuteOptions {
listWorkspaceFiles?: (params: {
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
path?: string;
after_path?: string;
max_results: number;
@@ -613,6 +616,7 @@ export interface ToolExecuteOptions {
overwrite: boolean;
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
codeApiBaseUrl: string;
executionProfile: CodeExecutionContext['executionProfile'];
bridgeWorkerId?: string;
@@ -628,6 +632,7 @@ export interface ToolExecuteOptions {
edits: Array<{ oldText: string; newText: string }>;
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
codeApiBaseUrl: string;
executionProfile: CodeExecutionContext['executionProfile'];
bridgeWorkerId?: string;
@@ -644,6 +649,7 @@ export interface ToolExecuteOptions {
expected_base_sha256?: string;
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
codeApiBaseUrl: string;
executionProfile: CodeExecutionContext['executionProfile'];
bridgeWorkerId?: string;
@@ -2474,6 +2480,7 @@ async function handleWorkspaceFileRead(
...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
: {}),
+ ...(codeExecutionContext.codeWorkspace?.linkedWorktrees ? { linked_worktrees: true } : {}),
start_line: startLine,
max_lines: maxLines,
codeApiBaseUrl: codeExecutionContext.baseUrl,
@@ -2580,6 +2587,7 @@ async function handleWorkspaceSearchCall(
...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
: {}),
+ ...(codeExecutionContext.codeWorkspace?.linkedWorktrees ? { linked_worktrees: true } : {}),
...(typeof args.path === 'string' && args.path.length > 0 ? { path: args.path } : {}),
max_results: Number(maxResults),
codeApiBaseUrl: codeExecutionContext.baseUrl,
@@ -2668,6 +2676,7 @@ async function handleWorkspaceListCall(
...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
: {}),
+ ...(codeExecutionContext.codeWorkspace?.linkedWorktrees ? { linked_worktrees: true } : {}),
...(typeof args.path === 'string' && args.path.length > 0 ? { path: args.path } : {}),
...(typeof args.after_path === 'string' && args.after_path.length > 0
? { after_path: args.after_path }
@@ -3939,6 +3948,7 @@ function attachedWorkspaceMutationParams(
): {
workspace_id: string;
workspace_instance_id?: string;
+ linked_worktrees?: boolean;
codeApiBaseUrl: string;
executionProfile: CodeExecutionContext['executionProfile'];
bridgeWorkerId?: string;
@@ -3954,6 +3964,7 @@ function attachedWorkspaceMutationParams(
...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
: {}),
+ ...(codeExecutionContext.codeWorkspace?.linkedWorktrees ? { linked_worktrees: true } : {}),
codeApiBaseUrl: codeExecutionContext.baseUrl,
...limits,
...(limits.maxRequestTimeoutMs == null
diff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.ts
index 9a09ac949c..6f0af0c7c7 100644
--- a/packages/api/src/agents/initialize.ts
+++ b/packages/api/src/agents/initialize.ts
@@ -2080,6 +2080,7 @@ export async function initializeAgent(
workspaceOperations: attachedWorkspaceOperations,
workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,
workspaceEnvironment: trustedCodeExecutionContext.codeWorkspace?.environment,
+ workspaceLinkedWorktrees: trustedCodeExecutionContext.codeWorkspace?.linkedWorktrees,
});
toolDefinitions = codeExecResult.toolDefinitions;
recordCapabilityToolNames(AgentCapabilities.execute_code, codeExecResult.toolNames);
@@ -2325,6 +2326,7 @@ export async function initializeAgent(
userId: user?.id,
workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,
workspaceEnvironment: trustedCodeExecutionContext.codeWorkspace?.environment,
+ workspaceLinkedWorktrees: trustedCodeExecutionContext.codeWorkspace?.linkedWorktrees,
skillStates: params.skillStates,
defaultActiveOnShare: params.defaultActiveOnShare,
maxCatalogSkills: getMaxCatalogSkills(runtime),
diff --git a/packages/api/src/agents/skills.ts b/packages/api/src/agents/skills.ts
index d080628cc3..f74fee50ea 100644
--- a/packages/api/src/agents/skills.ts
+++ b/packages/api/src/agents/skills.ts
@@ -441,6 +441,8 @@ export interface InjectSkillCatalogParams {
/** Deployment ceiling advertised on attached Bash tool definitions. */
workspaceCommandTimeoutMaxMs?: number;
workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
+ /** The worker runs `.worktrees/<name>` in its own lane; advertise `cwd` routing to the model. */
+ workspaceLinkedWorktrees?: boolean;
/** Current user ID — used to determine skill ownership for active-state resolution. */
userId?: string;
/** Per-user skill overrides: `{ [skillId]: boolean }`. Missing entries use the default. */
@@ -677,6 +679,7 @@ export async function injectSkillCatalog(
workspaceOperations,
workspaceCommandTimeoutMaxMs,
workspaceEnvironment,
+ workspaceLinkedWorktrees,
userId,
skillStates,
defaultActiveOnShare = false,
@@ -863,6 +866,7 @@ export async function injectSkillCatalog(
workspaceOperations,
workspaceCommandTimeoutMaxMs,
workspaceEnvironment,
+ workspaceLinkedWorktrees,
});
workingDefs = codeExecResult.toolDefinitions;
diff --git a/packages/api/src/agents/tools.spec.ts b/packages/api/src/agents/tools.spec.ts
index 0455c7cb0f..1852ea5a1a 100644
--- a/packages/api/src/agents/tools.spec.ts
+++ b/packages/api/src/agents/tools.spec.ts
@@ -704,6 +704,24 @@ describe('registerCodeExecutionTools', () => {
});
expect(bash?.description).toContain('owner/app');
});
+
+ it('tells the model to route worktree commands through cwd only when lanes are available', () => {
+ const cwdDescription = (workspaceLinkedWorktrees: boolean): string | undefined => {
+ const bash = registerCodeExecutionTools({
+ toolRegistry: undefined,
+ toolDefinitions: [],
+ includeBash: true,
+ workspaceTools: true,
+ workspaceOperations: new Set(['execute_command']),
+ workspaceLinkedWorktrees,
+ }).toolDefinitions.find((def) => def.name === 'bash_tool');
+ return (bash?.parameters as { properties?: { cwd?: { description?: string } } })?.properties
+ ?.cwd?.description;
+ };
+
+ expect(cwdDescription(true)).toContain('.worktrees/<name>');
+ expect(cwdDescription(false)).not.toContain('.worktrees');
+ });
const makeRegistry = (): LCToolRegistry => new Map() as unknown as LCToolRegistry;
describe('fresh run (no pre-existing defs or registry entries)', () => {
diff --git a/packages/api/src/agents/tools.ts b/packages/api/src/agents/tools.ts
index 8dd9742dbd..3c8d85c24e 100644
--- a/packages/api/src/agents/tools.ts
+++ b/packages/api/src/agents/tools.ts
@@ -439,6 +439,8 @@ export interface RegisterCodeExecutionToolsParams {
/** Deployment ceiling advertised on attached Bash tool definitions. */
workspaceCommandTimeoutMaxMs?: number;
workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
+ /** The worker runs `.worktrees/<name>` in its own lane; advertise `cwd` routing to the model. */
+ workspaceLinkedWorktrees?: boolean;
/**
* When `true`, the registered `bash_tool` description includes the
* LLM-facing `{{tool<idx>turn<turn>}}` reference syntax guide so the
@@ -1040,6 +1042,7 @@ function createBashToolDef(
workspaceTools = false,
workspaceCommandTimeoutMaxMs?: number,
workspaceEnvironment?: CodeWorkspaceDescriptor['environment'],
+ workspaceLinkedWorktrees = false,
): LCTool {
/* Passed as a variable (not an inline literal) so the extra
* `statefulSessions` key stays assignable against pinned SDK versions
@@ -1052,7 +1055,11 @@ function createBashToolDef(
? buildAttachedWorkspaceBashDescription(enableToolOutputReferences, workspaceEnvironment)
: buildBashExecutionToolDescription(descriptionOpts),
parameters: (workspaceTools
- ? buildAttachedWorkspaceBashSchema(workspaceCommandTimeoutMaxMs, workspaceEnvironment)
+ ? buildAttachedWorkspaceBashSchema(
+ workspaceCommandTimeoutMaxMs,
+ workspaceEnvironment,
+ workspaceLinkedWorktrees,
+ )
: BashExecutionToolDefinition.schema) as unknown as LCTool['parameters'],
}) as LCTool;
}
@@ -1066,6 +1073,8 @@ function buildBashToolDef(opts: {
workspaceTools?: boolean;
workspaceCommandTimeoutMaxMs?: number;
workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
+ /** The worker runs `.worktrees/<name>` in its own lane; advertise `cwd` routing to the model. */
+ workspaceLinkedWorktrees?: boolean;
}): LCTool {
/* Stateful defs are built on demand: the stateless pair covers the
* default path, and per-run construction is negligible next to init. */
@@ -1076,6 +1085,7 @@ function buildBashToolDef(opts: {
opts.workspaceTools === true,
opts.workspaceCommandTimeoutMaxMs,
opts.workspaceEnvironment,
+ opts.workspaceLinkedWorktrees === true,
);
}
return opts.enableToolOutputReferences
@@ -1109,6 +1119,7 @@ export function registerCodeExecutionTools(
workspaceOperations,
workspaceCommandTimeoutMaxMs,
workspaceEnvironment,
+ workspaceLinkedWorktrees,
enableToolOutputReferences = false,
statefulSessions = false,
} = params;
@@ -1129,6 +1140,7 @@ export function registerCodeExecutionTools(
workspaceTools,
workspaceCommandTimeoutMaxMs,
workspaceEnvironment,
+ workspaceLinkedWorktrees,
}),
);
}
diff --git a/packages/api/src/code/bridge.spec.ts b/packages/api/src/code/bridge.spec.ts
index bd9dae4bf0..9fe3e8990f 100644
--- a/packages/api/src/code/bridge.spec.ts
+++ b/packages/api/src/code/bridge.spec.ts
@@ -97,6 +97,7 @@ describe('getCodeBridgeWorkerStatus', () => {
id: 'project-a',
name: 'Project A',
workspaceInstances: ['git_worktree'],
+ workspaceScopes: ['git_linked_worktree'],
},
{ id: 'docs', operations: ['read_file'] },
],
@@ -128,6 +129,7 @@ describe('getCodeBridgeWorkerStatus', () => {
id: 'project-a',
name: 'Project A',
workspaceInstances: ['git_worktree'],
+ workspaceScopes: ['git_linked_worktree'],
},
{ id: 'docs', operations: ['read_file'] },
],
@@ -249,6 +251,53 @@ describe('getCodeBridgeWorkerStatus', () => {
},
},
},
+ {
+ online: true,
+ ready: true,
+ leaseExpiresInMs: 5_000,
+ capabilities: {
+ statefulWorkspace: true,
+ sandboxProfile: 'native-srt',
+ runtimes: ['bash'],
+ workspaceTools: {
+ protocolVersion: 1,
+ operations: ['read_file'],
+ workspaces: [{ id: 'project-a', workspaceScopes: ['subdirectory'] }],
+ },
+ },
+ },
+ {
+ online: true,
+ ready: true,
+ leaseExpiresInMs: 5_000,
+ capabilities: {
+ statefulWorkspace: true,
+ sandboxProfile: 'native-srt',
+ runtimes: ['bash'],
+ workspaceTools: {
+ protocolVersion: 1,
+ operations: ['read_file'],
+ workspaces: [{ id: 'project-a', workspaceScopes: 'git_linked_worktree' }],
+ },
+ },
+ },
+ {
+ online: true,
+ ready: true,
+ leaseExpiresInMs: 5_000,
+ capabilities: {
+ statefulWorkspace: true,
+ sandboxProfile: 'native-srt',
+ runtimes: ['bash'],
+ workspaceTools: {
+ protocolVersion: 1,
+ operations: ['read_file'],
+ workspaces: [
+ { id: 'project-a', workspaceScopes: ['git_linked_worktree', 'git_linked_worktree'] },
+ ],
+ },
+ },
+ },
])('rejects an invalid upstream status response: %p', async (invalid) => {
const fetchImpl = jest
.fn()
diff --git a/packages/api/src/code/bridge.ts b/packages/api/src/code/bridge.ts
index 0820901eca..17f31aa1f5 100644
--- a/packages/api/src/code/bridge.ts
+++ b/packages/api/src/code/bridge.ts
@@ -282,6 +282,7 @@ function validWorkspaceCapabilities(value: unknown): value is {
key !== 'name' &&
key !== 'operations' &&
key !== 'workspaceInstances' &&
+ key !== 'workspaceScopes' &&
key !== 'environment' &&
key !== 'instructions',
) ||
@@ -297,6 +298,10 @@ function validWorkspaceCapabilities(value: unknown): value is {
(!Array.isArray(workspace.workspaceInstances) ||
workspace.workspaceInstances.length !== 1 ||
workspace.workspaceInstances[0] !== 'git_worktree')) ||
+ (workspace.workspaceScopes !== undefined &&
+ (!Array.isArray(workspace.workspaceScopes) ||
+ workspace.workspaceScopes.length !== 1 ||
+ workspace.workspaceScopes[0] !== 'git_linked_worktree')) ||
(workspace.name !== undefined &&
(typeof workspace.name !== 'string' ||
workspace.name.trim().length === 0 ||
diff --git a/packages/api/src/code/capabilities.spec.ts b/packages/api/src/code/capabilities.spec.ts
index 746d68b8d1..4365e0d24e 100644
--- a/packages/api/src/code/capabilities.spec.ts
+++ b/packages/api/src/code/capabilities.spec.ts
@@ -461,6 +461,49 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
expect(legacy.codeWorkspace).not.toHaveProperty('workspaceInstanceId');
});
+ it('routes linked worktrees into lanes only when configured and no conversation instance owns the checkout', async () => {
+ const workspaceInstanceId = 'c'.repeat(64);
+ jest.spyOn(globalThis, 'fetch').mockImplementation(async () =>
+ workspaceStatus([
+ {
+ id: 'lanes',
+ workspaceInstances: ['git_worktree'],
+ workspaceScopes: ['git_linked_worktree'],
+ },
+ { id: 'legacy' },
+ ]),
+ );
+ const resolve = (workspaceId: string, instanceId?: string, linkedWorktrees = true) =>
+ resolveCodeExecutionWorkspaceContext({
+ context: {
+ ...context,
+ codeEnvironmentConfigSchema: { workspaces: { linkedWorktrees } },
+ ...(instanceId ? { conversationWorkspaceInstanceId: instanceId } : {}),
+ },
+ requestedSelections: [{ environmentId: 'personal', workspaceId }],
+ environments,
+ getAppConfig,
+ });
+
+ const lanes = await resolve('lanes');
+ const disabled = await resolve('lanes', undefined, false);
+ const unconfigured = await resolveCodeExecutionWorkspaceContext({
+ context,
+ requestedSelections: [{ environmentId: 'personal', workspaceId: 'lanes' }],
+ environments,
+ getAppConfig,
+ });
+ const instance = await resolve('lanes', workspaceInstanceId);
+ const legacy = await resolve('legacy');
+
+ expect(lanes.codeWorkspace?.linkedWorktrees).toBe(true);
+ expect(disabled.codeWorkspace).not.toHaveProperty('linkedWorktrees');
+ expect(unconfigured.codeWorkspace).not.toHaveProperty('linkedWorktrees');
+ expect(instance.codeWorkspace?.workspaceInstanceId).toBe(workspaceInstanceId);
+ expect(instance.codeWorkspace).not.toHaveProperty('linkedWorktrees');
+ expect(legacy.codeWorkspace).not.toHaveProperty('linkedWorktrees');
+ });
+
it('admits native workspace tools without enabling programmatic runtime execution', async () => {
jest
.spyOn(globalThis, 'fetch')
diff --git a/packages/api/src/code/capabilities.ts b/packages/api/src/code/capabilities.ts
index 85b8f7ed72..32f1d37ad2 100644
--- a/packages/api/src/code/capabilities.ts
+++ b/packages/api/src/code/capabilities.ts
@@ -182,6 +182,14 @@ export async function resolveCodeExecutionWorkspaceContext({
workspace.workspaceInstances?.includes('git_worktree')
? { workspaceInstanceId: context.conversationWorkspaceInstanceId }
: {}),
+ ...(context.codeEnvironmentConfigSchema?.workspaces?.linkedWorktrees === true &&
+ workspace.workspaceScopes?.includes('git_linked_worktree') &&
+ !(
+ context.conversationWorkspaceInstanceId &&
+ workspace.workspaceInstances?.includes('git_worktree')
+ )
+ ? { linkedWorktrees: true }
+ : {}),
...(status.maxCommandTimeoutMs == null
? {}
: { maxCommandTimeoutMs: status.maxCommandTimeoutMs }),
diff --git a/packages/api/src/code/command.spec.ts b/packages/api/src/code/command.spec.ts
index b027583ef6..7a625819a6 100644
--- a/packages/api/src/code/command.spec.ts
+++ b/packages/api/src/code/command.spec.ts
@@ -316,6 +316,23 @@ describe('createAttachedWorkspaceBashTool', () => {
});
});
+ test('runs a command whose working directory is a linked worktree in that lane', async () => {
+ const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
+ const bashTool = createAttachedWorkspaceBashTool({
+ baseUrl: 'https://code.example.com/v1',
+ authHeaders: () => ({}),
+ workspaceId: 'project-a',
+ linkedWorktrees: true,
+ fetchImpl,
+ });
+
+ expect(JSON.stringify(bashTool.schema)).toContain('.worktrees/<name>');
+ await bashTool.func({ command: 'npm test', cwd: '.worktrees/fix-a/api' }, undefined, {});
+
+ const request = JSON.parse(String((fetchImpl as jest.Mock).mock.calls[0][1]?.body));
+ expect(request).toMatchObject({ command: 'npm test', cwd: 'api', worktree: 'fix-a' });
+ });
+
test('forwards a bounded per-call execution timeout', async () => {
const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
const bashTool = createAttachedWorkspaceBashTool({
diff --git a/packages/api/src/code/command.ts b/packages/api/src/code/command.ts
index 7981204f2a..d9754ee670 100644
--- a/packages/api/src/code/command.ts
+++ b/packages/api/src/code/command.ts
@@ -173,9 +173,15 @@ export function resolveAttachedWorkspaceRequestTimeoutMs(
return configured;
}
+const linkedWorktreeWorkingDirectorySchema: BoundedWorkingDirectorySchema = {
+ ...attachedWorkingDirectorySchema,
+ description: `${attachedWorkingDirectorySchema.description} To work in a linked worktree, pass its directory here (for example ".worktrees/fix-auth") instead of running cd inside the command: commands in different .worktrees/<name> directories then run in parallel, while a cd from the workspace root waits for all of them.`,
+};
+
export function buildAttachedWorkspaceBashSchema(
maxTimeoutMs: number = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,
environment?: CodeWorkspaceDescriptor['environment'],
+ linkedWorktrees = false,
): NonNullable<LCTool['parameters']> {
const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);
return {
@@ -183,7 +189,10 @@ export function buildAttachedWorkspaceBashSchema(
properties: {
...bashSchema.properties,
command: attachedCommandSchema,
- cwd: attachedWorkingDirectorySchema,
+ cwd:
+ linkedWorktrees === true
+ ? linkedWorktreeWorkingDirectorySchema
+ : attachedWorkingDirectorySchema,
timeoutMs: buildAttachedTimeoutSchema(effectiveMaxTimeoutMs),
...(environment?.actions.length
? {
@@ -322,12 +331,15 @@ export function createAttachedWorkspaceBashTool({
codeApiMaxRetryWaitMs,
maxRequestTimeoutMs,
minCommandAdmissionMs,
+ linkedWorktrees = false,
fetchImpl,
}: {
baseUrl: string;
authHeaders: () => Promise<Record<string, string>> | Record<string, string>;
workspaceId: string;
workspaceInstanceId?: string;
+ /** The worker runs each `.worktrees/<name>` in its own lane; a matching `cwd` is routed there. */
+ linkedWorktrees?: boolean;
environment?: CodeWorkspaceDescriptor['environment'];
gitIdentity?: AgentGitIdentity | null;
/** Effective admin/upstream ceiling already intersected with the protocol hard cap. */
@@ -347,7 +359,7 @@ export function createAttachedWorkspaceBashTool({
minCommandAdmissionMs,
);
const schema = structuredClone(
- buildAttachedWorkspaceBashSchema(effectiveMaxTimeoutMs, environment),
+ buildAttachedWorkspaceBashSchema(effectiveMaxTimeoutMs, environment, linkedWorktrees),
);
const actions = environment?.actions ?? [];
return tool(
@@ -405,6 +417,7 @@ export function createAttachedWorkspaceBashTool({
baseURL: baseUrl,
/** Passed as a supplier: a queued call outlives its minted token. */
authHeaders,
+ linkedWorktrees,
request: {
protocolVersion: 1,
operation: 'execute_command',
diff --git a/packages/api/src/code/workspace.lanes.spec.ts b/packages/api/src/code/workspace.lanes.spec.ts
new file mode 100644
index 0000000000..46ae78b429
--- /dev/null
+++ b/packages/api/src/code/workspace.lanes.spec.ts
@@ -0,0 +1,183 @@
+import type { WorkspaceToolRequest, WorkspaceToolResult } from './workspace';
+import { fromLinkedWorktreeResult, toLinkedWorktreeRequest } from './workspace';
+
+const base = { protocolVersion: 1, workspaceId: 'librechat' } as const;
+
+describe('toLinkedWorktreeRequest', () => {
+ it.each([
+ ['read_file', { operation: 'read_file', path: '.worktrees/fix-a/src/index.ts' }],
+ ['write_file', { operation: 'write_file', path: '.worktrees/fix-a/src/index.ts', content: '' }],
+ ['edit_file', { operation: 'edit_file', path: '.worktrees/fix-a/src/index.ts', edits: [] }],
+ [
+ 'preview_edit',
+ { operation: 'preview_edit', path: '.worktrees/fix-a/src/index.ts', edits: [] },
+ ],
+ ])('routes a %s path into its worktree lane', (_operation, fields) => {
+ const request = { ...base, ...fields } as WorkspaceToolRequest;
+ expect(toLinkedWorktreeRequest(request)).toEqual({
+ worktree: 'fix-a',
+ request: { ...request, path: 'src/index.ts', worktree: 'fix-a' },
+ });
+ });
+
+ it('scopes searches and listings to the worktree, omitting the path at its root', () => {
+ expect(
+ toLinkedWorktreeRequest({
+ ...base,
+ operation: 'search_text',
+ query: 'TODO',
+ path: '.worktrees/fix-a',
+ }),
+ ).toEqual({
+ worktree: 'fix-a',
+ request: { ...base, operation: 'search_text', query: 'TODO', worktree: 'fix-a' },
+ });
+ expect(
+ toLinkedWorktreeRequest({
+ ...base,
+ operation: 'list_files',
+ path: '.worktrees/fix-a/src',
+ afterPath: '.worktrees/fix-a/src/a.ts',
+ }),
+ ).toEqual({
+ worktree: 'fix-a',
+ request: {
+ ...base,
+ operation: 'list_files',
+ path: 'src',
+ afterPath: 'src/a.ts',
+ worktree: 'fix-a',
+ },
+ });
+ });
+
+ it('runs a command whose cwd is inside a worktree in that lane', () => {
+ expect(
+ toLinkedWorktreeRequest({
+ ...base,
+ operation: 'execute_command',
+ command: 'npm test',
+ cwd: '.worktrees/fix-a',
+ }),
+ ).toEqual({
+ worktree: 'fix-a',
+ request: { ...base, operation: 'execute_command', command: 'npm test', worktree: 'fix-a' },
+ });
+ expect(
+ toLinkedWorktreeRequest({
+ ...base,
+ operation: 'execute_command',
+ command: 'npx jest',
+ cwd: '.worktrees/fix-a/packages/api',
+ })?.request,
+ ).toMatchObject({ cwd: 'packages/api', worktree: 'fix-a' });
+ });
+
+ it.each<[string, WorkspaceToolRequest]>([
+ ['a root path', { ...base, operation: 'read_file', path: 'src/index.ts' }],
+ ['the worktree directory itself', { ...base, operation: 'read_file', path: '.worktrees/a' }],
+ ['the worktrees container', { ...base, operation: 'list_files', path: '.worktrees' }],
+ ['an invalid name', { ...base, operation: 'read_file', path: '.worktrees/-bad/x.ts' }],
+ ['a lock name', { ...base, operation: 'read_file', path: '.worktrees/a.lock/x.ts' }],
+ [
+ 'an instruction read',
+ {
+ ...base,
+ operation: 'read_file',
+ path: '.worktrees/a/AGENTS.md',
+ instructionSha256: 'a'.repeat(64),
+ },
+ ],
+ [
+ 'a conversation instance',
+ {
+ ...base,
+ operation: 'read_file',
+ path: '.worktrees/a/x.ts',
+ workspaceInstanceId: 'b'.repeat(64),
+ },
+ ],
+ [
+ 'a listing cursor in another worktree',
+ {
+ ...base,
+ operation: 'list_files',
+ path: '.worktrees/a',
+ afterPath: '.worktrees/b/x.ts',
+ },
+ ],
+ [
+ 'a listing cursor at the worktree root',
+ { ...base, operation: 'list_files', path: '.worktrees/a', afterPath: '.worktrees/a' },
+ ],
+ [
+ 'a command without cwd',
+ { ...base, operation: 'execute_command', command: 'cd .worktrees/a' },
+ ],
+ [
+ 'an environment action',
+ {
+ ...base,
+ operation: 'execute_command',
+ command: 'setup',
+ cwd: '.worktrees/a',
+ environmentAction: { name: 'setup', fingerprint: 'c'.repeat(64) },
+ },
+ ],
+ ])('leaves %s root-scoped', (_case, request) => {
+ expect(toLinkedWorktreeRequest(request)).toBeUndefined();
+ });
+});
+
+describe('fromLinkedWorktreeResult', () => {
+ it('restores the worktree prefix on every reported path', () => {
+ const listing: WorkspaceToolResult = {
+ ...base,
+ operation: 'list_files',
+ paths: ['src/a.ts', 'src/b.ts'],
+ truncated: true,
+ nextAfterPath: 'src/b.ts',
+ };
+ expect(fromLinkedWorktreeResult(listing, 'fix-a')).toEqual({
+ ...listing,
+ paths: ['.worktrees/fix-a/src/a.ts', '.worktrees/fix-a/src/b.ts'],
+ nextAfterPath: '.worktrees/fix-a/src/b.ts',
+ });
+
+ const search: WorkspaceToolResult = {
+ ...base,
+ operation: 'search_text',
+ matches: [{ path: 'src/a.ts', line: 3, column: 1, text: 'TODO' }],
+ truncated: false,
+ };
+ expect(fromLinkedWorktreeResult(search, 'fix-a')).toEqual({
+ ...search,
+ matches: [{ path: '.worktrees/fix-a/src/a.ts', line: 3, column: 1, text: 'TODO' }],
+ });
+
+ const written: WorkspaceToolResult = {
+ ...base,
+ operation: 'write_file',
+ path: 'src/a.ts',
+ created: true,
+ bytesWritten: 1,
+ };
+ expect(fromLinkedWorktreeResult(written, 'fix-a')).toEqual({
+ ...written,
+ path: '.worktrees/fix-a/src/a.ts',
+ });
+ });
+
+ it('returns command results unchanged', () => {
+ const result: WorkspaceToolResult = {
+ ...base,
+ operation: 'execute_command',
+ stdout: '',
+ stderr: '',
+ exitCode: 0,
+ timedOut: false,
+ truncated: false,
+ };
+ expect(fromLinkedWorktreeResult(result, 'fix-a')).toBe(result);
+ });
+});
diff --git a/packages/api/src/code/workspace.spec.ts b/packages/api/src/code/workspace.spec.ts
index fb48d98933..35fe63292c 100644
--- a/packages/api/src/code/workspace.spec.ts
+++ b/packages/api/src/code/workspace.spec.ts
@@ -2176,3 +2176,72 @@ describe('executeWorkspaceTool', () => {
expect(fetchImpl).toHaveBeenCalledTimes(2);
});
});
+
+describe('linked worktree lanes', () => {
+ const listing = (paths: string[]) =>
+ new Response(
+ JSON.stringify({
+ protocolVersion: 1,
+ operation: 'list_files',
+ workspaceId: 'librechat',
+ paths,
+ truncated: false,
+ }),
+ { status: 200, headers: { 'Content-Type': 'application/json' } },
+ );
+ const request: WorkspaceToolRequest = {
+ protocolVersion: 1,
+ operation: 'list_files',
+ workspaceId: 'librechat',
+ path: '.worktrees/fix-a/src',
+ };
+
+ test('sends a worktree request and reports paths relative to the checkout', async () => {
+ const fetchImpl = jest.fn().mockResolvedValue(listing(['src/a.ts']));
+
+ await expect(
+ executeWorkspaceTool({
+ baseURL: 'https://code.example/v1',
+ authHeaders: {},
+ fetchImpl,
+ request,
+ linkedWorktrees: true,
+ }),
+ ).resolves.toMatchObject({ paths: ['.worktrees/fix-a/src/a.ts'] });
+ expect(JSON.parse(fetchImpl.mock.calls[0][1].body)).toEqual({
+ protocolVersion: 1,
+ operation: 'list_files',
+ workspaceId: 'librechat',
+ path: 'src',
+ worktree: 'fix-a',
+ });
+ });
+
+ test('keeps the checkout-scoped request when the worker has no lanes', async () => {
+ const fetchImpl = jest.fn().mockResolvedValue(listing(['.worktrees/fix-a/src/a.ts']));
+
+ await expect(
+ executeWorkspaceTool({
+ baseURL: 'https://code.example/v1',
+ authHeaders: {},
+ fetchImpl,
+ request,
+ }),
+ ).resolves.toMatchObject({ paths: ['.worktrees/fix-a/src/a.ts'] });
+ expect(JSON.parse(fetchImpl.mock.calls[0][1].body)).toEqual(request);
+ });
+
+ test('rejects lane results that escape the requested worktree scope', async () => {
+ const fetchImpl = jest.fn().mockResolvedValue(listing(['lib/a.ts']));
+
+ await expect(
+ executeWorkspaceTool({
+ baseURL: 'https://code.example/v1',
+ authHeaders: {},
+ fetchImpl,
+ request,
+ linkedWorktrees: true,
+ }),
+ ).rejects.toMatchObject({ reason: 'invalid' });
+ });
+});
diff --git a/packages/api/src/code/workspace.ts b/packages/api/src/code/workspace.ts
index c953dffbfa..80ab78a4dc 100644
--- a/packages/api/src/code/workspace.ts
+++ b/packages/api/src/code/workspace.ts
@@ -858,6 +858,142 @@ function getWorkspaceAuthHeaders(
});
}
+/** Linked worktrees live at `.worktrees/<name>` beneath a registered checkout. */
+const LINKED_WORKTREE_DIRECTORY = '.worktrees/';
+/** Mirrors Code API's single-segment worktree name rule. */
+const LINKED_WORKTREE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+export type LinkedWorktreeRequest = WorkspaceToolRequest & { worktree: string };
+
+interface LinkedWorktreePath {
+ worktree: string;
+ /** Path relative to the worktree root; empty for the worktree root itself. */
+ rest: string;
+}
+
+function splitLinkedWorktreePath(path: string | undefined): LinkedWorktreePath | undefined {
+ if (path == null || !path.startsWith(LINKED_WORKTREE_DIRECTORY)) return undefined;
+ const remainder = path.slice(LINKED_WORKTREE_DIRECTORY.length);
+ const slash = remainder.indexOf('/');
+ const worktree = slash === -1 ? remainder : remainder.slice(0, slash);
+ if (!LINKED_WORKTREE_NAME_PATTERN.test(worktree) || worktree.endsWith('.lock')) {
+ return undefined;
+ }
+ return { worktree, rest: slash === -1 ? '' : remainder.slice(slash + 1) };
+}
+
+function prefixed(worktree: string, path: string): string {
+ return `${LINKED_WORKTREE_DIRECTORY}${worktree}/${path}`;
+}
+
+/**
+ * Route a request that targets `.worktrees/<name>/…` into that worktree's own
+ * scheduling lane, so work in sibling worktrees runs concurrently. Only
+ * structural targets are routed: a file path, a search or listing scope, or a
+ * command `cwd`. Anything else, including a command that `cd`s into a worktree
+ * from the root, stays root-scoped because its reach cannot be bounded.
+ */
+export function toLinkedWorktreeRequest(
+ request: WorkspaceToolRequest,
+): { request: LinkedWorktreeRequest; worktree: string } | undefined {
+ if (request.workspaceInstanceId != null) return undefined;
+ switch (request.operation) {
+ case 'read_file':
+ case 'write_file':
+ case 'edit_file':
+ case 'preview_edit': {
+ if (request.operation === 'read_file' && request.instructionSha256 != null) return undefined;
+ const target = splitLinkedWorktreePath(request.path);
+ if (target == null || target.rest === '') return undefined;
+ return {
+ worktree: target.worktree,
+ request: { ...request, path: target.rest, worktree: target.worktree },
+ };
+ }
+ case 'search_text': {
+ const target = splitLinkedWorktreePath(request.path);
+ if (target == null) return undefined;
+ const { path: _path, ...rest } = request;
+ return {
+ worktree: target.worktree,
+ request: {
+ ...rest,
+ ...(target.rest === '' ? {} : { path: target.rest }),
+ worktree: target.worktree,
+ },
+ };
+ }
+ case 'list_files': {
+ const target = splitLinkedWorktreePath(request.path);
+ if (target == null) return undefined;
+ const after =
+ request.afterPath == null ? undefined : splitLinkedWorktreePath(request.afterPath);
+ if (
+ request.afterPath != null &&
+ (after == null || after.worktree !== target.worktree || after.rest === '')
+ ) {
+ return undefined;
+ }
+ const { path: _path, afterPath: _afterPath, ...rest } = request;
+ return {
+ worktree: target.worktree,
+ request: {
+ ...rest,
+ ...(target.rest === '' ? {} : { path: target.rest }),
+ ...(after == null ? {} : { afterPath: after.rest }),
+ worktree: target.worktree,
+ },
+ };
+ }
+ case 'execute_command': {
+ if (request.environmentAction != null) return undefined;
+ const target = splitLinkedWorktreePath(request.cwd);
+ if (target == null) return undefined;
+ const { cwd: _cwd, ...rest } = request;
+ return {
+ worktree: target.worktree,
+ request: {
+ ...rest,
+ ...(target.rest === '' ? {} : { cwd: target.rest }),
+ worktree: target.worktree,
+ },
+ };
+ }
+ }
+}
+
+/** Restore the `.worktrees/<name>/` prefix on every path a lane result reports. */
+export function fromLinkedWorktreeResult(
+ result: WorkspaceToolResult,
+ worktree: string,
+): WorkspaceToolResult {
+ switch (result.operation) {
+ case 'read_file':
+ case 'write_file':
+ case 'edit_file':
+ case 'preview_edit':
+ return { ...result, path: prefixed(worktree, result.path) };
+ case 'search_text':
+ return {
+ ...result,
+ matches: result.matches.map((match) => ({
+ ...match,
+ path: prefixed(worktree, match.path),
+ })),
+ };
+ case 'list_files':
+ return {
+ ...result,
+ paths: result.paths.map((path) => prefixed(worktree, path)),
+ ...(result.nextAfterPath == null
+ ? {}
+ : { nextAfterPath: prefixed(worktree, result.nextAfterPath) }),
+ };
+ case 'execute_command':
+ return result;
+ }
+}
+
export async function executeWorkspaceTool({
baseURL,
authHeaders,
@@ -868,6 +1004,7 @@ export async function executeWorkspaceTool({
codeApiMaxRetryWaitMs = CODE_API_RATE_LIMIT_WAIT_DEFAULT_MS,
maxRequestTimeoutMs,
deadlineAtMs,
+ linkedWorktrees = false,
}: {
baseURL: string;
authHeaders: WorkspaceToolAuthHeaders;
@@ -881,6 +1018,8 @@ export async function executeWorkspaceTool({
maxRequestTimeoutMs?: number;
/** Optional earlier caller deadline; a signal alone has no remaining-time value. */
deadlineAtMs?: number;
+ /** The worker runs each `.worktrees/<name>` in its own lane; route matching requests there. */
+ linkedWorktrees?: boolean;
}): Promise<WorkspaceToolResult> {
if (
!isValidRequest(request) ||
@@ -898,16 +1037,18 @@ export async function executeWorkspaceTool({
) {
throw new WorkspaceToolHttpError('invalid');
}
- const executionBudgetMs = getWorkspaceExecutionBudgetMs(request);
+ const lane = linkedWorktrees === true ? toLinkedWorktreeRequest(request) : undefined;
+ const wireRequest: WorkspaceToolRequest = lane?.request ?? request;
+ const executionBudgetMs = getWorkspaceExecutionBudgetMs(wireRequest);
const completionReserveMs = executionBudgetMs + WORKSPACE_COMMAND_TRANSPORT_GRACE_MS;
- const perAttemptTimeoutMs = maxRequestTimeoutMs ?? getWorkspaceToolTimeoutMs(request);
+ const perAttemptTimeoutMs = maxRequestTimeoutMs ?? getWorkspaceToolTimeoutMs(wireRequest);
const callerDeadlineAt = Math.min(
deadlineAtMs ?? Infinity,
maxRequestTimeoutMs == null ? Infinity : Date.now() + maxRequestTimeoutMs,
);
const queueDeadlineAt = Date.now() + maxQueueWaitMs;
const callerRetryDeadlineAt = callerDeadlineAt - completionReserveMs;
- const body = JSON.stringify(request);
+ const body = JSON.stringify(wireRequest);
let lastAdmissionRejection: WorkspaceToolHttpError | undefined;
let lastRetryDeadlineAt = Infinity;
let rateLimitWaitedMs = 0;
@@ -1011,10 +1152,10 @@ export async function executeWorkspaceTool({
continue;
}
const result = await readBoundedJson(response, requestSignal);
- if (!isValidResult(request, result)) {
+ if (!isValidResult(wireRequest, result)) {
throw new WorkspaceToolHttpError('invalid');
}
- return result;
+ return lane ? fromLinkedWorktreeResult(result, lane.worktree) : result;
} catch (error) {
if (error instanceof WorkspaceToolHttpError) throw error;
if (
diff --git a/packages/data-provider/src/code/workspace.ts b/packages/data-provider/src/code/workspace.ts
index 33e0592fe4..5afb6567ab 100644
--- a/packages/data-provider/src/code/workspace.ts
+++ b/packages/data-provider/src/code/workspace.ts
@@ -25,6 +25,8 @@ export const CODE_WORKSPACE_OPERATIONS = [
'execute_command',
] as const;
export const CODE_WORKSPACE_INSTANCE_TYPES = ['git_worktree'] as const;
+/** Scheduling scopes a worker can admit beneath one registered root. */
+export const CODE_WORKSPACE_SCOPES = ['git_linked_worktree'] as const;
export const CODE_WORKSPACE_SELECTION_ERROR_REASONS = [
'required',
'invalid',
@@ -37,6 +39,7 @@ export const CODE_ENVIRONMENT_MODES = ['attached', 'without_attached'] as const;
export type CodeWorkspaceOperation = (typeof CODE_WORKSPACE_OPERATIONS)[number];
export type CodeWorkspaceInstanceType = (typeof CODE_WORKSPACE_INSTANCE_TYPES)[number];
+export type CodeWorkspaceScope = (typeof CODE_WORKSPACE_SCOPES)[number];
export type CodeWorkspaceSelectionErrorReason =
(typeof CODE_WORKSPACE_SELECTION_ERROR_REASONS)[number];
export type CodeEnvironmentMode = (typeof CODE_ENVIRONMENT_MODES)[number];
@@ -50,6 +53,8 @@ export interface CodeWorkspaceDescriptor {
operations?: CodeWorkspaceOperation[];
/** Optional worker-managed isolation modes available beneath this root. */
workspaceInstances?: CodeWorkspaceInstanceType[];
+ /** `git_linked_worktree`: each `.worktrees/<name>` runs in its own scheduling lane. */
+ workspaceScopes?: CodeWorkspaceScope[];
environment?: {
fingerprint: string;
repo?: string;
diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.ts
index 6ef043dbe1..c4e874f424 100644
--- a/packages/data-provider/src/config.spec.ts
+++ b/packages/data-provider/src/config.spec.ts
@@ -736,6 +736,35 @@ describe('attached code environment user config schema', () => {
});
});
+ it.each([
+ [{ linkedWorktrees: true }, true],
+ [{ linkedWorktrees: 'yes' }, false],
+ [{ linkedWorktrees: true, subdirectories: true }, false],
+ ])('validates the linked worktree lane toggle %p', (workspaces, valid) => {
+ const result = configSchema.safeParse({
+ version: '1.0',
+ endpoints: {
+ agents: {
+ statefulCodeSessions: {
+ allowedEnvironments: ['user'],
+ environments: [
+ {
+ id: 'personal-vm',
+ name: 'Personal VM',
+ type: 'attached',
+ baseURL: 'https://code.example.com/v1',
+ default: true,
+ configSchema: { workspaces },
+ },
+ ],
+ },
+ },
+ },
+ });
+
+ expect(result.success).toBe(valid);
+ });
+
it('rejects an attached command timeout above the protocol hard cap', () => {
const result = configSchema.safeParse({
version: '1.0',
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 815ec69d87..b7ecf82b33 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -1290,6 +1290,15 @@ export const codeEnvironmentUserConfigSchema = z
});
})
.optional(),
+ workspaces: z
+ .object({
+ /** Run requests aimed at `.worktrees/<name>` in that worktree's own lane when the
+ * worker advertises linked-worktree lanes. Omission keeps every request scoped to
+ * its checkout. */
+ linkedWorktrees: z.boolean().optional(),
+ })
+ .strict()
+ .optional(),
})
.strict();