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(cindy-make): unify preparation and manage task lifecycle

Liziabc3061def81
diff --git a/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts b/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
index d60722642a..57e009c171 100644
--- a/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
+++ b/apps/desktop/src/main/__tests__/makerSendToSessionOrdering.test.ts
@@ -45,6 +45,18 @@ const useOrcaWorkerSelectionSourcePath = resolve(__dirname, '..', '..', 'rendere
const useOrcaWorkerSelectionSource = readFileSync(useOrcaWorkerSelectionSourcePath, 'utf8').replace(/\r\n?/g, '\n');
describe('sendToSession ordering', () => {
+ it('guards Cindy Make direct sends without reentering the session send lock', () => {
+ const block = extractBetween(source, 'async function sendUserMessageWithAwaitedGitBaseline', 'async function sendToSessionInternal');
+ expect(block).toContain('cindyMakeManager.isTaskPreparing(session.id)');
+ expectOrder(block, 'await assertCindyMakeTaskReady(session.id)', 'const dispatch = async');
+ expect(block).toContain("withCindyMakeProjectUse(app.getPath('userData'), session.workDir, dispatch)");
+ expect(block).not.toContain('sendToAgentAccepted(');
+ expect(block).not.toContain('sendToSessionLocks');
+ const observer = extractBetween(source, 'const sessionTurnObserverDependencies =', 'export function wireSessionToIpc');
+ expect(observer).toContain('beforeLocalProviderStart:');
+ expect(observer).toContain("withCindyMakeProjectUse(app.getPath('userData'), session.workDir,");
+ });
+
it('routes pending harness selections through the canonical queued send before using a live handle', () => {
const block = extractSendToSessionSource();
const routing = block.indexOf('|| agentSwitchPending.get(targetSessionId)');
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index 930a0f2eed..2da04208cd 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -13,7 +13,7 @@ import {
auditRegisteredWorktrees,
} from './worktree/recycleMaintenance';
import { requestWorktreeRecycle } from './worktree/managedRecycle';
-import { recycleSessionWorktreeForStatusChange } from './localDb/ipc/sessions';
+import { patchSessionMetaInDb, recycleSessionWorktreeForStatusChange } from './localDb/ipc/sessions';
import { tryGetDbClient } from './localDb/client/current';
import {
app,
@@ -323,12 +323,14 @@ import {
import { broadcastCindyMakeSourceStatus } from './cindy-make/sourceStatusBroadcast.js';
import { cindyMakeManager } from './cindy-make/manager.js';
import { broadcastCindyMakeState } from './cindy-make/stateBroadcast.js';
-import { CINDY_MAKE_RUN_ID_PATTERN } from './cindy-make/sourcePaths.js';
-import { prepareCindyMakeWorkspace } from './cindy-make/taskWorkspace.js';
import {
createMakeToolchainEnvironment,
resolveMakeToolEnvironment,
} from './cindy-make/toolchainEnvironment.js';
+import { CINDY_MAKE_RUN_ID_PATTERN } from './cindy-make/sourcePaths.js';
+import { prepareCindyMakeWorkspace } from './cindy-make/taskWorkspace.js';
+import { restoreCindyMakeTaskState, startCindyMakeTask } from './cindy-make/taskRuntime.js';
+import { configureCindyMakeTaskManagement, manageCindyMakeTask } from './cindy-make/taskManagement.js';
import { createStorageIpcHandlers } from './cindy-media/storageIpc';
import {
collectDatabaseSizeWarningStatus,
@@ -7397,69 +7399,105 @@ const registerIpcHandlers = () => {
ipcMain.handle('app:get-cindy-make-source-status', async (event) => {
assertTrustedAppRendererEvent(event);
const userData = app.getPath('userData');
- let env;
+ let env: Awaited<ReturnType<typeof createMakeToolchainEnvironment>> | undefined;
try {
env = await createMakeToolchainEnvironment(userData);
} catch {
// The persisted status remains usable when tool discovery is unavailable.
}
- return readCurrentCindySourceStatus(makeSourceRoot(userData), env);
+ return cindyMakeManager.refreshSourceStatus(() =>
+ readCurrentCindySourceStatus(makeSourceRoot(userData), env),
+ );
});
// 源码准备是全局单例:进度广播给所有窗口,任意窗口都能停止它。
subscribeCindySourceStatus(broadcastCindyMakeSourceStatus);
cindyMakeManager.subscribe(broadcastCindyMakeState);
+ configureCindyMakeTaskManagement({
+ isAlive: (id) => getMakerIfReady()?.isSessionAlive(id),
+ isRunning: (id) => getMakerIfReady()?.getSession(id)?.isTurnRunning() ?? false,
+ setStatus: patchSessionMetaInDb,
+ recycle: recycleSessionWorktreeForStatusChange,
+ });
+ cindyMakeManager.setProjectBusyProbe(
+ (root) =>
+ getMakerIfReady()
+ ?.listActiveSessions()
+ .some((session) => {
+ const relative = path.relative(path.join(root, 'worktrees'), session.workDir);
+ return (
+ session.isTurnRunning() &&
+ relative.length > 0 &&
+ !relative.startsWith('..') &&
+ !path.isAbsolute(relative)
+ );
+ }) ?? false,
+ );
ipcMain.handle('app:get-cindy-make-state', async (event) => {
assertTrustedAppRendererEvent(event);
+ try {
+ await restoreCindyMakeTaskState();
+ for (const [runId, report] of Object.entries(cindyMakeManager.getState().tasks ?? {})) {
+ if (report.task) cindyMakeManager.projectTaskSession(runId, {
+ executing: getMakerIfReady()?.getSession(report.task.sessionId)?.isTurnRunning() ?? false,
+ });
+ }
+ } catch {
+ throwIpcError('INTERNAL', 'Could not restore Cindy Make preparation state');
+ }
return cindyMakeManager.getState();
});
+ ipcMain.handle('app:manage-cindy-make-task', async (event, sessionId: unknown, action: unknown) => {
+ assertTrustedAppRendererEvent(event);
+ await manageCindyMakeTask(sessionId, action).catch((error) => {
+ if (error instanceof Error && error.message.startsWith('[')) throw error;
+ throwIpcError('INTERNAL', 'cleanupFailed');
+ });
+ });
ipcMain.handle('app:cancel-cindy-make-source', async (event): Promise<{ success: boolean }> => {
assertTrustedAppRendererEvent(event);
return { success: cancelCindySourcePreparation() };
});
- ipcMain.handle(
- 'app:open-cindy-make-source-dir',
- async (event): Promise<{ success: boolean }> => {
+ ipcMain.handle('app:open-cindy-make-source-dir', async (event): Promise<{ success: boolean }> => {
assertTrustedAppRendererEvent(event);
return openMakeSourceDirectory(app.getPath('userData'), {
openPath: (directory) => shell.openPath(directory),
});
});
- // 个人版制作任务的独立开发目录:从个人版基线建任务分支 + worktree 并安装依赖。
+ // 个人版制作任务的独立开发目录:先从个人版基线建任务分支 + worktree。
// 只认 runId 形状;路径全部由 main 从 userData 派生,renderer 只拿回结果。
- ipcMain.handle('app:prepare-cindy-make-workspace', async (event, rawRunId: unknown) => {
+ ipcMain.handle('app:start-cindy-make-task', async (event, input: unknown) => {
assertTrustedAppRendererEvent(event);
- if (typeof rawRunId !== 'string' || !CINDY_MAKE_RUN_ID_PATTERN.test(rawRunId)) {
- throwIpcError('INVALID_PARAMS', 'invalid Cindy Make run id');
- }
+ return startCindyMakeTask(input, event.sender.id).catch((error) => {
+ if (error instanceof Error && error.message.startsWith('[')) throw error;
+ throwIpcError('INTERNAL', 'Could not start Cindy Make preparation');
+ });
+ });
+ ipcMain.handle('app:cancel-cindy-make-task', async (event, runId: unknown) => {
+ assertTrustedAppRendererEvent(event);
+ if (typeof runId !== 'string' || !CINDY_MAKE_RUN_ID_PATTERN.test(runId))
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make run');
+ return { success: cindyMakeManager.cancel(runId, event.sender.id) === 'cancelled' };
+ });
+ ipcMain.handle('app:prepare-cindy-make-workspace', async (event, runId: unknown) => {
+ assertTrustedAppRendererEvent(event);
+ if (typeof runId !== 'string' || !CINDY_MAKE_RUN_ID_PATTERN.test(runId))
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make run');
const userData = app.getPath('userData');
- const env = await createMakeToolchainEnvironment(userData);
try {
- const signal = AbortSignal.timeout(20 * 60_000);
- const processEnvironment = await resolveMakeToolEnvironment(
- env,
- ['git', 'node', 'pnpm', 'python'],
- signal,
- );
- return await prepareCindyMakeWorkspace(userData, rawRunId, signal, {
- processEnvironment,
- });
- } catch (error) {
- const code = (error as { code?: unknown } | null)?.code;
- createSchedulerLogger('cindy-make').warn('workspace preparation failed', {
- runId: rawRunId,
- code,
- message: error instanceof Error ? error.message : String(error),
+ return await cindyMakeManager.withProject(makeSourceRoot(userData), async () => {
+ const signal = AbortSignal.timeout(20 * 60_000);
+ const env = await createMakeToolchainEnvironment(userData);
+ const processEnvironment = await resolveMakeToolEnvironment(
+ env,
+ ['git', 'node', 'pnpm', 'python'],
+ signal,
+ );
+ return prepareCindyMakeWorkspace(userData, runId, signal, { processEnvironment });
});
- throwIpcError(
- code === 'environmentNotReady' ? 'PRECONDITION_FAILED' : 'INTERNAL',
- code === 'installFailed'
- ? 'Cindy Make workspace dependency install failed'
- : code === 'environmentNotReady'
- ? 'Cindy Make source is not prepared'
- : 'Cindy Make workspace preparation failed',
- );
+ } catch {
+ throwIpcError('INTERNAL', 'Cindy Make workspace preparation failed');
}
});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/doctorCommand.test.ts b/apps/desktop/src/main/cindy-make/__tests__/doctorCommand.test.ts
index 0e597a588f..3130d27dc4 100644
--- a/apps/desktop/src/main/cindy-make/__tests__/doctorCommand.test.ts
+++ b/apps/desktop/src/main/cindy-make/__tests__/doctorCommand.test.ts
@@ -606,6 +606,13 @@ describe('Make upstream workflow', () => {
expect(h.prepareSource).not.toHaveBeenCalled();
expect(h.searchUpstream).not.toHaveBeenCalled();
finishEnvironment(ready());
+ await vi.waitFor(() => expect(h.prepareSource).toHaveBeenCalled());
+ expect(h.prepareSource).toHaveBeenCalledWith(
+ 'make',
+ expect.anything(),
+ expect.any(AbortSignal),
+ expect.any(Function),
+ );
await vi.waitFor(() => expect(h.prepareSource).toHaveBeenCalledOnce());
expect(h.searchUpstream).not.toHaveBeenCalled();
expect(h.publish.mock.calls.at(-1)?.[1]).toMatchObject({
@@ -614,6 +621,12 @@ describe('Make upstream workflow', () => {
source: { status: 'preparing' },
upstream: { status: 'pending' },
});
+ expect(cindyMakeManager.getState().reports?.make).toMatchObject({
+ status: 'running',
+ checks: ready().checks,
+ source: { status: 'preparing' },
+ upstream: { status: 'pending' },
+ });
finishSource({ ...ready(), checks: [], source: { status: 'ready', path: 'managed-source' } });
await expect(pending).resolves.toMatchObject({
doctorReport: { upstream: { status: 'notFound' } },
diff --git a/apps/desktop/src/main/cindy-make/__tests__/projectAccess.test.ts b/apps/desktop/src/main/cindy-make/__tests__/projectAccess.test.ts
new file mode 100644
index 0000000000..335270cb9c
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/projectAccess.test.ts
@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import os from 'node:os';
+import { lstat } from 'node:fs/promises';
+import { assertCindyMakeWorkspace, withCindyMakeProjectUse } from '../projectAccess.js';
+import { makeSourceCheckoutPath, makeTaskWorktreePath } from '../sourcePaths.js';
+
+vi.mock('node:fs/promises', () => ({ lstat: vi.fn() }));
+vi.mock('../../i18n.js', () => ({ t: (key: string) => key }));
+
+const userData = path.join(os.tmpdir(), 'cindy-make-access-fixture');
+const workingDir = makeTaskWorktreePath(userData, 'task-run');
+const worktreeGit = path.join(workingDir, '.git');
+const sourceGit = path.join(makeSourceCheckoutPath(userData), '.git');
+
+function metadata(kind: 'directory' | 'file' | 'symlink') {
+ return {
+ isDirectory: () => kind === 'directory',
+ isFile: () => kind === 'file',
+ isSymbolicLink: () => kind === 'symlink',
+ } as Awaited<ReturnType<typeof lstat>>;
+}
+
+beforeEach(() => {
+ vi.mocked(lstat)
+ .mockReset()
+ .mockImplementation(async (file) => metadata(file === worktreeGit ? 'file' : 'directory'));
+});
+
+describe('Cindy Make project send access', () => {
+ it('checks the worktree and original checkout before dispatch', async () => {
+ const send = vi.fn(async () => 'accepted');
+ await expect(withCindyMakeProjectUse(userData, workingDir, send)).resolves.toBe('accepted');
+ expect(lstat).toHaveBeenCalledWith(workingDir);
+ expect(lstat).toHaveBeenCalledWith(worktreeGit);
+ expect(lstat).toHaveBeenCalledWith(sourceGit);
+ expect(send).toHaveBeenCalledOnce();
+ });
+
+ it.each([workingDir, worktreeGit, sourceGit])(
+ 'does not dispatch or recreate a missing %s',
+ async (missing) => {
+ vi.mocked(lstat).mockImplementation(async (file) => {
+ if (file === missing) throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+ return metadata(file === worktreeGit ? 'file' : 'directory');
+ });
+ const send = vi.fn(async () => undefined);
+ await expect(withCindyMakeProjectUse(userData, workingDir, send)).rejects.toThrow(
+ 'cindyMake.code.workspaceUnavailable',
+ );
+ expect(send).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['file', 'symlink'] as const)('rejects a worktree replaced by a %s', async (kind) => {
+ vi.mocked(lstat).mockImplementation(async (file) =>
+ metadata(file === workingDir ? kind : file === worktreeGit ? 'file' : 'directory'),
+ );
+ await expect(assertCindyMakeWorkspace(userData, workingDir)).rejects.toThrow(
+ 'PRECONDITION_FAILED',
+ );
+ });
+
+ it('leaves ordinary projects and missing working directory defaults unchanged', async () => {
+ const send = vi.fn(async () => 'accepted');
+ for (const directory of [undefined, path.join(os.tmpdir(), 'ordinary-project')])
+ await expect(withCindyMakeProjectUse(userData, directory, send)).resolves.toBe('accepted');
+ expect(lstat).not.toHaveBeenCalled();
+ expect(send).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/sourcePnpm.test.ts b/apps/desktop/src/main/cindy-make/__tests__/sourcePnpm.test.ts
new file mode 100644
index 0000000000..9fe9ff9882
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/sourcePnpm.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { parseMakeDependencyProgress } from '../sourcePnpm.js';
+
+describe('dependency progress projection', () => {
+ it('keeps the actual counters when pnpm moves into installation scripts', () => {
+ const counters = { resolved: 12, reused: 8, downloaded: 4, added: 12 };
+ expect(
+ parseMakeDependencyProgress(
+ 'apps/desktop postinstall$ node install.js\nprivate output',
+ counters,
+ ),
+ ).toEqual({ ...counters, activity: 'scripts' });
+ });
+ it('returns the latest real pnpm counts without leaking raw output', () => {
+ expect(
+ parseMakeDependencyProgress(
+ 'private path and credentials\nProgress: resolved 12, reused 4, downloaded 6, added 2\nProgress: resolved 30, reused 14, downloaded 16, added 20',
+ ),
+ ).toEqual({ resolved: 30, reused: 14, downloaded: 16, added: 20 });
+ });
+ it('does not invent a percentage or counters from other output', () => {
+ expect(parseMakeDependencyProgress('apps/desktop postinstall$ node install.js')).toEqual({
+ activity: 'scripts',
+ });
+ expect(parseMakeDependencyProgress('Downloading package: 42%')).toBeUndefined();
+ expect(
+ parseMakeDependencyProgress('Progress: resolved 2, reused 1, downloaded'),
+ ).toBeUndefined();
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/sourcePreparation.test.ts b/apps/desktop/src/main/cindy-make/__tests__/sourcePreparation.test.ts
index 749da2a71e..1dab38afcb 100644
--- a/apps/desktop/src/main/cindy-make/__tests__/sourcePreparation.test.ts
+++ b/apps/desktop/src/main/cindy-make/__tests__/sourcePreparation.test.ts
@@ -21,6 +21,10 @@ import type { DoctorProbeResult } from '../doctor.js';
vi.mock('../sourceGit.js', () => ({ runSourceGit: vi.fn() }));
vi.mock('../sourcePnpm.js', () => ({ runSourcePnpm: vi.fn(async () => undefined) }));
+vi.mock('node:fs/promises', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('node:fs/promises')>();
+ return { ...actual, writeFile: vi.fn(actual.writeFile) };
+});
async function createExistingCheckout(sourcePath: string): Promise<void> {
await mkdir(path.join(sourcePath, '.git'), { recursive: true });
@@ -48,6 +52,7 @@ describe('Source and dependency preparation', () => {
root = await mkdtemp(path.join(os.tmpdir(), 'cindy-make-source-'));
vi.mocked(runSourceGit).mockReset();
vi.mocked(runSourcePnpm).mockReset().mockResolvedValue(undefined);
+ vi.mocked(writeFile).mockClear();
});
afterEach(async () => {
await rm(root, { recursive: true, force: true });
@@ -166,11 +171,20 @@ describe('Source and dependency preparation', () => {
CINDY_TEST_GIT: selectedGit,
CINDY_TEST_NODE: path.join(root, source === 'system' ? 'system' : 'tools', 'node'),
CINDY_TEST_PNPM: path.join(root, source === 'system' ? 'system' : 'tools', 'pnpm'),
- CINDY_TEST_PYTHON: path.join(root, source === 'system' ? 'system' : 'tools', 'python3'),
+ CINDY_TEST_PYTHON: undefined,
},
- ['install', '--frozen-lockfile', '--prefer-offline', '--prod=false'],
+ [
+ 'fetch',
+ '--frozen-lockfile',
+ '--prefer-offline',
+ '--prod=false',
+ '--ignore-scripts',
+ '--config.node-linker=isolated',
+ '--config.enable-modules-dir=false',
+ ],
sourcePath,
expect.any(AbortSignal),
+ expect.any(Function),
);
const checkoutIndex = gitCalls.findIndex(([, args]) => args[0] === 'checkout');
expect(vi.mocked(runSourceGit).mock.invocationCallOrder[checkoutIndex]).toBeLessThan(
@@ -180,11 +194,11 @@ describe('Source and dependency preparation', () => {
status: 'ready',
});
await expect(readCindySourceStatus(root)).resolves.not.toHaveProperty('mainCommit');
- expect(probe).toHaveBeenCalledTimes(source === 'system' ? 4 : 8);
+ expect(probe).toHaveBeenCalledTimes(source === 'system' ? 3 : 6);
expect(
probe.mock.calls.every(
([, command, args]) =>
- ['git', 'node', 'pnpm', 'python3'].includes(command) && args.join(' ') === '--version',
+ ['git', 'node', 'pnpm'].includes(command) && args.join(' ') === '--version',
),
).toBe(true);
expect(native).not.toHaveBeenCalled();
@@ -214,7 +228,55 @@ describe('Source and dependency preparation', () => {
});
});
- it('keeps the shared job preparing until installation completes, including late subscribers', async () => {
+ it('warms the cache without installing baseline dependencies or running scripts', async () => {
+ const progress = vi.fn();
+ const result = await prepareCindySource(
+ env,
+ root,
+ { channel: 'dev', version: '0.0.0' },
+ new AbortController().signal,
+ progress,
+ );
+ expect(result.status).toBe('ready');
+ expect(runSourcePnpm).toHaveBeenCalledOnce();
+ const args = vi.mocked(runSourcePnpm).mock.calls[0][1];
+ expect(args[0]).toBe('fetch');
+ expect(args).toEqual(
+ expect.arrayContaining(['--ignore-scripts', '--config.enable-modules-dir=false']),
+ );
+ expect(progress.mock.calls.some(([value]) => value.phase === 'caching')).toBe(true);
+ });
+
+ it('broadcasts cache reuse and download counters to Settings', async () => {
+ const dependencies = {
+ resolved: 21,
+ reused: 12,
+ downloaded: 9,
+ added: 0,
+ };
+ const status = vi.fn();
+ const unsubscribe = subscribeCindySourceStatus(status);
+ vi.mocked(runSourcePnpm).mockImplementationOnce(
+ async (_env, _args, _cwd, _signal, publish) => {
+ publish?.(dependencies);
+ },
+ );
+ try {
+ await prepareCindySource(
+ env,
+ root,
+ { channel: 'dev', version: '0.0.0' },
+ new AbortController().signal,
+ );
+ expect(status).toHaveBeenCalledWith(
+ expect.objectContaining({ status: 'preparing', phase: 'caching', dependencies }),
+ );
+ } finally {
+ unsubscribe();
+ }
+ });
+
+ it('keeps the shared job preparing until cache warming completes, including late subscribers', async () => {
let finishInstall!: () => void;
vi.mocked(runSourcePnpm).mockImplementationOnce(
() =>
@@ -233,12 +295,12 @@ describe('Source and dependency preparation', () => {
await vi.waitFor(() => expect(runSourcePnpm).toHaveBeenCalledOnce());
await expect(readCurrentCindySourceStatus(root)).resolves.toMatchObject({
status: 'preparing',
- phase: 'installing',
+ phase: 'caching',
branch: 'cindy-personal',
});
await expect(readCindySourceStatus(root)).resolves.toMatchObject({
status: 'preparing',
- phase: 'installing',
+ phase: 'caching',
});
expect(progress.mock.calls.some(([update]) => update.status === 'ready')).toBe(false);
const lateProgress = vi.fn();
@@ -249,7 +311,7 @@ describe('Source and dependency preparation', () => {
new AbortController().signal,
lateProgress,
);
- expect(lateProgress).toHaveBeenCalledWith(expect.objectContaining({ phase: 'installing' }));
+ expect(lateProgress).toHaveBeenCalledWith(expect.objectContaining({ phase: 'caching' }));
finishInstall();
const [firstResult, secondResult] = await Promise.all([first, second]);
expect(firstResult).toBe(secondResult);
@@ -258,7 +320,7 @@ describe('Source and dependency preparation', () => {
await expect(readCindySourceStatus(root)).resolves.toMatchObject({ status: 'ready' });
});
- it('reports install failure and retries the existing personal checkout without resetting it', async () => {
+ it('reports cache warming failure and retries the existing personal checkout without resetting it', async () => {
vi.mocked(runSourcePnpm).mockRejectedValueOnce(
Object.assign(new Error('installation failed'), { code: 'installFailed' }),
);
@@ -297,7 +359,7 @@ describe('Source and dependency preparation', () => {
).toBe(false);
});
- it('does not mark a cancelled installation ready even if the child completes successfully', async () => {
+ it('does not mark cancelled cache warming ready even if the child completes successfully', async () => {
const controller = new AbortController();
vi.mocked(runSourcePnpm).mockImplementationOnce(async (_env, _args, _cwd, signal) => {
expect(cancelCindySourcePreparation()).toBe(true);
@@ -316,10 +378,28 @@ describe('Source and dependency preparation', () => {
expect(progress.mock.calls.some(([update]) => update.status === 'ready')).toBe(false);
await expect(readCindySourceStatus(root)).resolves.toMatchObject({ status: 'cancelled' });
expect(cancelCindySourcePreparation()).toBe(false);
+ expect(
+ vi
+ .mocked(writeFile)
+ .mock.calls.filter(
+ ([file, data]) =>
+ file === path.join(root, 'source-status.json') &&
+ String(data).includes('"status":"cancelled"'),
+ ),
+ ).toHaveLength(1);
+ await expect(
+ prepareCindySource(
+ env,
+ root,
+ { channel: 'dev', version: '0.0.0' },
+ new AbortController().signal,
+ ),
+ ).resolves.toMatchObject({ status: 'ready' });
+ await expect(readCindySourceStatus(root)).resolves.toMatchObject({ status: 'ready' });
});
- it.each(['node', 'pnpm', 'python3'] as const)(
- 'fails without installing when %s is unavailable',
+ it.each(['node', 'pnpm'] as const)(
+ 'fails without fetching when %s is unavailable',
async (tool) => {
vi.mocked(env.probe).mockImplementation(async (command) =>
command === tool ? { status: 'missing', stdout: '' } : probeReadyTool(command),
@@ -336,6 +416,24 @@ describe('Source and dependency preparation', () => {
},
);
+ it('warms the cache without Python because builds belong to task worktrees', async () => {
+ vi.mocked(env.probe).mockImplementation(async (command) =>
+ command === 'python3' ? { status: 'missing', stdout: '' } : probeReadyTool(command),
+ );
+ await expect(
+ prepareCindySource(
+ env,
+ root,
+ { channel: 'dev', version: '0.0.0' },
+ new AbortController().signal,
+ ),
+ ).resolves.toMatchObject({ status: 'ready' });
+ expect(runSourcePnpm).toHaveBeenCalledOnce();
+ expect(vi.mocked(env.probe).mock.calls.some(([command]) => command === 'python3')).toBe(
+ false,
+ );
+ });
+
it('prepares dependencies for a previously Git-only ready checkout', async () => {
await writeFile(
path.join(root, 'source-status.json'),
@@ -753,6 +851,60 @@ describe('Source and dependency preparation', () => {
expect(vi.mocked(runSourceGit).mock.calls.some(([, args]) => args[0] === 'clone')).toBe(true);
});
+ it('reports remote discovery and local checks without retaining completed Git percentages', async () => {
+ await createExistingCheckout(path.join(root, 'source'));
+ const env = {
+ platform: 'win32',
+ probe: vi.fn(probeReadyTool),
+ processEnvironment: () => ({}),
+ } as unknown as MakeToolchainEnvironment;
+ const onProgress = vi.fn();
+ let releaseRemote!: () => void;
+ const remoteGate = new Promise<void>((resolve) => {
+ releaseRemote = resolve;
+ });
+ vi.mocked(runSourceGit).mockImplementation(async (_env, args, _cwd, _signal, publish) => {
+ if (args[0] === 'ls-remote') {
+ await remoteGate;
+ return '0123456789abcdef\trefs/heads/main';
+ }
+ if (args[0] === 'remote' || args[0] === 'status') {
+ expect(onProgress).toHaveBeenLastCalledWith(
+ expect.objectContaining({ phase: 'checkingLocal' }),
+ );
+ expect(onProgress.mock.lastCall?.[0].progress).toBeUndefined();
+ return args[0] === 'remote' ? CINDY_SOURCE_REPOSITORY : '';
+ }
+ if (args[0] === 'fetch') publish?.({ stage: 'receiving', percent: 100 });
+ if (args[0] === 'rev-parse') return '0123456789abcdef';
+ return '';
+ });
+ const pending = prepareCindySource(
+ env,
+ root,
+ { channel: 'dev', version: '0.0.0' },
+ new AbortController().signal,
+ onProgress,
+ );
+ try {
+ await vi.waitFor(() => expect(runSourceGit).toHaveBeenCalled());
+ expect(onProgress).toHaveBeenLastCalledWith(
+ expect.objectContaining({ phase: 'checkingRemote' }),
+ );
+ await expect(readCurrentCindySourceStatus(root)).resolves.toMatchObject({
+ status: 'preparing',
+ phase: 'checkingRemote',
+ });
+ expect(onProgress.mock.lastCall?.[0].progress).toBeUndefined();
+ } finally {
+ releaseRemote();
+ await pending;
+ }
+ await expect(pending).resolves.toMatchObject({ status: 'ready' });
+ expect(onProgress.mock.lastCall?.[0].phase).toBeUndefined();
+ expect(onProgress.mock.lastCall?.[0].progress).toBeUndefined();
+ });
+
it('attaches a concurrent caller to the running job instead of starting a second one', async () => {
const sourcePath = path.join(root, 'source');
await createExistingCheckout(sourcePath);
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.git-integration.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.git-integration.test.ts
new file mode 100644
index 0000000000..7cef2e4d58
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.git-integration.test.ts
@@ -0,0 +1,137 @@
+import { mkdtemp, mkdir, writeFile, readFile, access, rm, symlink } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { expect, it } from 'vitest';
+import { runSourceGit } from '../sourceGit.js';
+import { manageCindyMakeWorkspace } from '../taskCleanup.js';
+import { makeSourceCheckoutPath, makeTaskWorktreePath, makeTaskBranch } from '../sourcePaths.js';
+
+it('preserves archives, merges personal changes, and completely removes discarded work with real Git', async () => {
+ const profile = await mkdtemp(path.join(os.tmpdir(), 'cindy-make-cleanup-'));
+ const source = makeSourceCheckoutPath(profile);
+ const env: NodeJS.ProcessEnv = {
+ PATH: process.env.PATH,
+ SystemRoot: process.env.SystemRoot,
+ GIT_CONFIG_GLOBAL: path.join(profile, 'empty.gitconfig'),
+ GIT_CONFIG_NOSYSTEM: '1',
+ GIT_AUTHOR_NAME: 'Test',
+ GIT_AUTHOR_EMAIL: '[email protected]',
+ GIT_COMMITTER_NAME: 'Test',
+ GIT_COMMITTER_EMAIL: '[email protected]',
+ };
+ const signal = AbortSignal.timeout(90_000);
+ const git = async (args: string[], cwd = source) => {
+ try {
+ return await runSourceGit(env, args, cwd, signal);
+ } catch (error) {
+ const detail = error as { operation?: string; stderr?: string; spawnCode?: string };
+ throw new Error(
+ [detail.operation, detail.spawnCode, detail.stderr].filter(Boolean).join(': '),
+ { cause: error },
+ );
+ }
+ };
+ try {
+ await writeFile(env.GIT_CONFIG_GLOBAL!, '');
+ await mkdir(source, { recursive: true });
+ await git(['init', '--initial-branch=cindy-personal']);
+ await writeFile(path.join(source, '.gitignore'), 'node_modules/\n');
+ await git(['add', '.']);
+ await git(['commit', '-s', '-m', 'base']);
+ const baseCommit = await git(['rev-parse', 'HEAD']);
+ const target = makeTaskWorktreePath(profile, 'first');
+ await git(['worktree', 'add', '-b', makeTaskBranch('first'), target]);
+ await expect(
+ manageCindyMakeWorkspace(profile, 'first', 'archive', env, signal, { baseCommit }),
+ ).resolves.toBe(false);
+ await writeFile(path.join(target, 'feature.txt'), 'personal change');
+ await expect(
+ manageCindyMakeWorkspace(profile, 'first', 'finish', env, signal),
+ ).rejects.toMatchObject({ code: 'dirty' });
+ await git(['add', '.'], target);
+ await git(['commit', '-s', '-m', 'feature'], target);
+ await mkdir(path.join(target, 'node_modules'), { recursive: true });
+ await writeFile(path.join(target, 'node_modules', 'dependency'), 'ignored dependency');
+ await expect(
+ manageCindyMakeWorkspace(profile, 'first', 'archive', env, signal, { baseCommit }),
+ ).resolves.toBe(false);
+ await expect(manageCindyMakeWorkspace(profile, 'first', 'finish', env, signal)).resolves.toBe(
+ true,
+ );
+ expect(await readFile(path.join(source, 'feature.txt'), 'utf8')).toBe('personal change');
+ await expect(access(target)).rejects.toThrow();
+ expect(await git(['branch', '--list', makeTaskBranch('first')])).toBe('');
+ const conflict = makeTaskWorktreePath(profile, 'conflict');
+ await git(['worktree', 'add', '-b', makeTaskBranch('conflict'), conflict]);
+ await writeFile(path.join(conflict, 'feature.txt'), 'task change');
+ await git(['add', '.'], conflict);
+ await git(['commit', '-s', '-m', 'task change'], conflict);
+ await writeFile(path.join(source, 'feature.txt'), 'personal change advanced');
+ await git(['add', '.']);
+ await git(['commit', '-s', '-m', 'personal change advanced']);
+ await expect(
+ manageCindyMakeWorkspace(profile, 'conflict', 'finish', env, signal),
+ ).rejects.toMatchObject({ code: 'conflict' });
+ expect(await readFile(path.join(conflict, 'feature.txt'), 'utf8')).toBe('task change');
+ expect(await readFile(path.join(source, 'feature.txt'), 'utf8')).toBe(
+ 'personal change advanced',
+ );
+ expect(await git(['status', '--porcelain'])).toBe('');
+ await expect(access(path.join(source, '.git', 'MERGE_HEAD'))).rejects.toThrow();
+ await expect(
+ manageCindyMakeWorkspace(profile, 'conflict', 'delete', env, signal),
+ ).resolves.toBe(true);
+ const discarded = makeTaskWorktreePath(profile, 'discarded');
+ await git(['worktree', 'add', '-b', makeTaskBranch('discarded'), discarded]);
+ await writeFile(path.join(discarded, 'not-merged.txt'), 'discard only this');
+ const longDependency = path.join(
+ discarded,
+ 'node_modules',
+ ...Array(6).fill('long-dependency-name-1234567890'),
+ );
+ await mkdir(longDependency, { recursive: true });
+ await writeFile(path.join(longDependency, 'index.js'), 'long path dependency');
+ await expect(
+ manageCindyMakeWorkspace(profile, 'discarded', 'delete', env, signal),
+ ).resolves.toBe(true);
+ await expect(access(discarded)).rejects.toThrow();
+ // Match Windows' failed removal: no registration/.git, but dependencies and
+ // the task branch survive. Preparation metadata is the recovery authority.
+ const partial = makeTaskWorktreePath(profile, 'partial');
+ const partialBranch = makeTaskBranch('partial');
+ await git(['worktree', 'add', '-b', partialBranch, partial]);
+ await git(['worktree', 'remove', '--force', partial]);
+ const deep = path.join(
+ partial,
+ 'node_modules',
+ ...Array(6).fill('dependency-with-long-package-name-123456789'),
+ );
+ await mkdir(deep, { recursive: true });
+ await writeFile(path.join(deep, 'leftover.js'), 'locked during previous cleanup');
+ const outside = path.join(profile, 'unrelated-work');
+ await mkdir(outside);
+ await writeFile(path.join(outside, 'keep.txt'), 'keep');
+ await symlink(
+ outside,
+ path.join(partial, 'linked-folder'),
+ process.platform === 'win32' ? 'junction' : 'dir',
+ );
+ await expect(
+ manageCindyMakeWorkspace(profile, 'partial', 'delete', env, signal),
+ ).rejects.toMatchObject({ code: 'unavailable' });
+ await expect(
+ manageCindyMakeWorkspace(profile, 'partial', 'delete', env, signal, {
+ preparedWorkspace: { path: partial, branch: partialBranch },
+ }),
+ ).resolves.toBe(true);
+ await expect(access(partial)).rejects.toThrow();
+ expect(await readFile(path.join(outside, 'keep.txt'), 'utf8')).toBe('keep');
+ expect(await git(['branch', '--list', 'cindy-make/*'])).toBe('');
+ expect(await git(['worktree', 'list', '--porcelain'])).not.toContain('worktrees');
+ expect(await readFile(path.join(source, 'feature.txt'), 'utf8')).toBe(
+ 'personal change advanced',
+ );
+ } finally {
+ await rm(profile, { recursive: true, force: true });
+ }
+}, 90_000);
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.test.ts
new file mode 100644
index 0000000000..2663741c0f
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskCleanup.test.ts
@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { rm } from 'node:fs/promises';
+import os from 'node:os';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const h = vi.hoisted(() => ({ paths: new Set<string>(), links: new Set<string>() }));
+vi.mock('node:fs/promises', () => ({
+ lstat: vi.fn(async (p: string) => {
+ if (!h.paths.has(p)) throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+ return { isSymbolicLink: () => h.links.has(p), isDirectory: () => true };
+ }),
+ realpath: vi.fn(async (p: string) => p),
+ rm: vi.fn(async (p: string) => {
+ h.paths.delete(p);
+ }),
+}));
+import { manageCindyMakeWorkspace } from '../taskCleanup.js';
+import {
+ makeSourceCheckoutPath,
+ makeTaskWorktreePath,
+ makeTaskBranch,
+ makeWorktreesRoot,
+} from '../sourcePaths.js';
+
+const profile = path.join(os.tmpdir(), 'make-cleanup-unit');
+const source = makeSourceCheckoutPath(profile);
+const target = makeTaskWorktreePath(profile, 'run');
+const branch = makeTaskBranch('run');
+function fixture() {
+ const state = {
+ merged: false,
+ dirty: false,
+ head: 'changed',
+ branchExists: true,
+ registered: true,
+ };
+ const git = vi.fn(async (_env: unknown, args: string[], cwd: string) => {
+ if (args[0] === '-c') args = args.slice(2);
+ if (args[0] === 'branch' && args[1] === '--list') return state.branchExists ? branch : '';
+ if (args[0] === 'branch') {
+ state.branchExists = false;
+ return '';
+ }
+ if (args[0] === 'worktree' && args[1] === 'list')
+ return (
+ 'worktree ' +
+ (state.registered ? target : source) +
+ '\0branch refs/heads/' +
+ (state.registered ? branch : 'cindy-personal') +
+ '\0\0'
+ );
+ if (args[0] === 'worktree' && args[1] === 'remove') {
+ h.paths.delete(target);
+ return '';
+ }
+ if (args.includes('--git-common-dir')) return path.join(source, '.git');
+ if (args.includes('--abbrev-ref')) return cwd === target ? branch : 'cindy-personal';
+ if (args[0] === 'rev-parse') return state.head;
+ if (args[0] === 'status') return state.dirty ? ' M code.ts' : '';
+ if (args[0] === 'merge-base') {
+ if (!state.merged) throw Object.assign(new Error('not merged'), { exitCode: 1 });
+ return '';
+ }
+ if (args.includes('merge')) {
+ state.merged = true;
+ return '';
+ }
+ return '';
+ });
+ const manage = (
+ action: 'finish' | 'delete' | 'archive',
+ checkCurrent?: () => void,
+ preparedWorkspace?: { path: string; branch: string },
+ ) =>
+ manageCindyMakeWorkspace(profile, 'run', action, {}, new AbortController().signal, {
+ git,
+ baseCommit: 'base',
+ checkCurrent,
+ preparedWorkspace,
+ });
+ return { state, git, manage };
+}
+beforeEach(() => {
+ vi.mocked(rm).mockClear();
+ h.links.clear();
+ h.paths = new Set([
+ profile,
+ path.dirname(source),
+ source,
+ path.join(source, '.git'),
+ makeWorktreesRoot(profile),
+ target,
+ ]);
+});
+describe('managed task cleanup', () => {
+ it('merges committed work before removing the worktree and branch', async () => {
+ const f = fixture();
+ await expect(f.manage('finish')).resolves.toBe(true);
+ const calls = f.git.mock.calls.map(([, args]) => args);
+ expect(calls.findIndex((args) => args.includes('merge'))).toBeLessThan(
+ calls.findIndex((args) => args.includes('remove')),
+ );
+ expect(calls.at(-1)).toEqual(['branch', '-d', branch]);
+ expect(h.paths.has(target)).toBe(false);
+ });
+ it.each(['dirty', 'unmerged', 'unchanged'] as const)(
+ 'retains %s work when merely archived',
+ async (kind) => {
+ const f = fixture();
+ f.state.dirty = kind === 'dirty';
+ f.state.head = kind === 'unchanged' ? 'base' : 'changed';
+ await expect(f.manage('archive')).resolves.toBe(false);
+ expect(h.paths.has(target)).toBe(true);
+ expect(f.state.branchExists).toBe(true);
+ },
+ );
+ it('reclaims an archived task whose changes are already merged', async () => {
+ const f = fixture();
+ f.state.merged = true;
+ await expect(f.manage('archive')).resolves.toBe(true);
+ expect(f.git.mock.calls.some(([, args]) => args.includes('merge'))).toBe(false);
+ });
+ it('refuses finish with uncommitted changes but explicit delete discards them', async () => {
+ const f = fixture();
+ f.state.dirty = true;
+ await expect(f.manage('finish')).rejects.toMatchObject({ code: 'dirty' });
+ expect(h.paths.has(target)).toBe(true);
+ await expect(f.manage('delete')).resolves.toBe(true);
+ expect(f.git.mock.calls.at(-1)?.[1]).toEqual(['branch', '-D', branch]);
+ });
+ it('retries after worktree removal succeeded but branch removal failed', async () => {
+ const f = fixture();
+ h.paths.delete(target);
+ await expect(f.manage('delete')).resolves.toBe(true);
+ await expect(f.manage('delete')).resolves.toBe(true);
+ expect(f.state.branchExists).toBe(false);
+ });
+ it('never removes substituted or unregistered directories', async () => {
+ const f = fixture();
+ h.links.add(makeWorktreesRoot(profile));
+ await expect(f.manage('delete')).rejects.toMatchObject({ code: 'unavailable' });
+ h.links.clear();
+ f.state.registered = false;
+ await expect(f.manage('delete')).rejects.toMatchObject({ code: 'unavailable' });
+ expect(h.paths.has(target)).toBe(true);
+ });
+ it('stops before mutation when the account changes', async () => {
+ const f = fixture();
+ await expect(
+ f.manage('delete', () => {
+ throw new Error('owner changed');
+ }),
+ ).rejects.toThrow('owner changed');
+ expect(h.paths.has(target)).toBe(true);
+ expect(f.git).not.toHaveBeenCalled();
+ });
+ it('resumes a partial deletion using the exact persisted preparation identity', async () => {
+ const f = fixture();
+ f.state.registered = false;
+ await expect(f.manage('delete', undefined, { path: target, branch })).resolves.toBe(true);
+ expect(rm).toHaveBeenCalledWith(target, expect.objectContaining({ recursive: true }));
+ expect(h.paths.has(target)).toBe(false);
+ expect(f.state.branchExists).toBe(false);
+ });
+ it.each(['wrong-path', 'wrong-branch', 'git-marker', 'junction', 'no-branch'])(
+ 'rejects unsafe residual recovery: %s',
+ async (kind) => {
+ const f = fixture();
+ f.state.registered = false;
+ if (kind === 'git-marker') h.paths.add(path.join(target, '.git'));
+ if (kind === 'junction') h.links.add(target);
+ if (kind === 'no-branch') f.state.branchExists = false;
+ await expect(
+ f.manage('delete', undefined, {
+ path: kind === 'wrong-path' ? source : target,
+ branch: kind === 'wrong-branch' ? 'another-branch' : branch,
+ }),
+ ).rejects.toMatchObject({ code: 'unavailable' });
+ expect(rm).not.toHaveBeenCalled();
+ expect(h.paths.has(target)).toBe(true);
+ },
+ );
+ it('preserves the branch and reports occupied files until a retry succeeds', async () => {
+ const f = fixture();
+ f.state.registered = false;
+ vi.mocked(rm).mockRejectedValueOnce(Object.assign(new Error('locked'), { code: 'EPERM' }));
+ await expect(f.manage('delete', undefined, { path: target, branch })).rejects.toMatchObject({
+ code: 'directoryBusy',
+ });
+ expect(f.state.branchExists).toBe(true);
+ await expect(f.manage('delete', undefined, { path: target, branch })).resolves.toBe(true);
+ });
+ it('continues when Git removes its registration but leaves files behind', async () => {
+ const f = fixture();
+ const original = f.git.getMockImplementation()!;
+ f.git.mockImplementation(async (...args) => {
+ if (args[1].includes('remove')) {
+ f.state.registered = false;
+ throw new Error('unable to delete directory');
+ }
+ return original(...args);
+ });
+ await expect(f.manage('delete')).resolves.toBe(true);
+ expect(rm).toHaveBeenCalled();
+ expect(f.state.branchExists).toBe(false);
+ });
+ it('preserves work when merging fails', async () => {
+ const f = fixture();
+ const original = f.git.getMockImplementation()!;
+ f.git.mockImplementation(async (...args) => {
+ if (args[1].includes('merge')) throw new Error('conflict');
+ return original(...args);
+ });
+ await expect(f.manage('finish')).rejects.toMatchObject({ code: 'conflict' });
+ expect(h.paths.has(target)).toBe(true);
+ expect(f.state.branchExists).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskLifecycle.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskLifecycle.test.ts
new file mode 100644
index 0000000000..2b67b3d8c6
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskLifecycle.test.ts
@@ -0,0 +1,473 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CindyMakeManager, type CindyMakeTaskLifecycle } from '../manager.js';
+import type { CindyMakeTaskStart, MakeDoctorReport } from '../../../shared/cindyMakeDoctor.js';
+import type { SourcePreparationProgress, SourcePreparationResult } from '../sourcePreparation.js';
+
+function deferred() {
+ let resolve!: () => void;
+ const promise = new Promise<void>((done) => {
+ resolve = done;
+ });
+ return { promise, resolve };
+}
+
+function fixture(runId = 'task-run') {
+ const input: CindyMakeTaskStart = {
+ originSessionId: 'origin',
+ runId,
+ request: 'fix scrolling',
+ title: 'Cindy Make: fix scrolling',
+ };
+ const report: MakeDoctorReport = {
+ runId,
+ platform: 'win32',
+ arch: 'x64',
+ checks: [],
+ status: 'running',
+ task: { sessionId: runId + '-session', originSessionId: 'origin', phase: 'waiting' },
+ };
+ const gate = deferred();
+ const lifecycle: CindyMakeTaskLifecycle = {
+ create: vi.fn(async () => structuredClone(report)),
+ prepare: vi.fn(async (signal, publish) => {
+ publish({ ...report, task: { ...report.task!, phase: 'dependencies' } });
+ await gate.promise;
+ signal.throwIfAborted();
+ }),
+ persist: vi.fn(async () => undefined),
+ start: vi.fn(async () => undefined),
+ isCurrent: vi.fn(() => true),
+ onError: vi.fn(),
+ };
+ return { input, report, gate, lifecycle };
+}
+
+function sourceFixture() {
+ const cancelled = (): SourcePreparationResult => ({
+ status: 'cancelled',
+ path: 'project/source',
+ target: { channel: 'dev', version: '0.0.0', ref: 'main', candidates: ['main'] },
+ });
+ return {
+ root: 'project',
+ clearOnly: true,
+ signal: new AbortController().signal,
+ cancelled,
+ onProgress: vi.fn(),
+ toStatus: (progress: SourcePreparationProgress) => ({
+ status: progress.status,
+ path: progress.path,
+ phase: progress.phase,
+ }),
+ run: vi.fn(async (): Promise<SourcePreparationResult> => ({ ...cancelled(), status: 'ready' })),
+ };
+}
+
+describe('Main-owned Cindy Make task lifecycle', () => {
+ it('keeps one cleanup running without renderer subscribers and shares duplicate requests', async () => {
+ const manager = new CindyMakeManager();
+ const gate = deferred();
+ const run = vi.fn(() => gate.promise);
+ const unsubscribe = manager.subscribe(() => {});
+ const first = manager.runTaskAction('session', 'delete', () => true, run);
+ unsubscribe();
+ const second = manager.runTaskAction('session', 'delete', () => true, run);
+ expect(second).toBe(first);
+ expect(manager.getState().taskActions?.session).toEqual({
+ action: 'delete',
+ status: 'running',
+ });
+ const reopened = vi.fn();
+ manager.subscribe(reopened);
+ expect(reopened).toHaveBeenCalledWith(
+ expect.objectContaining({
+ taskActions: { session: { action: 'delete', status: 'running' } },
+ }),
+ );
+ await expect(manager.runTaskAction('session', 'finish', () => true, run)).rejects.toMatchObject(
+ { code: 'busy' },
+ );
+ gate.resolve();
+ await first;
+ expect(run).toHaveBeenCalledTimes(1);
+ expect(manager.getState().taskActions?.session).toBeUndefined();
+ });
+ it('preserves cleanup failures across view lifetimes and clears them when retrying', async () => {
+ const manager = new CindyMakeManager();
+ await expect(
+ manager.runTaskAction(
+ 'session',
+ 'delete',
+ () => true,
+ async () => {
+ throw Object.assign(new Error('locked'), { code: 'directoryBusy' });
+ },
+ ),
+ ).rejects.toThrow('locked');
+ expect(manager.getState().taskActions?.session).toEqual({
+ action: 'delete',
+ status: 'failed',
+ error: 'directoryBusy',
+ });
+ const gate = deferred();
+ const retry = manager.runTaskAction(
+ 'session',
+ 'delete',
+ () => true,
+ () => gate.promise,
+ );
+ expect(manager.getState().taskActions?.session).toEqual({
+ action: 'delete',
+ status: 'running',
+ });
+ gate.resolve();
+ await retry;
+ expect(manager.getState().taskActions?.session).toBeUndefined();
+ });
+ it('tracks the canonical recycle inside an action without waiting on itself', async () => {
+ const manager = new CindyMakeManager();
+ const recycle = vi.fn(async () => {});
+ await manager.runTaskAction(
+ 'session',
+ 'finish',
+ () => true,
+ () => manager.runTaskAction('session', 'finish', () => true, recycle, true),
+ );
+ expect(recycle).toHaveBeenCalledOnce();
+ expect(manager.getState().taskActions?.session).toBeUndefined();
+ });
+ it('does not leak old-owner cleanup or let its completion erase a newer job', async () => {
+ const manager = new CindyMakeManager();
+ const oldGate = deferred();
+ const newGate = deferred();
+ let current = true;
+ const old = manager.runTaskAction(
+ 'session',
+ 'delete',
+ () => current,
+ () => oldGate.promise,
+ );
+ await Promise.resolve();
+ current = false;
+ expect(manager.getState().taskActions?.session).toBeUndefined();
+ const newer = manager.runTaskAction(
+ 'session',
+ 'delete',
+ () => true,
+ () => newGate.promise,
+ );
+ oldGate.resolve();
+ await old;
+ expect(manager.getState().taskActions?.session?.status).toBe('running');
+ newGate.resolve();
+ await newer;
+ });
+ it('does not mistake a plain archive recycle for the explicitly requested Finish', async () => {
+ const manager = new CindyMakeManager();
+ const gate = deferred();
+ const background = manager.runTaskAction(
+ 'session',
+ 'finish',
+ () => true,
+ () => gate.promise,
+ true,
+ );
+ const merge = vi.fn(async () => {});
+ const explicit = manager.runTaskAction('session', 'finish', () => true, merge);
+ expect(merge).not.toHaveBeenCalled();
+ gate.resolve();
+ await background;
+ await explicit;
+ expect(merge).toHaveBeenCalledOnce();
+ });
+ it('does not replace live source progress with a slow directory read', async () => {
+ const manager = new CindyMakeManager();
+ const gate = deferred();
+ const read = manager.refreshSourceStatus(async () => {
+ await gate.promise;
+ return { status: 'missing', path: '/source' };
+ });
+ manager.setSourceStatus({ status: 'preparing', path: '/source', phase: 'installing' });
+ gate.resolve();
+ await expect(read).resolves.toMatchObject({ status: 'preparing', phase: 'installing' });
+ expect(manager.getState().source?.status).toBe('preparing');
+ });
+
+ it('retains complete owner-scoped reports independently of renderer subscriptions', () => {
+ const manager = new CindyMakeManager();
+ const { report } = fixture();
+ let current = true;
+ manager.setReport(report, () => current);
+ report.status = 'failed';
+ expect(manager.getState().reports?.[report.runId]?.status).toBe('running');
+ const snapshot = manager.getState();
+ snapshot.reports![report.runId].status = 'failed';
+ expect(manager.getState().reports?.[report.runId]?.status).toBe('running');
+ current = false;
+ expect(manager.getState().reports?.[report.runId]).toBeUndefined();
+ });
+
+ it('prevents clear during send admission and the subsequent running turn', async () => {
+ const manager = new CindyMakeManager();
+ const gate = deferred();
+ const source = sourceFixture();
+ let turnRunning = false;
+ manager.setProjectBusyProbe(() => turnRunning);
+ const send = manager.withProjectUse('project', async () => {
+ await gate.promise;
+ turnRunning = true;
+ });
+ await expect(manager.prepareSource(source)).rejects.toMatchObject({ code: 'busy' });
+ gate.resolve();
+ await send;
+ await expect(manager.prepareSource(source)).rejects.toMatchObject({ code: 'busy' });
+ expect(source.run).not.toHaveBeenCalled();
+ turnRunning = false;
+ await expect(manager.prepareSource(source)).resolves.toMatchObject({ status: 'ready' });
+ });
+
+ it('rejects new sends while clear is awaiting filesystem work', async () => {
+ const manager = new CindyMakeManager();
+ const source = sourceFixture();
+ const gate = deferred();
+ source.run.mockImplementation(async () => {
+ await gate.promise;
+ return { ...source.cancelled(), status: 'ready' };
+ });
+ const clearing = manager.prepareSource(source);
+ await vi.waitFor(() => expect(source.run).toHaveBeenCalledOnce());
+ const send = vi.fn(async () => undefined);
+ await expect(manager.withProjectUse('project', send)).rejects.toMatchObject({ code: 'busy' });
+ expect(send).not.toHaveBeenCalled();
+ gate.resolve();
+ await clearing;
+ await manager.withProjectUse('project', send);
+ expect(send).toHaveBeenCalledOnce();
+ });
+
+ it('releases project use when send preflight fails', async () => {
+ const manager = new CindyMakeManager();
+ await expect(
+ manager.withProjectUse('project', async () => {
+ throw new Error('missing worktree');
+ }),
+ ).rejects.toThrow('missing worktree');
+ await expect(manager.prepareSource(sourceFixture())).resolves.toMatchObject({
+ status: 'ready',
+ });
+ });
+
+ it('shows queued source work to both the global state and callers joining before it starts', async () => {
+ const manager = new CindyMakeManager();
+ const source = { ...sourceFixture(), clearOnly: false };
+ const blocked = deferred();
+ const preceding = manager.withProject(source.root, () => blocked.promise);
+ const first = manager.prepareSource(source);
+ const lateProgress = vi.fn();
+ const second = manager.prepareSource({ ...source, onProgress: lateProgress });
+ try {
+ expect(source.run).not.toHaveBeenCalled();
+ expect(manager.getState().source).toMatchObject({ status: 'preparing', phase: 'waiting' });
+ expect(source.onProgress).toHaveBeenLastCalledWith(
+ expect.objectContaining({ phase: 'waiting' }),
+ );
+ expect(lateProgress).toHaveBeenLastCalledWith(expect.objectContaining({ phase: 'waiting' }));
+ } finally {
+ blocked.resolve();
+ await Promise.all([preceding, first, second]);
+ }
+ expect(source.run).toHaveBeenCalledOnce();
+ });
+
+ it('persists queued cancellation inside the project lock before later writers', async () => {
+ const manager = new CindyMakeManager();
+ const source = sourceFixture();
+ const blocked = deferred();
+ const persisted = deferred();
+ const controller = new AbortController();
+ const events: string[] = [];
+ const preceding = manager.withProject('project', () => blocked.promise);
+ const cancelled = manager.prepareSource({
+ ...source,
+ signal: controller.signal,
+ onCancelledBeforeStart: async () => {
+ events.push('cancel-write');
+ await persisted.promise;
+ },
+ });
+ controller.abort();
+ const next = manager.withProject('project', async () => {
+ events.push('retry-write');
+ });
+ blocked.resolve();
+ await preceding;
+ await vi.waitFor(() => expect(events).toEqual(['cancel-write']));
+ persisted.resolve();
+ await Promise.all([cancelled, next]);
+ expect(events).toEqual(['cancel-write', 'retry-write']);
+ expect(source.run).not.toHaveBeenCalled();
+ });
+
+ it('revokes first dispatch synchronously when the task is cleared', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate, report } = fixture();
+ await manager.startTask(input, lifecycle);
+ manager.cancelTasksForSession(report.task!.sessionId);
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ expect(manager.taskReport(input.runId)?.status).toBe('cancelled');
+ });
+
+ it('creates and persists a visible task before dependency installation, then starts exactly once without subscribers', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate, report } = fixture();
+ const unsubscribe = manager.subscribe(vi.fn());
+ expect(await manager.startTask(input, lifecycle)).toBe(report.task!.sessionId);
+ expect(lifecycle.persist).toHaveBeenCalledWith(report);
+ expect(manager.taskReport(input.runId)?.task?.phase).toBe('dependencies');
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ unsubscribe();
+ expect(await manager.startTask(input, lifecycle)).toBe(report.task!.sessionId);
+ expect(lifecycle.create).toHaveBeenCalledTimes(1);
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).toHaveBeenCalledTimes(1);
+ expect(manager.taskReport(input.runId)).toMatchObject({
+ status: 'completed',
+ task: { phase: 'completed' },
+ });
+ await manager.startTask(input, lifecycle);
+ expect(lifecycle.start).toHaveBeenCalledTimes(1);
+ });
+
+ it('coalesces clicks while task creation itself is pending', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, report, gate } = fixture();
+ const creation = deferred();
+ vi.mocked(lifecycle.create).mockImplementation(async () => {
+ await creation.promise;
+ return report;
+ });
+ const first = manager.startTask(input, lifecycle);
+ const second = manager.startTask(input, lifecycle);
+ expect(first).toBe(second);
+ creation.resolve();
+ await first;
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.create).toHaveBeenCalledOnce();
+ expect(lifecycle.start).toHaveBeenCalledOnce();
+ });
+
+ it.each(['cancel', 'failed'] as const)(
+ 'does not send on %s and retries the same task',
+ async (reason) => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate, report } = fixture();
+ if (reason === 'failed')
+ vi.mocked(lifecycle.prepare).mockRejectedValueOnce(new Error('install failed'));
+ await manager.startTask(input, lifecycle);
+ if (reason === 'cancel') expect(manager.cancel(input.runId, 99)).toBe('cancelled');
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(manager.taskReport(input.runId)?.status).toBe(
+ reason === 'cancel' ? 'cancelled' : 'failed',
+ );
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ expect(await manager.startTask(input, lifecycle)).toBe(report.task!.sessionId);
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).toHaveBeenCalledOnce();
+ },
+ );
+
+ it('retains a failed dispatch for explicit retry rather than treating it as accepted', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate } = fixture();
+ vi.mocked(lifecycle.start).mockRejectedValueOnce(new Error('not accepted'));
+ gate.resolve();
+ await manager.startTask(input, lifecycle);
+ await manager.waitForTask(input.runId);
+ expect(manager.taskReport(input.runId)?.status).toBe('failed');
+ await manager.startTask(input, lifecycle);
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).toHaveBeenCalledTimes(2);
+ expect(manager.taskReport(input.runId)?.status).toBe('completed');
+ });
+
+ it('does not persist or dispatch into a different account', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate } = fixture();
+ await manager.startTask(input, lifecycle);
+ await Promise.resolve();
+ vi.mocked(lifecycle.isCurrent).mockReturnValue(false);
+ vi.mocked(lifecycle.persist).mockClear();
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ expect(lifecycle.persist).not.toHaveBeenCalled();
+ expect(manager.getState().tasks).toBeUndefined();
+ });
+
+ it('keeps simultaneous task snapshots separate and immutable', async () => {
+ const manager = new CindyMakeManager();
+ const first = fixture('one');
+ const second = fixture('two');
+ await manager.startTask(first.input, first.lifecycle);
+ await manager.startTask(second.input, second.lifecycle);
+ const snapshot = manager.getState();
+ snapshot.tasks!.one.status = 'failed';
+ expect(manager.taskReport('one')?.status).toBe('running');
+ first.gate.resolve();
+ await manager.waitForTask('one');
+ expect(manager.taskReport('two')?.status).toBe('running');
+ second.gate.resolve();
+ await manager.waitForTask('two');
+ });
+
+ it('serializes project preparation, branch changes and completion writes', async () => {
+ const manager = new CindyMakeManager();
+ const gate = deferred();
+ const events: string[] = [];
+ const first = manager.withProject('project', async () => {
+ events.push('install');
+ await gate.promise;
+ events.push('installed');
+ });
+ const second = manager.withProject('project', async () => {
+ events.push('commit');
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ expect(events).toEqual(['install']);
+ gate.resolve();
+ await Promise.all([first, second]);
+ expect(events).toEqual(['install', 'installed', 'commit']);
+ });
+
+ it('blocks dispatch when progress cannot be persisted', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, gate } = fixture();
+ vi.mocked(lifecycle.persist)
+ .mockResolvedValueOnce(undefined)
+ .mockRejectedValue(new Error('disk full'));
+ await manager.startTask(input, lifecycle);
+ gate.resolve();
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ expect(manager.taskReport(input.runId)?.status).toBe('failed');
+ });
+
+ it('does not restart a persisted accepted task and rejects a mismatched run id', async () => {
+ const manager = new CindyMakeManager();
+ const { input, lifecycle, report } = fixture();
+ vi.mocked(lifecycle.create).mockResolvedValue({ ...report, status: 'completed' });
+ await manager.startTask(input, lifecycle);
+ await manager.waitForTask(input.runId);
+ expect(lifecycle.prepare).not.toHaveBeenCalled();
+ expect(lifecycle.start).not.toHaveBeenCalled();
+ await expect(
+ manager.startTask({ ...input, request: 'other' }, lifecycle),
+ ).rejects.toMatchObject({ code: 'invalid' });
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskManagement.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskManagement.test.ts
new file mode 100644
index 0000000000..efce48112f
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskManagement.test.ts
@@ -0,0 +1,243 @@
+import os from 'node:os';
+import path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const h = vi.hoisted(() => ({
+ row: undefined as Record<string, unknown> | undefined,
+ borrowers: [] as Array<{ id: string; status: string }>,
+ current: true,
+ dbReady: true,
+ content: '',
+ profile: '',
+ alive: false,
+ running: false,
+ clean: vi.fn(),
+ persist: vi.fn(),
+ forget: vi.fn(),
+ patch: vi.fn(),
+ recycle: vi.fn(),
+}));
+vi.mock('electron', () => ({ app: { getPath: () => h.profile } }));
+vi.mock('../../localDb/client/current.js', () => ({
+ getDbClient: () => {
+ if (!h.dbReady) throw new Error('DbClient not ready');
+ return client;
+ },
+}));
+vi.mock('../../localDb/ipc/messages.js', () => ({ updateMessageContent: h.persist }));
+vi.mock('../../localDb/sessionRouteLock.js', () => ({
+ withSessionRouteLock: async (_id: string, fn: () => unknown) => fn(),
+}));
+vi.mock('../../device-link/broadcast-tap.js', () => ({
+ captureDataOwnerBroadcastScope: () => ({}),
+ isDataOwnerBroadcastScopeCurrent: () => h.current,
+}));
+vi.mock('../toolchainEnvironment.js', () => ({
+ createMakeToolchainEnvironment: async () => ({}),
+ resolveMakeToolEnvironment: async () => ({}),
+}));
+vi.mock('../manager.js', async (original) => ({
+ ...(await original<typeof import('../manager.js')>()),
+ cindyMakeManager: {
+ withProject: async (_root: string, fn: () => unknown) => fn(),
+ isTaskPreparing: () => false,
+ forgetTask: h.forget,
+ runTaskAction: (...args: Parameters<CindyMakeManager['runTaskAction']>) =>
+ actionManager.runTaskAction(...args),
+ },
+}));
+import { CindyMakeManager } from '../manager.js';
+let actionManager: CindyMakeManager;
+vi.mock('../taskCleanup.js', async (original) => ({
+ ...(await original<typeof import('../taskCleanup.js')>()),
+ manageCindyMakeWorkspace: h.clean,
+}));
+import {
+ configureCindyMakeTaskManagement,
+ manageCindyMakeTask,
+ recycleCindyMakeTask,
+} from '../taskManagement.js';
+import { makeTaskWorktreePath } from '../sourcePaths.js';
+
+const client = {
+ drizzle: {
+ select: (selection?: Record<string, unknown>) => {
+ const read = () =>
+ selection && 'content' in selection
+ ? [{ content: h.content, clientId: 'cindy-make-preparation-run' }]
+ : selection
+ ? h.borrowers
+ : h.row
+ ? [h.row]
+ : [];
+ const query = {
+ from: () => query,
+ where: () => query,
+ limit: async () => read(),
+ then: (resolve: (value: unknown) => unknown) => Promise.resolve(read()).then(resolve),
+ };
+ return query;
+ },
+ },
+};
+const db = client.drizzle as unknown as Parameters<typeof recycleCindyMakeTask>[1];
+beforeEach(() => {
+ actionManager = new CindyMakeManager();
+ vi.clearAllMocks();
+ h.current = true;
+ h.dbReady = true;
+ h.alive = false;
+ h.running = false;
+ h.borrowers = [];
+ h.profile = path.join(os.tmpdir(), 'make-management-unit');
+ h.row = {
+ id: 'session',
+ source: 'cindy-make',
+ status: 'archived',
+ workingDir: makeTaskWorktreePath(h.profile, 'run'),
+ remoteHostId: null,
+ };
+ h.content = JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ report: {
+ runId: 'run',
+ status: 'completed',
+ task: { sessionId: 'session' },
+ source: { baseCommit: 'base', path: h.row!.workingDir, branch: 'cindy-make/run' },
+ },
+ },
+ },
+ });
+ h.clean.mockResolvedValue(true);
+ h.persist.mockResolvedValue({});
+ h.patch.mockImplementation(async (_id, patch) => Object.assign(h.row!, patch));
+ h.recycle.mockResolvedValue(undefined);
+ configureCindyMakeTaskManagement({
+ isAlive: () => h.alive,
+ isRunning: () => h.running,
+ setStatus: h.patch,
+ recycle: h.recycle,
+ });
+});
+describe('Cindy Make task management', () => {
+ it('uses canonical deletion and waits for runtime recycling before removing artifacts', async () => {
+ h.row!.status = 'active';
+ let settle!: () => void;
+ h.recycle.mockImplementationOnce(
+ () =>
+ new Promise<void>((done) => {
+ settle = done;
+ }),
+ );
+ const operation = manageCindyMakeTask('session', 'delete');
+ await vi.waitFor(() => expect(h.recycle).toHaveBeenCalled());
+ expect(actionManager.getState().taskActions?.session).toEqual({
+ action: 'delete',
+ status: 'running',
+ });
+ const duplicate = manageCindyMakeTask('session', 'delete');
+ expect(h.clean).not.toHaveBeenCalled();
+ settle();
+ await operation;
+ await duplicate;
+ expect(h.patch).toHaveBeenCalledTimes(1);
+ expect(actionManager.getState().taskActions?.session).toBeUndefined();
+ expect(h.patch).toHaveBeenCalledWith('session', { status: 'deleted', pinnedAt: null });
+ expect(h.persist.mock.calls[0][2].__cindyMakeCard.data.report.task.finished).toBe(true);
+ expect(h.forget).toHaveBeenCalledWith('run');
+ expect(h.clean.mock.calls[0][5].preparedWorkspace).toEqual({
+ path: h.row!.workingDir,
+ branch: 'cindy-make/run',
+ });
+ });
+ it('retains a durable unfinished record when cleanup fails', async () => {
+ h.clean.mockRejectedValue(new Error('locked directory'));
+ await expect(manageCindyMakeTask('session', 'delete')).rejects.toThrow('cleanupFailed');
+ expect(h.row!.status).toBe('deleted');
+ expect(h.persist).not.toHaveBeenCalled();
+ expect(h.forget).not.toHaveBeenCalled();
+ h.clean.mockResolvedValue(true);
+ await expect(manageCindyMakeTask('session', 'delete')).resolves.toBeUndefined();
+ expect(h.forget).toHaveBeenCalledWith('run');
+ });
+ it('keeps global snapshots readable when the database closes during cleanup', async () => {
+ let settle!: () => void;
+ h.recycle.mockImplementationOnce(
+ () =>
+ new Promise<void>((done) => {
+ settle = done;
+ }),
+ );
+ const operation = manageCindyMakeTask('session', 'delete');
+ await vi.waitFor(() => expect(h.recycle).toHaveBeenCalled());
+ h.dbReady = false;
+ expect(actionManager.getState().taskActions?.session).toBeUndefined();
+ settle();
+ await expect(operation).rejects.toThrow('unavailable');
+ expect(h.clean).not.toHaveBeenCalled();
+ expect(actionManager.getState().taskActions?.session).toBeUndefined();
+ });
+ it('does not hide an unmerged archived task', async () => {
+ h.clean.mockResolvedValue(false);
+ await recycleCindyMakeTask('session', db, () => h.current);
+ expect(h.persist).not.toHaveBeenCalled();
+ expect(h.forget).not.toHaveBeenCalled();
+ });
+ it('does not authorize residual deletion from another preparation record', async () => {
+ const content = JSON.parse(h.content);
+ content.__cindyMakeCard.data.report.task.sessionId = 'someone-else';
+ h.content = JSON.stringify(content);
+ await manageCindyMakeTask('session', 'delete');
+ expect(h.clean.mock.calls[0][5].preparedWorkspace).toBeUndefined();
+ });
+ it('passes file-in-use failures through to the cleanup action', async () => {
+ h.clean.mockRejectedValue(Object.assign(new Error('locked'), { code: 'directoryBusy' }));
+ await expect(manageCindyMakeTask('session', 'delete')).rejects.toThrow('directoryBusy');
+ expect(actionManager.getState().taskActions?.session).toEqual({
+ action: 'delete',
+ status: 'failed',
+ error: 'directoryBusy',
+ });
+ expect(h.persist).not.toHaveBeenCalled();
+ expect(h.forget).not.toHaveBeenCalled();
+ });
+ it('can delete a managed workspace even when its preparation card is damaged', async () => {
+ h.content = '{invalid';
+ await expect(manageCindyMakeTask('session', 'delete')).resolves.toBeUndefined();
+ expect(h.clean).toHaveBeenCalled();
+ expect(h.persist).not.toHaveBeenCalled();
+ expect(h.forget).toHaveBeenCalledWith('run');
+ });
+ it('refuses finish while running and refuses cleanup when shutdown did not succeed', async () => {
+ h.running = true;
+ await expect(manageCindyMakeTask('session', 'finish')).rejects.toThrow('busy');
+ expect(h.patch).not.toHaveBeenCalled();
+ h.alive = true;
+ await expect(recycleCindyMakeTask('session', db, () => true)).rejects.toMatchObject({
+ code: 'busy',
+ });
+ expect(h.clean).not.toHaveBeenCalled();
+ });
+ it('protects other active references and changed ownership', async () => {
+ h.borrowers = [{ id: 'another-session', status: 'active' }];
+ await expect(recycleCindyMakeTask('session', db, () => true)).rejects.toMatchObject({
+ code: 'busy',
+ });
+ h.current = false;
+ await expect(manageCindyMakeTask('session', 'delete')).rejects.toThrow();
+ expect(h.clean).not.toHaveBeenCalled();
+ });
+ it('does not report success when a task was restored during cleanup', async () => {
+ h.row!.status = 'active';
+ await expect(recycleCindyMakeTask('session', db, () => true, 'finish')).rejects.toMatchObject({
+ code: 'unavailable',
+ });
+ expect(h.clean).not.toHaveBeenCalled();
+ });
+ it('ignores unrelated sessions and refuses managed actions on them', async () => {
+ h.row!.source = 'desktop';
+ await recycleCindyMakeTask('session', db, () => true);
+ await expect(manageCindyMakeTask('session', 'delete')).rejects.toThrow();
+ expect(h.clean).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskRuntime.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskRuntime.test.ts
new file mode 100644
index 0000000000..8e74f395d5
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskRuntime.test.ts
@@ -0,0 +1,893 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import os from 'node:os';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+
+const harness = vi.hoisted(() => ({
+ select: vi.fn(),
+ readBoundary: vi.fn(),
+ insert: vi.fn(),
+ values: vi.fn(),
+ reads: [] as Array<unknown[] | (() => unknown[])>,
+ updateMessage: vi.fn(),
+ createMessage: vi.fn(),
+ emit: vi.fn(),
+ prepare: vi.fn(),
+ environment: vi.fn(),
+ source: vi.fn(),
+ prepareSource: vi.fn(),
+ workspace: vi.fn(),
+ install: vi.fn(),
+ send: vi.fn(),
+ current: true,
+ clearBoundary: null as number | null,
+ dbClearBoundary: null as number | null,
+ firstMessages: [] as Array<{ id: string }>,
+ effective: undefined as Record<string, unknown> | undefined,
+ rows: [] as Array<Record<string, unknown>>,
+ cards: new Map<string, unknown>(),
+ userData: '',
+}));
+vi.mock('electron', () => ({
+ app: { getPath: () => harness.userData, getVersion: () => '1.0.0', isPackaged: false },
+}));
+vi.mock('../toolchainEnvironment.js', () => ({
+ createMakeToolchainEnvironment: harness.environment,
+ resolveMakeToolEnvironment: vi.fn(async () => ({ PATH: '/managed' })),
+}));
+vi.mock('../prepare.js', () => ({ prepareCindyMakeEnvironment: harness.prepare }));
+vi.mock('../sourcePreparation.js', () => ({
+ prepareCindySource: harness.prepareSource,
+ readCurrentCindySourceStatus: harness.source,
+}));
+vi.mock('../taskWorkspace.js', () => ({
+ createCindyMakeWorktree: harness.workspace,
+ installCindyMakeWorktree: harness.install,
+}));
+vi.mock('../../localDb/client/current.js', () => ({ getDbClient: () => client }));
+vi.mock('../../localDb/ipc/messages.js', () => ({
+ createMessage: harness.createMessage,
+ updateMessageContent: harness.updateMessage,
+}));
+vi.mock('../../localDb/ipc/sessionCreatedBroadcast.js', () => ({
+ emitSessionCreated: harness.emit,
+}));
+vi.mock('../../device-link/broadcast-tap.js', () => ({
+ captureDataOwnerBroadcastScope: () => ({}),
+ isDataOwnerBroadcastScopeCurrent: () => harness.current,
+}));
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ warn: vi.fn() }) }));
+vi.mock('../../i18n.js', () => ({ t: (key: string) => key }));
+vi.mock('../../maker-ipc/sessionRuntimeControl.js', () => ({
+ getSessionRuntimeControlSnapshot: () => ({ effectiveOverride: harness.effective }),
+}));
+
+import { cindyMakeManager } from '../manager.js';
+import {
+ assertCindyMakeTaskReady,
+ CINDY_MAKE_TASK_DISPATCH,
+ configureCindyMakeTaskSender,
+ restoreCindyMakeTaskState,
+ startCindyMakeTask,
+ validateCindyMakeTaskStart,
+} from '../taskRuntime.js';
+import { MAKE_DOCTOR_CHECK_IDS } from '../../../shared/cindyMakeDoctor.js';
+import { sessionCreateToRow } from '../../localDb/mapper.js';
+import { normalizeWorkingDirForStorage } from '../../../shared/workingDir.js';
+import * as sourcePaths from '../sourcePaths.js';
+
+const client = { drizzle: { select: harness.select, insert: harness.insert } };
+let sequence = 0;
+const origin = {
+ id: 'origin',
+ status: 'active',
+ agentKind: 'codex' as const,
+ model: 'origin-model',
+ effort: 'high',
+ providerId: 'origin-provider',
+ fastMode: true,
+ planModeEnabled: true,
+ permissionMode: 'ask',
+ remoteHostId: null,
+};
+function input() {
+ return {
+ originSessionId: origin.id,
+ runId: 'runtime-' + ++sequence,
+ request: ' 修复滚动,保留原文 ',
+ title: 'Cindy Make: 修复滚动',
+ };
+}
+function deferred() {
+ let resolve!: () => void;
+ const promise = new Promise<void>((done) => {
+ resolve = done;
+ });
+ return { promise, resolve };
+}
+function initialReads() {
+ harness.reads.push([origin], [], () => [harness.rows.at(-1)!]);
+}
+
+beforeEach(() => {
+ vi.restoreAllMocks();
+ vi.clearAllMocks();
+ harness.current = true;
+ harness.clearBoundary = null;
+ harness.dbClearBoundary = null;
+ harness.firstMessages = [];
+ harness.effective = undefined;
+ harness.rows = [];
+ harness.reads = [];
+ harness.cards.clear();
+ harness.userData = path.join(os.tmpdir(), 'cindy-make-runtime-unit');
+ harness.readBoundary.mockImplementation(async () => [{ clearedAt: harness.dbClearBoundary }]);
+ harness.select.mockImplementation((selection) => {
+ const builder: Record<string, unknown> = {};
+ for (const key of ['from', 'innerJoin', 'where', 'orderBy']) builder[key] = () => builder;
+ const read = async () => {
+ if (selection && Object.keys(selection).length === 1) {
+ if ('clearedAt' in selection) return harness.readBoundary();
+ if ('id' in selection) return harness.firstMessages;
+ }
+ const rows = harness.reads.shift();
+ return typeof rows === 'function' ? rows() : (rows ?? []);
+ };
+ builder.limit = read;
+ builder.then = (resolve: (rows: unknown[]) => unknown, reject: (error: unknown) => unknown) =>
+ read().then(resolve, reject);
+ return builder;
+ });
+ harness.insert.mockReturnValue({ values: harness.values });
+ harness.values.mockImplementation(async (row) => {
+ harness.rows.push(row);
+ });
+ harness.updateMessage.mockImplementation(async (_id, key, content) => {
+ harness.cards.set(key, content);
+ return { id: key };
+ });
+ harness.createMessage.mockImplementation(async (_id, body, options) => {
+ if (options.expectedClearBoundaryMs !== harness.dbClearBoundary)
+ throw new Error('Task preparation was cleared');
+ harness.cards.set(body.clientId, body.content);
+ return { id: body.clientId };
+ });
+ harness.environment.mockResolvedValue({ processEnvironment: () => ({ PATH: '/managed' }) });
+ harness.prepare.mockImplementation(async (runId, _env, _root, _signal, publish) => {
+ const report = {
+ runId,
+ status: 'completed',
+ checks: MAKE_DOCTOR_CHECK_IDS.map((id) => ({ id, status: 'passed' })),
+ platform: 'win32',
+ arch: 'x64',
+ };
+ publish(report);
+ return report;
+ });
+ harness.source.mockResolvedValue({ status: 'ready', path: '/source', branch: 'cindy-personal' });
+ harness.workspace.mockImplementation(async (userData, runId) => ({
+ path: sourcePaths.makeTaskWorktreePath(userData, runId),
+ branch: 'cindy-make/' + runId,
+ baseCommit: 'base',
+ }));
+ harness.install.mockResolvedValue(undefined);
+ harness.send.mockResolvedValue({ accepted: true });
+ configureCindyMakeTaskSender(harness.send, () => harness.clearBoundary);
+});
+
+describe('Cindy Make task runtime', () => {
+ it('creates exactly one task from home preferences and exposes it before dependencies finish', async () => {
+ const start = {
+ ...input(),
+ originSessionId: undefined,
+ createOptions: {
+ agentKind: 'pi' as const,
+ model: 'home-model',
+ effort: 'high',
+ providerId: 'home-provider',
+ permissionMode: 'acceptEdits',
+ planModeEnabled: true,
+ fastMode: true,
+ },
+ };
+ harness.reads.push([], () => [harness.rows.at(-1)!]);
+ const gate = deferred();
+ harness.install.mockImplementation(
+ async (_userData, _workspace, _signal, _deps, _phase, publish) => {
+ publish({ resolved: 10, reused: 6, downloaded: 4, added: 8 });
+ await gate.promise;
+ },
+ );
+ const sessionId = await startCindyMakeTask(start, 1);
+ await vi.waitFor(() => expect(harness.install).toHaveBeenCalledOnce());
+ expect(harness.rows).toHaveLength(1);
+ expect(harness.rows[0]).toMatchObject({
+ ...start.createOptions,
+ id: sessionId,
+ source: 'cindy-make',
+ });
+ expect(harness.emit).toHaveBeenCalledWith(sessionId);
+ expect(harness.send).not.toHaveBeenCalled();
+ expect(cindyMakeManager.taskReport(start.runId)?.task).toMatchObject({
+ phase: 'dependencies',
+ dependencies: { downloaded: 4 },
+ });
+ gate.resolve();
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.send).toHaveBeenCalledOnce();
+ });
+
+ it.each([
+ { agentKind: ['cc'] },
+ { fastMode: 'true' },
+ { workingDir: '/untrusted' },
+ { model: 'x'.repeat(501) },
+ ])('rejects malformed home preferences before creating a task: %j', (createOptions) => {
+ expect(() =>
+ validateCindyMakeTaskStart({ ...input(), originSessionId: undefined, createOptions }),
+ ).toThrow('Invalid Cindy Make preferences');
+ });
+ it.each([false, true])(
+ 'dispatches with the real mapper and Windows paths after initial persistence failure=%s',
+ async (failInitialPersistence) => {
+ const start = input();
+ harness.userData = path.win32.resolve('C:/', 'cindy-make-runtime-unit');
+ vi.spyOn(sourcePaths, 'makeTaskWorktreePath').mockImplementation((userData, runId) =>
+ path.win32.resolve(userData, 'cindy-make', 'worktrees', runId),
+ );
+ if (failInitialPersistence) {
+ harness.reads.push([origin], []);
+ harness.updateMessage.mockRejectedValueOnce(new Error('disk full'));
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('disk full');
+ harness.reads.push(
+ [origin],
+ [],
+ () => [harness.rows[0]],
+ () => [harness.rows[0]],
+ );
+ } else initialReads();
+ const sessionId = await startCindyMakeTask(start, 1);
+ await cindyMakeManager.waitForTask(start.runId);
+ const workspacePath = sourcePaths.makeTaskWorktreePath(harness.userData, start.runId);
+ expect(harness.rows).toHaveLength(1);
+ expect(harness.rows[0].workingDir).not.toBe(workspacePath);
+ expect(harness.rows[0].workingDir).toBe(normalizeWorkingDirForStorage(workspacePath));
+ expect(harness.send).toHaveBeenCalledOnce();
+ expect(harness.send).toHaveBeenCalledWith(
+ sessionId,
+ start.request,
+ expect.objectContaining({ workingDir: workspacePath }),
+ expect.anything(),
+ );
+ expect(cindyMakeManager.taskReport(start.runId)?.status).toBe('completed');
+ },
+ );
+
+ it.each(['before-db-write', 'persisted'] as const)(
+ 'does not dispatch or recreate preparation messages after clear is %s',
+ async (clearStage) => {
+ const start = input();
+ initialReads();
+ const gate = deferred();
+ harness.install.mockImplementation(async () => gate.promise);
+ await startCindyMakeTask(start, 1);
+ await vi.waitFor(() => expect(harness.install).toHaveBeenCalledOnce());
+ const previousWrites = harness.updateMessage.mock.calls.length;
+ harness.clearBoundary = Date.now();
+ if (clearStage === 'persisted') {
+ harness.dbClearBoundary = harness.clearBoundary;
+ harness.rows[0].clearedAt = harness.clearBoundary;
+ }
+ gate.resolve();
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.send).not.toHaveBeenCalled();
+ expect(harness.updateMessage).toHaveBeenCalledTimes(previousWrites);
+ expect(harness.createMessage).not.toHaveBeenCalled();
+ expect(cindyMakeManager.getState().tasks?.[start.runId]).toBeUndefined();
+ },
+ );
+
+ it('does not recreate a missing preparation message when clear wins the update await', async () => {
+ const start = input();
+ harness.reads.push([origin], []);
+ harness.updateMessage.mockImplementationOnce(async () => {
+ harness.clearBoundary = Date.now();
+ return null;
+ });
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('Task preparation was cleared');
+ expect(harness.createMessage).not.toHaveBeenCalled();
+ expect(harness.prepare).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ });
+
+ it('passes clear cancellation to the sender while first dispatch is preparing', async () => {
+ const start = input();
+ initialReads();
+ const gate = deferred();
+ const providerStart = vi.fn();
+ harness.send.mockImplementation(async (_sessionId, _message, _createOpts, sendOpts) => {
+ await gate.promise;
+ if (sendOpts.signal.aborted) return { accepted: false, reason: 'cancelled-before-dispatch' };
+ providerStart();
+ return { accepted: true };
+ });
+ const sessionId = await startCindyMakeTask(start, 1);
+ await vi.waitFor(() => expect(harness.send).toHaveBeenCalledOnce());
+ expect(cindyMakeManager.taskReport(start.runId)?.task?.phase).toBe('starting');
+ harness.clearBoundary = Date.now();
+ cindyMakeManager.cancelTasksForSession(sessionId);
+ gate.resolve();
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(providerStart).not.toHaveBeenCalled();
+ expect(cindyMakeManager.getState().tasks?.[start.runId]).toBeUndefined();
+ });
+
+ it('guards a new preparation message insert against a durable clear race', async () => {
+ const start = input();
+ harness.reads.push([origin], []);
+ harness.updateMessage.mockImplementationOnce(async () => {
+ harness.dbClearBoundary = Date.now();
+ return null;
+ });
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('Task preparation was cleared');
+ expect(harness.createMessage).toHaveBeenCalledWith(
+ harness.rows[0].id,
+ expect.objectContaining({ clientId: 'cindy-make-preparation-' + start.runId }),
+ expect.objectContaining({
+ expectedClearBoundaryMs: null,
+ shouldBroadcast: expect.any(Function),
+ }),
+ );
+ expect(harness.cards.size).toBe(0);
+ expect(harness.prepare).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ });
+
+ it('ignores restoration results from before an in-memory clear boundary', async () => {
+ const start = input();
+ harness.clearBoundary = Date.now();
+ harness.reads.push([
+ {
+ sessionId: 'cleared-task',
+ clientId: 'cindy-make-preparation-' + start.runId,
+ clearedAt: null,
+ content: JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ report: {
+ runId: start.runId,
+ checks: [],
+ status: 'running',
+ task: { sessionId: 'cleared-task', phase: 'dependencies' },
+ },
+ },
+ },
+ }),
+ },
+ ]);
+ await restoreCindyMakeTaskState();
+ expect(cindyMakeManager.taskReport(start.runId)).toBeUndefined();
+ expect(harness.updateMessage).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ });
+
+ it.each(['dependencies', 'starting'] as const)(
+ 'restores persisted %s state in Main without replaying a request',
+ async (phase) => {
+ const start = input();
+ const sessionId = 'restored-' + start.runId;
+ const report = {
+ runId: start.runId,
+ status: 'running',
+ checks: [],
+ task: { phase, sessionId, originSessionId: origin.id, request: start.request },
+ };
+ harness.reads.push([
+ {
+ sessionId,
+ clientId: 'cindy-make-preparation-' + start.runId,
+ clearedAt: null,
+ content: JSON.stringify({
+ __cindyMakeCard: { data: { request: start.request, report } },
+ }),
+ },
+ ]);
+ harness.firstMessages = [{ id: 'persisted-before-provider-dispatch' }];
+ await restoreCindyMakeTaskState();
+ expect(cindyMakeManager.getState().tasks?.[start.runId]?.status).toBe('cancelled');
+ expect(harness.updateMessage).toHaveBeenCalledOnce();
+ expect(harness.send).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['archived', 'deleted'] as const)(
+ 'restores unfinished %s tasks for reopening or cleanup retry',
+ async (sessionStatus) => {
+ const start = input();
+ const sessionId = 'restored-' + start.runId;
+ const report = {
+ runId: start.runId,
+ status: 'completed',
+ checks: [],
+ task: { phase: 'completed', sessionId, request: start.request },
+ };
+ const row = {
+ sessionId,
+ sessionStatus,
+ clearedAt: null,
+ clientId: 'cindy-make-preparation-' + start.runId,
+ content: JSON.stringify({ __cindyMakeCard: { data: { report } } }),
+ };
+ harness.reads.push([row]);
+ await restoreCindyMakeTaskState();
+ expect(cindyMakeManager.getState().tasks?.[start.runId]?.task?.sessionStatus).toBe(
+ sessionStatus,
+ );
+ expect(harness.send).not.toHaveBeenCalled();
+ harness.reads.push([
+ {
+ ...row,
+ content: JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ report: { ...report, task: { ...report.task, finished: true } },
+ },
+ },
+ }),
+ },
+ ]);
+ await restoreCindyMakeTaskState();
+ expect(cindyMakeManager.getState().tasks?.[start.runId]).toBeUndefined();
+ expect(harness.send).not.toHaveBeenCalled();
+ expect(harness.updateMessage).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['running', 'failed', 'cancelled'])(
+ 'blocks ordinary sends for a persisted %s preparation',
+ async (status) => {
+ harness.reads.push([
+ { content: JSON.stringify({ __cindyMakeCard: { data: { report: { status } } } }) },
+ ]);
+ await expect(assertCindyMakeTaskReady('created')).rejects.toThrow(
+ 'Retry Cindy Make preparation',
+ );
+ },
+ );
+
+ it('allows completed preparations and legacy tasks without a preparation card', async () => {
+ harness.reads.push(
+ [
+ {
+ content: JSON.stringify({
+ __cindyMakeCard: { data: { report: { status: 'completed' } } },
+ }),
+ },
+ ],
+ [],
+ );
+ await expect(assertCindyMakeTaskReady('created')).resolves.toBeUndefined();
+ await expect(assertCindyMakeTaskReady('legacy')).resolves.toBeUndefined();
+ });
+
+ it('only blocks on the newest preparation visible after clear and rewind', async () => {
+ const sqlite = new Database(':memory:');
+ try {
+ sqlite.exec(`
+ CREATE TABLE sessions (id TEXT PRIMARY KEY, cleared_at INTEGER);
+ CREATE TABLE messages (
+ session_id TEXT, client_id TEXT, content TEXT, created_at INTEGER, rewind_at INTEGER
+ );
+ INSERT INTO sessions VALUES ('created', 100), ('other', NULL);
+ `);
+ const db = drizzle(sqlite);
+ harness.select.mockImplementation(db.select.bind(db));
+ const add = (
+ id: string,
+ status: string,
+ createdAt: number,
+ rewindAt: number | null = null,
+ sid = 'created',
+ ) =>
+ sqlite
+ .prepare('INSERT INTO messages VALUES (?, ?, ?, ?, ?)')
+ .run(
+ sid,
+ 'cindy-make-preparation-' + id,
+ JSON.stringify({ __cindyMakeCard: { data: { report: { status } } } }),
+ createdAt,
+ rewindAt,
+ );
+ add('before-clear', 'failed', 99);
+ add('at-clear', 'cancelled', 100);
+ add('rewound', 'running', 101, 102);
+ add('other-task', 'failed', 103, null, 'other');
+ await expect(assertCindyMakeTaskReady('created')).resolves.toBeUndefined();
+ expect(sqlite.prepare('SELECT COUNT(*) AS count FROM messages').get()).toEqual({ count: 4 });
+
+ add('visible', 'failed', 110);
+ await expect(assertCindyMakeTaskReady('created')).rejects.toThrow(
+ 'Retry Cindy Make preparation',
+ );
+ sqlite.prepare('UPDATE messages SET rewind_at = 111 WHERE created_at = 110').run();
+ await expect(assertCindyMakeTaskReady('created')).resolves.toBeUndefined();
+
+ add('completed', 'completed', 120);
+ await expect(assertCindyMakeTaskReady('created')).resolves.toBeUndefined();
+ add('latest', 'cancelled', 121);
+ await expect(assertCindyMakeTaskReady('created')).rejects.toThrow(
+ 'Retry Cindy Make preparation',
+ );
+ } finally {
+ sqlite.close();
+ }
+ });
+
+ it.each(['active', 'archived', 'deleted', 'missing'])(
+ 'reuses a task after initial message persistence fails when its origin is %s',
+ async (originStatus) => {
+ const start = input();
+ harness.reads.push([origin], []);
+ harness.updateMessage.mockRejectedValueOnce(new Error('disk full'));
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('disk full');
+ expect(harness.rows).toHaveLength(1);
+ harness.reads.push(
+ originStatus === 'missing' ? [] : [{ ...origin, status: originStatus }],
+ [],
+ () => [harness.rows[0]],
+ () => [harness.rows[0]],
+ );
+ expect(await startCindyMakeTask(start, 1)).toBe(harness.rows[0].id);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.rows).toHaveLength(1);
+ expect(harness.send).toHaveBeenCalledOnce();
+ },
+ );
+
+ it('publishes a titled task before installation and automatically sends the original request after it completes', async () => {
+ const start = input();
+ initialReads();
+ const gate = deferred();
+ harness.install.mockImplementation(
+ async (_root, _workspace, signal, _deps, _phase, progress) => {
+ progress({ resolved: 10, reused: 4, downloaded: 6, added: 10 });
+ await gate.promise;
+ signal.throwIfAborted();
+ },
+ );
+ const sessionId = await startCindyMakeTask(start, 1);
+ expect(harness.emit).toHaveBeenCalledWith(sessionId);
+ await vi.waitFor(() => expect(harness.install).toHaveBeenCalledOnce());
+ expect(harness.send).not.toHaveBeenCalled();
+ expect(harness.rows[0]).toMatchObject({
+ title: start.title,
+ source: 'cindy-make',
+ workingDir: normalizeWorkingDirForStorage(
+ sourcePaths.makeTaskWorktreePath(harness.userData, start.runId),
+ ),
+ });
+ expect(cindyMakeManager.taskReport(start.runId)).toMatchObject({
+ status: 'running',
+ task: { phase: 'dependencies', dependencies: { downloaded: 6 } },
+ });
+ gate.resolve();
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.send).toHaveBeenCalledOnce();
+ expect(harness.send).toHaveBeenCalledWith(
+ sessionId,
+ start.request,
+ expect.objectContaining({
+ model: origin.model,
+ effort: origin.effort,
+ providerId: origin.providerId,
+ permissionMode: 'ask',
+ planMode: true,
+ fastMode: true,
+ }),
+ expect.objectContaining({
+ [CINDY_MAKE_TASK_DISPATCH]: true,
+ signal: expect.any(AbortSignal),
+ expectedClearBoundaryMs: null,
+ persistUserMessage: expect.objectContaining({
+ clientId: 'cindy-make-first-' + start.runId,
+ content: start.request,
+ expectedClearBoundaryMs: null,
+ }),
+ }),
+ );
+ expect(cindyMakeManager.taskReport(start.runId)?.status).toBe('completed');
+ });
+
+ it.each(['cc', 'codex', 'pi'])(
+ 'inherits the effective %s runtime, including cleared provider and effort',
+ async (agentKind) => {
+ const start = input();
+ harness.effective = {
+ agentKind: agentKind === 'cc' ? 'claude-code' : agentKind,
+ model: 'effective-model',
+ effort: undefined,
+ providerId: null,
+ fastMode: false,
+ };
+ initialReads();
+ await startCindyMakeTask(start, 1);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.rows[0]).toMatchObject({
+ agentKind,
+ model: 'effective-model',
+ effort: '',
+ providerId: null,
+ fastMode: false,
+ permissionMode: 'ask',
+ planModeEnabled: true,
+ });
+ expect(harness.send).toHaveBeenCalledOnce();
+ },
+ );
+
+ it.each(['cancel', 'owner', 'archive', 'directory'] as const)(
+ 'does not dispatch after %s changes during preparation',
+ async (change) => {
+ const start = input();
+ initialReads();
+ const gate = deferred();
+ harness.install.mockImplementation(async (_root, _workspace, signal) => {
+ await gate.promise;
+ signal.throwIfAborted();
+ });
+ await startCindyMakeTask(start, 1);
+ await vi.waitFor(() => expect(harness.install).toHaveBeenCalledOnce());
+ if (change === 'cancel') cindyMakeManager.cancel(start.runId, 1);
+ if (change === 'owner') harness.current = false;
+ if (change === 'archive') harness.rows[0].status = 'archived';
+ if (change === 'directory') harness.rows[0].workingDir = '/different';
+ gate.resolve();
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.send).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['active', 'archived', 'deleted', 'missing'])(
+ 'retries a rejected first dispatch in the existing task when its origin is %s',
+ async (originStatus) => {
+ const start = input();
+ initialReads();
+ harness.send.mockResolvedValueOnce({ accepted: false, reason: 'unavailable' });
+ const sessionId = await startCindyMakeTask(start, 1);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(cindyMakeManager.taskReport(start.runId)?.status).toBe('failed');
+ const content = harness.cards.get('cindy-make-preparation-' + start.runId);
+ harness.reads.push(
+ originStatus === 'missing' ? [] : [{ ...origin, status: originStatus }],
+ [
+ {
+ sessionId,
+ status: 'active',
+ content: JSON.stringify(content),
+ clearedAt: null,
+ createdAt: Date.now(),
+ },
+ ],
+ () => [harness.rows[0]],
+ );
+ harness.firstMessages = [{ id: 'accepted-but-not-dispatched-user-row' }];
+ expect(await startCindyMakeTask(start, 1)).toBe(sessionId);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.rows).toHaveLength(1);
+ expect(harness.send).toHaveBeenCalledTimes(2);
+ expect(cindyMakeManager.taskReport(start.runId)?.status).toBe('completed');
+ },
+ );
+
+ it.each(['running', 'cancelled'] as const)(
+ 'explicitly retries an interrupted %s preparation even with a persisted first user message',
+ async (status) => {
+ const start = input();
+ const sessionId = 'retry-' + start.runId;
+ const createdAt = Date.now();
+ harness.clearBoundary = createdAt - 1000;
+ harness.dbClearBoundary = harness.clearBoundary;
+ const row = {
+ ...sessionCreateToRow(
+ sessionId,
+ {
+ ...origin,
+ workingDir: sourcePaths.makeTaskWorktreePath(harness.userData, start.runId),
+ source: 'cindy-make',
+ },
+ createdAt,
+ ),
+ clearedAt: harness.clearBoundary,
+ };
+ harness.rows.push(row);
+ harness.firstMessages = [{ id: 'user-row-without-provider-acceptance' }];
+ harness.reads.push(
+ [origin],
+ [
+ {
+ sessionId,
+ status: 'active',
+ createdAt,
+ clearedAt: harness.clearBoundary,
+ content: JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ request: start.request,
+ report: {
+ runId: start.runId,
+ status,
+ checks: [],
+ task: {
+ sessionId,
+ originSessionId: origin.id,
+ phase: 'starting',
+ request: start.request,
+ title: start.title,
+ },
+ },
+ },
+ },
+ }),
+ },
+ ],
+ [row],
+ );
+ expect(await startCindyMakeTask(start, 1)).toBe(sessionId);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.values).not.toHaveBeenCalled();
+ expect(harness.send).toHaveBeenCalledOnce();
+ expect(harness.send).toHaveBeenCalledWith(
+ sessionId,
+ start.request,
+ expect.anything(),
+ expect.objectContaining({
+ signal: expect.any(AbortSignal),
+ expectedClearBoundaryMs: harness.clearBoundary,
+ persistUserMessage: expect.objectContaining({
+ clientId: 'cindy-make-first-' + start.runId,
+ content: start.request,
+ expectedClearBoundaryMs: harness.clearBoundary,
+ }),
+ }),
+ );
+ const sendOpts = harness.send.mock.calls[0][3];
+ expect(sendOpts.persistUserMessage.shouldBroadcast()).toBe(true);
+ harness.clearBoundary = createdAt + 1;
+ expect(sendOpts.persistUserMessage.shouldBroadcast()).toBe(false);
+ expect(cindyMakeManager.getState().tasks?.[start.runId]).toBeUndefined();
+ },
+ );
+
+ it('rejects a stale retry card whose task was cleared', async () => {
+ const start = input();
+ harness.reads.push(
+ [origin],
+ [
+ {
+ sessionId: 'cleared-task',
+ status: 'active',
+ createdAt: 100,
+ clearedAt: 200,
+ content: JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ request: start.request,
+ report: {
+ runId: start.runId,
+ status: 'cancelled',
+ checks: [],
+ task: {
+ sessionId: 'cleared-task',
+ originSessionId: origin.id,
+ phase: 'dependencies',
+ },
+ },
+ },
+ },
+ }),
+ },
+ ],
+ );
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('Task preparation was cleared');
+ expect(harness.updateMessage).not.toHaveBeenCalled();
+ expect(harness.createMessage).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ });
+
+ it('does not replay a preparation durably marked completed after a Main restart', async () => {
+ const start = input();
+ const sessionId = 'persisted-task';
+ harness.reads.push(
+ [origin],
+ [
+ {
+ sessionId,
+ status: 'active',
+ clearedAt: null,
+ createdAt: Date.now(),
+ content: JSON.stringify({
+ __cindyMakeCard: {
+ data: {
+ request: start.request,
+ report: {
+ runId: start.runId,
+ status: 'completed',
+ checks: [],
+ task: { sessionId, originSessionId: origin.id, phase: 'completed' },
+ },
+ },
+ },
+ }),
+ },
+ ],
+ );
+ expect(await startCindyMakeTask(start, 1)).toBe(sessionId);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.prepare).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ expect(harness.rows).toHaveLength(0);
+ });
+
+ it('prepares missing source only after the task is visible', async () => {
+ const start = input();
+ initialReads();
+ harness.source.mockResolvedValueOnce({ status: 'missing', path: '/source' });
+ harness.prepareSource.mockImplementation(async (_env, _root, _identity, _signal, progress) => {
+ expect(harness.emit).toHaveBeenCalledOnce();
+ progress({ status: 'preparing', path: '/source', target: { ref: 'main' }, phase: 'cloning' });
+ return { status: 'ready', path: '/source' };
+ });
+ await startCindyMakeTask(start, 1);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(harness.prepareSource).toHaveBeenCalledOnce();
+ expect(harness.send).toHaveBeenCalledOnce();
+ });
+
+ it.each(['environment', 'source', 'dependencies'])(
+ 'keeps the request without sending when %s fails',
+ async (phase) => {
+ const start = input();
+ initialReads();
+ if (phase === 'environment')
+ harness.prepare.mockRejectedValueOnce(new Error('environment failed'));
+ if (phase === 'source') {
+ harness.source.mockResolvedValueOnce({ status: 'missing' });
+ harness.prepareSource.mockResolvedValueOnce({ status: 'failed', error: 'gitFailed' });
+ }
+ if (phase === 'dependencies')
+ harness.install.mockRejectedValueOnce(new Error('install failed'));
+ await startCindyMakeTask(start, 1);
+ await cindyMakeManager.waitForTask(start.runId);
+ expect(cindyMakeManager.taskReport(start.runId)).toMatchObject({
+ status: 'failed',
+ task: { request: start.request },
+ });
+ expect(harness.send).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['archived', 'deleted', 'missing'])(
+ 'rejects a new preparation when its origin is %s',
+ async (originStatus) => {
+ harness.reads.push(
+ originStatus === 'missing' ? [] : [{ ...origin, status: originStatus }],
+ [],
+ );
+ await expect(startCindyMakeTask(input(), 1)).rejects.toThrow('Origin task is unavailable');
+ expect(harness.values).not.toHaveBeenCalled();
+ expect(harness.prepare).not.toHaveBeenCalled();
+ expect(harness.send).not.toHaveBeenCalled();
+ },
+ );
+
+ it('rejects remote origins and invalid run ids before creating a task', async () => {
+ const start = input();
+ expect(() => validateCindyMakeTaskStart({ ...start, runId: '../escape' })).toThrow();
+ expect(() => validateCindyMakeTaskStart({ ...start, request: ' ' })).toThrow();
+ harness.reads.push([{ ...origin, remoteHostId: 'remote-host' }]);
+ await expect(startCindyMakeTask(start, 1)).rejects.toThrow('local task');
+ expect(harness.rows).toHaveLength(0);
+ expect(harness.send).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/cindy-make/__tests__/taskWorkspace.test.ts b/apps/desktop/src/main/cindy-make/__tests__/taskWorkspace.test.ts
index cd739b6450..273def4efc 100644
--- a/apps/desktop/src/main/cindy-make/__tests__/taskWorkspace.test.ts
+++ b/apps/desktop/src/main/cindy-make/__tests__/taskWorkspace.test.ts
@@ -3,7 +3,12 @@ import os from 'node:os';
import path from 'node:path';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { isCindyMakeWorktreePath, prepareCindyMakeWorkspace } from '../taskWorkspace';
+import {
+ createCindyMakeWorktree,
+ installCindyMakeWorktree,
+ isCindyMakeWorktreePath,
+ prepareCindyMakeWorkspace,
+} from '../taskWorkspace';
describe('prepareCindyMakeWorkspace', () => {
let userData: string;
@@ -116,6 +121,38 @@ describe('prepareCindyMakeWorkspace', () => {
});
});
+describe('split Cindy Make workspace preparation', () => {
+ it('creates the worktree without pnpm, then installs in a separate step', async () => {
+ const userData = await mkdtemp(path.join(os.tmpdir(), 'cindy-make-split-'));
+ try {
+ await mkdir(path.join(userData, 'cindy-make', 'source', '.git'), { recursive: true });
+ const git = vi.fn(async (_env: NodeJS.ProcessEnv, args: string[]) => {
+ if (args[0] === 'branch' && args[2] === 'cindy-personal') return 'cindy-personal\n';
+ if (args[0] === 'rev-parse') return 'base123\n';
+ if (args[0] === 'worktree') return '';
+ return '';
+ });
+ const pnpm = vi.fn(async () => undefined);
+ const workspace = await createCindyMakeWorktree(
+ userData,
+ 'run-split',
+ new AbortController().signal,
+ { processEnvironment: {}, git, pnpm },
+ );
+ expect(pnpm).not.toHaveBeenCalled();
+ await installCindyMakeWorktree(
+ userData,
+ workspace,
+ new AbortController().signal,
+ { processEnvironment: {}, git, pnpm },
+ );
+ expect(pnpm).toHaveBeenCalledOnce();
+ } finally {
+ await rm(userData, { recursive: true, force: true });
+ }
+ });
+});
+
describe('isCindyMakeWorktreePath', () => {
const userData = path.resolve(os.tmpdir(), 'cindy-userdata');
const worktrees = path.join(userData, 'cindy-make', 'worktrees');
diff --git a/apps/desktop/src/main/cindy-make/doctorCommand.ts b/apps/desktop/src/main/cindy-make/doctorCommand.ts
index 93a436459f..50d3aac71b 100644
--- a/apps/desktop/src/main/cindy-make/doctorCommand.ts
+++ b/apps/desktop/src/main/cindy-make/doctorCommand.ts
@@ -1,4 +1,8 @@
import { randomUUID } from 'node:crypto';
+import {
+ captureDataOwnerBroadcastScope,
+ isDataOwnerBroadcastScopeCurrent,
+} from '../device-link/broadcast-tap.js';
import type { DesktopCommandContext, DesktopCommandDefinition } from '../commands/registry.js';
import { throwIpcError } from '../utils/ipcValidate.js';
import {
@@ -88,6 +92,7 @@ export function createMakeDoctorCommand<T extends MakeDoctorEnvironment>(deps: {
return { success: true };
}
const startedAt = Date.now();
+ const owner = captureDataOwnerBroadcastScope();
const timeoutMs = name === 'cindy-make' ? 20 * 60_000 : 60_000;
// Presence (including empty text) distinguishes the chat workflow from Settings preparation.
const workflow = name === 'cindy-make' && ctx.makeRequest !== undefined && !ctx.makeAction;
@@ -121,7 +126,8 @@ export function createMakeDoctorCommand<T extends MakeDoctorEnvironment>(deps: {
...(workflow ? { upstream: report.upstream ?? latest.upstream } : {}),
...(ctx.forceManagedTools ? { forceManagedTools: true } : {}),
};
- deps.publish(ctx, latest);
+ cindyMakeManager.setReport(latest, () => isDataOwnerBroadcastScopeCurrent(owner));
+ if (isDataOwnerBroadcastScopeCurrent(owner)) deps.publish(ctx, latest);
};
let managerOperation: CindyMakeOperationHandle<T>;
try {
diff --git a/apps/desktop/src/main/cindy-make/manager.ts b/apps/desktop/src/main/cindy-make/manager.ts
index f7d6511be4..42b34bf498 100644
--- a/apps/desktop/src/main/cindy-make/manager.ts
+++ b/apps/desktop/src/main/cindy-make/manager.ts
@@ -1,4 +1,49 @@
-import type { CindyMakeGlobalState, MakeDoctorReport } from '../../shared/cindyMakeDoctor.js';
+import type {
+ CindyMakeGlobalState,
+ CindyMakeTaskStart,
+ MakeDoctorReport,
+ MakeSourceStatus,
+ CindyMakeTaskActionState,
+ CindyMakeTaskError,
+} from '../../shared/cindyMakeDoctor.js';
+import { CINDY_MAKE_TASK_ERROR_CODES } from '../../shared/cindyMakeDoctor.js';
+import type { SourcePreparationProgress, SourcePreparationResult } from './sourcePreparation.js';
+import { untilAborted } from './doctor.js';
+
+interface SharedSourceJob {
+ clearOnly: boolean;
+ controller: AbortController;
+ latest?: SourcePreparationProgress;
+ status?: MakeSourceStatus;
+ listeners: Set<(progress: SourcePreparationProgress) => void>;
+ promise: Promise<SourcePreparationResult>;
+}
+
+export interface CindyMakeTaskLifecycle {
+ create: (previous?: MakeDoctorReport) => Promise<MakeDoctorReport>;
+ onCreated?: () => void;
+ prepare: (signal: AbortSignal, publish: (report: MakeDoctorReport) => void) => Promise<void>;
+ start: (signal: AbortSignal) => Promise<void>;
+ persist: (report: MakeDoctorReport) => Promise<void>;
+ isCurrent: () => boolean;
+ onError: (error: unknown) => void;
+}
+
+interface ActiveTask {
+ input: CindyMakeTaskStart;
+ controller: AbortController;
+ report?: MakeDoctorReport;
+ created: Promise<string>;
+ done?: Promise<void>;
+ lifecycle: CindyMakeTaskLifecycle;
+}
+
+interface TaskAction {
+ state: CindyMakeTaskActionState;
+ isCurrent: () => boolean;
+ promise: Promise<void>;
+ recycleOnly: boolean;
+}
export type CindyMakeOperationKey =
| { resource: 'environment'; mode: 'check' | 'prepare'; forceManagedTools: boolean }
@@ -10,7 +55,9 @@ function keyId(key: CindyMakeOperationKey): string {
return [key.resource, key.mode, key.forceManagedTools ? 'managed' : 'system'].join(':');
}
-function stateSlot(key: CindyMakeOperationKey): keyof CindyMakeGlobalState {
+function stateSlot(
+ key: CindyMakeOperationKey,
+): 'environmentCheck' | 'environmentPrepare' | 'sourcePrepare' | 'sourceClear' {
if (key.resource === 'environment')
return key.mode === 'check' ? 'environmentCheck' : 'environmentPrepare';
return key.mode === 'prepare' ? 'sourcePrepare' : 'sourceClear';
@@ -48,6 +95,446 @@ export class CindyMakeManager {
private readonly workflows = new Map<string, { sender: number; controller: AbortController }>();
private readonly states: CindyMakeGlobalState = {};
private readonly stateListeners = new Set<CindyMakeStateListener>();
+ private readonly sourceJobs = new Map<string, SharedSourceJob>();
+ private readonly projectJobs = new Map<string, Promise<unknown>>();
+ private readonly projectUsers = new Map<string, number>();
+ private readonly reports = new Map<
+ string,
+ { report: MakeDoctorReport; isCurrent: () => boolean }
+ >();
+ private readonly tasks = new Map<string, ActiveTask>();
+ private readonly taskActions = new Map<string, TaskAction>();
+ private readonly restoredTasks = new Map<
+ string,
+ { report: MakeDoctorReport; isCurrent: () => boolean }
+ >();
+ private sourceRevision = 0;
+ private isProjectBusy: (root: string) => boolean = () => false;
+
+ setProjectBusyProbe(probe: (root: string) => boolean): void {
+ this.isProjectBusy = probe;
+ }
+
+ private projectInUse(root: string): boolean {
+ return (this.projectUsers.get(root) ?? 0) > 0 || this.isProjectBusy(root);
+ }
+
+ async withProjectUse<T>(root: string, run: () => Promise<T>): Promise<T> {
+ if (this.sourceJobs.get(root)?.clearOnly)
+ throw Object.assign(new Error('project is being cleared'), { code: 'busy' });
+ this.projectUsers.set(root, (this.projectUsers.get(root) ?? 0) + 1);
+ try {
+ return await run();
+ } finally {
+ const users = (this.projectUsers.get(root) ?? 1) - 1;
+ if (users === 0) this.projectUsers.delete(root);
+ else this.projectUsers.set(root, users);
+ }
+ }
+
+ setReport(report: MakeDoctorReport, isCurrent: () => boolean): void {
+ if (!isCurrent()) return;
+ this.reports.set(report.runId, { report: structuredClone(report), isCurrent });
+ this.notify();
+ }
+
+ async withProject<T>(root: string, run: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+ const previous = this.projectJobs.get(root) ?? Promise.resolve();
+ const pending = previous
+ .catch(() => undefined)
+ .then(() => {
+ signal?.throwIfAborted();
+ return run();
+ })
+ .finally(() => {
+ if (this.projectJobs.get(root) === pending) this.projectJobs.delete(root);
+ });
+ this.projectJobs.set(root, pending);
+ return pending;
+ }
+
+ sourceStatus(root: string): MakeSourceStatus | undefined {
+ return this.sourceJobs.get(root)?.status;
+ }
+
+ isPreparingSource(root: string): boolean {
+ return this.sourceJobs.has(root);
+ }
+
+ setSourceStatus(status: MakeSourceStatus): void {
+ this.sourceRevision += 1;
+ this.states.source = status;
+ this.notify();
+ }
+
+ async refreshSourceStatus(read: () => Promise<MakeSourceStatus>): Promise<MakeSourceStatus> {
+ const revision = this.sourceRevision;
+ const status = await read();
+ if (revision !== this.sourceRevision && this.states.source)
+ return structuredClone(this.states.source);
+ this.setSourceStatus(status);
+ return status;
+ }
+
+ cancelSource(): boolean {
+ let cancelled = false;
+ for (const job of this.sourceJobs.values()) {
+ if (job.controller.signal.aborted) continue;
+ job.controller.abort('cancelled');
+ cancelled = true;
+ }
+ return cancelled;
+ }
+
+ async prepareSource(input: {
+ root: string;
+ clearOnly: boolean;
+ signal: AbortSignal;
+ cancelled: () => SourcePreparationResult;
+ onCancelledBeforeStart?: (result: SourcePreparationResult) => Promise<void>;
+ onProgress: (progress: SourcePreparationProgress) => void;
+ toStatus: (progress: SourcePreparationProgress) => MakeSourceStatus;
+ run: (
+ signal: AbortSignal,
+ publish: (progress: SourcePreparationProgress) => void,
+ ) => Promise<SourcePreparationResult>;
+ }): Promise<SourcePreparationResult> {
+ while (
+ this.sourceJobs.has(input.root) &&
+ this.sourceJobs.get(input.root)?.clearOnly !== input.clearOnly
+ ) {
+ if (input.signal.aborted) return input.cancelled();
+ await untilAborted(this.sourceJobs.get(input.root)!.promise, input.signal).catch(
+ () => undefined,
+ );
+ }
+ if (input.signal.aborted) return input.cancelled();
+ if (
+ input.clearOnly &&
+ (this.projectInUse(input.root) ||
+ [...this.tasks.values()].some(
+ (task) => task.lifecycle.isCurrent() && task.report?.status === 'running',
+ ))
+ ) {
+ throw Object.assign(new Error('task preparation is running'), { code: 'busy' });
+ }
+ let job = this.sourceJobs.get(input.root);
+ if (!job) {
+ job = {
+ clearOnly: input.clearOnly,
+ controller: new AbortController(),
+ listeners: new Set(),
+ promise: Promise.resolve(input.cancelled()),
+ };
+ const current = job;
+ this.sourceJobs.set(input.root, current);
+ current.latest = {
+ ...input.cancelled(),
+ status: 'preparing',
+ error: undefined,
+ phase: this.projectJobs.has(input.root) ? 'waiting' : 'checking',
+ };
+ current.status = input.toStatus(current.latest);
+ this.setSourceStatus(current.status);
+ current.promise = this.withProject(input.root, async () => {
+ if (current.controller.signal.aborted) {
+ const result = input.cancelled();
+ await input.onCancelledBeforeStart?.(result);
+ current.latest = result;
+ current.status = input.toStatus(result);
+ this.setSourceStatus(current.status);
+ for (const listener of current.listeners) {
+ try {
+ listener(result);
+ } catch {}
+ }
+ return result;
+ }
+ if (input.clearOnly && this.projectInUse(input.root))
+ throw Object.assign(new Error('project is in use'), { code: 'busy' });
+ return input.run(current.controller.signal, (progress) => {
+ current.latest = progress;
+ current.status = input.toStatus(progress);
+ this.setSourceStatus(current.status);
+ for (const listener of current.listeners) {
+ try {
+ listener(progress);
+ } catch {}
+ }
+ });
+ })
+ .catch((error) => {
+ const result: SourcePreparationResult = current.controller.signal.aborted
+ ? input.cancelled()
+ : {
+ ...input.cancelled(),
+ status: 'failed',
+ error: (error as { code?: unknown })?.code === 'busy' ? 'locked' : 'gitFailed',
+ };
+ current.status = input.toStatus(result);
+ this.setSourceStatus(current.status);
+ return result;
+ })
+ .finally(() => {
+ if (this.sourceJobs.get(input.root) === current) this.sourceJobs.delete(input.root);
+ });
+ }
+ const current = job;
+ const abort = () => current.controller.abort(input.signal.reason);
+ current.listeners.add(input.onProgress);
+ input.signal.addEventListener('abort', abort, { once: true });
+ if (current.latest) input.onProgress(current.latest);
+ try {
+ return await current.promise;
+ } finally {
+ current.listeners.delete(input.onProgress);
+ input.signal.removeEventListener('abort', abort);
+ }
+ }
+
+ startTask(input: CindyMakeTaskStart, lifecycle: CindyMakeTaskLifecycle): Promise<string> {
+ this.restoredTasks.delete(input.runId);
+ const previous = this.tasks.get(input.runId);
+ const existing = previous?.lifecycle.isCurrent() ? previous : undefined;
+ if (previous && !existing) previous.controller.abort('owner-changed');
+ if (existing) {
+ if (
+ existing.input.originSessionId !== input.originSessionId ||
+ existing.input.request !== input.request
+ ) {
+ return Promise.reject(
+ Object.assign(new Error('task run does not match'), { code: 'invalid' }),
+ );
+ }
+ if (
+ existing.report?.status === 'running' ||
+ existing.report?.status === 'completed' ||
+ !existing.report
+ )
+ return existing.created;
+ }
+ const controller = new AbortController();
+ const task: ActiveTask = { input, controller, created: Promise.resolve(''), lifecycle };
+ this.tasks.set(input.runId, task);
+ task.created = (async () => {
+ const report = await lifecycle.create(existing?.report);
+ if (!report.task) throw new Error('task identity missing');
+ if (!lifecycle.isCurrent()) throw new Error('task owner changed');
+ task.report = report;
+ await lifecycle.persist(report);
+ lifecycle.onCreated?.();
+ this.publishTask(task);
+ task.done = this.runTask(task);
+ return report.task.sessionId;
+ })().catch((error) => {
+ if (task.report) {
+ task.report = { ...task.report, status: 'failed' };
+ this.publishTask(task);
+ } else if (this.tasks.get(input.runId) === task) this.tasks.delete(input.runId);
+ throw error;
+ });
+ return task.created;
+ }
+
+ isTaskPreparing(sessionId: string): boolean {
+ return [...this.tasks.values()].some(
+ (task) =>
+ task.lifecycle.isCurrent() &&
+ task.report?.task?.sessionId === sessionId &&
+ task.report.status === 'running',
+ );
+ }
+
+ cancelTasksForSession(sessionId: string): void {
+ for (const task of this.tasks.values()) {
+ if (task.report?.task?.sessionId === sessionId && task.report.status === 'running')
+ task.controller.abort('cancelled');
+ }
+ this.notify();
+ }
+
+ async settleTasksForSession(sessionId: string): Promise<void> {
+ this.cancelTasksForSession(sessionId);
+ await Promise.all(
+ [...this.tasks.values()]
+ .filter((task) => task.report?.task?.sessionId === sessionId)
+ .map((task) => task.created.then(() => task.done).catch(() => undefined)),
+ );
+ }
+
+ /** Owns cleanup from dispatch through completion, including when every view unmounts. */
+ runTaskAction(
+ sessionId: string,
+ action: CindyMakeTaskActionState['action'],
+ isCurrent: () => boolean,
+ run: () => Promise<void>,
+ nestedRecycle = false,
+ ): Promise<void> {
+ if (!isCurrent())
+ return Promise.reject(Object.assign(new Error('owner changed'), { code: 'unavailable' }));
+ const existing = this.taskActions.get(sessionId);
+ if (existing?.isCurrent() && existing.state.status === 'running') {
+ // The canonical terminal-session hook runs inside the outer Settings action.
+ // It must not await its own parent's promise or overwrite its progress.
+ if (nestedRecycle) return run();
+ // A plain archive only checks already-merged work. A later explicit Finish
+ // still needs to perform its merge after that background recycle settles.
+ if (existing.recycleOnly)
+ return existing.promise
+ .catch(() => undefined)
+ .then(() => this.runTaskAction(sessionId, action, isCurrent, run));
+ if (existing.state.action === action) return existing.promise;
+ return Promise.reject(Object.assign(new Error('task cleanup in progress'), { code: 'busy' }));
+ }
+ const entry: TaskAction = {
+ state: { action, status: 'running' },
+ isCurrent,
+ promise: Promise.resolve(),
+ recycleOnly: nestedRecycle,
+ };
+ this.taskActions.set(sessionId, entry);
+ entry.promise = Promise.resolve()
+ .then(() => {
+ if (!isCurrent()) throw Object.assign(new Error('owner changed'), { code: 'unavailable' });
+ return run();
+ })
+ .then(
+ () => {
+ if (this.taskActions.get(sessionId) === entry) this.taskActions.delete(sessionId);
+ },
+ (error) => {
+ const code = (error as { code?: CindyMakeTaskError })?.code;
+ entry.state = {
+ action,
+ status: 'failed',
+ error: code && CINDY_MAKE_TASK_ERROR_CODES.includes(code) ? code : 'cleanupFailed',
+ };
+ throw error;
+ },
+ )
+ .finally(() => {
+ if (isCurrent()) this.notify();
+ });
+ this.notify();
+ return entry.promise;
+ }
+
+ forgetTask(runId: string): void {
+ const live = this.tasks.delete(runId);
+ const restored = this.restoredTasks.delete(runId);
+ if (live || restored) this.notify();
+ }
+
+ projectTaskSession(
+ runId: string,
+ projection: Partial<NonNullable<MakeDoctorReport['task']>>,
+ ): void {
+ const report = this.taskReport(runId);
+ if (!report?.task) return;
+ if (
+ Object.entries(projection).every(
+ ([key, value]) =>
+ report.task![key as keyof NonNullable<MakeDoctorReport['task']>] === value,
+ )
+ )
+ return;
+ Object.assign(report.task, projection);
+ this.notify();
+ }
+
+ taskReport(runId: string): MakeDoctorReport | undefined {
+ const task = this.tasks.get(runId);
+ if (task?.lifecycle.isCurrent()) return task.report;
+ const restored = this.restoredTasks.get(runId);
+ return restored?.isCurrent() ? restored.report : undefined;
+ }
+
+ restoreTaskReport(
+ report: MakeDoctorReport,
+ isCurrent: () => boolean,
+ ): MakeDoctorReport | undefined {
+ if (!isCurrent() || !report.task) return undefined;
+ const active = this.tasks.get(report.runId);
+ if (active?.lifecycle.isCurrent()) return undefined;
+ const restored =
+ report.status === 'running' ? { ...report, status: 'cancelled' as const } : report;
+ const previous = this.restoredTasks.get(report.runId);
+ if (previous?.isCurrent()) {
+ // Runtime execution is projected separately from the persisted preparation.
+ restored.task = { ...restored.task!, executing: previous.report.task?.executing };
+ if (JSON.stringify(previous.report) === JSON.stringify(restored)) return undefined;
+ }
+ this.restoredTasks.set(report.runId, { report: restored, isCurrent });
+ this.notify();
+ return restored;
+ }
+
+ waitForTask(runId: string): Promise<void> {
+ const task = this.tasks.get(runId);
+ return task ? task.created.then(() => task.done) : Promise.resolve();
+ }
+
+ private publishTask(task: ActiveTask): void {
+ if (!task.report || !task.lifecycle.isCurrent()) return;
+ this.notify();
+ }
+
+ private async runTask(task: ActiveTask): Promise<void> {
+ const { lifecycle, controller } = task;
+ if (task.report?.status === 'completed') return;
+ const timeout = setTimeout(() => controller.abort('timeout'), 20 * 60_000);
+ let persistence = Promise.resolve();
+ let persistenceError: unknown;
+ const publish = (report: MakeDoctorReport) => {
+ if (controller.signal.aborted) return;
+ if (!lifecycle.isCurrent()) {
+ controller.abort('owner-changed');
+ return;
+ }
+ task.report = report;
+ this.publishTask(task);
+ persistence = persistence
+ .then(() => lifecycle.persist(report))
+ .catch((error) => {
+ persistenceError = error;
+ controller.abort('persistence');
+ });
+ };
+ try {
+ await lifecycle.prepare(controller.signal, publish);
+ controller.signal.throwIfAborted();
+ if (!lifecycle.isCurrent()) throw new Error('task owner changed');
+ publish({ ...task.report!, task: { ...task.report!.task!, phase: 'starting' } });
+ await persistence;
+ controller.signal.throwIfAborted();
+ await lifecycle.start(controller.signal);
+ task.report = {
+ ...task.report!,
+ status: 'completed',
+ task: { ...task.report!.task!, phase: 'completed' },
+ };
+ } catch (error) {
+ lifecycle.onError(persistenceError ?? error);
+ task.report = {
+ ...task.report!,
+ status:
+ controller.signal.aborted && controller.signal.reason === 'cancelled'
+ ? 'cancelled'
+ : 'failed',
+ };
+ } finally {
+ clearTimeout(timeout);
+ }
+ await persistence;
+ if (lifecycle.isCurrent()) {
+ try {
+ await lifecycle.persist(task.report!);
+ } catch (error) {
+ lifecycle.onError(error);
+ }
+ this.publishTask(task);
+ }
+ }
subscribe(listener: CindyMakeStateListener): () => void {
this.stateListeners.add(listener);
@@ -56,7 +543,33 @@ export class CindyMakeManager {
}
getState(): CindyMakeGlobalState {
- return { ...this.states };
+ const restored = Object.fromEntries(
+ [...this.restoredTasks].flatMap(([runId, task]) =>
+ task.isCurrent() ? [[runId, task.report]] : [],
+ ),
+ );
+ const tasks = {
+ ...restored,
+ ...Object.fromEntries(
+ [...this.tasks].flatMap(([runId, task]) =>
+ task.report && !task.report.task?.finished && task.lifecycle.isCurrent()
+ ? [[runId, task.report]]
+ : [],
+ ),
+ ),
+ };
+ return structuredClone({
+ ...this.states,
+ reports: Object.fromEntries(
+ [...this.reports].flatMap(([runId, entry]) =>
+ entry.isCurrent() ? [[runId, entry.report]] : [],
+ ),
+ ),
+ ...(Object.keys(tasks).length ? { tasks } : { tasks: undefined }),
+ taskActions: Object.fromEntries(
+ [...this.taskActions].flatMap(([id, job]) => (job.isCurrent() ? [[id, job.state]] : [])),
+ ),
+ });
}
claim<T = unknown>(
@@ -161,6 +674,13 @@ export class CindyMakeManager {
}
cancel(operationId: string, sender: number): 'cancelled' | 'forbidden' | 'not-found' {
+ const task = this.tasks.get(operationId);
+ if (task && task.lifecycle.isCurrent()) {
+ if (task.report?.status !== 'running' || task.report.task?.phase === 'starting')
+ return 'not-found';
+ task.controller.abort('cancelled');
+ return 'cancelled';
+ }
const operation = this.aliases.get(operationId);
if (!operation) {
const workflow = this.workflows.get(operationId);
@@ -185,7 +705,11 @@ export class CindyMakeManager {
private notify(): void {
const state = this.getState();
- for (const listener of this.stateListeners) listener(state);
+ for (const listener of this.stateListeners) {
+ try {
+ listener(state);
+ } catch {}
+ }
}
}
diff --git a/apps/desktop/src/main/cindy-make/projectAccess.ts b/apps/desktop/src/main/cindy-make/projectAccess.ts
new file mode 100644
index 0000000000..d4192b0659
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/projectAccess.ts
@@ -0,0 +1,46 @@
+import { lstat } from 'node:fs/promises';
+import path from 'node:path';
+import { t } from '../i18n.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import { cindyMakeManager } from './manager.js';
+import { isCindyMakeWorktreePath, makeSourceCheckoutPath, makeSourceRoot } from './sourcePaths.js';
+
+export async function assertCindyMakeWorkspace(
+ userData: string,
+ workingDir: string,
+): Promise<void> {
+ if (!isCindyMakeWorktreePath(userData, workingDir)) return;
+ try {
+ const [directory, worktreeGit, sourceGit] = await Promise.all([
+ lstat(workingDir),
+ lstat(path.join(workingDir, '.git')),
+ lstat(path.join(makeSourceCheckoutPath(userData), '.git')),
+ ]);
+ if (
+ directory.isDirectory() &&
+ !directory.isSymbolicLink() &&
+ worktreeGit.isFile() &&
+ sourceGit.isDirectory()
+ )
+ return;
+ } catch {}
+ throwIpcError('PRECONDITION_FAILED', t('cindyMake.code.workspaceUnavailable'));
+}
+
+export async function withCindyMakeProjectUse<T>(
+ userData: string,
+ workingDir: string | null | undefined,
+ run: () => Promise<T>,
+): Promise<T> {
+ if (!workingDir || !isCindyMakeWorktreePath(userData, workingDir)) return run();
+ try {
+ return await cindyMakeManager.withProjectUse(makeSourceRoot(userData), async () => {
+ await assertCindyMakeWorkspace(userData, workingDir);
+ return run();
+ });
+ } catch (error) {
+ if ((error as { code?: unknown })?.code === 'busy')
+ throwIpcError('DEVICE_BUSY', t('cindyMake.code.projectClearing'));
+ throw error;
+ }
+}
diff --git a/apps/desktop/src/main/cindy-make/sourcePaths.ts b/apps/desktop/src/main/cindy-make/sourcePaths.ts
index c96692b053..6a8cc4df95 100644
--- a/apps/desktop/src/main/cindy-make/sourcePaths.ts
+++ b/apps/desktop/src/main/cindy-make/sourcePaths.ts
@@ -31,3 +31,14 @@ export function makeTaskBranch(runId: string): string {
export function makeTaskWorktreePath(userData: string, runId: string): string {
return path.resolve(makeWorktreesRoot(userData), runId);
}
+
+export function isCindyMakeWorktreePath(userData: string, workingDir: string): boolean {
+ const relative = path.relative(makeWorktreesRoot(userData), path.resolve(workingDir));
+ return (
+ relative.length > 0 &&
+ !relative.startsWith('..') &&
+ !path.isAbsolute(relative) &&
+ !relative.includes(path.sep) &&
+ CINDY_MAKE_RUN_ID_PATTERN.test(relative)
+ );
+}
diff --git a/apps/desktop/src/main/cindy-make/sourcePnpm.ts b/apps/desktop/src/main/cindy-make/sourcePnpm.ts
index b43d63999c..3f89a1648b 100644
--- a/apps/desktop/src/main/cindy-make/sourcePnpm.ts
+++ b/apps/desktop/src/main/cindy-make/sourcePnpm.ts
@@ -2,6 +2,36 @@ import { spawn, type ChildProcess } from 'node:child_process';
import { constants } from 'node:fs';
import { access, stat } from 'node:fs/promises';
import path from 'node:path';
+import type { CindyMakeTaskPreparation } from '../../shared/cindyMakeDoctor.js';
+
+export function parseMakeDependencyProgress(
+ text: string,
+ previous?: CindyMakeTaskPreparation['dependencies'],
+): CindyMakeTaskPreparation['dependencies'] {
+ const matches = [
+ ...text.matchAll(
+ /Progress: resolved ([0-9]+), reused ([0-9]+), downloaded ([0-9]+), added ([0-9]+)/g,
+ ),
+ ];
+ const match = matches.at(-1);
+ const scripts = [
+ ...text.matchAll(/(?:^|[\r\n])[^\r\n]*(?:preinstall|postinstall|install|prepare)[$:]/g),
+ ].at(-1);
+ const counts = match
+ ? {
+ resolved: Number(match[1]),
+ reused: Number(match[2]),
+ downloaded: Number(match[3]),
+ added: Number(match[4]),
+ }
+ : previous;
+ if (scripts && (!match || scripts.index! > match.index!))
+ return {
+ ...counts,
+ activity: 'scripts',
+ };
+ return counts;
+}
const OUTPUT_TAIL_CHARS = 2048;
@@ -53,8 +83,11 @@ export async function runSourcePnpm(
args: readonly string[],
cwd: string,
signal: AbortSignal,
+ onProgress?: (progress: NonNullable<CindyMakeTaskPreparation['dependencies']>) => void,
): Promise<void> {
signal.throwIfAborted();
+ // Keep progress visible in a non-TTY/CI process, including lifecycle scripts.
+ args = ['install', 'fetch'].includes(args[0]) ? [...args, '--reporter=append-only'] : args;
if (args.some((arg) => !/^[\w.=-]+$/.test(arg))) {
throw Object.assign(new Error('unsafe pnpm argument'), { code: 'installFailed' });
}
@@ -86,8 +119,18 @@ export async function runSourcePnpm(
stdio: ['ignore', 'pipe', 'pipe'],
});
let tail = '';
+ let lastProgress = '';
+ let previousProgress: CindyMakeTaskPreparation['dependencies'];
const collect = (chunk: Buffer) => {
tail = (tail + chunk.toString('utf8')).slice(-OUTPUT_TAIL_CHARS);
+ if (onProgress && !signal.aborted) {
+ const progress = parseMakeDependencyProgress(tail, previousProgress);
+ if (progress && JSON.stringify(progress) !== lastProgress) {
+ previousProgress = progress;
+ lastProgress = JSON.stringify(progress);
+ onProgress(progress);
+ }
+ }
};
child.stdout?.on('data', collect);
child.stderr?.on('data', collect);
diff --git a/apps/desktop/src/main/cindy-make/sourcePreparation.ts b/apps/desktop/src/main/cindy-make/sourcePreparation.ts
index 31a295ecc1..8d673137ca 100644
--- a/apps/desktop/src/main/cindy-make/sourcePreparation.ts
+++ b/apps/desktop/src/main/cindy-make/sourcePreparation.ts
@@ -2,6 +2,7 @@ import { access, lstat, mkdir, mkdtemp, readFile, rename, stat, writeFile } from
import originalFs from 'original-fs';
import path from 'node:path';
import { createLogger } from '../logger.js';
+import { cindyMakeManager } from './manager.js';
import {
resolveMakeToolEnvironment,
type MakeToolchainEnvironment,
@@ -77,26 +78,23 @@ export async function readCindySourceStatus(root: string): Promise<MakeSourceSta
}
}
-const sourceStatusListeners = new Set<(status: MakeSourceStatus) => void>();
-
-interface SharedSourceJob {
- clearOnly: boolean;
- controller: AbortController;
- latest?: SourcePreparationProgress;
- status?: MakeSourceStatus;
- listeners: Set<(progress: SourcePreparationProgress) => void>;
- promise: Promise<SourcePreparationResult>;
-}
-
-/** The single in-flight source operation; later callers attach to it instead of racing it. */
-let inFlight: SharedSourceJob | undefined;
-
-/** Subscribe to source preparation state shared by every renderer window. */
export function subscribeCindySourceStatus(
listener: (status: MakeSourceStatus) => void,
): () => void {
- sourceStatusListeners.add(listener);
- return () => sourceStatusListeners.delete(listener);
+ let previous: MakeSourceStatus | undefined;
+ let initial = true;
+ return cindyMakeManager.subscribe((state) => {
+ if (initial) {
+ initial = false;
+ if (state.source?.status !== 'preparing') {
+ previous = state.source;
+ return;
+ }
+ }
+ if (!state.source || JSON.stringify(state.source) === JSON.stringify(previous)) return;
+ previous = state.source;
+ listener(state.source);
+ });
}
/**
@@ -107,7 +105,8 @@ export async function readCurrentCindySourceStatus(
root: string,
env?: MakeToolchainEnvironment,
): Promise<MakeSourceStatus> {
- if (inFlight?.status) return inFlight.status;
+ const live = cindyMakeManager.sourceStatus(root);
+ if (live) return live;
const status = await readCindySourceStatus(root);
if (status.status === 'ready' && env) {
const sourcePath = path.resolve(root, 'source');
@@ -138,7 +137,7 @@ export async function readCurrentCindySourceStatus(
};
}
}
- if (status.status === 'preparing' && !inFlight) {
+ if (status.status === 'preparing' && !cindyMakeManager.isPreparingSource(root)) {
return {
...status,
status: 'cancelled',
@@ -152,9 +151,7 @@ export async function readCurrentCindySourceStatus(
/** Stop the running source operation, whichever window or workflow started it. */
export function cancelCindySourcePreparation(): boolean {
- if (!inFlight || inFlight.controller.signal.aborted) return false;
- inFlight.controller.abort('cancelled');
- return true;
+ return cindyMakeManager.cancelSource();
}
function toSourceStatus(progress: SourcePreparationProgress): MakeSourceStatus {
@@ -175,6 +172,7 @@ function toSourceStatus(progress: SourcePreparationProgress): MakeSourceStatus {
...(progress.error ? { error: progress.error } : {}),
...(progress.phase ? { phase: progress.phase } : {}),
...(progress.progress ? { progress: progress.progress } : {}),
+ ...(progress.dependencies ? { dependencies: progress.dependencies } : {}),
};
}
@@ -211,6 +209,7 @@ export interface SourcePreparationProgress extends SourceRevisions {
error?: SourcePreparationResult['error'];
phase?: MakeSourceStatus['phase'];
progress?: MakeSourceGitProgress;
+ dependencies?: MakeSourceStatus['dependencies'];
}
/** Resolve the two allowed release refs. A dev build always follows main. */
@@ -385,55 +384,20 @@ export async function prepareCindySource(
target: sourceTarget(identity),
error: 'cancelled',
});
- while (inFlight && inFlight.clearOnly !== clearOnly) {
- if (callerSignal.aborted) return cancelled();
- await inFlight.promise.catch(() => undefined);
- }
- if (callerSignal.aborted) return cancelled();
- if (inFlight) {
- const job = inFlight;
- const forwardAbort = () => job.controller.abort(callerSignal.reason);
- job.listeners.add(onProgress);
- callerSignal.addEventListener('abort', forwardAbort, { once: true });
- if (job.latest) onProgress(job.latest);
- try {
- return await job.promise;
- } finally {
- job.listeners.delete(onProgress);
- callerSignal.removeEventListener('abort', forwardAbort);
- }
- }
- const controller = new AbortController();
- const forwardAbort = () => controller.abort(callerSignal.reason);
- callerSignal.addEventListener('abort', forwardAbort, { once: true });
- const job: SharedSourceJob = {
+ return cindyMakeManager.prepareSource({
+ root,
clearOnly,
- controller,
- listeners: new Set([onProgress]),
- promise: Promise.resolve(cancelled()),
- };
- const fanout = (progress: SourcePreparationProgress) => {
- job.latest = progress;
- job.status =
+ signal: callerSignal,
+ cancelled,
+ onCancelledBeforeStart: (result) => persistSourceStatus(root, toSourceStatus(result)),
+ onProgress,
+ toStatus: (progress) =>
clearOnly && progress.status === 'ready'
? { status: 'missing', path: progress.path }
- : toSourceStatus(progress);
- for (const listener of job.listeners) listener(progress);
- for (const listener of sourceStatusListeners) listener(job.status);
- };
- inFlight = job;
- job.promise = prepareCindySourceInternal(
- env,
- root,
- identity,
- controller.signal,
- fanout,
- options,
- ).finally(() => {
- callerSignal.removeEventListener('abort', forwardAbort);
- if (inFlight === job) inFlight = undefined;
+ : toSourceStatus(progress),
+ run: (signal, publish) =>
+ prepareCindySourceInternal(env, root, identity, signal, publish, options),
});
- return job.promise;
}
async function prepareCindySourceInternal(
@@ -508,8 +472,15 @@ async function prepareCindySourceInternal(
return result;
}
+ await emitProgress({ status: 'preparing', path: sourcePath, target, phase: 'checkingRemote' });
const resolvedRef = await resolveRemoteRef(env, target, signal);
const resolvedTarget = { ...target, ref: resolvedRef };
+ await emitProgress({
+ status: 'preparing',
+ path: sourcePath,
+ target: resolvedTarget,
+ phase: 'checkingLocal',
+ });
if (await exists(gitDir)) {
const remote = await git(env, ['remote', 'get-url', 'origin'], sourcePath, signal);
if (remote !== CINDY_SOURCE_REPOSITORY)
@@ -547,6 +518,12 @@ async function prepareCindySourceInternal(
);
// Nobody works in the managed checkout itself (tasks use their own worktrees),
// so uncommitted changes here mean an older layout or outside tampering.
+ await emitProgress({
+ status: 'preparing',
+ path: sourcePath,
+ target: resolvedTarget,
+ phase: 'checkingLocal',
+ });
const dirty = await git(env, ['status', '--porcelain'], sourcePath, signal);
if (dirty) throw Object.assign(new Error('dirty'), { code: 'dirty' });
}
@@ -644,18 +621,39 @@ async function prepareCindySourceInternal(
commit,
branch: CINDY_PERSONAL_BRANCH,
...revisions,
- phase: 'installing',
+ phase: 'caching',
});
- const processEnvironment = await resolveMakeToolEnvironment(
- env,
- ['node', 'pnpm', 'python'],
- signal,
- );
+ const processEnvironment = await resolveMakeToolEnvironment(env, ['node', 'pnpm'], signal);
+ // Settings and preflight warm the same pnpm store. Check the current lockfile
+ // and cache each time, filling changed or evicted packages without trusting a
+ // stale ready marker. The personal baseline needs no installed dependencies.
await runSourcePnpm(
processEnvironment,
- ['install', '--frozen-lockfile', '--prefer-offline', '--prod=false'],
+ [
+ 'fetch',
+ '--frozen-lockfile',
+ '--prefer-offline',
+ '--prod=false',
+ '--ignore-scripts',
+ // The hoisted linker imports packages even with modules disabled. Override
+ // only this command; worktree installs keep the repository's linker and
+ // run the required lifecycle scripts as usual.
+ '--config.node-linker=isolated',
+ '--config.enable-modules-dir=false',
+ ],
sourcePath,
signal,
+ (dependencies) =>
+ onProgress({
+ status: 'preparing',
+ path: sourcePath,
+ target: resolvedTarget,
+ commit,
+ branch: CINDY_PERSONAL_BRANCH,
+ ...revisions,
+ phase: 'caching',
+ dependencies,
+ }),
);
signal.throwIfAborted();
const result: SourcePreparationResult = {
diff --git a/apps/desktop/src/main/cindy-make/stateBroadcast.ts b/apps/desktop/src/main/cindy-make/stateBroadcast.ts
index 7e1c850a32..67d8db0830 100644
--- a/apps/desktop/src/main/cindy-make/stateBroadcast.ts
+++ b/apps/desktop/src/main/cindy-make/stateBroadcast.ts
@@ -1,6 +1,7 @@
import { BrowserWindow } from 'electron';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
+import { captureDataOwnerBroadcastScope } from '../device-link/broadcast-tap.js';
import type { CindyMakeGlobalState } from '../../shared/cindyMakeDoctor.js';
/** Push the Main-owned Cindy Make snapshot to every trusted renderer window. */
@@ -8,7 +9,10 @@ export function broadcastCindyMakeState(state: CindyMakeGlobalState): void {
for (const window of BrowserWindow.getAllWindows()) {
if (window.isDestroyed()) continue;
try {
- window.webContents.send(MAKER_PUSH.CINDY_MAKE_STATE_CHANGED, state);
+ window.webContents.send(MAKER_PUSH.CINDY_MAKE_STATE_CHANGED, {
+ ...state,
+ ownerStamp: captureDataOwnerBroadcastScope().ownerStamp,
+ });
} catch {
// A closing renderer must not affect the operation running in Main.
}
diff --git a/apps/desktop/src/main/cindy-make/taskCleanup.ts b/apps/desktop/src/main/cindy-make/taskCleanup.ts
new file mode 100644
index 0000000000..b5f3f55f91
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/taskCleanup.ts
@@ -0,0 +1,205 @@
+import { lstat, realpath, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { runSourceGit } from './sourceGit.js';
+import type { CindyMakeTaskError } from '../../shared/cindyMakeDoctor.js';
+import {
+ CINDY_MAKE_RUN_ID_PATTERN,
+ CINDY_PERSONAL_BRANCH,
+ makeSourceCheckoutPath,
+ makeTaskBranch,
+ makeTaskWorktreePath,
+ makeWorktreesRoot,
+} from './sourcePaths.js';
+
+export type MakeTaskAction = 'finish' | 'delete';
+export type MakeTaskError = CindyMakeTaskError;
+export function taskError(code: MakeTaskError): Error & { code: MakeTaskError } {
+ return Object.assign(new Error('Cindy Make task ' + code), { code });
+}
+
+async function exists(target: string): Promise<boolean> {
+ try {
+ await lstat(target);
+ return true;
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false;
+ throw error;
+ }
+}
+
+/** Only operates on a registered managed worktree or its verified deletion residue. */
+export async function manageCindyMakeWorkspace(
+ userData: string,
+ runId: string,
+ action: MakeTaskAction | 'archive',
+ env: NodeJS.ProcessEnv,
+ signal: AbortSignal,
+ options: {
+ git?: typeof runSourceGit;
+ baseCommit?: string;
+ checkCurrent?: () => void;
+ /** Main's persisted preparation result, never supplied by the renderer. */
+ preparedWorkspace?: { path: string; branch: string };
+ } = {},
+): Promise<boolean> {
+ if (!CINDY_MAKE_RUN_ID_PATTERN.test(runId)) throw taskError('unavailable');
+ const source = makeSourceCheckoutPath(userData);
+ const target = makeTaskWorktreePath(userData, runId);
+ const branch = makeTaskBranch(runId);
+ const check = options.checkCurrent ?? (() => {});
+ const git = async (args: string[], cwd = source) => {
+ check();
+ return (options.git ?? runSourceGit)(env, args, cwd, signal);
+ };
+ const targetExists = await exists(target);
+ const samePath = (left: string, right: string) =>
+ process.platform === 'win32'
+ ? path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase()
+ : path.resolve(left) === path.resolve(right);
+ const canonicalProfile = await realpath(userData);
+ // Reject substituted roots as well as a symlink at the leaf. Never follow a
+ // junction out of this profile, including when a previous cleanup was partial.
+ const assertManagedPaths = async () => {
+ check();
+ for (const directory of [path.dirname(source), source, makeWorktreesRoot(userData), target]) {
+ if (!(await exists(directory))) continue;
+ if (
+ (await lstat(directory)).isSymbolicLink() ||
+ !samePath(
+ await realpath(directory),
+ path.join(canonicalProfile, path.relative(userData, directory)),
+ )
+ )
+ throw taskError('unavailable');
+ }
+ };
+ await assertManagedPaths();
+ if (!(await exists(path.join(source, '.git')))) {
+ if (!targetExists && action === 'delete') return true;
+ throw taskError('unavailable');
+ }
+ const gitDirectory = await lstat(path.join(source, '.git'));
+ if (!gitDirectory.isDirectory() || gitDirectory.isSymbolicLink()) throw taskError('unavailable');
+ const branchExists = !!(await git(['branch', '--list', branch])).trim();
+ if (!targetExists && !branchExists) return true;
+ const registrations = async () =>
+ (await git(['worktree', 'list', '--porcelain', '-z'])).split('\0\0').map((entry) => {
+ const lines = entry.split('\0');
+ return {
+ directory: lines.find((line) => line.startsWith('worktree '))?.slice(9),
+ branch: lines.find((line) => line.startsWith('branch '))?.slice(7),
+ };
+ });
+ const gitMarker = path.join(target, '.git');
+ let verifiedWorkspace =
+ options.preparedWorkspace?.branch === branch &&
+ samePath(options.preparedWorkspace.path, target);
+ const canRemoveResidue = async () => {
+ if (action !== 'delete' || !verifiedWorkspace || !branchExists || (await exists(gitMarker)))
+ return false;
+ return !(await registrations()).some(
+ (entry) =>
+ (entry.directory && samePath(entry.directory, target)) ||
+ entry.branch === 'refs/heads/' + branch,
+ );
+ };
+ let registered = false;
+ if (targetExists) {
+ registered = (await registrations()).some(
+ (entry) =>
+ entry.directory &&
+ samePath(entry.directory, target) &&
+ entry.branch === 'refs/heads/' + branch,
+ );
+ if (!registered) {
+ if (!(await canRemoveResidue())) throw taskError('unavailable');
+ } else {
+ if ((await git(['rev-parse', '--abbrev-ref', 'HEAD'], target)).trim() !== branch)
+ throw taskError('unavailable');
+ const common = (
+ await git(['rev-parse', '--path-format=absolute', '--git-common-dir'], target)
+ ).trim();
+ if (!samePath(await realpath(common), await realpath(path.join(source, '.git'))))
+ throw taskError('unavailable');
+ verifiedWorkspace = true;
+ }
+ }
+ if (action !== 'delete') {
+ if (!branchExists) throw taskError('unavailable');
+ if (
+ targetExists &&
+ (await git(['status', '--porcelain', '--untracked-files=all'], target)).trim()
+ ) {
+ if (action === 'archive') return false;
+ throw taskError('dirty');
+ }
+ const head = (await git(['rev-parse', branch])).trim();
+ if (action === 'archive' && (!options.baseCommit || head === options.baseCommit)) return false;
+ let merged = false;
+ try {
+ await git(['merge-base', '--is-ancestor', branch, CINDY_PERSONAL_BRANCH]);
+ merged = true;
+ } catch (error) {
+ if ((error as { exitCode?: number }).exitCode !== 1) throw error;
+ }
+ if (!merged && action === 'archive') return false;
+ if (!merged) {
+ if (await exists(path.join(source, '.git', 'MERGE_HEAD'))) throw taskError('dirty');
+ if (
+ (await git(['status', '--porcelain', '--untracked-files=all'])).trim() ||
+ (await git(['rev-parse', '--abbrev-ref', 'HEAD'])).trim() !== CINDY_PERSONAL_BRANCH
+ )
+ throw taskError('dirty');
+ try {
+ await git([
+ '-c',
+ 'user.name=Cindy Make',
+ '-c',
+ 'user.email=cindy-make@localhost',
+ 'merge',
+ '--no-edit',
+ '--signoff',
+ branch,
+ ]);
+ } catch {
+ // The source was clean before our merge. Abort only a merge that Git
+ // actually started; a pre-existing merge is never touched.
+ if (await exists(path.join(source, '.git', 'MERGE_HEAD'))) await git(['merge', '--abort']);
+ throw taskError('conflict');
+ }
+ }
+ // Recheck after merge: external edits must not be discarded by --force.
+ if (
+ targetExists &&
+ (await git(['status', '--porcelain', '--untracked-files=all'], target)).trim()
+ )
+ throw taskError('dirty');
+ }
+ if (targetExists && registered) {
+ try {
+ // pnpm paths routinely exceed Win32's legacy MAX_PATH.
+ await git(['-c', 'core.longpaths=true', 'worktree', 'remove', '--force', target]);
+ } catch (error) {
+ // Git can erase the registration and .git file even when removing files
+ // fails. Keep the branch until the leftover directory is gone.
+ if (!(await canRemoveResidue())) throw error;
+ }
+ }
+ if (targetExists && (await exists(target))) {
+ if (!(await canRemoveResidue())) throw taskError('cleanupFailed');
+ await assertManagedPaths();
+ check();
+ signal.throwIfAborted();
+ try {
+ await rm(target, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+ } catch (error) {
+ const code = (error as NodeJS.ErrnoException).code;
+ if (['EBUSY', 'EPERM', 'EACCES', 'ENOTEMPTY'].includes(code ?? ''))
+ throw taskError('directoryBusy');
+ throw error;
+ }
+ }
+ if (!targetExists) await git(['worktree', 'prune']);
+ if (branchExists) await git(['branch', action === 'delete' ? '-D' : '-d', branch]);
+ return true;
+}
diff --git a/apps/desktop/src/main/cindy-make/taskManagement.ts b/apps/desktop/src/main/cindy-make/taskManagement.ts
new file mode 100644
index 0000000000..a8987f0b80
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/taskManagement.ts
@@ -0,0 +1,212 @@
+import path from 'node:path';
+import { and, eq } from 'drizzle-orm';
+import { app } from 'electron';
+import { getDbClient } from '../localDb/client/current.js';
+import { messages, sessions } from '../localDb/schema.js';
+import { updateMessageContent } from '../localDb/ipc/messages.js';
+import { withSessionRouteLock } from '../localDb/sessionRouteLock.js';
+import {
+ captureDataOwnerBroadcastScope,
+ isDataOwnerBroadcastScopeCurrent,
+} from '../device-link/broadcast-tap.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import { cindyMakeManager } from './manager.js';
+import { isCindyMakeWorktreePath, makeSourceRoot } from './sourcePaths.js';
+import {
+ createMakeToolchainEnvironment,
+ resolveMakeToolEnvironment,
+} from './toolchainEnvironment.js';
+import { manageCindyMakeWorkspace, taskError, type MakeTaskAction } from './taskCleanup.js';
+import type { MakeDoctorReport } from '../../shared/cindyMakeDoctor.js';
+
+interface TaskManagementRuntime {
+ isAlive(sessionId: string): boolean | undefined;
+ isRunning(sessionId: string): boolean;
+ setStatus(
+ sessionId: string,
+ patch: { status: 'archived' | 'deleted'; pinnedAt: null },
+ ): Promise<unknown>;
+ recycle(sessionId: string, status: 'archived' | 'deleted'): Promise<void>;
+}
+let runtime: TaskManagementRuntime | undefined;
+/** The composition root supplies runtime shutdown and canonical session writes. */
+export function configureCindyMakeTaskManagement(deps: TaskManagementRuntime): void {
+ runtime = deps;
+}
+
+/** Called under the existing terminal-session route lock, after all writers stop. */
+export async function recycleCindyMakeTask(
+ sessionId: string,
+ db: ReturnType<typeof getDbClient>['drizzle'],
+ isCurrent: () => boolean,
+ action?: MakeTaskAction,
+): Promise<void> {
+ if (!isCurrent()) {
+ if (action) throw taskError('unavailable');
+ return;
+ }
+ const [row] = await db.select().from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ const userData = app.getPath('userData');
+ if (
+ !row ||
+ row.source !== 'cindy-make' ||
+ row.remoteHostId ||
+ !row.workingDir ||
+ !isCindyMakeWorktreePath(userData, row.workingDir) ||
+ (row.status !== 'archived' && row.status !== 'deleted')
+ ) {
+ if (action) throw taskError('unavailable');
+ return;
+ }
+ if (action === 'finish' && row.status !== 'archived') throw taskError('unavailable');
+ const workingDir = row.workingDir;
+ const runId = path.basename(workingDir);
+ const [card] = await db
+ .select({ content: messages.content, clientId: messages.clientId })
+ .from(messages)
+ .where(
+ and(
+ eq(messages.sessionId, sessionId),
+ eq(messages.clientId, 'cindy-make-preparation-' + runId),
+ ),
+ )
+ .limit(1);
+ const content = (() => {
+ try {
+ return card ? JSON.parse(card.content) : undefined;
+ } catch {
+ // A damaged card must not strand a managed workspace.
+ return undefined;
+ }
+ })();
+ const report = content?.__cindyMakeCard?.data?.report as MakeDoctorReport | undefined;
+ if (report?.task?.finished) {
+ cindyMakeManager.forgetTask(runId);
+ return;
+ }
+ const checkCurrent = () => {
+ if (!isCurrent()) throw taskError('unavailable');
+ };
+ if (!runtime) throw taskError('busy');
+ await cindyMakeManager.runTaskAction(
+ sessionId,
+ row.status === 'deleted' ? 'delete' : 'finish',
+ isCurrent,
+ () =>
+ cindyMakeManager.withProject(makeSourceRoot(userData), async () => {
+ checkCurrent();
+ const signal = AbortSignal.timeout(120_000);
+ const environment = await createMakeToolchainEnvironment(userData);
+ const env = await resolveMakeToolEnvironment(environment, ['git'], signal);
+ // Recheck after waiting for project operations and tool discovery. A failed
+ // close, or another session borrowing this directory, must preserve it.
+ if (runtime!.isAlive(sessionId)) throw taskError('busy');
+ const borrowers = await db
+ .select({ id: sessions.id, status: sessions.status })
+ .from(sessions)
+ .where(eq(sessions.workingDir, workingDir));
+ if (
+ borrowers.some(
+ (other) =>
+ other.id !== sessionId && (other.status === 'active' || runtime!.isAlive(other.id)),
+ )
+ )
+ throw taskError('busy');
+ const cleaned = await manageCindyMakeWorkspace(
+ userData,
+ runId,
+ row.status === 'deleted' ? 'delete' : (action ?? 'archive'),
+ env,
+ signal,
+ {
+ baseCommit: report?.source?.baseCommit,
+ checkCurrent,
+ preparedWorkspace:
+ report?.runId === runId &&
+ report.task?.sessionId === sessionId &&
+ report.source?.path &&
+ report.source.branch
+ ? { path: report.source.path, branch: report.source.branch }
+ : undefined,
+ },
+ );
+ checkCurrent();
+ if (!cleaned) return;
+ if (card && report?.task) {
+ await updateMessageContent(sessionId, card.clientId, {
+ ...content,
+ __cindyMakeCard: {
+ ...content.__cindyMakeCard,
+ data: {
+ ...content.__cindyMakeCard.data,
+ report: { ...report, task: { ...report.task, finished: true } },
+ },
+ },
+ });
+ }
+ checkCurrent();
+ cindyMakeManager.forgetTask(runId);
+ }),
+ true,
+ );
+}
+
+/** Settings actions reuse the canonical archive/delete pipeline and its runtime shutdown. */
+export async function manageCindyMakeTask(sessionId: unknown, action: unknown): Promise<void> {
+ if (
+ typeof sessionId !== 'string' ||
+ !/^[a-zA-Z0-9-]{1,128}$/.test(sessionId) ||
+ (action !== 'finish' && action !== 'delete')
+ )
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make action');
+ const client = getDbClient();
+ const owner = captureDataOwnerBroadcastScope();
+ const isCurrent = () => {
+ try {
+ return isDataOwnerBroadcastScopeCurrent(owner) && getDbClient() === client;
+ } catch {
+ return false;
+ }
+ };
+ const [row] = await client.drizzle
+ .select()
+ .from(sessions)
+ .where(eq(sessions.id, sessionId))
+ .limit(1);
+ if (
+ !isCurrent() ||
+ !row ||
+ row.source !== 'cindy-make' ||
+ row.remoteHostId ||
+ !row.workingDir ||
+ !isCindyMakeWorktreePath(app.getPath('userData'), row.workingDir) ||
+ (row.status === 'deleted' && action !== 'delete')
+ )
+ throwIpcError('NOT_FOUND', 'Cindy Make task unavailable');
+ if (!runtime) throwIpcError('PRECONDITION_FAILED', 'busy');
+ if (
+ action === 'finish' &&
+ (cindyMakeManager.isTaskPreparing(sessionId) || runtime.isRunning(sessionId))
+ )
+ throwIpcError('PRECONDITION_FAILED', 'busy');
+ if (!isCurrent()) throwIpcError('PRECONDITION_FAILED', 'unavailable');
+ try {
+ await cindyMakeManager.runTaskAction(sessionId, action, isCurrent, async () => {
+ const status = action === 'delete' ? 'deleted' : 'archived';
+ await runtime!.setStatus(sessionId, { status, pinnedAt: null });
+ await runtime!.recycle(sessionId, status);
+ if (!isCurrent()) throw taskError('unavailable');
+ await withSessionRouteLock(sessionId, () =>
+ recycleCindyMakeTask(sessionId, client.drizzle, isCurrent, action),
+ );
+ });
+ } catch (error) {
+ const code = (error as { code?: string }).code;
+ throwIpcError(
+ 'PRECONDITION_FAILED',
+ code && ['busy', 'dirty', 'conflict', 'unavailable', 'directoryBusy'].includes(code)
+ ? code
+ : 'cleanupFailed',
+ );
+ }
+}
diff --git a/apps/desktop/src/main/cindy-make/taskRuntime.ts b/apps/desktop/src/main/cindy-make/taskRuntime.ts
new file mode 100644
index 0000000000..e8318e864e
--- /dev/null
+++ b/apps/desktop/src/main/cindy-make/taskRuntime.ts
@@ -0,0 +1,578 @@
+import { randomUUID } from 'node:crypto';
+import { normalizeDbAgentKind, dbToMakerAgentKind } from '../../shared/agentKindConversion.js';
+import { and, desc, eq, gt, isNull, like, or } from 'drizzle-orm';
+import { app } from 'electron';
+import { cindyMakeManager } from './manager.js';
+import {
+ createMakeToolchainEnvironment,
+ resolveMakeToolEnvironment,
+ type MakeToolchainEnvironment,
+} from './toolchainEnvironment.js';
+import { prepareCindyMakeEnvironment } from './prepare.js';
+import { untilAborted } from './doctor.js';
+import { prepareCindySource, readCurrentCindySourceStatus } from './sourcePreparation.js';
+import { createCindyMakeWorktree, installCindyMakeWorktree } from './taskWorkspace.js';
+import { CINDY_MAKE_RUN_ID_PATTERN, makeSourceRoot, makeTaskWorktreePath } from './sourcePaths.js';
+import { makeToolRoot } from './toolInstaller.js';
+import { getDbClient } from '../localDb/client/current.js';
+import { messages, sessions } from '../localDb/schema.js';
+import { sessionCreateToRow } from '../localDb/mapper.js';
+import { createMessage, updateMessageContent } from '../localDb/ipc/messages.js';
+import { emitSessionCreated } from '../localDb/ipc/sessionCreatedBroadcast.js';
+import {
+ captureDataOwnerBroadcastScope,
+ isDataOwnerBroadcastScopeCurrent,
+} from '../device-link/broadcast-tap.js';
+import { createBusinessSessionId } from '../sessionIds.js';
+import { createLogger } from '../logger.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import { t } from '../i18n.js';
+import { getSessionRuntimeControlSnapshot } from '../maker-ipc/sessionRuntimeControl.js';
+import { normalizeWorkingDirForStorage } from '../../shared/workingDir.js';
+import {
+ isMakeEnvironmentReady,
+ type CindyMakeTaskStart,
+ type MakeDoctorReport,
+ type MakeTaskWorkspace,
+} from '../../shared/cindyMakeDoctor.js';
+import type { DesktopMakerSendResult } from '../maker-host/send-outcome.js';
+
+export const CINDY_MAKE_TASK_DISPATCH = Symbol('cindy-make-task-dispatch');
+const log = createLogger('cindy-make');
+type SendTask = (
+ sessionId: string,
+ message: string,
+ createOpts: Record<string, unknown>,
+ sendOpts: Record<PropertyKey, unknown>,
+) => Promise<DesktopMakerSendResult>;
+let sendTask: SendTask | undefined;
+let readClearBoundary: ((sessionId: string) => number | null) | undefined;
+
+export function configureCindyMakeTaskSender(
+ sender: SendTask,
+ getClearBoundary: (sessionId: string) => number | null,
+): void {
+ sendTask = sender;
+ readClearBoundary = getClearBoundary;
+}
+
+export async function restoreCindyMakeTaskState(): Promise<void> {
+ const dbClient = getDbClient();
+ const owner = captureDataOwnerBroadcastScope();
+ const isCurrent = () => {
+ try {
+ return isDataOwnerBroadcastScopeCurrent(owner) && getDbClient() === dbClient;
+ } catch {
+ return false;
+ }
+ };
+ const rows = await dbClient.drizzle
+ .select({
+ sessionId: messages.sessionId,
+ clientId: messages.clientId,
+ content: messages.content,
+ clearedAt: sessions.clearedAt,
+ sessionStatus: sessions.status,
+ })
+ .from(messages)
+ .innerJoin(sessions, eq(messages.sessionId, sessions.id))
+ .where(
+ and(
+ eq(sessions.source, 'cindy-make'),
+ like(messages.clientId, 'cindy-make-preparation-%'),
+ isNull(messages.rewindAt),
+ or(isNull(sessions.clearedAt), gt(messages.createdAt, sessions.clearedAt)),
+ ),
+ )
+ .orderBy(desc(messages.createdAt));
+ for (const row of rows) {
+ if (!isCurrent()) return;
+ const isRestoredCurrent = () =>
+ isCurrent() && (!readClearBoundary || readClearBoundary(row.sessionId) === row.clearedAt);
+ if (!isRestoredCurrent()) continue;
+ let content;
+ try {
+ content = JSON.parse(row.content);
+ } catch {
+ continue;
+ }
+ const report = content?.__cindyMakeCard?.data?.report as MakeDoctorReport | undefined;
+ if (
+ !report ||
+ typeof report.runId !== 'string' ||
+ !CINDY_MAKE_RUN_ID_PATTERN.test(report.runId) ||
+ report.task?.sessionId !== row.sessionId ||
+ !Array.isArray(report.checks)
+ )
+ continue;
+ const savedStatus = report.status;
+ if (report.task.finished) {
+ cindyMakeManager.forgetTask(report.runId);
+ continue;
+ }
+ report.task.sessionStatus = row.sessionStatus;
+ const restored = cindyMakeManager.restoreTaskReport(report, isRestoredCurrent);
+ cindyMakeManager.projectTaskSession(report.runId, { sessionStatus: row.sessionStatus });
+ if (restored && restored.status !== savedStatus && isRestoredCurrent()) {
+ await updateMessageContent(row.sessionId, row.clientId, {
+ ...content,
+ text: t(
+ restored.status === 'completed'
+ ? 'cindyMake.code.prepared'
+ : 'cindyMake.prepare.cancelled',
+ ),
+ __cindyMakeCard: {
+ ...content.__cindyMakeCard,
+ data: { ...content.__cindyMakeCard.data, report: restored },
+ },
+ });
+ }
+ }
+}
+
+export async function assertCindyMakeTaskReady(sessionId: string): Promise<void> {
+ const [card] = await getDbClient()
+ .drizzle.select({ content: messages.content })
+ .from(messages)
+ .innerJoin(sessions, eq(messages.sessionId, sessions.id))
+ .where(
+ and(
+ eq(messages.sessionId, sessionId),
+ like(messages.clientId, 'cindy-make-preparation-%'),
+ isNull(messages.rewindAt),
+ or(isNull(sessions.clearedAt), gt(messages.createdAt, sessions.clearedAt)),
+ ),
+ )
+ .orderBy(desc(messages.createdAt))
+ .limit(1);
+ if (!card) return;
+ let status: unknown;
+ try {
+ status = JSON.parse(card.content).__cindyMakeCard?.data?.report?.status;
+ } catch {}
+ if (status !== 'completed')
+ throwIpcError('PRECONDITION_FAILED', 'Retry Cindy Make preparation before starting this task');
+}
+
+export function validateCindyMakeTaskStart(raw: unknown): CindyMakeTaskStart {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make task');
+ const input = raw as Record<string, unknown>;
+ if (
+ (input.originSessionId !== undefined &&
+ (typeof input.originSessionId !== 'string' ||
+ !/^[a-zA-Z0-9-]{1,128}$/.test(input.originSessionId))) ||
+ typeof input.runId !== 'string' ||
+ !CINDY_MAKE_RUN_ID_PATTERN.test(input.runId) ||
+ typeof input.request !== 'string' ||
+ !input.request.trim() ||
+ input.request.length > 4000 ||
+ typeof input.title !== 'string' ||
+ !input.title.trim() ||
+ input.title.length > 200
+ ) {
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make task');
+ }
+ const options = input.createOptions;
+ if (options !== undefined) {
+ if (!options || typeof options !== 'object' || Array.isArray(options))
+ throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make preferences');
+ const fields = options as Record<string, unknown>;
+ for (const [key, value] of Object.entries(fields)) {
+ const valid =
+ value === undefined ||
+ (key === 'agentKind'
+ ? typeof value === 'string' && ['cc', 'codex', 'pi'].includes(value)
+ : key === 'fastMode' || key === 'planModeEnabled'
+ ? typeof value === 'boolean'
+ : key === 'providerId' && value === null
+ ? true
+ : ['model', 'effort', 'providerId', 'permissionMode'].includes(key) &&
+ typeof value === 'string' &&
+ value.length <= 500);
+ if (!valid) throwIpcError('INVALID_PARAMS', 'Invalid Cindy Make preferences');
+ }
+ }
+ return {
+ originSessionId: input.originSessionId as string | undefined,
+ createOptions: options as CindyMakeTaskStart['createOptions'],
+ runId: input.runId,
+ request: input.request,
+ title: input.title.trim(),
+ };
+}
+
+export async function startCindyMakeTask(raw: unknown, sender: number): Promise<string> {
+ const input = validateCindyMakeTaskStart(raw);
+ if (!sendTask) throwIpcError('PRECONDITION_FAILED', 'Task runner is not ready');
+ const dbClient = getDbClient();
+ const db = dbClient.drizzle;
+ const owner = captureDataOwnerBroadcastScope();
+ const isCurrent = () => {
+ try {
+ return isDataOwnerBroadcastScopeCurrent(owner) && getDbClient() === dbClient;
+ } catch {
+ return false;
+ }
+ };
+ const checkCurrent = () => {
+ if (!isCurrent()) throwIpcError('PRECONDITION_FAILED', 'Task owner changed');
+ };
+ const [origin] = input.originSessionId
+ ? await db.select().from(sessions).where(eq(sessions.id, input.originSessionId)).limit(1)
+ : [];
+ checkCurrent();
+ const userData = app.getPath('userData');
+ const root = makeSourceRoot(userData);
+ const clientId = 'cindy-make-preparation-' + input.runId;
+ let sessionId = '';
+ let expectedClearBoundaryMs: number | null = null;
+ let report: MakeDoctorReport;
+ let workspace: MakeTaskWorkspace;
+ const isPreparationCurrent = () =>
+ isCurrent() && (!readClearBoundary || readClearBoundary(sessionId) === expectedClearBoundaryMs);
+ const checkPreparationCurrent = () => {
+ checkCurrent();
+ if (!isPreparationCurrent())
+ throwIpcError('PRECONDITION_FAILED', 'Task preparation was cleared');
+ };
+ const persist = async (next: MakeDoctorReport) => {
+ checkPreparationCurrent();
+ const [current] = await db
+ .select({ clearedAt: sessions.clearedAt })
+ .from(sessions)
+ .where(eq(sessions.id, sessionId))
+ .limit(1);
+ checkPreparationCurrent();
+ if (!current || current.clearedAt !== expectedClearBoundaryMs)
+ throwIpcError('PRECONDITION_FAILED', 'Task preparation was cleared');
+ const content = {
+ text: t(
+ next.status === 'failed'
+ ? 'cindyMake.code.preparationFailed'
+ : next.status === 'cancelled'
+ ? 'cindyMake.prepare.cancelled'
+ : next.status === 'completed'
+ ? 'cindyMake.code.prepared'
+ : 'cindyMake.code.phases.' + next.task!.phase,
+ ),
+ __cindyMakeCard: {
+ type: 'cindy-make',
+ data: {
+ request: input.request,
+ codeSessionId: sessionId,
+ decision: 'personal',
+ mainOwned: true,
+ report: next,
+ },
+ },
+ };
+ const updated = await updateMessageContent(sessionId, clientId, content);
+ checkPreparationCurrent();
+ if (!updated)
+ await createMessage(
+ sessionId,
+ { clientId, role: 'assistant', content },
+ {
+ broadcastOwnerScope: owner,
+ expectedClearBoundaryMs,
+ shouldBroadcast: isPreparationCurrent,
+ },
+ );
+ };
+ const phase = (
+ name: NonNullable<MakeDoctorReport['task']>['phase'],
+ publish: (value: MakeDoctorReport) => void,
+ ) => {
+ checkPreparationCurrent();
+ report = { ...report, status: 'running', task: { ...report.task!, phase: name } };
+ publish(report);
+ };
+ return cindyMakeManager.startTask(input, {
+ isCurrent: isPreparationCurrent,
+ onError: (error) =>
+ log.warn('task preparation failed', {
+ runId: input.runId,
+ code: (error as { code?: unknown })?.code,
+ }),
+ onCreated: () => {
+ checkPreparationCurrent();
+ emitSessionCreated(sessionId);
+ },
+ create: async (previousReport) => {
+ const [previous] = await db
+ .select({
+ sessionId: messages.sessionId,
+ content: messages.content,
+ status: sessions.status,
+ createdAt: messages.createdAt,
+ clearedAt: sessions.clearedAt,
+ })
+ .from(messages)
+ .innerJoin(sessions, eq(sessions.id, messages.sessionId))
+ .where(and(eq(messages.clientId, clientId), eq(sessions.source, 'cindy-make')))
+ .limit(1);
+ checkCurrent();
+ if (previous) {
+ if (previous.status !== 'active')
+ throwIpcError('PRECONDITION_FAILED', 'Prepared task is archived');
+ if (previous.clearedAt !== null && previous.createdAt <= previous.clearedAt)
+ throwIpcError('PRECONDITION_FAILED', 'Task preparation was cleared');
+ const data = JSON.parse(previous.content).__cindyMakeCard?.data;
+ if (
+ data?.report?.task?.originSessionId !== input.originSessionId ||
+ data?.request !== input.request
+ )
+ throwIpcError('INVALID_PARAMS', 'Task run does not match');
+ sessionId = previous.sessionId;
+ expectedClearBoundaryMs = previous.clearedAt;
+ checkPreparationCurrent();
+ report = data.report as MakeDoctorReport;
+ const alreadyStarted = report.status === 'completed';
+ report = {
+ ...report,
+ status: alreadyStarted ? 'completed' : 'running',
+ task: {
+ ...report.task!,
+ phase: alreadyStarted ? 'completed' : 'waiting',
+ dependencies: undefined,
+ },
+ };
+ } else if (previousReport?.task) {
+ sessionId = previousReport.task.sessionId;
+ const [row] = await db.select().from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ checkCurrent();
+ if (
+ !row ||
+ row.status !== 'active' ||
+ row.source !== 'cindy-make' ||
+ normalizeWorkingDirForStorage(row.workingDir) !==
+ normalizeWorkingDirForStorage(makeTaskWorktreePath(userData, input.runId)) ||
+ row.remoteHostId
+ )
+ throwIpcError('PRECONDITION_FAILED', 'Prepared task is unavailable');
+ if (row.clearedAt !== null && row.createdAt <= row.clearedAt)
+ throwIpcError('PRECONDITION_FAILED', 'Task preparation was cleared');
+ expectedClearBoundaryMs = row.clearedAt;
+ checkPreparationCurrent();
+ report = {
+ ...previousReport,
+ status: 'running',
+ task: { ...previousReport.task, phase: 'waiting', dependencies: undefined },
+ };
+ } else {
+ // Existing preparations own their session and preferences. Only a new
+ // task needs a live local origin from which to inherit its configuration.
+ if (input.originSessionId && (!origin || origin.status !== 'active'))
+ throwIpcError('NOT_FOUND', 'Origin task is unavailable');
+ if (origin?.remoteHostId)
+ throwIpcError('UNSUPPORTED_CAPABILITY', 'Cindy Make requires a local task');
+ const effective = origin
+ ? getSessionRuntimeControlSnapshot(origin.id).effectiveOverride
+ : undefined;
+ const preferences = origin ?? input.createOptions ?? {};
+ sessionId = createBusinessSessionId();
+ const row = sessionCreateToRow(
+ sessionId,
+ {
+ title: input.title,
+ workingDir: makeTaskWorktreePath(userData, input.runId),
+ workspaceKind: 'project',
+ source: 'cindy-make',
+ agentKind: normalizeDbAgentKind(effective?.agentKind ?? preferences.agentKind),
+ model: effective?.model ?? preferences.model,
+ effort: effective ? (effective.effort ?? '') : preferences.effort,
+ providerId: effective ? effective.providerId : preferences.providerId,
+ fastMode: effective?.fastMode ?? preferences.fastMode,
+ planModeEnabled: preferences.planModeEnabled,
+ permissionMode: preferences.permissionMode,
+ },
+ Date.now(),
+ );
+ await db.insert(sessions).values(row);
+ checkCurrent();
+ expectedClearBoundaryMs = row.clearedAt ?? null;
+ report = {
+ runId: input.runId,
+ platform: process.platform,
+ arch: process.arch,
+ mode: 'prepare',
+ status: 'running',
+ checks: [],
+ task: {
+ title: input.title,
+ request: input.request,
+ sessionId,
+ originSessionId: input.originSessionId,
+ phase: 'waiting',
+ },
+ };
+ }
+ return report;
+ },
+ persist,
+ prepare: async (signal, publish) => {
+ phase('environment', publish);
+ const operationId = randomUUID();
+ const operation = cindyMakeManager.claim<MakeToolchainEnvironment>(
+ { resource: 'environment', mode: 'prepare', forceManagedTools: false },
+ operationId,
+ sender,
+ (environmentReport) => {
+ if (!signal.aborted) {
+ report = { ...report, checks: environmentReport.checks };
+ publish(report);
+ }
+ },
+ );
+ if (!operation.attached) {
+ void (async () => {
+ try {
+ const environment = await createMakeToolchainEnvironment(userData);
+ const sharedSignal = AbortSignal.any([
+ operation.controller.signal,
+ AbortSignal.timeout(20 * 60_000),
+ ]);
+ const checked = await prepareCindyMakeEnvironment(
+ operationId,
+ environment,
+ makeToolRoot(userData),
+ sharedSignal,
+ operation.publish,
+ );
+ operation.complete(checked, environment);
+ } catch {
+ operation.complete({
+ runId: operationId,
+ platform: process.platform,
+ arch: process.arch,
+ checks: [],
+ mode: 'prepare',
+ status: operation.controller.signal.aborted ? 'cancelled' : 'failed',
+ });
+ }
+ })();
+ }
+ let env: MakeToolchainEnvironment;
+ try {
+ const prepared = await untilAborted(operation.promise, signal);
+ signal.throwIfAborted();
+ if (!isMakeEnvironmentReady(prepared) || !operation.context)
+ throw Object.assign(new Error('environment not ready'), { code: 'environmentNotReady' });
+ env = operation.context;
+ } finally {
+ operation.unsubscribe();
+ }
+ phase('source', publish);
+ let source = await readCurrentCindySourceStatus(root, env);
+ signal.throwIfAborted();
+ if (source.status !== 'ready') {
+ const version = app.getVersion();
+ const result = await untilAborted(
+ prepareCindySource(
+ env,
+ root,
+ {
+ channel: !app.isPackaged ? 'dev' : version.includes('-beta') ? 'beta' : 'release',
+ version,
+ },
+ AbortSignal.timeout(20 * 60_000),
+ (progress) => {
+ if (!signal.aborted) {
+ report = { ...report, source: { ...progress, ref: progress.target.ref } };
+ publish(report);
+ }
+ },
+ ),
+ signal,
+ );
+ if (result.status !== 'ready')
+ throw Object.assign(new Error('source not ready'), { code: result.error });
+ source = await readCurrentCindySourceStatus(root, env);
+ }
+ signal.throwIfAborted();
+ report = { ...report, source };
+ cindyMakeManager.setSourceStatus(source);
+ phase('workspace', publish);
+ await untilAborted(
+ cindyMakeManager.withProject(
+ root,
+ async () => {
+ checkCurrent();
+ const processEnvironment = await resolveMakeToolEnvironment(
+ env,
+ ['git', 'node', 'pnpm', 'python'],
+ signal,
+ );
+ workspace = await createCindyMakeWorktree(userData, input.runId, signal, {
+ processEnvironment,
+ });
+ signal.throwIfAborted();
+ report = { ...report, source: { status: 'ready', ...workspace } };
+ phase('dependencies', publish);
+ await installCindyMakeWorktree(
+ userData,
+ workspace,
+ signal,
+ { processEnvironment },
+ undefined,
+ (dependencies) => {
+ if (!signal.aborted) {
+ report = { ...report, task: { ...report.task!, dependencies } };
+ publish(report);
+ }
+ },
+ );
+ },
+ signal,
+ ),
+ signal,
+ );
+ },
+ start: async (signal) => {
+ checkPreparationCurrent();
+ signal.throwIfAborted();
+ const [row] = await db.select().from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ checkPreparationCurrent();
+ signal.throwIfAborted();
+ if (
+ !row ||
+ row.status !== 'active' ||
+ row.source !== 'cindy-make' ||
+ normalizeWorkingDirForStorage(row.workingDir) !==
+ normalizeWorkingDirForStorage(workspace.path) ||
+ row.clearedAt !== expectedClearBoundaryMs ||
+ row.remoteHostId
+ )
+ throwIpcError('PRECONDITION_FAILED', 'Task changed during preparation');
+ const sent = await sendTask!(
+ sessionId,
+ input.request,
+ {
+ id: sessionId,
+ agentKind: dbToMakerAgentKind(row.agentKind),
+ workingDir: workspace.path,
+ model: row.model,
+ effort: row.effort,
+ providerId: row.providerId,
+ fastMode: row.fastMode,
+ permissionMode: row.permissionMode,
+ planMode: row.planModeEnabled,
+ },
+ {
+ [CINDY_MAKE_TASK_DISPATCH]: true,
+ signal,
+ expectedClearBoundaryMs,
+ persistUserMessage: {
+ clientId: 'cindy-make-first-' + input.runId,
+ content: input.request,
+ expectedClearBoundaryMs,
+ shouldBroadcast: isPreparationCurrent,
+ },
+ },
+ );
+ if (!sent.accepted)
+ throw Object.assign(new Error('task dispatch failed'), { code: sent.reason });
+ },
+ });
+}
diff --git a/apps/desktop/src/main/cindy-make/taskWorkspace.ts b/apps/desktop/src/main/cindy-make/taskWorkspace.ts
index f7e8ffdd3d..f64459a77d 100644
--- a/apps/desktop/src/main/cindy-make/taskWorkspace.ts
+++ b/apps/desktop/src/main/cindy-make/taskWorkspace.ts
@@ -1,11 +1,12 @@
import { access, lstat, mkdir } from 'node:fs/promises';
import path from 'node:path';
-import type { MakeTaskWorkspace } from '../../shared/cindyMakeDoctor.js';
+import type { CindyMakeTaskPreparation, MakeTaskWorkspace } from '../../shared/cindyMakeDoctor.js';
import { runSourceGit } from './sourceGit.js';
import { runSourcePnpm } from './sourcePnpm.js';
import {
CINDY_MAKE_RUN_ID_PATTERN,
CINDY_PERSONAL_BRANCH,
+ isCindyMakeWorktreePath,
makeSourceCheckoutPath,
makeTaskBranch,
makeTaskWorktreePath,
@@ -32,11 +33,11 @@ async function exists(file: string): Promise<boolean> {
/**
* Create (or reuse) the per-task worktree: a fresh branch off the personal
- * baseline, checked out under `<root>/worktrees/<runId>`, with dependencies
- * installed so the agent can run the repository's checks immediately. Reuse
+ * baseline, checked out under `<root>/worktrees/<runId>`. Dependency installation
+ * is a separate step after the task is visible. Reuse
* keeps a retry after a crash from creating a second branch for the same task.
*/
-export async function prepareCindyMakeWorkspace(
+export async function createCindyMakeWorktree(
userData: string,
runId: string,
signal: AbortSignal,
@@ -47,7 +48,6 @@ export async function prepareCindyMakeWorkspace(
throw Object.assign(new Error('invalid run id'), { code: 'gitFailed' });
}
const git = deps.git ?? runSourceGit;
- const pnpm = deps.pnpm ?? runSourcePnpm;
const env = deps.processEnvironment;
const sourcePath = makeSourceCheckoutPath(userData);
const worktreePath = makeTaskWorktreePath(userData, runId);
@@ -102,26 +102,45 @@ export async function prepareCindyMakeWorkspace(
);
}
}
+ return { path: worktreePath, branch, baseCommit: baseCommit.trim() };
+}
+
+/** Install dependencies in an already-created task worktree. */
+export async function installCindyMakeWorktree(
+ userData: string,
+ workspace: MakeTaskWorkspace,
+ signal: AbortSignal,
+ deps: TaskWorkspaceDeps,
+ onPhase: (phase: TaskWorkspacePhase) => void = () => {},
+ onProgress?: (progress: NonNullable<CindyMakeTaskPreparation['dependencies']>) => void,
+): Promise<MakeTaskWorkspace> {
+ const pnpm = deps.pnpm ?? runSourcePnpm;
onPhase('installing');
+ signal.throwIfAborted();
+ if (!isCindyMakeWorktreePath(userData, workspace.path)) {
+ throw Object.assign(new Error('invalid task workspace'), { code: 'gitFailed' });
+ }
await pnpm(
- env,
+ deps.processEnvironment,
['install', '--frozen-lockfile', '--prefer-offline', '--prod=false'],
- worktreePath,
+ workspace.path,
signal,
+ ...(onProgress ? [onProgress] : []),
);
signal.throwIfAborted();
- return { path: worktreePath, branch, baseCommit: baseCommit.trim() };
+ return workspace;
}
-/** Whether `workingDir` is a task worktree Cindy created (used by the session source guard). */
-export function isCindyMakeWorktreePath(userData: string, workingDir: string): boolean {
- const root = makeWorktreesRoot(userData);
- const relative = path.relative(root, path.resolve(workingDir));
- return (
- relative.length > 0 &&
- !relative.startsWith('..') &&
- !path.isAbsolute(relative) &&
- !relative.includes(path.sep) &&
- CINDY_MAKE_RUN_ID_PATTERN.test(relative)
- );
+/** Backwards-compatible synchronous preparation used by existing callers/tests. */
+export async function prepareCindyMakeWorkspace(
+ userData: string,
+ runId: string,
+ signal: AbortSignal,
+ deps: TaskWorkspaceDeps,
+ onPhase: (phase: TaskWorkspacePhase) => void = () => {},
+): Promise<MakeTaskWorkspace> {
+ const workspace = await createCindyMakeWorktree(userData, runId, signal, deps, onPhase);
+ return installCindyMakeWorktree(userData, workspace, signal, deps, onPhase);
}
+
+export { isCindyMakeWorktreePath };
diff --git a/apps/desktop/src/main/commands/builtins.ts b/apps/desktop/src/main/commands/builtins.ts
index 0e3c717612..7c720c5854 100644
--- a/apps/desktop/src/main/commands/builtins.ts
+++ b/apps/desktop/src/main/commands/builtins.ts
@@ -449,6 +449,7 @@ export function registerBuiltinDesktopCommands(
error: progress.error,
phase: progress.phase,
progress: progress.progress,
+ dependencies: progress.dependencies,
},
});
},
diff --git a/apps/desktop/src/main/localDb/__tests__/sessionCreateToRow.providerId.test.ts b/apps/desktop/src/main/localDb/__tests__/sessionCreateToRow.providerId.test.ts
index 9ada504e61..392d6e5b06 100644
--- a/apps/desktop/src/main/localDb/__tests__/sessionCreateToRow.providerId.test.ts
+++ b/apps/desktop/src/main/localDb/__tests__/sessionCreateToRow.providerId.test.ts
@@ -50,4 +50,14 @@ describe('sessionCreateToRow source', () => {
it('未传 source 仍保持 desktop 兼容默认值', () => {
expect(sessionCreateToRow('desktop-session', { workingDir: '/repo' }, now).source).toBe('desktop');
});
+
+ it('Cindy Make 创建标题直接落库,不回到默认未命名标题', () => {
+ expect(
+ sessionCreateToRow(
+ 'cindy-make-session',
+ { workingDir: '/repo', source: 'cindy-make', title: '[Cindy-Make] 修复构建' },
+ now,
+ ).title,
+ ).toBe('[Cindy-Make] 修复构建');
+ });
});
diff --git a/apps/desktop/src/main/localDb/ipc/sessions.ts b/apps/desktop/src/main/localDb/ipc/sessions.ts
index e156315071..258ddfd9c2 100644
--- a/apps/desktop/src/main/localDb/ipc/sessions.ts
+++ b/apps/desktop/src/main/localDb/ipc/sessions.ts
@@ -87,6 +87,8 @@ import { removeTurnChangeSetsForSession } from '../../turn-change-set/store.js';
import { quiesceSessionBeforeWorktreeRecycle } from './sessionRemovalOperations.js';
import { withSessionRouteLock, withSessionRouteLocks } from '../sessionRouteLock.js';
import { cleanupSessionRuntimeForTerminalStatus } from '../sessionRuntimeCleanup.js';
+import { cindyMakeManager } from '../../cindy-make/manager.js';
+import { recycleCindyMakeTask } from '../../cindy-make/taskManagement.js';
import { broadcastSubagentRunsInvalidated } from './subagentRuns.js';
import { compactSessionToolResultsBestEffort } from '../toolResultCompaction.js';
import { consumeWritableDirectoryPickerGrants } from '../../maker-ipc/writableDirectoryPickerGrant.js';
@@ -460,6 +462,8 @@ async function recycleSessionWorktreeInQueue(
ownerIsCurrent() && recycle.isSessionStillRemovable(id, mediaDb);
const closeAndRecycle = async (targetSessionId: string, scanOwners: boolean): Promise<void> => {
if (!(await isStillRemovable(targetSessionId))) return;
+ // Settle preparation before taking the send route lock it may be waiting for.
+ await cindyMakeManager.settleTasksForSession(targetSessionId);
await withSessionRouteLock(targetSessionId, async () => {
const shouldRecycle = await quiesceSessionBeforeWorktreeRecycle(targetSessionId, {
isOwnerCurrent: ownerIsCurrent,
@@ -474,6 +478,7 @@ async function recycleSessionWorktreeInQueue(
},
});
if (!shouldRecycle || !ownerIsCurrent()) return;
+ await recycleCindyMakeTask(targetSessionId, mediaDb, ownerIsCurrent);
// Keep irreversible cleanup under the same task route lock as the final
// status check. A concurrent restore/start/send must not slip between
@@ -1335,6 +1340,12 @@ export function registerSessionIpc(
if (bodyObj.agentKind !== undefined && !ALLOWED_AGENT_KINDS.has(bodyObj.agentKind as string)) {
throwIpcError('INVALID_PARAMS', `invalid agentKind: ${String(bodyObj.agentKind)}`);
}
+ if (
+ bodyObj.title !== undefined &&
+ (typeof bodyObj.title !== 'string' || bodyObj.title.length > 200)
+ ) {
+ throwIpcError('INVALID_PARAMS', 'title must be a string no longer than 200 characters');
+ }
const ALLOWED_WORKSPACE_KINDS = new Set<string>(['project', 'dialogue']);
if (
bodyObj.workspaceKind !== undefined &&
diff --git a/apps/desktop/src/main/localDb/mapper.ts b/apps/desktop/src/main/localDb/mapper.ts
index f854901cdd..1b4c0232b1 100644
--- a/apps/desktop/src/main/localDb/mapper.ts
+++ b/apps/desktop/src/main/localDb/mapper.ts
@@ -348,6 +348,7 @@ export function sessionCreateToRow(
body:
| {
id?: string;
+ title?: string;
workingDir?: string;
workspaceKind?: WorkspaceKind;
model?: string;
@@ -377,7 +378,10 @@ export function sessionCreateToRow(
): SessionInsert {
return {
id,
- title: DEFAULT_DRAFT_SESSION_TITLE,
+ title:
+ typeof body?.title === 'string' && body.title.trim().length > 0
+ ? body.title.trim()
+ : DEFAULT_DRAFT_SESSION_TITLE,
workingDir: normalizeWorkingDirForStorage(body?.workingDir),
workspaceKind: body?.workspaceKind ?? 'project',
model: body?.model ?? 'claude-sonnet-4-6',
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index 515d3a08f0..18850c1128 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -1,4 +1,6 @@
import { readDisabledSkillPaths } from '../skillhub/activationPreferences';
+import { cindyMakeManager } from '../cindy-make/manager.js';
+import { makeSourceRoot } from '../cindy-make/sourcePaths.js';
import { clearCodexAccountUsageSnapshot } from '../usageBroadcaster.js';
/**
* apps/desktop/src/main/maker-host
@@ -1071,10 +1073,12 @@ export function getMaker(): Maker {
}
const env = await createMakeToolchainEnvironment(userData);
const title = meta.title?.trim();
- return commitCindyMakeChanges(
- (args) =>
- runSourceGit(env.processEnvironment(), args, meta.workDir, AbortSignal.timeout(60_000)),
- `Cindy Make: ${title || sessionId}`,
+ return cindyMakeManager.withProject(makeSourceRoot(userData), () =>
+ commitCindyMakeChanges(
+ (args) =>
+ runSourceGit(env.processEnvironment(), args, meta.workDir, AbortSignal.timeout(60_000)),
+ `Cindy Make: ${title || sessionId}`,
+ ),
);
},
persist: (sessionId, meta) =>
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
index 2e7b9e3653..eb65afaa6a 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
@@ -831,6 +831,80 @@ describe('provider turn observer on real Session.send', () => {
},
};
}
+ it('holds the send reservation while waiting for the local project boundary', async () => {
+ const harnessState = harness();
+ const gate = deferred();
+ const onAccepted = vi.fn();
+ const beforeLocalProviderStart = vi.fn(async (session: Session) => {
+ expect(session.isTurnRunning()).toBe(true);
+ await gate.promise;
+ effects.calls.push('project-ready');
+ });
+ const dispose = installSessionTurnObserver(
+ { ...observerDeps(), beforeLocalProviderStart }, harnessState.session,
+ );
+ const sending = harnessState.session.send('test', { onAccepted });
+ try {
+ await microtasks();
+ expect(beforeLocalProviderStart).toHaveBeenCalledWith(harnessState.session);
+ expect(harnessState.session.isTurnRunning()).toBe(true);
+ expect(onAccepted).not.toHaveBeenCalled();
+ expect(harnessState.handle.send).not.toHaveBeenCalled();
+ expect(effects.fn('verdictForModelRoute')).not.toHaveBeenCalled();
+ gate.resolve();
+ await sending;
+ ordered('project-ready', 'lease-start');
+ expect(effects.fn('verdictForModelRoute')).toHaveBeenCalledOnce();
+ expect(onAccepted).toHaveBeenCalledOnce();
+ expect(harnessState.handle.send).toHaveBeenCalledOnce();
+ } finally {
+ gate.resolve();
+ await sending;
+ dispose();
+ await harnessState.dispose();
+ }
+ });
+
+ it('rejects unavailable local projects before persistence, lease and provider dispatch', async () => {
+ const harnessState = harness();
+ const deps = observerDeps();
+ const onAccepted = vi.fn();
+ const beforeLocalProviderStart = vi.fn(async () => {
+ throw new Error('project unavailable');
+ });
+ const dispose = installSessionTurnObserver(
+ { ...deps, beforeLocalProviderStart }, harnessState.session,
+ );
+ try {
+ await expect(harnessState.session.send('test', { onAccepted })).rejects.toThrow('project unavailable');
+ expect(beforeLocalProviderStart).toHaveBeenCalledOnce();
+ expect(onAccepted).not.toHaveBeenCalled();
+ expect(deps.sessionTurnLeaseTracker.markTurnStarted).not.toHaveBeenCalled();
+ expect(harnessState.handle.send).not.toHaveBeenCalled();
+ expect(harnessState.session.isTurnRunning()).toBe(false);
+ } finally {
+ dispose();
+ await harnessState.dispose();
+ }
+ });
+
+ it('does not apply the local project boundary to a remote session', async () => {
+ const harnessState = harness();
+ Object.defineProperty(harnessState.session, 'remoteHostId', { value: 'ssh-host' });
+ const beforeLocalProviderStart = vi.fn(async () => {});
+ const dispose = installSessionTurnObserver(
+ { ...observerDeps(), beforeLocalProviderStart }, harnessState.session,
+ );
+ try {
+ await harnessState.session.send('test');
+ expect(beforeLocalProviderStart).not.toHaveBeenCalled();
+ expect(harnessState.handle.send).toHaveBeenCalledOnce();
+ } finally {
+ dispose();
+ await harnessState.dispose();
+ }
+ });
+
it.each(['reject', 'reroute'] as const)(
'stops a paid-model %s before lease and provider dispatch',
async (kind) => {
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 2c758a0342..1bd959ea01 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -586,6 +586,10 @@ import { readXaiSubscriptionUsageSnapshotForDeviceLink, readClaudeSubscriptionUs
import { requireEnum, requireObject, throwIpcError } from '../utils/ipcValidate.js';
import { applyPersistedCindyMakeMarker } from './cindyMakeSessionStart.js';
import { CINDY_MAKE_SESSION_SOURCE } from '../../shared/cindyMakeSession.js';
+import { cindyMakeManager } from '../cindy-make/manager.js';
+import { assertCindyMakeWorkspace, withCindyMakeProjectUse } from '../cindy-make/projectAccess.js';
+import { isCindyMakeWorktreePath } from '../cindy-make/sourcePaths.js';
+import { assertCindyMakeTaskReady, configureCindyMakeTaskSender, CINDY_MAKE_TASK_DISPATCH } from '../cindy-make/taskRuntime.js';
import { isIpcError, type IpcErrorCode } from '../../shared/ipc-errors.js';
import { piPackageCommandDiagnostic } from '../maker-host/pi-package-diagnostic.js';
import {
@@ -4571,6 +4575,8 @@ const sessionEventDependencies: SessionEventDependencies = {
};
const sessionTurnObserverDependencies = {
+ beforeLocalProviderStart: (session: Session) =>
+ withCindyMakeProjectUse(app.getPath('userData'), session.workDir, async () => undefined),
silentStopTurnLeaseGate,
sessionTurnLeaseTracker,
providerTurnLeaseId,
@@ -8465,47 +8471,57 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
anchorClientId: string,
opts: SessionSendOptions,
): Promise<SessionSendResult> {
- let baselineStarted = false;
- let turnChangeSetStarted = false;
- const pendingHandoff = await agentHandoffPending.peek(session.id);
- const outgoingMessage: UserMessage = pendingHandoff
- ? (prependHandoffToUserMessage(
- { type: 'user', content: message },
- pendingHandoff,
- ) as UserMessage)
- : { type: 'user', content: message };
- try {
- const sendResult = await session.send(outgoingMessage, {
- ...opts,
- onAccepted: async () => {
- await opts.onAccepted?.();
- await beginTurnChangeSetAtDispatch(session, anchorClientId);
- turnChangeSetStarted = true;
- if (gitSnapshotCoordinator) {
- await gitSnapshotCoordinator.onTurnStart(session.id);
- baselineStarted = true;
- }
- },
- });
- if (turnChangeSetStarted && !sendResult.accepted) {
- clearPendingTurnChangeSets(session.id);
- }
- if (baselineStarted && !sendResult.accepted) {
- gitSnapshotCoordinator?.onTurnAbort(session.id);
- }
- if (pendingHandoff && sendResult.accepted) {
- agentHandoffPending.consume(session.id);
- }
- return sendResult;
- } catch (err) {
- if (turnChangeSetStarted) {
- clearPendingTurnChangeSets(session.id);
- }
- if (baselineStarted) {
- gitSnapshotCoordinator?.onTurnAbort(session.id);
- }
- throw err;
+ if (!session.remoteHostId && isCindyMakeWorktreePath(app.getPath('userData'), session.workDir)) {
+ if (cindyMakeManager.isTaskPreparing(session.id))
+ throwIpcError('PRECONDITION_FAILED', 'Cindy Make is still preparing this task');
+ await assertCindyMakeTaskReady(session.id);
}
+ const dispatch = async (): Promise<SessionSendResult> => {
+ let baselineStarted = false;
+ let turnChangeSetStarted = false;
+ const pendingHandoff = await agentHandoffPending.peek(session.id);
+ const outgoingMessage: UserMessage = pendingHandoff
+ ? (prependHandoffToUserMessage(
+ { type: 'user', content: message },
+ pendingHandoff,
+ ) as UserMessage)
+ : { type: 'user', content: message };
+ try {
+ const sendResult = await session.send(outgoingMessage, {
+ ...opts,
+ onAccepted: async () => {
+ await opts.onAccepted?.();
+ await beginTurnChangeSetAtDispatch(session, anchorClientId);
+ turnChangeSetStarted = true;
+ if (gitSnapshotCoordinator) {
+ await gitSnapshotCoordinator.onTurnStart(session.id);
+ baselineStarted = true;
+ }
+ },
+ });
+ if (turnChangeSetStarted && !sendResult.accepted) {
+ clearPendingTurnChangeSets(session.id);
+ }
+ if (baselineStarted && !sendResult.accepted) {
+ gitSnapshotCoordinator?.onTurnAbort(session.id);
+ }
+ if (pendingHandoff && sendResult.accepted) {
+ agentHandoffPending.consume(session.id);
+ }
+ return sendResult;
+ } catch (err) {
+ if (turnChangeSetStarted) {
+ clearPendingTurnChangeSets(session.id);
+ }
+ if (baselineStarted) {
+ gitSnapshotCoordinator?.onTurnAbort(session.id);
+ }
+ throw err;
+ }
+ };
+ return session.remoteHostId
+ ? dispatch()
+ : withCindyMakeProjectUse(app.getPath('userData'), session.workDir, dispatch);
}
async function sendToSessionInternal(params: {
@@ -12265,6 +12281,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const sendToAgentAccepted: typeof sendToAgentAcceptedUnlocked = async (...args) => {
const [sessionId] = args;
if (typeof sessionId !== 'string') return await sendToAgentAcceptedUnlocked(...args);
+ if (cindyMakeManager.isTaskPreparing(sessionId) && (args[3] as Record<PropertyKey, unknown> | undefined)?.[CINDY_MAKE_TASK_DISPATCH] !== true) {
+ throwIpcError('PRECONDITION_FAILED', 'Cindy Make is still preparing this task');
+ }
await assertReviewExternalInputAllowed(sessionId);
await reconcileBotModelRoute(sessionId);
const compactedRuntime = maker.getSession(sessionId);
@@ -12275,6 +12294,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
.drizzle.select({
source: sessions.source,
role: botSessionLinks.role,
+ workingDir: sessions.workingDir,
+ remoteHostId: sessions.remoteHostId,
profileStatus: botProfiles.status,
hiddenAt: botProfiles.hiddenAt,
})
@@ -12284,6 +12305,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
.where(eq(sessions.id, sessionId))
.limit(1);
const blocked = botSessionInputBlockReason(botInput ?? null);
+ if (botInput?.source === CINDY_MAKE_SESSION_SOURCE && (args[3] as Record<PropertyKey, unknown> | undefined)?.[CINDY_MAKE_TASK_DISPATCH] !== true) {
+ await assertCindyMakeTaskReady(sessionId);
+ }
if (isDeviceLinkInvoke() && botInput?.source === 'bot' && (botInput.hiddenAt || botInput.profileStatus === 'archived')) {
throwIpcError('NOT_FOUND', 'Session does not exist');
}
@@ -12291,7 +12315,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
if (inputCoordinator.isExecutionPaused(sessionId)) {
throwIpcError('PRECONDITION_FAILED', 'Task is paused; resume it before continuing');
}
- return sendToAgentAcceptedUnlocked(...args);
+ return botInput?.remoteHostId ? sendToAgentAcceptedUnlocked(...args)
+ : withCindyMakeProjectUse(app.getPath('userData'), botInput?.workingDir, () => sendToAgentAcceptedUnlocked(...args));
});
};
contextOverflowRolloverHolder = createContextOverflowRollover({
@@ -12587,7 +12612,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
(row.source !== 'desktop' || isHeadlessGhostSetupTurn(sessionId) || bindingStore.findByTarget(sessionId))) {
return { accepted: false };
}
- const result = await sendToAgentAcceptedUnlocked(
+ const sendReplay = () => sendToAgentAcceptedUnlocked(
sessionId,
persistedUserContentToWireMessage(agentFacingWireContent ?? content),
createOpts,
@@ -12602,6 +12627,8 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
: { signal: recovery?.signal },
);
+ const result = row.remoteHostId ? await sendReplay()
+ : await withCindyMakeProjectUse(app.getPath('userData'), row.workingDir, sendReplay);
return { accepted: result.accepted === true };
},
withSessionLock: withSendToSessionLock,
@@ -12800,6 +12827,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
};
};
const revokeTrustedDesktopQueueOrigin = (item?: AgentInputQueuedMessage): void => { if (item?.origin) delete (item.origin as Record<PropertyKey, unknown>)[TRUSTED_DESKTOP_QUEUE_ORIGIN]; };
+ configureCindyMakeTaskSender((sessionId, message, createOpts, sendOpts) =>
+ sendToAgentAccepted(sessionId, message, createOpts, attachTrustedDesktopSendContext(message, sendOpts)),
+ (sessionId) => inputCoordinator.getClearBoundaryMs(sessionId),
+ );
registerMakerSessionSendHandler(
{
handle(channel, handler) {
@@ -15327,6 +15358,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
isRemoteInvoke: remoteInvoke,
});
const projection = inputCoordinator.clearSession(sid, clearBoundary);
+ cindyMakeManager.cancelTasksForSession(sid);
workingDirectoryRecovery.discard(sid);
resetAutomaticRecoveryForExplicitStop(sid);
// 丢弃缓存的待注入交接 / fork 来源标记:它们是按 clear 之前的历史算出来的,
@@ -18018,6 +18050,8 @@ async function checkWorkDirExists(
// 或者 agent 真跑起来时由远端 codex 自己报 ENOENT)。这里直接放行。
if (remoteHostId) return true;
if (!workingDir?.trim()) return true;
+ const cindyMakeWorkspace = isCindyMakeWorktreePath(app.getPath('userData'), workingDir);
+ if (cindyMakeWorkspace) workingDirectoryRecovery.discard(sessionId);
workingDir = workingDirectoryRecovery.resolve(sessionId, workingDir);
const source: AgentKind = agentKind === 'codex' || agentKind === 'pi' ? agentKind : 'claude-code';
// suppressMissingBroadcast: 调用方(SEND 事务)手里还有 DB 权威值可兜底时,
@@ -18030,6 +18064,7 @@ async function checkWorkDirExists(
usingFallback: workingDirectoryRecovery.isFallback(sessionId, workingDir),
};
try {
+ if (cindyMakeWorkspace) await assertCindyMakeWorkspace(app.getPath('userData'), workingDir);
const stat = await statWorkingDirectory(workingDir);
if (!stat.isDirectory()) {
workdirLog.warn('workdir preflight rejected', { ...diagnosticContext, reason: 'not-directory' });
@@ -18062,7 +18097,7 @@ async function checkWorkDirExists(
return false;
}
}
- if (getManagedWorktreeBasePath(normalizedWorkingDir) === null) {
+ if (!cindyMakeWorkspace && getManagedWorktreeBasePath(normalizedWorkingDir) === null) {
if (!await workingDirectoryRecovery.recover(sessionId, workingDir)) {
workdirLog.warn('workdir preflight rejected', { ...diagnosticContext, reason: 'recovery-failed-after-stat' });
return false;
@@ -18080,6 +18115,10 @@ async function checkWorkDirExists(
workdirLog.warn('workdir preflight failed', {
...diagnosticContext, code: workdirDiagnosticErrorCode(error), elapsedMs: Date.now() - startedAt,
});
+ if (cindyMakeWorkspace) {
+ if (!suppress) emitWorkDirMissingError(sessionId, workingDir, source, 'not-exist');
+ return false;
+ }
// Cindy 托管 worktree 被外部 PR cleanup / 手动 git 命令移除时,先按 DB 中
// 的精确 worktree_path 从本地或 origin tracking 分支重建,保留原代码与快照。
const restored = await restoreMissingManagedWorktreeForSession(sessionId, workingDir);
diff --git a/apps/desktop/src/main/maker-ipc/sessionTurnObserver.ts b/apps/desktop/src/main/maker-ipc/sessionTurnObserver.ts
index f0519388a3..8462036893 100644
--- a/apps/desktop/src/main/maker-ipc/sessionTurnObserver.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionTurnObserver.ts
@@ -7,6 +7,7 @@ import { describeModelRouteRejection } from '../maker-host/model-route-guard.js'
import { SilentStopTurnLeaseGate, SessionTurnLeaseTracker } from './sessionTurnLease.js';
export interface InstallSessionTurnObserverDeps {
+ readonly beforeLocalProviderStart?: (session: Session) => Promise<void>;
readonly silentStopTurnLeaseGate: Pick<
SilentStopTurnLeaseGate,
'supersede' | 'schedule' | 'supersedeOwnedBy'
@@ -23,6 +24,7 @@ export function installSessionTurnObserver(deps: InstallSessionTurnObserverDeps,
session.setTurnLifecycleObserver({
beforeProviderStart: async (turnGeneration) => {
if (session.remoteHostId) return;
+ await deps.beforeLocalProviderStart?.(session);
// 每条本地 Session.send 都经过这一个 Main-owned 边界,包括 renderer、IM、
// Goal、Learn、Hook 与 Scheduler。付费权限不能只挂在普通 IPC 发送事务上。
const model = session.model;
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 49348cf32c..175280dd82 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -3848,6 +3848,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
getCindyMakeState: (): Promise<import('../shared/cindyMakeDoctor').CindyMakeGlobalState> =>
ipcRenderer.invoke('app:get-cindy-make-state'),
+ manageCindyMakeTask: (sessionId: string, action: 'finish' | 'delete'): Promise<void> =>
+ ipcRenderer.invoke('app:manage-cindy-make-task', sessionId, action),
onCindyMakeState: (
listener: (state: import('../shared/cindyMakeDoctor').CindyMakeGlobalState) => void,
@@ -3877,11 +3879,15 @@ contextBridge.exposeInMainWorld('electronAPI', {
cancelCindyMakeSource: (): Promise<{ success: boolean }> =>
ipcRenderer.invoke('app:cancel-cindy-make-source'),
- // Create the per-task worktree (branch off the personal baseline + install deps).
+ // Compatibility entry point: prepare a worktree and its dependencies.
prepareCindyMakeWorkspace: (
runId: string,
): Promise<import('../shared/cindyMakeDoctor').MakeTaskWorkspace> =>
ipcRenderer.invoke('app:prepare-cindy-make-workspace', runId),
+ startCindyMakeTask: (input: import('../shared/cindyMakeDoctor').CindyMakeTaskStart): Promise<string> =>
+ ipcRenderer.invoke('app:start-cindy-make-task', input),
+ cancelCindyMakeTask: (runId: string): Promise<{ success: boolean }> =>
+ ipcRenderer.invoke('app:cancel-cindy-make-task', runId),
// ── 客户端日志上报(Settings → About)──
// 真相在 main:是否配置了上报目标、是否已同意隐私政策、开关的 override 状态都由 main
diff --git a/apps/desktop/src/renderer/__tests__/cindyMakeInlineEntry.test.ts b/apps/desktop/src/renderer/__tests__/cindyMakeInlineEntry.test.ts
index d7baa9d7ab..e917ed0343 100644
--- a/apps/desktop/src/renderer/__tests__/cindyMakeInlineEntry.test.ts
+++ b/apps/desktop/src/renderer/__tests__/cindyMakeInlineEntry.test.ts
@@ -3,23 +3,34 @@ import { resolve } from 'node:path';
import { describe, expect, it } from 'vitest';
const composer = readFileSync(resolve(__dirname, '../components/new-chat/ChatInput.tsx'), 'utf8');
+const sessionView = readFileSync(
+ resolve(__dirname, '../features/cc-agent/CCAgentSessionView.tsx'),
+ 'utf8',
+);
describe('Cindy Make composer presentation', () => {
- it('has no modal state or overlay for the preparation workflow', () => {
- expect(composer).not.toContain('CindyMakeCommandDialog');
- expect(composer).not.toContain('makeDialogSessionId');
+ it('opens preflight in place and only routes standalone diagnostics to their container', () => {
+ expect(composer).toContain('<CindyMakePreflightDialog');
+ expect(composer).toContain("makeResult.kind === 'preflight'");
+ expect(composer).toContain('setMakePreflight({');
+ expect(composer).toContain('else if (makeResult.sessionId !== sourceSessionId)');
});
- it('navigates only a newly created container and retains the existing task route', () => {
- const start = composer.indexOf("if (makeResult.kind === 'started')");
- expect(start).toBeGreaterThan(-1);
- const accepted = composer.slice(start, composer.indexOf('\n }', start));
- expect(accepted).toContain('clearComposerDraft(sourceStorageKey)');
- expect(accepted).toMatch(
- /if\s*\(makeResult\.sessionId !== sourceSessionId\)\s*\{\s*navigate\('\/cc-agent\/' \+ makeResult\.sessionId\);\s*\}/,
+ it('keeps question, plan and permission prompts ahead of the first-execution input lock', () => {
+ const promptHost = sessionView.indexOf('<InteractionPromptHost');
+ const mask = sessionView.indexOf('<CindyMakeComposerMask');
+ const input = sessionView.indexOf('<ChatInput', mask);
+ expect(promptHost).toBeGreaterThan(-1);
+ expect(mask).toBeGreaterThan(promptHost);
+ expect(input).toBeGreaterThan(mask);
+ const interactionGuard = sessionView.slice(
+ sessionView.indexOf('</InteractionPromptHost>'),
+ mask,
);
- expect(
- composer.indexOf("if (!isMakeSourceCurrent() || makeResult.kind === 'stale') return;"),
- ).toBeLessThan(start);
+ expect(interactionGuard).toMatch(
+ /pendingPlanReview ||[\s\S]*pendingPermission ||[\s\S]*pendingAskUser/,
+ );
+ expect(interactionGuard).toContain('pendingGhostGrantConfirm ? null');
+ expect(sessionView).toContain('if (cindyMakeComposerPhase) return false;');
});
});
diff --git a/apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx b/apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx
index 47b6a71a20..a7f6bc2bec 100644
--- a/apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx
+++ b/apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx
@@ -13,6 +13,10 @@ import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
import { Collapse } from '@/components/ui/collapse';
import { Spinner } from '@/components/ui/spinner';
+import { CindyMakeTaskCard } from '@/components/cindy-make/CindyMakeTaskCard';
+import { CindyMakeDependencyProgress } from '@/components/cindy-make/CindyMakeDependencyProgress';
+import { useCindyMakeState } from '@/lib/cindyMakeState';
+import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
import {
getDataOwnerGeneration,
isDataOwnerGenerationCurrent,
@@ -36,26 +40,101 @@ export function CindyMakeDoctorCard({
sessionId?: string;
onDismiss?: () => void;
}) {
- const report = data?.report as MakeDoctorReport | undefined;
+ const persistedReport = data?.report as MakeDoctorReport | undefined;
+ const makeState = useCindyMakeState();
+ const remote = Boolean(getStickySessionDeviceId(sessionId));
+ const liveReport =
+ !remote && persistedReport ? makeState.reports?.[persistedReport.runId] : undefined;
+ const report = liveReport ?? persistedReport;
const { t } = useTranslation();
const navigate = useNavigate();
const [startingCode, setStartingCode] = useState(false);
const activeSession = useRef(sessionId);
+ const openingTask = useRef(false);
useEffect(() => {
activeSession.current = sessionId;
return () => {
activeSession.current = undefined;
};
}, [sessionId]);
+ const openTask = async (targetSessionId: string) => {
+ const owner = getDataOwnerGeneration();
+ const current = () =>
+ activeSession.current === sessionId &&
+ isDataOwnerGenerationCurrent(owner) &&
+ !getStickySessionDeviceId(sessionId) &&
+ !getStickySessionDeviceId(targetSessionId);
+ if (openingTask.current || !current()) return;
+ openingTask.current = true;
+ try {
+ const [service, { sessionsStore }] = await Promise.all([
+ import('@/lib/sessionService'),
+ import('@/lib/sessionsStore'),
+ ]);
+ if (!current()) return;
+ let target = await service.get(targetSessionId);
+ if (!current()) return;
+ if (!target || target.status === 'deleted') throw new Error('unavailable');
+ if (target.status === 'archived') {
+ const restored = await service.restoreIfArchived(target.id, target);
+ if (!current()) return;
+ if (!restored) throw new Error('unavailable');
+ target = restored;
+ }
+ sessionsStore.prependCreated(target);
+ onDismiss?.();
+ navigate('/cc-agent/' + target.id);
+ } catch {
+ if (current()) toast.error(t('settings.cindyMake.tasks.errors.unavailable'));
+ } finally {
+ openingTask.current = false;
+ }
+ };
if (!report) return null;
+ if (report.task || (!remote && makeState.tasks?.[report.runId]?.task)) {
+ const live = !remote ? makeState.tasks?.[report.runId] : undefined;
+ const snapshot = live ?? report;
+ return (
+ <CindyMakeTaskCard
+ report={snapshot}
+ readOnly={remote}
+ request={typeof data?.request === 'string' ? data.request : undefined}
+ onOpenTask={
+ !remote && snapshot.task?.sessionId !== sessionId
+ ? () => void openTask(snapshot.task!.sessionId)
+ : undefined
+ }
+ />
+ );
+ }
const codeSessionId = typeof data?.codeSessionId === 'string' ? data.codeSessionId : undefined;
+ const compactPrepare = report.mode === 'prepare' && codeSessionId === sessionId;
+ const syncLiveReport = async () => {
+ if (!sessionId || !liveReport || getStickySessionDeviceId(sessionId)) return;
+ const owner = getDataOwnerGeneration();
+ const { makerChatStore } = await import('@/lib/makerChatStore');
+ if (!isDataOwnerGenerationCurrent(owner) || getStickySessionDeviceId(sessionId)) return;
+ const message = makerChatStore
+ .getSnapshot(sessionId)
+ .messages.find(
+ (row) =>
+ (row.systemCardType === 'cindy-make' || row.systemCardType === 'cindy-make-doctor') &&
+ (row.systemCardData?.report as MakeDoctorReport | undefined)?.runId === liveReport.runId,
+ );
+ if (message)
+ makerChatStore.updateSystemCardData(sessionId, message.clientId, { report: liveReport });
+ };
const start = (choice?: MakeUpstreamDecision) => {
- if (!sessionId || startingCode) return;
+ if (!sessionId || startingCode || getStickySessionDeviceId(sessionId)) return;
const owner = getDataOwnerGeneration();
setStartingCode(true);
void import('@/lib/cindyMakeDoctorStream')
- .then(({ chooseMakeUpstream, startMakeCodeSession }) => {
- if (!isDataOwnerGenerationCurrent(owner)) return null;
+ .then(async ({ chooseMakeUpstream, startMakeCodeSession }) => {
+ if (!isDataOwnerGenerationCurrent(owner) || getStickySessionDeviceId(sessionId))
+ return null;
+ await syncLiveReport();
+ if (!isDataOwnerGenerationCurrent(owner) || getStickySessionDeviceId(sessionId))
+ return null;
return choice
? chooseMakeUpstream(sessionId, report.runId, choice)
: startMakeCodeSession(sessionId, report.runId);
@@ -68,7 +147,9 @@ export function CindyMakeDoctorCard({
if (
createdId &&
activeSession.current === sessionId &&
- isDataOwnerGenerationCurrent(owner)
+ isDataOwnerGenerationCurrent(owner) &&
+ !getStickySessionDeviceId(sessionId) &&
+ !getStickySessionDeviceId(createdId)
) {
onDismiss?.();
navigate(`/cc-agent/${createdId}`);
@@ -82,15 +163,18 @@ export function CindyMakeDoctorCard({
});
};
const recheck = (request?: string) => {
- if (!sessionId) return;
+ if (!sessionId || getStickySessionDeviceId(sessionId)) return;
const owner = getDataOwnerGeneration();
void import('@/lib/cindyMakeDoctorStream')
- .then(({ startMakeDoctorInStream }) => {
- if (isDataOwnerGenerationCurrent(owner))
+ .then(async ({ startMakeDoctorInStream }) => {
+ if (isDataOwnerGenerationCurrent(owner) && !getStickySessionDeviceId(sessionId)) {
+ await syncLiveReport();
+ if (!isDataOwnerGenerationCurrent(owner) || getStickySessionDeviceId(sessionId)) return;
startMakeDoctorInStream(sessionId, {
retryRunId: report.runId,
...(request !== undefined ? { request } : {}),
});
+ }
})
.catch(() => {
if (isDataOwnerGenerationCurrent(owner)) toast.error(t('cindyMakeDoctor.failed'));
@@ -99,6 +183,7 @@ export function CindyMakeDoctorCard({
return (
<MakeDoctorReportCard
report={report}
+ readOnly={remote}
request={typeof data?.request === 'string' ? data.request : undefined}
decision={
data?.decision === 'wait' || data?.decision === 'personal' ? data.decision : undefined
@@ -106,22 +191,22 @@ export function CindyMakeDoctorCard({
onSearch={recheck}
onChoose={start}
onStartCode={sessionId ? () => start() : undefined}
- onOpenCode={
- codeSessionId
- ? () => {
- onDismiss?.();
- navigate(`/cc-agent/${codeSessionId}`);
- }
- : undefined
- }
+ onOpenCode={codeSessionId && !remote ? () => void openTask(codeSessionId) : undefined}
startingCode={startingCode}
- startingPhase={data?.codeStartPhase === 'workspace' ? 'workspace' : 'session'}
+ startingPhase={
+ data?.codeStartPhase === 'workspace'
+ ? 'workspace'
+ : data?.codeStartPhase === 'dependencies'
+ ? 'dependencies'
+ : 'session'
+ }
codeSessionError={data?.codeSessionError === true}
+ compactPrepare={compactPrepare}
onRecheck={() => recheck()}
onStop={() => {
- void cancelMakeDoctor(report.runId, report.mode).catch(() =>
- toast.error(t('cindyMakeDoctor.failed')),
- );
+ if (getStickySessionDeviceId(sessionId)) return;
+ const stop = cancelMakeDoctor(report.runId, report.mode);
+ void stop.catch(() => toast.error(t('cindyMakeDoctor.failed')));
}}
/>
);
@@ -163,6 +248,8 @@ export function MakeDoctorReportCard({
codeSessionError = false,
alwaysAllowRecheck = false,
showSource = true,
+ compactPrepare = false,
+ readOnly = false,
}: {
report: MakeDoctorReport;
request?: string;
@@ -179,10 +266,12 @@ export function MakeDoctorReportCard({
/** Settings shows the environment on its own; the numbered step row belongs to the workflow. */
showSteps?: boolean;
/** Creating the task worktree (branch + dependency install) precedes creating the task. */
- startingPhase?: 'workspace' | 'session';
+ startingPhase?: 'workspace' | 'dependencies' | 'session';
codeSessionError?: boolean;
alwaysAllowRecheck?: boolean;
showSource?: boolean;
+ compactPrepare?: boolean;
+ readOnly?: boolean;
}) {
const { t } = useTranslation();
const [expanded, setExpanded] = useState(true);
@@ -270,17 +359,19 @@ export function MakeDoctorReportCard({
: `cindyMakeDoctor.${status}`;
const currentStatusKey =
source?.status === 'ready' && decision === 'personal'
- ? startingCode
- ? startingPhase === 'workspace'
- ? 'cindyMake.code.preparingWorkspace'
- : 'cindyMake.code.starting'
- : codeSessionError
- ? onOpenCode
- ? 'cindyMake.code.sendFailed'
- : 'cindyMake.code.failed'
- : onOpenCode
- ? 'cindyMake.code.started'
- : sourceStatusKey
+ ? startingPhase === 'dependencies'
+ ? 'cindyMake.code.preparingDependencies'
+ : startingCode
+ ? startingPhase === 'workspace'
+ ? 'cindyMake.code.preparingWorkspace'
+ : 'cindyMake.code.starting'
+ : codeSessionError
+ ? onOpenCode
+ ? 'cindyMake.code.sendFailed'
+ : 'cindyMake.code.failed'
+ : onOpenCode
+ ? 'cindyMake.code.started'
+ : sourceStatusKey
: sourceStatusKey;
const currentStatusClass =
(codeSessionError && source?.status === 'ready') ||
@@ -297,6 +388,16 @@ export function MakeDoctorReportCard({
: source?.status === 'ready' || allPassed
? 'text-[var(--status-success)]'
: 'text-[var(--text-secondary)]';
+ if (compactPrepare) {
+ return (
+ <CompactMakePreparationCard
+ report={report}
+ onStop={onStop}
+ onRecheck={onRecheck}
+ readOnly={readOnly}
+ />
+ );
+ }
return (
<section
className="min-w-0 w-full rounded-[12px] border border-[var(--border-default)] bg-[var(--surface-elevated)] text-14 text-[var(--text-primary)]"
@@ -314,7 +415,7 @@ export function MakeDoctorReportCard({
{running && <Spinner size={14} />}
{expanded ? <ChevronDown size={16} /> : <ChevronRight size={16} />}
</button>
- {upstream && queryFinished && !running && !startingCode && (
+ {!readOnly && upstream && queryFinished && !running && !startingCode && (
<Button
variant="secondary"
size="md"
@@ -458,11 +559,17 @@ export function MakeDoctorReportCard({
{t(`cindyMake.source.${source.status}`)}
</p>
)}
- {source.status === 'preparing' && source.phase && !source.progress && (
- <p className="text-[var(--text-secondary)]">
- {t(`cindyMake.source.phase.${source.phase}`)}
- </p>
+ {source.status === 'preparing' && source.phase === 'caching' && (
+ <CindyMakeDependencyProgress progress={source.dependencies} running cacheOnly />
)}
+ {source.status === 'preparing' &&
+ source.phase &&
+ source.phase !== 'caching' &&
+ !source.progress && (
+ <p className="text-[var(--text-secondary)]">
+ {t(`cindyMake.source.phase.${source.phase}`)}
+ </p>
+ )}
{source.status === 'preparing' && source.progress && (
<div
className="space-y-1 text-12 text-[var(--text-secondary)]"
@@ -564,7 +671,8 @@ export function MakeDoctorReportCard({
</>
)}
</div>
- {!decision &&
+ {!readOnly &&
+ !decision &&
(!queryFinished || !upstream) &&
(!allPassed ||
running ||
@@ -597,22 +705,31 @@ export function MakeDoctorReportCard({
</Button>
</div>
)}
- {source?.status === 'ready' && decision === 'personal' && (onStartCode || onOpenCode) && (
- <Button variant="secondary" disabled={startingCode} onClick={onOpenCode ?? onStartCode}>
- {t(onOpenCode ? 'cindyMake.code.open' : 'cindyMake.code.start')}
- </Button>
- )}
- {(upstream?.status === 'found' || upstream?.status === 'notFound') &&
+ {!readOnly &&
+ source?.status === 'ready' &&
+ decision === 'personal' &&
+ (onStartCode || onOpenCode) && (
+ <Button variant="secondary" disabled={startingCode} onClick={onOpenCode ?? onStartCode}>
+ {t(onOpenCode ? 'cindyMake.code.open' : 'cindyMake.code.start')}
+ </Button>
+ )}
+ {!readOnly &&
+ (upstream?.status === 'found' || upstream?.status === 'notFound') &&
!decision &&
!searching && (
<div className="flex shrink-0 flex-wrap justify-end gap-2">
- <Button variant="secondary" disabled={!onChoose} onClick={() => onChoose?.('wait')}>
+ <Button
+ variant="secondary"
+ disabled={!onChoose || startingCode}
+ onClick={() => onChoose?.('wait')}
+ >
{t('cindyMake.upstream.wait')}
</Button>
<Button
variant="primary"
className="border-[var(--border-default)] enabled:hover:border-[var(--button-primary-hover)] enabled:active:border-[var(--button-primary-pressed)]"
- disabled={!onChoose}
+ disabled={!onChoose || startingCode}
+ loading={startingCode}
onClick={() => onChoose?.('personal')}
>
{t('cindyMake.upstream.personal')}
@@ -682,6 +799,72 @@ function MakeUpstreamResults({
);
}
+/** Compact handoff status shown inside the newly-created Cindy Make task. */
+function CompactMakePreparationCard({
+ report,
+ onStop,
+ onRecheck,
+ readOnly,
+}: {
+ report: MakeDoctorReport;
+ onStop: () => void;
+ onRecheck: () => void;
+ readOnly: boolean;
+}) {
+ const { t } = useTranslation();
+ const running = report.status === 'running';
+ const failed = report.status === 'failed';
+ const cancelled = report.status === 'cancelled';
+ const statusKey = running
+ ? 'cindyMake.code.preparingNpmDependencies'
+ : failed
+ ? 'cindyMake.prepare.failed'
+ : cancelled
+ ? 'cindyMake.prepare.cancelled'
+ : 'cindyMake.prepare.passed';
+ const source = report.source;
+ return (
+ <section
+ className="w-full rounded-[12px] border border-[var(--border-default)] bg-[var(--surface-elevated)] text-14 text-[var(--text-primary)]"
+ aria-label={t('cindyMake.code.taskName')}
+ >
+ <div className="flex items-center gap-2 px-4 py-3">
+ <Wrench size={16} className="shrink-0 text-[var(--text-secondary)]" aria-hidden />
+ <span className="font-medium">{t('cindyMake.code.taskName')}</span>
+ {running && <Spinner size={14} className="ml-auto" />}
+ </div>
+ <div className="space-y-2 border-t border-[var(--border-default)] px-4 py-3">
+ {source?.branch && (
+ <p className="text-13">{t('cindyMake.code.workspace', { branch: source.branch })}</p>
+ )}
+ {source?.path && (
+ <p className="break-all font-mono text-12 text-[var(--text-secondary)]">{source.path}</p>
+ )}
+ <p
+ className={`flex items-center gap-2 text-13 ${failed ? 'text-[var(--status-danger)]' : cancelled ? 'text-[var(--text-secondary)]' : 'text-[var(--text-primary)]'}`}
+ role="status"
+ >
+ {running ? <Spinner size={14} /> : failed ? <Minus size={14} /> : <Check size={14} />}
+ <span>{t(statusKey)}</span>
+ </p>
+ {failed && source?.error && (
+ <p className="text-12 text-[var(--status-danger)]">
+ {t(`cindyMake.source.errors.${source.error}`)}
+ </p>
+ )}
+ </div>
+ {!readOnly && (running || failed || cancelled) && (
+ <div className="flex justify-end gap-2 border-t border-[var(--border-default)] px-4 py-3">
+ <Button variant="secondary" onClick={running ? onStop : onRecheck}>
+ {t(running ? 'cindyMake.prepare.stop' : 'cindyMake.prepare.retry')}
+ </Button>
+ </div>
+ )}
+ </section>
+ );
+}
+
+/** Each result keeps its own disclosure state; titles remain visible for scanning. */
function MakeUpstreamResult({ item }: { item: MakeUpstreamItem }) {
const { t } = useTranslation();
const [expanded, setExpanded] = useState(false);
diff --git a/apps/desktop/src/renderer/components/chat/__tests__/CindyMakeDoctorCard.test.tsx b/apps/desktop/src/renderer/components/chat/__tests__/CindyMakeDoctorCard.test.tsx
index d79ed62d20..ed9fa72c56 100644
--- a/apps/desktop/src/renderer/components/chat/__tests__/CindyMakeDoctorCard.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/__tests__/CindyMakeDoctorCard.test.tsx
@@ -1,8 +1,15 @@
// @vitest-environment jsdom
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { ReactElement } from 'react';
import { MemoryRouter, useLocation } from 'react-router-dom';
-import { cleanup, fireEvent, render as renderUI, screen, waitFor } from '@testing-library/react';
+import {
+ act,
+ cleanup,
+ fireEvent,
+ render as renderUI,
+ screen,
+ waitFor,
+} from '@testing-library/react';
import { CindyMakeDoctorCard, MakeDoctorReportCard } from '../CindyMakeDoctorCard';
import { SystemCard } from '../SystemCard';
import {
@@ -11,7 +18,23 @@ import {
startMakeDoctorInStream,
} from '@/lib/cindyMakeDoctorStream';
import { cancelMakeDoctor } from '@/lib/cindyMakeDoctor';
+import { useCindyMakeState } from '@/lib/cindyMakeState';
+import { makerChatStore } from '@/lib/makerChatStore';
+import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
import { MAKE_DOCTOR_CHECK_IDS, type MakeDoctorReport } from '../../../../shared/cindyMakeDoctor';
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+const opening = vi.hoisted(() => ({
+ get: vi.fn(),
+ restore: vi.fn(),
+ prepend: vi.fn(),
+ error: vi.fn(),
+}));
+vi.mock('@/lib/sessionService', () => ({
+ get: opening.get,
+ restoreIfArchived: opening.restore,
+}));
+vi.mock('@/lib/sessionsStore', () => ({ sessionsStore: { prependCreated: opening.prepend } }));
+vi.mock('@/lib/toast', () => ({ toast: { error: opening.error } }));
vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
vi.mock('@/lib/cindyMakeDoctorStream', () => ({
startMakeDoctorInStream: vi.fn(),
@@ -19,6 +42,16 @@ vi.mock('@/lib/cindyMakeDoctorStream', () => ({
startMakeCodeSession: vi.fn(),
}));
vi.mock('@/lib/cindyMakeDoctor', () => ({ cancelMakeDoctor: vi.fn(async () => {}) }));
+vi.mock('@/lib/cindyMakeState', () => ({ useCindyMakeState: vi.fn(() => ({})) }));
+vi.mock('@/lib/makerChatStore', () => ({
+ makerChatStore: {
+ getSnapshot: vi.fn(() => ({ messages: [] })),
+ updateSystemCardData: vi.fn(),
+ },
+}));
+vi.mock('@/features/device-link/stickySessionOrigin', () => ({
+ getStickySessionDeviceId: vi.fn(),
+}));
vi.mock('@/features/bots/useRemoteBots', () => ({ useRemoteBots: () => [] }));
// Partner task cards have their own integration suite; isolate this sibling variant.
vi.mock('@/features/bots/BotCollaborationCard', () => ({
@@ -34,8 +67,17 @@ function Location() {
return <span data-testid="location">{useLocation().pathname}</span>;
}
+beforeEach(() => {
+ setDataOwnerGeneration('doctor-card-test');
+ opening.get.mockReset();
+ opening.restore.mockReset();
+});
+
afterEach(() => {
cleanup();
+ vi.restoreAllMocks();
+ vi.mocked(useCindyMakeState).mockReturnValue({});
+ vi.mocked(getStickySessionDeviceId).mockReset();
vi.clearAllMocks();
vi.unstubAllGlobals();
});
@@ -498,6 +540,31 @@ describe('Make upstream step', () => {
expect(screen.queryByText('a'.repeat(40))).toBeNull();
expect(screen.queryByText('d'.repeat(12))).toBeNull();
});
+ it('shows cache warming and counters in preflight without claiming to install dependencies', () => {
+ render(
+ <MakeDoctorReportCard
+ onStop={vi.fn()}
+ onRecheck={vi.fn()}
+ report={{
+ ...found,
+ status: 'running',
+ source: {
+ status: 'preparing',
+ phase: 'caching',
+ path: 'managed-source',
+ dependencies: { resolved: 21, reused: 12, downloaded: 9, added: 0 },
+ },
+ }}
+ />,
+ );
+ expect(screen.getByText('cindyMake.source.phase.caching')).toBeTruthy();
+ expect(screen.getByText('cindyMake.source.cacheProgress')).toBeTruthy();
+ expect(screen.queryByText('cindyMake.code.dependencyActivity.packages')).toBeNull();
+ expect(
+ screen.getByRole('button', { name: 'cindyMake.upstream.personal' }).hasAttribute('disabled'),
+ ).toBe(true);
+ });
+
it('uses a spinner instead of a transient progress bar while preparing source', () => {
render(
<MakeDoctorReportCard
@@ -584,7 +651,193 @@ const report: MakeDoctorReport = {
checks: [{ id: 'git', status: 'passed', version: '2.55.0' }],
};
+describe('Main-owned report recovery', () => {
+ const persisted: MakeDoctorReport = {
+ ...report,
+ mode: 'prepare',
+ status: 'running',
+ upstream: { status: 'pending', items: [] },
+ source: { status: 'preparing', phase: 'cloning', path: '/source' },
+ };
+ const completed: MakeDoctorReport = {
+ ...persisted,
+ status: 'completed',
+ checks: MAKE_DOCTOR_CHECK_IDS.map((id) => ({ id, status: 'passed' })),
+ source: { status: 'ready', path: '/source' },
+ upstream: { status: 'notFound', items: [] },
+ };
+ it('uses the complete Main workflow after reload instead of the old running message', () => {
+ vi.mocked(useCindyMakeState).mockReturnValue({ reports: { [report.runId]: completed } });
+ render(
+ <CindyMakeDoctorCard
+ sessionId="origin"
+ data={{ report: persisted, request: 'original request' }}
+ />,
+ );
+ expect(screen.getByRole('button', { name: 'cindyMake.upstream.personal' })).toBeTruthy();
+ expect(screen.getByText('cindyMake.upstream.notFoundHint')).toBeTruthy();
+ expect(screen.queryByText('cindyMake.source.phase.cloning')).toBeNull();
+ expect(screen.queryByRole('button', { name: 'cindyMake.prepare.stop' })).toBeNull();
+ });
+ it('projects updated source and cancellation reports without writing a guessed message state', () => {
+ const update = vi.spyOn(makerChatStore, 'updateSystemCardData').mockImplementation(() => {});
+ vi.mocked(useCindyMakeState).mockReturnValue({
+ reports: {
+ [report.runId]: {
+ ...persisted,
+ source: { status: 'preparing', phase: 'installing', path: '/source' },
+ },
+ },
+ });
+ const view = render(<CindyMakeDoctorCard sessionId="origin" data={{ report: persisted }} />);
+ expect(screen.getByText('cindyMake.source.phase.installing')).toBeTruthy();
+ vi.mocked(useCindyMakeState).mockReturnValue({
+ reports: {
+ [report.runId]: {
+ ...persisted,
+ status: 'cancelled',
+ source: { status: 'cancelled', path: '/source' },
+ },
+ },
+ });
+ view.rerender(<CindyMakeDoctorCard sessionId="origin" data={{ report: persisted }} />);
+ expect(screen.getByRole('status').textContent).toBe('cindyMake.source.cancelled');
+ expect(screen.getByRole('button', { name: 'cindyMake.prepare.retry' })).toBeTruthy();
+ expect(update).not.toHaveBeenCalled();
+ });
+ it('falls back to the saved report when Main has no matching run', () => {
+ vi.mocked(useCindyMakeState).mockReturnValue({ reports: { other: completed } });
+ render(<CindyMakeDoctorCard sessionId="origin" data={{ report: persisted }} />);
+ expect(screen.getByText('cindyMake.source.phase.cloning')).toBeTruthy();
+ expect(screen.queryByRole('button', { name: 'cindyMake.upstream.personal' })).toBeNull();
+ });
+ it.each(['choose', 'retry'] as const)(
+ 'syncs only the authoritative report before the legacy %s action checks its cached message',
+ async (action) => {
+ const authoritative: MakeDoctorReport =
+ action === 'choose'
+ ? completed
+ : {
+ ...persisted,
+ status: 'cancelled',
+ source: { status: 'cancelled', path: '/source' },
+ };
+ vi.mocked(useCindyMakeState).mockReturnValue({ reports: { [report.runId]: authoritative } });
+ const request = 'original request\n keep whitespace';
+ const snapshot = {
+ ...makerChatStore.getSnapshot('origin'),
+ messages: [
+ {
+ clientId: 'original-card',
+ role: 'assistant' as const,
+ content: '',
+ systemCardType: 'cindy-make' as const,
+ systemCardData: { report: persisted, request },
+ },
+ ],
+ };
+ vi.spyOn(makerChatStore, 'getSnapshot').mockReturnValue(snapshot);
+ const update = vi.spyOn(makerChatStore, 'updateSystemCardData').mockImplementation(() => {});
+ render(<CindyMakeDoctorCard sessionId="origin" data={{ report: persisted, request }} />);
+ fireEvent.click(
+ screen.getByRole('button', {
+ name: action === 'choose' ? 'cindyMake.upstream.personal' : 'cindyMake.prepare.retry',
+ }),
+ );
+ await waitFor(() =>
+ expect(update).toHaveBeenCalledWith('origin', 'original-card', { report: authoritative }),
+ );
+ const command = action === 'choose' ? chooseMakeUpstream : startMakeDoctorInStream;
+ await waitFor(() => expect(command).toHaveBeenCalledOnce());
+ expect(update.mock.invocationCallOrder[0]).toBeLessThan(
+ vi.mocked(command).mock.invocationCallOrder[0],
+ );
+ expect(snapshot.messages[0].systemCardData.request).toBe(request);
+ },
+ );
+ it('does not replace a remote task report with a matching local run or expose local controls', () => {
+ vi.mocked(getStickySessionDeviceId).mockReturnValue('remote-device');
+ const remoteReport: MakeDoctorReport = {
+ ...persisted,
+ task: { sessionId: 'remote-task', originSessionId: 'remote-origin', phase: 'dependencies' },
+ };
+ vi.mocked(useCindyMakeState).mockReturnValue({
+ reports: { [report.runId]: completed },
+ tasks: {
+ [report.runId]: {
+ ...remoteReport,
+ status: 'completed',
+ task: { ...remoteReport.task!, phase: 'completed' },
+ },
+ },
+ });
+ render(
+ <>
+ <CindyMakeDoctorCard
+ sessionId="remote-origin"
+ data={{ report: remoteReport, request: 'request' }}
+ />
+ <Location />
+ </>,
+ );
+ expect(screen.getByRole('status').textContent).toBe('cindyMake.code.phases.dependencies');
+ expect(screen.queryByRole('button')).toBeNull();
+ expect(screen.getByTestId('location').textContent).toBe('/');
+ });
+ it('keeps remote legacy cards read-only and ignores local workflow reports', () => {
+ vi.mocked(getStickySessionDeviceId).mockReturnValue('remote-device');
+ vi.mocked(useCindyMakeState).mockReturnValue({ reports: { [report.runId]: completed } });
+ const view = render(
+ <CindyMakeDoctorCard sessionId="remote-origin" data={{ report: persisted }} />,
+ );
+ expect(screen.getByText('cindyMake.source.phase.cloning')).toBeTruthy();
+ expect(screen.queryByRole('button', { name: 'cindyMake.prepare.stop' })).toBeNull();
+ view.rerender(
+ <CindyMakeDoctorCard
+ sessionId="remote-origin"
+ data={{ report: completed, decision: 'personal', codeSessionId: 'remote-task' }}
+ />,
+ );
+ expect(screen.queryByRole('button', { name: 'cindyMake.upstream.retry' })).toBeNull();
+ expect(screen.queryByRole('button', { name: 'cindyMake.code.open' })).toBeNull();
+ expect(startMakeCodeSession).not.toHaveBeenCalled();
+ expect(cancelMakeDoctor).not.toHaveBeenCalled();
+ });
+});
+
describe('doctor card interactions', () => {
+ it('uses a compact worktree and dependency card inside the created task', () => {
+ render(
+ <CindyMakeDoctorCard
+ sessionId="task-session"
+ data={{
+ request: '修复消息流闪烁',
+ codeSessionId: 'task-session',
+ report: {
+ ...report,
+ mode: 'prepare',
+ status: 'running',
+ checks: [],
+ source: {
+ status: 'ready',
+ branch: 'cindy-make/task-run',
+ path: 'C:/Cindy/worktrees/task-run',
+ },
+ },
+ }}
+ />,
+ );
+ expect(screen.getByText('cindyMake.code.taskName')).toBeTruthy();
+ expect(screen.getByText('cindyMake.code.workspace')).toBeTruthy();
+ expect(screen.getByText('C:/Cindy/worktrees/task-run')).toBeTruthy();
+ expect(screen.getByText('cindyMake.code.preparingNpmDependencies')).toBeTruthy();
+ expect(screen.queryByText('修复消息流闪烁')).toBeNull();
+ expect(screen.queryByText('cindyMakeDoctor.scope')).toBeNull();
+ expect(screen.queryByText('cindyMake.stepEnvironment')).toBeNull();
+ expect(screen.queryByText('cindyMake.stepSource')).toBeNull();
+ expect(screen.queryByText('cindyMake.stepUpstream')).toBeNull();
+ });
+
it('shows download progress and retries preparation after a checksum failure in the same card', () => {
const retry = vi.fn();
const view = render(
@@ -753,7 +1006,8 @@ describe('doctor card interactions', () => {
expect(chooseMakeUpstream).toHaveBeenCalledWith('origin-task', report.runId, 'personal');
});
- it('opens the persisted task without creating or sending again, including after a failed send', () => {
+ it('opens the persisted task without creating or sending again, including after a failed send', async () => {
+ opening.get.mockResolvedValue({ id: 'existing-task', status: 'active' });
render(
<>
<Location />
@@ -771,7 +1025,130 @@ describe('doctor card interactions', () => {
);
expect(screen.getByRole('status').textContent).toBe('cindyMake.code.sendFailed');
fireEvent.click(screen.getByRole('button', { name: 'cindyMake.code.open' }));
- expect(screen.getByTestId('location').textContent).toBe('/cc-agent/existing-task');
+ await waitFor(() =>
+ expect(screen.getByTestId('location').textContent).toBe('/cc-agent/existing-task'),
+ );
expect(startMakeCodeSession).not.toHaveBeenCalled();
+ expect(opening.restore).not.toHaveBeenCalled();
+ });
+});
+
+describe.each(['task', 'legacy'] as const)('opening a %s preparation card', (kind) => {
+ const archived = {
+ id: 'existing-task',
+ status: 'archived',
+ workingDir: '/make/run',
+ workspaceKind: 'project',
+ remoteHostId: null,
+ };
+ const renderLink = (onDismiss = vi.fn()) => {
+ const saved: MakeDoctorReport = {
+ ...report,
+ status: kind === 'task' ? 'cancelled' : 'completed',
+ source: { status: 'ready', path: '/make/run' },
+ ...(kind === 'task'
+ ? { task: { sessionId: archived.id, phase: 'dependencies' as const } }
+ : {}),
+ };
+ return render(
+ <>
+ <Location />
+ <CindyMakeDoctorCard
+ sessionId="origin-task"
+ onDismiss={onDismiss}
+ data={{ report: saved, decision: 'personal', codeSessionId: archived.id }}
+ />
+ </>,
+ );
+ };
+ const clickOpen = () =>
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.code.open' }));
+
+ it('restores the archived task before dismissing and navigating, without dispatching again', async () => {
+ opening.get.mockResolvedValue(archived);
+ let finishRestore!: (value: unknown) => void;
+ opening.restore.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finishRestore = resolve;
+ }),
+ );
+ const dismiss = vi.fn();
+ renderLink(dismiss);
+ clickOpen();
+ clickOpen();
+ await waitFor(() => expect(opening.restore).toHaveBeenCalledWith(archived.id, archived));
+ expect(opening.restore).toHaveBeenCalledOnce();
+ expect(dismiss).not.toHaveBeenCalled();
+ expect(opening.prepend).not.toHaveBeenCalled();
+ expect(screen.getByTestId('location').textContent).toBe('/');
+ const restored = { ...archived, status: 'active' };
+ await act(async () => finishRestore(restored));
+ expect(opening.prepend).toHaveBeenCalledWith(restored);
+ expect(dismiss).toHaveBeenCalledOnce();
+ expect(screen.getByTestId('location').textContent).toBe('/cc-agent/' + archived.id);
+ expect(startMakeCodeSession).not.toHaveBeenCalled();
+ expect(chooseMakeUpstream).not.toHaveBeenCalled();
+ });
+
+ it.each(['deleted', 'changed'] as const)('does not open a %s task', async (state) => {
+ opening.get.mockResolvedValue(
+ state === 'deleted' ? { ...archived, status: 'deleted' } : archived,
+ );
+ opening.restore.mockResolvedValue(null);
+ const dismiss = vi.fn();
+ renderLink(dismiss);
+ clickOpen();
+ await waitFor(() =>
+ expect(opening.error).toHaveBeenCalledWith('settings.cindyMake.tasks.errors.unavailable'),
+ );
+ expect(screen.getByTestId('location').textContent).toBe('/');
+ expect(opening.prepend).not.toHaveBeenCalled();
+ expect(dismiss).not.toHaveBeenCalled();
+ if (state === 'deleted') expect(opening.restore).not.toHaveBeenCalled();
+ });
+
+ it.each(['owner', 'remote'] as const)(
+ 'does not restore after the %s changes during lookup',
+ async (change) => {
+ let finishGet!: (value: unknown) => void;
+ opening.get.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finishGet = resolve;
+ }),
+ );
+ renderLink();
+ clickOpen();
+ await waitFor(() => expect(opening.get).toHaveBeenCalledOnce());
+ if (change === 'owner') setDataOwnerGeneration('another-owner');
+ else
+ vi.mocked(getStickySessionDeviceId).mockImplementation((id) =>
+ id === archived.id ? 'remote-device' : undefined,
+ );
+ await act(async () => finishGet(archived));
+ expect(opening.restore).not.toHaveBeenCalled();
+ expect(opening.prepend).not.toHaveBeenCalled();
+ expect(screen.getByTestId('location').textContent).toBe('/');
+ },
+ );
+
+ it('does not navigate after the originating card has unmounted', async () => {
+ let finishGet!: (value: unknown) => void;
+ opening.get.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finishGet = resolve;
+ }),
+ );
+ const dismiss = vi.fn();
+ const view = renderLink(dismiss);
+ clickOpen();
+ await waitFor(() => expect(opening.get).toHaveBeenCalledOnce());
+ view.unmount();
+ await act(async () => finishGet(archived));
+ expect(opening.restore).not.toHaveBeenCalled();
+ expect(opening.prepend).not.toHaveBeenCalled();
+ expect(dismiss).not.toHaveBeenCalled();
});
});
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakeComposerMask.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakeComposerMask.tsx
new file mode 100644
index 0000000000..3a54ee4deb
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakeComposerMask.tsx
@@ -0,0 +1,51 @@
+import { LockKeyhole } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { Button } from '@/components/ui/button';
+import { Spinner } from '@/components/ui/spinner';
+import type { CindyMakeComposerPhase } from '@/lib/cindyMakeComposer';
+
+/** Same footprint as TakeoverMask; interaction prompts are rendered ahead of this mask. */
+export function CindyMakeComposerMask({
+ phase,
+ onStop,
+}: {
+ phase: CindyMakeComposerPhase;
+ onStop?: () => void;
+}) {
+ const { t } = useTranslation();
+ const stopped = phase === 'failed' || phase === 'cancelled';
+ const heading =
+ phase === 'executing'
+ ? 'cindyMake.code.inputLocked.executing'
+ : phase === 'failed'
+ ? 'cindyMake.code.preparationFailed'
+ : phase === 'cancelled'
+ ? 'cindyMake.prepare.cancelled'
+ : 'cindyMake.code.phases.' + phase;
+ return (
+ <div
+ role="status"
+ aria-live="polite"
+ className="flex min-h-[90px] w-full items-center justify-between gap-3 rounded-xl border border-[hsl(var(--sidebar-border))] bg-[hsl(var(--content-area))] px-4 py-3"
+ >
+ <div className="flex min-w-0 items-center gap-3">
+ <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-[hsl(var(--sidebar-item-hover))] text-[var(--workingdir-icon)]">
+ {stopped ? <LockKeyhole size={16} aria-hidden /> : <Spinner size={16} />}
+ </div>
+ <div className="flex min-w-0 flex-col gap-1">
+ <p className="text-14 font-medium leading-tight text-[var(--msg-assistant-text)]">
+ {t(heading)}
+ </p>
+ <p className="text-12 leading-snug text-[var(--workingdir-text)]">
+ {t(stopped ? 'cindyMake.code.inputLocked.retry' : 'cindyMake.code.inputLocked.hint')}
+ </p>
+ </div>
+ </div>
+ {phase === 'executing' && onStop && (
+ <Button variant="primary" onClick={onStop}>
+ {t('cindyMake.prepare.stop')}
+ </Button>
+ )}
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakeCreateDialog.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakeCreateDialog.tsx
index 30b725defe..b828c3c1fa 100644
--- a/apps/desktop/src/renderer/components/cindy-make/CindyMakeCreateDialog.tsx
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakeCreateDialog.tsx
@@ -1,7 +1,6 @@
import { useEffect, useRef, useState } from 'react';
import * as Dialog from '@radix-ui/react-dialog';
import { useTranslation } from 'react-i18next';
-import { useNavigate } from 'react-router-dom';
import { Button } from '@/components/ui/button';
import { FormField } from '@/components/ui/form-field';
@@ -11,19 +10,21 @@ import {
isDataOwnerGenerationCurrent,
} from '@/contexts/dataOwnerGeneration';
import { isSelectableVendor } from '@/lib/agentVendors';
+import { CindyMakePreflightDialog, type CindyMakePreflightProps } from './CindyMakePreflightDialog';
const MAX_REQUEST_LENGTH = 4000;
export function CindyMakeCreateDialog({ onOpenChange }: { onOpenChange: (open: boolean) => void }) {
const { t } = useTranslation();
- const navigate = useNavigate();
+ const [preflight, setPreflight] = useState<Omit<CindyMakePreflightProps, 'onOpenChange'> | null>(
+ null,
+ );
const [request, setRequest] = useState('');
const [starting, setStarting] = useState(false);
const [failed, setFailed] = useState(false);
const submitting = useRef(false);
const mounted = useRef(true);
const owner = useRef(getDataOwnerGeneration());
- const sessionId = useRef<string | undefined>(undefined);
const returnFocusRef = useRef(
document.activeElement instanceof HTMLElement ? document.activeElement : null,
);
@@ -47,19 +48,15 @@ export function CindyMakeCreateDialog({ onOpenChange }: { onOpenChange: (open: b
setStarting(true);
setFailed(false);
try {
- const [{ ensureMakeTask, startMakeDoctorInStream }, draftState] = await Promise.all([
- import('@/lib/cindyMakeDoctorStream'),
- import('@/state/newMakerDraft'),
- ]);
+ const draftState = await import('@/state/newMakerDraft');
if (!isCurrent()) return;
const draft = draftState.getDraft();
const vendor = isSelectableVendor(draft.vendor) ? draft.vendor : 'cc';
const prefs = draft.lastByVendor[vendor];
- const createdId = await ensureMakeTask({
- sessionId: sessionId.current,
- title: t('settings.cindyMake.create.title'),
+ if (!mounted.current) return;
+ setPreflight({
+ request,
createOptions: {
- workspaceKind: 'dialogue',
agentKind: vendor,
model: prefs.model,
effort: prefs.effort,
@@ -68,17 +65,7 @@ export function CindyMakeCreateDialog({ onOpenChange }: { onOpenChange: (open: b
fastMode: draftState.getFastModeForModel(prefs.model),
planModeEnabled: prefs.planMode,
},
- isCurrent,
});
- if (!isCurrent()) return;
- if (!createdId) throw new Error('Cindy Make task was not created');
- sessionId.current = createdId;
- const runId = startMakeDoctorInStream(createdId, { command: 'cindy-make', request });
- if (!runId) throw new Error('Cindy Make workflow was not started');
- if (mounted.current) {
- onOpenChange(false);
- navigate('/cc-agent/' + createdId);
- }
} catch {
if (mounted.current && isCurrent()) setFailed(true);
} finally {
@@ -90,6 +77,8 @@ export function CindyMakeCreateDialog({ onOpenChange }: { onOpenChange: (open: b
}
};
+ if (preflight) return <CindyMakePreflightDialog {...preflight} onOpenChange={onOpenChange} />;
+
return (
<Dialog.Root open onOpenChange={(open) => !submitting.current && onOpenChange(open)}>
<Dialog.Portal>
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakeDependencyProgress.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakeDependencyProgress.tsx
new file mode 100644
index 0000000000..07f037f148
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakeDependencyProgress.tsx
@@ -0,0 +1,39 @@
+import { useTranslation } from 'react-i18next';
+import { Spinner } from '@/components/ui/spinner';
+import type { MakeDependencyProgress } from '../../../shared/cindyMakeDoctor';
+
+export function CindyMakeDependencyProgress({
+ progress,
+ running,
+ cacheOnly = false,
+}: {
+ progress?: MakeDependencyProgress;
+ running: boolean;
+ cacheOnly?: boolean;
+}) {
+ const { t } = useTranslation();
+ return (
+ <div className="space-y-1 text-12 text-[var(--text-secondary)]" aria-live="polite">
+ {running && (
+ <div className="flex items-center gap-2">
+ <Spinner size={14} />
+ <span>
+ {t(
+ cacheOnly
+ ? 'cindyMake.source.phase.caching'
+ : 'cindyMake.code.dependencyActivity.' +
+ (progress?.activity ?? (progress ? 'packages' : 'starting')),
+ )}
+ </span>
+ </div>
+ )}
+ {progress?.resolved !== undefined && (
+ <p>
+ {t(cacheOnly ? 'cindyMake.source.cacheProgress' : 'cindyMake.code.dependencyProgress', {
+ ...progress,
+ })}
+ </p>
+ )}
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakePreflightDialog.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakePreflightDialog.tsx
new file mode 100644
index 0000000000..10625786a0
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakePreflightDialog.tsx
@@ -0,0 +1,193 @@
+import { useEffect, useRef, useState } from 'react';
+import * as Dialog from '@radix-ui/react-dialog';
+import { useTranslation } from 'react-i18next';
+import { useNavigate } from 'react-router-dom';
+import { Button } from '@/components/ui/button';
+import { MakeDoctorReportCard } from '@/components/chat/CindyMakeDoctorCard';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+} from '@/contexts/dataOwnerGeneration';
+import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
+import { startMakeDoctor, cancelMakeDoctor } from '@/lib/cindyMakeDoctor';
+import { toast } from '@/lib/toast';
+import type { CindyMakeTaskOptions, MakeDoctorReport } from '../../../shared/cindyMakeDoctor';
+
+export interface CindyMakePreflightProps {
+ request: string;
+ sessionId?: string;
+ createOptions?: CindyMakeTaskOptions;
+ onOpenChange: (open: boolean) => void;
+}
+
+/** Checks belong to this dialog; only Continue creates a persistent task. */
+export function CindyMakePreflightDialog({
+ request,
+ sessionId,
+ createOptions,
+ onOpenChange,
+}: CindyMakePreflightProps) {
+ const { t } = useTranslation();
+ const navigate = useNavigate();
+ const [report, setReport] = useState<MakeDoctorReport>();
+ const [attempt, setAttempt] = useState(0);
+ const [starting, setStarting] = useState(false);
+ const [failed, setFailed] = useState(false);
+ const submitting = useRef(false);
+ const contentRef = useRef<HTMLDivElement>(null);
+ const mounted = useRef(false);
+ const owner = useRef(getDataOwnerGeneration());
+ const returnFocus = useRef(
+ document.activeElement instanceof HTMLElement ? document.activeElement : null,
+ );
+ const current = () =>
+ mounted.current &&
+ isDataOwnerGenerationCurrent(owner.current) &&
+ !getStickySessionDeviceId(sessionId);
+
+ useEffect(() => {
+ mounted.current = true;
+ const controller = new AbortController();
+ let latest: MakeDoctorReport | undefined;
+ // StrictMode rehearses effect cleanup before the real mount. Do not dispatch
+ // a run from that discarded effect and immediately cancel the shared checks.
+ queueMicrotask(() => {
+ if (
+ controller.signal.aborted ||
+ !isDataOwnerGenerationCurrent(owner.current) ||
+ getStickySessionDeviceId(sessionId)
+ )
+ return;
+ startMakeDoctor(
+ (next) => {
+ latest = next;
+ setReport(next);
+ },
+ undefined,
+ 'cindy-make',
+ { request, signal: controller.signal },
+ );
+ });
+ return () => {
+ mounted.current = false;
+ controller.abort();
+ if (latest?.status === 'running' && isDataOwnerGenerationCurrent(owner.current))
+ void cancelMakeDoctor(latest.runId, latest.mode).catch(() => {});
+ };
+ }, [request, sessionId, attempt]);
+
+ const start = async () => {
+ if (
+ !current() ||
+ submitting.current ||
+ report?.status !== 'completed' ||
+ !['found', 'notFound'].includes(report.upstream?.status ?? '')
+ )
+ return;
+ submitting.current = true;
+ setStarting(true);
+ setFailed(false);
+ try {
+ const chars = Array.from(request.replace(/\s+/gu, ' ').trim());
+ const createdId = await window.electronAPI.startCindyMakeTask({
+ originSessionId: sessionId,
+ runId: report.runId,
+ request,
+ title: t('cindyMake.code.taskTitle', {
+ request: chars.slice(0, 60).join('') + (chars.length > 60 ? '…' : ''),
+ }),
+ createOptions,
+ });
+ if (!isDataOwnerGenerationCurrent(owner.current)) return;
+ const [{ makerChatStore }, sessionService, { sessionsStore }] = await Promise.all([
+ import('@/lib/makerChatStore'),
+ import('@/lib/sessionService'),
+ import('@/lib/sessionsStore'),
+ ]);
+ if (!isDataOwnerGenerationCurrent(owner.current)) return;
+ makerChatStore.setSessionRuntime(createdId, { autoTitleDisabled: true });
+ const session = await sessionService.get(createdId).catch(() => null);
+ if (!isDataOwnerGenerationCurrent(owner.current)) return;
+ if (session) sessionsStore.prependCreated(session);
+ if (current()) {
+ onOpenChange(false);
+ navigate('/cc-agent/' + createdId);
+ }
+ } catch {
+ if (current()) setFailed(true);
+ } finally {
+ submitting.current = false;
+ if (mounted.current) setStarting(false);
+ }
+ };
+
+ return (
+ <Dialog.Root open onOpenChange={(open) => !submitting.current && onOpenChange(open)}>
+ <Dialog.Portal>
+ <Dialog.Overlay className="fixed inset-0 z-[10000] bg-[var(--overlay-modal)]" />
+ <Dialog.Content
+ ref={contentRef}
+ tabIndex={-1}
+ className="fixed left-1/2 top-1/2 z-[10001] flex max-h-[85vh] w-[min(600px,calc(100vw-32px))] -translate-x-1/2 -translate-y-1/2 flex-col gap-4 overflow-y-auto rounded-xl bg-[var(--confirm-bg)] p-4 shadow-[var(--confirm-shadow)] outline-none"
+ onOpenAutoFocus={(event) => {
+ // The report and Continue action arrive asynchronously. Start at the
+ // readable content instead of making Cancel the initial action.
+ event.preventDefault();
+ contentRef.current?.focus({ preventScroll: true });
+ }}
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ returnFocus.current?.isConnected && returnFocus.current.focus();
+ }}
+ onEscapeKeyDown={(event) => {
+ if (submitting.current || event.isComposing || event.keyCode === 229)
+ event.preventDefault();
+ }}
+ >
+ <Dialog.Title className="text-16 font-medium text-[var(--confirm-title)]">
+ {t('cindyMake.title')}
+ </Dialog.Title>
+ <Dialog.Description className="whitespace-pre-wrap break-words text-13 text-[var(--confirm-desc)]">
+ {request}
+ </Dialog.Description>
+ {report && (
+ <MakeDoctorReportCard
+ report={report}
+ request={request}
+ startingCode={starting}
+ onChoose={(choice) => {
+ if (submitting.current) return;
+ if (choice === 'wait') onOpenChange(false);
+ else void start();
+ }}
+ onRecheck={() => {
+ if (!submitting.current && current()) {
+ setFailed(false);
+ setAttempt((value) => value + 1);
+ }
+ }}
+ onStop={() => {
+ if (current())
+ void cancelMakeDoctor(report.runId, report.mode).catch(() =>
+ toast.error(t('cindyMakeDoctor.failed')),
+ );
+ }}
+ />
+ )}
+ {failed && (
+ <p role="alert" className="text-13 text-[var(--error-fg)]">
+ {t('cindyMake.code.preparationFailed')}
+ </p>
+ )}
+ <div className="flex justify-end">
+ <Dialog.Close asChild>
+ <Button variant="secondary" disabled={starting}>
+ {t('settings.cindyMake.create.cancel')}
+ </Button>
+ </Dialog.Close>
+ </div>
+ </Dialog.Content>
+ </Dialog.Portal>
+ </Dialog.Root>
+ );
+}
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakeTaskCard.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakeTaskCard.tsx
new file mode 100644
index 0000000000..83475c7984
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakeTaskCard.tsx
@@ -0,0 +1,168 @@
+import { useState } from 'react';
+import { Check, Minus } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { Button } from '@/components/ui/button';
+import { Spinner } from '@/components/ui/spinner';
+import { CindyMakeDependencyProgress } from './CindyMakeDependencyProgress';
+import { toast } from '@/lib/toast';
+import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
+import type { MakeDoctorReport } from '../../../shared/cindyMakeDoctor';
+
+const phases = ['environment', 'source', 'workspace', 'dependencies', 'starting'] as const;
+
+export function CindyMakeTaskCard({
+ report,
+ request,
+ onOpenTask,
+ readOnly = false,
+}: {
+ report: MakeDoctorReport;
+ request?: string;
+ onOpenTask?: () => void;
+ readOnly?: boolean;
+}) {
+ const { t } = useTranslation();
+ const [pending, setPending] = useState(false);
+ const task = report.task;
+ if (!task) return null;
+ const canOperate = () =>
+ !readOnly &&
+ !getStickySessionDeviceId(task.sessionId) &&
+ !getStickySessionDeviceId(task.originSessionId);
+ const interactive = canOperate();
+ const running = report.status === 'running';
+ const completed = report.status === 'completed';
+ const failed = report.status === 'failed';
+ const current =
+ task.phase === 'completed' ? phases.length : phases.findIndex((phase) => phase === task.phase);
+ const operate = async () => {
+ if (pending || !canOperate()) return;
+ setPending(true);
+ try {
+ if (running) {
+ const result = await window.electronAPI.cancelCindyMakeTask(report.runId);
+ if (!result.success) throw new Error('Preparation is already finishing');
+ } else if (request) {
+ await window.electronAPI.startCindyMakeTask({
+ originSessionId: task.originSessionId,
+ runId: report.runId,
+ request,
+ title: task.title ?? t('cindyMake.code.taskName'),
+ });
+ }
+ } catch {
+ toast.error(t('cindyMake.code.failed'));
+ } finally {
+ setPending(false);
+ }
+ };
+ return (
+ <section
+ className="w-full rounded-xl border border-[var(--border-default)] bg-[var(--surface-elevated)] text-13 text-[var(--text-primary)]"
+ aria-label={t('cindyMake.code.taskName')}
+ >
+ <div className="flex items-center gap-2 px-4 py-3">
+ <span className="min-w-0 flex-1 break-words font-medium">
+ {task.title ?? t('cindyMake.code.taskName')}
+ </span>
+ {running && <Spinner size={14} />}
+ </div>
+ <div className="space-y-3 border-t border-[var(--border-default)] px-4 py-3">
+ <ol className="space-y-2">
+ {phases.map((phase, index) => (
+ <li key={phase} className="flex items-center gap-2">
+ {completed || index < current ? (
+ <Check size={14} className="text-[var(--status-success)]" aria-hidden />
+ ) : running && index === current ? (
+ <Spinner size={14} />
+ ) : (
+ <Minus size={14} className="text-[var(--text-tertiary)]" aria-hidden />
+ )}
+ <span
+ className={
+ index === current ? 'text-[var(--text-primary)]' : 'text-[var(--text-secondary)]'
+ }
+ >
+ {t('cindyMake.code.phases.' + phase)}
+ </span>
+ </li>
+ ))}
+ </ol>
+ <div
+ role="status"
+ aria-live="polite"
+ className={failed ? 'text-[var(--status-danger)]' : 'text-[var(--text-secondary)]'}
+ >
+ {t(
+ completed
+ ? 'cindyMake.code.prepared'
+ : failed
+ ? 'cindyMake.code.preparationFailed'
+ : !running
+ ? 'cindyMake.prepare.cancelled'
+ : 'cindyMake.code.phases.' + task.phase,
+ )}
+ </div>
+ {(task.phase === 'dependencies' || task.dependencies) && (
+ <CindyMakeDependencyProgress
+ progress={task.dependencies}
+ running={running && task.phase === 'dependencies'}
+ />
+ )}
+ {task.phase === 'environment' &&
+ report.checks.map((check) => (
+ <p key={check.id} className="text-12 text-[var(--text-secondary)]">
+ {t('cindyMakeDoctor.checks.' + check.id)} ·{' '}
+ {t('cindyMakeDoctor.checkStatus.' + check.status)}
+ {check.progress &&
+ ' · ' +
+ t('cindyMake.prepare.downloadProgress', {
+ loaded: (check.progress.loaded / 1024 ** 2).toFixed(1),
+ total:
+ check.progress.total === null
+ ? '?'
+ : (check.progress.total / 1024 ** 2).toFixed(1),
+ })}
+ </p>
+ ))}
+ {task.phase === 'source' && report.source?.phase && (
+ <p className="text-12 text-[var(--text-secondary)]">
+ {t('cindyMake.source.phase.' + report.source.phase)}
+ {report.source.progress && ' · ' + report.source.progress.percent + '%'}
+ </p>
+ )}
+ {report.source?.branch && (
+ <p className="break-all text-12 text-[var(--text-tertiary)]">
+ {t('cindyMake.code.workspace', { branch: report.source.branch })}
+ </p>
+ )}
+ {failed && report.source?.error && (
+ <p className="text-12 text-[var(--status-danger)]">
+ {t('cindyMake.source.errors.' + report.source.error)}
+ </p>
+ )}
+ </div>
+ {interactive && onOpenTask && (
+ <div className="flex justify-end px-4 pb-3">
+ <Button variant="secondary" onClick={() => canOperate() && onOpenTask()}>
+ {t('cindyMake.code.open')}
+ </Button>
+ </div>
+ )}
+ {interactive && !completed && task.phase !== 'starting' && (running || request) && (
+ <div className="flex justify-end border-t border-[var(--border-default)] px-4 py-3">
+ <Button variant="secondary" disabled={pending} onClick={() => void operate()}>
+ {t(running ? 'cindyMake.prepare.stop' : 'cindyMake.prepare.retry')}
+ </Button>
+ </div>
+ )}
+ {interactive && !running && task.phase === 'starting' && request && (
+ <div className="flex justify-end border-t border-[var(--border-default)] px-4 py-3">
+ <Button variant="secondary" disabled={pending} onClick={() => void operate()}>
+ {t('cindyMake.prepare.retry')}
+ </Button>
+ </div>
+ )}
+ </section>
+ );
+}
diff --git a/apps/desktop/src/renderer/components/cindy-make/CindyMakeTasksPanel.tsx b/apps/desktop/src/renderer/components/cindy-make/CindyMakeTasksPanel.tsx
new file mode 100644
index 0000000000..b683fac503
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/CindyMakeTasksPanel.tsx
@@ -0,0 +1,289 @@
+import { useEffect, useRef, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { useConfirmDialog } from '@/components/ui/confirm-dialog-provider';
+import { cindyMakeState } from '@/lib/cindyMakeState';
+import { toast } from '@/lib/toast';
+import { extractIpcError } from '@/utils/ipcError';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+} from '@/contexts/dataOwnerGeneration';
+import type {
+ MakeDoctorReport,
+ CindyMakeGlobalState,
+ CindyMakeTaskActionState,
+} from '../../../shared/cindyMakeDoctor';
+import { CindyMakeTaskCard } from './CindyMakeTaskCard';
+import './cindyMakeTasks.css';
+
+function statusOf(report: MakeDoctorReport, action?: CindyMakeTaskActionState): string {
+ if (action?.status === 'running') return 'cleaning';
+ if (report.task?.sessionStatus === 'deleted') return 'cleanup';
+ if (report.task?.sessionStatus === 'archived') return 'archived';
+ if (report.status === 'running') return 'preparing';
+ if (report.status === 'failed') return 'failed';
+ if (report.status === 'cancelled') return 'cancelled';
+ return report.task?.executing ? 'running' : 'ready';
+}
+
+/** A bounded master/detail view: only the selected task mounts its preparation details. */
+export function CindyMakeTasksPanel({
+ reports,
+ taskActions = {},
+}: {
+ reports: MakeDoctorReport[];
+ taskActions?: CindyMakeGlobalState['taskActions'];
+}) {
+ const { t } = useTranslation();
+ const navigate = useNavigate();
+ const { confirm } = useConfirmDialog();
+ const [selectedId, setSelectedId] = useState('');
+ const [query, setQuery] = useState('');
+ const [pending, setPending] = useState(false);
+ const [operation, setOperation] = useState<{
+ runId: string;
+ action: 'open' | 'finish' | 'delete';
+ }>();
+ const busy = useRef(false);
+ const owner = getDataOwnerGeneration();
+ const current = () => isDataOwnerGenerationCurrent(owner);
+ const tasks = reports.filter((report) => report.task && !report.task.finished);
+ const search = query.trim().toLocaleLowerCase();
+ const visible = tasks.filter((report) =>
+ [report.task?.title, report.task?.request].some((value) =>
+ value?.toLocaleLowerCase().includes(search),
+ ),
+ );
+ const selected = visible.find((report) => report.runId === selectedId) ?? visible[0];
+ const taskAction = selected?.task ? taskActions[selected.task.sessionId] : undefined;
+ const cleaning = taskAction?.status === 'running';
+ const failureCode = taskAction?.status === 'failed' ? taskAction.error : undefined;
+ const disabled = pending || cleaning;
+ useEffect(() => {
+ let refreshing = false;
+ const refresh = async () => {
+ if (refreshing || document.visibilityState === 'hidden') return;
+ refreshing = true;
+ try {
+ await cindyMakeState.refresh();
+ } catch {
+ /* Keep the last known snapshot. */
+ } finally {
+ refreshing = false;
+ }
+ };
+ const timer = window.setInterval(() => void refresh(), 5000);
+ window.addEventListener('focus', refresh);
+ return () => {
+ window.clearInterval(timer);
+ window.removeEventListener('focus', refresh);
+ };
+ }, []);
+
+ const open = async () => {
+ if (!selected?.task || busy.current || cleaning || !current()) return;
+ busy.current = true;
+ setPending(true);
+ setOperation({ runId: selected.runId, action: 'open' });
+ try {
+ const service = await import('@/lib/sessionService');
+ if (!current()) return;
+ let session = await service.get(selected.task.sessionId);
+ if (!current() || session.status === 'deleted') throw new Error('unavailable');
+ if (session.status === 'archived') {
+ const restored = await service.restoreIfArchived(session.id, session);
+ if (!current() || !restored) throw new Error('unavailable');
+ session = restored;
+ }
+ const { sessionsStore } = await import('@/lib/sessionsStore');
+ if (!current()) return;
+ sessionsStore.prependCreated(session);
+ navigate('/cc-agent/' + session.id);
+ } catch {
+ if (current()) toast.error(t('settings.cindyMake.tasks.errors.unavailable'));
+ } finally {
+ busy.current = false;
+ setPending(false);
+ setOperation(undefined);
+ }
+ };
+
+ const manage = async (action: 'finish' | 'delete') => {
+ if (!selected?.task || busy.current || cleaning || !current()) return;
+ busy.current = true;
+ setPending(true);
+ try {
+ if (selected.task.sessionStatus !== 'deleted') {
+ const accepted = await confirm({
+ title: t('settings.cindyMake.tasks.' + action),
+ description: t('settings.cindyMake.tasks.' + action + 'Confirm', {
+ title: selected.task.title,
+ }),
+ confirmText: t('settings.cindyMake.tasks.' + action),
+ cancelText: t('settings.cindyMake.create.cancel'),
+ confirmVariant: action === 'delete' ? 'destructive' : 'default',
+ });
+ if (!accepted || !current()) return;
+ }
+ setOperation({ runId: selected.runId, action });
+ await window.electronAPI.manageCindyMakeTask(selected.task.sessionId, action);
+ if (current()) await cindyMakeState.refresh();
+ } catch (error) {
+ if (!current()) return;
+ const message = extractIpcError(error)?.message;
+ const code = [
+ 'busy',
+ 'dirty',
+ 'conflict',
+ 'cleanupFailed',
+ 'unavailable',
+ 'directoryBusy',
+ ].includes(message ?? '')
+ ? message!
+ : 'cleanupFailed';
+ toast.error(t('settings.cindyMake.tasks.errors.' + code));
+ await cindyMakeState.refresh().catch(() => {});
+ } finally {
+ busy.current = false;
+ setPending(false);
+ setOperation(undefined);
+ }
+ };
+
+ return (
+ <section
+ aria-label={t('settings.cindyMake.tasks.title')}
+ className="cindy-make-tasks rounded-xl border border-[var(--border-default)] bg-[var(--surface-elevated)] text-13 text-[var(--text-primary)]"
+ >
+ <div className="flex flex-wrap items-center justify-between gap-3 border-b border-[var(--border-default)] p-4">
+ <h3 className="font-medium">
+ {t('settings.cindyMake.tasks.title')} · {tasks.length}
+ </h3>
+ <Input
+ size="sm"
+ value={query}
+ onChange={setQuery}
+ aria-label={t('settings.cindyMake.tasks.search')}
+ placeholder={t('settings.cindyMake.tasks.search')}
+ className="cindy-make-tasks-search w-full"
+ />
+ </div>
+ <div className="cindy-make-tasks-layout grid min-w-0">
+ <ul
+ aria-label={t('settings.cindyMake.tasks.title')}
+ className="cindy-make-tasks-list max-h-60 space-y-1 overflow-y-auto overscroll-contain border-b border-[var(--border-default)] p-2"
+ >
+ {visible.map((report) => (
+ <li key={report.runId}>
+ <button
+ type="button"
+ aria-pressed={selected?.runId === report.runId}
+ onClick={() => setSelectedId(report.runId)}
+ className="flex w-full min-w-0 flex-col gap-1 rounded-lg px-3 py-3 text-left hover:bg-[var(--surface-hover)] aria-pressed:bg-[var(--surface-hover)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-[var(--focus-ring)]"
+ >
+ <span className="line-clamp-2 break-words font-medium">
+ {report.task?.title ?? t('cindyMake.code.taskName')}
+ </span>
+ <span className="text-12 text-[var(--text-secondary)]">
+ {t(
+ 'settings.cindyMake.tasks.status.' +
+ statusOf(
+ report,
+ report.task ? taskActions[report.task.sessionId] : undefined,
+ ),
+ )}
+ </span>
+ </button>
+ </li>
+ ))}
+ {!visible.length && (
+ <li className="p-3 text-[var(--text-secondary)]">
+ {t('settings.cindyMake.tasks.noResults')}
+ </li>
+ )}
+ </ul>
+ {selected?.task && (
+ <div className="flex min-w-0 max-h-[420px] flex-col">
+ <div className="shrink-0 p-4 pb-0">
+ <h4 className="break-words font-medium">
+ {selected.task.title ?? t('cindyMake.code.taskName')}
+ </h4>
+ <p className="mt-1 text-12 text-[var(--text-secondary)]">
+ {t('settings.cindyMake.tasks.status.' + statusOf(selected, taskAction))}
+ </p>
+ </div>
+ <div className="min-h-0 flex-1 space-y-4 overflow-y-auto overscroll-contain p-4">
+ <p className="whitespace-pre-wrap break-words">{selected.task.request}</p>
+ {selected.status !== 'completed' && selected.task.sessionStatus !== 'deleted' && (
+ <CindyMakeTaskCard
+ report={selected}
+ request={selected.task.request}
+ readOnly={selected.task.sessionStatus === 'archived'}
+ />
+ )}
+ {selected.status === 'completed' && selected.task.sessionStatus !== 'deleted' && (
+ <p className="text-12 text-[var(--text-secondary)]">
+ {t('settings.cindyMake.tasks.finishHint')}
+ </p>
+ )}
+ </div>
+ <div className="shrink-0 space-y-3 border-t border-[var(--border-default)] p-4">
+ {failureCode && (
+ <p role="alert" className="text-12 text-[var(--error-fg)]">
+ {t('settings.cindyMake.tasks.errors.' + failureCode)}
+ </p>
+ )}
+ <div className="flex flex-wrap gap-2">
+ {selected.task.sessionStatus !== 'deleted' && (
+ <Button
+ variant="secondary"
+ disabled={disabled}
+ loading={operation?.runId === selected.runId && operation.action === 'open'}
+ onClick={() => void open()}
+ >
+ {t(
+ selected.task.sessionStatus === 'archived'
+ ? 'settings.cindyMake.tasks.restore'
+ : 'cindyMake.code.open',
+ )}
+ </Button>
+ )}
+ {selected.status === 'completed' && selected.task.sessionStatus !== 'deleted' && (
+ <Button
+ variant="secondary"
+ disabled={disabled || selected.task.executing}
+ loading={
+ (cleaning && taskAction.action === 'finish') ||
+ (operation?.runId === selected.runId && operation.action === 'finish')
+ }
+ onClick={() => void manage('finish')}
+ >
+ {t('settings.cindyMake.tasks.finish')}
+ </Button>
+ )}
+ <Button
+ variant="secondary"
+ disabled={disabled}
+ loading={
+ (cleaning && taskAction.action === 'delete') ||
+ (operation?.runId === selected.runId && operation.action === 'delete')
+ }
+ onClick={() => void manage('delete')}
+ >
+ {t(
+ selected.task.sessionStatus === 'deleted'
+ ? 'settings.cindyMake.tasks.retryCleanup'
+ : 'settings.cindyMake.tasks.delete',
+ )}
+ </Button>
+ </div>
+ </div>
+ </div>
+ )}
+ </div>
+ </section>
+ );
+}
diff --git a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeComposerMask.test.tsx b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeComposerMask.test.tsx
new file mode 100644
index 0000000000..4f17543f6e
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeComposerMask.test.tsx
@@ -0,0 +1,30 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { CindyMakeComposerMask } from '../CindyMakeComposerMask';
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+afterEach(cleanup);
+
+describe('Cindy Make input replacement', () => {
+ it('replaces the editor with preparation status and an explanation', () => {
+ const view = render(<CindyMakeComposerMask phase="dependencies" />);
+ expect(screen.getByRole('status').textContent).toContain('cindyMake.code.phases.dependencies');
+ expect(screen.getByText('cindyMake.code.inputLocked.hint')).toBeTruthy();
+ expect(screen.queryByRole('textbox')).toBeNull();
+ expect(view.container.querySelector('[contenteditable="true"]')).toBeNull();
+ expect(screen.queryByRole('button')).toBeNull();
+ });
+
+ it('preserves the stop action during first execution', () => {
+ const stop = vi.fn();
+ render(<CindyMakeComposerMask phase="executing" onStop={stop} />);
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.prepare.stop' }));
+ expect(stop).toHaveBeenCalledOnce();
+ });
+
+ it.each(['failed', 'cancelled'] as const)('explains where to retry %s preparation', (phase) => {
+ render(<CindyMakeComposerMask phase={phase} />);
+ expect(screen.getByText('cindyMake.code.inputLocked.retry')).toBeTruthy();
+ expect(screen.queryByRole('textbox')).toBeNull();
+ });
+});
diff --git a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeCreateDialog.test.tsx b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeCreateDialog.test.tsx
index edcb7e1c8d..f4baa3ef0e 100644
--- a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeCreateDialog.test.tsx
+++ b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeCreateDialog.test.tsx
@@ -9,6 +9,7 @@ const mocks = vi.hoisted(() => ({
ensureMakeTask: vi.fn<typeof import('@/lib/cindyMakeDoctorStream').ensureMakeTask>(),
startMakeDoctorInStream:
vi.fn<typeof import('@/lib/cindyMakeDoctorStream').startMakeDoctorInStream>(),
+ preflight: vi.fn(),
getDraft: vi.fn(),
getFastModeForModel: vi.fn(),
navigate: vi.fn(),
@@ -20,19 +21,17 @@ vi.mock('@/lib/cindyMakeDoctorStream', () => ({
ensureMakeTask: mocks.ensureMakeTask,
startMakeDoctorInStream: mocks.startMakeDoctorInStream,
}));
+vi.mock('../CindyMakePreflightDialog', () => ({
+ CindyMakePreflightDialog: (props: unknown) => {
+ mocks.preflight(props);
+ return <div data-testid="preflight" />;
+ },
+}));
vi.mock('@/state/newMakerDraft', () => ({
getDraft: mocks.getDraft,
getFastModeForModel: mocks.getFastModeForModel,
}));
-function deferred<T>() {
- let resolve!: (value: T) => void;
- const promise = new Promise<T>((done) => {
- resolve = done;
- });
- return { promise, resolve };
-}
-
function openDialog() {
const onOpenChange = vi.fn();
const view = render(<CindyMakeCreateDialog onOpenChange={onOpenChange} />);
@@ -117,13 +116,11 @@ describe('Cindy Make creation from Settings', () => {
fireEvent.change(view.input, { target: { value: request } });
fireEvent.click(view.submit);
- await waitFor(() => expect(mocks.navigate).toHaveBeenCalledWith('/cc-agent/make-task'));
- expect(mocks.ensureMakeTask).toHaveBeenCalledExactlyOnceWith({
- sessionId: undefined,
- title: 'settings.cindyMake.create.title',
- isCurrent: expect.any(Function),
+ await waitFor(() => expect(screen.getByTestId('preflight')).toBeTruthy());
+ expect(mocks.preflight).toHaveBeenCalledWith({
+ request,
+ onOpenChange: view.onOpenChange,
createOptions: {
- workspaceKind: 'dialogue',
agentKind: vendor,
model: 'selected-model',
effort: 'high',
@@ -133,70 +130,35 @@ describe('Cindy Make creation from Settings', () => {
planModeEnabled: true,
},
});
- expect(mocks.startMakeDoctorInStream).toHaveBeenCalledExactlyOnceWith('make-task', {
- command: 'cindy-make',
- request,
- });
- expect(view.onOpenChange).toHaveBeenCalledWith(false);
+ expect(mocks.ensureMakeTask).not.toHaveBeenCalled();
+ expect(mocks.startMakeDoctorInStream).not.toHaveBeenCalled();
+ expect(mocks.navigate).not.toHaveBeenCalled();
+ expect(view.onOpenChange).not.toHaveBeenCalled();
expect(JSON.stringify(draft)).toBe(originalDraft);
},
);
- it('coalesces repeated submissions while creating the task', async () => {
- const pending = deferred<string | null>();
- mocks.ensureMakeTask.mockReturnValue(pending.promise);
+ it('coalesces repeated submissions before opening preflight', async () => {
const view = openDialog();
fireEvent.change(view.input, { target: { value: 'Add a filter' } });
fireEvent.click(view.submit);
fireEvent.submit(view.input.closest('form')!);
fireEvent.keyDown(view.input, { key: 'Enter', metaKey: true });
- await waitFor(() => expect(mocks.ensureMakeTask).toHaveBeenCalledTimes(1));
- expect(view.submit.disabled).toBe(true);
- expect(view.input.disabled).toBe(true);
- await act(async () => pending.resolve('make-task'));
- expect(mocks.startMakeDoctorInStream).toHaveBeenCalledTimes(1);
- expect(mocks.navigate).toHaveBeenCalledTimes(1);
+ await waitFor(() => expect(screen.getByTestId('preflight')).toBeTruthy());
+ expect(mocks.getDraft).toHaveBeenCalledTimes(1);
});
- it('keeps the requirements after a creation failure and permits retry', async () => {
- mocks.ensureMakeTask.mockRejectedValueOnce(new Error('creation failed'));
+ it('retains requirements if loading preferences fails and allows retry', async () => {
+ mocks.getDraft.mockImplementationOnce(() => {
+ throw new Error('unavailable');
+ });
const view = openDialog();
fireEvent.change(view.input, { target: { value: 'Add a filter' } });
fireEvent.click(view.submit);
await waitFor(() => expect(screen.getByRole('alert')).toBeTruthy());
expect(view.input.value).toBe('Add a filter');
- expect(view.submit.disabled).toBe(false);
- expect(mocks.startMakeDoctorInStream).not.toHaveBeenCalled();
- expect(mocks.navigate).not.toHaveBeenCalled();
- fireEvent.click(view.submit);
- await waitFor(() => expect(mocks.navigate).toHaveBeenCalledTimes(1));
- expect(mocks.ensureMakeTask).toHaveBeenCalledTimes(2);
- });
-
- it('reuses the created task if starting the workflow fails', async () => {
- mocks.startMakeDoctorInStream.mockReturnValueOnce(null);
- const view = openDialog();
- fireEvent.change(view.input, { target: { value: 'Add a filter' } });
- fireEvent.click(view.submit);
- await waitFor(() => expect(screen.getByRole('alert')).toBeTruthy());
- fireEvent.click(view.submit);
- await waitFor(() => expect(mocks.navigate).toHaveBeenCalledTimes(1));
- expect(mocks.ensureMakeTask.mock.calls[1][0].sessionId).toBe('make-task');
- });
-
- it('does not start or navigate under a different account after task creation', async () => {
- const pending = deferred<string | null>();
- mocks.ensureMakeTask.mockReturnValue(pending.promise);
- const view = openDialog();
- fireEvent.change(view.input, { target: { value: 'Add a filter' } });
fireEvent.click(view.submit);
- await waitFor(() => expect(mocks.ensureMakeTask).toHaveBeenCalledTimes(1));
- setDataOwnerGeneration('owner-b', 2);
- expect(mocks.ensureMakeTask.mock.calls[0][0].isCurrent()).toBe(false);
- await act(async () => pending.resolve('old-owner-task'));
- expect(mocks.startMakeDoctorInStream).not.toHaveBeenCalled();
- expect(mocks.navigate).not.toHaveBeenCalled();
- expect(view.onOpenChange).toHaveBeenCalledWith(false);
+ await waitFor(() => expect(screen.getByTestId('preflight')).toBeTruthy());
});
it('dismisses a stale form rather than submitting the previous account’s request', async () => {
@@ -209,22 +171,14 @@ describe('Cindy Make creation from Settings', () => {
expect(view.onOpenChange).toHaveBeenCalledWith(false);
});
- it('keeps accepted work independent of Settings unmount without late navigation', async () => {
- const pending = deferred<string | null>();
- mocks.ensureMakeTask.mockReturnValue(pending.promise);
+ it('does not open preflight if Settings unmounts while loading preferences', async () => {
const view = openDialog();
fireEvent.change(view.input, { target: { value: 'Add a filter' } });
fireEvent.click(view.submit);
- await waitFor(() => expect(mocks.ensureMakeTask).toHaveBeenCalledTimes(1));
view.unmount();
- expect(mocks.ensureMakeTask.mock.calls[0][0].isCurrent()).toBe(true);
- await act(async () => pending.resolve('make-task'));
- expect(mocks.startMakeDoctorInStream).toHaveBeenCalledExactlyOnceWith('make-task', {
- command: 'cindy-make',
- request: 'Add a filter',
- });
- expect(mocks.navigate).not.toHaveBeenCalled();
- expect(view.onOpenChange).not.toHaveBeenCalled();
+ await act(async () => {});
+ expect(mocks.preflight).not.toHaveBeenCalled();
+ expect(mocks.ensureMakeTask).not.toHaveBeenCalled();
});
it('supports Ctrl+Enter but never submits while composing text', async () => {
@@ -235,6 +189,6 @@ describe('Cindy Make creation from Settings', () => {
});
expect(mocks.ensureMakeTask).not.toHaveBeenCalled();
fireEvent.keyDown(view.input, { key: 'Enter', ctrlKey: true });
- await waitFor(() => expect(mocks.navigate).toHaveBeenCalledTimes(1));
+ await waitFor(() => expect(screen.getByTestId('preflight')).toBeTruthy());
});
});
diff --git a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakePreflightDialog.test.tsx b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakePreflightDialog.test.tsx
new file mode 100644
index 0000000000..5422bbd1e5
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakePreflightDialog.test.tsx
@@ -0,0 +1,200 @@
+// @vitest-environment jsdom
+import { StrictMode } from 'react';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { MAKE_DOCTOR_CHECK_IDS, type MakeDoctorReport } from '../../../../shared/cindyMakeDoctor';
+import { CindyMakePreflightDialog } from '../CindyMakePreflightDialog';
+
+const h = vi.hoisted(() => ({
+ start: vi.fn(),
+ cancel: vi.fn(),
+ create: vi.fn(),
+ navigate: vi.fn(),
+ get: vi.fn(),
+ prepend: vi.fn(),
+ runtime: vi.fn(),
+ remote: false,
+ publish: undefined as undefined | ((report: MakeDoctorReport) => void),
+}));
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+vi.mock('react-router-dom', () => ({ useNavigate: () => h.navigate }));
+vi.mock('@/lib/cindyMakeDoctor', () => ({ startMakeDoctor: h.start, cancelMakeDoctor: h.cancel }));
+vi.mock('@/lib/makerChatStore', () => ({ makerChatStore: { setSessionRuntime: h.runtime } }));
+vi.mock('@/lib/sessionService', () => ({ get: h.get }));
+vi.mock('@/lib/sessionsStore', () => ({ sessionsStore: { prependCreated: h.prepend } }));
+vi.mock('@/features/device-link/stickySessionOrigin', () => ({
+ getStickySessionDeviceId: () => (h.remote ? 'remote' : undefined),
+}));
+
+const ready: MakeDoctorReport = {
+ runId: 'run',
+ mode: 'prepare',
+ status: 'completed',
+ platform: 'win32',
+ arch: 'x64',
+ checks: MAKE_DOCTOR_CHECK_IDS.map((id) => ({ id, status: 'passed' })),
+ source: { status: 'ready', path: '/source' },
+ upstream: { status: 'notFound', items: [] },
+};
+const continueButton = () => screen.getByRole('button', { name: 'cindyMake.upstream.personal' });
+const finishChecks = async () => {
+ await waitFor(() => expect(h.publish).toBeTypeOf('function'));
+ act(() => h.publish!(ready));
+};
+function open(sessionId?: string) {
+ const close = vi.fn();
+ return {
+ close,
+ ...render(
+ <CindyMakePreflightDialog
+ request=" Keep my request "
+ sessionId={sessionId}
+ createOptions={{ agentKind: 'codex', model: 'selected' }}
+ onOpenChange={close}
+ />,
+ ),
+ };
+}
+beforeEach(() => {
+ vi.clearAllMocks();
+ h.remote = false;
+ h.publish = undefined;
+ setDataOwnerGeneration('owner', 1);
+ h.start.mockImplementation((publish) => {
+ h.publish = publish;
+ publish({
+ ...ready,
+ status: 'running',
+ source: undefined,
+ upstream: { status: 'pending', items: [] },
+ });
+ return 'run';
+ });
+ h.cancel.mockResolvedValue(undefined);
+ h.create.mockResolvedValue('code-task');
+ h.get.mockResolvedValue({ id: 'code-task' });
+ window.electronAPI = { ...window.electronAPI, startCindyMakeTask: h.create };
+});
+afterEach(() => {
+ cleanup();
+ setDataOwnerGeneration(null);
+});
+
+describe('Make preflight confirmation boundary', () => {
+ it('starts checks once under StrictMode without cancelling them on the rehearsal mount', async () => {
+ render(
+ <StrictMode>
+ <CindyMakePreflightDialog request="Fix scrolling" onOpenChange={vi.fn()} />
+ </StrictMode>,
+ );
+ await waitFor(() => expect(h.start).toHaveBeenCalledOnce());
+ expect(h.cancel).not.toHaveBeenCalled();
+ expect(h.create).not.toHaveBeenCalled();
+ });
+
+ it.each([undefined, 'origin'])(
+ 'does not create or navigate during checks from %s',
+ async (sessionId) => {
+ open(sessionId);
+ expect(screen.getByRole('dialog')).toBeTruthy();
+ expect(screen.queryByRole('button', { name: 'cindyMake.upstream.personal' })).toBeNull();
+ await finishChecks();
+ expect(h.create).not.toHaveBeenCalled();
+ expect(h.navigate).not.toHaveBeenCalled();
+ fireEvent.click(continueButton());
+ await waitFor(() => expect(h.navigate).toHaveBeenCalledWith('/cc-agent/code-task'));
+ expect(h.create).toHaveBeenCalledExactlyOnceWith({
+ originSessionId: sessionId,
+ runId: 'run',
+ request: ' Keep my request ',
+ title: 'cindyMake.code.taskTitle',
+ createOptions: { agentKind: 'codex', model: 'selected' },
+ });
+ expect(h.runtime).toHaveBeenCalledWith('code-task', { autoTitleDisabled: true });
+ },
+ );
+
+ it.each(['cancel', 'wait'])('creates no task on %s', async (choice) => {
+ const view = open();
+ await finishChecks();
+ fireEvent.click(
+ screen.getByRole('button', {
+ name: choice === 'wait' ? 'cindyMake.upstream.wait' : 'settings.cindyMake.create.cancel',
+ }),
+ );
+ expect(view.close).toHaveBeenCalledWith(false);
+ expect(h.create).not.toHaveBeenCalled();
+ });
+
+ it('cancels unfinished checks when dismissed', async () => {
+ const view = open();
+ await waitFor(() => expect(h.start).toHaveBeenCalledOnce());
+ view.unmount();
+ expect(h.cancel).toHaveBeenCalledWith('run', 'prepare');
+ expect(h.create).not.toHaveBeenCalled();
+ });
+
+ it('keeps failed creation in the dialog and retries the same run', async () => {
+ h.create.mockRejectedValueOnce(new Error('failure'));
+ open();
+ await finishChecks();
+ fireEvent.click(continueButton());
+ await waitFor(() => expect(screen.getByRole('alert')).toBeTruthy());
+ expect(h.navigate).not.toHaveBeenCalled();
+ fireEvent.click(continueButton());
+ await waitFor(() => expect(h.navigate).toHaveBeenCalledTimes(1));
+ expect(h.create.mock.calls[0][0]).toEqual(h.create.mock.calls[1][0]);
+ });
+
+ it('coalesces clicks, blocks dismissal during creation, and ignores late navigation after unmount', async () => {
+ let done!: (id: string) => void;
+ h.create.mockImplementationOnce(
+ () =>
+ new Promise<string>((resolve) => {
+ done = resolve;
+ }),
+ );
+ const view = open();
+ await finishChecks();
+ fireEvent.click(continueButton());
+ fireEvent.click(continueButton());
+ fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+ expect(h.create).toHaveBeenCalledTimes(1);
+ expect(view.close).not.toHaveBeenCalled();
+ view.unmount();
+ await act(async () => done('code-task'));
+ expect(h.prepend).toHaveBeenCalledWith({ id: 'code-task' });
+ expect(h.navigate).not.toHaveBeenCalled();
+ expect(h.cancel).not.toHaveBeenCalled();
+ });
+
+ it.each(['account', 'remote'])(
+ 'does not create after the %s boundary changes',
+ async (boundary) => {
+ open();
+ await finishChecks();
+ if (boundary === 'account') setDataOwnerGeneration('other', 2);
+ else h.remote = true;
+ fireEvent.click(continueButton());
+ expect(h.create).not.toHaveBeenCalled();
+ },
+ );
+
+ it('ignores an old account result after confirmation', async () => {
+ let done!: (id: string) => void;
+ h.create.mockImplementationOnce(
+ () =>
+ new Promise<string>((resolve) => {
+ done = resolve;
+ }),
+ );
+ open();
+ await finishChecks();
+ fireEvent.click(continueButton());
+ setDataOwnerGeneration('other', 2);
+ await act(async () => done('old-task'));
+ expect(h.prepend).not.toHaveBeenCalled();
+ expect(h.navigate).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTaskCard.test.tsx b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTaskCard.test.tsx
new file mode 100644
index 0000000000..650e075510
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTaskCard.test.tsx
@@ -0,0 +1,140 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { CindyMakeTaskCard } from '../CindyMakeTaskCard';
+import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
+import type { MakeDoctorReport } from '../../../../shared/cindyMakeDoctor';
+vi.mock('react-i18next', () => ({
+ useTranslation: () => ({
+ t: (key: string, values?: unknown) => key + (values ? ' ' + JSON.stringify(values) : ''),
+ }),
+}));
+vi.mock('@/lib/toast', () => ({ toast: { error: vi.fn() } }));
+vi.mock('@/features/device-link/stickySessionOrigin', () => ({
+ getStickySessionDeviceId: vi.fn(),
+}));
+afterEach(() => {
+ cleanup();
+ vi.mocked(getStickySessionDeviceId).mockReset();
+ vi.unstubAllGlobals();
+});
+const report: MakeDoctorReport = {
+ runId: 'make-run',
+ status: 'running',
+ checks: [],
+ platform: 'win32',
+ arch: 'x64',
+ task: {
+ title: 'Cindy Make: scrolling',
+ sessionId: 'created',
+ originSessionId: 'origin',
+ phase: 'dependencies',
+ dependencies: { resolved: 10, reused: 3, downloaded: 7, added: 10 },
+ },
+};
+
+describe('Cindy Make preparation card', () => {
+ it.each(['running', 'failed', 'cancelled'] as const)(
+ 'keeps a read-only %s card visible without controls or local navigation',
+ (status) => {
+ render(
+ <CindyMakeTaskCard
+ report={{ ...report, status }}
+ request="original request"
+ onOpenTask={vi.fn()}
+ readOnly
+ />,
+ );
+ expect(screen.getByRole('status')).toBeTruthy();
+ expect(screen.queryByRole('button')).toBeNull();
+ },
+ );
+ it.each(['created', 'origin'])('keeps remotely owned %s tasks read-only', (remoteSession) => {
+ vi.mocked(getStickySessionDeviceId).mockImplementation((sessionId) =>
+ sessionId === remoteSession ? 'remote-device' : undefined,
+ );
+ render(<CindyMakeTaskCard report={report} request="original request" onOpenTask={vi.fn()} />);
+ expect(screen.queryByRole('button')).toBeNull();
+ });
+ it.each(['running', 'failed'] as const)(
+ 'rechecks device ownership before a %s action or navigation',
+ (status) => {
+ const cancel = vi.fn();
+ const start = vi.fn();
+ const open = vi.fn();
+ vi.stubGlobal('electronAPI', { cancelCindyMakeTask: cancel, startCindyMakeTask: start });
+ render(
+ <CindyMakeTaskCard
+ report={{ ...report, status }}
+ request="original request"
+ onOpenTask={open}
+ />,
+ );
+ vi.mocked(getStickySessionDeviceId).mockReturnValue('remote-device');
+ fireEvent.click(
+ screen.getByRole('button', {
+ name: status === 'running' ? 'cindyMake.prepare.stop' : 'cindyMake.prepare.retry',
+ }),
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.code.open' }));
+ expect(cancel).not.toHaveBeenCalled();
+ expect(start).not.toHaveBeenCalled();
+ expect(open).not.toHaveBeenCalled();
+ },
+ );
+ it('shows all stages and real dependency counts without a fake overall percentage', () => {
+ render(<CindyMakeTaskCard report={report} request="original request" />);
+ expect(screen.getAllByRole('listitem')).toHaveLength(5);
+ expect(screen.getByRole('status').textContent).toBe('cindyMake.code.phases.dependencies');
+ expect(screen.getByText(/dependencyProgress/).textContent).toContain('"downloaded":7');
+ expect(screen.queryByRole('progressbar')).toBeNull();
+ });
+ it('shows startup and script activity even when no package counts have arrived', () => {
+ const initial = { ...report, task: { ...report.task!, dependencies: undefined } };
+ const view = render(<CindyMakeTaskCard report={initial} />);
+ expect(screen.getByText(/dependencyActivity.starting/)).toBeTruthy();
+ expect(screen.queryByText(/dependencyProgress/)).toBeNull();
+ view.rerender(
+ <CindyMakeTaskCard
+ report={{ ...initial, task: { ...initial.task, dependencies: { activity: 'scripts' } } }}
+ />,
+ );
+ expect(screen.getByText(/dependencyActivity.scripts/)).toBeTruthy();
+ expect(screen.queryByText(/dependencyProgress/)).toBeNull();
+ });
+ it('uses Main to cancel and does not invent a completed or cancelled report', async () => {
+ const cancel = vi.fn(async () => ({ success: true }));
+ vi.stubGlobal('electronAPI', { cancelCindyMakeTask: cancel });
+ render(<CindyMakeTaskCard report={report} request="original request" />);
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.prepare.stop' }));
+ await waitFor(() => expect(cancel).toHaveBeenCalledWith('make-run'));
+ expect(screen.getByRole('status').textContent).toBe('cindyMake.code.phases.dependencies');
+ });
+ it('retries the same task using the preserved request', async () => {
+ const start = vi.fn(async () => 'created');
+ vi.stubGlobal('electronAPI', { startCindyMakeTask: start });
+ render(
+ <CindyMakeTaskCard report={{ ...report, status: 'failed' }} request="original request" />,
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.prepare.retry' }));
+ await waitFor(() =>
+ expect(start).toHaveBeenCalledWith({
+ originSessionId: 'origin',
+ runId: 'make-run',
+ request: 'original request',
+ title: report.task!.title,
+ }),
+ );
+ });
+ it('has no dispatch action and shows automatic start only after Main acknowledges it', () => {
+ const view = render(<CindyMakeTaskCard report={report} request="original request" />);
+ view.rerender(
+ <CindyMakeTaskCard
+ report={{ ...report, status: 'completed', task: { ...report.task!, phase: 'completed' } }}
+ request="original request"
+ />,
+ );
+ expect(screen.getByRole('status').textContent).toBe('cindyMake.code.prepared');
+ expect(screen.queryByRole('button')).toBeNull();
+ });
+});
diff --git a/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTasksPanel.test.tsx b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTasksPanel.test.tsx
new file mode 100644
index 0000000000..ba45a67964
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakeTasksPanel.test.tsx
@@ -0,0 +1,207 @@
+// @vitest-environment jsdom
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const h = vi.hoisted(() => ({
+ navigate: vi.fn(),
+ confirm: vi.fn(),
+ get: vi.fn(),
+ restore: vi.fn(),
+ prepend: vi.fn(),
+ refresh: vi.fn(),
+ manage: vi.fn(),
+ error: vi.fn(),
+}));
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+vi.mock('react-router-dom', () => ({ useNavigate: () => h.navigate }));
+vi.mock('@/components/ui/confirm-dialog-provider', () => ({
+ useConfirmDialog: () => ({ confirm: h.confirm }),
+}));
+vi.mock('@/lib/sessionService', () => ({ get: h.get, restoreIfArchived: h.restore }));
+vi.mock('@/lib/sessionsStore', () => ({ sessionsStore: { prependCreated: h.prepend } }));
+vi.mock('@/lib/cindyMakeState', () => ({ cindyMakeState: { refresh: h.refresh } }));
+vi.mock('@/lib/toast', () => ({ toast: { error: h.error } }));
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import type { MakeDoctorReport } from '../../../../shared/cindyMakeDoctor';
+import { CindyMakeTasksPanel } from '../CindyMakeTasksPanel';
+
+function report(
+ index: number,
+ extra: Partial<NonNullable<MakeDoctorReport['task']>> = {},
+): MakeDoctorReport {
+ return {
+ runId: 'run-' + index,
+ platform: 'win32',
+ arch: 'x64',
+ status: 'completed',
+ checks: [],
+ task: {
+ sessionId: 'session-' + index,
+ title: 'Build ' + index,
+ request: 'Request ' + index,
+ phase: 'completed',
+ sessionStatus: 'active',
+ ...extra,
+ },
+ };
+}
+beforeEach(() => {
+ vi.clearAllMocks();
+ setDataOwnerGeneration('make-tasks-test');
+ h.confirm.mockResolvedValue(true);
+ h.manage.mockResolvedValue(undefined);
+ h.refresh.mockResolvedValue(undefined);
+ h.get.mockResolvedValue({ id: 'session-1', status: 'active', source: 'cindy-make' });
+ h.restore.mockResolvedValue({ id: 'session-1', status: 'active', source: 'cindy-make' });
+ vi.stubGlobal('electronAPI', { manageCindyMakeTask: h.manage });
+});
+afterEach(() => {
+ cleanup();
+ vi.unstubAllGlobals();
+});
+
+describe('Cindy Make settings task list', () => {
+ it('shows one detail for many tasks, with search and no completed preparation steps', () => {
+ render(<CindyMakeTasksPanel reports={Array.from({ length: 100 }, (_, i) => report(i))} />);
+ expect(screen.getByText('Request 0')).toBeTruthy();
+ expect(screen.queryByText('Request 50')).toBeNull();
+ expect(screen.queryByText('cindyMake.code.phases.environment')).toBeNull();
+ fireEvent.change(screen.getByRole('textbox'), { target: { value: 'Build 50' } });
+ expect(screen.getByText('Request 50')).toBeTruthy();
+ expect(screen.queryByText('Request 0')).toBeNull();
+ });
+ it('does not show finished tasks and preserves selection when another record disappears', () => {
+ const view = render(
+ <CindyMakeTasksPanel reports={[report(1), report(2), report(3, { finished: true })]} />,
+ );
+ expect(screen.queryByText('Build 3')).toBeNull();
+ fireEvent.click(screen.getByRole('button', { name: /Build 2/ }));
+ view.rerender(<CindyMakeTasksPanel reports={[report(2)]} />);
+ expect(screen.getByText('Request 2')).toBeTruthy();
+ });
+ it('opens an active task without starting another execution', async () => {
+ render(<CindyMakeTasksPanel reports={[report(1)]} />);
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.code.open' }));
+ await waitFor(() => expect(h.navigate).toHaveBeenCalledWith('/cc-agent/session-1'));
+ expect(h.restore).not.toHaveBeenCalled();
+ expect(h.manage).not.toHaveBeenCalled();
+ });
+ it('restores archived tasks before navigating', async () => {
+ const archived = {
+ id: 'session-1',
+ status: 'archived',
+ workingDir: '/make/run',
+ workspaceKind: 'project',
+ };
+ h.get.mockResolvedValue(archived);
+ let resolve!: (value: unknown) => void;
+ h.restore.mockImplementation(
+ () =>
+ new Promise((done) => {
+ resolve = done;
+ }),
+ );
+ render(<CindyMakeTasksPanel reports={[report(1, { sessionStatus: 'archived' })]} />);
+ fireEvent.click(screen.getByRole('button', { name: 'settings.cindyMake.tasks.restore' }));
+ await waitFor(() => expect(h.restore).toHaveBeenCalledWith('session-1', archived));
+ expect(h.navigate).not.toHaveBeenCalled();
+ await act(async () => resolve({ ...archived, status: 'active' }));
+ expect(h.navigate).toHaveBeenCalledWith('/cc-agent/session-1');
+ });
+ it('does not revive a deleted task or continue after an account switch', async () => {
+ h.get.mockResolvedValue({ id: 'session-1', status: 'deleted' });
+ render(<CindyMakeTasksPanel reports={[report(1)]} />);
+ fireEvent.click(screen.getByRole('button', { name: 'cindyMake.code.open' }));
+ await waitFor(() => expect(h.error).toHaveBeenCalled());
+ expect(h.navigate).not.toHaveBeenCalled();
+ h.confirm.mockImplementation(async () => {
+ setDataOwnerGeneration('another-owner');
+ return true;
+ });
+ fireEvent.click(screen.getByRole('button', { name: 'settings.cindyMake.tasks.delete' }));
+ await waitFor(() => expect(h.confirm).toHaveBeenCalled());
+ expect(h.manage).not.toHaveBeenCalled();
+ });
+ it('requires confirmation before deleting and refreshes only after the operation settles', async () => {
+ h.confirm.mockResolvedValueOnce(false);
+ render(<CindyMakeTasksPanel reports={[report(1)]} />);
+ const remove = screen.getByRole('button', { name: 'settings.cindyMake.tasks.delete' });
+ fireEvent.click(remove);
+ await waitFor(() => expect(remove.hasAttribute('disabled')).toBe(false));
+ expect(h.manage).not.toHaveBeenCalled();
+ fireEvent.click(remove);
+ await waitFor(() => expect(h.manage).toHaveBeenCalledWith('session-1', 'delete'));
+ expect(h.confirm).toHaveBeenLastCalledWith(
+ expect.objectContaining({ confirmVariant: 'destructive' }),
+ );
+ await waitFor(() => expect(h.refresh).toHaveBeenCalled());
+ });
+ it('keeps cleanup retry available without offering to reopen a deleted task', async () => {
+ render(<CindyMakeTasksPanel reports={[report(1, { sessionStatus: 'deleted' })]} />);
+ expect(screen.queryByRole('button', { name: 'cindyMake.code.open' })).toBeNull();
+ fireEvent.click(screen.getByRole('button', { name: 'settings.cindyMake.tasks.retryCleanup' }));
+ await waitFor(() => expect(h.manage).toHaveBeenCalledWith('session-1', 'delete'));
+ expect(h.confirm).not.toHaveBeenCalled();
+ });
+ it('shows cleanup progress and keeps an actionable failure beside the retry button', async () => {
+ let reject!: (error: Error) => void;
+ h.manage.mockImplementationOnce(
+ () =>
+ new Promise((_, fail) => {
+ reject = fail;
+ }),
+ );
+ const view = render(
+ <CindyMakeTasksPanel reports={[report(1, { sessionStatus: 'deleted' })]} />,
+ );
+ const button = screen.getByRole('button', { name: 'settings.cindyMake.tasks.retryCleanup' });
+ fireEvent.click(button);
+ await waitFor(() => expect(button.getAttribute('aria-busy')).toBe('true'));
+ expect(button.hasAttribute('disabled')).toBe(true);
+ await act(async () => reject(new Error('[PRECONDITION_FAILED] directoryBusy')));
+ view.rerender(
+ <CindyMakeTasksPanel
+ reports={[report(1, { sessionStatus: 'deleted' })]}
+ taskActions={{
+ 'session-1': { action: 'delete', status: 'failed', error: 'directoryBusy' },
+ }}
+ />,
+ );
+ expect(screen.getByRole('alert').textContent).toBe(
+ 'settings.cindyMake.tasks.errors.directoryBusy',
+ );
+ expect(button.hasAttribute('disabled')).toBe(false);
+ expect(button.getAttribute('aria-busy')).toBeNull();
+ });
+ it('shows global cleanup after leaving and reopening settings, then retains its failure', () => {
+ const props = {
+ reports: [report(1, { sessionStatus: 'deleted' })],
+ taskActions: { 'session-1': { action: 'delete' as const, status: 'running' as const } },
+ };
+ const first = render(<CindyMakeTasksPanel {...props} />);
+ first.unmount();
+ const next = render(<CindyMakeTasksPanel {...props} />);
+ const retry = screen.getByRole('button', { name: 'settings.cindyMake.tasks.retryCleanup' });
+ expect(retry.getAttribute('aria-busy')).toBe('true');
+ expect(retry.hasAttribute('disabled')).toBe(true);
+ expect(screen.getAllByText('settings.cindyMake.tasks.status.cleaning')).toHaveLength(2);
+ fireEvent.click(retry);
+ expect(h.manage).not.toHaveBeenCalled();
+ next.unmount();
+ render(
+ <CindyMakeTasksPanel
+ reports={props.reports}
+ taskActions={{
+ 'session-1': { action: 'delete', status: 'failed', error: 'directoryBusy' },
+ }}
+ />,
+ );
+ expect(screen.getByRole('alert').textContent).toBe(
+ 'settings.cindyMake.tasks.errors.directoryBusy',
+ );
+ expect(
+ screen
+ .getByRole('button', { name: 'settings.cindyMake.tasks.retryCleanup' })
+ .hasAttribute('disabled'),
+ ).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/renderer/components/cindy-make/cindyMakeTasks.css b/apps/desktop/src/renderer/components/cindy-make/cindyMakeTasks.css
new file mode 100644
index 0000000000..a97e01d18e
--- /dev/null
+++ b/apps/desktop/src/renderer/components/cindy-make/cindyMakeTasks.css
@@ -0,0 +1,19 @@
+.cindy-make-tasks {
+ container-type: inline-size;
+}
+
+@container (min-width: 560px) {
+ .cindy-make-tasks-search {
+ width: 224px;
+ }
+
+ .cindy-make-tasks-layout {
+ grid-template-columns: minmax(180px, 2fr) minmax(0, 3fr);
+ }
+
+ .cindy-make-tasks-list {
+ max-height: 420px;
+ border-bottom-width: 0;
+ border-right-width: 1px;
+ }
+}
diff --git a/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx b/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
index 7d4a3c6fc0..14abf8ddb3 100644
--- a/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
@@ -242,6 +242,10 @@ import { Fragment, Slice, type Node as ProseMirrorNode } from '@tiptap/pm/model'
import { Selection, TextSelection } from '@tiptap/pm/state';
import * as sessionService from '@/lib/sessionService';
import { classifyCindyMakeCommand, tryStartCindyMakeCommand } from '@/lib/cindyMakeCommand';
+import {
+ CindyMakePreflightDialog,
+ type CindyMakePreflightProps,
+} from '@/components/cindy-make/CindyMakePreflightDialog';
import { getModelById } from '@/lib/modelDefinitions';
import {
beginSlashCommandRosterLoad,
@@ -1689,6 +1693,10 @@ export function ChatInput({
// 这里用本地乐观态承接即时反馈:seed 自 initialProviderId,选择时乐观更新;
// initialProviderId 变化(将来 session 回流)时跟随。null = 跟随默认路由。
const currentSessionIdRef = useRef(sessionId);
+ const [makePreflight, setMakePreflight] = useState<
+ Omit<CindyMakePreflightProps, 'onOpenChange'> | null
+ >(null);
+ useEffect(() => setMakePreflight(null), [sessionId]);
currentSessionIdRef.current = sessionId;
const [selectedProviderId, setSelectedProviderId] = useState<string | null>(
initialProviderId ?? null,
@@ -5202,13 +5210,36 @@ export function ChatInput({
toast.error(t('cindyMakeDoctor.failed'));
return;
}
- if (makeResult.kind === 'started') {
+ if (makeResult.kind === 'started' || makeResult.kind === 'preflight') {
editor.commands.clearContent(true);
historyIndexRef.current = -1;
hydratedHistoryDocumentRef.current = null;
draftRef.current = null;
if (sourceStorageKey) clearComposerDraft(sourceStorageKey);
- if (makeResult.sessionId !== sourceSessionId) {
+ if (makeResult.kind === 'preflight') {
+ const {
+ agentKind,
+ model,
+ effort,
+ permissionMode,
+ providerId,
+ fastMode,
+ planModeEnabled,
+ } = makeResult.createOptions ?? {};
+ setMakePreflight({
+ request: makeResult.request,
+ sessionId: sourceSessionId,
+ createOptions: {
+ agentKind,
+ model,
+ effort,
+ permissionMode,
+ providerId,
+ fastMode,
+ planModeEnabled,
+ },
+ });
+ } else if (makeResult.sessionId !== sourceSessionId) {
navigate('/cc-agent/' + makeResult.sessionId);
}
return;
@@ -8158,6 +8189,12 @@ export function ChatInput({
return (
<div className="relative flex w-full flex-col items-center gap-4" data-chat-input-root>
+ {makePreflight && makePreflight.sessionId === sessionId && (
+ <CindyMakePreflightDialog
+ {...makePreflight}
+ onOpenChange={(open) => !open && setMakePreflight(null)}
+ />
+ )}
{/* 计划模式激活态 chip(输入框上方,与 GoalIndicator 同形)。-mb-2 抵一部分
root gap-4,让 chip 与输入框间距接近 GoalIndicator 的节奏。 */}
{planModeEntry && planModeEnabled && (
diff --git a/apps/desktop/src/renderer/components/settings/CindyMakeSection.tsx b/apps/desktop/src/renderer/components/settings/CindyMakeSection.tsx
index 038596ab81..853567cf1b 100644
--- a/apps/desktop/src/renderer/components/settings/CindyMakeSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/CindyMakeSection.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useState } from 'react';
import { ChevronDown, ChevronRight, GitBranch, Plus, Wrench } from 'lucide-react';
import { useTranslation } from 'react-i18next';
@@ -9,22 +9,22 @@ import { Spinner } from '@/components/ui/spinner';
import { MakeDoctorReportCard } from '@/components/chat/CindyMakeDoctorCard';
import { CindyMakeSourceDetails } from '@/components/cindy-make/CindyMakeSourceDetails';
import { CindyMakeCreateDialog } from '@/components/cindy-make/CindyMakeCreateDialog';
+import { CindyMakeDependencyProgress } from '@/components/cindy-make/CindyMakeDependencyProgress';
+import { CindyMakeTasksPanel } from '@/components/cindy-make/CindyMakeTasksPanel';
+import { useCindyMakeState } from '@/lib/cindyMakeState';
import { cancelMakeDoctor, startMakeDoctor } from '@/lib/cindyMakeDoctor';
import { useCindyMakeSettings } from '@/lib/cindyMakeSettings';
import { toast } from '@/lib/toast';
-import type {
- CindyMakeGlobalState,
- MakeDoctorReport,
- MakeSourceStatus,
-} from '../../../shared/cindyMakeDoctor';
+import type { MakeDoctorReport, MakeSourceStatus } from '../../../shared/cindyMakeDoctor';
export function CindyMakeSection() {
const { t } = useTranslation();
const { forceManagedTools, setForceManagedTools } = useCindyMakeSettings();
const [createOpen, setCreateOpen] = useState(false);
const [report, setReport] = useState<MakeDoctorReport>();
- const [backgroundPreparation, setBackgroundPreparation] = useState<MakeDoctorReport>();
- const environmentSelection = useRef(0);
+ const makeState = useCindyMakeState();
+ const [dismissedPreparationId, setDismissedPreparationId] = useState<string>();
+ const [trackedPreparationId, setTrackedPreparationId] = useState<string>();
const [checkVersion, setCheckVersion] = useState(0);
const [runMode, setRunMode] = useState<'check' | 'prepare'>('check');
const [runVersion, setRunVersion] = useState(0);
@@ -32,65 +32,15 @@ export function CindyMakeSection() {
makeAction: 'prepare-source' | 'clear-source';
forceManagedTools: boolean;
}>();
- // Source state is global (Main owns one shared job): the initial read returns
- // live progress when something is running, and the broadcast keeps every
- // window current whether Settings or the /cindy-make workflow started it.
- const [sourceStatus, setSourceStatus] = useState<MakeSourceStatus>();
+ const sourceStatus = makeState.source;
const [sourceRunPending, setSourceRunPending] = useState(false);
const { confirm } = useConfirmDialog();
useEffect(() => {
- let active = true;
- let latestPush: CindyMakeGlobalState | undefined;
- const selection = environmentSelection.current;
- setBackgroundPreparation(undefined);
- const applyState = (state: CindyMakeGlobalState, restoreCompletion = false) => {
- if (!active) return;
- const snapshot = state.environmentPrepare;
- if (!snapshot || (snapshot.report.forceManagedTools === true) !== forceManagedTools) return;
- setBackgroundPreparation((current) =>
- snapshot.active || restoreCompletion || current?.runId === snapshot.report.runId
- ? snapshot.report
- : current,
- );
- };
- const unsubscribe = window.electronAPI.onCindyMakeState?.((state) => {
- latestPush = state;
- applyState(state);
- });
- Promise.resolve(window.electronAPI.getCindyMakeState?.())
- .then((state) => {
- if (!state || selection !== environmentSelection.current) return;
- if (!latestPush) applyState(state);
- else if (
- state.environmentPrepare?.active &&
- latestPush.environmentPrepare?.report.runId === state.environmentPrepare.report.runId
- )
- applyState(latestPush, true);
- })
- .catch(() => undefined);
- return () => {
- active = false;
- unsubscribe?.();
- };
- }, [forceManagedTools]);
- useEffect(() => {
- let active = true;
- const unsubscribe =
- window.electronAPI.onCindyMakeSourceStatus?.((status) => {
- if (!active) return;
- setSourceStatus(status);
- if (status.status !== 'preparing') setSourceRunPending(false);
- }) ?? (() => {});
- Promise.resolve(window.electronAPI.getCindyMakeSourceStatus?.())
- .then((status) => {
- if (active && status) setSourceStatus((current) => current ?? status);
- })
- .catch(() => undefined);
- return () => {
- active = false;
- unsubscribe();
- };
+ void window.electronAPI.getCindyMakeSourceStatus?.().catch(() => undefined);
}, []);
+ useEffect(() => {
+ if (sourceStatus?.status !== 'preparing') setSourceRunPending(false);
+ }, [sourceStatus]);
useEffect(() => {
if (!sourceRun) return;
const controller = new AbortController();
@@ -100,17 +50,7 @@ export function CindyMakeSection() {
// catches a start that never reached Main (e.g. the IPC itself failed).
if (sourceReport.status === 'running' || sourceReport.source) return;
setSourceRunPending(false);
- setSourceStatus((current) =>
- current && current.status === 'preparing'
- ? {
- ...current,
- status: sourceReport.status === 'cancelled' ? 'cancelled' : 'failed',
- error: sourceReport.status === 'cancelled' ? 'cancelled' : 'gitFailed',
- phase: undefined,
- progress: undefined,
- }
- : current,
- );
+ toast.error(t('cindyMakeDoctor.failed'));
},
undefined,
'cindy-make',
@@ -132,7 +72,31 @@ export function CindyMakeSection() {
return () => controller.abort();
}, [forceManagedTools, checkVersion, runMode, runVersion]);
const sourceBusy = sourceRunPending || sourceStatus?.status === 'preparing';
- const displayReport = backgroundPreparation ?? report;
+ const preparation = makeState.environmentPrepare;
+ const check = makeState.environmentCheck;
+ useEffect(() => {
+ if (
+ preparation?.active &&
+ (preparation.report.forceManagedTools === true) === forceManagedTools &&
+ preparation.report.runId !== dismissedPreparationId
+ )
+ setTrackedPreparationId(preparation.report.runId);
+ }, [
+ preparation?.active,
+ preparation?.report.runId,
+ preparation?.report.forceManagedTools,
+ forceManagedTools,
+ dismissedPreparationId,
+ ]);
+ const displayReport =
+ preparation &&
+ (preparation.active || preparation.report.runId === trackedPreparationId) &&
+ (preparation.report.forceManagedTools === true) === forceManagedTools &&
+ preparation.report.runId !== dismissedPreparationId
+ ? preparation.report
+ : check && (check.report.forceManagedTools === true) === forceManagedTools
+ ? check.report
+ : report;
return (
<div className="flex flex-col gap-[18px]">
@@ -168,6 +132,7 @@ export function CindyMakeSection() {
// Toggling the developer switch is a diagnostic recheck. Never
// let it restart an in-progress preparation run implicitly.
setRunMode('check');
+ setTrackedPreparationId(undefined);
setForceManagedTools(checked);
}}
aria-label={t('settings.cindyMake.forceManaged.ariaLabel')}
@@ -190,8 +155,7 @@ export function CindyMakeSection() {
showSteps={false}
alwaysAllowRecheck
onPrepare={() => {
- environmentSelection.current += 1;
- setBackgroundPreparation(undefined);
+ setDismissedPreparationId(undefined);
setRunMode('prepare');
setRunVersion((version) => version + 1);
}}
@@ -209,8 +173,8 @@ export function CindyMakeSection() {
);
}}
onRecheck={() => {
- environmentSelection.current += 1;
- setBackgroundPreparation(undefined);
+ setDismissedPreparationId(preparation?.report.runId);
+ setTrackedPreparationId(undefined);
setRunMode('check');
setCheckVersion((version) => version + 1);
}}
@@ -252,6 +216,12 @@ export function CindyMakeSection() {
}}
/>
)}
+ {Object.keys(makeState.tasks ?? {}).length > 0 && (
+ <CindyMakeTasksPanel
+ reports={Object.values(makeState.tasks ?? {})}
+ taskActions={makeState.taskActions}
+ />
+ )}
</div>
);
}
@@ -272,6 +242,9 @@ function CindyMakeSourceStatusCard({
const { t } = useTranslation();
const [expanded, setExpanded] = useState(true);
const displayStatus = preparing ? 'preparing' : status.status;
+ // A click is pending before Main publishes the new run. Never reuse the last
+ // run's phase, counters or error in that window.
+ const activeStatus = preparing && status.status === 'preparing' ? status : undefined;
const statusClass =
displayStatus === 'ready'
? 'text-[var(--status-success)]'
@@ -317,32 +290,35 @@ function CindyMakeSourceStatusCard({
<dt className="inline font-medium">{t('settings.cindyMake.source.path')}: </dt>
<dd className="inline break-all font-mono">{status.path}</dd>
</div>
- {status.error && (
- <div className="text-[var(--status-danger)]">
- {t(`cindyMake.source.errors.${status.error}`)}
- </div>
- )}
</dl>
- {preparing && status.progress && (
- <div className="space-y-1 text-12 text-[var(--text-secondary)]" aria-live="polite">
- <div className="flex items-center gap-2">
- <Spinner size={14} />
- <span>{t(`cindyMake.source.gitProgress.${status.progress.stage}`)}</span>
- <span className="text-[var(--text-tertiary)]">({status.progress.percent}%)</span>
- </div>
- {status.progress.message && (
- <p className="break-all pl-5 font-mono text-11 text-[var(--text-tertiary)]">
- {status.progress.message}
- </p>
- )}
- </div>
+ {activeStatus?.progress?.message && (
+ <p className="break-all font-mono text-11 text-[var(--text-tertiary)]">
+ {activeStatus.progress.message}
+ </p>
)}
</div>
)}
<div className="flex flex-wrap items-center justify-between gap-3 border-t border-[var(--border-default)] px-4 py-3">
- <div className={`min-w-0 flex-1 text-13 ${statusClass}`} role="status">
- {t(`settings.cindyMake.source.status.${displayStatus}`)}
- {preparing && status.phase ? ` · ${t(`cindyMake.source.phase.${status.phase}`)}` : ''}
+ <div className={`min-w-0 flex-1 space-y-1 text-13 ${statusClass}`} role="status">
+ <div>
+ {t(`settings.cindyMake.source.status.${displayStatus}`)}
+ {activeStatus?.phase ? ` · ${t(`cindyMake.source.phase.${activeStatus.phase}`)}` : ''}
+ {activeStatus?.progress && (
+ <>
+ {' · '}
+ <span>{t(`cindyMake.source.gitProgress.${activeStatus.progress.stage}`)}</span>{' '}
+ <span>({activeStatus.progress.percent}%)</span>
+ </>
+ )}
+ </div>
+ {!preparing && status.error && <p>{t(`cindyMake.source.errors.${status.error}`)}</p>}
+ {(activeStatus?.phase === 'installing' || activeStatus?.phase === 'caching') && (
+ <CindyMakeDependencyProgress
+ progress={activeStatus.dependencies}
+ running={activeStatus.phase === 'installing'}
+ cacheOnly={activeStatus.phase === 'caching'}
+ />
+ )}
</div>
<div className="flex shrink-0 flex-wrap justify-end gap-2">
<Button variant="secondary" onClick={openSourceDir}>
@@ -358,7 +334,9 @@ function CindyMakeSourceStatusCard({
{t(
status.status === 'ready'
? 'settings.cindyMake.source.update'
- : 'settings.cindyMake.source.prepare',
+ : status.status === 'failed' || status.status === 'cancelled'
+ ? 'settings.cindyMake.source.retry'
+ : 'settings.cindyMake.source.prepare',
)}
</Button>
)}
diff --git a/apps/desktop/src/renderer/components/settings/__tests__/CindyMakeSection.test.tsx b/apps/desktop/src/renderer/components/settings/__tests__/CindyMakeSection.test.tsx
index 28e55b3204..9bc0ded5f7 100644
--- a/apps/desktop/src/renderer/components/settings/__tests__/CindyMakeSection.test.tsx
+++ b/apps/desktop/src/renderer/components/settings/__tests__/CindyMakeSection.test.tsx
@@ -5,13 +5,21 @@ import { MemoryRouter } from 'react-router-dom';
import { CindyMakeSection } from '../CindyMakeSection';
import { startMakeDoctor } from '@/lib/cindyMakeDoctor';
import { setCindyMakeForceManagedTools } from '@/lib/cindyMakeSettings';
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
import type {
CindyMakeGlobalState,
MakeDoctorReport,
MakeSourceStatus,
} from '../../../../shared/cindyMakeDoctor';
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+vi.mock('react-i18next', () => ({
+ useTranslation: () => ({
+ t: (key: string, values?: { resolved: number; reused: number; downloaded: number }) =>
+ key === 'cindyMake.source.cacheProgress' && values
+ ? `${key} ${values.resolved} / ${values.reused} / ${values.downloaded}`
+ : key,
+ }),
+}));
vi.mock('@/lib/toast', () => ({ toast: { error: vi.fn() } }));
vi.mock('@/components/ui/confirm-dialog-provider', () => ({
useConfirmDialog: () => ({
@@ -30,7 +38,10 @@ function harness() {
let globalState: CindyMakeGlobalState = {};
const runs = new Map<string, (result: Result) => void>();
const api = {
- getCindyMakeState: vi.fn(async () => globalState),
+ getCindyMakeState: vi.fn(async (): Promise<CindyMakeGlobalState> => ({
+ ...globalState,
+ source: globalState.source ?? (await api.getCindyMakeSourceStatus()),
+ })),
onCindyMakeState: (listener: (state: CindyMakeGlobalState) => void) => {
stateListeners.add(listener);
return () => {
@@ -65,7 +76,14 @@ function harness() {
getCindyMakeState: api.getCindyMakeState,
onCindyMakeState: api.onCindyMakeState,
openCindyMakeToolsDir: api.openCindyMakeToolsDir,
- getCindyMakeSourceStatus: api.getCindyMakeSourceStatus,
+ getCindyMakeSourceStatus: async () => {
+ const source = await api.getCindyMakeSourceStatus();
+ if (source) {
+ globalState = { ...globalState, source };
+ for (const listener of stateListeners) listener(globalState);
+ }
+ return source;
+ },
openCindyMakeSourceDir: api.openCindyMakeSourceDir,
onCindyMakeSourceStatus: api.onCindyMakeSourceStatus,
cancelCindyMakeSource: api.cancelCindyMakeSource,
@@ -75,6 +93,8 @@ function harness() {
const pushSource = async (status: MakeSourceStatus) => {
await act(async () => {
for (const listener of sourceListeners) listener(status);
+ globalState = { ...globalState, source: status };
+ for (const listener of stateListeners) listener(globalState);
});
};
const complete = async (
@@ -103,6 +123,7 @@ function harness() {
}
beforeEach(() => {
+ setDataOwnerGeneration('settings-make-test-owner');
vi.stubEnv('DEV', true);
setCindyMakeForceManagedTools(false);
});
@@ -114,6 +135,43 @@ afterEach(() => {
});
describe('Settings > Cindy Make', () => {
+ it.each(['missing', 'passed'] as const)(
+ 'shows the new %s check instead of a completed preparation from before entry',
+ async (status) => {
+ const environment = harness();
+ const preparation: MakeDoctorReport = {
+ runId: 'historical-preparation',
+ mode: 'prepare',
+ platform: 'win32',
+ arch: 'x64',
+ status: status === 'missing' ? 'completed' : 'failed',
+ checks: [{ id: 'node', status: status === 'missing' ? 'passed' : 'missing' }],
+ };
+ await environment.pushState({ environmentPrepare: { active: false, report: preparation } });
+ render(<CindyMakeSection />);
+ const runId = environment.starts()[0][1].doctorRunId!;
+ await environment.complete(runId, '', [{ id: 'node', status }]);
+ await environment.pushState({
+ environmentPrepare: { active: false, report: preparation },
+ environmentCheck: {
+ active: false,
+ report: {
+ ...preparation,
+ runId,
+ mode: 'check',
+ status: 'completed',
+ checks: [{ id: 'node', status }],
+ },
+ },
+ });
+ expect(screen.getByRole('status').textContent).toContain(
+ status === 'missing' ? 'cindyMakeDoctor.needsAttention' : 'cindyMakeDoctor.passed',
+ );
+ expect(screen.queryByText('cindyMake.prepare.passed')).toBeNull();
+ expect(screen.queryByText('cindyMake.prepare.failed')).toBeNull();
+ },
+ );
+
it('restores a background installation after reentry, keeps completion, and stops the real run', async () => {
const environment = harness();
const first = render(<CindyMakeSection />);
@@ -210,7 +268,7 @@ describe('Settings > Cindy Make', () => {
});
});
- it('restores completion that arrives before the initial active snapshot', async () => {
+ it('keeps the fresh check when an unobserved preparation completes before a stale active snapshot', async () => {
const environment = harness();
let resolveSnapshot!: (state: CindyMakeGlobalState) => void;
environment.api.getCindyMakeState.mockImplementationOnce(
@@ -244,8 +302,9 @@ describe('Settings > Cindy Make', () => {
},
}),
);
- expect(screen.getByRole('status').textContent).toContain('cindyMake.prepare.passed');
- expect(screen.queryByText('cindyMake.prepare.install')).toBeNull();
+ expect(screen.getByRole('status').textContent).toContain('cindyMakeDoctor.needsAttention');
+ expect(screen.getByText('cindyMake.prepare.install')).toBeTruthy();
+ expect(screen.queryByText('cindyMake.prepare.stop')).toBeNull();
});
it('does not let a delayed initial snapshot undo an explicit recheck', async () => {
@@ -360,6 +419,8 @@ describe('Settings > Cindy Make', () => {
h.api.openCindyMakeSourceDir = vi.fn(async () => ({ success: true }));
vi.stubGlobal('electronAPI', {
maker: h.api,
+ getCindyMakeState: h.api.getCindyMakeState,
+ onCindyMakeState: h.api.onCindyMakeState,
openCindyMakeToolsDir: h.api.openCindyMakeToolsDir,
getCindyMakeSourceStatus: h.api.getCindyMakeSourceStatus,
openCindyMakeSourceDir: h.api.openCindyMakeSourceDir,
@@ -404,7 +465,7 @@ describe('Settings > Cindy Make', () => {
expect(h.api.openCindyMakeSourceDir).toHaveBeenCalledTimes(1);
});
- it.each(['cloning', 'installing'] as const)(
+ it.each(['waiting', 'checkingRemote', 'checkingLocal', 'cloning', 'installing'] as const)(
'shows a source job %s elsewhere and stops it from Settings',
async (phase) => {
const h = harness();
@@ -428,11 +489,56 @@ describe('Settings > Cindy Make', () => {
// Settings itself never started a doctor run for this job.
expect(h.starts().filter(([name]) => name === 'cindy-make')).toHaveLength(0);
await h.pushSource({ status: 'cancelled', path: 'C:\\managed\\source', error: 'cancelled' });
- expect(within(sourceCard).getByText('settings.cindyMake.source.prepare')).toBeTruthy();
+ expect(within(sourceCard).getByText('settings.cindyMake.source.retry')).toBeTruthy();
expect(within(sourceCard).getByText('settings.cindyMake.source.reset')).toBeTruthy();
},
);
+ it.each([
+ ['failed', 'installFailed'],
+ ['cancelled', 'cancelled'],
+ ] as const)(
+ 'keeps a restored %s result visible when collapsed, until retry starts',
+ async (status, error) => {
+ const h = harness();
+ const source: MakeSourceStatus = {
+ status,
+ error,
+ path: '/managed/source',
+ phase: 'caching',
+ dependencies: { resolved: 21, reused: 12, downloaded: 9, added: 0 },
+ };
+ h.api.getCindyMakeSourceStatus.mockResolvedValue(source);
+ render(<CindyMakeSection />);
+ const sourceCard = await screen.findByRole('region', {
+ name: 'settings.cindyMake.source.title',
+ });
+ fireEvent.click(
+ within(sourceCard).getByRole('button', { name: 'settings.cindyMake.source.title' }),
+ );
+ expect(within(sourceCard).getByRole('status').textContent).toContain(
+ 'settings.cindyMake.source.status.' + status,
+ );
+ expect(within(sourceCard).getByRole('status').textContent).toContain(
+ 'cindyMake.source.errors.' + error,
+ );
+ fireEvent.click(within(sourceCard).getByText('settings.cindyMake.source.retry'));
+ expect(within(sourceCard).getByRole('status').textContent).toBe(
+ 'settings.cindyMake.source.status.preparing',
+ );
+ await h.pushSource({ status: 'preparing', path: source.path, phase: 'checkingRemote' });
+ expect(within(sourceCard).getByRole('status').textContent).toContain(
+ 'cindyMake.source.phase.checkingRemote',
+ );
+ expect(within(sourceCard).queryByText('cindyMake.source.errors.' + error)).toBeNull();
+ await h.pushSource({ status: 'ready', path: source.path });
+ expect(within(sourceCard).getByRole('status').textContent).toBe(
+ 'settings.cindyMake.source.status.ready',
+ );
+ expect(within(sourceCard).getByText('settings.cindyMake.source.update')).toBeTruthy();
+ },
+ );
+
it('keeps the clear action for a failed checkout so a dirty tree has a way out', async () => {
const h = harness();
const source: MakeSourceStatus = {
@@ -446,6 +552,8 @@ describe('Settings > Cindy Make', () => {
h.api.getCindyMakeSourceStatus = vi.fn(async () => source);
vi.stubGlobal('electronAPI', {
maker: h.api,
+ getCindyMakeState: h.api.getCindyMakeState,
+ onCindyMakeState: h.api.onCindyMakeState,
openCindyMakeToolsDir: h.api.openCindyMakeToolsDir,
getCindyMakeSourceStatus: h.api.getCindyMakeSourceStatus,
openCindyMakeSourceDir: vi.fn(async () => ({ success: true })),
@@ -467,6 +575,8 @@ describe('Settings > Cindy Make', () => {
h.api.getCindyMakeSourceStatus = vi.fn(async () => source);
vi.stubGlobal('electronAPI', {
maker: h.api,
+ getCindyMakeState: h.api.getCindyMakeState,
+ onCindyMakeState: h.api.onCindyMakeState,
openCindyMakeToolsDir: h.api.openCindyMakeToolsDir,
getCindyMakeSourceStatus: h.api.getCindyMakeSourceStatus,
openCindyMakeSourceDir: h.api.openCindyMakeSourceDir,
@@ -486,6 +596,8 @@ describe('Settings > Cindy Make', () => {
h.api.getCindyMakeSourceStatus = vi.fn(async () => ready);
vi.stubGlobal('electronAPI', {
maker: h.api,
+ getCindyMakeState: h.api.getCindyMakeState,
+ onCindyMakeState: h.api.onCindyMakeState,
openCindyMakeToolsDir: h.api.openCindyMakeToolsDir,
getCindyMakeSourceStatus: h.api.getCindyMakeSourceStatus,
openCindyMakeSourceDir: h.api.openCindyMakeSourceDir,
@@ -512,6 +624,8 @@ describe('Settings > Cindy Make', () => {
h.api.getCindyMakeSourceStatus = vi.fn(async () => source);
vi.stubGlobal('electronAPI', {
maker: h.api,
+ getCindyMakeState: h.api.getCindyMakeState,
+ onCindyMakeState: h.api.onCindyMakeState,
openCindyMakeToolsDir: h.api.openCindyMakeToolsDir,
getCindyMakeSourceStatus: h.api.getCindyMakeSourceStatus,
openCindyMakeSourceDir: h.api.openCindyMakeSourceDir,
@@ -539,6 +653,10 @@ describe('Settings > Cindy Make', () => {
const previousEnvironment = environmentCard.textContent;
const sourceCard = screen.getByRole('region', { name: 'settings.cindyMake.source.title' });
fireEvent.click(within(sourceCard).getByText('settings.cindyMake.source.update'));
+ fireEvent.click(
+ within(sourceCard).getByRole('button', { name: 'settings.cindyMake.source.title' }),
+ );
+ expect(within(sourceCard).queryByText('settings.cindyMake.source.path')).toBeNull();
expect(environmentCard.textContent).toBe(previousEnvironment);
await h.pushSource({
...source,
@@ -549,12 +667,28 @@ describe('Settings > Cindy Make', () => {
expect(within(sourceCard).queryByRole('progressbar')).toBeNull();
expect(within(sourceCard).getByText('cindyMake.source.gitProgress.receiving')).toBeTruthy();
expect(within(sourceCard).getByText(/cindyMake.source.phase.fetching/)).toBeTruthy();
+ expect(within(sourceCard).getByRole('status').textContent).toContain('(43%)');
+ await h.pushSource({
+ ...source,
+ status: 'preparing',
+ phase: 'caching',
+ dependencies: { resolved: 21, reused: 12, downloaded: 9, added: 0 },
+ });
+ expect(within(sourceCard).getByRole('status').textContent).toContain(
+ 'cindyMake.source.phase.caching',
+ );
+ expect(within(sourceCard).getByRole('status').textContent).toContain(
+ 'cindyMake.source.cacheProgress 21 / 12 / 9',
+ );
+ expect(within(sourceCard).queryByText('(43%)')).toBeNull();
+ expect(within(sourceCard).queryByText('cindyMake.code.dependencyActivity.packages')).toBeNull();
expect(environmentCard.textContent).toBe(previousEnvironment);
await h.pushSource({ ...source, status: 'failed', error: 'gitUnavailable' });
expect(within(sourceCard).getByText('cindyMake.source.errors.gitUnavailable')).toBeTruthy();
expect(within(sourceCard).queryByRole('progressbar')).toBeNull();
expect(environmentCard.textContent).toBe(previousEnvironment);
- fireEvent.click(within(sourceCard).getByText('settings.cindyMake.source.prepare'));
+ fireEvent.click(within(sourceCard).getByText('settings.cindyMake.source.retry'));
+ expect(within(sourceCard).queryByText('cindyMake.source.errors.gitUnavailable')).toBeNull();
expect(h.starts()).toHaveLength(3);
expect(
h
@@ -593,6 +727,36 @@ describe('Settings > Cindy Make', () => {
).toBe(false);
});
+ it('does not restore a previously tracked completion after switching check modes back', async () => {
+ const environment = harness();
+ render(<CindyMakeSection />);
+ await environment.complete(environment.starts()[0][1].doctorRunId!, '');
+ const preparation: MakeDoctorReport = {
+ runId: 'tracked-preparation',
+ mode: 'prepare',
+ platform: 'win32',
+ arch: 'x64',
+ status: 'running',
+ checks: [{ id: 'node', status: 'installing' }],
+ };
+ await environment.pushState({ environmentPrepare: { active: true, report: preparation } });
+ await environment.pushState({
+ environmentPrepare: {
+ active: false,
+ report: { ...preparation, status: 'completed', checks: [{ id: 'node', status: 'passed' }] },
+ },
+ });
+ expect(screen.getByRole('status').textContent).toContain('cindyMake.prepare.passed');
+ fireEvent.click(screen.getByRole('switch'));
+ await environment.complete(environment.starts()[1][1].doctorRunId!, '');
+ fireEvent.click(screen.getByRole('switch'));
+ await environment.complete(environment.starts()[2][1].doctorRunId!, '', [
+ { id: 'node', status: 'missing' },
+ ]);
+ expect(screen.getByRole('status').textContent).toContain('cindyMakeDoctor.needsAttention');
+ expect(screen.getByText('cindyMake.prepare.install')).toBeTruthy();
+ });
+
it('changing the switch leaves the old check running, ignores late results, and carries the option into the chat command', async () => {
const h = harness();
const view = render(<CindyMakeSection />);
diff --git a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
index f59b5ff819..3cd541f6ce 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
@@ -60,6 +60,9 @@ import { Spinner } from '@/components/ui/spinner';
import { setRemoteReceiptDisplayReady } from '@/lib/sessionAttentionStore';
import { shortSessionId } from '@/lib/sessionId';
import { ChatInput } from '@/components/new-chat/ChatInput';
+import { CindyMakeComposerMask } from '@/components/cindy-make/CindyMakeComposerMask';
+import { getCindyMakeComposerPhase } from '@/lib/cindyMakeComposer';
+import { useCindyMakeState } from '@/lib/cindyMakeState';
import { GoalIndicator } from '@/components/new-chat/GoalIndicator';
import { PinnedPlanPanel } from '@/components/new-chat/PinnedPlanPanel';
import { sessionsStore } from '@/lib/sessionsStore';
@@ -1764,6 +1767,23 @@ export function CCAgentSessionView({
updateQueueItem,
chatDisplaySnapshot,
} = useCCAgentChat(sessionId, handleTitleUpdate, { chatRealtime });
+ const makeState = useCindyMakeState();
+ const cindyMakeComposerPhase = useMemo(
+ () =>
+ getCindyMakeComposerPhase({
+ session,
+ report: remoteDeviceId
+ ? undefined
+ : Object.values(makeState.tasks ?? {}).find(
+ (report) => report.task?.sessionId === sessionId,
+ ),
+ messages,
+ historyLoaded,
+ busy: isAgentBusy,
+ error,
+ }),
+ [session, sessionId, remoteDeviceId, makeState, messages, historyLoaded, isAgentBusy, error],
+ );
useEffect(() => {
if (!sessionId || !isOrcaLeadSessionView || !historyLoaded) return;
const recoveredAssignment = getRecoverableDeferredUiAssignment({
@@ -3377,6 +3397,7 @@ export function CCAgentSessionView({
},
) => {
if (readOnly) return false;
+ if (cindyMakeComposerPhase) return false;
const deliveryMode = opts?.deliveryMode ?? 'queue';
const originalMessage = message;
const navigationRequestVersion =
@@ -3659,6 +3680,7 @@ export function CCAgentSessionView({
vendorAuthGate,
remoteDeviceId,
sessionHandoffPreparing,
+ cindyMakeComposerPhase,
],
);
@@ -3828,9 +3850,10 @@ export function CCAgentSessionView({
]);
const handleBeforeVoiceInputStart = useCallback(async () => {
+ if (cindyMakeComposerPhase) return false;
const { proceed } = await vendorAuthGate.checkAndConfirm('codex', { purpose: 'voice-input' });
return proceed;
- }, [vendorAuthGate]);
+ }, [vendorAuthGate, cindyMakeComposerPhase]);
// M32: Retry — ErrorBanner 的 retryText 现在只是兼容展示值。真正的
// recovery target 由 main coordinator 持有,避免把已发出的文本重新走普通
@@ -4431,6 +4454,7 @@ export function CCAgentSessionView({
const shareSelectionBlocked =
Boolean(sessionBinding.attached) ||
worktreePreparing ||
+ Boolean(cindyMakeComposerPhase) ||
Boolean(
pendingPlanReview ||
pendingPermission ||
@@ -4583,6 +4607,7 @@ export function CCAgentSessionView({
if (hasSplitGroupSessionType(e.dataTransfer.types)) return;
e.preventDefault();
e.stopPropagation();
+ if (cindyMakeComposerPhase) return;
dragCounterRef.current += 1;
if (dragCounterRef.current === 1) setIsDragOver(true);
}}
@@ -4590,7 +4615,7 @@ export function CCAgentSessionView({
if (hasSplitGroupSessionType(e.dataTransfer.types)) return;
e.preventDefault();
e.stopPropagation();
- e.dataTransfer.dropEffect = 'copy';
+ e.dataTransfer.dropEffect = cindyMakeComposerPhase ? 'none' : 'copy';
}}
onDragLeave={(e) => {
if (hasSplitGroupSessionType(e.dataTransfer.types)) return;
@@ -4605,6 +4630,7 @@ export function CCAgentSessionView({
e.stopPropagation();
dragCounterRef.current = 0;
setIsDragOver(false);
+ if (cindyMakeComposerPhase) return;
// .cindy / .cshare 已被窗口级 capture 接管(装入 / 导入链路),
// 只清理拖拽 UI 状态,不当附件消费。
if (isGlobalDropIntercepted(e.nativeEvent)) return;
@@ -5135,9 +5161,10 @@ export function CCAgentSessionView({
既处理不了确认又无法继续发送或排队消息。
优先级 (高 → 低):
1. attached (远程接管中) → TakeoverMask (90px)
- 2. worktreePreparing → WorktreeCreatingOverlay (90px, 视觉同款)
- 3. 默认 → ChatInput
- 两个 mask 共用 TakeoverMask 同款外形 (90px h / 12px round / sidebar
+ 2. Cindy Make 准备 / 首次执行 → CindyMakeComposerMask (90px, 视觉同款)
+ 3. worktreePreparing → WorktreeCreatingOverlay (90px, 视觉同款)
+ 4. 默认 → ChatInput
+ 这些 mask 共用 TakeoverMask 同款外形 (90px h / 12px round / sidebar
border), 切到 ChatInput 时高度变大, 与 takeover 收回回到 ChatInput
的体验一致。 */}
{pendingPlanReview ||
@@ -5153,6 +5180,11 @@ export function CCAgentSessionView({
userId={sessionBinding.identity?.userId ?? null}
displayName={sessionBinding.displayName}
/>
+ ) : cindyMakeComposerPhase ? (
+ <CindyMakeComposerMask
+ phase={cindyMakeComposerPhase}
+ onStop={!readOnly && isAgentBusy ? handleStopSession : undefined}
+ />
) : worktreePreparing && smoothedBranchName ? (
<WorktreeCreatingOverlay branchName={smoothedBranchName} />
) : shareSelectionActive && sessionId ? (
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionCard.tsx b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionCard.tsx
index e8608aafaf..6df1bb3746 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionCard.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionCard.tsx
@@ -97,6 +97,8 @@ import { projectSidebarSessionActivity, resolveSidebarRightStatus } from './side
import { Tip } from '@/components/ui/tooltip';
import { SidebarRightStatusIndicator } from './SidebarRightStatusIndicator';
import { shouldPrefetchSessionOnPointerDown } from './sessionSwitchPrefetch';
+import { useCindyMakePreparing } from './useCindyMakePreparing';
+import { CINDY_MAKE_SESSION_SOURCE } from '../../../../shared/cindyMakeSession';
import {
finishSessionDrag,
isSplitGroupDragSource,
@@ -162,6 +164,7 @@ export const SessionCard = memo(function SessionCard({
}: SessionCardProps) {
const { t } = useTranslation();
const navigate = useNavigate();
+ const cindyMakePreparing = useCindyMakePreparing(session);
// mod+1..9 序号徽标:模块 store 按 sessionId 精准订阅,非按住态恒为 null。
const ordinalBadgeLabel = useSessionOrdinalBadge(session.id);
// 灵动岛同源的 per-session 实时活动(执行中逐步活动 + 等待交互态)。
@@ -181,7 +184,9 @@ export const SessionCard = memo(function SessionCard({
liveActivity: session.deviceLinkDeviceId ? remoteActivity : islandActivity,
attentionKind,
isUrgentFromContext: isUrgentFromContext || remoteSchedule?.hasUnreadFailedRun === true,
- isRunning: session.deviceLinkDeviceId ? remoteActivity?.phase === 'running' : isRunning,
+ isRunning: session.deviceLinkDeviceId
+ ? remoteActivity?.phase === 'running'
+ : isRunning || cindyMakePreparing != null,
hasAttentionNotification: hasAttentionNotification || remoteSchedule?.hasUnreadRun === true,
});
const leftIconRunning = sessionActivity.currentTurnActive === true;
@@ -202,7 +207,14 @@ export const SessionCard = memo(function SessionCard({
const boundSchedules = useSessionBoundSchedules(session.id);
const showScheduleBindingBadge = boundSchedules.length > 0;
const showAutomationTimer = !showScheduleBindingBadge && isAutomationGenerated;
- const displayTitle = getSessionDisplayTitle(session, t('ccAgent.common.unnamedSession'));
+ const displayTitle = getSessionDisplayTitle(
+ session,
+ t(
+ session.source === CINDY_MAKE_SESSION_SOURCE
+ ? 'cindyMake.code.taskName'
+ : 'ccAgent.common.unnamedSession',
+ ),
+ );
const canHighlightDisplayTitle = canHighlightSessionDisplayTitle(session);
const isArchived = session.status === 'archived';
const canQuickArchive = !isArchived && !isEmpty && !remoteWritesBlocked;
@@ -239,8 +251,11 @@ export const SessionCard = memo(function SessionCard({
islandActivity?.phase === 'running' && islandActivity.compactDetail
? islandActivity.compactDetail
: null;
- const listPreview = awaitingText ?? runningDetail ?? bodyPreview;
- const cardPreview = awaitingText ?? bodyPreview;
+ const preparationText = cindyMakePreparing
+ ? t('cindyMake.code.phases.' + cindyMakePreparing)
+ : null;
+ const listPreview = awaitingText ?? preparationText ?? runningDetail ?? bodyPreview;
+ const cardPreview = awaitingText ?? preparationText ?? bodyPreview;
const usesPinnedCardSummary = variant === 'card' && isPinned && Boolean(session.summary);
const cardPreviewLineClamp = usesPinnedCardSummary
? 3
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionItem.tsx b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionItem.tsx
index 0583e4ab70..67c89b370e 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionItem.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionItem.tsx
@@ -106,6 +106,8 @@ import {
startSessionDrag,
} from '../splitGroupDnd';
import { shouldPrefetchSessionOnPointerDown } from './sessionSwitchPrefetch';
+import { useCindyMakePreparing } from './useCindyMakePreparing';
+import { CINDY_MAKE_SESSION_SOURCE } from '../../../../shared/cindyMakeSession';
// Module-level dedup cache for loadScheduleSidebarIndexRuns.
// When many ungrouped automation rows mount simultaneously they all need the
@@ -337,6 +339,7 @@ export const SessionItem = memo(function SessionItem({
insideAutomationGroup = false,
}: SessionItemProps) {
const { t } = useTranslation();
+ const cindyMakePreparing = useCindyMakePreparing(session);
const prRefs = usePrRefsForSession(session.id);
// 任务信息复选(C 期):行右侧信息槽内容,与整理菜单同源共享状态。
const { fields: taskInfoFields } = useTaskInfoFields();
@@ -411,7 +414,9 @@ export const SessionItem = memo(function SessionItem({
liveActivity: session.deviceLinkDeviceId ? remoteActivity : islandActivity,
attentionKind,
isUrgentFromContext: isUrgentFromContext || remoteSchedule?.hasUnreadFailedRun === true,
- isRunning: session.deviceLinkDeviceId ? remoteActivity?.phase === 'running' : isRunning,
+ isRunning: session.deviceLinkDeviceId
+ ? remoteActivity?.phase === 'running'
+ : isRunning || cindyMakePreparing != null,
hasAttentionNotification: hasAttentionNotification || remoteSchedule?.hasUnreadRun === true,
});
const leftIconRunning = sessionActivity.currentTurnActive === true;
@@ -499,7 +504,14 @@ export const SessionItem = memo(function SessionItem({
);
}
}, [effectiveScheduleId, t]);
- const displayTitle = getSessionDisplayTitle(session, t('ccAgent.common.unnamedSession'));
+ const displayTitle = getSessionDisplayTitle(
+ session,
+ t(
+ session.source === CINDY_MAKE_SESSION_SOURCE
+ ? 'cindyMake.code.taskName'
+ : 'ccAgent.common.unnamedSession',
+ ),
+ );
const canHighlightDisplayTitle = canHighlightSessionDisplayTitle(session);
const titleContent =
matchIndices && matchIndices.length > 0 && canHighlightDisplayTitle
@@ -1105,7 +1117,18 @@ export const SessionItem = memo(function SessionItem({
ordinalBadgeLabel != null && 'opacity-0',
)}
>
- {showRightStatus ? (
+ {cindyMakePreparing && rightStatusKind === 'running' ? (
+ <span
+ className={cn(
+ 'max-w-[9rem] truncate text-xs font-normal',
+ isActive
+ ? 'text-sidebar-item-active-foreground/80'
+ : 'text-[var(--cmd-palette-item-meta)]',
+ )}
+ >
+ {t('cindyMake.code.phases.' + cindyMakePreparing)}
+ </span>
+ ) : showRightStatus ? (
<SidebarRightStatusIndicator kind={rightStatusKind} isActive={isActive} />
) : (
// 任务信息复选:按用户勾选拼装 pr / worktree / tokens / cost / time;默认仅
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionStatusIcon.tsx b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionStatusIcon.tsx
index 04b408081b..d0f428222f 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionStatusIcon.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/SessionStatusIcon.tsx
@@ -27,6 +27,7 @@ import { useSessionAttentionKind } from '@/lib/sessionAttentionStore';
import { useSessionAttentionUrgency } from '../contexts/SessionAttentionUrgencyContext';
import { AttentionDot } from '@/components/sidebar/AttentionDot';
import { VendorIcon, agentKindToVendor } from '@/components/sidebar/VendorIcon';
+import { useCindyMakePreparing } from './useCindyMakePreparing';
export interface SessionStatusIconProps {
session: Session;
@@ -70,7 +71,10 @@ export function SessionStatusIcon({
// fire-and-forget 任务期间用户也能看出"这个会话还有活在跑"。per-row
// primitive 订阅(性能不变量同下方 attention hooks)。
const isGhostBusy = useGhostSessionBusy(session.id);
- const isRunning = isAgentRunning || isGhostBusy;
+ // Preparation is task activity before an Agent turn exists. Keep this local
+ // to presentation, including pinned rail icons that have no row projection.
+ const cindyMakePreparing = useCindyMakePreparing(session);
+ const isRunning = isAgentRunning || isGhostBusy || cindyMakePreparing != null;
const vendor = agentKindToVendor(session.agentKind);
const isOrcaLead = isOrcaLeadSession(session);
const isArchived = session.status === 'archived';
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
index ae41d72ff6..669dd6b6a4 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
@@ -11,6 +11,7 @@ import {
within,
} from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cindyMakeState } from '@/lib/cindyMakeState';
import {
applyRemoteSessionActivity,
@@ -240,8 +241,47 @@ describe('SessionCard visual cases', () => {
afterEach(() => {
cleanup();
+ vi.restoreAllMocks();
});
+ it.each(['card', 'list'] as const)(
+ 'keeps %s active during preparation before the Agent starts',
+ (variant) => {
+ const visualCase = sessionCardVisualCases.find((item) => item.id === 'short-idle-cc')!;
+ vi.spyOn(cindyMakeState, 'subscribe').mockReturnValue(() => {});
+ vi.spyOn(cindyMakeState, 'taskForSession').mockReturnValue({
+ runId: 'make-run',
+ platform: 'win32',
+ arch: 'x64',
+ checks: [],
+ status: 'running',
+ task: { sessionId: visualCase.session.id, phase: 'dependencies' },
+ });
+ renderCase(visualCase.id, {
+ variant,
+ isRunning: false,
+ session: { ...visualCase.session, source: 'cindy-make' },
+ });
+ expect(sessionRowEl().querySelector('.session-status-breathing')).not.toBeNull();
+ expect(screen.getByText('cindyMake.code.phases.dependencies')).toBeTruthy();
+ if (variant === 'list') {
+ expect(
+ sessionRowEl().querySelector('[data-sidebar-right-status="running"]'),
+ ).not.toBeNull();
+ }
+
+ cleanup();
+ mocks.pendingPluginSetupSessionIds.add(visualCase.session.id);
+ renderCase(visualCase.id, {
+ variant,
+ isRunning: false,
+ session: { ...visualCase.session, source: 'cindy-make' },
+ });
+ expect(screen.getByText('等待插件设置')).toBeTruthy();
+ expect(screen.queryByText('cindyMake.code.phases.dependencies')).toBeNull();
+ },
+ );
+
it('keeps a broad gallery of title, body, icon, and state combinations', () => {
expect(sessionCardVisualCases.map((item) => item.id)).toEqual([
'short-idle-cc',
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionCardReviewRegressions.test.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionCardReviewRegressions.test.ts
index ba641bd848..cdf42b464b 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionCardReviewRegressions.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionCardReviewRegressions.test.ts
@@ -7,7 +7,10 @@ const sidebarDir = resolve(__dirname, '..');
const sessionCardSource = readFileSync(resolve(sidebarDir, 'SessionCard.tsx'), 'utf8');
const sessionEntryListSource = readFileSync(resolve(sidebarDir, 'SessionEntryList.tsx'), 'utf8');
const sessionItemSource = readFileSync(resolve(sidebarDir, 'SessionItem.tsx'), 'utf8');
-const sessionOrdinalBadgeSource = readFileSync(resolve(sidebarDir, 'sessionOrdinalBadges.tsx'), 'utf8');
+const sessionOrdinalBadgeSource = readFileSync(
+ resolve(sidebarDir, 'sessionOrdinalBadges.tsx'),
+ 'utf8',
+);
const railNavSource = readFileSync(resolve(sidebarDir, 'RailNav.tsx'), 'utf8');
const sessionRenameInputSource = readFileSync(
resolve(sidebarDir, '..', 'SessionRenameInput.tsx'),
@@ -44,7 +47,7 @@ describe('SessionCard review regressions', () => {
it('keeps awaiting text in list mode previews', () => {
expect(sessionCardSource).toContain(
- 'const listPreview = awaitingText ?? runningDetail ?? bodyPreview',
+ 'const listPreview = awaitingText ?? preparationText ?? runningDetail ?? bodyPreview',
);
expect(sessionCardSource).toContain('{listPreview}');
});
@@ -237,11 +240,13 @@ describe('SessionCard review regressions', () => {
it('keeps running card previews stable instead of streaming compact activity text', () => {
expect(sessionCardSource).toContain(
- 'const listPreview = awaitingText ?? runningDetail ?? bodyPreview',
+ 'const listPreview = awaitingText ?? preparationText ?? runningDetail ?? bodyPreview',
+ );
+ expect(sessionCardSource).toContain(
+ 'const cardPreview = awaitingText ?? preparationText ?? bodyPreview',
);
- expect(sessionCardSource).toContain('const cardPreview = awaitingText ?? bodyPreview');
expect(sessionCardSource).not.toContain(
- 'const cardPreview = awaitingText ?? runningDetail ?? bodyPreview',
+ 'const cardPreview = awaitingText ?? preparationText ?? runningDetail ?? bodyPreview',
);
});
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
index 5297c8ac67..cd246c2c5c 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
@@ -32,6 +32,8 @@ import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
import type { Session } from '@/lib/ccAgent.types';
+import { cindyMakeState } from '@/lib/cindyMakeState';
+import type { CindyMakeGlobalState, MakeDoctorReport } from '../../../../../shared/cindyMakeDoctor';
import { addSessionAttention, clearSessionAttention } from '@/lib/sessionAttentionStore';
import { SessionAttentionUrgencyProvider } from '../../contexts/SessionAttentionUrgencyContext';
import { SPLIT_GROUP_SESSION_MIME } from '../../splitGroupDnd';
@@ -45,9 +47,9 @@ const sessionStatusIconSource = readFileSync(
);
vi.mock('../SessionStatusIcon', () => ({
- SessionStatusIcon: ({ session }: { session: { id: string } }) => {
+ SessionStatusIcon: ({ session, isRunning }: { session: { id: string }; isRunning: boolean }) => {
renderCounts.set(session.id, (renderCounts.get(session.id) ?? 0) + 1);
- return null;
+ return createElement('span', { 'data-testid': session.id, 'data-running': isRunning });
},
}));
@@ -167,6 +169,7 @@ beforeEach(() => {
afterEach(() => {
cleanup();
+ vi.restoreAllMocks();
// attention store 是模块级单例,测试间必须清干净,否则串台。
clearSessionAttention('session-a');
clearSessionAttention('session-b');
@@ -174,6 +177,65 @@ afterEach(() => {
// ── 不变量 1:memo 包裹(结构断言 + 源码断言双保险) ──────────────────────────
+describe('SessionItem — Cindy Make preparation', () => {
+ it('shows preparation as activity and redraws only when this task changes phase', () => {
+ let state: CindyMakeGlobalState = {};
+ const listeners = new Set<() => void>();
+ vi.spyOn(cindyMakeState, 'getSnapshot').mockImplementation(() => state);
+ const subscribe = vi.spyOn(cindyMakeState, 'subscribe').mockImplementation((listener) => {
+ listeners.add(listener);
+ return () => {
+ listeners.delete(listener);
+ };
+ });
+ const makeA = { ...sessionA, source: 'cindy-make' as const };
+ const makeB = { ...sessionB, source: 'cindy-make' as const };
+ const ordinary = makeSession('ordinary');
+ const remote = {
+ ...makeSession('remote'),
+ source: 'cindy-make' as const,
+ deviceLinkDeviceId: 'device',
+ };
+ render(rowsElement([makeA, makeB, ordinary, remote], new Set()));
+ expect(subscribe).toHaveBeenCalledTimes(2);
+ const baselineB = renderCounts.get(makeB.id);
+ const baselineOrdinary = renderCounts.get(ordinary.id);
+ const baselineRemote = renderCounts.get(remote.id);
+ let report: MakeDoctorReport = {
+ runId: 'make-run',
+ platform: 'win32',
+ arch: 'x64',
+ checks: [],
+ status: 'running',
+ task: { sessionId: makeA.id, phase: 'workspace' },
+ };
+ const publish = () =>
+ act(() => {
+ state = { tasks: { [report.runId]: report } };
+ listeners.forEach((listener) => listener());
+ });
+ publish();
+ expect(screen.getByTestId(makeA.id).getAttribute('data-running')).toBe('true');
+ expect(screen.getByText('cindyMake.code.phases.workspace')).toBeTruthy();
+ report = { ...report, task: { ...report.task!, phase: 'dependencies' } };
+ publish();
+ expect(screen.getByText('cindyMake.code.phases.dependencies')).toBeTruthy();
+ const baselineA = renderCounts.get(makeA.id);
+ report = { ...report, task: { ...report.task!, dependencies: { added: 42, reused: 200 } } };
+ publish();
+ expect(renderCounts.get(makeA.id)).toBe(baselineA);
+ expect(renderCounts.get(makeB.id)).toBe(baselineB);
+ expect(renderCounts.get(ordinary.id)).toBe(baselineOrdinary);
+ expect(renderCounts.get(remote.id)).toBe(baselineRemote);
+ for (const status of ['failed', 'cancelled', 'completed'] as const) {
+ report = { ...report, status };
+ publish();
+ expect(screen.getByTestId(makeA.id).getAttribute('data-running')).toBe('false');
+ expect(screen.queryByText('cindyMake.code.phases.dependencies')).toBeNull();
+ }
+ });
+});
+
describe('SessionItem — memo 包裹', () => {
it('导出的是 React.memo 组件', () => {
expect((SessionItem as unknown as { $$typeof: symbol }).$$typeof).toBe(
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/useCindyMakePreparing.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/useCindyMakePreparing.ts
new file mode 100644
index 0000000000..7597466fe6
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/useCindyMakePreparing.ts
@@ -0,0 +1,27 @@
+import { useCallback, useSyncExternalStore } from 'react';
+import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { cindyMakeState } from '@/lib/cindyMakeState';
+import type { Session } from '@/lib/ccAgent.types';
+import { CINDY_MAKE_SESSION_SOURCE } from '../../../../shared/cindyMakeSession';
+import type { CindyMakeTaskPreparation } from '../../../../shared/cindyMakeDoctor';
+
+const idle = () => undefined;
+
+export function useCindyMakePreparing(
+ session: Session,
+): CindyMakeTaskPreparation['phase'] | undefined {
+ const generation = getDataOwnerGeneration();
+ const enabled = session.source === CINDY_MAKE_SESSION_SOURCE && !session.deviceLinkDeviceId;
+ const subscribe = useCallback(
+ (listener: () => void) => (enabled ? cindyMakeState.subscribe(listener) : idle),
+ [enabled, generation.dataOwnerId, generation.generation],
+ );
+ // Rows select a primitive for their own task: package counters and other tasks'
+ // progress must not redraw the entire sidebar on every installation update.
+ const getSnapshot = useCallback(() => {
+ if (!enabled) return undefined;
+ const report = cindyMakeState.taskForSession(session.id);
+ return report?.status === 'running' ? report.task?.phase : undefined;
+ }, [enabled, session.id]);
+ return useSyncExternalStore(subscribe, getSnapshot, idle);
+}
diff --git a/apps/desktop/src/renderer/features/right-sidebar/plugins/cindy-make/CindyMakeTabBody.tsx b/apps/desktop/src/renderer/features/right-sidebar/plugins/cindy-make/CindyMakeTabBody.tsx
index 5ce877fd0d..31c94655dc 100644
--- a/apps/desktop/src/renderer/features/right-sidebar/plugins/cindy-make/CindyMakeTabBody.tsx
+++ b/apps/desktop/src/renderer/features/right-sidebar/plugins/cindy-make/CindyMakeTabBody.tsx
@@ -4,7 +4,7 @@ import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
import { MessageStream } from '@/components/chat/MessageStream';
import { makerChatStore } from '@/lib/makerChatStore';
-import { startMakeDoctorInStream } from '@/lib/cindyMakeDoctorStream';
+import { CindyMakePreflightDialog } from '@/components/cindy-make/CindyMakePreflightDialog';
import type { TabKindBodyProps } from '../../types';
import type { CindyMakeState } from './index';
@@ -19,6 +19,7 @@ function useCindyMakeChat(sessionId: string) {
export function CindyMakeTabBody({ ctx }: TabKindBodyProps<CindyMakeState>) {
const { t } = useTranslation();
const [draft, setDraft] = useState('');
+ const [request, setRequest] = useState<string | null>(null);
const chat = useCindyMakeChat(ctx.sessionId);
useEffect(() => {
@@ -28,7 +29,7 @@ export function CindyMakeTabBody({ ctx }: TabKindBodyProps<CindyMakeState>) {
const send = useCallback(() => {
const request = draft.trim();
if (!request || !ctx.workdir || chat.isStreaming) return;
- startMakeDoctorInStream(ctx.sessionId, { command: 'cindy-make', request });
+ setRequest(request);
setDraft('');
}, [chat.isStreaming, ctx.sessionId, ctx.workdir, draft]);
@@ -39,6 +40,14 @@ export function CindyMakeTabBody({ ctx }: TabKindBodyProps<CindyMakeState>) {
return (
<div className="flex h-full min-h-0 flex-col bg-[var(--surface-base)]">
+ {request && (
+ <CindyMakePreflightDialog
+ key={ctx.sessionId}
+ request={request}
+ sessionId={ctx.sessionId}
+ onOpenChange={(open) => !open && setRequest(null)}
+ />
+ )}
<div className="min-h-0 flex-1">
{chat.messages.length === 0 && (
<div className="border-b border-[var(--border-default)] px-4 py-3 text-13 text-[var(--text-secondary)]">
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index a8eca0c801..57c22eaace 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -5689,6 +5689,7 @@
"title": "Personal build source",
"openDir": "Open source folder",
"prepare": "Prepare source",
+ "retry": "Retry Preparation",
"reset": "Clear source",
"update": "Update source",
"preparingAction": "Preparing source",
@@ -5718,6 +5719,36 @@
"ariaLabel": "Test Installation: Ignore System Tools",
"enabledHint": "The card below can test downloading and installing missing Windows tools. Existing Cindy-managed tools are reused. This takes effect immediately and resets on reload or restart; system tools stay unchanged.",
"reportHint": "Installation test is on: portable tools use Cindy-managed copies. Windows compiler tools are shown as missing to test the official installation guide; turn off the switch to check their real status."
+ },
+ "tasks": {
+ "title": "Unfinished builds",
+ "search": "Search build sessions",
+ "noResults": "No matching build sessions",
+ "restore": "Restore and open session",
+ "finish": "Finish build",
+ "delete": "Delete build",
+ "retryCleanup": "Retry cleanup",
+ "finishHint": "After reviewing the changes, finish to merge them into your personal version and clean up the development folder. Conversation history stays in the archived session.",
+ "finishConfirm": "Finish “{{title}}”? Committed changes will be merged into your personal version, the development folder and build branch removed, and the session archived. Uncommitted changes or merge conflicts will prevent cleanup.",
+ "deleteConfirm": "Delete “{{title}}”? This stops the build, deletes the session, and removes its development folder, installed project dependencies, and build branch. Changes not merged into your personal version will be permanently discarded.",
+ "status": {
+ "preparing": "Preparing",
+ "running": "Building",
+ "ready": "Awaiting completion",
+ "archived": "Archived · Can resume",
+ "failed": "Preparation failed",
+ "cancelled": "Preparation stopped",
+ "cleaning": "Cleaning up",
+ "cleanup": "Cleanup pending"
+ },
+ "errors": {
+ "busy": "The session or folder is still in use. Stop it and try again.",
+ "dirty": "There are uncommitted changes. Open the session and save them before finishing.",
+ "conflict": "The merge did not finish. Your changes are preserved. Open the session to resolve conflicts and retry.",
+ "cleanupFailed": "Cleanup did not finish. The record is kept so you can retry.",
+ "directoryBusy": "Files in the development folder are in use or cannot be removed. Close terminals, editors, or previews using this folder, then retry cleanup.",
+ "unavailable": "The session or development folder changed. Refresh and try again."
+ }
}
}
},
@@ -12645,13 +12676,18 @@
"source": {
"preparing": "Preparing source checkout…",
"phase": {
- "checking": "Checking Git and source",
+ "waiting": "Waiting for other project operations to finish…",
+ "checking": "Checking Git…",
+ "checkingRemote": "Checking the upstream version…",
+ "checkingLocal": "Checking local source…",
"cloning": "Downloading source",
"fetching": "Refreshing repository",
"checkingOut": "Selecting version",
"preparingBranch": "Preparing personal branch",
+ "caching": "Preparing dependency cache",
"installing": "Installing dependencies"
},
+ "cacheProgress": "Resolved {{resolved}} · Reused {{reused}} · Downloaded {{downloaded}}",
"pending": "Waiting to prepare source",
"ready": "Source is ready",
"failed": "Source preparation failed",
@@ -12665,7 +12701,7 @@
"localCommits": "The source contains local commits or stashes not included upstream. Keep or back them up before clearing.",
"environmentNotReady": "The build environment is not ready. Check the required tools.",
"gitUnavailable": "Git is unavailable. Check and install Git in the environment card, then retry.",
- "installFailed": "Dependency install failed. Please retry.",
+ "installFailed": "Dependency preparation failed. Please retry.",
"locked": "Some files are in use by another program and could not be removed. Close it or restart Cindy, then retry."
},
"gitProgress": {
@@ -12693,7 +12729,35 @@
"start": "Start personal build",
"open": "Open personal build task",
"sendFailed": "Could not send the request to the personal build task",
- "preparingWorkspace": "Creating an isolated workspace and installing dependencies",
+ "preparingWorkspace": "Creating an isolated workspace",
+ "preparingDependencies": "Preparing dependencies for the personal task",
+ "preparingNpmDependencies": "Preparing npm dependencies",
+ "phases": {
+ "waiting": "Waiting for project preparation",
+ "environment": "Preparing the environment",
+ "source": "Preparing personal project source",
+ "workspace": "Creating the task branch and worktree",
+ "dependencies": "Installing task dependencies",
+ "starting": "Starting your request",
+ "completed": "Preparation complete"
+ },
+ "prepared": "Preparation complete. Your request has started automatically.",
+ "preparationFailed": "Preparation failed. Your request has not started; retry to continue.",
+ "workspaceUnavailable": "The personal-build workspace is missing or incomplete. Create a new build task, or restore the original worktree before continuing.",
+ "projectClearing": "The personal-build project is being cleared. Wait before sending another message.",
+ "inputLocked": {
+ "executing": "Cindy Make is running your first request",
+ "hint": "Input resumes after this run. You can still answer questions and review plans.",
+ "retry": "Input is unavailable. Retry from the preparation card above."
+ },
+ "dependencyActivity": {
+ "starting": "Starting dependency installation…",
+ "packages": "Downloading and installing dependencies…",
+ "scripts": "Running installation scripts…"
+ },
+ "dependencyProgress": "Resolved {{resolved}} · reused {{reused}} · downloaded {{downloaded}} · added {{added}}",
+ "taskName": "Cindy Make personal build",
+ "taskTitle": "[Cindy-Make] {{request}}",
"workspace": "Workspace {{branch}}"
},
"complete": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 8759c65c78..2e06f44e00 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -5687,6 +5687,7 @@
"title": "個人版ソース",
"openDir": "ソースコードフォルダーを開く",
"prepare": "ソースを準備",
+ "retry": "準備を再試行",
"reset": "ソースを削除",
"update": "ソースを更新",
"preparingAction": "ソースを準備中",
@@ -5716,6 +5717,36 @@
"ariaLabel": "インストールテスト:システムのツールを無視",
"enabledHint": "下のカードから Windows ツールのダウンロードとインストールをテストできます。インストール済みの Cindy 管理ツールは再利用します。切り替えは即時反映され、再読み込みや再起動でオフになります。システムのツールは変更しません。",
"reportHint": "インストールテストがオンです。ポータブルツールは Cindy 管理のコピーを使用します。公式の案内をテストするため、Windows のコンパイラを不足として表示します。実際の状態を確認するにはスイッチをオフにしてください。"
+ },
+ "tasks": {
+ "title": "未完了の制作",
+ "search": "制作タスクを検索",
+ "noResults": "一致する制作タスクはありません",
+ "restore": "復元してタスクを開く",
+ "finish": "制作を完了",
+ "delete": "制作を削除",
+ "retryCleanup": "クリーンアップを再試行",
+ "finishHint": "変更を確認して制作を完了すると、個人版にマージし、開発フォルダーを削除します。対話履歴はアーカイブ済みタスクに残ります。",
+ "finishConfirm": "「{{title}}」を完了しますか?コミット済みの変更を個人版にマージし、開発フォルダーと制作ブランチを削除してタスクをアーカイブします。未コミットの変更や競合がある場合は削除しません。",
+ "deleteConfirm": "「{{title}}」を削除しますか?制作を停止してタスクを削除し、開発フォルダー、インストール済みの依存関係、制作ブランチを削除します。個人版にマージされていない変更は完全に失われます。",
+ "status": {
+ "preparing": "準備中",
+ "running": "制作中",
+ "ready": "完了の確認待ち",
+ "archived": "アーカイブ済み · 再開可能",
+ "failed": "準備に失敗",
+ "cancelled": "準備を停止",
+ "cleaning": "クリーンアップ中",
+ "cleanup": "クリーンアップ待ち"
+ },
+ "errors": {
+ "busy": "タスクまたはフォルダーは使用中です。停止して再試行してください。",
+ "dirty": "未コミットの変更があります。タスクを開いて変更を保存してから完了してください。",
+ "conflict": "マージは完了していません。変更は保持されています。タスクを開いて競合を解決し、再試行してください。",
+ "cleanupFailed": "クリーンアップは未完了です。記録を保持しているため再試行できます。",
+ "directoryBusy": "開発フォルダー内のファイルが使用中か、削除できません。このフォルダーを使用しているターミナル、エディター、プレビューを閉じてから、クリーンアップを再試行してください。",
+ "unavailable": "タスクまたは開発フォルダーが変更されました。更新して再試行してください。"
+ }
}
}
},
@@ -12628,13 +12659,18 @@
"source": {
"preparing": "ソースを準備しています",
"phase": {
- "checking": "Git とソースを確認中",
+ "waiting": "他のプロジェクト操作の完了を待機中…",
+ "checking": "Git を確認中…",
+ "checkingRemote": "上流のバージョンを確認中…",
+ "checkingLocal": "ローカルのソースを確認中…",
"cloning": "ソースをダウンロード中",
"fetching": "リポジトリを更新中",
"checkingOut": "バージョンを切替中",
"preparingBranch": "個人版ブランチを準備中",
+ "caching": "依存関係のキャッシュを準備中",
"installing": "依存関係をインストール中"
},
+ "cacheProgress": "解決済み {{resolved}} · 再利用 {{reused}} · ダウンロード済み {{downloaded}}",
"pending": "ソースの準備を待っています",
"ready": "ソースの準備が完了しました",
"failed": "ソースの準備に失敗しました",
@@ -12648,7 +12684,7 @@
"localCommits": "ソースに上流に含まれないローカルコミットまたはスタッシュがあります。削除する前に保存またはバックアップしてください。",
"environmentNotReady": "ビルド環境の準備ができていません。必要なツールを確認してください。",
"gitUnavailable": "Git を利用できません。環境カードで Git を確認してインストールし、再試行してください。",
- "installFailed": "依存関係のインストールに失敗しました。再試行してください。",
+ "installFailed": "依存関係の準備に失敗しました。再試行してください。",
"locked": "一部のファイルが他のプログラムで使用中のため削除できません。そのプログラムを閉じるか Cindy を再起動してから再試行してください。"
},
"gitProgress": {
@@ -12676,7 +12712,35 @@
"start": "個人版を作成",
"open": "個人版タスクを開く",
"sendFailed": "要求を送信できませんでした。個人版タスクを開いて再試行してください",
- "preparingWorkspace": "独立した作業ディレクトリを作成し、依存関係をインストールしています",
+ "preparingWorkspace": "独立した作業ディレクトリを作成しています",
+ "preparingDependencies": "個人版タスクの依存関係を準備しています",
+ "preparingNpmDependencies": "npm 依存関係を準備しています",
+ "phases": {
+ "waiting": "プロジェクトの準備を待っています",
+ "environment": "環境を準備しています",
+ "source": "個人用プロジェクトのソースを準備しています",
+ "workspace": "タスクのブランチと作業ディレクトリを作成しています",
+ "dependencies": "タスクの依存関係をインストールしています",
+ "starting": "タスクを自動で開始しています",
+ "completed": "準備完了"
+ },
+ "prepared": "準備が完了し、リクエストの実行を自動で開始しました。",
+ "preparationFailed": "準備に失敗しました。リクエストは未実行です。再試行できます。",
+ "workspaceUnavailable": "個人版の作業ディレクトリが見つからないか、不完全です。新しい作成タスクを開始するか、元の作業ディレクトリを復元してから続行してください。",
+ "projectClearing": "個人版のプロジェクトを削除中です。完了してからメッセージを送信してください。",
+ "inputLocked": {
+ "executing": "Cindy Make が初回のリクエストを実行中",
+ "hint": "初回の実行が終わると入力できます。質問への回答やプランの確認は引き続き行えます。",
+ "retry": "入力は一時的に無効です。上の準備カードから再試行してください。"
+ },
+ "dependencyActivity": {
+ "starting": "依存関係のインストールを開始中…",
+ "packages": "依存関係をダウンロードしてインストール中…",
+ "scripts": "インストールスクリプトを実行中…"
+ },
+ "dependencyProgress": "解決 {{resolved}} · 再利用 {{reused}} · ダウンロード {{downloaded}} · 追加 {{added}}",
+ "taskName": "Cindy Make 個人版",
+ "taskTitle": "[Cindy-Make] {{request}}",
"workspace": "作業ディレクトリ {{branch}}"
},
"complete": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 8ebfc65c80..650c86656b 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -5687,6 +5687,7 @@
"title": "개인 버전 소스",
"openDir": "소스 폴더 열기",
"prepare": "소스 준비",
+ "retry": "준비 재시도",
"reset": "소스 정리",
"update": "소스 업데이트",
"preparingAction": "소스 준비 중",
@@ -5716,6 +5717,36 @@
"ariaLabel": "설치 테스트: 시스템 도구 무시",
"enabledHint": "아래 카드에서 Windows 도구의 다운로드와 설치를 테스트할 수 있습니다. 이미 설치된 Cindy 관리 도구는 재사용합니다. 즉시 적용되며 새로고침이나 재시작 시 꺼집니다. 시스템 도구는 변경하지 않습니다.",
"reportHint": "설치 테스트가 켜져 있습니다. 휴대용 도구는 Cindy 관리 복사본을 사용합니다. 공식 설치 안내를 테스트하도록 Windows 컴파일 도구를 없음으로 표시합니다. 실제 상태를 확인하려면 스위치를 끄세요."
+ },
+ "tasks": {
+ "title": "미완료 제작",
+ "search": "제작 작업 검색",
+ "noResults": "일치하는 제작 작업이 없습니다",
+ "restore": "복원하고 작업 열기",
+ "finish": "제작 완료",
+ "delete": "제작 삭제",
+ "retryCleanup": "정리 다시 시도",
+ "finishHint": "변경 사항을 확인하고 제작을 완료하면 개인 버전에 병합하고 개발 폴더를 정리합니다. 대화 기록은 보관된 작업에 남습니다.",
+ "finishConfirm": "“{{title}}” 제작을 완료할까요? 커밋된 변경 사항을 개인 버전에 병합하고 개발 폴더와 제작 브랜치를 삭제한 뒤 작업을 보관합니다. 커밋하지 않은 변경 사항이나 병합 충돌이 있으면 정리를 중단합니다.",
+ "deleteConfirm": "“{{title}}” 제작을 삭제할까요? 제작을 중지하고 작업을 삭제하며 개발 폴더, 설치된 프로젝트 의존성 및 제작 브랜치를 정리합니다. 개인 버전에 병합하지 않은 변경 사항은 영구적으로 삭제됩니다.",
+ "status": {
+ "preparing": "준비 중",
+ "running": "제작 중",
+ "ready": "완료 확인 대기",
+ "archived": "보관됨 · 재개 가능",
+ "failed": "준비 실패",
+ "cancelled": "준비 중지됨",
+ "cleaning": "정리 중",
+ "cleanup": "정리 대기"
+ },
+ "errors": {
+ "busy": "작업 또는 폴더가 사용 중입니다. 중지한 후 다시 시도하세요.",
+ "dirty": "커밋하지 않은 변경 사항이 있습니다. 작업을 열어 변경 사항을 저장한 후 완료하세요.",
+ "conflict": "병합하지 못했습니다. 변경 사항은 보존되었습니다. 작업을 열어 충돌을 해결한 후 다시 시도하세요.",
+ "cleanupFailed": "정리하지 못했습니다. 다시 시도할 수 있도록 기록이 유지됩니다.",
+ "directoryBusy": "개발 폴더의 파일이 사용 중이거나 삭제할 수 없습니다. 이 폴더를 사용하는 터미널, 편집기 또는 미리보기를 닫은 후 정리를 다시 시도하세요.",
+ "unavailable": "작업 또는 개발 폴더가 변경되었습니다. 새로 고침한 후 다시 시도하세요."
+ }
}
}
},
@@ -12628,13 +12659,18 @@
"source": {
"preparing": "소스를 준비하는 중",
"phase": {
- "checking": "Git 및 소스 확인 중",
+ "waiting": "다른 프로젝트 작업이 끝나기를 기다리는 중…",
+ "checking": "Git 확인 중…",
+ "checkingRemote": "업스트림 버전 확인 중…",
+ "checkingLocal": "로컬 소스 확인 중…",
"cloning": "소스 다운로드 중",
"fetching": "저장소 새로 고침 중",
"checkingOut": "버전 전환 중",
"preparingBranch": "개인 버전 브랜치 준비 중",
+ "caching": "의존성 캐시 준비 중",
"installing": "의존성 설치 중"
},
+ "cacheProgress": "확인 {{resolved}} · 재사용 {{reused}} · 다운로드 {{downloaded}}",
"pending": "소스 준비 대기 중",
"ready": "소스가 준비되었습니다",
"failed": "소스 준비 실패",
@@ -12648,7 +12684,7 @@
"localCommits": "소스에 업스트림에 포함되지 않은 로컬 커밋 또는 스태시가 있습니다. 정리하기 전에 보관하거나 백업하세요.",
"environmentNotReady": "빌드 환경이 준비되지 않았습니다. 필요한 도구를 확인하세요.",
"gitUnavailable": "Git을 사용할 수 없습니다. 환경 카드에서 Git을 확인하고 설치한 후 다시 시도하세요.",
- "installFailed": "의존성 설치에 실패했습니다. 다시 시도하세요.",
+ "installFailed": "의존성 준비에 실패했습니다. 다시 시도하세요.",
"locked": "일부 파일이 다른 프로그램에서 사용 중이라 삭제할 수 없습니다. 해당 프로그램을 닫거나 Cindy를 다시 시작한 뒤 재시도하세요."
},
"gitProgress": {
@@ -12676,7 +12712,35 @@
"start": "개인 버전 만들기",
"open": "개인 버전 작업 열기",
"sendFailed": "요청을 보내지 못했습니다. 개인 버전 작업을 열어 다시 시도하세요",
- "preparingWorkspace": "독립 작업 디렉터리를 만들고 의존성을 설치하는 중",
+ "preparingWorkspace": "독립 작업 디렉터리를 만드는 중",
+ "preparingDependencies": "개인 작업 의존성을 준비하는 중",
+ "preparingNpmDependencies": "npm 의존성을 준비하는 중",
+ "phases": {
+ "waiting": "프로젝트 준비 대기 중",
+ "environment": "환경 준비 중",
+ "source": "개인 프로젝트 소스 준비 중",
+ "workspace": "작업 브랜치와 작업 디렉터리 생성 중",
+ "dependencies": "작업 의존성 설치 중",
+ "starting": "작업 자동 시작 중",
+ "completed": "준비 완료"
+ },
+ "prepared": "준비가 완료되어 요청을 자동으로 실행하기 시작했습니다.",
+ "preparationFailed": "준비에 실패하여 요청이 시작되지 않았습니다. 다시 시도할 수 있습니다.",
+ "workspaceUnavailable": "개인 버전의 작업 디렉터리가 없거나 불완전합니다. 새 제작 작업을 시작하거나 원래 작업 디렉터리를 복원한 후 계속하세요.",
+ "projectClearing": "개인 버전 프로젝트를 정리하고 있습니다. 완료된 후 메시지를 보내세요.",
+ "inputLocked": {
+ "executing": "Cindy Make가 첫 요청을 실행 중입니다",
+ "hint": "첫 실행이 끝나면 입력할 수 있습니다. 질문 응답과 계획 검토는 계속할 수 있습니다.",
+ "retry": "지금은 입력할 수 없습니다. 위의 준비 카드에서 다시 시도하세요."
+ },
+ "dependencyActivity": {
+ "starting": "의존성 설치 시작 중…",
+ "packages": "의존성 다운로드 및 설치 중…",
+ "scripts": "설치 스크립트 실행 중…"
+ },
+ "dependencyProgress": "해결 {{resolved}} · 재사용 {{reused}} · 다운로드 {{downloaded}} · 추가 {{added}}",
+ "taskName": "Cindy Make 개인 버전",
+ "taskTitle": "[Cindy-Make] {{request}}",
"workspace": "작업 디렉터리 {{branch}}"
},
"complete": {
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 40f3a00009..e88d6a746e 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -2162,7 +2162,11 @@
"endpointLabel": "{{agent}} 基础 URL",
"noAuthNote": "此 Proxy 无需客户端密钥;Cindy 会在转发前移除 CLI 的订阅凭证。",
"signIn": "登录",
- "setupLink": { "apiKey": "获取 API Key", "account": "注册或登录", "setup": "设置帮助" },
+ "setupLink": {
+ "apiKey": "获取 API Key",
+ "account": "注册或登录",
+ "setup": "设置帮助"
+ },
"fetching": "正在验证连接并获取模型列表…",
"fetchFailed": "模型列表获取失败——可先按预设推荐模型完成添加,稍后在详情里刷新",
"manualModelHint": "未发现可用模型,请填写此 Proxy 实际提供的模型 ID。",
@@ -5683,6 +5687,7 @@
"title": "个人版源码",
"openDir": "打开源码目录",
"prepare": "准备源码",
+ "retry": "重试准备",
"reset": "清理源码",
"update": "更新源码",
"preparingAction": "正在准备源码",
@@ -5712,6 +5717,36 @@
"ariaLabel": "测试安装:忽略系统工具",
"enabledHint": "下方卡片可以测试 Windows 工具的下载与安装,已安装的 Cindy 工具会复用。开关立即生效,刷新或重启后关闭,不改动系统工具。",
"reportHint": "安装测试已开启:便携工具使用 Cindy 管理的副本。Windows 原生编译工具会模拟缺失,以便测试官方安装指引;关闭开关可检查真实状态。"
+ },
+ "tasks": {
+ "title": "未完成的制作",
+ "search": "搜索制作任务",
+ "noResults": "没有匹配的制作任务",
+ "restore": "恢复并打开任务",
+ "finish": "完成制作",
+ "delete": "删除制作",
+ "retryCleanup": "重试清理",
+ "finishHint": "确认改动后完成制作,合入个人版并清理开发目录。对话记录保留在已归档任务中。",
+ "finishConfirm": "完成「{{title}}」?已提交的改动将合入个人版,随后清理开发目录和制作分支,并归档任务。未提交的改动或合并冲突会阻止清理。",
+ "deleteConfirm": "删除「{{title}}」?将停止制作、删除任务,并清理开发目录、已安装的项目依赖和制作分支。未合入个人版的改动将被丢弃,无法恢复。",
+ "status": {
+ "preparing": "正在准备",
+ "running": "正在制作",
+ "ready": "待确认完成",
+ "archived": "已归档 · 可继续",
+ "failed": "准备失败",
+ "cancelled": "准备已停止",
+ "cleaning": "正在清理",
+ "cleanup": "待清理"
+ },
+ "errors": {
+ "busy": "任务仍在运行或目录正在使用,请停止后重试。",
+ "dirty": "还有未提交的改动,请打开任务保存改动后再完成。",
+ "conflict": "合并未完成,改动已保留。请打开任务解决冲突后重试。",
+ "cleanupFailed": "清理未完成,记录已保留,请重试清理。",
+ "directoryBusy": "开发目录中的文件被占用或无法删除,请关闭使用该目录的终端、编辑器或预览后重试清理。",
+ "unavailable": "任务或开发目录已变化,请刷新后重试。"
+ }
}
}
},
@@ -12624,13 +12659,18 @@
"source": {
"preparing": "正在准备源码",
"phase": {
- "checking": "正在检查 Git 和源码",
+ "waiting": "正在等待其他工程操作完成…",
+ "checking": "正在检查 Git…",
+ "checkingRemote": "正在查询上游版本…",
+ "checkingLocal": "正在检查本地源码…",
"cloning": "正在下载源码",
"fetching": "正在刷新仓库",
"checkingOut": "正在切换版本",
"preparingBranch": "正在准备个人版分支",
+ "caching": "正在准备依赖缓存",
"installing": "正在安装依赖"
},
+ "cacheProgress": "已解析 {{resolved}} · 已复用 {{reused}} · 已下载 {{downloaded}}",
"pending": "等待准备源码",
"ready": "源码已准备好",
"failed": "源码准备失败",
@@ -12644,7 +12684,7 @@
"localCommits": "源码中有尚未包含在上游的本地提交或暂存记录,请保留或备份后再清理。",
"environmentNotReady": "构建环境尚未就绪,请检查所需工具。",
"gitUnavailable": "Git 不可用,请先在环境卡片中检查并安装 Git,再重试。",
- "installFailed": "依赖安装失败,请重试。",
+ "installFailed": "依赖准备失败,请重试。",
"locked": "部分文件正被其他程序占用,无法删除。请关闭相关程序或重启 Cindy 后重试。"
},
"gitProgress": {
@@ -12672,7 +12712,35 @@
"start": "开始制作个人版",
"open": "打开个人版任务",
"sendFailed": "需求发送失败,请打开个人版任务重试",
- "preparingWorkspace": "正在创建独立开发目录并安装依赖",
+ "preparingWorkspace": "正在创建独立开发目录",
+ "preparingDependencies": "正在准备个人版任务依赖",
+ "preparingNpmDependencies": "正在准备 npm 依赖",
+ "phases": {
+ "waiting": "等待准备项目",
+ "environment": "正在准备环境",
+ "source": "正在准备个人项目源码",
+ "workspace": "正在创建任务分支和工作目录",
+ "dependencies": "正在安装任务依赖",
+ "starting": "正在自动开始任务",
+ "completed": "准备完成"
+ },
+ "prepared": "准备完成,已自动开始执行你的需求。",
+ "preparationFailed": "准备失败,尚未开始执行你的需求;可重试继续。",
+ "workspaceUnavailable": "个人版工作目录缺失或不完整,请创建新的制作任务,或恢复原工作目录后再继续",
+ "projectClearing": "正在清理个人版项目,请等待清理完成后再发送消息",
+ "inputLocked": {
+ "executing": "Cindy Make 正在首次执行",
+ "hint": "首次执行结束后恢复输入,提问和计划确认不受影响。",
+ "retry": "输入暂不可用,请在上方准备卡片中重试。"
+ },
+ "dependencyActivity": {
+ "starting": "正在启动依赖安装…",
+ "packages": "正在下载并安装依赖…",
+ "scripts": "正在执行安装脚本…"
+ },
+ "dependencyProgress": "已解析 {{resolved}} · 已复用 {{reused}} · 已下载 {{downloaded}} · 已添加 {{added}}",
+ "taskName": "Cindy Make 个人版",
+ "taskTitle": "[Cindy-Make] {{request}}",
"workspace": "开发目录 {{branch}}"
},
"complete": {
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 bd3b870d91..d05815b390 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -2162,7 +2162,11 @@
"endpointLabel": "{{agent}} 基礎 URL",
"noAuthNote": "此 Proxy 無需客戶端金鑰;Cindy 會在轉發前移除 CLI 的訂閱憑證。",
"signIn": "登入",
- "setupLink": { "apiKey": "取得 API Key", "account": "註冊或登入", "setup": "設定說明" },
+ "setupLink": {
+ "apiKey": "取得 API Key",
+ "account": "註冊或登入",
+ "setup": "設定說明"
+ },
"fetching": "正在驗證連線並獲取模型列表…",
"fetchFailed": "模型列表獲取失敗——可先按預設推薦模型完成新增,稍後在詳情裡重新整理",
"manualModelHint": "未發現可用模型,請填寫此 Proxy 實際提供的模型 ID。",
@@ -5683,6 +5687,7 @@
"title": "個人版原始碼",
"openDir": "開啟原始碼目錄",
"prepare": "準備原始碼",
+ "retry": "重試準備",
"reset": "清理原始碼",
"update": "更新原始碼",
"preparingAction": "正在準備原始碼",
@@ -5712,6 +5717,36 @@
"ariaLabel": "測試安裝:忽略系統工具",
"enabledHint": "下方卡片可以測試 Windows 工具的下載與安裝,已安裝的 Cindy 工具會重複使用。開關立即生效,重新整理或重啟後關閉,不更動系統工具。",
"reportHint": "安裝測試已開啟:可攜式工具使用 Cindy 管理的副本。Windows 原生編譯工具會模擬缺失,以便測試官方安裝指引;關閉開關可檢查真實狀態。"
+ },
+ "tasks": {
+ "title": "未完成的製作",
+ "search": "搜尋製作任務",
+ "noResults": "沒有相符的製作任務",
+ "restore": "恢復並開啟任務",
+ "finish": "完成製作",
+ "delete": "刪除製作",
+ "retryCleanup": "重試清理",
+ "finishHint": "確認修改後完成製作,合入個人版並清理開發目錄。對話記錄保留在已封存任務中。",
+ "finishConfirm": "完成「{{title}}」?已提交的修改將合入個人版,接著清理開發目錄和製作分支,並封存任務。未提交的修改或合併衝突會阻止清理。",
+ "deleteConfirm": "刪除「{{title}}」?將停止製作、刪除任務,並清理開發目錄、已安裝的專案依賴和製作分支。未合入個人版的修改將被捨棄,無法恢復。",
+ "status": {
+ "preparing": "正在準備",
+ "running": "正在製作",
+ "ready": "待確認完成",
+ "archived": "已封存 · 可繼續",
+ "failed": "準備失敗",
+ "cancelled": "準備已停止",
+ "cleaning": "正在清理",
+ "cleanup": "待清理"
+ },
+ "errors": {
+ "busy": "任務仍在執行或目錄正在使用,請停止後重試。",
+ "dirty": "還有未提交的修改,請開啟任務儲存修改後再完成。",
+ "conflict": "合併未完成,修改已保留。請開啟任務解決衝突後重試。",
+ "cleanupFailed": "清理未完成,記錄已保留,請重試清理。",
+ "directoryBusy": "開發目錄中的檔案被占用或無法刪除,請關閉使用該目錄的終端機、編輯器或預覽後重試清理。",
+ "unavailable": "任務或開發目錄已變更,請重新整理後重試。"
+ }
}
}
},
@@ -12624,13 +12659,18 @@
"source": {
"preparing": "正在準備原始碼",
"phase": {
- "checking": "正在檢查 Git 和原始碼",
+ "waiting": "正在等待其他專案操作完成…",
+ "checking": "正在檢查 Git…",
+ "checkingRemote": "正在查詢上游版本…",
+ "checkingLocal": "正在檢查本機原始碼…",
"cloning": "正在下載原始碼",
"fetching": "正在更新儲存庫",
"checkingOut": "正在切換版本",
"preparingBranch": "正在準備個人版分支",
+ "caching": "正在準備相依套件快取",
"installing": "正在安裝相依套件"
},
+ "cacheProgress": "已解析 {{resolved}} · 已重用 {{reused}} · 已下載 {{downloaded}}",
"pending": "等待準備原始碼",
"ready": "原始碼已準備好",
"failed": "原始碼準備失敗",
@@ -12644,7 +12684,7 @@
"localCommits": "原始碼中有尚未包含在上游的本機提交或暫存記錄,請保留或備份後再清理。",
"environmentNotReady": "建置環境尚未就緒,請檢查所需工具。",
"gitUnavailable": "Git 無法使用,請先在環境卡片中檢查並安裝 Git,再重試。",
- "installFailed": "相依套件安裝失敗,請重試。",
+ "installFailed": "相依套件準備失敗,請重試。",
"locked": "部分檔案正被其他程式佔用,無法刪除。請關閉相關程式或重新啟動 Cindy 後重試。"
},
"gitProgress": {
@@ -12672,7 +12712,35 @@
"start": "開始製作個人版",
"open": "開啟個人版任務",
"sendFailed": "需求傳送失敗,請開啟個人版任務重試",
- "preparingWorkspace": "正在建立獨立開發目錄並安裝相依套件",
+ "preparingWorkspace": "正在建立獨立開發目錄",
+ "preparingDependencies": "正在準備個人版任務相依套件",
+ "preparingNpmDependencies": "正在準備 npm 相依套件",
+ "phases": {
+ "waiting": "等待準備專案",
+ "environment": "正在準備環境",
+ "source": "正在準備個人專案原始碼",
+ "workspace": "正在建立任務分支和工作目錄",
+ "dependencies": "正在安裝任務相依套件",
+ "starting": "正在自動開始任務",
+ "completed": "準備完成"
+ },
+ "prepared": "準備完成,已自動開始執行你的需求。",
+ "preparationFailed": "準備失敗,尚未開始執行你的需求;可重試繼續。",
+ "workspaceUnavailable": "個人版工作目錄遺失或不完整,請建立新的製作任務,或還原原工作目錄後再繼續",
+ "projectClearing": "正在清理個人版專案,請等待清理完成後再傳送訊息",
+ "inputLocked": {
+ "executing": "Cindy Make 正在首次執行",
+ "hint": "首次執行結束後恢復輸入,提問和計畫確認不受影響。",
+ "retry": "輸入暫不可用,請在上方準備卡片中重試。"
+ },
+ "dependencyActivity": {
+ "starting": "正在啟動依賴安裝…",
+ "packages": "正在下載並安裝依賴…",
+ "scripts": "正在執行安裝指令碼…"
+ },
+ "dependencyProgress": "已解析 {{resolved}} · 已重用 {{reused}} · 已下載 {{downloaded}} · 已新增 {{added}}",
+ "taskName": "Cindy Make 個人版",
+ "taskTitle": "[Cindy-Make] {{request}}",
"workspace": "開發目錄 {{branch}}"
},
"complete": {
diff --git a/apps/desktop/src/renderer/lib/__tests__/cindyMakeCommand.test.ts b/apps/desktop/src/renderer/lib/__tests__/cindyMakeCommand.test.ts
index a11b3d55e0..00bc25d6d1 100644
--- a/apps/desktop/src/renderer/lib/__tests__/cindyMakeCommand.test.ts
+++ b/apps/desktop/src/renderer/lib/__tests__/cindyMakeCommand.test.ts
@@ -154,18 +154,23 @@ describe('native environment-check entry', () => {
])(
'starts the same diagnostics without a connected model: $text',
async ({ text, invocation }) => {
- expect(await tryStartCindyMakeCommand(input({ text, agentKind: null }))).toEqual({
- kind: 'started',
- sessionId: 'source-task',
- });
- expect(h.ensureTask).toHaveBeenCalledWith(
- expect.objectContaining({ sessionId: 'source-task' }),
- );
- expect(h.start).toHaveBeenCalledExactlyOnceWith('source-task', invocation);
+ const result = await tryStartCindyMakeCommand(input({ text, agentKind: null }));
+ if (invocation.command === 'cindy-make') {
+ expect(result).toMatchObject({
+ kind: 'preflight',
+ request: 'fix scrolling',
+ sessionId: 'source-task',
+ });
+ expect(h.ensureTask).not.toHaveBeenCalled();
+ expect(h.start).not.toHaveBeenCalled();
+ } else {
+ expect(result).toEqual({ kind: 'started', sessionId: 'source-task' });
+ expect(h.start).toHaveBeenCalledExactlyOnceWith('source-task', invocation);
+ }
},
);
- it('passes home preferences only to task creation and starts a persistent timeline card', async () => {
+ it('returns home preferences for the preflight without creating a task', async () => {
h.ensureTask.mockResolvedValue('home-task');
const createOptions = {
workspaceKind: 'dialogue',
@@ -178,19 +183,13 @@ describe('native environment-check entry', () => {
planModeEnabled: true,
} as const;
expect(await tryStartCindyMakeCommand(input({ sessionId: undefined, createOptions }))).toEqual({
- kind: 'started',
- sessionId: 'home-task',
- });
- expect(h.ensureTask).toHaveBeenCalledWith({
+ kind: 'preflight',
sessionId: undefined,
- createOptions,
- title: 'fix scrolling',
- isCurrent: expect.any(Function),
- });
- expect(h.start).toHaveBeenCalledWith('home-task', {
- command: 'cindy-make',
request: 'fix scrolling',
+ createOptions,
});
+ expect(h.ensureTask).not.toHaveBeenCalled();
+ expect(h.start).not.toHaveBeenCalled();
});
it.each(['cindy-make', 'cindy-make-doctor'])(
@@ -243,7 +242,11 @@ describe('native environment-check entry', () => {
else current = false;
return 'late-task';
});
- expect(await tryStartCindyMakeCommand(input({ isCurrent: () => current }))).toEqual({
+ expect(
+ await tryStartCindyMakeCommand(
+ input({ text: '/cindy-make-doctor', isCurrent: () => current }),
+ ),
+ ).toEqual({
kind: 'stale',
});
expect(h.start).not.toHaveBeenCalled();
@@ -252,7 +255,9 @@ describe('native environment-check entry', () => {
it('returns a sanitized failure if task creation fails', async () => {
h.ensureTask.mockRejectedValue(new Error('private error details'));
- expect(await tryStartCindyMakeCommand(input())).toEqual({ kind: 'failed' });
+ expect(await tryStartCindyMakeCommand(input({ text: '/cindy-make-doctor' }))).toEqual({
+ kind: 'failed',
+ });
expect(h.start).not.toHaveBeenCalled();
});
});
diff --git a/apps/desktop/src/renderer/lib/__tests__/cindyMakeComposer.test.ts b/apps/desktop/src/renderer/lib/__tests__/cindyMakeComposer.test.ts
new file mode 100644
index 0000000000..e760bdf9eb
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/__tests__/cindyMakeComposer.test.ts
@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import { getCindyMakeComposerPhase } from '../cindyMakeComposer';
+import type { MakeDoctorReport } from '../../../shared/cindyMakeDoctor';
+import type { ChatMessage } from '../makerChatStore';
+
+const session = {
+ id: 'make-session',
+ source: 'cindy-make' as const,
+ clearedAt: null,
+ lastTurnEndedAt: null,
+};
+const preparing: MakeDoctorReport = {
+ runId: 'make-run',
+ platform: 'win32',
+ arch: 'x64',
+ status: 'running',
+ checks: [],
+ task: { sessionId: session.id, phase: 'dependencies' },
+};
+const dispatched: MakeDoctorReport = {
+ ...preparing,
+ status: 'completed',
+ task: { ...preparing.task!, phase: 'completed' },
+};
+const input = {
+ session,
+ report: preparing,
+ messages: [],
+ historyLoaded: true,
+ busy: false,
+ error: null,
+};
+const card = (report: MakeDoctorReport): ChatMessage => ({
+ clientId: 'preparation',
+ role: 'assistant',
+ content: '',
+ systemCardType: 'cindy-make',
+ systemCardData: { report },
+});
+
+describe('Cindy Make composer lifecycle', () => {
+ it('locks from preparation through accepted dispatch until the first product turn ends', () => {
+ expect(getCindyMakeComposerPhase(input)).toBe('dependencies');
+ expect(getCindyMakeComposerPhase({ ...input, report: dispatched })).toBe('executing');
+ expect(getCindyMakeComposerPhase({ ...input, report: dispatched, busy: true })).toBe(
+ 'executing',
+ );
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: dispatched,
+ session: { ...session, lastTurnEndedAt: 123 },
+ }),
+ ).toBeNull();
+ });
+
+ it('does not unlock just because a question or plan temporarily pauses streaming', () => {
+ const messages: ChatMessage[] = [
+ card(dispatched),
+ { clientId: 'ask', role: 'assistant', content: 'Choose', askUserStatus: 'pending' },
+ { clientId: 'plan', role: 'assistant', content: 'Plan', planReviewStatus: 'pending' },
+ ];
+ expect(getCindyMakeComposerPhase({ ...input, report: dispatched, messages, busy: false })).toBe(
+ 'executing',
+ );
+ });
+
+ it('restores the lock from the saved card after remount and supports remote history', () => {
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: undefined,
+ messages: [card(dispatched)],
+ busy: true,
+ }),
+ ).toBe('executing');
+ });
+
+ it('does not relock later manual turns, including after remount', () => {
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: dispatched,
+ busy: true,
+ session: { ...session, lastTurnEndedAt: 123 },
+ }),
+ ).toBeNull();
+ });
+
+ it.each(['failed', 'cancelled'] as const)(
+ 'keeps %s preparation unavailable until retry',
+ (status) => {
+ expect(getCindyMakeComposerPhase({ ...input, report: { ...preparing, status } })).toBe(
+ status,
+ );
+ expect(getCindyMakeComposerPhase(input)).toBe('dependencies');
+ },
+ );
+
+ it('prefers the live cancellation over stale running history', () => {
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: { ...preparing, status: 'cancelled' },
+ messages: [card(preparing)],
+ }),
+ ).toBe('cancelled');
+ });
+
+ it('releases failed or interrupted execution for recovery without waiting for a session patch', () => {
+ expect(getCindyMakeComposerPhase({ ...input, report: dispatched, error: 'failed' })).toBeNull();
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: dispatched,
+ session: { ...session, interruptedTurnStartedAt: 123 },
+ }),
+ ).toBeNull();
+ });
+
+ it('uses a persisted top-level terminal before session metadata arrives, not a subagent terminal', () => {
+ const terminal: ChatMessage = {
+ clientId: 'answer',
+ role: 'assistant',
+ content: 'Done',
+ turnCompleted: true,
+ };
+ expect(
+ getCindyMakeComposerPhase({ ...input, report: dispatched, messages: [terminal] }),
+ ).toBeNull();
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ report: dispatched,
+ messages: [{ ...terminal, parentToolUseId: 'subagent' }],
+ }),
+ ).toBe('executing');
+ });
+
+ it('leaves ordinary, cleared, legacy and other-session tasks alone', () => {
+ expect(
+ getCindyMakeComposerPhase({ ...input, session: { ...session, source: 'desktop' } }),
+ ).toBeNull();
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ session: { ...session, clearedAt: '2026-09-16T12:00:00Z' },
+ }),
+ ).toBeNull();
+ expect(getCindyMakeComposerPhase({ ...input, report: undefined })).toBeNull();
+ expect(
+ getCindyMakeComposerPhase({
+ ...input,
+ session: { ...session, id: 'other' },
+ messages: [card(preparing)],
+ }),
+ ).toBeNull();
+ });
+
+ it('keeps a new task unavailable until its history arrives', () => {
+ expect(getCindyMakeComposerPhase({ ...input, report: undefined, historyLoaded: false })).toBe(
+ 'waiting',
+ );
+ });
+});
diff --git a/apps/desktop/src/renderer/lib/__tests__/cindyMakeDoctorStream.test.ts b/apps/desktop/src/renderer/lib/__tests__/cindyMakeDoctorStream.test.ts
index f104a6a7b2..bbb0dce6b9 100644
--- a/apps/desktop/src/renderer/lib/__tests__/cindyMakeDoctorStream.test.ts
+++ b/apps/desktop/src/renderer/lib/__tests__/cindyMakeDoctorStream.test.ts
@@ -4,6 +4,7 @@ import type { MakeDoctorReport } from '../../../shared/cindyMakeDoctor';
const h = vi.hoisted(() => ({
create: vi.fn(),
+ startTask: vi.fn(),
update: vi.fn(),
prepend: vi.fn(),
get: vi.fn(),
@@ -57,7 +58,7 @@ vi.mock('@/lib/makerTransport', () => ({
isRemoteSessionSticky: () => false,
}));
-import { buildCreateOptsForCurrentSession, makerChatStore } from '@/lib/makerChatStore';
+import { makerChatStore } from '@/lib/makerChatStore';
import * as messageService from '@/lib/messageService';
import { tryStartCindyMakeCommand } from '../cindyMakeCommand';
import {
@@ -150,6 +151,7 @@ const cardReport = (sessionId: string) =>
?.systemCardData?.report as MakeDoctorReport | undefined;
beforeEach(() => {
+ h.startTask.mockReset().mockImplementation(async () => sid());
setDataOwnerGeneration('doctor-test-owner');
h.create.mockReset().mockImplementation(async (options) => ({ id: sid(), ...options }));
h.get.mockReset().mockResolvedValue({
@@ -170,7 +172,11 @@ beforeEach(() => {
main = mainApi();
h.prepareWorkspace.mockClear();
vi.stubGlobal('window', {
- electronAPI: { maker: main.api, prepareCindyMakeWorkspace: h.prepareWorkspace },
+ electronAPI: {
+ maker: main.api,
+ prepareCindyMakeWorkspace: h.prepareWorkspace,
+ startCindyMakeTask: h.startTask,
+ },
});
vi.spyOn(makerChatStore, 'sendMessage').mockResolvedValue(true);
});
@@ -184,7 +190,7 @@ afterEach(async () => {
describe('doctor cards in the message stream', () => {
it.each(['home', 'existing-task'])(
- 'persists the native Make command from %s as a visible card without starting an Agent',
+ 'opens preflight from %s without creating a task or timeline card',
async (entry) => {
const sessionId = sid();
const created = { id: sessionId, agentKind: 'codex', title: 'fix scrolling' };
@@ -199,24 +205,15 @@ describe('doctor cards in the message stream', () => {
isCurrent: () => true,
createOptions: { workspaceKind: 'dialogue', agentKind: 'codex' },
});
- expect(result).toEqual({ kind: 'started', sessionId });
- const card = messages(sessionId)[0];
- expect(card.systemCardType).toBe('cindy-make');
- expect(card.systemCardData?.request).toBe('fix scrolling');
- expect(card.systemCardData?.modalOnly).toBeUndefined();
- await vi.waitFor(() => expect(messageService.create).toHaveBeenCalledOnce());
- expect(messageService.create).toHaveBeenCalledWith(
- sessionId,
- expect.objectContaining({
- content: {
- __cindyMakeCard: {
- type: 'cindy-make',
- data: expect.objectContaining({ request: 'fix scrolling' }),
- },
- },
- }),
- );
- expect(h.create).toHaveBeenCalledTimes(entry === 'home' ? 1 : 0);
+ expect(result).toEqual({
+ kind: 'preflight', request: 'fix scrolling',
+ sessionId: entry === 'home' ? undefined : sessionId,
+ createOptions: { workspaceKind: 'dialogue', agentKind: 'codex' },
+ });
+ expect(messages(sessionId)).toHaveLength(0);
+ expect(messageService.create).not.toHaveBeenCalled();
+ expect(h.create).not.toHaveBeenCalled();
+ expect(main.api.executeDesktopCommand).not.toHaveBeenCalled();
expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
expect(h.prepareWorkspace).not.toHaveBeenCalled();
},
@@ -302,38 +299,23 @@ describe('doctor cards in the message stream', () => {
await main.complete(runId, { upstream });
expect(messages(id)[0].systemCardData?.decision).toBe('personal');
});
- it('keeps completed environment checks and upstream results while source-only reports update the same card', async () => {
+ it('keeps the historical checks and upstream results when handing source preparation to Main', async () => {
const id = sid();
const runId = 'source-run';
const upstream = { status: 'found' as const, items: [] };
- const checks = report(runId).checks;
makerChatStore.insertSystemCard(id, 'cindy-make', {
request: '修复消息流闪烁',
report: { ...report(runId), upstream },
});
-
- vi.stubGlobal('window', {
- electronAPI: { maker: main.api, prepareCindyMakeWorkspace: h.prepareWorkspace },
- });
- const preparation = prepareMakeSourceInStream(id, runId);
- await vi.waitFor(() => expect(main.api.executeDesktopCommand).toHaveBeenCalled());
- main.push(runId, 'running', { checks: [], platform: '', arch: '' });
+ expect(await prepareMakeSourceInStream(id, runId)).toBeTruthy();
expect(messages(id)[0].systemCardData?.report).toMatchObject({
upstream,
- checks,
- platform: 'win32',
- arch: 'x64',
- });
- await main.complete(runId, {
- checks: [],
- source: { status: 'ready', path: 'C:\\cindy-make\\source' },
- });
- await preparation;
- expect(messages(id)[0].systemCardData?.report).toMatchObject({
- upstream,
- checks,
- source: { status: 'ready' },
+ checks: report(runId).checks,
});
+ expect(h.startTask).toHaveBeenCalledWith(
+ expect.objectContaining({ originSessionId: id, runId, request: '修复消息流闪烁' }),
+ );
+ expect(main.api.executeDesktopCommand).not.toHaveBeenCalled();
});
it('does not create a card for a bare Make request', () => {
const id = sid();
@@ -550,102 +532,6 @@ describe('doctor task placement', () => {
},
);
- it('creates a code task in the prepared source directory and sends the original request', async () => {
- const origin = sid();
- const sourcePath = 'C:\\cindy-make\\source';
- const codeTask = {
- id: sid(),
- workingDir: sourcePath,
- workspaceKind: 'project',
- agentKind: 'codex' as const,
- model: 'runtime-model',
- effort: 'high',
- providerId: 'runtime-provider',
- fastMode: true,
- permissionMode: 'ask',
- planModeEnabled: true,
- };
- h.get.mockResolvedValue({
- agentKind: 'codex',
- model: 'old-model',
- effort: 'low',
- providerId: 'old-provider',
- fastMode: false,
- permissionMode: 'ask',
- planModeEnabled: true,
- remoteHostId: null,
- runtimeEffective: {
- agentKind: 'codex',
- model: 'runtime-model',
- effort: 'high',
- providerId: 'runtime-provider',
- fastMode: true,
- },
- });
- h.create.mockResolvedValue(codeTask);
- const runId = 'code-run';
- const worktreePath = 'C:\\cindy-make\\worktrees\\code-run';
- const prepareCindyMakeWorkspace = vi.fn(async () => ({
- path: worktreePath,
- branch: 'cindy-make/code-run',
- baseCommit: '0123456789ab',
- }));
- vi.stubGlobal('window', { electronAPI: { maker: main.api, prepareCindyMakeWorkspace } });
- makerChatStore.insertSystemCard(origin, 'cindy-make', {
- request: '修复消息流闪烁',
- decision: 'personal',
- report: {
- ...report(runId),
- source: { status: 'ready', path: sourcePath },
- },
- });
-
- const createdId = await startMakeCodeSession(origin, runId);
-
- expect(createdId).toBe(codeTask.id);
- // The task never works in the managed checkout: it gets its own worktree.
- expect(prepareCindyMakeWorkspace).toHaveBeenCalledWith(runId);
- expect(h.create).toHaveBeenCalledWith(
- expect.objectContaining({
- workingDir: worktreePath,
- source: 'cindy-make',
- workspaceKind: 'project',
- model: 'runtime-model',
- effort: 'high',
- providerId: 'runtime-provider',
- fastMode: true,
- permissionMode: 'ask',
- planModeEnabled: true,
- }),
- );
- expect(makerChatStore.sendMessage).toHaveBeenCalledWith(
- codeTask.id,
- '修复消息流闪烁',
- 'runtime-model',
- 'high',
- 'ask',
- worktreePath,
- );
- expect(
- buildCreateOptsForCurrentSession(
- codeTask.id,
- codeTask.model,
- codeTask.effort,
- codeTask.permissionMode,
- worktreePath,
- ),
- ).toMatchObject({
- agentKind: 'codex',
- providerId: 'runtime-provider',
- fastMode: true,
- planMode: true,
- });
- expect(messages(origin)[0].systemCardData).toMatchObject({
- codeSessionId: codeTask.id,
- codeWorkspace: { path: worktreePath, branch: 'cindy-make/code-run' },
- });
- });
-
it('does not create a task for a stale composer or report success after creation fails', async () => {
expect(await ensureMakeTask({ createOptions, isCurrent: () => false })).toBeNull();
expect(h.create).not.toHaveBeenCalled();
@@ -679,211 +565,114 @@ describe('doctor task placement', () => {
describe('personal code task handoff', () => {
const runId = 'code-ready';
const request = ' 修复滚动\n保留 <b>原文</b> ';
- const sourcePath = '/Users/test/Cindy/source';
function readyCard(extra: Record<string, unknown> = {}) {
const id = sid();
makerChatStore.insertSystemCard(id, 'cindy-make', {
request,
decision: 'personal',
- report: { ...report(runId), source: { status: 'ready', path: sourcePath } },
+ report: { ...report(runId), source: { status: 'ready', path: '/source' } },
...extra,
});
return id;
}
- it('creates a task only after lookup and a personal choice, without preparing the ready source twice', async () => {
+ it('hands off only after the personal choice; Main owns preparation and first dispatch', async () => {
const id = sid();
const workflowRun = startMakeDoctorInStream(id, { command: 'cindy-make', request }, main.api)!;
- const source = { status: 'ready' as const, path: sourcePath };
- main.push(workflowRun, 'running', { source, upstream: { status: 'searching', items: [] } });
+ main.push(workflowRun, 'running', { upstream: { status: 'searching', items: [] } });
expect(await chooseMakeUpstream(id, workflowRun, 'personal')).toBeNull();
- expect(h.create).not.toHaveBeenCalled();
- expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
- await main.complete(workflowRun, { source, upstream: { status: 'notFound', items: [] } });
+ expect(h.startTask).not.toHaveBeenCalled();
+ await main.complete(workflowRun, {
+ source: { status: 'ready', path: '/source' },
+ upstream: { status: 'notFound', items: [] },
+ });
const created = await chooseMakeUpstream(id, workflowRun, 'personal');
expect(created).toBeTruthy();
- expect(h.create).toHaveBeenCalledOnce();
- expect(makerChatStore.sendMessage).toHaveBeenCalledWith(
- created,
- request,
- 'selected-model',
- 'high',
- 'ask',
- `/Users/test/Cindy/worktrees/${workflowRun}`,
+ expect(h.startTask).toHaveBeenCalledExactlyOnceWith(
+ expect.objectContaining({ originSessionId: id, runId: workflowRun, request }),
);
- // Only the original workflow command; no follow-up prepare-source invocation.
+ expect(h.create).not.toHaveBeenCalled();
+ expect(h.prepareWorkspace).not.toHaveBeenCalled();
+ expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
expect(main.api.executeDesktopCommand).toHaveBeenCalledOnce();
expect(await chooseMakeUpstream(id, workflowRun, 'personal')).toBeNull();
- expect(h.create).toHaveBeenCalledOnce();
});
- it('waiting after all steps does not create a code task or invoke another source operation', async () => {
+ it('waiting for upstream does not start a task', async () => {
const id = readyCard({
decision: undefined,
- report: {
- ...report(runId),
- source: { status: 'ready', path: sourcePath },
- upstream: { status: 'found', items: [] },
- },
+ report: { ...report(runId), upstream: { status: 'found', items: [] } },
});
await chooseMakeUpstream(id, runId, 'wait');
expect(messages(id)[0].systemCardData?.decision).toBe('wait');
- expect(h.create).not.toHaveBeenCalled();
+ expect(h.startTask).not.toHaveBeenCalled();
expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
- expect(main.api.executeDesktopCommand).not.toHaveBeenCalled();
});
- it('supports a historical search-first card by preparing its missing source before creating a task', async () => {
+ it('hands off historical cards before their missing source is prepared', async () => {
const id = readyCard({
decision: undefined,
report: { ...report(runId), upstream: { status: 'notFound', items: [] } },
});
- vi.stubGlobal('window', {
- electronAPI: { maker: main.api, prepareCindyMakeWorkspace: h.prepareWorkspace },
- });
- const result = chooseMakeUpstream(id, runId, 'personal');
- expect(h.create).not.toHaveBeenCalled();
- await main.complete(runId, { source: { status: 'ready', path: sourcePath } });
- expect(await result).toBeTruthy();
- expect(h.create).toHaveBeenCalledOnce();
- expect(makerChatStore.sendMessage).toHaveBeenCalledWith(
- expect.any(String),
- request,
- 'selected-model',
- 'high',
- 'ask',
- `/Users/test/Cindy/worktrees/${runId}`,
- );
+ expect(await chooseMakeUpstream(id, runId, 'personal')).toBeTruthy();
+ expect(h.startTask).toHaveBeenCalledOnce();
+ expect(main.api.executeDesktopCommand).not.toHaveBeenCalled();
});
- it.each(['failed', 'cancelled'] as const)(
- 'does not create a task when source preparation is %s',
- async (status) => {
- const id = readyCard();
- vi.stubGlobal('window', {
- electronAPI: { maker: main.api, prepareCindyMakeWorkspace: h.prepareWorkspace },
- });
- const result = prepareMakeSourceInStream(id, runId);
- // A stale ready source must not be actionable while preparation is running.
- expect(await startMakeCodeSession(id, runId)).toBeNull();
- main.push(runId, status, { source: { status, path: sourcePath } });
- await main.complete(runId, { status, source: { status, path: sourcePath } });
- expect(await result).toBeNull();
- expect(h.create).not.toHaveBeenCalled();
- },
- );
-
- it('coalesces concurrent clicks and opening a persisted target never replays its first message', async () => {
+ it('coalesces clicks and never replays a persisted task', async () => {
const id = readyCard();
- const create = deferred<{ id: string }>();
- h.create.mockReturnValue(create.promise);
+ const creation = deferred<string>();
+ h.startTask.mockReturnValueOnce(creation.promise);
const first = startMakeCodeSession(id, runId);
- const second = startMakeCodeSession(id, runId);
- expect(first).toBe(second);
+ expect(startMakeCodeSession(id, runId)).toBe(first);
const target = sid();
- create.resolve({ id: target });
+ creation.resolve(target);
expect(await first).toBe(target);
expect(await startMakeCodeSession(id, runId)).toBe(target);
- const restored = readyCard({ codeSessionId: target });
- expect(await startMakeCodeSession(restored, runId)).toBe(target);
- expect(h.create).toHaveBeenCalledOnce();
- expect(makerChatStore.sendMessage).toHaveBeenCalledOnce();
+ expect(h.startTask).toHaveBeenCalledOnce();
+ expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
});
- it.each(['cc', 'codex', 'pi'] as const)(
- 'inherits %s configuration when there is no runtime projection',
- async (agentKind) => {
- const id = readyCard();
- h.get.mockResolvedValue({
- agentKind,
- model: 'chosen',
- effort: 'medium',
- permissionMode: 'auto',
- providerId: null,
- fastMode: false,
- planModeEnabled: false,
- });
- const target = await startMakeCodeSession(id, runId);
- expect(h.create).toHaveBeenCalledWith(
- expect.objectContaining({
- agentKind,
- model: 'chosen',
- effort: 'medium',
- permissionMode: 'auto',
- providerId: null,
- }),
- );
- expect(makerChatStore.getSnapshot(target!).agentKind).toBe(
- agentKind === 'cc' ? 'claude-code' : agentKind,
- );
- },
- );
-
- it('does not inherit stale effort or provider when the runtime explicitly clears them', async () => {
+ it('preserves the exact request, derives a readable title and keeps title generation disabled', async () => {
const id = readyCard();
- h.get.mockResolvedValue({
- agentKind: 'codex',
- model: 'old',
- effort: 'high',
- providerId: 'old',
- permissionMode: 'ask',
- runtimeEffective: {
- agentKind: 'claude-code',
- model: 'current',
- effort: null,
- providerId: null,
- fastMode: false,
- },
+ const target = await startMakeCodeSession(id, runId);
+ expect(target).toBeTruthy();
+ expect(h.startTask).toHaveBeenCalledWith({
+ originSessionId: id,
+ runId,
+ request,
+ title: expect.stringContaining('修复滚动 保留 <b>原文</b>'),
});
- await startMakeCodeSession(id, runId);
- expect(h.create).toHaveBeenCalledWith(
- expect.objectContaining({ agentKind: 'cc', model: 'current', effort: '', providerId: null }),
- );
+ expect(makerChatStore.getSnapshot(target!).autoTitleDisabled).toBe(true);
+ expect(messages(id)[0].systemCardData?.codeSessionId).toBe(target);
});
- it.each(['rejected', 'thrown'])(
- 'keeps the created task and request draft when sending is %s',
- async (failure) => {
- const id = readyCard();
- const send = vi.mocked(makerChatStore.sendMessage);
- if (failure === 'rejected') send.mockResolvedValueOnce(false);
- else send.mockRejectedValueOnce(new Error('send failed'));
- const target = await startMakeCodeSession(id, runId);
- expect(target).toBeTruthy();
- expect(h.saveDraft).toHaveBeenCalledWith(target, {
- text: { type: 'doc', content: [{ type: 'text', text: request }] },
- attachments: [],
- });
- expect(messages(id)[0].systemCardData).toMatchObject({
- codeSessionId: target,
- codeSessionError: true,
- });
- expect(await startMakeCodeSession(id, runId)).toBe(target);
- expect(send).toHaveBeenCalledOnce();
- expect(h.create).toHaveBeenCalledOnce();
- },
- );
+ it('keeps an already-started task navigable when the sidebar refresh fails', async () => {
+ const id = readyCard();
+ h.get.mockRejectedValueOnce(new Error('refresh failed'));
+ const target = await startMakeCodeSession(id, runId);
+ expect(target).toBeTruthy();
+ expect(messages(id)[0].systemCardData?.codeSessionError).toBe(false);
+ expect(h.startTask).toHaveBeenCalledOnce();
+ });
- it('allows a failed creation to be retried without sending to the original task', async () => {
+ it('allows a failed IPC start to retry without sending from Renderer', async () => {
const id = readyCard();
- h.create.mockRejectedValueOnce(new Error('create failed'));
+ h.startTask.mockRejectedValueOnce(new Error('start failed'));
expect(await startMakeCodeSession(id, runId)).toBeNull();
expect(messages(id)[0].systemCardData?.codeSessionError).toBe(true);
+ expect(await startMakeCodeSession(id, runId)).toBeTruthy();
+ expect(h.startTask).toHaveBeenCalledTimes(2);
expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
- const target = await startMakeCodeSession(id, runId);
- expect(target).toBeTruthy();
- expect(target).not.toBe(id);
- expect(makerChatStore.sendMessage).toHaveBeenCalledOnce();
});
- it('does not start or publish a task after the data owner changes during creation', async () => {
+ it("does not publish another account's task after an owner switch", async () => {
const id = readyCard();
- const create = deferred<{ id: string }>();
- h.create.mockReturnValue(create.promise);
+ const creation = deferred<string>();
+ h.startTask.mockReturnValueOnce(creation.promise);
const result = startMakeCodeSession(id, runId);
- await vi.waitFor(() => expect(h.create).toHaveBeenCalledOnce());
setDataOwnerGeneration('another-owner');
- create.resolve({ id: sid() });
+ creation.resolve(sid());
expect(await result).toBeNull();
expect(h.prepend).not.toHaveBeenCalled();
expect(makerChatStore.sendMessage).not.toHaveBeenCalled();
diff --git a/apps/desktop/src/renderer/lib/__tests__/cindyMakeState.test.ts b/apps/desktop/src/renderer/lib/__tests__/cindyMakeState.test.ts
new file mode 100644
index 0000000000..0aa623f8e5
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/__tests__/cindyMakeState.test.ts
@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cindyMakeState } from '../cindyMakeState';
+import { getDataOwnerGeneration, setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import type { CindyMakeGlobalState } from '../../../shared/cindyMakeDoctor';
+
+const subscriptions: Array<() => void> = [];
+let push: (state: CindyMakeGlobalState) => void;
+let resolve: (state: CindyMakeGlobalState) => void;
+let api: {
+ getCindyMakeState: ReturnType<typeof vi.fn>;
+ onCindyMakeState: ReturnType<typeof vi.fn>;
+};
+beforeEach(() => {
+ setDataOwnerGeneration('make-state-owner');
+ api = {
+ getCindyMakeState: vi.fn(
+ () =>
+ new Promise<CindyMakeGlobalState>((done) => {
+ resolve = done;
+ }),
+ ),
+ onCindyMakeState: vi.fn((listener) => {
+ push = listener;
+ return vi.fn();
+ }),
+ };
+ vi.stubGlobal('window', { electronAPI: api });
+});
+afterEach(() => {
+ subscriptions.splice(0).forEach((unsubscribe) => unsubscribe());
+ vi.unstubAllGlobals();
+});
+function subscribe() {
+ const listener = vi.fn();
+ subscriptions.push(cindyMakeState.subscribe(listener));
+ return listener;
+}
+
+describe('read-only Main Cindy Make state', () => {
+ it('shares one subscription between Settings, task cards and the sidebar', () => {
+ const first = subscribe();
+ const second = subscribe();
+ const state: CindyMakeGlobalState = {
+ source: { status: 'preparing', path: '/source', phase: 'installing' },
+ };
+ push(state);
+ expect(api.onCindyMakeState).toHaveBeenCalledOnce();
+ expect(first).toHaveBeenCalledOnce();
+ expect(second).toHaveBeenCalledOnce();
+ expect(cindyMakeState.getSnapshot()).toBe(state);
+ });
+
+ it('never replaces newer progress with a stale initial read', async () => {
+ subscribe();
+ const state: CindyMakeGlobalState = { source: { status: 'ready', path: '/source' } };
+ push(state);
+ resolve({ source: { status: 'preparing', path: '/source' } });
+ await Promise.resolve();
+ expect(cindyMakeState.getSnapshot()).toBe(state);
+ expect(cindyMakeState.isLoaded()).toBe(true);
+ });
+
+ it('rejects late responses from a disconnected view', async () => {
+ subscribe();
+ const oldResolve = resolve;
+ subscriptions.pop()!();
+ subscribe();
+ const state: CindyMakeGlobalState = { source: { status: 'ready', path: '/source' } };
+ push(state);
+ oldResolve({ source: { status: 'missing', path: '/old' } });
+ await Promise.resolve();
+ expect(cindyMakeState.getSnapshot()).toBe(state);
+ });
+
+ it('rejects stale account pushes and reconnects with an empty account snapshot', async () => {
+ subscribe();
+ const oldPush = push;
+ const oldOwner = getDataOwnerGeneration();
+ setDataOwnerGeneration('other-owner');
+ subscribe();
+ expect(cindyMakeState.getSnapshot()).toEqual({});
+ oldPush({ source: { status: 'ready', path: '/old' } });
+ push({
+ source: { status: 'ready', path: '/old' },
+ ownerStamp: { dataOwnerId: oldOwner.dataOwnerId, ownerGeneration: oldOwner.generation },
+ });
+ expect(cindyMakeState.getSnapshot()).toEqual({});
+ resolve({ source: { status: 'missing', path: '/current' } });
+ await Promise.resolve();
+ expect(cindyMakeState.getSnapshot().source?.path).toBe('/current');
+ });
+});
diff --git a/apps/desktop/src/renderer/lib/cindyMakeCommand.ts b/apps/desktop/src/renderer/lib/cindyMakeCommand.ts
index 221dce4b56..b1f759f426 100644
--- a/apps/desktop/src/renderer/lib/cindyMakeCommand.ts
+++ b/apps/desktop/src/renderer/lib/cindyMakeCommand.ts
@@ -56,6 +56,12 @@ export interface CindyMakeCommandInput {
type MakeCommandResult =
| { kind: 'none' | 'stale' | 'failed' }
| { kind: 'blocked'; messageKey: string }
+ | {
+ kind: 'preflight';
+ request: string;
+ sessionId?: string;
+ createOptions: CindyMakeCommandInput['createOptions'];
+ }
| { kind: 'started'; sessionId: string };
/** Native entry shared by home and existing-task composers, before model/send gates. */
@@ -109,15 +115,20 @@ export async function tryStartCindyMakeCommand(
if (input.remoteHostId || input.deviceId !== null) {
return { kind: 'blocked', messageKey: `${copy}.localOnly` };
}
+ if (match.invocation.command === 'cindy-make') {
+ if (match.invocation.request.length > 4000)
+ return { kind: 'blocked', messageKey: 'cindyMake.usage' };
+ return {
+ kind: 'preflight',
+ request: match.invocation.request,
+ sessionId: input.sessionId,
+ createOptions: input.createOptions,
+ };
+ }
const sessionId = await ensureMakeTask({
sessionId: input.sessionId,
createOptions: input.createOptions,
- title:
- match.kind === 'start'
- ? match.invocation.command === 'cindy-make'
- ? match.invocation.request.trim().replace(/\s+/g, ' ').slice(0, 80)
- : 'Cindy Make 环境检查'
- : undefined,
+ title: 'Cindy Make 环境检查',
isCurrent,
});
if (!sessionId || !isCurrent()) return { kind: 'stale' };
diff --git a/apps/desktop/src/renderer/lib/cindyMakeComposer.ts b/apps/desktop/src/renderer/lib/cindyMakeComposer.ts
new file mode 100644
index 0000000000..f2f8723c99
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/cindyMakeComposer.ts
@@ -0,0 +1,59 @@
+import type { Session } from './ccAgent.types';
+import type { ChatMessage } from './makerChatStore';
+import type { MakeDoctorReport, CindyMakeTaskPreparation } from '../../shared/cindyMakeDoctor';
+import { CINDY_MAKE_SESSION_SOURCE } from '../../shared/cindyMakeSession';
+
+export type CindyMakeComposerPhase =
+ Exclude<CindyMakeTaskPreparation['phase'], 'completed'> | 'executing' | 'failed' | 'cancelled';
+
+type MakeSession = Pick<
+ Session,
+ 'id' | 'source' | 'clearedAt' | 'lastTurnEndedAt' | 'interruptedTurnStartedAt'
+>;
+
+/** Preparation completion means dispatch accepted, not the end of the first execution. */
+export function getCindyMakeComposerPhase({
+ session,
+ report,
+ messages,
+ historyLoaded,
+ busy,
+ error,
+}: {
+ session: MakeSession | null;
+ report?: MakeDoctorReport;
+ messages: readonly ChatMessage[];
+ historyLoaded: boolean;
+ busy: boolean;
+ error: string | null;
+}): CindyMakeComposerPhase | null {
+ if (session?.source !== CINDY_MAKE_SESSION_SOURCE || session.clearedAt) return null;
+ // Main persists this only at a product-turn terminal, not while waiting for
+ // questions, plan review, permission, or an automatic continuation. It also
+ // survives remounts and keeps later manual turns from locking the composer.
+ if (session.lastTurnEndedAt != null) return null;
+
+ const saved = messages.find(
+ (message) =>
+ message.systemCardType === 'cindy-make' &&
+ (message.systemCardData?.report as MakeDoctorReport | undefined)?.task?.sessionId ===
+ session.id,
+ )?.systemCardData?.report as MakeDoctorReport | undefined;
+ const preparation = report?.task?.sessionId === session.id ? report : saved;
+ if (!preparation) return historyLoaded ? null : 'waiting';
+ if (preparation.status === 'failed' || preparation.status === 'cancelled')
+ return preparation.status;
+ if (preparation.status === 'running')
+ return preparation.task?.phase === 'completed'
+ ? 'executing'
+ : (preparation.task?.phase ?? 'waiting');
+
+ // Old history can arrive before the session patch. An interrupted/failed
+ // execution must leave the existing recovery controls and manual input usable.
+ if (
+ (!busy && (error || session.interruptedTurnStartedAt != null)) ||
+ messages.some((message) => !message.parentToolUseId && message.turnCompleted === true)
+ )
+ return null;
+ return 'executing';
+}
diff --git a/apps/desktop/src/renderer/lib/cindyMakeDoctorStream.ts b/apps/desktop/src/renderer/lib/cindyMakeDoctorStream.ts
index 0b3045dd7a..fe92359bbe 100644
--- a/apps/desktop/src/renderer/lib/cindyMakeDoctorStream.ts
+++ b/apps/desktop/src/renderer/lib/cindyMakeDoctorStream.ts
@@ -8,111 +8,64 @@ import { sessionsStore } from './sessionsStore';
import { startMakeDoctor } from './cindyMakeDoctor';
import type { MakeDoctorReport, MakeUpstreamDecision } from '../../shared/cindyMakeDoctor';
import type { CindyMakeInvocation } from './cindyMakeCommand';
-import { CINDY_MAKE_SESSION_SOURCE } from '../../shared/cindyMakeSession';
import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
-import { plainTextToTiptapDoc, saveDraft } from './composerDraftStore';
+import i18n from '@/i18n';
// Only coalesce concurrent clicks. The created task id lives in the persisted card.
const codeSessionStarts = new Map<string, Promise<string | null>>();
-/** Create an ordinary code task and send the original request through the normal send path. */
export function startMakeCodeSession(sessionId: string, runId: string): Promise<string | null> {
const owner = getDataOwnerGeneration();
- const key = `${owner}:${sessionId}:${runId}`;
+ const key = [owner.dataOwnerId, owner.generation, sessionId, runId].join(':');
const pending = codeSessionStarts.get(key);
if (pending) return pending;
if (getStickySessionDeviceId(sessionId)) return Promise.resolve(null);
- const currentCard = () =>
- makerChatStore
- .getSnapshot(sessionId)
- .messages.find(
- (row) =>
- row.systemCardType === 'cindy-make' &&
- (row.systemCardData?.report as MakeDoctorReport | undefined)?.runId === runId,
- );
- const message = currentCard();
+ const message = makerChatStore
+ .getSnapshot(sessionId)
+ .messages.find(
+ (row) =>
+ row.systemCardType === 'cindy-make' &&
+ (row.systemCardData?.report as MakeDoctorReport | undefined)?.runId === runId,
+ );
const data = message?.systemCardData;
const report = data?.report as MakeDoctorReport | undefined;
- const source = report?.source;
const request = typeof data?.request === 'string' ? data.request : '';
- if (
- !message ||
- !request.trim() ||
- report?.status !== 'completed' ||
- source?.status !== 'ready' ||
- !source.path ||
- data?.decision !== 'personal'
- )
+ if (!message || !request.trim() || !report || data?.decision !== 'personal')
return Promise.resolve(null);
- // Opening an existing task must never replay its first message, including after reload.
if (typeof data.codeSessionId === 'string') return Promise.resolve(data.codeSessionId);
- const isCurrent = () =>
- isDataOwnerGenerationCurrent(owner) && currentCard()?.clientId === message.clientId;
const update = (patch: Record<string, unknown>) => {
- if (isCurrent()) makerChatStore.updateSystemCardData(sessionId, message.clientId, patch);
+ if (isDataOwnerGenerationCurrent(owner))
+ makerChatStore.updateSystemCardData(sessionId, message.clientId, patch);
};
- const start = async (): Promise<string | null> => {
- let createdId: string | null = null;
+ const start = async () => {
+ update({ codeStartPhase: 'session', codeSessionError: false });
try {
- const origin = await sessionService.get(sessionId);
- if (!isCurrent() || origin.remoteHostId || origin.deviceLinkDeviceId) return null;
- const profile = origin.runtimeEffective;
- const agentKind =
- profile?.agentKind === 'claude-code' ? 'cc' : (profile?.agentKind ?? origin.agentKind);
- // Each task works in its own worktree branched from the personal baseline;
- // the managed checkout itself is never a task's working directory.
- update({ codeStartPhase: 'workspace' });
- const workspace = await window.electronAPI.prepareCindyMakeWorkspace(runId);
- if (!isCurrent()) return null;
- update({ codeStartPhase: 'session', codeWorkspace: workspace });
- const session = await sessionService.create({
- workingDir: workspace.path,
- workspaceKind: 'project',
- // Persisted purpose: Main hydrates the cindy_make tool and task note from it.
- source: CINDY_MAKE_SESSION_SOURCE,
- agentKind,
- model: profile?.model ?? origin.model,
- effort: profile ? (profile.effort ?? '') : origin.effort,
- providerId: profile ? profile.providerId : origin.providerId,
- fastMode: profile?.fastMode ?? origin.fastMode,
- permissionMode: origin.permissionMode,
- planModeEnabled: origin.planModeEnabled ?? false,
- });
- if (!isCurrent()) return null;
- createdId = session.id;
- sessionsStore.prependCreated(session);
- update({ codeSessionId: session.id, codeSessionError: false });
- makerChatStore.setSessionRuntime(session.id, {
- agentKind: session.agentKind === 'cc' ? 'claude-code' : session.agentKind,
- fastMode: session.fastMode,
- planModeEnabled: session.planModeEnabled ?? false,
- remoteHostId: null,
+ const requestChars = Array.from(request.replace(/\s+/gu, ' ').trim());
+ const title = i18n.t('cindyMake.code.taskTitle', {
+ request:
+ requestChars.length > 60
+ ? requestChars.slice(0, 60).join('') + '…'
+ : requestChars.join(''),
});
- makerChatStore.mirrorSessionFields(session.id, { providerId: session.providerId ?? null });
- const accepted = await makerChatStore.sendMessage(
- session.id,
+ const createdId = await window.electronAPI.startCindyMakeTask({
+ originSessionId: sessionId,
+ runId,
request,
- session.model,
- session.effort,
- session.permissionMode,
- workspace.path,
- );
- if (!accepted && isCurrent()) {
- saveDraft(session.id, { text: plainTextToTiptapDoc(request), attachments: [] });
- update({ codeSessionError: true, codeStartPhase: undefined });
- }
- return isCurrent() ? session.id : null;
+ title,
+ });
+ if (!isDataOwnerGenerationCurrent(owner)) return null;
+ update({ codeSessionId: createdId, codeStartPhase: undefined, codeSessionError: false });
+ makerChatStore.setSessionRuntime(createdId, { autoTitleDisabled: true });
+ const session = await sessionService.get(createdId).catch(() => null);
+ if (!isDataOwnerGenerationCurrent(owner)) return null;
+ if (session) sessionsStore.prependCreated(session);
+ return createdId;
} catch {
- if (createdId && isCurrent()) {
- saveDraft(createdId, { text: plainTextToTiptapDoc(request), attachments: [] });
- }
update({ codeSessionError: true, codeStartPhase: undefined });
- return isCurrent() ? createdId : null;
+ return null;
}
};
- const result = start().finally(() => {
- codeSessionStarts.delete(key);
- });
+ const result = start().finally(() => codeSessionStarts.delete(key));
codeSessionStarts.set(key, result);
return result;
}
@@ -222,7 +175,6 @@ export function startMakeDoctorInStream(
);
}
-/** After the three preparation steps, the personal choice creates the code task. */
export async function chooseMakeUpstream(
sessionId: string,
runId: string,
@@ -238,22 +190,15 @@ export async function chooseMakeUpstream(
const report = message?.systemCardData?.report as MakeDoctorReport | undefined;
if (
!message ||
- !report ||
- report.status !== 'completed' ||
+ report?.status !== 'completed' ||
!['found', 'notFound'].includes(report.upstream?.status ?? '') ||
message.systemCardData?.decision
)
return null;
makerChatStore.updateSystemCardData(sessionId, message.clientId, { decision });
- if (decision !== 'personal') return null;
- if (report.source?.status === 'ready' && report.source.path) {
- return startMakeCodeSession(sessionId, runId);
- }
- // Historical cards from the search-first workflow may not have a checkout yet.
- return prepareMakeSourceInStream(sessionId, runId);
+ return decision === 'personal' ? startMakeCodeSession(sessionId, runId) : null;
}
-/** Starts the Main-owned source checkout while keeping the existing message card. */
export async function prepareMakeSourceInStream(
sessionId: string,
runId: string,
@@ -265,102 +210,7 @@ export async function prepareMakeSourceInStream(
row.systemCardType === 'cindy-make' &&
(row.systemCardData?.report as MakeDoctorReport | undefined)?.runId === runId,
);
- const request =
- typeof message?.systemCardData?.request === 'string' ? message.systemCardData.request : '';
- if (
- !message ||
- !request.trim() ||
- typeof window === 'undefined' ||
- getStickySessionDeviceId(sessionId)
- )
- return null;
- const currentReport = message.systemCardData?.report as MakeDoctorReport | undefined;
- const pendingSource = currentReport?.source ?? { status: 'pending' as const, path: '' };
- const retainUpstream = (report: MakeDoctorReport): MakeDoctorReport => {
- const existing = makerChatStore
- .getSnapshot(sessionId)
- .messages.find((row) => row.clientId === message.clientId);
- const existingReport = existing?.systemCardData?.report as MakeDoctorReport | undefined;
- return {
- ...report,
- // Source reports describe only the checkout. Retain the actual results
- // from the earlier environment step instead of inventing new passes.
- checks: currentReport?.checks ?? report.checks,
- platform: report.platform || currentReport?.platform || '',
- arch: report.arch || currentReport?.arch || '',
- ...(report.upstream || existingReport?.upstream
- ? { upstream: report.upstream ?? existingReport?.upstream }
- : {}),
- ...(report.source || existingReport?.source
- ? { source: report.source ?? existingReport?.source }
- : {}),
- };
- };
- makerChatStore.updateSystemCardData(sessionId, message.clientId, {
- report: {
- ...(currentReport ?? {
- runId,
- platform: '',
- arch: '',
- checks: [],
- status: 'running' as const,
- }),
- mode: 'prepare',
- status: 'running',
- source: pendingSource,
- },
- request,
- decision: 'personal',
- });
- const owner = getDataOwnerGeneration();
- const isCurrent = () =>
- isDataOwnerGenerationCurrent(owner) &&
- (
- makerChatStore
- .getSnapshot(sessionId)
- .messages.find((row) => row.clientId === message.clientId)?.systemCardData?.report as
- MakeDoctorReport | undefined
- )?.runId === runId;
- let unsubscribe = () => {};
- unsubscribe = window.electronAPI.maker.onDesktopCommandTriggered((event) => {
- if (!isCurrent() || event.command !== 'cindy-make') return;
- const report = event.doctorReport as MakeDoctorReport | undefined;
- if (!report || report.runId !== runId) return;
- makerChatStore.updateSystemCardData(sessionId, message.clientId, {
- // The follow-up Main command receives only the request and run id. Keep the
- // upstream lookup from the original card while its source checkout progresses.
- report: retainUpstream(report),
- request,
- decision: 'personal',
- });
- if (
- ['completed', 'failed', 'cancelled'].includes(report.status) &&
- report.source?.status !== 'preparing'
- ) {
- unsubscribe();
- }
- });
- return window.electronAPI.maker
- .executeDesktopCommand('cindy-make', {
- doctorRunId: runId,
- makeAction: 'prepare-source',
- makeRequest: request,
- ...(currentReport?.forceManagedTools ? { forceManagedTools: true } : {}),
- })
- .then((result) => {
- const report = result?.doctorReport as MakeDoctorReport | undefined;
- if (isCurrent() && report?.runId === runId) {
- makerChatStore.updateSystemCardData(sessionId, message.clientId, {
- report: retainUpstream(report),
- request,
- decision: 'personal',
- });
- if (report.status === 'completed' && report.source?.status === 'ready') {
- return startMakeCodeSession(sessionId, runId);
- }
- }
- return null;
- })
- .catch(() => null)
- .finally(() => unsubscribe());
+ if (!message || getStickySessionDeviceId(sessionId)) return null;
+ makerChatStore.updateSystemCardData(sessionId, message.clientId, { decision: 'personal' });
+ return startMakeCodeSession(sessionId, runId);
}
diff --git a/apps/desktop/src/renderer/lib/cindyMakeState.ts b/apps/desktop/src/renderer/lib/cindyMakeState.ts
new file mode 100644
index 0000000000..3d2e7d0d9f
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/cindyMakeState.ts
@@ -0,0 +1,100 @@
+import { useCallback, useSyncExternalStore } from 'react';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+ isDataOwnerPushCurrent,
+} from '@/contexts/dataOwnerGeneration';
+import type { CindyMakeGlobalState, MakeDoctorReport } from '../../shared/cindyMakeDoctor';
+
+const empty: CindyMakeGlobalState = {};
+let state: CindyMakeGlobalState = empty;
+let owner = getDataOwnerGeneration();
+let loaded = false;
+let unsubscribe: (() => void) | undefined;
+const listeners = new Set<() => void>();
+let connection = 0;
+
+function connect(): void {
+ if (!isDataOwnerGenerationCurrent(owner)) {
+ unsubscribe?.();
+ unsubscribe = undefined;
+ state = empty;
+ loaded = false;
+ owner = getDataOwnerGeneration();
+ }
+ if (unsubscribe || typeof window === 'undefined' || !window.electronAPI) return;
+ const generation = owner;
+ const connectionId = ++connection;
+ let pushed = false;
+ const apply = (next: CindyMakeGlobalState) => {
+ if (
+ connectionId !== connection ||
+ !isDataOwnerGenerationCurrent(generation) ||
+ !isDataOwnerPushCurrent(next.ownerStamp)
+ )
+ return false;
+ state = next;
+ loaded = true;
+ for (const listener of listeners) listener();
+ return true;
+ };
+ unsubscribe =
+ window.electronAPI.onCindyMakeState?.((next) => {
+ pushed = apply(next) || pushed;
+ }) ?? (() => {});
+ void Promise.resolve(window.electronAPI.getCindyMakeState?.())
+ .then((next) => {
+ if (next && !pushed) apply(next);
+ })
+ .catch(() => undefined);
+}
+
+export const cindyMakeState = {
+ async refresh(): Promise<void> {
+ const generation = getDataOwnerGeneration();
+ const previous = state;
+ const next = await window.electronAPI.getCindyMakeState?.();
+ if (
+ !next ||
+ !isDataOwnerGenerationCurrent(generation) ||
+ !isDataOwnerPushCurrent(next.ownerStamp) ||
+ state !== previous
+ )
+ return;
+ state = next;
+ loaded = true;
+ for (const listener of listeners) listener();
+ },
+ subscribe(listener: () => void): () => void {
+ listeners.add(listener);
+ connect();
+ return () => {
+ listeners.delete(listener);
+ if (listeners.size === 0) {
+ connection += 1;
+ unsubscribe?.();
+ unsubscribe = undefined;
+ }
+ };
+ },
+ getSnapshot(): CindyMakeGlobalState {
+ return isDataOwnerGenerationCurrent(owner) ? state : empty;
+ },
+ isLoaded(): boolean {
+ return loaded && isDataOwnerGenerationCurrent(owner);
+ },
+ taskForSession(sessionId: string): MakeDoctorReport | undefined {
+ return Object.values(cindyMakeState.getSnapshot().tasks ?? {}).find(
+ (report) => report.task?.sessionId === sessionId,
+ );
+ },
+};
+
+export function useCindyMakeState(): CindyMakeGlobalState {
+ const generation = getDataOwnerGeneration();
+ const subscribe = useCallback(
+ (listener: () => void) => cindyMakeState.subscribe(listener),
+ [generation.dataOwnerId, generation.generation],
+ );
+ return useSyncExternalStore(subscribe, cindyMakeState.getSnapshot, () => empty);
+}
diff --git a/apps/desktop/src/renderer/lib/makerChatStore.ts b/apps/desktop/src/renderer/lib/makerChatStore.ts
index 201370cb0a..69d2b94192 100644
--- a/apps/desktop/src/renderer/lib/makerChatStore.ts
+++ b/apps/desktop/src/renderer/lib/makerChatStore.ts
@@ -2403,6 +2403,8 @@ export interface SessionChatState {
taskUpdates?: ReadonlyMap<string, AgentTaskUpdate>;
isStreaming: boolean;
agentStatus: AgentStatus;
+ /** A task with an explicit product title must not be auto-renamed from its first message. */
+ autoTitleDisabled?: boolean;
error: string | null;
/** 当前 terminal error 是否为可恢复的账号用量限制,以及可识别的重置时刻。 */
usageLimitRecovery?: UsageLimitRecoveryHint | null;
@@ -13447,6 +13449,7 @@ function maybeAutoNameUnnamedSession(
agentKind: 'claude-code' | 'codex' | 'pi',
): void {
if (!seed?.isUserText) return;
+ if (sessions.get(sessionId)?.autoTitleDisabled === true) return;
scheduleAutoName(sessionId, seed.text, agentKind, true);
}
@@ -16165,6 +16168,8 @@ function setSessionRuntime(
planModeEnabled?: boolean;
/** Seed before SessionView hydrates the DB row; sendMessage reads this for SSH routing. */
remoteHostId?: string | null;
+ /** Disable automatic first-message renaming for product-owned titled sessions. */
+ autoTitleDisabled?: boolean;
},
): void {
if (!sessionId) return;
@@ -16175,11 +16180,13 @@ function setSessionRuntime(
const nextRemoteHostId = Object.hasOwn(opts, 'remoteHostId')
? (opts.remoteHostId ?? null)
: s.remoteHostId;
+ const nextAutoTitleDisabled = opts.autoTitleDisabled ?? s.autoTitleDisabled;
if (
s.agentKind === nextAgentKind &&
s.fastMode === nextFastMode &&
s.planModeEnabled === nextPlanMode &&
- s.remoteHostId === nextRemoteHostId
+ s.remoteHostId === nextRemoteHostId &&
+ s.autoTitleDisabled === nextAutoTitleDisabled
)
return s;
return {
@@ -16188,6 +16195,7 @@ function setSessionRuntime(
fastMode: nextFastMode,
planModeEnabled: nextPlanMode,
remoteHostId: nextRemoteHostId,
+ autoTitleDisabled: nextAutoTitleDisabled,
...(s.planModeEnabled !== nextPlanMode ? { planModeRev: s.planModeRev + 1 } : {}),
};
});
diff --git a/apps/desktop/src/renderer/lib/sessionService.ts b/apps/desktop/src/renderer/lib/sessionService.ts
index d5ef5d71ea..e65d4d310a 100644
--- a/apps/desktop/src/renderer/lib/sessionService.ts
+++ b/apps/desktop/src/renderer/lib/sessionService.ts
@@ -94,6 +94,7 @@ export async function list(
export async function create(body?: {
id?: string;
+ title?: string;
workingDir?: string;
workspaceKind?: WorkspaceKind;
model?: string;
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
index 914351a473..33f778e3ae 100644
--- a/apps/desktop/src/renderer/vite-env.d.ts
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -3007,6 +3007,7 @@ interface ElectronAPI {
openCindyMakeToolsDir: () => Promise<{ success: boolean }>;
getCindyMakeSourceStatus: () => Promise<import('../shared/cindyMakeDoctor').MakeSourceStatus>;
getCindyMakeState: () => Promise<import('../shared/cindyMakeDoctor').CindyMakeGlobalState>;
+ manageCindyMakeTask: (sessionId: string, action: 'finish' | 'delete') => Promise<void>;
openCindyMakeSourceDir: () => Promise<{ success: boolean }>;
onCindyMakeState: (
listener: (state: import('../shared/cindyMakeDoctor').CindyMakeGlobalState) => void,
@@ -3017,10 +3018,12 @@ interface ElectronAPI {
) => () => void;
/** Stop the running source operation from any window. */
cancelCindyMakeSource: () => Promise<{ success: boolean }>;
- /** Create the per-task worktree for a Cindy Make run; resolves with its path and branch. */
+ /** Compatibility entry point: prepare a worktree and its dependencies. */
prepareCindyMakeWorkspace: (
runId: string,
) => Promise<import('../shared/cindyMakeDoctor').MakeTaskWorkspace>;
+ startCindyMakeTask: (input: import('../shared/cindyMakeDoctor').CindyMakeTaskStart) => Promise<string>;
+ cancelCindyMakeTask: (runId: string) => Promise<{ success: boolean }>;
/**
* Reveal a file in the OS file manager (Explorer / Finder). Accepts either
diff --git a/apps/desktop/src/shared/cindyMakeDoctor.ts b/apps/desktop/src/shared/cindyMakeDoctor.ts
index cdb84507a9..f5115e06ba 100644
--- a/apps/desktop/src/shared/cindyMakeDoctor.ts
+++ b/apps/desktop/src/shared/cindyMakeDoctor.ts
@@ -55,6 +55,50 @@ export interface MakeDoctorReport {
forceManagedTools?: boolean;
upstream?: MakeUpstreamQuery;
source?: MakeSourcePreparation;
+ task?: CindyMakeTaskPreparation;
+}
+
+export interface CindyMakeTaskPreparation {
+ title?: string;
+ request?: string;
+ sessionId: string;
+ originSessionId?: string;
+ phase:
+ 'waiting' | 'environment' | 'source' | 'workspace' | 'dependencies' | 'starting' | 'completed';
+ dependencies?: MakeDependencyProgress;
+ /** Settings projection; preparation completion is not production completion. */
+ sessionStatus?: 'active' | 'archived' | 'deleted';
+ executing?: boolean;
+ /** Persisted only after the task directory and branch have both been reclaimed. */
+ finished?: boolean;
+}
+
+export interface MakeDependencyProgress {
+ /** Absent when pnpm only emits lifecycle activity (e.g. an up-to-date install). */
+ resolved?: number;
+ reused?: number;
+ downloaded?: number;
+ added?: number;
+ activity?: 'packages' | 'scripts';
+}
+
+export interface CindyMakeTaskOptions {
+ agentKind?: 'cc' | 'codex' | 'pi';
+ model?: string;
+ effort?: string;
+ providerId?: string | null;
+ permissionMode?: string;
+ fastMode?: boolean;
+ planModeEnabled?: boolean;
+}
+
+export interface CindyMakeTaskStart {
+ originSessionId?: string;
+ /** Home/settings entry has no origin task before the user chooses Continue. */
+ createOptions?: CindyMakeTaskOptions;
+ runId: string;
+ request: string;
+ title: string;
}
/** Main-owned snapshots for all Cindy Make resources. Renderer only subscribes. */
@@ -63,11 +107,32 @@ export interface CindyMakeOperationSnapshot {
report: MakeDoctorReport;
}
+export const CINDY_MAKE_TASK_ERROR_CODES = [
+ 'busy',
+ 'dirty',
+ 'conflict',
+ 'cleanupFailed',
+ 'unavailable',
+ 'directoryBusy',
+] as const;
+export type CindyMakeTaskError = (typeof CINDY_MAKE_TASK_ERROR_CODES)[number];
+export interface CindyMakeTaskActionState {
+ action: 'finish' | 'delete';
+ status: 'running' | 'failed';
+ error?: CindyMakeTaskError;
+}
+
export interface CindyMakeGlobalState {
+ ownerStamp?: import('./dataOwnerPush').DataOwnerPushStamp;
environmentCheck?: CindyMakeOperationSnapshot;
environmentPrepare?: CindyMakeOperationSnapshot;
sourcePrepare?: CindyMakeOperationSnapshot;
sourceClear?: CindyMakeOperationSnapshot;
+ source?: MakeSourceStatus;
+ reports?: Record<string, MakeDoctorReport>;
+ tasks?: Record<string, MakeDoctorReport>;
+ /** Current-owner cleanup jobs, keyed by session ID; independent of Settings lifetime. */
+ taskActions?: Record<string, CindyMakeTaskActionState>;
}
export interface MakeSourcePreparation {
@@ -99,8 +164,19 @@ export interface MakeSourcePreparation {
| 'installFailed'
| 'locked'
| 'cancelled';
- phase?: 'checking' | 'cloning' | 'fetching' | 'checkingOut' | 'preparingBranch' | 'installing';
+ phase?:
+ | 'waiting'
+ | 'checking'
+ | 'checkingRemote'
+ | 'checkingLocal'
+ | 'cloning'
+ | 'fetching'
+ | 'checkingOut'
+ | 'preparingBranch'
+ | 'caching'
+ | 'installing';
progress?: MakeSourceGitProgress;
+ dependencies?: MakeDependencyProgress;
}
/** A per-task worktree branched from the personal baseline; the code task's working directory. */
@@ -137,6 +213,7 @@ export interface MakeSourceStatus {
error?: MakeSourcePreparation['error'];
phase?: MakeSourcePreparation['phase'];
progress?: MakeSourceGitProgress;
+ dependencies?: MakeDependencyProgress;
}
export interface MakeUpstreamItem {
diff --git a/docs/cindy-make-upstream.md b/docs/cindy-make-upstream.md
index 9c48f7427d..1cccc0e27b 100644
--- a/docs/cindy-make-upstream.md
+++ b/docs/cindy-make-upstream.md
@@ -37,3 +37,74 @@
保持既有全局后台流程、源码准备和用户主动选择;不切分支、不合并 PR、不升级客户端。
历史消息中的 Issue 结果与缺少新字段的记录继续可读,新查询只产生 PR。
Main 负责网络和 Git,UI 只消费报告;运行版本摘要在结果详情内,主流程保持紧凑。
+
+## 个人版任务准备
+
+- 环境、个人版源码、任务分支和工作目录统一由 Main 的 `CindyMakeManager` 管理。
+ 源码准备/清理、任务工作目录创建/依赖安装、完成后的 Git 写操作共用项目队列,
+ 不再由 Settings、消息卡片或创建弹窗各自维护后台作业。发送入场与源码清理互斥,
+ 已进入发送事务或运行中的任务禁止清理源码;清理已开始时拒绝新的发送。
+- 输入 /cindy-make 需求后,在当前页面弹窗检查环境、准备个人版源码并查询上游;
+ 这段前置流程不创建任务、不创建 worktree;源码准备与 Settings 共用同一流程,
+ 准备 Git 内容后按锁文件预热依赖缓存,不生成个人分支的依赖目录或执行安装脚本。
+ 关闭弹窗或选择等待上游不会留下空任务。Settings 的制作入口与侧栏入口复用同一个弹窗。
+ 实现与确认边界回归见 [CindyMakePreflightDialog](../apps/desktop/src/renderer/components/cindy-make/CindyMakePreflightDialog.tsx)
+ 及其[测试](../apps/desktop/src/renderer/components/cindy-make/__tests__/CindyMakePreflightDialog.test.tsx)。
+- 选择「继续制作个人版」后,先创建带需求标题的任务并保存准备消息,再复核环境、
+ 个人项目源码、任务分支/工作目录和依赖。历史卡片缺少源码时也先创建任务,
+ 不让用户等待依赖安装结束才看到任务。首页和 Settings 直接创建这一个制作任务,
+ 不再为前置检查另建容器任务;已有任务入口继续继承来源任务的运行配置。
+- Settings、消息卡片/弹窗和侧栏读取同一个 Main 快照;准备卡显示实际阶段、工具下载量、
+ Git 阶段以及 pnpm 的解析/复用/下载/添加数量;安装开始与安装脚本执行另有状态提示,
+ 不伪造总进度。Settings 和前置弹窗均显示缓存预热的解析/复用/下载数量;
+ 缓存缺失或版本变化时按需补下载,任务 worktree 再复用缓存独立安装并执行安装脚本。
+ Settings 源码卡的底部状态常驻:区分等待其他工程操作、Git 检查、上游版本查询和本地源码检查,
+ 收起详情后仍显示当前阶段与已有进度。失败或停止时保留结果和原因,按钮为「重试准备」;
+ 点击重试立即切换到本轮状态,不沿用上一轮错误或进度。
+ 准备不冒充 Agent 正在执行。
+ 首阶段检查及源码准备也按 runId 从 Main 读取完整报告;Renderer 重载不退回过时的保存卡片。
+ Settings 重新检查后展示新检查,不用上一轮已完成的准备结果覆盖它。
+- 准备成功后由 Main 自动发送原始需求,通过既有发送事务继承模型、供应商、推理档位、
+ 权限、计划模式与 Fast 设置。确认后的任务准备不因切换任务或重载 Renderer 中止,
+ 也不会丢失首次发送;确认前关闭弹窗则停止该轮前置检查。
+- 从确认后的准备阶段到首次自动执行结束,普通输入区用飞书接管同款状态框替代,
+ 不接受输入、语音或附件拖入;Ask Question、Plan 和权限确认仍优先展示并正常操作。
+ 首轮结束后恢复输入,之后的手动执行不再锁定。准备失败/取消时提示从准备卡重试;
+ 执行中保留停止入口,执行失败或中断继续使用既有恢复入口。判定复用持久准备报告与
+ 主进程的执行结束记录,切换页面或重载不会提前解锁。
+ 见 [CindyMakeComposerMask](../apps/desktop/src/renderer/components/cindy-make/CindyMakeComposerMask.tsx)
+ 和[生命周期回归](../apps/desktop/src/renderer/lib/__tests__/cindyMakeComposer.test.ts)。
+- 失败或取消时不发送需求;显式重试复用原任务和分支。取消单个任务不会取消共享的
+ 环境/源码准备;全局准备的停止入口仍在 Settings。重复点击、打开已有任务不会再次派发。
+- 应用进程重启不静默重放请求。未完成的持久准备卡按已中断显示,用户可显式重试;不能仅凭
+ 已保存的用户消息推断 Agent 已成功执行。已确认完成的准备不会再次自动派发。
+ 清空任务立即取消本任务准备并使旧请求、旧卡片失效;清空前排队的首次请求不得再发送。
+ 任务被归档、工作目录改变或切换账号后,不再自动发送。
+- 个人项目或任务工作目录丢失时,阻止发送并提示恢复原工作目录或新建制作任务;不会进入
+ 通用 mkdir 恢复、在空目录执行,也不会偷偷重建源码来冒充已恢复原来的文件和分支。
+- Settings 的「未完成的制作」使用可搜索的列表/详情双栏;窄容器改为上下排列,列表和
+ 详情内容分别限高滚动,操作区始终可见。只展开当前选中任务的准备进度,已完成的准备步骤
+ 不再占据页面。准备完成或一轮执行结束不等于整个制作已完成,仍可打开任务继续修改。
+- 「打开任务」跳转到原任务;归档但未完成的任务先通过既有恢复入口重新激活,再跳转。
+ 「完成制作」要求执行已结束且没有未提交改动,将制作分支合入个人版后清理 worktree
+ (包括安装的依赖)和制作分支,保留已归档任务中的交流记录,随后从未完成列表移除。
+ 普通归档只回收已确认合入个人版的提交,未合入、未提交或尚无新提交的工作仍保留。
+- 「删除制作」确认后沿用既有删除流程,先停止准备与运行时再丢弃该任务的工作目录和分支。
+ 清理失败不标记完成,保留「待清理/重试清理」,重启后仍可重试;已删除的任务不提供恢复入口。
+ 只操作从合法 runId 派生且由该个人项目 Git 注册的目录,拒绝符号链接/junction 替换、
+ 仍在使用的目录和账号切换后的旧操作。合并冲突保留两侧修改,清理成功后才持久化完成标记。
+ Windows 清理启用 Git 长路径支持;Git 移除登记后仍残留目录时,仅显式删除允许续清理,
+ 必须同时匹配持久准备记录中的任务、路径与分支,确认原分支仍在、目录没有 `.git`,
+ 且该路径和分支都未登记在其它 worktree。删除前重新核验托管根与链接边界;目录删除成功
+ 才删除分支。文件占用时在操作区保留原因和重试入口,执行期间按钮显示加载状态。
+ 完成/删除操作及失败原因由 Main manager 按任务和当前账号持有,通过同一全局快照推送;
+ 退出设置不取消清理,重进设置或另开窗口继续显示「正在清理」,同一任务的重复请求共用
+ 在途操作。失败后保留原因直到重试;应用退出中断的清理在重启后显示「待清理」,由用户
+ 重试,不自动重放删除。临时的打开/确认弹窗状态才留在 Renderer。
+ 实现见 [taskManagement](../apps/desktop/src/main/cindy-make/taskManagement.ts),
+ [真实 Git 回归](../apps/desktop/src/main/cindy-make/__tests__/taskCleanup.git-integration.test.ts)
+ 覆盖合并、冲突保留、忽略目录与分支回收。
+- 此流程仍是本地 Desktop Cindy Make:拒绝 SSH 任务作为来源,不新增 device-link invoke
+ 白名单。手机可通过已有任务/消息同步读取保存的阶段文本,但没有新增原生准备控制卡,
+ 实时多端准备操作需单独适配。远端 Desktop 的准备卡只读,不能误调用查看端的停止/重试。
+ 本次不改 device-link 重试、超时或连接恢复策略。
diff --git a/docs/design-rules/design-decision-log.md b/docs/design-rules/design-decision-log.md
index 911a7dd8ca..9e764d0fd0 100644
--- a/docs/design-rules/design-decision-log.md
+++ b/docs/design-rules/design-decision-log.md
@@ -737,6 +737,10 @@ BORDER_BG → border-default,TEXT_PRIMARY/SECONDARY/TERTIARY → 对应 text
- 用户指出设置中的 placeholder 看起来与普通文字相同,要求降低其显著程度。CINDY Light/Dark
的 `text-placeholder` 改为沿用 DESIGN §4 的空输入色阶(Light `#C4C4C4` / Dark `#525252`),
不再复用三级文字;修改 DTCG 正本并生成内置主题,同时更新独立预期。其它文字色阶不变。
+- 用户要求多个未完成制作可容纳、可重新打开,归档可恢复,完成与放弃后清理。Settings 采用
+ 搜索+列表/详情双栏,560px 以下改为上下布局;只显示当前选中项详情,列表与详情内容
+ 分别滚动,底部操作不随长需求滚出。全部表面、边框、文字与焦点使用语义 token,按钮复用
+ 标准组件。完成、归档和删除的具体合同见 [Cindy Make](../cindy-make-upstream.md)。
- 这是根据用户反馈完成的实现决定,不代表用户已经对最终视觉签字验收。
## 2026-09-11 · DS-9 Desktop 范围与授权呈现
diff --git a/docs/design-rules/design-inventory.md b/docs/design-rules/design-inventory.md
index 09b9d4fd62..dfecb78bba 100644
--- a/docs/design-rules/design-inventory.md
+++ b/docs/design-rules/design-inventory.md
@@ -18,12 +18,12 @@
| `desktop.auth.add-account` | desktop | 添加账号 | hash `/add-account`(ProtectedRoute → AddAccountLoginPage) | AddAccountLoginPage | apps/desktop/src/renderer/components/login/AddAccountLoginPage.tsx, apps/desktop/src/renderer/components/login/LoginBrandStage.tsx, apps/desktop/src/renderer/components/login/LoginCaptchaOverlay.tsx, apps/desktop/src/renderer/components/login/LoginControls.tsx, apps/desktop/src/renderer/components/login/LoginPage.tsx, apps/desktop/src/renderer/components/login/loginDesignTokens.ts | 59 | 0 | 21 |
| `desktop.auth.legacy-migration` | desktop | 首登数据迁移弹窗 | App 顶层挂载 LegacyMigrationDialog(仅主窗;main 检测到旧版 userData 经 `legacy-migration:state` 驱动) | LegacyMigrationDialog | apps/desktop/src/renderer/components/auth/LegacyMigrationDialog.tsx | 8 | 0 | 2 |
| `desktop.auth.login` | desktop | 登录页 | hash `/login`(GuestRoute → LoginPage) | LoginBrandStage, LoginCaptchaOverlay, LoginControls, LoginPage | apps/desktop/src/renderer/components/login/LoginBrandStage.tsx, apps/desktop/src/renderer/components/login/LoginCaptchaOverlay.tsx, apps/desktop/src/renderer/components/login/LoginControls.tsx, apps/desktop/src/renderer/components/login/LoginPage.tsx, apps/desktop/src/renderer/components/login/loginDesignTokens.ts | 59 | 0 | 21 |
-| `desktop.bots` | desktop | 伙伴(列表 / 对话 / 设置 / 历史 / 伙伴私聊) | hash `/bots`、`/bots/:botId`、`/bots/roster` 及伙伴当前/历史任务、伙伴私聊路由(BotsFeatureLayout) | BotBasicProfileFields, BotCollaborationCard, BotDirectMessageView, BotHistorySessionView, BotLifecycleSettings, BotModelChainEditor, BotRosterView, BotSessionView, BotSettingsDrawer, BotsHomeView, RemoteBotSessionView | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/bots/BotAuthorizationCard.tsx, apps/desktop/src/renderer/features/bots/BotAvatar.tsx, apps/desktop/src/renderer/features/bots/BotBasicProfileFields.tsx, apps/desktop/src/renderer/features/bots/BotCapabilitySettings.tsx, apps/desktop/src/renderer/features/bots/BotCollaborationCard.tsx, apps/desktop/src/renderer/features/bots/BotConnectionStatus.tsx, apps/desktop/src/renderer/features/bots/BotCreateMenu.tsx, apps/desktop/src/renderer/features/bots/BotDeleteDialog.tsx, apps/desktop/src/renderer/features/bots/BotDirectMessageCard.tsx, apps/desktop/src/renderer/features/bots/BotDirectMessageView.tsx, apps/desktop/src/renderer/features/bots/BotHistorySessionView.tsx, apps/desktop/src/renderer/features/bots/BotInvitationWelcome.tsx, apps/desktop/src/renderer/features/bots/BotLifecycleSettings.tsx, apps/desktop/src/renderer/features/bots/BotModelChainEditor.tsx, apps/desktop/src/renderer/features/bots/BotPortraitPicker.tsx, apps/desktop/src/renderer/features/bots/BotRosterView.tsx, apps/desktop/src/renderer/features/bots/BotRoutines.tsx, apps/desktop/src/renderer/features/bots/BotSessionContentHeader.tsx, apps/desktop/src/renderer/features/bots/BotSessionView.tsx, apps/desktop/src/renderer/features/bots/BotSettingsBlock.tsx, apps/desktop/src/renderer/features/bots/BotSettingsDrawer.tsx, apps/desktop/src/renderer/features/bots/BotsFeatureLayout.tsx, apps/desktop/src/renderer/features/bots/BotsGlobalSettingsSection.tsx, apps/desktop/src/renderer/features/bots/BotsHomeView.tsx, apps/desktop/src/renderer/features/bots/BotsSidebar.tsx, apps/desktop/src/renderer/features/bots/RemoteBotSessionView.tsx, apps/desktop/src/renderer/features/bots/botAvatarIdentity.ts, apps/desktop/src/renderer/features/bots/botCapabilityDefaults.ts, apps/desktop/src/renderer/features/bots/botChatPresentation.ts, apps/desktop/src/renderer/features/bots/botConversationTimeline.ts, apps/desktop/src/renderer/features/bots/botDelegationLive.ts, apps/desktop/src/renderer/features/bots/botGeneratedArtifacts.ts, apps/desktop/src/renderer/features/bots/botListDisplay.ts, apps/desktop/src/renderer/features/bots/botNavigation.ts, apps/desktop/src/renderer/features/bots/botPronounContext.tsx, apps/desktop/src/renderer/features/bots/botReadState.ts, apps/desktop/src/renderer/features/bots/botRosterDisplay.ts, apps/desktop/src/renderer/features/bots/botSessionOwners.ts, apps/desktop/src/renderer/features/bots/botSettingsAutosave.ts, apps/desktop/src/renderer/features/bots/botStore.ts, apps/desktop/src/renderer/features/bots/remoteBotRoster.ts, apps/desktop/src/renderer/features/bots/useBotIslandVisibleSession.ts, apps/desktop/src/renderer/features/bots/useBotSettingsAutosave.ts, apps/desktop/src/renderer/features/bots/useRemoteBots.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx | 293 | 46 | 502 |
+| `desktop.bots` | desktop | 伙伴(列表 / 对话 / 设置 / 历史 / 伙伴私聊) | hash `/bots`、`/bots/:botId`、`/bots/roster` 及伙伴当前/历史任务、伙伴私聊路由(BotsFeatureLayout) | BotBasicProfileFields, BotCollaborationCard, BotDirectMessageView, BotHistorySessionView, BotLifecycleSettings, BotModelChainEditor, BotRosterView, BotSessionView, BotSettingsDrawer, BotsHomeView, RemoteBotSessionView | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/bots/BotAuthorizationCard.tsx, apps/desktop/src/renderer/features/bots/BotAvatar.tsx, apps/desktop/src/renderer/features/bots/BotBasicProfileFields.tsx, apps/desktop/src/renderer/features/bots/BotCapabilitySettings.tsx, apps/desktop/src/renderer/features/bots/BotCollaborationCard.tsx, apps/desktop/src/renderer/features/bots/BotConnectionStatus.tsx, apps/desktop/src/renderer/features/bots/BotCreateMenu.tsx, apps/desktop/src/renderer/features/bots/BotDeleteDialog.tsx, apps/desktop/src/renderer/features/bots/BotDirectMessageCard.tsx, apps/desktop/src/renderer/features/bots/BotDirectMessageView.tsx, apps/desktop/src/renderer/features/bots/BotHistorySessionView.tsx, apps/desktop/src/renderer/features/bots/BotInvitationWelcome.tsx, apps/desktop/src/renderer/features/bots/BotLifecycleSettings.tsx, apps/desktop/src/renderer/features/bots/BotModelChainEditor.tsx, apps/desktop/src/renderer/features/bots/BotPortraitPicker.tsx, apps/desktop/src/renderer/features/bots/BotRosterView.tsx, apps/desktop/src/renderer/features/bots/BotRoutines.tsx, apps/desktop/src/renderer/features/bots/BotSessionContentHeader.tsx, apps/desktop/src/renderer/features/bots/BotSessionView.tsx, apps/desktop/src/renderer/features/bots/BotSettingsBlock.tsx, apps/desktop/src/renderer/features/bots/BotSettingsDrawer.tsx, apps/desktop/src/renderer/features/bots/BotsFeatureLayout.tsx, apps/desktop/src/renderer/features/bots/BotsGlobalSettingsSection.tsx, apps/desktop/src/renderer/features/bots/BotsHomeView.tsx, apps/desktop/src/renderer/features/bots/BotsSidebar.tsx, apps/desktop/src/renderer/features/bots/RemoteBotSessionView.tsx, apps/desktop/src/renderer/features/bots/botAvatarIdentity.ts, apps/desktop/src/renderer/features/bots/botCapabilityDefaults.ts, apps/desktop/src/renderer/features/bots/botChatPresentation.ts, apps/desktop/src/renderer/features/bots/botConversationTimeline.ts, apps/desktop/src/renderer/features/bots/botDelegationLive.ts, apps/desktop/src/renderer/features/bots/botGeneratedArtifacts.ts, apps/desktop/src/renderer/features/bots/botListDisplay.ts, apps/desktop/src/renderer/features/bots/botNavigation.ts, apps/desktop/src/renderer/features/bots/botPronounContext.tsx, apps/desktop/src/renderer/features/bots/botReadState.ts, apps/desktop/src/renderer/features/bots/botRosterDisplay.ts, apps/desktop/src/renderer/features/bots/botSessionOwners.ts, apps/desktop/src/renderer/features/bots/botSettingsAutosave.ts, apps/desktop/src/renderer/features/bots/botStore.ts, apps/desktop/src/renderer/features/bots/remoteBotRoster.ts, apps/desktop/src/renderer/features/bots/useBotIslandVisibleSession.ts, apps/desktop/src/renderer/features/bots/useBotSettingsAutosave.ts, apps/desktop/src/renderer/features/bots/useRemoteBots.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx | 293 | 46 | 503 |
| `desktop.chat.files` | desktop | 工作目录文件浏览 | hash `/cc-agent/files/:sessionId`(WorkdirBrowseRoute) | FileBodyView, FileTreeView, WorkdirBrowseRoute | apps/desktop/src/renderer/features/cc-agent/workdir-browse/DocSearchBar.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/DrawioPreview.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/FileBodyView.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/FileFilterInput.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/FileTabsBar.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/FileTreeView.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/FilterResultList.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/ImagePreview.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/OpenInSystemActions.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/PdfPreview.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/SessionTabsBar.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/UnrenderablePlaceholder.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/WorkdirBrowseRoute.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/WorkdirBrowseSidebar.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useChatRailCollapsed.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useChatRailResize.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useConfirmSwitchAwayIfDirty.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useDelayedFlag.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useFileContent.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useFileTree.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useOpenTabs.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useProjectFileList.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/hooks/useRevealFileInTree.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/activeFileBodyHandle.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/docModeSwitchProjects.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/drawioExt.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/expandedStore.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/fileContentCache.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/fileIcon.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/fileMeta.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/fileScrollStore.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/fileSelectionParams.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/filterFiles.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/imageExt.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/markdownAutosave.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/openTabsStore.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/pdfExt.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/lib/selectedFileStore.ts, apps/desktop/src/renderer/features/cc-agent/workdir-browse/search/SearchInput.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/search/SearchPanel.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/search/SearchResults.tsx, apps/desktop/src/renderer/features/cc-agent/workdir-browse/search/hooks/useProjectSearch.ts | 22 | 7 | 64 |
| `desktop.chat.new-draft` | desktop | 新建任务草稿页 | hash `/cc-agent/new`(NewMakerDraftRoute) | NewMakerDraftRoute | apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx | 15 | 0 | 2 |
-| `desktop.chat.orca-workflow` | desktop | Orca 协同工作台 | hash `/cc-agent/orca/:sessionId`(OrcaWorkflowRoute) | CCAgentSessionView, OrcaSplitView, OrcaWorkerPanel, OrcaWorkflowRoute | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaSplitView.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaWorkflowRoute.tsx | 273 | 46 | 408 |
+| `desktop.chat.orca-workflow` | desktop | Orca 协同工作台 | hash `/cc-agent/orca/:sessionId`(OrcaWorkflowRoute) | CCAgentSessionView, OrcaSplitView, OrcaWorkerPanel, OrcaWorkflowRoute | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaSplitView.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaWorkerPanel.tsx, apps/desktop/src/renderer/features/cc-agent/OrcaWorkflowRoute.tsx | 273 | 46 | 409 |
| `desktop.chat.scheduled` | desktop | 调度任务列表 | hash `/cc-agent/scheduled`(SchedulerPage) | SchedulerPage | apps/desktop/src/renderer/features/scheduler/SchedulerPage.tsx, apps/desktop/src/renderer/features/scheduler/components/AgentMark.tsx, apps/desktop/src/renderer/features/scheduler/components/BoundSessionCard.tsx, apps/desktop/src/renderer/features/scheduler/components/ProjectAutomationNotifyBridge.tsx, apps/desktop/src/renderer/features/scheduler/components/RunHistoryCard.tsx, apps/desktop/src/renderer/features/scheduler/components/RunHistoryPane.tsx, apps/desktop/src/renderer/features/scheduler/components/ScheduleChips.tsx, apps/desktop/src/renderer/features/scheduler/components/ScheduleFormDialog.tsx, apps/desktop/src/renderer/features/scheduler/components/ScheduleSessionIndexOwner.tsx, apps/desktop/src/renderer/features/scheduler/components/ScheduleStatusChip.tsx, apps/desktop/src/renderer/features/scheduler/components/ScriptCapabilityMultiSelect.tsx, apps/desktop/src/renderer/features/scheduler/components/TaskListCell.tsx, apps/desktop/src/renderer/features/scheduler/components/TaskListFilterPopover.tsx, apps/desktop/src/renderer/features/scheduler/components/TaskListPane.tsx, apps/desktop/src/renderer/features/scheduler/components/TemplateCard.tsx, apps/desktop/src/renderer/features/scheduler/components/TemplateGallery.tsx, apps/desktop/src/renderer/features/scheduler/components/TemplateParamForm.tsx, apps/desktop/src/renderer/features/scheduler/hooks/useDeleteScheduleWithSessions.tsx, apps/desktop/src/renderer/features/scheduler/hooks/useReadFailedScheduleRuns.ts, apps/desktop/src/renderer/features/scheduler/hooks/useRunNowBusyGuard.ts, apps/desktop/src/renderer/features/scheduler/hooks/useRuns.ts, apps/desktop/src/renderer/features/scheduler/hooks/useScheduleForm.ts, apps/desktop/src/renderer/features/scheduler/hooks/useScheduleUnreadRunCounts.ts, apps/desktop/src/renderer/features/scheduler/hooks/useSchedules.ts, apps/desktop/src/renderer/features/scheduler/hooks/useSessionReferences.ts, apps/desktop/src/renderer/features/scheduler/hooks/useTemplates.ts, apps/desktop/src/renderer/features/scheduler/index.ts, apps/desktop/src/renderer/features/scheduler/lib/cronCodexPreset.ts, apps/desktop/src/renderer/features/scheduler/lib/cronToHuman.ts, apps/desktop/src/renderer/features/scheduler/lib/failedScheduleDismissal.ts, apps/desktop/src/renderer/features/scheduler/lib/formatters.ts, apps/desktop/src/renderer/features/scheduler/lib/pluginScheduleCreateIntent.ts, apps/desktop/src/renderer/features/scheduler/lib/projectAutomationConfig.ts, apps/desktop/src/renderer/features/scheduler/lib/projectScheduleSidebarIndex.ts, apps/desktop/src/renderer/features/scheduler/lib/runHistoryGrouping.ts, apps/desktop/src/renderer/features/scheduler/lib/runUnread.ts, apps/desktop/src/renderer/features/scheduler/lib/scheduleFormLogic.ts, apps/desktop/src/renderer/features/scheduler/lib/scheduleRunReadSync.ts, apps/desktop/src/renderer/features/scheduler/lib/scheduleSessionBinding.ts, apps/desktop/src/renderer/features/scheduler/lib/scheduleSidebarIndexRuns.ts, apps/desktop/src/renderer/features/scheduler/lib/schedulesStore.ts, apps/desktop/src/renderer/features/scheduler/lib/statusFilter.ts, apps/desktop/src/renderer/features/scheduler/lib/statusFilterStorage.ts, apps/desktop/src/renderer/features/scheduler/lib/templateLocalization.ts, apps/desktop/src/renderer/features/scheduler/lib/usageLimitScheduleCreateIntent.ts | 44 | 0 | 118 |
-| `desktop.chat.session` | desktop | 会话工作台 | hash `/cc-agent/:sessionId`;副窗经 `/cc-agent/boot` 解析后落到同一会话视图 | AssistantMessage, CCAgentFeatureLayout, CCAgentSessionView, ChatInput, PermissionPrompt | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx | 273 | 46 | 407 |
+| `desktop.chat.session` | desktop | 会话工作台 | hash `/cc-agent/:sessionId`;副窗经 `/cc-agent/boot` 解析后落到同一会话视图 | AssistantMessage, CCAgentFeatureLayout, CCAgentSessionView, ChatInput, PermissionPrompt | apps/desktop/src/renderer/components/chat/AgentActionRow.tsx, apps/desktop/src/renderer/components/chat/AgentActionsBlock.tsx, apps/desktop/src/renderer/components/chat/AgentTaskCard.tsx, apps/desktop/src/renderer/components/chat/AskUserQuestionBubble.tsx, apps/desktop/src/renderer/components/chat/AssistantMessage.tsx, apps/desktop/src/renderer/components/chat/AutomationOriginBadge.tsx, apps/desktop/src/renderer/components/chat/ChatAudioCard.tsx, apps/desktop/src/renderer/components/chat/ChatDisplaySnapshotContext.tsx, apps/desktop/src/renderer/components/chat/ChatImageView.tsx, apps/desktop/src/renderer/components/chat/ChatSessionFileContext.tsx, apps/desktop/src/renderer/components/chat/ChatSoundEffectCard.tsx, apps/desktop/src/renderer/components/chat/ChatVideoView.tsx, apps/desktop/src/renderer/components/chat/CindyMakeDoctorCard.tsx, apps/desktop/src/renderer/components/chat/CopyAsImageBlock.tsx, apps/desktop/src/renderer/components/chat/CredentialSwitchWaitBanner.tsx, apps/desktop/src/renderer/components/chat/DiffView.tsx, apps/desktop/src/renderer/components/chat/ErrorBanner.tsx, apps/desktop/src/renderer/components/chat/ErrorMessageCard.tsx, apps/desktop/src/renderer/components/chat/GeneratedFilesCard.tsx, apps/desktop/src/renderer/components/chat/GhostSummonCard.tsx, apps/desktop/src/renderer/components/chat/GhostToolCard.tsx, apps/desktop/src/renderer/components/chat/HookTaskCard.tsx, apps/desktop/src/renderer/components/chat/ImageGalleryContext.tsx, apps/desktop/src/renderer/components/chat/ImageHoverPreview.tsx, apps/desktop/src/renderer/components/chat/ImageLightbox.tsx, apps/desktop/src/renderer/components/chat/ImageMissingPlaceholder.tsx, apps/desktop/src/renderer/components/chat/InlineReferenceChip.tsx, apps/desktop/src/renderer/components/chat/InterruptedTurnBanner.tsx, apps/desktop/src/renderer/components/chat/JumpToBottomChip.tsx, apps/desktop/src/renderer/components/chat/MarkdownDiffBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownMermaidBlock.tsx, apps/desktop/src/renderer/components/chat/MarkdownRenderer.tsx, apps/desktop/src/renderer/components/chat/MermaidLightbox.tsx, apps/desktop/src/renderer/components/chat/MessageActionBar.tsx, apps/desktop/src/renderer/components/chat/MessageNavRail.tsx, apps/desktop/src/renderer/components/chat/MessageStream.tsx, apps/desktop/src/renderer/components/chat/ModelLightbox.tsx, apps/desktop/src/renderer/components/chat/NewMessageIndicator.tsx, apps/desktop/src/renderer/components/chat/PlanReviewBubble.tsx, apps/desktop/src/renderer/components/chat/PrevMessageJumpChip.tsx, apps/desktop/src/renderer/components/chat/ProjectLinkChip.tsx, apps/desktop/src/renderer/components/chat/QuoteChip.tsx, apps/desktop/src/renderer/components/chat/RewindPreviewDialog.tsx, apps/desktop/src/renderer/components/chat/SelectionQuoteButton.tsx, apps/desktop/src/renderer/components/chat/SentAgentReferenceChip.tsx, apps/desktop/src/renderer/components/chat/SentInlineAtomBody.tsx, apps/desktop/src/renderer/components/chat/SessionHandoffCard.tsx, apps/desktop/src/renderer/components/chat/SessionLinkChip.tsx, apps/desktop/src/renderer/components/chat/ShareMessageCheckbox.tsx, apps/desktop/src/renderer/components/chat/ShareSelectionBar.tsx, apps/desktop/src/renderer/components/chat/SlackIcon.tsx, apps/desktop/src/renderer/components/chat/StreamFadeSpan.tsx, apps/desktop/src/renderer/components/chat/StreamingMarkdownChunk.tsx, apps/desktop/src/renderer/components/chat/SystemCard.tsx, apps/desktop/src/renderer/components/chat/TextLightbox.tsx, apps/desktop/src/renderer/components/chat/ThinkingCard.tsx, apps/desktop/src/renderer/components/chat/ThinkingText.tsx, apps/desktop/src/renderer/components/chat/TodoListCard.tsx, apps/desktop/src/renderer/components/chat/ToolCallCard.tsx, apps/desktop/src/renderer/components/chat/ToolPayloadLightbox.tsx, apps/desktop/src/renderer/components/chat/TopRightChipStack.tsx, apps/desktop/src/renderer/components/chat/TurnChangesCard.tsx, apps/desktop/src/renderer/components/chat/UnreadFailedScheduleBanner.tsx, apps/desktop/src/renderer/components/chat/UpgradeBanner.tsx, apps/desktop/src/renderer/components/chat/UserMessage.tsx, apps/desktop/src/renderer/components/chat/UserMessageEditBox.tsx, apps/desktop/src/renderer/components/chat/UserMessageUrlLink.tsx, apps/desktop/src/renderer/components/chat/VideoLightbox.tsx, apps/desktop/src/renderer/components/chat/WorkGroupBlock.tsx, apps/desktop/src/renderer/components/chat/WorktreeRestoreBanner.tsx, apps/desktop/src/renderer/components/chat/XIcon.tsx, apps/desktop/src/renderer/components/chat/activityRowChrome.ts, apps/desktop/src/renderer/components/chat/autoFollowIntent.ts, apps/desktop/src/renderer/components/chat/chatChrome.ts, apps/desktop/src/renderer/components/chat/errorReasonI18n.ts, apps/desktop/src/renderer/components/chat/imageDisplaySize.ts, apps/desktop/src/renderer/components/chat/lightboxAnnotations.ts, apps/desktop/src/renderer/components/chat/lightboxGestures.ts, apps/desktop/src/renderer/components/chat/markdownImageTargets.ts, apps/desktop/src/renderer/components/chat/messageNavRailModel.ts, apps/desktop/src/renderer/components/chat/messageNavRailWheel.ts, apps/desktop/src/renderer/components/chat/messageStreamIndicatorPosition.ts, apps/desktop/src/renderer/components/chat/messageViewportCompensation.ts, apps/desktop/src/renderer/components/chat/messageWorkGroups.ts, apps/desktop/src/renderer/components/chat/rehypeFencedCodeMarker.ts, apps/desktop/src/renderer/components/chat/rehypeMathBlockMarker.ts, apps/desktop/src/renderer/components/chat/rehypeStreamWordFade.ts, apps/desktop/src/renderer/components/chat/remarkHtmlImages.ts, apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts, apps/desktop/src/renderer/components/chat/remarkPreserveRawLocalDestinations.ts, apps/desktop/src/renderer/components/chat/remarkSessionLinks.ts, apps/desktop/src/renderer/components/chat/remarkStrictInlineMath.ts, apps/desktop/src/renderer/components/chat/remarkTruncateCjkUrls.ts, apps/desktop/src/renderer/components/chat/repairStreamingMarkdown.ts, apps/desktop/src/renderer/components/chat/scrollAnchoringDetect.ts, apps/desktop/src/renderer/components/chat/shareSelectionStore.ts, apps/desktop/src/renderer/components/chat/streamingMarkdownBlocks.tsx, apps/desktop/src/renderer/components/chat/streamingMarkdownChunks.ts, apps/desktop/src/renderer/components/chat/toolLoopI18n.ts, apps/desktop/src/renderer/components/chat/unreadCount.ts, apps/desktop/src/renderer/components/chat/useAutomaticHistoryLoadBudget.ts, apps/desktop/src/renderer/components/chat/useCopyAsImage.tsx, apps/desktop/src/renderer/components/chat/useDeleteMessage.ts, apps/desktop/src/renderer/components/chat/useFileChipContextMenu.tsx, apps/desktop/src/renderer/components/chat/useForkAtMessage.ts, apps/desktop/src/renderer/components/chat/useNavigationKeyListener.ts, apps/desktop/src/renderer/components/chat/useOpenWithMenu.tsx, apps/desktop/src/renderer/components/chat/usePrevUserMessageInView.ts, apps/desktop/src/renderer/components/chat/useTurnChangeSets.ts, apps/desktop/src/renderer/components/chat/userMessageCollapse.ts, apps/desktop/src/renderer/components/chat/userMessageDisplayText.ts, apps/desktop/src/renderer/components/chat/userMessageLinkify.ts, apps/desktop/src/renderer/components/chat/viewportFillDetect.ts, apps/desktop/src/renderer/components/new-chat/AddRemoteProjectDialog.tsx, apps/desktop/src/renderer/components/new-chat/AgentSelect.tsx, apps/desktop/src/renderer/components/new-chat/AskUserQuestionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/AtMentionPanel.tsx, apps/desktop/src/renderer/components/new-chat/AttachmentTypeThumb.tsx, apps/desktop/src/renderer/components/new-chat/ChatInput.tsx, apps/desktop/src/renderer/components/new-chat/CjkPunctDecoration.ts, apps/desktop/src/renderer/components/new-chat/CjkPunctuationUtils.ts, apps/desktop/src/renderer/components/new-chat/ComposerListIndentDecoration.ts, apps/desktop/src/renderer/components/new-chat/ComposerListNodes.ts, apps/desktop/src/renderer/components/new-chat/ComposerQuoteNode.tsx, apps/desktop/src/renderer/components/new-chat/DeviceSwitcherPill.tsx, apps/desktop/src/renderer/components/new-chat/EffortSlider.tsx, apps/desktop/src/renderer/components/new-chat/EmptyDocSelectionGuard.ts, apps/desktop/src/renderer/components/new-chat/ExtraDirsButton.tsx, apps/desktop/src/renderer/components/new-chat/FastModeToggle.tsx, apps/desktop/src/renderer/components/new-chat/FolderPickerPopover.tsx, apps/desktop/src/renderer/components/new-chat/FullAccessConfirmContent.tsx, apps/desktop/src/renderer/components/new-chat/GhostCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/GoalAdvancedLimits.tsx, apps/desktop/src/renderer/components/new-chat/GoalIndicator.tsx, apps/desktop/src/renderer/components/new-chat/HomeUsageDashboard.tsx, apps/desktop/src/renderer/components/new-chat/ListComposerTextarea.tsx, apps/desktop/src/renderer/components/new-chat/MentionChipNode.tsx, apps/desktop/src/renderer/components/new-chat/MentionDragCaretDecoration.ts, apps/desktop/src/renderer/components/new-chat/ModelCompatibilityNotice.tsx, apps/desktop/src/renderer/components/new-chat/ModelConfigFlyout.tsx, apps/desktop/src/renderer/components/new-chat/ModelHarnessPicker.tsx, apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx, apps/desktop/src/renderer/components/new-chat/ModelSourceDetails.tsx, apps/desktop/src/renderer/components/new-chat/NewGoalDialog.tsx, apps/desktop/src/renderer/components/new-chat/PastedTextChipNode.tsx, apps/desktop/src/renderer/components/new-chat/PendingQueuePanel.tsx, apps/desktop/src/renderer/components/new-chat/PermissionPrompt.tsx, apps/desktop/src/renderer/components/new-chat/PermissionSelector.tsx, apps/desktop/src/renderer/components/new-chat/PinnedPlanPanel.tsx, apps/desktop/src/renderer/components/new-chat/PlanActionCard.tsx, apps/desktop/src/renderer/components/new-chat/PlanModeIndicator.tsx, apps/desktop/src/renderer/components/new-chat/PlanViewerCard.tsx, apps/desktop/src/renderer/components/new-chat/PluginSetupPrompt.tsx, apps/desktop/src/renderer/components/new-chat/QuickStartPillMark.ts, apps/desktop/src/renderer/components/new-chat/SendButton.tsx, apps/desktop/src/renderer/components/new-chat/SlashCommandDecoration.ts, apps/desktop/src/renderer/components/new-chat/SlashCommandPalette.tsx, apps/desktop/src/renderer/components/new-chat/TakeoverMask.tsx, apps/desktop/src/renderer/components/new-chat/ThinkingToggle.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedFlyoutHost.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRail.tsx, apps/desktop/src/renderer/components/new-chat/UnifiedModelRow.tsx, apps/desktop/src/renderer/components/new-chat/UsageDailyBars.tsx, apps/desktop/src/renderer/components/new-chat/UsageHeatmap.tsx, apps/desktop/src/renderer/components/new-chat/VendorSegmentedSwitcher.tsx, apps/desktop/src/renderer/components/new-chat/VoiceInputDraftDecoration.ts, apps/desktop/src/renderer/components/new-chat/WindowsSelectionReplacement.ts, apps/desktop/src/renderer/components/new-chat/WorktreeChipsRow.tsx, apps/desktop/src/renderer/components/new-chat/WorktreeCreatingOverlay.tsx, apps/desktop/src/renderer/components/new-chat/agentOptions.ts, apps/desktop/src/renderer/components/new-chat/agentSwitchConfirmation.ts, apps/desktop/src/renderer/components/new-chat/branchPick.ts, apps/desktop/src/renderer/components/new-chat/composerBlankPointerFocus.ts, apps/desktop/src/renderer/components/new-chat/composerContentSerialization.ts, apps/desktop/src/renderer/components/new-chat/composerDocState.ts, apps/desktop/src/renderer/components/new-chat/composerFrameScheduler.ts, apps/desktop/src/renderer/components/new-chat/composerHistoryProjection.ts, apps/desktop/src/renderer/components/new-chat/composerModelSelection.ts, apps/desktop/src/renderer/components/new-chat/composerPromptRecommendation.ts, apps/desktop/src/renderer/components/new-chat/composerRenderGate.ts, apps/desktop/src/renderer/components/new-chat/composerSendOwnership.ts, apps/desktop/src/renderer/components/new-chat/composerSendSnapshot.ts, apps/desktop/src/renderer/components/new-chat/effortChangeQueue.ts, apps/desktop/src/renderer/components/new-chat/extraDirsActions.ts, apps/desktop/src/renderer/components/new-chat/ghostComposerPlacement.ts, apps/desktop/src/renderer/components/new-chat/localAttachmentPicker.ts, apps/desktop/src/renderer/components/new-chat/mentionChipInsertion.ts, apps/desktop/src/renderer/components/new-chat/modelWindowErrorToast.ts, apps/desktop/src/renderer/components/new-chat/pastePipeline.ts, apps/desktop/src/renderer/components/new-chat/pathPaste.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueLocks.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowActivity.ts, apps/desktop/src/renderer/components/new-chat/pendingQueueRowPresentation.ts, apps/desktop/src/renderer/components/new-chat/planModeComposerCommand.ts, apps/desktop/src/renderer/components/new-chat/priceTierMarks.tsx, apps/desktop/src/renderer/components/new-chat/remoteBrowseAdapters.ts, apps/desktop/src/renderer/components/new-chat/remoteExistingProjects.ts, apps/desktop/src/renderer/components/new-chat/sessionLinkPaste.ts, apps/desktop/src/renderer/components/new-chat/sourceSwitch.ts, apps/desktop/src/renderer/components/new-chat/unifiedModelSelection.ts, apps/desktop/src/renderer/components/new-chat/usagePalette.ts, apps/desktop/src/renderer/components/new-chat/useComposerSendFocusRestore.ts, apps/desktop/src/renderer/components/new-chat/useModelDiscoveryPending.ts, apps/desktop/src/renderer/components/new-chat/useProviderWeeklyQuota.ts, apps/desktop/src/renderer/components/new-chat/useUnifiedRowActions.ts, apps/desktop/src/renderer/features/cc-agent/CCAgentFeatureLayout.tsx, apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx | 273 | 46 | 408 |
| `desktop.dev.maker-experimental` | desktop | Maker 实验诊断页 | hash `/maker-experimental`(MakerExperimentalView;EXPERIMENTAL_FEATURES 现为空,仍是生产路由) | MakerExperimentalView | apps/desktop/src/renderer/features/maker-experimental/MakerExperimentalView.tsx | 10 | 0 | 11 |
| `desktop.issues.guide` | desktop | Issue 引导页 | hash `/issues`(IssueTrackerFeatureLayout,已迁 GitHub 后的引导页) | IssueTrackerFeatureLayout | apps/desktop/src/renderer/features/issue-tracker/IssueTrackerFeatureLayout.tsx, apps/desktop/src/renderer/features/issue-tracker/MyIssueList.tsx, apps/desktop/src/renderer/features/issue-tracker/hooks/useMyIssues.ts, apps/desktop/src/renderer/features/issue-tracker/lib/myIssuesNotices.ts, apps/desktop/src/renderer/features/issue-tracker/lib/startIssueChat.ts | 0 | 0 | 8 |
| `desktop.native.app-menu` | desktop | 应用菜单 | Menu.setApplicationMenu(用户可见出口,不展开业务逻辑) | applicationMenuLabels | apps/desktop/src/main/applicationMenuLabels.ts | 0 | 0 | 0 |
diff --git a/docs/dev-rules/environment-setup.md b/docs/dev-rules/environment-setup.md
index 7ffab9b765..be483affc8 100644
--- a/docs/dev-rules/environment-setup.md
+++ b/docs/dev-rules/environment-setup.md
@@ -33,11 +33,18 @@ pnpm install
新 worktree 不共享 `node_modules`。确认 checkout 已完成且根 `package.json` 存在后,
在该 worktree 内重新运行 `pnpm install`。
-Cindy Make 在准备受管源码时,先切到 `cindy-personal`,按锁文件安装包含开发依赖的完整
-依赖,成功后才标记仓库就绪。后续开发分支的 worktree 使用已选定的系统或 Cindy 管理
+Cindy Make 的设置入口和指令前置弹窗共用源码准备流程:切到 `cindy-personal` 后,
+按锁文件预热包含开发依赖的 pnpm store 缓存,成功后才标记源码就绪。预热使用
+`pnpm fetch --frozen-lockfile --prefer-offline --prod=false --ignore-scripts
+--config.node-linker=isolated --config.enable-modules-dir=false`,只下载/复用缓存,
+不为个人分支建立依赖目录、不执行安装脚本;这两个 config 参数仅作用于预热子进程。
+每次准备都由 pnpm 校验当前锁文件和缓存,缺失或变化的包才补下载,不用就绪标记跳过校验。
+实现与回归见 [sourcePreparation.ts](../../apps/desktop/src/main/cindy-make/sourcePreparation.ts)
+及其[测试](../../apps/desktop/src/main/cindy-make/__tests__/sourcePreparation.test.ts)。
+用户继续后,开发任务的 worktree 使用已选定的系统或 Cindy 管理
工具(含原生依赖构建所需的 Python),并通过
`pnpm install --frozen-lockfile --prefer-offline --prod=false` 优先复用
-准备阶段填充的 pnpm store 缓存;各 worktree 仍保留独立的 `node_modules`,不复制或
+准备阶段填充的 pnpm store 缓存,并执行必要的安装脚本;各 worktree 仍保留独立的 `node_modules`,不复制或
链接个人分支的依赖目录。安装失败或取消可在现有 checkout 上重试,不重置个人分支。
## Linux:Electron SUID sandbox 权限