Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

feat(orca): 手动创建 Worker 支持选择项目、继承 Lead 实际目录与新建 worktree (#6588)

fmfsaisaidd07092c2734
diff --git a/apps/desktop/scripts/fixtures/orca-worker-project/ui-page.mjs b/apps/desktop/scripts/fixtures/orca-worker-project/ui-page.mjs
new file mode 100644
index 0000000000..446f6e798c
--- /dev/null
+++ b/apps/desktop/scripts/fixtures/orca-worker-project/ui-page.mjs
@@ -0,0 +1,152 @@
+import assert from 'node:assert/strict';
+export default {
+ name: 'orca-worker-project',
+ entry: './worker-project-fixture.tsx',
+ viewport: { width: 560, height: 640 },
+ real: 'WorkerProjectField, selection hook, FolderPickerPopover, BranchWorktreeChip, RolePillDropdown, themes, fonts and five locales',
+ notCovered:
+ 'Full Worker creation popover, model/device selection, native folder dialog, filesystem discovery, IPC and actual worktree creation',
+ cases: {
+ default: {
+ about:
+ 'Inherited Lead worktree, new-worktree branch chooser, project search and dirty other project',
+ },
+ 'same-repo': {
+ about:
+ 'Browsing the main checkout preserves that selection; current-project row restores inherited worktree',
+ },
+ 'browse-error': { about: 'Native folder dialog failure leaves the current project usable' },
+ missing: { about: 'Missing directory explains why creation cannot continue' },
+ empty: { about: 'Empty repository explains why worktree creation is unavailable' },
+ detached: {
+ about: 'Detached HEAD is displayed as a short SHA and allows choosing a real branch',
+ },
+ workers: { about: 'Worker project badge appears only for the other project' },
+ dialogue: { about: 'Dialogue Lead hides checkbox until a Git project is selected' },
+ },
+ async ready(page) {
+ await page.getByRole('button').first().waitFor();
+ },
+ async check(page, ui) {
+ if (ui.case === 'workers') {
+ await page.getByRole('button', { name: /frontend/ }).click();
+ await page.getByText('design-system', { exact: true }).first().waitFor();
+ await ui.capture('worker-project-badge');
+ return;
+ }
+ const current = await ui.t('orca.workerProject.current');
+ const checkbox = page.getByRole('checkbox');
+ if (ui.case === 'same-repo') {
+ await page.getByRole('button', { name: current, exact: true }).click();
+ await page
+ .getByRole('button', { name: await ui.t('newChat.folderPicker.browseProjectFolder') })
+ .click();
+ await page
+ .getByText(await ui.t('orca.workerProject.direct', { project: 'cindy', branch: 'main' }))
+ .waitFor();
+ await ui.capture('explicit-main-checkout');
+ await page.getByRole('button', { name: 'cindy', exact: true }).click();
+ await page.getByRole('button', { name: 'cindy /projects/cindy', exact: true }).click();
+ await page.getByRole('button', { name: current, exact: true }).waitFor();
+ await ui.capture('restored-inherited-worktree');
+ return;
+ }
+ if (ui.case === 'browse-error') {
+ await page.getByRole('button', { name: current, exact: true }).click();
+ await page
+ .getByRole('button', { name: await ui.t('newChat.folderPicker.browseProjectFolder') })
+ .click();
+ await page
+ .getByRole('alert')
+ .getByText(await ui.t('newChat.folderPicker.browseFailed'))
+ .waitFor();
+ await ui.capture('native-folder-error');
+ await page.keyboard.press('Escape');
+ await page.getByRole('button', { name: current, exact: true }).waitFor();
+ assert.equal(
+ await page.getByText(await ui.t('ccAgent.common.loading'), { exact: true }).count(),
+ 0,
+ );
+ await ui.capture('native-folder-error-dismissed');
+ return;
+ }
+ if (ui.case === 'missing') {
+ assert.equal(await checkbox.count(), 0);
+ await page
+ .getByRole('status')
+ .getByText(await ui.t('orca.workerProject.missingDirectory'))
+ .waitFor();
+ assert.equal(
+ await page
+ .getByText(
+ await ui.t('orca.workerProject.notGit', { directory: '/projects/missing-project' }),
+ { exact: true },
+ )
+ .count(),
+ 0,
+ );
+ await ui.capture('missing-directory');
+ return;
+ }
+ if (ui.case === 'empty') {
+ assert.equal(await checkbox.count(), 0);
+ await page
+ .getByText(await ui.t('orca.workerProject.emptyRepo', { directory: '/projects/cindy' }))
+ .waitFor();
+ await ui.capture('empty-repository');
+ return;
+ }
+ const detachedLabel = await ui.t('orca.workerProject.detachedHead', { sha: 'abcdef01' });
+ const sourceLabel = ui.case === 'detached' ? detachedLabel : 'feat/worker-project-picker';
+ if (ui.case === 'dialogue') assert.equal(await checkbox.count(), 0);
+ else {
+ await page.getByText(await ui.t('orca.workerProject.newWorktree'), { exact: true }).click();
+ await page
+ .getByText(await ui.t('orca.workerProject.splitWarning', { branch: sourceLabel }))
+ .waitFor();
+ await ui.capture('new-worktree');
+ await page
+ .getByRole('button', { name: await ui.t('newChat.branchChip.label'), exact: true })
+ .click();
+ await page.getByRole('option', { name: 'main', exact: true }).waitFor();
+ await ui.capture('branches');
+ if (ui.case === 'detached') {
+ await page.getByRole('option', { name: 'main', exact: true }).click();
+ const branchButton = page.getByRole('button', {
+ name: await ui.t('newChat.branchChip.label'),
+ exact: true,
+ });
+ assert.equal(await branchButton.textContent(), 'main');
+ await ui.capture('detached-pick-branch');
+ } else await page.keyboard.press('Escape');
+ }
+ await page.getByRole('button', { name: current, exact: true }).click();
+ await page.getByRole('textbox').waitFor();
+ assert.equal(
+ await page.getByText(await ui.t('newChat.folderPicker.dialogue'), { exact: true }).count(),
+ 0,
+ );
+ assert.equal(
+ await page
+ .getByRole('button', { name: await ui.t('newChat.folderPicker.removeFromList') })
+ .count(),
+ 0,
+ );
+ await ui.capture('projects');
+ await page.getByRole('textbox').fill('design-system');
+ await page.getByText('design-system', { exact: true }).click();
+ await page.getByText(await ui.t('orca.workerProject.dirty')).waitFor();
+ assert.equal(await checkbox.isChecked(), false, 'project changes reset worktree selection');
+ if (ui.case === 'detached') {
+ await page
+ .getByText(
+ await ui.t('orca.workerProject.directDetached', {
+ project: 'design-system',
+ branch: detachedLabel,
+ }),
+ )
+ .waitFor();
+ }
+ await ui.capture('other-project');
+ },
+};
diff --git a/apps/desktop/scripts/fixtures/orca-worker-project/worker-project-fixture.tsx b/apps/desktop/scripts/fixtures/orca-worker-project/worker-project-fixture.tsx
new file mode 100644
index 0000000000..43b5a1dfb2
--- /dev/null
+++ b/apps/desktop/scripts/fixtures/orca-worker-project/worker-project-fixture.tsx
@@ -0,0 +1,145 @@
+import { RolePillDropdown } from '../../../src/renderer/features/cc-agent/RolePillDropdown';
+import type { WorkerInfo } from '../../../src/renderer/features/cc-agent/hooks/useWorkers';
+import { mountPage } from '../../ui-page/harness';
+import {
+ WorkerProjectField,
+ useWorkerProjectSelection,
+} from '../../../src/renderer/features/cc-agent/WorkerProjectField';
+import type {
+ WorkerProjectContext,
+ WorkerProjectInfo,
+} from '../../../src/shared/orca-worker-project';
+
+const inherited: WorkerProjectInfo = {
+ directory: '/projects/cindy/.cindy-worktrees/worker-picker',
+ baseRepo: '/projects/cindy',
+ branch: 'feat/worker-project-picker',
+ headState: 'branch',
+ exists: true,
+ dirty: true,
+ isWorktree: true,
+};
+const projects = [
+ 'cindy',
+ 'design-system',
+ 'mobile-app',
+ 'website',
+ 'notes',
+ 'missing-project',
+].map((name) => ({
+ path: `/projects/${name}`,
+ name,
+ description: `/projects/${name}`,
+ missing: name === 'missing-project',
+}));
+function Fixture() {
+ const selection = useWorkerProjectSelection(true, 'fixture-lead', true);
+ return (
+ <main className="mx-auto w-full max-w-[440px] p-4">
+ <div className="rounded-xl border border-[var(--border-default)] bg-[var(--bg-primary)] p-4">
+ <WorkerProjectField selection={selection} disabled={false} />
+ </div>
+ </main>
+ );
+}
+const workers: WorkerInfo[] = ['frontend', 'reviewer'].map((role, index) => ({
+ workerId: role,
+ sessionId: role,
+ role,
+ agent: 'codex',
+ model: 'gpt-5',
+ effort: 'high',
+ label: null,
+ status: 'idle',
+ focused: index === 0,
+ idleSince: null,
+}));
+function WorkersFixture() {
+ return (
+ <main className="mx-auto w-full max-w-[440px] p-4">
+ <RolePillDropdown
+ worker={workers[0]}
+ workers={workers}
+ selectedWorkerId="frontend"
+ activeWorkerCount={2}
+ onSwitchFocus={() => {}}
+ onArchiveWorker={() => {}}
+ />
+ </main>
+ );
+}
+void mountPage({
+ host: (ctx) => ({
+ showOpenDirectoryDialog: async () => {
+ if (ctx.case === 'same-repo') return { canceled: false, path: '/projects/cindy' };
+ throw new Error('fixture dialog unavailable');
+ },
+ localDb: {
+ orcaWorkflows: {
+ projectLabel: async (id: string) =>
+ id === 'frontend' ? { name: 'design-system', path: '/projects/design-system' } : null,
+ projectContext: async (
+ _id: string,
+ directory?: string,
+ ): Promise<WorkerProjectContext | WorkerProjectInfo> => {
+ const lead =
+ ctx.case === 'missing'
+ ? {
+ ...inherited,
+ directory: '/projects/missing-project',
+ baseRepo: null,
+ branch: null,
+ exists: false,
+ isWorktree: false,
+ dirty: false,
+ }
+ : ctx.case === 'dialogue'
+ ? {
+ ...inherited,
+ baseRepo: null,
+ branch: null,
+ directory: '/tasks/dialogue',
+ isWorktree: false,
+ }
+ : ctx.case === 'empty'
+ ? {
+ ...inherited,
+ directory: '/projects/cindy',
+ branch: null,
+ headState: 'unborn' as const,
+ isWorktree: false,
+ }
+ : ctx.case === 'detached'
+ ? {
+ ...inherited,
+ branch: 'abcdef0123456789abcdef0123456789abcdef0123',
+ headState: 'detached' as const,
+ }
+ : inherited;
+ const selected = directory
+ ? {
+ ...inherited,
+ directory,
+ baseRepo: directory,
+ branch: ctx.case === 'detached' ? lead.branch : 'main',
+ headState: ctx.case === 'detached' ? lead.headState : ('branch' as const),
+ isWorktree: false,
+ }
+ : lead;
+ if (directory) return selected;
+ return {
+ recordedDirectory: ctx.case === 'dialogue' ? lead.directory : '/projects/cindy',
+ inherited: lead,
+ selected,
+ dialogue: ctx.case === 'dialogue',
+ projects,
+ };
+ },
+ },
+ },
+ worktreeListBranches: async () => ({
+ branches: ['main', 'feat/worker-project-picker', 'release/v2'],
+ }),
+ }),
+ render: (ctx) => (ctx.case === 'workers' ? <WorkersFixture /> : <Fixture />),
+});
diff --git a/apps/desktop/src/main/__tests__/gitContextSessionDirResolver.test.ts b/apps/desktop/src/main/__tests__/gitContextSessionDirResolver.test.ts
index 838c3a278c..6b900b3f0c 100644
--- a/apps/desktop/src/main/__tests__/gitContextSessionDirResolver.test.ts
+++ b/apps/desktop/src/main/__tests__/gitContextSessionDirResolver.test.ts
@@ -17,6 +17,7 @@ import {
findLiveLinkedWorktree,
posixDriveToWin32,
resolveSessionGitDir,
+ resolveWorkerInheritedDirectory,
type ResolveSessionGitDirDeps,
} from '../git-context/sessionDirResolver';
@@ -341,3 +342,56 @@ describe('collectTouchedDirs', () => {
]);
});
});
+
+// Test value: Worker inheritance is stricter than the header's directory badge.
+// Existing resolver tests accept any valid repository; a different common-dir is the minimal
+// unsafe input. Unit tier uses injected probes (no Git processes or disk writes).
+describe('Worker same-repository inheritance', () => {
+ const recorded = {directory: '/repo', realDirectory: '/repo', checkoutRoot: '/repo', baseRepo: '/repo', commonDir: '/repo/.git',
+ branch: 'main', exists: true, dirty: false, isWorktree: false};
+ it.each([
+ ['linked checkout', '/repo/.git', true, '/checkout'],
+ ['independent clone', '/clone/.git', true, '/repo'],
+ ['nested repository', '/repo/nested/.git', true, '/repo'],
+ ['deleted checkout', '/repo/.git', false, '/repo'],
+ ['non-Git directory', null, true, '/repo'],
+ ])('%s selects only a live directory with the same common-dir', async (_name, commonDir, exists, expected) => {
+ const result = await resolveWorkerInheritedDirectory({id: 'lead', workingDir: '/repo'}, {
+ infer: async () => ({workdir: '/checkout', head: branchHead('feature'), source: 'telemetry'}),
+ probe: async directory => directory === '/repo' ? recorded : {...recorded, directory, realDirectory: directory, checkoutRoot: '/checkout', commonDir, exists, isWorktree: true},
+ });
+ expect(result.directory).toBe(expected);
+ });
+ // Regression: Edit telemetry identifies a file's parent, not the desired Worker cwd.
+ // The previous implementation submitted that subdirectory; retain checkout/subproject scope.
+ it.each([
+ ['/repo', '/repo/src', '/repo', true, '/repo'],
+ ['/alias/repo', '/repo/src', '/repo', true, '/alias/repo'],
+ ['/repo', '/checkout/src', '/checkout', true, '/checkout'],
+ ['/repo/apps/web', '/checkout/src', '/checkout', true, '/checkout/apps/web'],
+ ['/repo/apps/web', '/checkout/src', '/checkout', false, '/checkout'],
+ ['/repo/apps/web', '/repo/lib', '/repo', true, '/repo/apps/web'],
+ ])('keeps project scope from %s with telemetry %s (candidate checkout %s, matching subproject exists=%s)', async (rawDirectory, rawTelemetry, rawCheckoutRoot, subprojectExists, expected) => {
+ const directory = path.resolve(rawDirectory);
+ const telemetry = path.resolve(rawTelemetry);
+ const checkoutRoot = path.resolve(rawCheckoutRoot);
+ const original = {...recorded, directory, checkoutRoot: path.resolve('/repo'), realDirectory: path.resolve(rawDirectory.replace('/alias', ''))};
+ const result = await resolveWorkerInheritedDirectory({id: 'lead', workingDir: directory}, {
+ infer: async () => ({workdir: telemetry, head: branchHead('feature'), source: 'telemetry'}),
+ probe: async dir => dir === directory ? original : {
+ ...recorded, directory: dir, realDirectory: dir, checkoutRoot,
+ exists: dir === path.resolve('/checkout/apps/web') ? subprojectExists : true,
+ isWorktree: checkoutRoot === path.resolve('/checkout'),
+ },
+ });
+ expect(result.directory).toBe(path.resolve(expected));
+ if (checkoutRoot === path.resolve('/repo')) expect(result).toBe(original);
+ });
+ it('preserves the recorded directory without telemetry or a Git identity', async () => {
+ const infer = vi.fn(async () => ({workdir: null, head: null, source: null} as const));
+ const result = await resolveWorkerInheritedDirectory({id: 'lead', workingDir: '/repo'}, {
+ infer, probe: async () => ({...recorded, commonDir: null}),
+ });
+ expect(result.directory).toBe('/repo');
+ });
+});
diff --git a/apps/desktop/src/main/__tests__/worktreeManagerCreate.test.ts b/apps/desktop/src/main/__tests__/worktreeManagerCreate.test.ts
index 94d3c21125..52b76c86d5 100644
--- a/apps/desktop/src/main/__tests__/worktreeManagerCreate.test.ts
+++ b/apps/desktop/src/main/__tests__/worktreeManagerCreate.test.ts
@@ -132,6 +132,44 @@ describe('createWorktree naming authority', () => {
await vi.waitFor(() => expect(checkoutLease.release).toHaveBeenCalledExactlyOnceWith({}));
});
+ // Worker failure compensation must wait for checkout; successful creation must not.
+ // Existing lease tests do not exercise the new opt-in wait handle (unit tier, fake I/O).
+ it.each([false, true])('tracks checkout without delaying success; setup failure=%s waits before rollback', async (failSetup) => {
+ const previousGit = gitExecMock.getMockImplementation()!;
+ let finishCheckout!: () => void;
+ const checkout = new Promise<{stdout: string; stderr: string}>(resolve => {
+ finishCheckout = () => resolve({stdout: '', stderr: ''});
+ });
+ let reachedSetup!: () => void;
+ const setup = new Promise<void>(resolve => { reachedSetup = resolve; });
+ gitExecMock.mockImplementation((args: string[], ...rest: unknown[]) => {
+ if (args[0] === 'checkout' && args.includes(':(exclude).sivi')) return checkout;
+ if (args.includes('core.hooksPath')) {
+ reachedSetup();
+ if (failSetup) return Promise.reject(new Error('hooks failed'));
+ }
+ return previousGit(args, ...rest);
+ });
+ const sessionId = `tracked-${failSetup}`;
+ const creating = manager.createWorktree({sessionId, baseRepo, name: 'tracked', sourceBranch: 'main'}, {trackBackgroundCheckout: true});
+ await setup;
+ let waited = false;
+ const waiting = manager.awaitBackgroundCheckout(sessionId).then(() => { waited = true; });
+ try {
+ if (!failSetup) await expect(creating).resolves.toMatchObject({ok: true});
+ await Promise.resolve();
+ expect(waited).toBe(false);
+ expect(gitExecMock.mock.calls.some(([args]) => args[0] === 'worktree' && args[1] === 'remove')).toBe(false);
+ } finally {
+ finishCheckout();
+ await waiting;
+ }
+ await expect(creating).resolves.toMatchObject({ok: !failSetup});
+ expect(checkoutLease.release).toHaveBeenCalledOnce();
+ expect(gitExecMock.mock.calls.some(([args]) => args[0] === 'worktree' && args[1] === 'remove')).toBe(failSetup);
+ await manager.awaitBackgroundCheckout(sessionId);
+ });
+
it.each(['', ' \t'])('generates a meaningful final name for blank input %j', async (name) => {
const result = await create(name);
diff --git a/apps/desktop/src/main/git-context/sessionDirResolver.ts b/apps/desktop/src/main/git-context/sessionDirResolver.ts
index 3c25bca35c..a14a3d0a22 100644
--- a/apps/desktop/src/main/git-context/sessionDirResolver.ts
+++ b/apps/desktop/src/main/git-context/sessionDirResolver.ts
@@ -1,3 +1,4 @@
+import type { WorkerProjectInfo } from '../../shared/orca-worker-project';
/**
* sessionDirResolver — 推断「一个对话当前实际在哪个 git 工作目录干活」。
*
@@ -522,3 +523,71 @@ export async function findLiveLinkedWorktreeLive(
return null;
}
}
+
+/** Canonical identities for inheritance; directory preserves the caller's spelling. */
+export interface WorkerProjectProbe extends WorkerProjectInfo {
+ commonDir: string | null;
+ checkoutRoot: string | null;
+ realDirectory: string | null;
+}
+
+/** PR2 can reuse this same-repository gate without changing MCP defaults in PR1. */
+export async function resolveWorkerInheritedDirectory(
+ lead: { id: string; workingDir: string | null; worktreePath?: string | null },
+ deps: {
+ infer: typeof resolveSessionGitDirLive;
+ probe: (dir: string) => Promise<WorkerProjectProbe>;
+ },
+): Promise<WorkerProjectProbe> {
+ const recorded = await deps.probe(lead.workingDir ?? '');
+ let inferred: SessionGitDirResult;
+ try {
+ inferred = await deps.infer({
+ sessionId: lead.id,
+ fallbackWorkingDir: lead.workingDir,
+ fallbackWorktreePath: lead.worktreePath ?? null,
+ });
+ } catch {
+ return recorded;
+ }
+ if (
+ inferred.source !== 'telemetry' ||
+ !inferred.workdir ||
+ inferred.workdir === recorded.directory ||
+ !recorded.commonDir ||
+ !recorded.checkoutRoot
+ )
+ return recorded;
+ const samePath = (a: string, b: string) =>
+ process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+ const candidate = await deps.probe(inferred.workdir);
+ if (
+ !candidate.exists ||
+ !candidate.commonDir ||
+ !candidate.checkoutRoot ||
+ !samePath(candidate.commonDir, recorded.commonDir) ||
+ samePath(candidate.checkoutRoot, recorded.checkoutRoot)
+ )
+ return recorded;
+
+ // Editing src/file.ts is evidence for its checkout, not a request to start in src.
+ const checkout = { ...candidate, directory: candidate.checkoutRoot, realDirectory: candidate.checkoutRoot };
+ if (!recorded.realDirectory) return checkout;
+ const relative = path.relative(recorded.checkoutRoot, recorded.realDirectory);
+ if (
+ !relative ||
+ relative === '..' ||
+ relative.startsWith(`..${path.sep}`) ||
+ path.isAbsolute(relative)
+ )
+ return checkout;
+ const corresponding = await deps.probe(path.join(candidate.checkoutRoot, relative));
+ // Keep a monorepo subproject when present, without crossing into a nested repository.
+ return corresponding.exists &&
+ corresponding.checkoutRoot &&
+ corresponding.commonDir &&
+ samePath(corresponding.checkoutRoot, candidate.checkoutRoot) &&
+ samePath(corresponding.commonDir, candidate.commonDir)
+ ? corresponding
+ : checkout;
+}
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
index 9b4d926f06..8ee983940d 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerCreationService.test.ts
@@ -3699,3 +3699,59 @@ it('rejects a plan changed during preparation without reserving or bootstrapping
const result=await service.createWorker({leadSessionId:'lead-1',role:'eval',agent:'codex',label:'sample'});
expect(result.ok).toBe(false);expect(deps.reserveWorkerCreation).not.toHaveBeenCalled();expect(deps.bootstrapSession).not.toHaveBeenCalled();
});
+
+// Test value: the UI's optional worktree creates new filesystem ownership before bootstrap.
+// The former tests only cover binding an existing path. Failures at each persistence boundary
+// must release that new ownership, never an inherited checkout. Unit tier, injected I/O.
+describe('local Worker worktree ownership', () => {
+ const request = {leadSessionId: 'lead-1', role: 'developer', label: 'worker', agent: 'codex' as const,
+ worktree: {sourceBranch: 'feature'}};
+ it('binds the newly created checkout to the Worker session and leaves success asynchronous', async () => {
+ const {deps, service} = createDeps({
+ createWorkerWorktree: vi.fn(async () => '/repo/.cindy-worktrees/worker'),
+ discardWorkerWorktree: vi.fn(async () => {}),
+ });
+ await expect(service.createWorker(request)).resolves.toMatchObject({ok: true, workerSessionId: WORKER_SESSION_ID});
+ expect(deps.createWorkerWorktree).toHaveBeenCalledWith(WORKER_SESSION_ID, 'C:\\repo', 'feature');
+ expect(deps.bootstrapSession).toHaveBeenCalledWith(expect.objectContaining({id: WORKER_SESSION_ID, workingDir: '/repo/.cindy-worktrees/worker'}));
+ expect(deps.discardWorkerWorktree).not.toHaveBeenCalled();
+ });
+ it.each(['create', 'bootstrap', 'renewal', 'persist', 'postcheck'])('compensates a %s failure before releasing the reservation', async phase => {
+ let finishCheckout!: () => void;
+ const checkout = new Promise<void>(resolve => {finishCheckout = resolve;});
+ let compensationStarted!: () => void;
+ const entered = new Promise<void>(resolve => {compensationStarted = resolve;});
+ const removed: string[] = [];
+ const {deps, service} = createDeps({
+ createWorkerWorktree: vi.fn(async () => {if (phase === 'create') throw new Error('Git failed'); return '/repo/.cindy-worktrees/worker';}),
+ discardWorkerWorktree: vi.fn(async id => {compensationStarted(); await checkout; removed.push(id);}),
+ ...(phase === 'bootstrap' ? {bootstrapSession: vi.fn(async () => {throw new Error('start failed');})} : {}),
+ ...(phase === 'renewal' ? {renewWorkerCreationReservation: vi.fn(async () => false)} : {}),
+ ...(phase === 'persist' ? {addOrUpdateWorker: vi.fn(async () => {throw new Error('write failed');})} : {}),
+ ...(phase === 'postcheck' ? {markOrcaRoleIfNeeded: vi.fn(async () => {throw new Error('mark failed');})} : {}),
+ });
+ const result = service.createWorker(request);
+ await entered;
+ expect(removed).toEqual([]);
+ expect(deps.releaseWorkerCreationReservation).not.toHaveBeenCalled();
+ finishCheckout();
+ await expect(result).resolves.toMatchObject({ok: false});
+ expect(removed).toEqual([WORKER_SESSION_ID]);
+ expect(deps.releaseWorkerCreationReservation).toHaveBeenCalledWith('worker-1');
+ if (phase === 'create') expect(deps.bootstrapSession).not.toHaveBeenCalled();
+ });
+ it('never claims or discards an inherited checkout, even when bootstrap fails', async () => {
+ const {deps, service} = createDeps({
+ createWorkerWorktree: vi.fn(), discardWorkerWorktree: vi.fn(),
+ bootstrapSession: vi.fn(async () => {throw new Error('start failed');}),
+ });
+ await expect(service.createWorker({...request, worktree: undefined})).resolves.toMatchObject({ok: false});
+ expect(deps.createWorkerWorktree).not.toHaveBeenCalled();
+ expect(deps.discardWorkerWorktree).not.toHaveBeenCalled();
+ });
+ it('rejects a new worktree on an execution device before reservation', async () => {
+ const {deps, service} = createDeps({createWorkerWorktree: vi.fn(), discardWorkerWorktree: vi.fn()});
+ await expect(service.createWorker({...request, executionDeviceId: 'other'})).resolves.toMatchObject({ok: false, errorCode: 'INVALID_PARAMS'});
+ expect(deps.reserveWorkerCreation).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerProject.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerProject.test.ts
new file mode 100644
index 0000000000..b3b69fdcae
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/__tests__/orcaWorkerProject.test.ts
@@ -0,0 +1,529 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { realpath, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { gitExec } from '../../worktree/gitExec';
+import { createWorktree, awaitBackgroundCheckout } from '../../worktree/WorktreeManager';
+import { createLogger } from '../../logger';
+import { MAKER_INVOKE } from '../channels';
+import { isDeviceLinkInvoke, runDeviceLinkInvokeContext } from '../../device-link/invoke-context';
+import {
+ createWorkerWorktree,
+ probeWorkerProject,
+ readWorkerProjectContext,
+} from '../orcaWorkerProject';
+import { createOrcaWorkerProjectHandlers } from '../orcaWorkerProjectHandlers';
+
+vi.mock('../../maker-host/codex-credential-switch', () => ({
+ isCredentialModeSwitchBusyError: () => false,
+}));
+vi.mock('../../device-link/subscriptions', () => ({}));
+
+vi.mock('electron', () => ({ app: {} }));
+vi.mock('../../logger', () => {
+ const log = { warn: vi.fn() };
+ return { createLogger: () => log };
+});
+vi.mock('../../maker-host/override-settings-file', () => ({
+ createOverrideSettingsFile: () => ({}),
+}));
+vi.mock('../../localDb/client/current', () => ({}));
+vi.mock('../../localDb/ipc/recentWorkdirs', () => ({}));
+vi.mock('../../git-context/sessionDirResolver', () => ({}));
+vi.mock('../../worktree/WorktreeManager', () => ({
+ createWorktree: vi.fn(),
+ awaitBackgroundCheckout: vi.fn(),
+}));
+// Keep the production probe and Git output real; isolate unrelated process/runtime services.
+vi.mock('../../worktree/gitExec', () => ({
+ gitExec: vi.fn(async (args: string[], cwd: string) => ({
+ stdout: execFileSync('git', args, { cwd, encoding: 'utf8' }),
+ stderr: '',
+ })),
+}));
+
+const directory = mkdtempSync(path.join(os.tmpdir(), 'cindy-worker-head-'));
+afterAll(() => rmSync(directory, { recursive: true, force: true }));
+
+// N07/N09: existing inheritance tests inject probes and miss actual Git HEAD states.
+// Integration tier: an empty repo, its first commit, then detached HEAD are the smallest
+// inputs proving availability and that the selected revision remains the full commit ID.
+describe('Worker project HEAD probe', () => {
+ it('distinguishes an unborn HEAD, a branch and a detached commit while retaining dirty status', async () => {
+ const git = (...args: string[]) =>
+ execFileSync('git', args, { cwd: directory, encoding: 'utf8' }).trim();
+ git('init', '--initial-branch=main');
+ writeFileSync(path.join(directory, 'file.txt'), 'worker\n');
+ expect(await probeWorkerProject(directory)).toMatchObject({
+ exists: true,
+ headState: 'unborn',
+ branch: null,
+ dirty: true,
+ });
+ git('add', 'file.txt');
+ git(
+ '-c',
+ 'user.name=Fixture',
+ '-c',
+ '-c',
+ 'commit.gpgsign=false',
+ 'commit',
+ '-m',
+ 'fixture',
+ );
+ expect(await probeWorkerProject(directory)).toMatchObject({
+ headState: 'branch',
+ branch: 'main',
+ dirty: false,
+ });
+ const sha = git('rev-parse', 'HEAD');
+ git('checkout', '--detach', '--quiet', sha);
+ expect(await probeWorkerProject(directory)).toMatchObject({
+ headState: 'detached',
+ branch: sha,
+ dirty: false,
+ });
+ });
+});
+
+// Unit: import the project extension parser used by both register.ts creation entries,
+// plus the actual project read handlers; use real device-link identity.
+// PR1 requires local project options to stay local; service tests bypass this boundary.
+// One new local field must fail parsing before a caller can reach lifecycle creation.
+// The existing makerSendToSessionOrdering guard protects lifecycle delegation in register.ts.
+const projectChannels = ['maker:worker:project-context', 'maker:worker:project-label'];
+const creationChannels = [MAKER_INVOKE.WORKER_CREATE, MAKER_INVOKE.SESSION_ENABLE_ORCA];
+type Handler = (event: unknown, ...args: unknown[]) => Promise<unknown>;
+function ipcHarness(ssh = false) {
+ const lead = {
+ id: 'lead',
+ remoteHostId: ssh ? 'ssh-host' : null,
+ workingDir: '/repo',
+ workspaceKind: 'project',
+ orcaRole: 'lead',
+ };
+ const worker = { ...lead, id: 'worker-session', orcaRole: 'worker' };
+ const getSession = vi.fn(async () => lead);
+ const owner = { userId: 'owner' };
+ const info = {
+ directory: '/repo',
+ baseRepo: '/repo',
+ branch: 'main',
+ exists: true,
+ dirty: false,
+ isWorktree: false,
+ };
+ const readContext = vi.fn(async () => ({
+ recordedDirectory: '/repo',
+ inherited: info,
+ selected: info,
+ dialogue: false,
+ projects: [],
+ }));
+ const probe = vi.fn(async () => info);
+ const remember = vi.fn(async () => {});
+ const trustedRenderer = vi.fn();
+ const adapters = createOrcaWorkerProjectHandlers({
+ isDeviceLinkInvoke,
+ assertTrustedAppRendererEvent: trustedRenderer,
+ getOwner: () => owner,
+ getSession,
+ readContext,
+ probe,
+ remember,
+ getTeamByWorkerSession: async () => ({ leadSessionId: 'lead' }),
+ log: { warn: vi.fn() },
+ });
+ const handlers = new Map<string, Handler>([
+ [projectChannels[0]!, (event, id, directory) => adapters.context(event, id, directory)],
+ [projectChannels[1]!, (event, id) => adapters.label(event, id)],
+ ]);
+ const invoke = (channel: string, args: unknown[], remote = true) => {
+ const handler = handlers.get(channel)!;
+ const call = () => handler({}, ...args);
+ return remote
+ ? runDeviceLinkInvokeContext({ controllerDeviceId: 'controller', channel }, call)
+ : call();
+ };
+ const options = (
+ fields: Record<string, unknown>,
+ remote = true,
+ channel: string = MAKER_INVOKE.WORKER_CREATE,
+ ) => {
+ const call = () => adapters.options({}, 'lead', fields);
+ return remote
+ ? runDeviceLinkInvokeContext({ controllerDeviceId: 'controller', channel }, call)
+ : call();
+ };
+ return {
+ invoke,
+ options,
+ getSession,
+ readContext,
+ probe,
+ remember,
+ trustedRenderer,
+ lead,
+ worker,
+ };
+}
+
+// Released pre-project-picker clients: mobile formWireFields with default placement or an
+// execution device + selected directory, and Desktop's executionDeviceId + workingDir.
+// These are protocol samples, deliberately independent of current client serializers:
+// breaking them would reject old clients or create their Worker in the wrong directory.
+const legacyWireFields = {
+ 'mobile-default': { workerPermissionMode: 'auto' },
+ 'mobile-execution-dir': {
+ model: 'chosen-model',
+ effort: 'high',
+ fast: false,
+ providerId: 'provider',
+ workerPermissionMode: 'auto',
+ executionDeviceId: 'execution-pc',
+ workingDir: '/remote/project',
+ },
+ 'desktop-execution-dir': { executionDeviceId: ' execution-pc ', workingDir: ' /remote/project ' },
+};
+describe('Worker project IPC cross-device boundary', () => {
+ it.each(
+ creationChannels.flatMap((channel) =>
+ ['worktree', 'projectPath', 'workingDir'].flatMap((field) =>
+ (field === 'workingDir' ? [false] : [false, true]).map((execution) => ({
+ channel,
+ field,
+ execution,
+ })),
+ ),
+ ),
+ )(
+ 'rejects device-link $channel with local $field before creation (execution=$execution)',
+ async ({ channel, field, execution }) => {
+ const h = ipcHarness();
+ const value = field === 'worktree' ? { sourceBranch: 'main' } : path.resolve('local-project');
+ await expect(
+ h.options(
+ { [field]: value, ...(execution ? { executionDeviceId: 'execution-pc' } : {}) },
+ true,
+ channel,
+ ),
+ ).rejects.toMatchObject({ code: 'PERMISSION_DENIED' });
+ expect(h.getSession).not.toHaveBeenCalled();
+ expect(h.readContext).not.toHaveBeenCalled();
+ expect(h.probe).not.toHaveBeenCalled();
+ expect(h.remember).not.toHaveBeenCalled();
+ },
+ );
+ it.each(creationChannels)(
+ 'rejects local project options for an SSH Lead through %s',
+ async (channel) => {
+ const h = ipcHarness(true);
+ await expect(
+ h.options({ worktree: { sourceBranch: 'main' } }, false, channel),
+ ).rejects.toMatchObject({ code: 'INVALID_PARAMS' });
+ expect(h.remember).not.toHaveBeenCalled();
+ },
+ );
+
+ // Parsing exposes only the extension fields and a deferred success callback. It must
+ // not write history while validation/creation can still fail; register owns dispatch.
+ it.each(creationChannels)(
+ 'returns local fields and defers history until success through %s',
+ async (channel) => {
+ const h = ipcHarness();
+ const directory = path.resolve('selected-project');
+ const worktree = { sourceBranch: 'feature' };
+ const project = await h.options(
+ { workingDir: directory, worktree, projectPath: directory },
+ false,
+ channel,
+ );
+ expect(project.fields).toEqual({ workingDir: directory, worktree });
+ expect(h.remember).not.toHaveBeenCalled();
+ await project.remember();
+ expect(h.remember).toHaveBeenCalledExactlyOnceWith(directory, 'owner');
+ },
+ );
+ it.each(projectChannels.flatMap((channel) => [false, true].map((ssh) => ({ channel, ssh }))))(
+ 'denies project reads $channel (SSH=$ssh)',
+ async ({ channel, ssh }) => {
+ const h = ipcHarness(ssh);
+ await expect(
+ h.invoke(channel, [channel.endsWith('label') ? 'worker-session' : 'lead'], !ssh),
+ ).rejects.toMatchObject({ code: ssh ? 'INVALID_PARAMS' : 'PERMISSION_DENIED' });
+ expect(h.readContext).not.toHaveBeenCalled();
+ expect(h.probe).not.toHaveBeenCalled();
+ },
+ );
+ it('rejects a local worker project label when its Lead is SSH', async () => {
+ const h = ipcHarness(true);
+ h.getSession.mockResolvedValueOnce({ ...h.worker, remoteHostId: null });
+ await expect(h.invoke(projectChannels[1]!, ['worker-session'], false)).rejects.toMatchObject({
+ code: 'INVALID_PARAMS',
+ });
+ expect(h.probe).not.toHaveBeenCalled();
+ });
+ it.each(
+ creationChannels.flatMap((channel) =>
+ ['mobile-default', 'mobile-execution-dir', 'desktop-execution-dir'].map((client) => ({
+ channel,
+ client,
+ })),
+ ),
+ )(
+ 'adds no project fields or history for released $client through $channel',
+ async ({ channel, client }) => {
+ const h = ipcHarness();
+ const fields = legacyWireFields[client as keyof typeof legacyWireFields];
+ const project = await h.options(fields, true, channel);
+ expect(project.fields).toEqual({});
+ await project.remember();
+ expect(h.trustedRenderer).not.toHaveBeenCalled();
+ expect(h.getSession).not.toHaveBeenCalled();
+ expect(h.remember).not.toHaveBeenCalled();
+ },
+ );
+});
+
+// Performance regression, unit: recent lists can contain hundreds of projects. Existing
+// HEAD/creation tests do not limit list-time Git work or selection-time list reloads.
+describe('Worker project read cost', () => {
+ it('builds 100 recent rows with bounded stat work and no Git, retaining order and current-worktree deduplication', async () => {
+ const inherited = {
+ directory: '/repo/.cindy-worktrees/lead',
+ baseRepo: '/repo',
+ branch: 'feature',
+ exists: true,
+ dirty: false,
+ isWorktree: true,
+ checkoutRoot: '/repo/.cindy-worktrees/lead',
+ commonDir: '/repo/.git',
+ realDirectory: '/repo/.cindy-worktrees/lead',
+ };
+ const inherit = vi.fn(async () => inherited);
+ const recent = Array.from({ length: 100 }, (_, index) => `/projects/project-${index}`);
+ let active = 0;
+ let peak = 0;
+ const isDirectory = vi.fn(async (directory: string) => {
+ active++;
+ peak = Math.max(peak, active);
+ await Promise.resolve();
+ active--;
+ return directory !== recent[99];
+ });
+ vi.mocked(gitExec).mockClear();
+ const result = await readWorkerProjectContext(
+ { id: 'lead', workingDir: inherited.directory },
+ {
+ inherit,
+ // Worker history precedes global recents; normalized aliases must not add rows.
+ recentDirectories: async () => [
+ recent[42]!,
+ '/repo/.',
+ inherited.directory,
+ ...recent,
+ `${recent[42]}/.`,
+ ],
+ isDirectory,
+ realpath: async (directory) => {
+ active++;
+ peak = Math.max(peak, active);
+ await Promise.resolve();
+ active--;
+ return directory;
+ },
+ },
+ );
+ expect(inherit).toHaveBeenCalledTimes(1);
+ expect(gitExec).not.toHaveBeenCalled();
+ expect(isDirectory).toHaveBeenCalledTimes(101);
+ expect(peak).toBeLessThanOrEqual(4);
+ expect(result.projects.map((row) => row.path)).toEqual([
+ '/repo',
+ recent[42],
+ ...recent.filter((value) => value !== recent[42]),
+ ]);
+ expect(result.projects.at(-1)).toMatchObject({ path: recent[99], missing: true });
+ expect(result.selected).toBe(inherited);
+ });
+
+ it('switches a project with exactly one target probe and no list or Lead inheritance reload', async () => {
+ const h = ipcHarness();
+ const selected = {
+ directory: '/other',
+ baseRepo: '/other',
+ branch: 'other',
+ exists: true,
+ dirty: true,
+ isWorktree: false,
+ };
+ h.probe.mockResolvedValue(selected);
+ await h.invoke(projectChannels[0]!, ['lead'], false);
+ const initialReads = h.readContext.mock.calls.length;
+ expect(await h.invoke(projectChannels[0]!, ['lead', '/other'], false)).toEqual(selected);
+ expect(h.readContext).toHaveBeenCalledTimes(initialReads);
+ expect(h.probe).toHaveBeenCalledExactlyOnceWith('/other', true);
+ });
+});
+
+// P2 regression: lexical path normalization misses filesystem aliases (/var vs /private/var,
+// or a user-created symlink). Real filesystem identities must merge rows without invoking Git
+// or rewriting the selected path. Unit tier: tiny temp directories, no timers or Git processes.
+describe('Worker project filesystem aliases', () => {
+ const base = path.join(directory, 'alias-fixture');
+ const linked = path.join(directory, 'linked-projects');
+ const projectA = path.join(base, 'proj-a');
+ const checkout = path.join(projectA, '.cindy-worktrees', 'worker');
+ const projectB = path.join(base, 'proj-b');
+ const projectC = path.join(base, 'proj-c');
+ const aliasB = path.join(linked, 'proj-b');
+ const missing = path.join(linked, 'missing');
+ // The parent fixture's afterAll removes both the target and its link.
+ beforeAll(() => {
+ mkdirSync(checkout, { recursive: true });
+ mkdirSync(projectB, { recursive: true });
+ mkdirSync(projectC, { recursive: true });
+ symlinkSync(base, linked, 'junction');
+ });
+
+ it('merges current checkout/base aliases and ordinary project aliases, preserving the first path and failed-realpath rows', async () => {
+ const canonicalA = await realpath(projectA);
+ const canonicalCheckout = await realpath(checkout);
+ const inherited = {
+ directory: canonicalCheckout,
+ baseRepo: canonicalA,
+ checkoutRoot: canonicalCheckout,
+ realDirectory: canonicalCheckout,
+ commonDir: path.join(canonicalA, '.git'),
+ branch: 'feature',
+ exists: true,
+ dirty: false,
+ isWorktree: true,
+ };
+ vi.mocked(gitExec).mockClear();
+ const result = await readWorkerProjectContext(
+ { id: 'lead', workingDir: canonicalCheckout, worktreePath: checkout },
+ {
+ inherit: async () => inherited,
+ recentDirectories: async () => [
+ path.join(linked, 'proj-a'),
+ projectA,
+ path.join(linked, 'proj-a/.cindy-worktrees/worker'),
+ // Worker history can retain both spellings; the list must show one row.
+ aliasB,
+ projectB,
+ missing,
+ projectC,
+ ],
+ realpath,
+ isDirectory: async (directory) => {
+ try {
+ return (await stat(directory)).isDirectory();
+ } catch {
+ return false;
+ }
+ },
+ },
+ );
+ expect(result.projects.map((row) => row.path)).toEqual([canonicalA, aliasB, missing, projectC]);
+ expect(result.projects[1]).toMatchObject({ path: aliasB, description: aliasB, missing: false });
+ expect(result.projects[2]).toMatchObject({ path: missing, missing: true });
+ expect(result.projects[3]).toMatchObject({ missing: false });
+ expect(gitExec).not.toHaveBeenCalled();
+ });
+});
+
+// Review P1: a subproject Worker must start beside its own rules, after checkout.
+// Unit orchestration with real filesystem/Git probe: a deferred checkout is the
+// smallest input exposing the race; root selections must keep asynchronous startup.
+// A source-branch symlink outside the checkout must not redirect the validated cwd.
+describe('Worker worktree subproject directory', () => {
+ const fixture = mkdtempSync(path.join(os.tmpdir(), 'cindy-worker-subproject-'));
+ const repo = path.join(fixture, 'repo');
+ const alias = path.join(fixture, 'repo-alias');
+ beforeAll(() => {
+ mkdirSync(path.join(repo, 'apps', 'web'), { recursive: true });
+ writeFileSync(path.join(repo, 'apps', 'web', 'AGENTS.md'), 'Subproject rules');
+ mkdirSync(path.join(repo, '..web'));
+ writeFileSync(path.join(repo, '..web', 'AGENTS.md'), 'Dot-prefixed subproject rules');
+ symlinkSync(repo, alias, process.platform === 'win32' ? 'junction' : 'dir');
+ const git = (...args: string[]) => execFileSync('git', args, { cwd: repo, encoding: 'utf8' });
+ git('init', '--initial-branch=main');
+ git('add', '.');
+ git(
+ '-c',
+ 'user.name=Fixture',
+ '-c',
+ '-c',
+ 'commit.gpgsign=false',
+ 'commit',
+ '-m',
+ 'fixture',
+ );
+ });
+ afterAll(() => rmSync(fixture, { recursive: true, force: true }));
+
+ it.each(['subproject', 'dot-prefixed', 'root', 'missing', 'external-symlink'] as const)(
+ 'keeps the correct startup directory for %s',
+ async (scenario) => {
+ const sessionId = `worker-${scenario}`;
+ const target = path.join(fixture, sessionId);
+ mkdirSync(target);
+ vi.mocked(createWorktree).mockResolvedValueOnce({
+ ok: true,
+ meta: {
+ sessionId,
+ path: target,
+ baseRepo: repo,
+ name: sessionId,
+ branch: `cindy/${sessionId}`,
+ sourceBranch: 'main',
+ createdAt: new Date(0).toISOString(),
+ },
+ });
+ const relative = scenario === 'dot-prefixed' ? '..web' : path.join('apps', 'web');
+ const subproject = path.join(target, relative);
+ const present = scenario === 'subproject' || scenario === 'dot-prefixed';
+ let finishCheckout!: () => void;
+ const checkout = new Promise<void>((resolve) => {
+ finishCheckout = resolve;
+ });
+ vi.mocked(awaitBackgroundCheckout).mockReset().mockReturnValue(checkout);
+ const source = scenario === 'root' ? alias : path.join(alias, relative);
+ let settled = false;
+ const result = createWorkerWorktree(sessionId, source, 'main').then((value) => {
+ settled = true;
+ return value;
+ });
+ if (scenario === 'root') {
+ expect(await result).toBe(target);
+ expect(awaitBackgroundCheckout).not.toHaveBeenCalled();
+ finishCheckout();
+ return;
+ }
+ await vi.waitFor(() => expect(awaitBackgroundCheckout).toHaveBeenCalledWith(sessionId));
+ expect(settled).toBe(false);
+ if (present) {
+ mkdirSync(subproject, { recursive: true });
+ writeFileSync(path.join(subproject, 'AGENTS.md'), 'Checked out rules');
+ }
+ if (scenario === 'external-symlink') {
+ const external = path.join(fixture, 'outside-checkout');
+ mkdirSync(external);
+ mkdirSync(path.dirname(subproject), { recursive: true });
+ symlinkSync(external, subproject, process.platform === 'win32' ? 'junction' : 'dir');
+ }
+ finishCheckout();
+ expect(await result).toBe(present ? subproject : target);
+ if (scenario === 'missing' || scenario === 'external-symlink')
+ expect(createLogger('test').warn).toHaveBeenCalledWith(
+ 'Worker subproject is unavailable within the new worktree; using its root',
+ { sessionId },
+ );
+ },
+ );
+});
diff --git a/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts b/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
index dc40aa8512..9ebb0443ac 100644
--- a/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaLifecycleService.ts
@@ -36,8 +36,9 @@ export interface OrcaEnableTeamParams {
workerPermissionMode?: OrcaWorkerPermissionMode;
/** 首个 Worker 放到同账号另一台电脑运行;语义见 OrcaWorkerCreateParams.executionDeviceId。 */
executionDeviceId?: string;
- /** 运行设备上的工作目录;只在指定运行设备时生效。 */
+ /** 显式工作目录;本机可选项目,指定运行设备时为那台电脑上的路径。 */
workingDir?: string;
+ worktree?: OrcaWorkerCreateParams['worktree'];
/** 首个 Worker 的 Agent 所在位置(远程供应商);语义见 OrcaWorkerCreateParams.agentDeviceId。 */
agentDeviceId?: string | null;
}
@@ -163,9 +164,10 @@ function normalizeEnableParams(params: OrcaEnableTeamParams): OrcaWorkerCreatePa
...(params.executionDeviceId
? {
executionDeviceId: params.executionDeviceId,
- ...(params.workingDir ? { workingDir: params.workingDir } : {}),
}
: {}),
+ ...(params.workingDir !== undefined ? { workingDir: params.workingDir } : {}),
+ ...(params.worktree ? { worktree: params.worktree } : {}),
...(params.agentDeviceId !== undefined ? { agentDeviceId: params.agentDeviceId } : {}),
};
}
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
index fa2fb623ec..c9b32b304f 100644
--- a/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts
@@ -1,3 +1,4 @@
+import type { WorkerWorktreeRequest } from '../../shared/orca-worker-project';
import type { AgentKind } from '@cindy/maker-core';
import { isCodexGatewayWireModel, type AuthStrategy } from '@cindy/model-providers';
import path from 'node:path';
@@ -235,6 +236,8 @@ export interface OrcaWorkerCreateParams {
* 指定运行设备时是那台电脑上的目录,缺省由那台按自身设置分配任务目录。
*/
workingDir?: string;
+ /** Local UI only. Omission preserves existing MCP and remote behavior. */
+ worktree?: WorkerWorktreeRequest;
/** 显式值用于本次创建;缺省读取全局 Worker 创建偏好。 */
workerPermissionMode?: OrcaWorkerPermissionMode;
/**
@@ -296,6 +299,8 @@ export interface OrcaWorkerCreationDeps {
getWorkerPermissionMode(): OrcaWorkerPermissionMode;
/** Validate existence and target project policy before reserving or bootstrapping. */
resolveWorkerWorkingDir(dir: string, lead: OrcaLeadSessionSnapshot): Promise<string>;
+ createWorkerWorktree?(sessionId: string, directory: string, sourceBranch: string): Promise<string>;
+ discardWorkerWorktree?(sessionId: string): Promise<void>;
getAvailableModels(agent: AgentKind): OrcaWorkerModelCapabilities[];
/**
* 从同一次 provider registry 读取构造 Worker 路由上下文。
@@ -1064,6 +1069,11 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
if (!lead) {
return { ok: false, errorCode: 'NOT_FOUND', message: `lead session ${params.leadSessionId} not found` };
}
+ if (params.worktree && (lead.remoteHostId || params.executionDeviceId !== undefined
+ || (lead.workspaceKind === 'dialogue' && params.workingDir === undefined)
+ || !deps.createWorkerWorktree || !deps.discardWorkerWorktree)) {
+ return {ok: false, errorCode: 'INVALID_PARAMS', message: 'Worker worktree requires a local project'};
+ }
const workerLocation = resolveWorkerAgentDeviceId(params, lead, deps.isSelfDeviceId);
if (!workerLocation.ok) {
return { ok: false, errorCode: 'INVALID_PARAMS', message: workerLocation.message };
@@ -1518,6 +1528,8 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
}, Math.floor(ORCA_WORKER_CREATION_RESERVATION_LEASE_MS / 3));
renewalTimer.unref?.();
+ let createdWorktreeSessionId: string | undefined;
+ let creationSucceeded = false;
try {
// Registration may race the preflight. Once a reservation exists, a new
// plan cannot be registered; reread any plan that won before reservation.
@@ -1526,6 +1538,11 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
return { ok: false, errorCode: 'WORKER_LIMIT_HARD_EXCEEDED', message: 'Registered plan concurrency reached' };
}
const workerSessionId = deps.createSessionId();
+ if (params.worktree) {
+ createdWorktreeSessionId = workerSessionId;
+ workingDir = await deps.createWorkerWorktree!(workerSessionId, workingDir, params.worktree.sourceBranch);
+ await assertCurrent?.();
+ }
const workerVendorOptions = {
orcaRole: 'worker' as const,
orcaWorkflowId: params.teamId,
@@ -1568,6 +1585,7 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
const bootstrapped = await deps.bootstrapSession(workerOpts);
workerSession = bootstrapped.session;
} catch (err) {
+ if (createdWorktreeSessionId) await cleanupBootstrappedWorkerSession(createdWorktreeSessionId);
return toInternalFailure(err);
}
@@ -1616,6 +1634,7 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
// Carry the resolved spawn facts through lifecycle/accepted callbacks only;
// neither the function nor its closure is part of the public result.
onCreated?.(async () => { await validatePlan(workingDir, resolved); });
+ creationSucceeded = true;
return {
ok: true,
teamId: params.teamId,
@@ -1634,9 +1653,19 @@ export function createOrcaWorkerCreationService(deps: OrcaWorkerCreationDeps): O
agentDeviceId: workerAgentDeviceId,
},
};
+ } catch (err) {
+ if (!params.worktree) throw err;
+ return toInternalFailure(err);
} finally {
- clearInterval(renewalTimer);
- await deps.releaseWorkerCreationReservation(workerId).catch(() => undefined);
+ // Keep the reservation alive until checkout and safe compensation have settled.
+ try {
+ if (createdWorktreeSessionId && !creationSucceeded) {
+ await deps.discardWorkerWorktree!(createdWorktreeSessionId);
+ }
+ } finally {
+ clearInterval(renewalTimer);
+ await deps.releaseWorkerCreationReservation(workerId).catch(() => undefined);
+ }
}
}
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerProject.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerProject.ts
new file mode 100644
index 0000000000..436064f774
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerProject.ts
@@ -0,0 +1,291 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { app } from 'electron';
+import { createOverrideSettingsFile } from '../maker-host/override-settings-file';
+import { createLogger } from '../logger';
+import { getCurrentDbClientSnapshot } from '../localDb/client/current';
+import { listRecentWorkdirs } from '../localDb/ipc/recentWorkdirs';
+import {
+ resolveSessionGitDirLive,
+ resolveWorkerInheritedDirectory,
+ type WorkerProjectProbe,
+} from '../git-context/sessionDirResolver';
+import { gitExec } from '../worktree/gitExec';
+import * as WorktreeManager from '../worktree/WorktreeManager';
+import type { WorkerProjectContext } from '../../shared/orca-worker-project';
+
+const log = createLogger('orca-worker-project');
+const stripEol = (value: string) => value.replace(/[\r\n]+$/, '');
+const identity = (value: string) => (process.platform === 'win32' ? value.toLowerCase() : value);
+
+export async function probeWorkerProject(
+ directory: string,
+ details = true,
+): Promise<WorkerProjectProbe> {
+ const result: WorkerProjectProbe = {
+ directory,
+ baseRepo: null as string | null,
+ branch: null as string | null,
+ exists: false,
+ dirty: false,
+ isWorktree: false,
+ worktreeName: undefined as string | undefined,
+ commonDir: null as string | null,
+ checkoutRoot: null as string | null,
+ realDirectory: null as string | null,
+ };
+ try {
+ result.exists = (await fs.stat(directory)).isDirectory();
+ if (result.exists) result.realDirectory = await fs.realpath(directory);
+ } catch {
+ return result;
+ }
+ if (!result.exists) return result;
+ try {
+ const options = { timeoutMs: 5000 };
+ const { stdout } = await gitExec(
+ ['rev-parse', '--path-format=absolute', '--show-toplevel', '--git-common-dir', '--git-dir'],
+ directory,
+ options,
+ );
+ const [root, common, gitDir] = stripEol(stdout).split(/\r?\n/);
+ result.checkoutRoot = await fs.realpath(root);
+ result.commonDir = await fs.realpath(common);
+ result.isWorktree = identity(await fs.realpath(gitDir)) !== identity(result.commonDir);
+ if (result.isWorktree) result.worktreeName = path.basename(root);
+ // worktree list's first entry is the main checkout (also handles separate git dirs).
+ const { stdout: list } = await gitExec(
+ ['worktree', 'list', '--porcelain', '-z'],
+ directory,
+ options,
+ );
+ const first = list.split('\0').find((line) => line.startsWith('worktree '));
+ result.baseRepo = first ? first.slice(9) : root;
+ if (!details) return result;
+ const { stdout: status } = await gitExec(
+ ['status', '--porcelain=v2', '--branch', '--untracked-files=normal'],
+ directory,
+ options,
+ );
+ const lines = stripEol(status).split(/\r?\n/);
+ const oid = lines.find((line) => line.startsWith('# branch.oid '))?.slice(13);
+ const head = lines.find((line) => line.startsWith('# branch.head '))?.slice(14);
+ if (oid === '(initial)') {
+ result.headState = 'unborn';
+ } else if (oid && head) {
+ result.headState = head === '(detached)' ? 'detached' : 'branch';
+ result.branch = result.headState === 'detached' ? oid : head;
+ }
+ result.dirty = lines.some((line) => line.length > 0 && !line.startsWith('# '));
+ } catch {
+ /* Non-Git directories remain valid projects. */
+ }
+ return result;
+}
+
+// Device-local history, partitioned by the database data owner. No defaults are persisted.
+const recents = createOverrideSettingsFile<{ byOwner: Record<string, string[]> }>({
+ filePath: () => path.join(app.getPath('userData'), 'orca-worker-projects.json'),
+ defaults: { byOwner: {} },
+ normalize: (raw) => {
+ const values = (raw as { byOwner?: Record<string, unknown> } | null)?.byOwner ?? {};
+ return {
+ byOwner: Object.fromEntries(
+ Object.entries(values).map(([owner, dirs]) => [
+ owner,
+ Array.isArray(dirs)
+ ? [
+ ...new Set(
+ dirs.filter(
+ (dir): dir is string => typeof dir === 'string' && path.isAbsolute(dir),
+ ),
+ ),
+ ].slice(0, 10)
+ : [],
+ ]),
+ ),
+ };
+ },
+ log,
+ label: 'worker project history',
+ logLoadedValue: false,
+});
+
+const normalizedPath = (directory: string) => identity(path.resolve(directory));
+
+async function mapProjectDirectories<T>(
+ directories: string[],
+ read: (directory: string) => Promise<T>,
+): Promise<T[]> {
+ const results: T[] = new Array(directories.length);
+ let next = 0;
+ await Promise.all(
+ Array.from({ length: Math.min(4, directories.length) }, async () => {
+ while (next < directories.length) {
+ const index = next++;
+ results[index] = await read(directories[index]!);
+ }
+ }),
+ );
+ return results;
+}
+
+async function projectPathIdentity(
+ directory: string,
+ realpath: (directory: string) => Promise<string>,
+): Promise<string> {
+ try {
+ return normalizedPath(await realpath(directory));
+ } catch {
+ return normalizedPath(directory);
+ }
+}
+
+export async function rememberWorkerProject(directory: string, owner: string): Promise<void> {
+ await recents.updateAtomic(({ value }) => {
+ const seen = new Set<string>();
+ return {
+ byOwner: {
+ ...value.byOwner,
+ [owner]: [directory, ...(value.byOwner[owner] ?? [])]
+ .filter((value) => {
+ const key = normalizedPath(value);
+ if (seen.has(key)) return false;
+ seen.add(key);
+ return true;
+ })
+ .slice(0, 10),
+ },
+ };
+ });
+}
+
+type ProjectLead = Parameters<typeof resolveWorkerInheritedDirectory>[0] & {
+ workspaceKind?: string | null;
+};
+interface WorkerProjectContextDependencies {
+ inherit(lead: ProjectLead): Promise<WorkerProjectProbe>;
+ recentDirectories(): Promise<string[]>;
+ isDirectory(directory: string): Promise<boolean>;
+ realpath(directory: string): Promise<string>;
+}
+const contextDependencies: WorkerProjectContextDependencies = {
+ realpath: (directory) => fs.realpath(directory),
+ inherit: (lead) =>
+ resolveWorkerInheritedDirectory(lead, {
+ infer: resolveSessionGitDirLive,
+ probe: probeWorkerProject,
+ }),
+ recentDirectories: async () => {
+ const snapshot = getCurrentDbClientSnapshot();
+ if (!snapshot) throw new Error('DbClient not ready');
+ recents.invalidateIfChanged();
+ const recent = await listRecentWorkdirs(snapshot.client);
+ return [...(recents.read().byOwner[snapshot.userId] ?? []), ...recent.map((row) => row.path)];
+ },
+ isDirectory: async (directory) => {
+ try {
+ return (await fs.stat(directory)).isDirectory();
+ } catch {
+ return false;
+ }
+ },
+};
+
+/** Open-time snapshot. Recent projects already store roots; never run Git for list rows. */
+export async function readWorkerProjectContext(
+ lead: ProjectLead,
+ deps: WorkerProjectContextDependencies = contextDependencies,
+): Promise<WorkerProjectContext> {
+ const [inherited, recent] = await Promise.all([deps.inherit(lead), deps.recentDirectories()]);
+ const current = inherited.baseRepo ?? lead.workingDir ?? '';
+ const aliases = [
+ current,
+ lead.workingDir,
+ lead.worktreePath,
+ inherited.directory,
+ inherited.checkoutRoot,
+ ].filter((directory): directory is string => !!directory);
+ const paths = [
+ ...new Map(
+ [...aliases, ...recent].filter(Boolean).map((value) => [normalizedPath(value), value]),
+ ).values(),
+ ];
+ const keys = await mapProjectDirectories(paths, (value) =>
+ projectPathIdentity(value, deps.realpath),
+ );
+ const identities = new Map(paths.map((value, index) => [normalizedPath(value), keys[index]!]));
+ const currentAliases = new Set(aliases.map((value) => identities.get(normalizedPath(value))!));
+ const seen = new Set<string>();
+ const directories: string[] = [];
+ for (const value of [current, ...recent]) {
+ if (!value) continue;
+ const key = identities.get(normalizedPath(value))!;
+ // Checkout/base-repository identities belong to the same current-project row.
+ const projectKey = currentAliases.has(key) ? identities.get(normalizedPath(current))! : key;
+ if (seen.has(projectKey)) continue;
+ seen.add(projectKey);
+ // Identity is canonical, but labels and submitted paths keep the original spelling.
+ directories.push(currentAliases.has(key) ? current : value);
+ }
+ const projects = await mapProjectDirectories(directories, async (directory) => ({
+ path: directory,
+ name: path.basename(directory) || directory,
+ description: directory,
+ missing: !(await deps.isDirectory(directory)),
+ }));
+
+ return {
+ recordedDirectory: lead.workingDir ?? '',
+ inherited,
+ selected: inherited,
+ dialogue: lead.workspaceKind === 'dialogue',
+ projects,
+ };
+}
+
+export async function createWorkerWorktree(
+ sessionId: string,
+ directory: string,
+ sourceBranch: string,
+): Promise<string> {
+ const info = await probeWorkerProject(directory);
+ if (!info.baseRepo) throw new Error('Worker worktree requires a Git repository');
+ const created = await WorktreeManager.createWorktree(
+ { sessionId, baseRepo: info.baseRepo, name: '', sourceBranch },
+ { trackBackgroundCheckout: true },
+ );
+ if (!created.ok) throw new Error(`Worker worktree creation failed: ${created.error.message}`);
+ // Probe paths are realpaths, so a symlink spelling cannot change the subproject offset.
+ const relative =
+ info.checkoutRoot && info.realDirectory
+ ? path.relative(info.checkoutRoot, info.realDirectory)
+ : '';
+ if (!relative) return created.meta.path;
+
+ // Stage checkout only includes root startup files. A subproject and its rules need
+ // the full checkout; root-directory Workers keep the normal asynchronous startup.
+ await WorktreeManager.awaitBackgroundCheckout(sessionId);
+ const subproject = path.join(created.meta.path, relative);
+ try {
+ const [realRoot, realSubproject] = await Promise.all([
+ fs.realpath(created.meta.path),
+ fs.realpath(subproject),
+ ]);
+ const withinRoot = path.relative(identity(realRoot), identity(realSubproject));
+ if (
+ withinRoot &&
+ withinRoot !== '..' &&
+ !withinRoot.startsWith(`..${path.sep}`) &&
+ !path.isAbsolute(withinRoot) &&
+ (await fs.stat(realSubproject)).isDirectory()
+ )
+ return subproject;
+ } catch {
+ // The selected source branch may not contain this subproject.
+ }
+ log.warn('Worker subproject is unavailable within the new worktree; using its root', {
+ sessionId,
+ });
+ return created.meta.path;
+}
diff --git a/apps/desktop/src/main/maker-ipc/orcaWorkerProjectHandlers.ts b/apps/desktop/src/main/maker-ipc/orcaWorkerProjectHandlers.ts
new file mode 100644
index 0000000000..fabe0baa4a
--- /dev/null
+++ b/apps/desktop/src/main/maker-ipc/orcaWorkerProjectHandlers.ts
@@ -0,0 +1,152 @@
+import path from 'node:path';
+import type {
+ WorkerProjectContext,
+ WorkerProjectInfo,
+ WorkerWorktreeRequest,
+} from '../../shared/orca-worker-project';
+import { throwIpcError } from '../utils/ipcValidate';
+
+interface ProjectSession {
+ id: string;
+ workingDir: string | null;
+ worktreePath?: string | null;
+ workspaceKind?: string | null;
+ remoteHostId?: string | null;
+ orcaRole?: string | null;
+}
+
+interface WorkerProjectHandlerDeps<Event, Owner> {
+ isDeviceLinkInvoke(): boolean;
+ assertTrustedAppRendererEvent(event: Event): void;
+ getOwner(): Owner | null;
+ getSession(owner: Owner, id: string): Promise<ProjectSession | undefined>;
+ getTeamByWorkerSession(id: string): Promise<{ leadSessionId: string } | null>;
+ readContext(lead: ProjectSession): Promise<WorkerProjectContext>;
+ probe(directory: string, details: boolean): Promise<WorkerProjectInfo>;
+ remember(directory: string, ownerId: string): Promise<void>;
+ log: { warn(message: string, meta: Record<string, unknown>): void };
+}
+
+/** Local project IPC adapters. Legacy requests bypass local-only reads and retain their wire semantics. */
+export function createOrcaWorkerProjectHandlers<Event, Owner extends { userId: string }>(
+ deps: WorkerProjectHandlerDeps<Event, Owner>,
+) {
+ // Local-only project reads. These channels intentionally do not enter device-link's allowlist.
+ async function localWorkerProjectLead(event: Event, id: unknown) {
+ if (deps.isDeviceLinkInvoke()) throwIpcError('PERMISSION_DENIED', 'Local project UI required');
+ deps.assertTrustedAppRendererEvent(event);
+ if (typeof id !== 'string' || !id || id.length > 128)
+ throwIpcError('INVALID_PARAMS', 'leadSessionId required');
+ const owner = deps.getOwner();
+ if (!owner) throwIpcError('INTERNAL', 'Task storage unavailable');
+ const lead = await deps.getSession(owner, id);
+ if (deps.getOwner() !== owner) throwIpcError('PERMISSION_DENIED', 'Account changed');
+ if (!lead || lead.remoteHostId) throwIpcError('INVALID_PARAMS', 'Local project required');
+ return { lead, owner };
+ }
+
+ async function context(event: Event, id: unknown, directory?: unknown) {
+ const { lead, owner } = await localWorkerProjectLead(event, id);
+ if (
+ directory !== undefined &&
+ (typeof directory !== 'string' || !path.isAbsolute(directory) || directory.length > 32768)
+ ) {
+ throwIpcError('INVALID_PARAMS', 'Absolute project directory required');
+ }
+ // A project change reads only its target; the renderer retains this opening's list.
+ const context =
+ typeof directory === 'string'
+ ? await deps.probe(directory, true)
+ : await deps.readContext(lead);
+ if (deps.getOwner() !== owner) throwIpcError('PERMISSION_DENIED', 'Account changed');
+ return context;
+ }
+
+ async function label(event: Event, workerSessionId: unknown) {
+ const { lead: worker, owner } = await localWorkerProjectLead(event, workerSessionId);
+ if (worker.orcaRole !== 'worker') return null;
+ const team = await deps.getTeamByWorkerSession(worker.id);
+ if (!team) return null;
+ const { lead } = await localWorkerProjectLead(event, team.leadSessionId);
+ if (!worker.workingDir || !lead.workingDir) return null;
+ const [workerProject, leadProject] = await Promise.all([
+ deps.probe(worker.workingDir, false),
+ deps.probe(lead.workingDir, false),
+ ]);
+ if (deps.getOwner() !== owner) throwIpcError('PERMISSION_DENIED', 'Account changed');
+ const workerBase = workerProject.baseRepo ?? worker.workingDir;
+ const leadBase = leadProject.baseRepo ?? lead.workingDir;
+ const sameProject =
+ process.platform === 'win32'
+ ? workerBase.toLowerCase() === leadBase.toLowerCase()
+ : workerBase === leadBase;
+ return sameProject ? null : { name: path.basename(workerBase), path: workerBase };
+ }
+
+ // Parse only the local project extension; callers retain legacy request parsing and
+ // lifecycle dispatch, and invoke remember only after successful Worker creation.
+ async function localWorkerProjectOptions(
+ event: Event,
+ id: string,
+ body: Record<string, unknown>,
+ ) {
+ const requested =
+ body.worktree !== undefined ||
+ body.projectPath !== undefined ||
+ (body.workingDir !== undefined && !body.executionDeviceId);
+ if (!requested) return { fields: {}, remember: async () => {} };
+ const { lead, owner } = await localWorkerProjectLead(event, id);
+ if (body.executionDeviceId)
+ throwIpcError('INVALID_PARAMS', 'Worker project options require local execution');
+ if (
+ body.workingDir !== undefined &&
+ (typeof body.workingDir !== 'string' ||
+ !path.isAbsolute(body.workingDir) ||
+ body.workingDir.length > 32768)
+ ) {
+ throwIpcError('INVALID_PARAMS', 'Absolute workingDir required');
+ }
+ if (
+ body.projectPath !== undefined &&
+ (typeof body.projectPath !== 'string' ||
+ !path.isAbsolute(body.projectPath) ||
+ body.projectPath.length > 32768)
+ ) {
+ throwIpcError('INVALID_PARAMS', 'Absolute projectPath required');
+ }
+ let worktree: WorkerWorktreeRequest | undefined;
+ if (body.worktree !== undefined) {
+ const source = (body.worktree as WorkerWorktreeRequest | null)?.sourceBranch;
+ if (
+ typeof source !== 'string' ||
+ !source ||
+ source.length > 1024 ||
+ source.startsWith('-') ||
+ Array.from(source).some((character) => character.charCodeAt(0) < 32)
+ ) {
+ throwIpcError('INVALID_PARAMS', 'Worktree sourceBranch required');
+ }
+ if (lead.workspaceKind === 'dialogue' && body.workingDir === undefined)
+ throwIpcError('INVALID_PARAMS', 'Worker worktree requires a project');
+ worktree = { sourceBranch: source };
+ }
+ return {
+ fields: {
+ ...(typeof body.workingDir === 'string' ? { workingDir: body.workingDir } : {}),
+ ...(worktree ? { worktree } : {}),
+ },
+ remember: async () => {
+ if (typeof body.projectPath !== 'string' || deps.getOwner() !== owner) return;
+ try {
+ await deps.remember(body.projectPath, owner.userId);
+ } catch (error) {
+ deps.log.warn('Worker project history could not be saved', {
+ error: error instanceof Error ? error.message : String(error),
+ });
+ }
+ },
+ };
+ }
+
+ return { context, label, options: localWorkerProjectOptions };
+}
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 60daa876a7..d56201e1cc 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -1,3 +1,7 @@
+import { createOrcaWorkerProjectHandlers } from './orcaWorkerProjectHandlers';
+import { getTeamByWorkerSession } from '../localDb/orcaTeamStore';
+import { readWorkerProjectContext, createWorkerWorktree, rememberWorkerProject, probeWorkerProject } from './orcaWorkerProject';
+import type { WorkerWorktreeRequest } from '../../shared/orca-worker-project';
import { captureAgentRequest as captureRequest, type CapturedAgentRequest } from './forwardedRequest.js';
import type { AgentRequestReceipt } from '../../shared/forwardedRequest.js';
import { configureBotTodoDispatch, settleBotTodoForSession } from './botTodoAccess.js';
@@ -2710,6 +2714,7 @@ interface EnableOrcaOptions {
workingDir?: string;
/** 首个 Worker 的 Agent 所在位置(远程供应商);语义见 OrcaWorkerCreateParams.agentDeviceId。 */
agentDeviceId?: string | null;
+ worktree?: WorkerWorktreeRequest;
}
let orcaCollabServiceHolder: OrcaCollabService | null = null;
@@ -10807,9 +10812,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
...(opts.executionDeviceId
? {
executionDeviceId: opts.executionDeviceId,
- ...(opts.workingDir ? { workingDir: opts.workingDir } : {}),
}
: {}),
+ ...(opts.workingDir !== undefined ? { workingDir: opts.workingDir } : {}),
+ ...(opts.worktree ? { worktree: opts.worktree } : {}),
...(opts.agentDeviceId !== undefined ? { agentDeviceId: opts.agentDeviceId } : {}),
});
if (!result.ok) throwOrcaServiceFailure(result);
@@ -13967,6 +13973,25 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
getCoordinator: () => inputCoordinator,
});
+ const workerProjectHandlers = createOrcaWorkerProjectHandlers({
+ isDeviceLinkInvoke,
+ assertTrustedAppRendererEvent,
+ getOwner: getCurrentDbClientSnapshot,
+ getSession: async (owner, id) => {
+ const [session] = await owner.client.drizzle
+ .select()
+ .from(sessions)
+ .where(eq(sessions.id, id))
+ .limit(1);
+ return session;
+ },
+ getTeamByWorkerSession,
+ readContext: readWorkerProjectContext,
+ probe: probeWorkerProject,
+ remember: rememberWorkerProject,
+ log,
+ });
+
ipcMain.handle(
MAKER_INVOKE.SESSION_ENABLE_ORCA,
async (_e, leadSessionId: unknown, opts: unknown) => {
@@ -13985,6 +14010,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
deferDelegateTask?: unknown;
executionDeviceId?: unknown;
workingDir?: unknown;
+ worktree?: unknown;
+ projectPath?: unknown;
agentDeviceId?: unknown;
};
const workerAgent: AgentKind =
@@ -13999,7 +14026,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
if (body.deferDelegateTask !== undefined && typeof body.deferDelegateTask !== 'boolean') {
throwIpcError('INVALID_PARAMS', 'deferDelegateTask must be a boolean');
}
- return enableOrcaInternal(leadSessionId, {
+ const project = await workerProjectHandlers.options(_e, leadSessionId, body);
+ const result = await enableOrcaInternal(leadSessionId, {
+ ...project.fields,
workerAgent,
delegateTask,
role: typeof body.role === 'string' ? body.role : undefined,
@@ -14026,6 +14055,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 首个 Worker 的 Agent 所在位置(远程供应商);旧控制端不带 = 跟 Lead。
...pickWorkerAgentDeviceId(body.agentDeviceId),
});
+ await project.remember();
+ return result;
},
);
@@ -14244,6 +14275,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
return disableOrcaInternal(leadSessionId);
});
+ // Local-only reads: intentionally absent from the device-link allowlist.
+ ipcMain.handle('maker:worker:project-context', workerProjectHandlers.context);
+ ipcMain.handle('maker:worker:project-label', workerProjectHandlers.label);
+
// ─── Orca worker IPC handlers ────────────────────────────────────────────
ipcMain.handle(MAKER_INVOKE.WORKER_CREATE, async (_e, body: unknown) => {
@@ -14268,8 +14303,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
) {
throwIpcError('INVALID_PARAMS', 'workerPermissionMode must be auto or bypassPermissions');
}
+ const project = await workerProjectHandlers.options(_e, b.leadSessionId, b);
await assertLeadCollabProjectEnabled(b.leadSessionId);
const result = await orcaLifecycleService.createWorker({
+ ...project.fields,
leadSessionId: b.leadSessionId,
role: b.role,
agent,
@@ -14298,6 +14335,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
...pickWorkerAgentDeviceId(b.agentDeviceId),
});
if (!result.ok) throwOrcaServiceFailure(result);
+ await project.remember();
return {
ok: true,
workerId: result.workerId,
@@ -14743,6 +14781,31 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
return { permissionMode: pluginId === null ? undefined : 'auto' as const, assertCurrent };
};
+ async function discardWorkerWorktree(sessionId: string): Promise<void> {
+ await withSendToSessionLock(sessionId, async () => {
+ await worktreeManager.awaitBackgroundCheckout(sessionId);
+ const meta = worktreeManager.getForSession(sessionId);
+ const result = await worktreeManager.cancelPrecreatedWorktree(
+ sessionId,
+ { path: meta?.path },
+ {
+ canRemove: async () => {
+ if (maker.getSession(sessionId)) return false;
+ const [row] = await getDbClient()
+ .drizzle.select({ status: sessions.status })
+ .from(sessions)
+ .where(eq(sessions.id, sessionId))
+ .limit(1);
+ return !row || row.status === 'archived';
+ },
+ },
+ );
+ if (result.status === 'preserved' || result.status === 'path-mismatch') {
+ log.warn('Failed Worker worktree was preserved', { sessionId, status: result.status });
+ }
+ });
+ }
+
const orcaWorkerCreationService = createOrcaWorkerCreationService({
withLeadSendLock: withSendToSessionLock,
getActiveTeamByLead,
@@ -14853,6 +14916,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
);
return resolved;
},
+ createWorkerWorktree,
+ discardWorkerWorktree,
getAvailableModels: (agent) => maker.getCapabilities(agent).availableModels,
getProviderRoutingContext: async (agent, remoteHostId, agentDeviceId) => agentDeviceId && !remoteHostId
// Worker 的 Agent 在另一台电脑(或分享)运行:模型与来源按那台的目录。
@@ -14991,7 +15056,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
forgetKnownOrcaWorkerSession(workerSessionId);
await archiveSingleWorkerSession(workerSessionId).catch(() => undefined);
- await removeWorker(workerId);
+ try {
+ await removeWorker(workerId);
+ } finally {
+ if (worktreeManager.getForSession(workerSessionId)) await discardWorkerWorktree(workerSessionId);
+ }
},
broadcastSessionCreated,
broadcastOrcaWorkerChanged: (leadSessionId) => {
diff --git a/apps/desktop/src/main/worktree/WorktreeManager.ts b/apps/desktop/src/main/worktree/WorktreeManager.ts
index 8dc4ec0e0e..a24b6f33dc 100644
--- a/apps/desktop/src/main/worktree/WorktreeManager.ts
+++ b/apps/desktop/src/main/worktree/WorktreeManager.ts
@@ -1045,15 +1045,21 @@ export async function copyClaudeSiviDirs(
* (不再无条件写全局 safe.directory:dubious-ownership 时由 gitExec 幂等按需处理;
* 删除/归档时由 removeWorktreeForSession 清理该 path 的条目, 见 #2627)
*/
-export async function createWorktree(req: CreateWorktreeReq): Promise<CreateWorktreeResp> {
+// Only opt-in creators retain a handle for failure compensation; normal startup stays asynchronous.
+const backgroundCheckouts = new Map<string, Promise<void>>();
+export async function awaitBackgroundCheckout(sessionId: string): Promise<void> {
+ await backgroundCheckouts.get(sessionId)?.catch(() => undefined);
+}
+
+export async function createWorktree(req: CreateWorktreeReq, options?: { trackBackgroundCheckout?: boolean }): Promise<CreateWorktreeResp> {
const create = () => withCreateWorktreeQueue(req.baseRepo, () => {
assertPrecreatedSessionNotCancelled(req.sessionId);
- return createWorktreeInner(req);
+ return createWorktreeInner(req, options);
});
return withPrecreatedWorktreeOperationQueue(req.sessionId, create);
}
-async function createWorktreeInner(req: CreateWorktreeReq): Promise<CreateWorktreeResp> {
+async function createWorktreeInner(req: CreateWorktreeReq, options?: { trackBackgroundCheckout?: boolean }): Promise<CreateWorktreeResp> {
const snap: CreatedSnapshot = {};
const totalStartedAt = Date.now();
try {
@@ -1198,6 +1204,13 @@ async function createWorktreeInner(req: CreateWorktreeReq): Promise<CreateWorktr
(pid) => recordWorktreeRuntimeLeaseChild(checkoutLease, pid),
));
bgPromise = stageRes.fullCheckoutPromise.finally(() => releaseWorktreeRuntimeLease(checkoutLease));
+ if (options?.trackBackgroundCheckout) {
+ const settled = bgPromise.catch(() => undefined);
+ backgroundCheckouts.set(req.sessionId, settled);
+ void settled.finally(() => {
+ if (backgroundCheckouts.get(req.sessionId) === settled) backgroundCheckouts.delete(req.sessionId);
+ });
+ }
} catch (err) {
await releaseWorktreeRuntimeLease(checkoutLease);
// stageCheckout 内部已记 warn, 这里再保险记一条; 不视为致命
@@ -1213,6 +1226,7 @@ async function createWorktreeInner(req: CreateWorktreeReq): Promise<CreateWorktr
try {
await timed('configure hooks', () => configureHooksPath(worktreePath, baseRepo));
} catch (err) {
+ if (options?.trackBackgroundCheckout) await awaitBackgroundCheckout(req.sessionId);
await rollbackPartialCreate(snap);
return { ok: false, error: classifyError(classifyAny(err)) };
}
@@ -1275,6 +1289,8 @@ async function createWorktreeInner(req: CreateWorktreeReq): Promise<CreateWorktr
return { ok: true, meta };
});
} catch (err) {
+ // Failed worker creation must also wait when metadata has not been published yet.
+ if (options?.trackBackgroundCheckout) await awaitBackgroundCheckout(req.sessionId);
// 兜底: 任何未捕获的异常走 classifier + rollback
await rollbackPartialCreate(snap);
log.warn(
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index d232ef3db6..d0146991d7 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -5892,6 +5892,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
ipcRenderer.invoke('local-db:session-share:classify-path', request),
},
orcaWorkflows: {
+ projectContext: (leadSessionId: string, directory?: string) => ipcRenderer.invoke('maker:worker:project-context', leadSessionId, directory),
+ projectLabel: (workerSessionId: string) => ipcRenderer.invoke('maker:worker:project-label', workerSessionId),
getByLeadSession: (leadSessionId: string): Promise<unknown> =>
ipcRenderer.invoke('local-db:orca-workflows:get-by-lead', leadSessionId),
getByWorkerSession: (workerSessionId: string): Promise<unknown> =>
@@ -6949,6 +6951,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
executionDeviceId?: string;
/** 运行设备上的工作目录;缺省由那台分配。 */
workingDir?: string;
+ worktree?: import('../shared/orca-worker-project').WorkerWorktreeRequest;
+ projectPath?: string;
/** 首个 Worker 的 Agent 所在电脑(远程供应商);null = 任务所在电脑,缺省 = 跟 Lead。 */
agentDeviceId?: string | null;
},
diff --git a/apps/desktop/src/preload/sidebarWindowPreload.ts b/apps/desktop/src/preload/sidebarWindowPreload.ts
index a145171bb0..5e1470a146 100644
--- a/apps/desktop/src/preload/sidebarWindowPreload.ts
+++ b/apps/desktop/src/preload/sidebarWindowPreload.ts
@@ -558,6 +558,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
onChanged: (cb: (payload: unknown, ownerStamp?: unknown) => void): (() => void) => onPayloadWithMetadata('local-db:subagent-runs:changed', cb),
},
orcaWorkflows: {
+ projectLabel: (workerSessionId: string) => ipcRenderer.invoke('maker:worker:project-label', workerSessionId),
getByLeadSession: (id: string): Promise<unknown> => ipcRenderer.invoke('local-db:orca-workflows:get-by-lead', id),
getByWorkerSession: (id: string): Promise<unknown> => ipcRenderer.invoke('local-db:orca-workflows:get-by-worker-session', id),
listWorkersByLead: (id: string): Promise<unknown> => ipcRenderer.invoke('local-db:orca-workflows:list-workers-by-lead', id),
diff --git a/apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx b/apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx
index 86267643d4..af2cd21696 100644
--- a/apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx
@@ -139,6 +139,8 @@ interface FolderPickerPopoverProps {
option?: FolderPickerOption,
) => void | Promise<void>;
projectOptions?: readonly FolderPickerOption[];
+ allowDialogue?: boolean;
+ allowRemove?: boolean;
/**
* 非空 = 项目区列的是这台对端设备的项目(本机时不传)。只用于空态文案与「浏览文件夹」
* 的目标设备,行本身的归属仍看每个 option 的 remoteDevice。
@@ -163,6 +165,8 @@ export function FolderPickerPopover({
onOpenChange,
onSelect,
projectOptions,
+ allowDialogue = true,
+ allowRemove = true,
deviceScope,
onRemoveRemoteProject,
onAddRemoteProject,
@@ -179,6 +183,7 @@ export function FolderPickerPopover({
const selectionPendingRef = useRef(false);
const [selectionPending, setSelectionPending] = useState(false);
const [projectQuery, setProjectQuery] = useState('');
+ const [browseFailed, setBrowseFailed] = useState(false);
const projectSearchRef = useRef<HTMLInputElement>(null);
// 用 state 持有列表元素:内容经 Radix Portal 渲染,首个 commit 时还没挂进 DOM,
// 普通 ref 配依赖数组的 effect 会在元素出现前测量一次,之后列表不变就再也不测。
@@ -194,7 +199,10 @@ export function FolderPickerPopover({
// 每次打开都从完整列表开始,不残留上次的搜索词。
useEffect(() => {
- if (!open) setProjectQuery('');
+ if (!open) {
+ setProjectQuery('');
+ setBrowseFailed(false);
+ }
}, [open]);
// 项目异步到达(远程设备首读、本机首次加载)时搜索框晚于弹层出现,onOpenAutoFocus 已错过。
@@ -261,7 +269,7 @@ export function FolderPickerPopover({
};
const renderProject = (project: FolderPickerOption, index: number) => {
- const canRemove = !project.remoteDevice || onRemoveRemoteProject !== undefined;
+ const canRemove = allowRemove && (!project.remoteDevice || onRemoveRemoteProject !== undefined);
// 有搜索词时首个结果常亮:回车选中的就是它。
const isEnterTarget = activeProjectQuery !== '' && index === 0;
return (
@@ -362,7 +370,12 @@ export function FolderPickerPopover({
onOpenChange(false);
return;
}
- const result = await window.electronAPI.showOpenDirectoryDialog();
+ setBrowseFailed(false);
+ const result = await window.electronAPI.showOpenDirectoryDialog().catch(() => {
+ setBrowseFailed(true);
+ return undefined;
+ });
+ if (!result) return;
if (!result.canceled && result.path) {
await handleSelectPath(result.path, 'browse');
}
@@ -405,26 +418,30 @@ export function FolderPickerPopover({
>
{isProjectPicker && (
<>
- <div className="px-3 py-2">
- <span className="text-xs font-normal text-[var(--folder-label)]">
- {t('newChat.folderPicker.dialogueOrSelectProject')}
- </span>
- </div>
- <button
- type="button"
- disabled={selectionPending}
- onClick={() => handleSelectPath('', 'dialogue')}
- className={cn(
- 'flex w-full items-center gap-3 rounded-[8px] px-3 py-[10px] text-left',
- 'transition-colors outline-none',
- 'hover:bg-[var(--folder-item-hover)]',
- )}
- >
- <MessageCircle size={20} className="shrink-0 text-[var(--folder-item-icon)]" />
- <span className="relative top-px text-sm font-medium text-[var(--folder-item-name)]">
- {t('newChat.folderPicker.dialogue')}
- </span>
- </button>
+ {allowDialogue && (
+ <>
+ <div className="px-3 py-2">
+ <span className="text-xs font-normal text-[var(--folder-label)]">
+ {t('newChat.folderPicker.dialogueOrSelectProject')}
+ </span>
+ </div>
+ <button
+ type="button"
+ disabled={selectionPending}
+ onClick={() => handleSelectPath('', 'dialogue')}
+ className={cn(
+ 'flex w-full items-center gap-3 rounded-[8px] px-3 py-[10px] text-left',
+ 'transition-colors outline-none',
+ 'hover:bg-[var(--folder-item-hover)]',
+ )}
+ >
+ <MessageCircle size={20} className="shrink-0 text-[var(--folder-item-icon)]" />
+ <span className="relative top-px text-sm font-medium text-[var(--folder-item-name)]">
+ {t('newChat.folderPicker.dialogue')}
+ </span>
+ </button>
+ </>
+ )}
<div className="px-3 pb-1 pt-3">
<span className="text-xs font-normal text-[var(--folder-label)]">
{t('newChat.folderPicker.projects')}
@@ -592,6 +609,13 @@ export function FolderPickerPopover({
</>
)}
+ {browseFailed && (
+ <ErrorNotice
+ role="alert"
+ className="mx-1"
+ message={t('newChat.folderPicker.browseFailed')}
+ />
+ )}
{/* Choose a different folder */}
<button
type="button"
diff --git a/apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx b/apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx
index 093f762d7d..5be10ddf4f 100644
--- a/apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx
@@ -416,8 +416,10 @@ function FolderChipBig({
// ── [分支 │ ☑ worktree] 联合控件(对齐 Claude Code,2026-07-29 用户裁决) ──────
-function BranchWorktreeChip({
+export function BranchWorktreeChip({
branchLabel,
+ branchDisplayLabel = branchLabel,
+ branchOnly = false,
branches,
branchesLoading,
branchesFailed,
@@ -433,6 +435,9 @@ function BranchWorktreeChip({
compact,
}: {
branchLabel: string;
+ /** Display text only; branchLabel remains the selection value. */
+ branchDisplayLabel?: string;
+ branchOnly?: boolean;
branches: string[];
branchesLoading: boolean;
/** 上次分支列表请求失败(区分于"仓库没分支"),菜单给重试入口。 */
@@ -552,7 +557,7 @@ function BranchWorktreeChip({
aria-label={t('newChat.branchChip.label')}
>
<GitBranch size={compact ? 12 : 15} className="shrink-0" />
- <span className="min-w-0 truncate">{branchLabel}</span>
+ <span className="min-w-0 truncate" title={branchDisplayLabel}>{branchDisplayLabel}</span>
{branchInteractive && (
<ChevronDown
size={12}
@@ -788,6 +793,7 @@ function BranchWorktreeChip({
)}
>
{branchArea}
+ {!branchOnly && <>
{/* 悬停激活任一半区时分隔线隐去,让 hover 填充看起来是一体的(对齐 Claude Code)。 */}
<span
aria-hidden
@@ -797,6 +803,7 @@ function BranchWorktreeChip({
)}
/>
{checkboxArea}
+ </>}
</div>
);
}
diff --git a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
index d59885aee1..f8621f0a49 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
@@ -3169,9 +3169,11 @@ function CCAgentSessionContent({
...(form.executionDeviceId
? {
executionDeviceId: form.executionDeviceId,
- ...(form.workingDir ? { workingDir: form.workingDir } : {}),
}
: {}),
+ ...(form.workingDir !== undefined ? {workingDir: form.workingDir} : {}),
+ ...(form.worktree ? {worktree: form.worktree} : {}),
+ ...(form.projectPath ? {projectPath: form.projectPath} : {}),
// 首个 Worker 的 Agent 所在电脑(远程供应商);面板只在任务所在电脑支持时才带。
...(form.agentDeviceId !== undefined ? { agentDeviceId: form.agentDeviceId } : {}),
};
@@ -6139,6 +6141,7 @@ function CCAgentSessionContent({
</ChatDisplaySnapshotProvider>
</SessionNavigationModeProvider>
<CreateWorkerPopover
+ leadSessionId={collabSessionId ?? undefined}
open={createWorkerOpen}
onClose={() => setCreateWorkerOpen(false)}
onCreate={requestEnableCollab}
diff --git a/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx b/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
index d05ac4cdc3..7601d0c22b 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CreateWorkerPopover.tsx
@@ -1,3 +1,5 @@
+import { WorkerProjectField, useWorkerProjectSelection } from './WorkerProjectField';
+import type { WorkerWorktreeRequest } from '../../../shared/orca-worker-project';
import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
import * as Dialog from '@radix-ui/react-dialog';
import { WINDOW_NO_DRAG_STYLE } from '@/components/layout/windowDrag';
@@ -88,8 +90,10 @@ export interface CreateWorkerForm {
executionDeviceId?: string;
/** 运行设备名,只用于失败提示。 */
executionDeviceName?: string;
- /** 运行设备上的指定工作目录;缺省在那台电脑创建对话任务。只在指定运行设备时有意义。 */
+ /** 本机显式项目目录,或指定运行设备上的目录;远程缺省创建对话任务。 */
workingDir?: string;
+ worktree?: WorkerWorktreeRequest;
+ projectPath?: string;
/**
* Worker 的 Agent 所在电脑(远程供应商):string = 那台电脑或分享,null = 任务所在电脑。
* 缺省 = 不指定(任务所在电脑不支持选择时),Worker 跟 Lead。
@@ -129,6 +133,7 @@ export function isAbsoluteRemoteDir(value: string): boolean {
}
export interface CreateWorkerPopoverProps {
+ leadSessionId?: string;
open: boolean;
onClose: () => void;
onCreate: (form: CreateWorkerForm) => void | Promise<void>;
@@ -161,6 +166,7 @@ export interface CreateWorkerPopoverProps {
}
export function CreateWorkerPopover({
+ leadSessionId,
open,
onClose,
onCreate,
@@ -208,6 +214,9 @@ export function CreateWorkerPopover({
// 远程控制的 Lead 读它所在的电脑,选了运行设备则读运行设备。权限档始终跟 Lead 所在电脑走。
const deviceId = agentDeviceId ?? leadDeviceId ?? executionDeviceId ?? undefined;
const executionDevice = executionDevices.find((d) => d.deviceId === executionDeviceId) ?? null;
+ const localProjectEnabled =
+ !!leadSessionId && !leadDeviceId && !sshRemote && !executionDeviceId && !isSidebarWindow();
+ const project = useWorkerProjectSelection(open, leadSessionId, localProjectEnabled);
const trimmedRemoteDir = remoteDir.trim();
const remoteDirInvalid =
!!executionDevice && remoteDirMode === 'path' && !isAbsoluteRemoteDir(trimmedRemoteDir);
@@ -736,6 +745,7 @@ export function CreateWorkerPopover({
const agentLocationUnsendable =
!agentLocationSelectable && agentDeviceId !== (leadAgentDeviceId ?? null);
const canCreate =
+ (!localProjectEnabled || project.ready) &&
!isSubmitting &&
activeRole.length >= 1 &&
activeRole.length <= 32 &&
@@ -815,6 +825,7 @@ export function CreateWorkerPopover({
: (submitEffortMeta?.defaultEffort ?? undefined);
try {
await onCreate({
+ ...(localProjectEnabled ? project.fields : {}),
role: activeRole,
agent,
model,
@@ -841,6 +852,8 @@ export function CreateWorkerPopover({
setIsSubmitting(false);
}
}, [
+ localProjectEnabled,
+ project.fields,
canCreate,
prefs,
modelSelectionScope,
@@ -974,6 +987,8 @@ export function CreateWorkerPopover({
)}
</div>
+ {localProjectEnabled && <WorkerProjectField selection={project} disabled={isSubmitting} />}
+
{/* 运行设备与远程供应商互斥:Worker 的 Agent 已在另一台电脑时不提供运行设备。 */}
{executionDevices.length > 0 && agentDeviceId === null ? (
<ExecutionDeviceField
diff --git a/apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx b/apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx
index 748b540e2a..1a31d9e7e5 100644
--- a/apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx
@@ -257,6 +257,7 @@ export function OrcaWorkerPanel({
)}
</div>
<CreateWorkerPopover
+ leadSessionId={leadSessionId}
open={createOpen}
onClose={() => setCreateOpen(false)}
onCreate={handleCreateWorker}
diff --git a/apps/desktop/src/renderer/features/cc-agent/RolePillDropdown.tsx b/apps/desktop/src/renderer/features/cc-agent/RolePillDropdown.tsx
index edd82e76bc..a19d870e5b 100644
--- a/apps/desktop/src/renderer/features/cc-agent/RolePillDropdown.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/RolePillDropdown.tsx
@@ -1,3 +1,5 @@
+import { isRemoteSessionSticky } from '@/lib/makerTransport';
+import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
/**
* RolePillDropdown — worker pane header 的 role pill + popover dropdown。
*
@@ -15,7 +17,7 @@ import {
type WheelEvent,
} from 'react';
import { useTranslation } from 'react-i18next';
-import { Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Plus, X, EllipsisVertical, Monitor, WifiOff } from 'lucide-react';
+import { Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Plus, X, EllipsisVertical, Monitor, WifiOff, Folder } from 'lucide-react';
import { cn } from '@/lib/utils';
import { useAppShortcutDisplay } from '@/hooks/useAppShortcut';
import { useReducedMotion } from '@/hooks/useReducedMotion';
@@ -52,16 +54,30 @@ export function workerDeviceName(
}
function WorkerModelLine({
+ workerSessionId,
model,
effort,
device,
}: {
+ workerSessionId: string;
model: string;
effort: string | null;
device?: WorkerExecutionDevice;
}) {
const { t } = useTranslation();
const effortLabel = workerEffortLabel(t, effort);
+ const [project, setProject] = useState<{name: string; path: string} | null>(null);
+ useEffect(() => {
+ setProject(null);
+ if (device || isRemoteSessionSticky(workerSessionId)) return;
+ let cancelled = false;
+ const owner = getDataOwnerGeneration();
+ void window.electronAPI?.localDb?.orcaWorkflows?.projectLabel?.(workerSessionId).then((value) => {
+ const current = getDataOwnerGeneration();
+ if (!cancelled && owner.dataOwnerId === current.dataOwnerId && owner.generation === current.generation) setProject(value);
+ }).catch(() => {});
+ return () => { cancelled = true; };
+ }, [workerSessionId, device?.deviceId]);
if (device) {
const name = workerDeviceName(t, device);
return (
@@ -93,6 +109,7 @@ function WorkerModelLine({
// 模型名可截,档位词短、必须留在可见区。右侧给 archive / ERR 留空。
return (
<div className="mt-0.5 mr-7 ml-[26px] flex min-w-0 items-baseline gap-1.5 text-12 leading-snug text-[var(--text-secondary)]">
+ {project && <Tip text={project.path}><span className="inline-flex min-w-0 items-center gap-1"><Folder size={11} aria-hidden className="shrink-0" /><span className="truncate">{project.name}</span><span>·</span></span></Tip>}
<span className="min-w-0 truncate">{simplifyModelName(model)}</span>
{effortLabel ? <span className="shrink-0">· {effortLabel}</span> : null}
</div>
@@ -331,7 +348,7 @@ function WorkerSummary({
)}
</div>
{!compact && (
- <WorkerModelLine model={worker.model} effort={worker.effort} device={worker.executionDevice} />
+ <WorkerModelLine workerSessionId={worker.sessionId} model={worker.model} effort={worker.effort} device={worker.executionDevice} />
)}
</>
);
@@ -658,7 +675,7 @@ function WorkerLayoutMenu({
</>
)}
</div>
- <WorkerModelLine model={w.model} effort={w.effort} device={w.executionDevice} />
+ <WorkerModelLine workerSessionId={w.sessionId} model={w.model} effort={w.effort} device={w.executionDevice} />
</button>
{/* hover archive ✕ */}
<button
@@ -1355,7 +1372,7 @@ export function RolePillDropdown({
</div>
{/* 副行: 简化 model 名 (去 provider 前缀) + 档位文字.
各模型档位集合不同,不用信号条假装同一把尺子. */}
- <WorkerModelLine model={w.model} effort={w.effort} device={w.executionDevice} />
+ <WorkerModelLine workerSessionId={w.sessionId} model={w.model} effort={w.effort} device={w.executionDevice} />
</button>
{/* hover archive ✕ */}
<button
diff --git a/apps/desktop/src/renderer/features/cc-agent/WorkerProjectField.tsx b/apps/desktop/src/renderer/features/cc-agent/WorkerProjectField.tsx
new file mode 100644
index 0000000000..29dd3d5ec7
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/WorkerProjectField.tsx
@@ -0,0 +1,315 @@
+import { useEffect, useRef, useState } from 'react';
+import { Folder, ChevronDown, Check } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import {
+ FolderPickerPopover,
+ type FolderPickerSelectSource,
+} from '@/components/new-chat/FolderPickerPopover';
+import { BranchWorktreeChip } from '@/components/new-chat/WorktreeChipsRow';
+import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { Button } from '@/components/ui/button';
+import type {
+ WorkerProjectContext,
+ WorkerWorktreeRequest,
+} from '../../../shared/orca-worker-project';
+
+const basename = (value: string) =>
+ value
+ .replace(/[\\/]$/, '')
+ .split(/[\\/]/)
+ .pop() || value;
+
+export function useWorkerProjectSelection(
+ open: boolean,
+ leadSessionId: string | undefined,
+ enabled: boolean,
+) {
+ const owner = getDataOwnerGeneration();
+ const scope = JSON.stringify([open, enabled, leadSessionId, owner]);
+ const [target, setTarget] = useState<{ scope: string; directory?: string }>();
+ const directory = target?.scope === scope ? target.directory : undefined;
+ const [checked, setChecked] = useState(false);
+ const [sourceBranch, setSourceBranch] = useState('');
+ const [retry, setRetry] = useState(0);
+ const baseSnapshot = useRef<{ scope: string; context: WorkerProjectContext } | undefined>(
+ undefined,
+ );
+ const [snapshot, setSnapshot] = useState<{
+ key: string;
+ context?: WorkerProjectContext;
+ failed?: boolean;
+ }>();
+ const key = JSON.stringify([scope, directory, retry]);
+ useEffect(() => {
+ setTarget(undefined);
+ setChecked(false);
+ setSourceBranch('');
+ setSnapshot(undefined);
+ if (!open || !enabled) baseSnapshot.current = undefined;
+ }, [scope, open, enabled]);
+ useEffect(() => {
+ if (!open || !enabled || !leadSessionId) return;
+ let cancelled = false;
+ const capturedOwner = getDataOwnerGeneration();
+ const base = baseSnapshot.current?.scope === scope ? baseSnapshot.current.context : undefined;
+ const read = async (): Promise<WorkerProjectContext> => {
+ if (!base || directory === undefined) {
+ if (base) return base;
+ const context =
+ await window.electronAPI.localDb.orcaWorkflows.projectContext(leadSessionId);
+ if (!cancelled) baseSnapshot.current = { scope, context };
+ return context;
+ }
+ const selected = await window.electronAPI.localDb.orcaWorkflows.projectContext(
+ leadSessionId,
+ directory,
+ );
+ return { ...base, selected };
+ };
+ void read().then(
+ (context) => {
+ const current = getDataOwnerGeneration();
+ if (
+ !cancelled &&
+ current.dataOwnerId === capturedOwner.dataOwnerId &&
+ current.generation === capturedOwner.generation
+ )
+ setSnapshot({ key, context });
+ },
+ () => {
+ if (!cancelled) setSnapshot({ key, failed: true });
+ },
+ );
+ return () => {
+ cancelled = true;
+ };
+ }, [key, scope, open, enabled, leadSessionId, directory]);
+ const context = snapshot?.key === key ? snapshot.context : undefined;
+ const sameProject = !!context && context.selected.directory === context.inherited.directory;
+ const canWorktree =
+ !!context?.selected.exists &&
+ !!context.selected.baseRepo &&
+ context.selected.headState !== 'unborn' &&
+ !(sameProject && context.dialogue);
+ const branch = sourceBranch || context?.selected.branch || '';
+ return {
+ context,
+ sameProject,
+ canWorktree,
+ checked,
+ setChecked,
+ branch,
+ setSourceBranch,
+ failed: snapshot?.key === key && snapshot.failed,
+ reload: () => setRetry((value) => value + 1),
+ ready: !!context?.selected.exists && (!checked || (canWorktree && !!branch)),
+ select: (value: string, source: FolderPickerSelectSource = 'project') => {
+ const current = context?.inherited.baseRepo ?? context?.recordedDirectory;
+ setTarget({ scope, directory: source !== 'browse' && value === current ? undefined : value });
+ setChecked(false);
+ setSourceBranch('');
+ },
+ fields: (context
+ ? {
+ ...(directory !== undefined && !sameProject
+ ? { projectPath: context.selected.baseRepo ?? context.selected.directory }
+ : {}),
+ ...(context.selected.directory !== context.recordedDirectory
+ ? { workingDir: context.selected.directory }
+ : {}),
+ ...(checked && canWorktree ? { worktree: { sourceBranch: branch } } : {}),
+ }
+ : {}) as { projectPath?: string; workingDir?: string; worktree?: WorkerWorktreeRequest },
+ };
+}
+
+export function WorkerProjectField({
+ selection,
+ disabled,
+}: {
+ selection: ReturnType<typeof useWorkerProjectSelection>;
+ disabled: boolean;
+}) {
+ const { t } = useTranslation();
+ const [pickerOpen, setPickerOpen] = useState(false);
+ const [branchSnapshot, setBranchSnapshot] = useState<{
+ base: string;
+ values: string[];
+ failed?: boolean;
+ }>();
+ const [branchLoading, setBranchLoading] = useState(false);
+ const { context, sameProject, canWorktree, checked, branch } = selection;
+ const base = context?.selected.baseRepo ?? '';
+ const branchRequest = useRef(0);
+ useEffect(() => {
+ branchRequest.current++;
+ setBranchSnapshot(undefined);
+ setBranchLoading(false);
+ }, [base]);
+ const loadBranches = () => {
+ if (!base) return;
+ const request = ++branchRequest.current;
+ setBranchLoading(true);
+ void window.electronAPI
+ .worktreeListBranches({ baseRepo: base })
+ .then(
+ (value) => {
+ if (request === branchRequest.current)
+ setBranchSnapshot({ base, values: value.branches });
+ },
+ () => {
+ if (request === branchRequest.current)
+ setBranchSnapshot({ base, values: [], failed: true });
+ },
+ )
+ .finally(() => {
+ if (request === branchRequest.current) setBranchLoading(false);
+ });
+ };
+ const selectedName = context
+ ? basename(context.selected.baseRepo ?? context.selected.directory)
+ : '';
+ const sharedName = context
+ ? `${selectedName}${context.selected.isWorktree ? ` (${context.selected.worktreeName ?? basename(context.selected.directory)})` : ''}`
+ : '';
+ const detached = context?.selected.headState === 'detached';
+ const currentBranchLabel = detached
+ ? t('orca.workerProject.detachedHead', { sha: context.selected.branch?.slice(0, 8) })
+ : (context?.selected.branch ?? '—');
+ const sourceBranchLabel =
+ detached && branch === context?.selected.branch ? currentBranchLabel : branch;
+ return (
+ <div className="mb-4 space-y-2 text-12 text-[var(--text-secondary)]">
+ <div className="font-medium text-[var(--text-tertiary)]">{t('orca.workerProject.label')}</div>
+ {!context ? (
+ <div role="status">
+ {selection.failed ? (
+ <>
+ {t('orca.workerProject.loadFailed')}{' '}
+ <Button size="sm" variant="secondary" tone="quiet" onClick={selection.reload}>
+ {t('commonUi.retry')}
+ </Button>
+ </>
+ ) : (
+ t('ccAgent.common.loading')
+ )}
+ </div>
+ ) : (
+ <>
+ <FolderPickerPopover
+ open={pickerOpen && !disabled}
+ onOpenChange={setPickerOpen}
+ allowDialogue={false}
+ allowRemove={false}
+ projectOptions={context.projects}
+ onSelect={selection.select}
+ align="start"
+ >
+ <button
+ type="button"
+ disabled={disabled}
+ className="flex min-h-8 max-w-full items-center gap-2 rounded-full border border-[var(--border-default)] px-3 text-13 text-[var(--text-primary)] hover:bg-[var(--surface-hover)]"
+ >
+ <Folder size={14} className="shrink-0" />
+ <span className="truncate">
+ {sameProject ? t('orca.workerProject.current') : selectedName}
+ </span>
+ <ChevronDown size={12} className="shrink-0" />
+ </button>
+ </FolderPickerPopover>
+ {context.selected.exists &&
+ context.selected.baseRepo &&
+ context.selected.headState !== 'unborn' &&
+ !checked && (
+ <div className="break-words" title={context.selected.directory}>
+ {sameProject
+ ? t('orca.workerProject.shared', {
+ project: sharedName,
+ branch: currentBranchLabel,
+ })
+ : t(
+ detached ? 'orca.workerProject.directDetached' : 'orca.workerProject.direct',
+ {
+ project: selectedName,
+ branch: currentBranchLabel,
+ },
+ )}
+ </div>
+ )}
+ {context.selected.exists &&
+ sameProject &&
+ context.selected.directory !== context.recordedDirectory && (
+ <div>{t('orca.workerProject.inferred')}</div>
+ )}
+ {context.selected.exists && !sameProject && !checked && context.selected.dirty && (
+ <div>{t('orca.workerProject.dirty')}</div>
+ )}
+ {!context.selected.exists ? (
+ <div role="status">{t('orca.workerProject.missingDirectory')}</div>
+ ) : canWorktree ? (
+ <>
+ <label className="flex min-h-8 cursor-pointer items-center gap-2">
+ <input
+ className="peer sr-only"
+ type="checkbox"
+ checked={checked}
+ disabled={disabled}
+ onChange={(event) => selection.setChecked(event.target.checked)}
+ />
+ <span
+ aria-hidden
+ className={`inline-flex size-3.5 shrink-0 items-center justify-center rounded border peer-focus-visible:ring-2 peer-focus-visible:ring-[var(--focus-ring)] ${checked ? 'border-[var(--create-agent-send-bg)] bg-[var(--create-agent-send-bg)] text-[var(--create-agent-send-icon)]' : 'border-[var(--text-secondary)]'}`}
+ >
+ {checked && <Check size={10} />}
+ </span>
+ {t('orca.workerProject.newWorktree')}
+ </label>
+ {checked && (
+ <>
+ <div className="flex flex-wrap items-center gap-2">
+ <span>{t('orca.workerProject.from')}</span>
+ <BranchWorktreeChip
+ branchOnly
+ compact
+ branchLabel={branch}
+ branchDisplayLabel={sourceBranchLabel}
+ branches={branchSnapshot?.base === base ? branchSnapshot.values : []}
+ branchesLoading={branchLoading}
+ branchesFailed={
+ branchSnapshot?.base === base && branchSnapshot.failed === true
+ }
+ onRetryBranches={loadBranches}
+ checked={false}
+ branchSourceSelected
+ branchInteractive={!disabled}
+ onPick={selection.setSourceBranch}
+ onOpenRequested={loadBranches}
+ onToggle={() => {}}
+ />
+ <span>{t('orca.workerProject.fromSuffix')}</span>
+ </div>
+ {sameProject && (
+ <div className="leading-relaxed">
+ {t('orca.workerProject.splitWarning', { branch: sourceBranchLabel })}
+ </div>
+ )}
+ </>
+ )}
+ </>
+ ) : (
+ <div className="break-words">
+ {t(
+ sameProject && context.dialogue
+ ? 'orca.workerProject.dialogue'
+ : context.selected.headState === 'unborn'
+ ? 'orca.workerProject.emptyRepo'
+ : 'orca.workerProject.notGit',
+ { directory: context.selected.directory },
+ )}
+ </div>
+ )}
+ </>
+ )}
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx b/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
index 329db66b64..3d31f25e59 100644
--- a/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/CreateWorkerPopover.test.tsx
@@ -1,8 +1,10 @@
// @vitest-environment jsdom
+import { WorkerProjectField, useWorkerProjectSelection } from '../WorkerProjectField';
+import type { WorkerProjectContext } from '../../../../shared/orca-worker-project';
import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act, cleanup, fireEvent, render, renderHook, screen, waitFor } from '@testing-library/react';
import { useState } from 'react';
import userEvent from '@testing-library/user-event';
import { renderToString } from 'react-dom/server';
@@ -111,7 +113,8 @@ function model(id: string, efforts = ['high'], defaultEffort = 'high') {
}
vi.mock('react-i18next', () => ({
- useTranslation: () => ({ t: (key: string) => key }),
+ useTranslation: () => ({ t: (key: string, values?: Record<string, unknown>) =>
+ key.startsWith('orca.workerProject.') && values ? `${key} ${Object.values(values).join(' ')}` : key }),
}));
vi.mock('@/hooks/useAgentCapabilities', () => ({
@@ -1648,12 +1651,14 @@ describe('CreateWorkerPopover', () => {
describe('CreateWorkerPopover execution device', () => {
const listExecutionDevices = vi.fn();
+ const projectContext = vi.fn();
const originalScrollIntoView = Object.getOwnPropertyDescriptor(
HTMLElement.prototype,
'scrollIntoView',
);
beforeEach(() => {
+ mocks.sidebarWindow = false;
// Radix Select scrolls the focused option; jsdom does not implement scrolling.
Object.defineProperty(HTMLElement.prototype, 'scrollIntoView', {
configurable: true,
@@ -1666,6 +1671,11 @@ describe('CreateWorkerPopover execution device', () => {
mocks.localProviders = [];
mocks.remoteProviders = [];
mocks.remoteUnsupported = false;
+ projectContext.mockReset().mockResolvedValue({
+ recordedDirectory: '/local', dialogue: false, projects: [],
+ inherited: {directory: '/local', baseRepo: '/local', branch: 'main', exists: true, dirty: false, isWorktree: false},
+ selected: {directory: '/local', baseRepo: '/local', branch: 'main', exists: true, dirty: false, isWorktree: false},
+ });
listExecutionDevices.mockReset();
listExecutionDevices.mockResolvedValue({
devices: [
@@ -1674,11 +1684,12 @@ describe('CreateWorkerPopover execution device', () => {
],
});
(window as unknown as { electronAPI: unknown }).electronAPI = {
- localDb: { orcaWorkflows: { listExecutionDevices } },
+ localDb: { orcaWorkflows: { listExecutionDevices, projectContext } },
};
});
afterEach(() => {
+ mocks.sidebarWindow = false;
cleanup();
delete (window as unknown as { electronAPI?: unknown }).electronAPI;
if (originalScrollIntoView) {
@@ -1688,6 +1699,41 @@ describe('CreateWorkerPopover execution device', () => {
}
});
+ // Guard: a local-only project picker must not probe this host or add local fields to
+ // controlled/SSH Leads. Existing remote model tests lacked leadSessionId and IPC spies.
+ it.each([{deviceId: 'controlled-pc'}, {sshRemote: true}])(
+ 'submits a remote Lead without local project reads or fields: %j', async (props) => {
+ const onCreate = vi.fn();
+ render(<CreateWorkerPopover open leadSessionId="remote-lead" {...props} onClose={vi.fn()} onCreate={onCreate} />);
+ fireEvent.click(screen.getByRole('button', {name: 'orca.createWorker.submit'}));
+ await waitFor(() => expect(onCreate).toHaveBeenCalledOnce());
+ expect(projectContext).not.toHaveBeenCalled();
+ for (const field of ['workingDir', 'worktree', 'projectPath'])
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty(field);
+ },
+ );
+
+ // Detached sidebar preload intentionally lacks native folder and branch tools.
+ // Unit/jsdom: its creation form must retain the legacy submission and never read projects.
+ it('keeps detached sidebar creation identical to the legacy form without project reads', async () => {
+ const legacyCreate = vi.fn();
+ const baseline = render(<CreateWorkerPopover open onClose={vi.fn()} onCreate={legacyCreate} />);
+ fireEvent.click(screen.getByRole('button', {name: 'orca.createWorker.submit'}));
+ await waitFor(() => expect(legacyCreate).toHaveBeenCalledOnce());
+ baseline.unmount();
+
+ mocks.sidebarWindow = true;
+ const onCreate = vi.fn();
+ render(<CreateWorkerPopover open leadSessionId="lead" onClose={vi.fn()} onCreate={onCreate} />);
+ expect(screen.queryByText('orca.workerProject.label')).toBeNull();
+ fireEvent.click(screen.getByRole('button', {name: 'orca.createWorker.submit'}));
+ await waitFor(() => expect(onCreate).toHaveBeenCalledOnce());
+ expect(projectContext).not.toHaveBeenCalled();
+ expect(onCreate.mock.calls[0]![0]).toEqual(legacyCreate.mock.calls[0]![0]);
+ for (const field of ['workingDir', 'worktree', 'projectPath'])
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty(field);
+ });
+
it('offers other computers only when enabled and the list is not empty', async () => {
const { unmount } = render(<CreateWorkerPopover open onClose={vi.fn()} onCreate={vi.fn()} />);
expect(listExecutionDevices).not.toHaveBeenCalled();
@@ -1705,7 +1751,7 @@ describe('CreateWorkerPopover execution device', () => {
it('creates on the chosen computer with its folder and leaves outdated computers unselectable', async () => {
const onCreate = vi.fn();
render(
- <CreateWorkerPopover open executionDevicesEnabled onClose={vi.fn()} onCreate={onCreate} />,
+ <CreateWorkerPopover open leadSessionId="local-lead" executionDevicesEnabled onClose={vi.fn()} onCreate={onCreate} />,
);
const devicePicker = await screen.findByRole('combobox', {
@@ -1721,6 +1767,8 @@ describe('CreateWorkerPopover execution device', () => {
expect(devicePicker.textContent).toContain('orca.createWorker.thisComputer');
fireEvent.click(screen.getByRole('option', { name: /Mac mini/ }));
+ // Opening on this computer legitimately probes once; after switching, no further local reads.
+ projectContext.mockClear();
// 另一台电脑的模型目录:不接本机来源记忆,也不跳本机供应商设置。
expect(screen.getByTestId('model-selector').dataset.memoryWired).toBe('false');
expect(screen.getByTestId('model-selector').dataset.navigateWired).toBe('false');
@@ -1752,18 +1800,23 @@ describe('CreateWorkerPopover execution device', () => {
}),
),
);
+ expect(projectContext).not.toHaveBeenCalled();
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('worktree');
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('projectPath');
});
it('creates a chat on the chosen computer without leaking a previously specified folder', async () => {
const onCreate = vi.fn();
render(
- <CreateWorkerPopover open executionDevicesEnabled onClose={vi.fn()} onCreate={onCreate} />,
+ <CreateWorkerPopover open leadSessionId="local-lead" executionDevicesEnabled onClose={vi.fn()} onCreate={onCreate} />,
);
const picker = await screen.findByRole('combobox', {
name: 'orca.createWorker.executionDeviceLabel',
});
fireEvent.keyDown(picker, { key: 'ArrowDown' });
fireEvent.click(await screen.findByRole('option', { name: /Mac mini/ }));
+ // Opening on this computer legitimately probes once; after switching, no further local reads.
+ projectContext.mockClear();
expect(
screen
.getByRole('radio', { name: 'orca.createWorker.remoteDirChat' })
@@ -1779,9 +1832,13 @@ describe('CreateWorkerPopover execution device', () => {
await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
expect(onCreate.mock.calls[0]![0]).toMatchObject({ executionDeviceId: 'mac-mini' });
expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('workingDir');
+ expect(projectContext).not.toHaveBeenCalled();
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('worktree');
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('projectPath');
fireEvent.keyDown(picker, { key: 'ArrowDown' });
fireEvent.click(await screen.findByRole('option', { name: 'orca.createWorker.thisComputer' }));
+ await waitFor(() => expect((screen.getByRole('button', { name: 'orca.createWorker.submit' }) as HTMLButtonElement).disabled).toBe(false));
fireEvent.click(screen.getByRole('button', { name: 'orca.createWorker.submit' }));
await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(2));
expect(onCreate.mock.calls[1]![0]).not.toHaveProperty('executionDeviceId');
@@ -2125,3 +2182,186 @@ describe('execution device helpers', () => {
expect(isAbsoluteRemoteDir('work')).toBe(false);
});
});
+
+// Test value: the local picker must submit exactly the shown checkout and reset transient
+// choices. Existing remote-directory tests do not exercise this path. Unit/jsdom, fake IPC.
+describe('local Worker project selection', () => {
+ const project = {directory: '/repo', baseRepo: '/repo', branch: 'main', exists: true, dirty: false, isWorktree: false};
+ const context: WorkerProjectContext = {recordedDirectory: '/repo', inherited: project, selected: project, dialogue: false, projects: []};
+ const projectContext = vi.fn();
+ beforeEach(() => {
+ Object.defineProperty(HTMLElement.prototype, 'scrollIntoView', { configurable: true, value: vi.fn() });
+ projectContext.mockReset().mockResolvedValue(context);
+ (window as unknown as {electronAPI: unknown}).electronAPI = {localDb: {orcaWorkflows: {projectContext}}};
+ });
+ afterEach(() => {cleanup(); Reflect.deleteProperty(HTMLElement.prototype, 'scrollIntoView'); delete (window as unknown as {electronAPI?: unknown}).electronAPI;});
+ // Native picker cancellation does not select a project. Rejected IPC must also leave
+ // the modal usable; previous field tests never opened the actual folder popover.
+ it.each(['cancel', 'error'] as const)('keeps the selected project ready, closable and submittable after native picker %s', async (outcome) => {
+ const user = userEvent.setup();
+ window.localStorage.clear();
+ resetProviderModelMemoryForTest();
+ mocks.modelsByAgent.codex = [model('codex/gpt-5.5')];
+ mocks.capabilitiesByAgent.codex = {availableModels: [{id: 'codex/gpt-5.5'}]};
+ mocks.localProviders = [];
+ mocks.remoteProviders = [];
+ mocks.remoteUnsupported = false;
+ const dialog = vi.fn();
+ if (outcome === 'cancel') dialog.mockResolvedValue({canceled: true});
+ else dialog.mockRejectedValueOnce(new Error('native dialog unavailable'));
+ window.electronAPI.showOpenDirectoryDialog = dialog;
+ const onClose = vi.fn();
+ const onCreate = vi.fn();
+ render(<CreateWorkerPopover open leadSessionId="lead" onClose={onClose} onCreate={onCreate} />);
+ const current = await screen.findByRole('button', {name: 'orca.workerProject.current'});
+ await user.click(current);
+ await user.click(screen.getByRole('button', {name: 'newChat.folderPicker.browseProjectFolder'}));
+ expect(dialog).toHaveBeenCalledTimes(1);
+ if (outcome === 'error') expect(screen.getByRole('alert').textContent).toContain('newChat.folderPicker.browseFailed');
+ expect(screen.queryByText('ccAgent.common.loading')).toBeNull();
+ expect(screen.getByRole('button', {name: 'orca.workerProject.current'})).toBe(current);
+ expect(projectContext).toHaveBeenCalledTimes(1);
+ await user.click(screen.getByRole('button', {name: 'orca.createWorker.closeAria'}));
+ expect(onClose).toHaveBeenCalledTimes(1);
+ // The controlled test parent keeps the modal mounted after close, so submit also
+ // exercises the same settled state without resetting the component.
+ await user.click(screen.getByRole('button', {name: 'orca.createWorker.submit'}));
+ await waitFor(() => expect(onCreate).toHaveBeenCalledTimes(1));
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('workingDir');
+ expect(onCreate.mock.calls[0]![0]).not.toHaveProperty('projectPath');
+ });
+ // N07/N09, unit/jsdom: injected HEAD probe states must change visible controls without
+ // changing the submitted revision. Previous tests covered only named branches.
+ function ProjectForm({ onCreate }: { onCreate: (fields: unknown) => void }) {
+ const selection = useWorkerProjectSelection(true, 'lead', true);
+ return <>
+ <WorkerProjectField selection={selection} disabled={false} />
+ <button disabled={!selection.ready} onClick={() => onCreate(selection.fields)}>Create</button>
+ </>;
+ }
+ // P3: a vanished directory must explain the disabled creation action, not claim
+ // that the Worker will run there as though it were an ordinary non-Git directory.
+ it('explains a missing directory before non-Git details and keeps creation disabled', async () => {
+ const missing = {...project, directory: '/gone', baseRepo: null, branch: null, exists: false};
+ projectContext.mockResolvedValue({...context, selected: missing});
+ const onCreate = vi.fn();
+ render(<ProjectForm onCreate={onCreate} />);
+ await screen.findByText('orca.workerProject.missingDirectory');
+ expect(screen.queryByText('orca.workerProject.notGit /gone')).toBeNull();
+ expect(screen.queryByRole('checkbox')).toBeNull();
+ const create = screen.getByRole('button', {name: 'Create'}) as HTMLButtonElement;
+ expect(create.disabled).toBe(true);
+ fireEvent.click(create);
+ expect(onCreate).not.toHaveBeenCalled();
+ });
+ it('explains an empty repository, hides worktree creation and still allows direct creation', async () => {
+ const empty = {...project, branch: null, headState: 'unborn'};
+ projectContext.mockResolvedValue({...context, inherited: empty, selected: empty});
+ const onCreate = vi.fn();
+ render(<ProjectForm onCreate={onCreate} />);
+ await screen.findByText('orca.workerProject.emptyRepo /repo');
+ expect(screen.queryByRole('checkbox')).toBeNull();
+ fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+ expect(onCreate).toHaveBeenCalledWith({});
+ });
+ it('shows a shortened detached HEAD while submitting its full SHA or a picked real branch', async () => {
+ const sha = 'abcdef0123456789abcdef0123456789abcdef0123';
+ const detached = {...project, directory: '/other', baseRepo: '/other', branch: sha, headState: 'detached'};
+ projectContext.mockResolvedValue({...context, selected: detached});
+ window.electronAPI.worktreeListBranches = vi.fn().mockResolvedValue({branches: ['main']});
+ const onCreate = vi.fn();
+ render(<ProjectForm onCreate={onCreate} />);
+ await screen.findByText('orca.workerProject.directDetached other orca.workerProject.detachedHead abcdef01');
+ fireEvent.click(screen.getByRole('checkbox'));
+ const branchButton = screen.getByRole('button', {name: 'newChat.branchChip.label'});
+ expect(branchButton.textContent).toContain('orca.workerProject.detachedHead abcdef01');
+ expect(branchButton.textContent).not.toContain(sha);
+ fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+ expect(onCreate).toHaveBeenLastCalledWith(expect.objectContaining({worktree: {sourceBranch: sha}}));
+ fireEvent.click(branchButton);
+ fireEvent.click(await screen.findByRole('option', {name: 'main'}));
+ fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+ expect(onCreate).toHaveBeenLastCalledWith(expect.objectContaining({worktree: {sourceBranch: 'main'}}));
+ expect(branchButton.textContent).toBe('main');
+ });
+ it('omits workingDir for unchanged inheritance and resets worktree choice on reopening', async () => {
+ const {result, rerender} = renderHook(({open}) => useWorkerProjectSelection(open, 'lead', true), {initialProps: {open: true}});
+ await waitFor(() => expect(result.current.ready).toBe(true));
+ expect(result.current.fields).not.toHaveProperty('workingDir');
+ expect(result.current.fields).not.toHaveProperty('projectPath');
+ act(() => result.current.setChecked(true));
+ expect(result.current.fields.worktree).toEqual({sourceBranch: 'main'});
+ rerender({open: false}); rerender({open: true});
+ await waitFor(() => expect(result.current.ready).toBe(true));
+ expect(result.current.fields).not.toHaveProperty('worktree');
+ });
+ it('submits a detected checkout explicitly while keeping its own branch', async () => {
+ const inherited = {...project, directory: '/checkout', branch: 'feature', isWorktree: true};
+ projectContext.mockResolvedValue({...context, inherited, selected: inherited});
+ const {result} = renderHook(() => useWorkerProjectSelection(true, 'lead', true));
+ await waitFor(() => expect(result.current.ready).toBe(true));
+ expect(result.current.fields.workingDir).toBe('/checkout');
+ expect(result.current.branch).toBe('feature');
+ expect(result.current.fields).not.toHaveProperty('projectPath');
+ });
+ it('ignores an old project response and resets checkbox and source on each selection', async () => {
+ let resolveOld!: (value: WorkerProjectContext['selected']) => void;
+ const old = new Promise<WorkerProjectContext['selected']>(resolve => {resolveOld = resolve;});
+ projectContext.mockImplementation(async (_id, dir) => dir === '/old' ? old : dir ? {...project, directory: dir, baseRepo: dir, branch: 'other'} : context);
+ const {result} = renderHook(() => useWorkerProjectSelection(true, 'lead', true));
+ await waitFor(() => expect(result.current.ready).toBe(true));
+ act(() => {result.current.setChecked(true); result.current.setSourceBranch('chosen');});
+ act(() => result.current.select('/old'));
+ act(() => result.current.select('/new'));
+ await waitFor(() => expect(result.current.fields.workingDir).toBe('/new'));
+ await act(async () => resolveOld({...project, directory: '/old'}));
+ expect(result.current.fields.workingDir).toBe('/new');
+ expect(result.current.checked).toBe(false);
+ expect(result.current.branch).toBe('other');
+ expect(result.current.fields.projectPath).toBe('/new');
+ act(() => result.current.select('/repo'));
+ await waitFor(() => expect(result.current.context?.selected.directory).toBe('/repo'));
+ expect(result.current.fields).not.toHaveProperty('projectPath');
+ expect(result.current.fields).not.toHaveProperty('workingDir');
+ expect(projectContext.mock.calls.filter((call) => call.length === 1)).toHaveLength(1);
+ expect(projectContext.mock.calls.map((call) => call[1])).toEqual([undefined, '/old', '/new']);
+ });
+ // A browsed directory reaches the same select callback without needing a recent-list row.
+ it('retains explicitly browsed directories even when their repository matches the Lead', async () => {
+ projectContext.mockImplementation(async (_id, dir) => dir === '/browsed' ? {...project, directory: '/browsed', baseRepo: '/browsed'} : dir ? {...project, directory: dir} : context);
+ const {result} = renderHook(() => useWorkerProjectSelection(true, 'lead', true));
+ await waitFor(() => expect(result.current.ready).toBe(true));
+ act(() => result.current.select('/browsed'));
+ await waitFor(() => expect(result.current.fields.projectPath).toBe('/browsed'));
+ act(() => result.current.select('/repo-alias', 'browse'));
+ await waitFor(() => expect(result.current.fields.workingDir).toBe('/repo-alias'));
+ expect(result.current.fields.projectPath).toBe('/repo');
+ });
+ // Review P1: explicit same-repository choices were silently replaced by inheritance.
+ // Unit/jsdom: exercise the actual native-picker callback and submitted form fields.
+ it.each(['/repo/apps/api', '/repo/.cindy-worktrees/other', '/repo'])(
+ 'submits the explicitly browsed same-repository directory %s', async (directory) => {
+ const inherited = {...project, directory: '/repo/apps/web'};
+ const opening = {...context, recordedDirectory: inherited.directory, inherited, selected: inherited};
+ projectContext.mockImplementation(async (_id, dir) => dir
+ ? {...project, directory: dir, branch: 'selected-branch'} : opening);
+ window.electronAPI.showOpenDirectoryDialog = vi.fn().mockResolvedValue({canceled: false, path: directory});
+ const onCreate = vi.fn();
+ render(<ProjectForm onCreate={onCreate} />);
+ fireEvent.click(await screen.findByRole('button', {name: 'orca.workerProject.current'}));
+ fireEvent.click(screen.getByRole('button', {name: 'newChat.folderPicker.browseProjectFolder'}));
+ await waitFor(() => expect(projectContext).toHaveBeenLastCalledWith('lead', directory));
+ await waitFor(() => expect((screen.getByRole('button', {name: 'Create'}) as HTMLButtonElement).disabled).toBe(false));
+ fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+ expect(onCreate).toHaveBeenCalledWith({workingDir: directory, projectPath: '/repo'});
+ },
+ );
+ it('allows a Git project selected from a dialogue Lead and never probes a disabled remote form', async () => {
+ projectContext.mockResolvedValue({...context, dialogue: true, selected: {...project, directory: '/other', baseRepo: '/other'}});
+ const {result} = renderHook(() => useWorkerProjectSelection(true, 'lead', true));
+ await waitFor(() => expect(result.current.canWorktree).toBe(true));
+ projectContext.mockClear();
+ renderHook(() => useWorkerProjectSelection(true, 'remote', false));
+ expect(projectContext).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/RolePillDropdown.executionDevice.test.tsx b/apps/desktop/src/renderer/features/cc-agent/__tests__/RolePillDropdown.executionDevice.test.tsx
index c6b0a61d2b..d217954c5b 100644
--- a/apps/desktop/src/renderer/features/cc-agent/__tests__/RolePillDropdown.executionDevice.test.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/RolePillDropdown.executionDevice.test.tsx
@@ -1,14 +1,14 @@
// @vitest-environment jsdom
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import { afterEach, describe, expect, it, vi } from 'vitest';
+import { remoteProjectsStore } from '@/features/device-link/remoteProjectsStore';
+import { __resetStickySessionOriginForTest } from '@/features/device-link/stickySessionOrigin';
import type { WorkerInfo } from '../hooks/useWorkers';
import { RolePillDropdown } from '../RolePillDropdown';
-const confirm = vi.hoisted(() =>
- vi.fn(async (_opts: { description: string }) => false),
-);
+const confirm = vi.hoisted(() => vi.fn(async (_opts: { description: string }) => false));
vi.mock('react-i18next', () => ({
useTranslation: () => ({ t: (key: string) => key }),
@@ -115,3 +115,52 @@ describe('RolePillDropdown worker on another computer', () => {
expect(screen.getAllByText('claude-opus-5-5').length).toBeGreaterThan(0);
});
});
+
+// Guard: actual remote session origin + execution-device projection must prevent local
+// project reads/badges. Existing device-name tests did not install a projectLabel endpoint.
+describe('Worker project badge device boundary', () => {
+ afterEach(() => {
+ cleanup();
+ remoteProjectsStore.__resetPinnedOriginsForTest();
+ __resetStickySessionOriginForTest();
+ delete (window as unknown as { electronAPI?: unknown }).electronAPI;
+ });
+ it.each(['controlled-lead', 'execution-device', 'local'])(
+ 'only queries and displays the local project for %s',
+ async (location) => {
+ const projectLabel = vi
+ .fn()
+ .mockResolvedValue({ name: 'other-project', path: '/other-project' });
+ (window as unknown as { electronAPI: unknown }).electronAPI = {
+ localDb: { orcaWorkflows: { projectLabel } },
+ };
+ const current = worker(
+ location === 'execution-device'
+ ? {
+ executionDevice: {
+ deviceId: 'execution-pc',
+ remoteSessionId: 'remote-worker',
+ deviceName: 'Execution PC',
+ reachable: true,
+ workingDir: '/remote-project',
+ },
+ }
+ : {},
+ );
+ if (location === 'controlled-lead') {
+ remoteProjectsStore.pinSessionOrigin('controlled-pc', 'lead');
+ remoteProjectsStore.pinSessionOrigin('controlled-pc', current.sessionId);
+ }
+ openMenu(current);
+ await act(async () => {});
+ if (location === 'local') {
+ expect(projectLabel).toHaveBeenCalledWith(current.sessionId);
+ expect(screen.getAllByText('other-project').length).toBeGreaterThan(0);
+ } else {
+ expect(projectLabel).not.toHaveBeenCalled();
+ expect(screen.queryByText('other-project')).toBeNull();
+ expect(screen.getAllByText('claude-opus-5-5').length).toBeGreaterThan(0);
+ }
+ },
+ );
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/hooks/useOrcaWorkerSelection.ts b/apps/desktop/src/renderer/features/cc-agent/hooks/useOrcaWorkerSelection.ts
index 10b0a031c9..9923a6921d 100644
--- a/apps/desktop/src/renderer/features/cc-agent/hooks/useOrcaWorkerSelection.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/hooks/useOrcaWorkerSelection.ts
@@ -319,9 +319,11 @@ export function useOrcaWorkerSelection({
...(form.executionDeviceId
? {
executionDeviceId: form.executionDeviceId,
- ...(form.workingDir ? { workingDir: form.workingDir } : {}),
}
: {}),
+ ...(form.workingDir !== undefined ? {workingDir: form.workingDir} : {}),
+ ...(form.worktree ? {worktree: form.worktree} : {}),
+ ...(form.projectPath ? {projectPath: form.projectPath} : {}),
// Worker 的 Agent 所在电脑(远程供应商);面板只在任务所在电脑支持时才带。
...(form.agentDeviceId !== undefined ? { agentDeviceId: form.agentDeviceId } : {}),
label,
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index d481c3ccb2..664e3db306 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -10750,6 +10750,7 @@
"recent": "Recent",
"browseFolder": "Choose a different folder",
"browseProjectFolder": "Choose another project folder",
+ "browseFailed": "Could not open the folder picker. Please try again.",
"dialogue": "Chat",
"dialogueOrSelectProject": "Chat or select project",
"searchProjects": "Search projects",
@@ -15084,6 +15085,25 @@
"remoteWorkerLoading": "Loading the task on {{device}}…",
"remoteWorkerUnreachable": "{{device}} can't be reached right now. This Worker's task will appear again once it reconnects.",
"closeAria": "Close"
+ },
+ "workerProject": {
+ "missingDirectory": "This directory no longer exists. Please choose another directory.",
+ "label": "Project",
+ "current": "Current project",
+ "shared": "Shared with Lead: {{project}} · {{branch}}",
+ "direct": "Changes will be made directly in {{project}} on {{branch}}",
+ "inferred": "Identified from Lead’s recent actions",
+ "dirty": "This directory has uncommitted changes. The Worker will continue working with them.",
+ "newWorktree": "Create a worktree for this Worker",
+ "from": "Branch from",
+ "fromSuffix": "(changeable)",
+ "splitWarning": "A new branch will start at the latest commit on {{branch}}. Lead’s uncommitted changes will not carry over. Later changes stay separate until merged.",
+ "dialogue": "The current session has no project, so a worktree cannot be created. The Worker will work in {{directory}}.",
+ "notGit": "This directory is not a Git repository, so a worktree cannot be created. The Worker will work in {{directory}}.",
+ "emptyRepo": "This repository has no commits yet, so a worktree cannot be created. The Worker will work in {{directory}}.",
+ "detachedHead": "Detached HEAD · {{sha}}",
+ "directDetached": "Changes will be made directly in {{project}} at {{branch}}",
+ "loadFailed": "Could not read the project directory."
}
},
"splitGroup": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index f9ab535588..3a3502a3be 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -10710,6 +10710,7 @@
"recent": "最近",
"browseFolder": "別のフォルダを選択",
"browseProjectFolder": "別のプロジェクトフォルダを選択",
+ "browseFailed": "フォルダー選択画面を開けませんでした。もう一度お試しください。",
"dialogue": "対話",
"dialogueOrSelectProject": "対話またはプロジェクトを選択",
"searchProjects": "プロジェクトを検索",
@@ -15029,6 +15030,25 @@
"remoteWorkerLoading": "{{device}} 上のタスクを読み込み中…",
"remoteWorkerUnreachable": "{{device}} に現在接続できません。再接続すると、この Worker のタスクが再び表示されます。",
"closeAria": "閉じる"
+ },
+ "workerProject": {
+ "missingDirectory": "このディレクトリは存在しません。別のディレクトリを選択してください。",
+ "label": "プロジェクト",
+ "current": "現在のプロジェクト",
+ "shared": "Lead と共有:{{project}} · {{branch}}",
+ "direct": "{{project}} の {{branch}} ブランチで直接変更します",
+ "inferred": "Lead の最近の操作から特定しました",
+ "dirty": "このディレクトリには未コミットの変更があります。Worker はその状態から作業を続けます。",
+ "newWorktree": "Worker 用の worktree を作成",
+ "from": "分岐元",
+ "fromSuffix": "(変更可能)",
+ "splitWarning": "{{branch}} の最新コミットから新しいブランチを作成します。Lead の未コミットの変更は引き継がれません。その後の変更は互いに反映されず、マージが必要です。",
+ "dialogue": "現在のセッションにプロジェクトがないため、worktree は作成できません。Worker は {{directory}} で作業します。",
+ "notGit": "このディレクトリは Git リポジトリではないため、worktree は作成できません。Worker は {{directory}} で作業します。",
+ "emptyRepo": "このリポジトリにはまだコミットがないため、worktree を作成できません。Worker は {{directory}} で作業します。",
+ "detachedHead": "Detached HEAD · {{sha}}",
+ "directDetached": "{{project}} の {{branch}} で直接変更します",
+ "loadFailed": "プロジェクトのディレクトリを読み取れませんでした。"
}
},
"splitGroup": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 078a067a41..e26de3480a 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -10710,6 +10710,7 @@
"recent": "최근",
"browseFolder": "다른 폴더 선택",
"browseProjectFolder": "다른 프로젝트 폴더 선택",
+ "browseFailed": "폴더 선택 창을 열 수 없습니다. 다시 시도해 주세요.",
"dialogue": "대화",
"dialogueOrSelectProject": "대화 또는 프로젝트 선택",
"searchProjects": "프로젝트 검색",
@@ -15029,6 +15030,25 @@
"remoteWorkerLoading": "{{device}}의 작업을 불러오는 중…",
"remoteWorkerUnreachable": "{{device}}에 지금 연결할 수 없습니다. 다시 연결되면 이 Worker의 작업이 다시 표시됩니다.",
"closeAria": "닫기"
+ },
+ "workerProject": {
+ "missingDirectory": "이 디렉터리가 더 이상 존재하지 않습니다. 다른 디렉터리를 선택해 주세요.",
+ "label": "프로젝트",
+ "current": "현재 프로젝트",
+ "shared": "Lead와 공유: {{project}} · {{branch}}",
+ "direct": "{{project}}의 {{branch}} 브랜치에서 직접 수정합니다",
+ "inferred": "Lead의 최근 작업을 바탕으로 확인했습니다",
+ "dirty": "이 디렉터리에는 커밋하지 않은 변경 사항이 있습니다. Worker는 이 상태에서 작업을 이어갑니다.",
+ "newWorktree": "Worker용 worktree 만들기",
+ "from": "분기 시작점",
+ "fromSuffix": "(변경 가능)",
+ "splitWarning": "{{branch}}의 최신 커밋에서 새 브랜치를 만듭니다. Lead가 커밋하지 않은 변경 사항은 가져오지 않습니다. 이후 양쪽 변경 사항은 서로 반영되지 않으므로 병합해야 합니다.",
+ "dialogue": "현재 세션에 프로젝트가 없어 worktree를 만들 수 없습니다. Worker는 {{directory}}에서 작업합니다.",
+ "notGit": "이 디렉터리는 Git 저장소가 아니므로 worktree를 만들 수 없습니다. Worker는 {{directory}}에서 작업합니다.",
+ "emptyRepo": "이 저장소에는 아직 커밋이 없어 worktree를 만들 수 없습니다. Worker는 {{directory}}에서 작업합니다.",
+ "detachedHead": "Detached HEAD · {{sha}}",
+ "directDetached": "{{project}}의 {{branch}}에서 직접 수정합니다",
+ "loadFailed": "프로젝트 디렉터리를 읽지 못했습니다."
}
},
"splitGroup": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index 5942e182d3..d98b80ed51 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -10710,6 +10710,7 @@
"recent": "最近",
"browseFolder": "选择其他文件夹",
"browseProjectFolder": "选择其他项目文件夹",
+ "browseFailed": "无法打开文件夹选择框,请重试。",
"dialogue": "对话",
"dialogueOrSelectProject": "对话或选择项目",
"searchProjects": "搜索项目",
@@ -15029,6 +15030,25 @@
"remoteWorkerLoading": "正在读取 {{device}} 上的任务…",
"remoteWorkerUnreachable": "{{device}} 当前无法连接,恢复后会自动显示这个 Worker 的任务。",
"closeAria": "关闭"
+ },
+ "workerProject": {
+ "missingDirectory": "目录已不存在,请重新选择。",
+ "label": "项目",
+ "current": "当前项目",
+ "shared": "与 Lead 共用:{{project}} · {{branch}}",
+ "direct": "将直接在 {{project}} 的 {{branch}} 分支上修改",
+ "inferred": "根据 Lead 最近的操作识别",
+ "dirty": "这个目录有未提交的改动,Worker 会在这些改动上继续工作。",
+ "newWorktree": "为 Worker 新建 worktree",
+ "from": "从",
+ "fromSuffix": "拉出(可更换)",
+ "splitWarning": "会从 {{branch}} 的最新提交拉出新分支。Lead 未提交的改动不会带过去,之后双方改动互不可见,需要再合并。",
+ "dialogue": "当前任务没有绑定项目,不能新建 worktree。Worker 将在 {{directory}} 工作。",
+ "notGit": "这个目录不是 Git 仓库,不能新建 worktree。Worker 将在 {{directory}} 工作。",
+ "emptyRepo": "仓库还没有任何提交,不能新建 worktree。Worker 将在 {{directory}} 工作。",
+ "detachedHead": "分离 HEAD · {{sha}}",
+ "directDetached": "将直接在 {{project}} 的 {{branch}} 上修改",
+ "loadFailed": "未能读取项目目录。"
}
},
"splitGroup": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
index 3b94f559b0..dcfda14521 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -10710,6 +10710,7 @@
"recent": "最近",
"browseFolder": "選擇其他資料夾",
"browseProjectFolder": "選擇其他專案資料夾",
+ "browseFailed": "無法開啟資料夾選擇視窗,請重試。",
"dialogue": "對話",
"dialogueOrSelectProject": "對話或選擇專案",
"searchProjects": "搜尋專案",
@@ -15029,6 +15030,25 @@
"remoteWorkerLoading": "正在讀取 {{device}} 上的任務…",
"remoteWorkerUnreachable": "{{device}} 目前無法連線,恢復後會自動顯示這個 Worker 的任務。",
"closeAria": "關閉"
+ },
+ "workerProject": {
+ "missingDirectory": "目錄已不存在,請重新選擇。",
+ "label": "專案",
+ "current": "目前專案",
+ "shared": "與 Lead 共用:{{project}} · {{branch}}",
+ "direct": "將直接在 {{project}} 的 {{branch}} 分支上修改",
+ "inferred": "根據 Lead 最近的操作辨識",
+ "dirty": "這個目錄有尚未提交的變更,Worker 會在這些變更上繼續工作。",
+ "newWorktree": "為 Worker 新建 worktree",
+ "from": "從",
+ "fromSuffix": "建立(可更換)",
+ "splitWarning": "會從 {{branch}} 的最新提交建立新分支。Lead 尚未提交的變更不會帶過去,之後雙方的變更互不可見,需要再合併。",
+ "dialogue": "目前任務未指定專案,無法新建 worktree。Worker 將在 {{directory}} 工作。",
+ "notGit": "這個目錄不是 Git 儲存庫,無法新建 worktree。Worker 將在 {{directory}} 工作。",
+ "emptyRepo": "儲存庫還沒有任何提交,無法新建 worktree。Worker 將在 {{directory}} 工作。",
+ "detachedHead": "分離 HEAD · {{sha}}",
+ "directDetached": "將直接在 {{project}} 的 {{branch}} 上修改",
+ "loadFailed": "無法讀取專案目錄。"
}
},
"splitGroup": {
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
index f3188c9865..ab13b69035 100644
--- a/apps/desktop/src/renderer/vite-env.d.ts
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -5195,6 +5195,11 @@ interface ElectronAPI {
}) => Promise<{ kind: 'share' | 'directory' | 'other' }>;
};
orcaWorkflows: {
+ projectContext: {
+ (leadSessionId: string): Promise<import('../shared/orca-worker-project').WorkerProjectContext>;
+ (leadSessionId: string, directory: string): Promise<import('../shared/orca-worker-project').WorkerProjectInfo>;
+ };
+ projectLabel: (workerSessionId: string) => Promise<{name: string; path: string} | null>;
getByLeadSession: (leadSessionId: string) => Promise<OrcaTeamRecord | null>;
getByWorkerSession: (workerSessionId: string) => Promise<OrcaTeamRecord | null>;
listWorkersByLead: (leadSessionId: string) => Promise<OrcaWorkerRecord[]>;
@@ -6146,6 +6151,8 @@ interface ElectronAPI {
executionDeviceId?: string;
/** 运行设备上的工作目录;缺省由那台分配。 */
workingDir?: string;
+ worktree?: import('../shared/orca-worker-project').WorkerWorktreeRequest;
+ projectPath?: string;
/** 首个 Worker 的 Agent 所在电脑(远程供应商);null = 任务所在电脑,缺省 = 跟 Lead。 */
agentDeviceId?: string | null;
},
diff --git a/apps/desktop/src/shared/orca-worker-project.ts b/apps/desktop/src/shared/orca-worker-project.ts
new file mode 100644
index 0000000000..74354f51cc
--- /dev/null
+++ b/apps/desktop/src/shared/orca-worker-project.ts
@@ -0,0 +1,23 @@
+/** Local Desktop worker project selection. Never sent through device-link. */
+export interface WorkerWorktreeRequest {
+ sourceBranch: string;
+}
+export interface WorkerProjectInfo {
+ directory: string;
+ baseRepo: string | null;
+ branch: string | null;
+ /** Main-process HEAD probe; branch retains the full commit ID when detached. */
+ headState?: 'branch' | 'detached' | 'unborn';
+ exists: boolean;
+ dirty: boolean;
+ isWorktree: boolean;
+ /** Checkout root name, even when telemetry points into a subdirectory. */
+ worktreeName?: string;
+}
+export interface WorkerProjectContext {
+ recordedDirectory: string;
+ inherited: WorkerProjectInfo;
+ selected: WorkerProjectInfo;
+ dialogue: boolean;
+ projects: Array<{ path: string; name: string; description: string; missing: boolean }>;
+}
diff --git a/docs/dev-rules/orca-team-architecture.md b/docs/dev-rules/orca-team-architecture.md
index cd97aab50f..21424858f0 100644
--- a/docs/dev-rules/orca-team-architecture.md
+++ b/docs/dev-rules/orca-team-architecture.md
@@ -211,7 +211,38 @@ Worker 不出现在普通 sidebar。renderer 用 `isOrcaWorkerSession(session) =
Worker 虽不进侧栏,它的出错与等待确认会汇总到所属 Lead 行(2026-10 用户裁决,只覆盖本机 Lead):Lead 行的状态点、项目折叠灯、rail 瓷砖、排序钉住与 Dock 角标都按「Worker 出错(红)> Worker 等待确认(蓝)> Lead 自己的状态」取一档,红 / 蓝同样盖过运行中;Worker 的完成不汇总。汇总只是读侧派生:来源是 Worker 自己在 `sessionAttentionStore` 里的 attention 与 Worker 投影(`workerProjectionStore` 中仍被持有的 Lead;已归档 Worker、已结束协同的团队不在投影里,自然不计),生命周期完全跟随 Worker 的 attention(重试 / 关横幅、Lead 重新派活、确认被回答即消失),点开 Lead 不会清掉,正在看该 Lead 时也照常显示。汇总结果**不得写回** `sessionAttentionStore`:那份会同步到 Main(Dock / 灵动岛 / 远端),并被「导航即已读」的被动清除抹掉,会破坏 Lead 自身的 attention 生命周期与完成保持判定。Dock 角标一个 Lead 只算 1,口径与侧栏行一致。逐行组件(`SessionItem` / `SessionCard` / `SessionStatusIcon`)只能用按 id 的 primitive 订阅 `useOrcaLeadWorkerAttentionKind`,聚合视图用 `useSessionAttentionKindsWithOrcaLeads` / `useOrcaLeadWorkerAttention` 与 `mergeOrcaLeadNotifications`。实现指针:`apps/desktop/src/renderer/features/cc-agent/lib/orcaLeadWorkerAttention.ts`、`workerProjectionStore.ts` 的 `listRetainedWorkerProjections`、`lib/appAttentionCount.ts` 的 `orcaLeadWorkerAttention` 入参。
-Worktree 现状:Orca 与普通 session 对齐,worktree 是可选项,不强制;toggle off 时 Lead/Worker 使用用户选的 workingDir,toggle on 时 Lead/Worker 共用同一个 worktree。
+Worktree 是可选项。旧调用方与 MCP 不传新字段时,Worker 仍继承 Lead 记录的目录。
+本机 Desktop 手动创建 Worker(包括开启协同的首个 Worker)可选择项目,并可为 Worker 单独新建 worktree。
+项目每次打开默认当前项目、不记忆选择;列表依次为当前项目、当前 data owner 主动选择且成功创建 Worker 的其他项目
+(本机独立记录,最多 10 项;默认当前项目不写入)、全局最近项目。当前项目按 Git 主仓去重,不额外提供 Lead 主目录选项;
+Worker 项目历史写入时按规范化路径字符串去重,保留最近 10 条;
+列表读取时按 realpath 身份去重,失败时退回规范化路径,显示和提交保留原路径;
+列表以最多 4 路并发执行 realpath / stat,不逐项探测 Git;打开面板时读取 Lead 继承目录,
+本次打开内保留列表,切换项目只探测选中目录,关闭后重新打开再现取 Lead 信息。
+保留浏览文件夹,隐藏对话和从全局最近列表移除的入口。Worker 仍不写入 recent_workdirs。
+
+新面板打开时由 Main 调用 resolveWorkerInheritedDirectory:在现有 resolveSessionGitDir 推断之上,
+只采纳仍存在、真实 Git common dir 与 Lead 记录目录相同的遥测目录;跨 clone、嵌套独立仓库、
+已删除或无遥测都回退记录目录。候选先按 realpath 后的 checkout 根目录比较:同一 checkout
+始终保留记录目录;另一个 worktree 使用其根目录,若记录目录是 monorepo 子项目且同样的相对
+路径仍存在,则保留该子项目位置。文件编辑产生的子目录不会改变 Worker 默认目录。
+这个新封装不改变顶栏分支徽标,也尚未改 MCP 默认继承。
+推断等于记录目录时不传 workingDir,否则显式传入面板展示的目录,再经现有目录与项目策略校验。
+
+新 worktree 勾选及源分支均不记忆;换项目重置勾选、分支和 dirty 状态。资格取决于当前目标:
+当前项目为 dialogue 或非 Git 时不提供;其他项目仅判断该目录。默认源分支取所选实际目录的 HEAD,
+建树 baseRepo 则解析为主仓,允许从 linked worktree 再分出一个独立 worktree。
+创建流程预留名额后用 Worker 自己的 sessionId 登记 worktree,再 bootstrap。选中 checkout 根目录时
+与普通任务一致,只等待启动必读文件检出,全量 checkout 在后台继续;选中子项目时保留其相对路径,
+等待全量 checkout 后进入对应子目录,若源分支没有该目录则回退新 worktree 根并记录警告。
+失败补偿先等待本次后台 checkout 收口,
+再在会话锁内走 cancelPrecreatedWorktree 的封存、preserveDirty 与所有权检查;保留结果写日志,绝不强删。
+正常归档继续走已有快照与回收规则;仅继承 Lead(包括模型自建)的目录时不登记所有权,不回收它。
+
+这套项目界面仅用于本机 Lead、本机运行设备;Agent 使用另一台电脑的供应商不改变任务目录归属。
+SSH、device-link 控制端、手机端与其他运行设备维持原界面和行为;新增本机项目参数在这些入口被拒绝。
+项目读取与标签读取使用仅本机 preload 方法,不进入 device-link allowlist;原创建协议只增加可选字段。
+Worker 与 Lead 不同项目时在模型副行显示文件夹图标和项目名,同项目不额外标注。
`create_worker` / `create_workers` 的每个 Worker 可显式指定 `working_dir`(Worker
所在主机上已存在的绝对目录)。省略时仍继承 Lead;显式指定时,在 reservation、session
@@ -228,7 +259,7 @@ SSH 行协议不接受含 CR/LF 的输入或物理路径(含 symlink 目标)
Git worktree,不改变供应商、模型与 Worker 创建权限偏好。
显式 `working_dir` 的单个或批量 MCP 调用走现有会话审批:Full Access 直接执行,Auto
审阅用户授权,Ask 使用现有确认;不得被可信 server 或缓存的 server 授权直接放行。
-省略时保持原有静默继承;审批缺少工具名或参数证据时不静默放行。无需新增 UI。
+省略时保持原有静默继承;审批缺少工具名或参数证据时不静默放行。MCP 新建 worktree 参数与默认继承调整不在本次本机 UI 改动范围内。
### 协同运行时行为契约
diff --git a/i18n/GLOSSARY.md b/i18n/GLOSSARY.md
index d238c790c5..512db97e0e 100644
--- a/i18n/GLOSSARY.md
+++ b/i18n/GLOSSARY.md
@@ -271,6 +271,10 @@ Cindy Make 生成的本机定制应用成品。可与原版切换并沿用同一
设置 → 存储空间内主动备份、清理任务消息并压缩本地数据库的功能名称。默认只清理非活跃任务;用户确认开启可选项后,也会清理活跃任务的历史。先登记为 proposed,待实际使用后再固化。
+### Detached HEAD
+
+沿用会话顶栏分支徽标现有译法
+
### Release
CindyDev 内部设置中的正式业务服务器环境标签,五语固定保留英文 Release。它表示 App 当前连接哪套服务,不代表安装包发行版本、OTA 通道或 cn / global 区域;因 release 也是普通英文单词,关闭全局大小写扫描,具体 UI key 由 Mobile 定向测试约束。
diff --git a/i18n/glossary.json b/i18n/glossary.json
index 191cbc0fdd..2035a2c306 100644
--- a/i18n/glossary.json
+++ b/i18n/glossary.json
@@ -6,6 +6,7 @@
"punctuationExempt": ["desktop:settings.help.qnaFeedbackBodyTemplate"],
"terms": [
{"id":"side-chat","status":"proposed","en":"Side chat","translations":{"zh-CN":"侧边追问","zh-TW":"側邊追問","ja":"サイドチャット","ko":"사이드 채팅"},"checkCase":false,"note":"在右侧独立提问,继承主任务已完成的上下文;追问不自动写回主任务。"},
+ {"id": "detached-head", "status": "proposed", "en": "Detached HEAD", "translations": {"zh-CN": "分离 HEAD", "zh-TW": "分離 HEAD", "ja": "Detached HEAD", "ko": "Detached HEAD"}, "checkCase": false, "note": "沿用会话顶栏分支徽标现有译法"},
{"id": "mivo-library", "status": "proposed", "en": "Mivo Library", "translations": {"zh-CN": "Mivo 作品库", "zh-TW": "Mivo 作品庫", "ja": "Mivo ライブラリ", "ko": "Mivo 라이브러리"}, "note": "#5929:引用目录系统项沿用 Mivo 品牌,仅本地化展示;通用 library 能力的品牌命名仍待维护者裁决。"},
{"id": "mcp-app", "status": "proposed", "en": "MCP App", "translations": {"zh-CN": "MCP App", "zh-TW": "MCP App", "ja": "MCP App", "ko": "MCP App"}, "note": "标准 MCP Apps 协议提供的交互应用;卡片标题与消息来源沿用协议名称,各语言保留 MCP App,待术语评审后固化。"},
{"id": "dissolve-group", "status": "proposed", "en": "Dissolve group", "translations": {"zh-CN": "解散群聊", "zh-TW": "解散群聊", "ja": "グループを解散", "ko": "그룹 해산"}, "checkCase": false, "note": "Irreversible group termination, distinct from archive, leave and personal list removal."},