fix(acp): isolate workspace settings and context file resolution for worktree sessions

packages/cli/src/acp-integration/acpAgent.test.ts

@@ -24,6 +24,13 @@ import { ACP_EVENT_LOOP_STALL_RESTART_MS } from '@qwen-code/channel-base';
 const { mockRunExitCleanup } = vi.hoisted(() => ({
   mockRunExitCleanup: vi.fn().mockResolvedValue(undefined),
 }));
+const { mockExistsSync } = vi.hoisted(() => ({
+  mockExistsSync: vi.fn().mockReturnValue(true),
+}));
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return { ...actual, existsSync: mockExistsSync };
+});
 const { mockStartNonInteractiveOpenAILogHousekeeping } = vi.hoisted(() => ({
   mockStartNonInteractiveOpenAILogHousekeeping: vi.fn(),
 }));
@@ -1994,6 +2001,10 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
     stdoutDestroySpy.mockRestore();
   });
 
+  afterEach(() => {
+    mockExistsSync.mockReturnValue(true);
+  });
+
   it('initialize response includes mcpCapabilities with sse and http', async () => {
     const mockSettings = {
       merged: { mcpServers: {} },
@@ -4378,6 +4389,63 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
     await agentPromise;
   });
 
+  it('session/cd sets worktreeCwd and getCore resolves against the worktree path', async () => {
+    const sessionId = '11111111-1111-1111-1111-111111111111';
+    const tmpDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'qwen-cd-worktree-settings-'),
+    );
+    const repoRoot = path.join(tmpDir, 'repo');
+    const targetDir = path.join(repoRoot, '.qwen', 'worktrees', 'test');
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(targetDir, '.git'), 'gitdir: /fake');
+    const canonicalTargetDir = await fs.realpath(targetDir);
+    const innerConfig = await setupSessionMocks(sessionId);
+    const relocateWorkingDirectory = vi.fn().mockResolvedValue({});
+    Object.assign(innerConfig, {
+      getTargetDir: vi.fn().mockReturnValue('/tmp'),
+      isRestrictiveSandbox: vi.fn().mockReturnValue(false),
+      relocateWorkingDirectory,
+    });
+    Object.assign(innerConfig.getGeminiClient(), {
+      addWorkingDirectoryChangedContext: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+
+    const { agent, agentPromise } = await bootAcpAgent();
+    await agent.newSession({ cwd: '/tmp', mcpServers: [] });
+
+    try {
+      await expect(
+        agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionCd, {
+          sessionId,
+          path: targetDir,
+        }),
+      ).resolves.toMatchObject({
+        previousCwd: '/tmp',
+        newCwd: canonicalTargetDir,
+      });
+
+      expect(
+        (lastSessionMock as Record<string, unknown>)?.['worktreeCwd'],
+      ).toBe(canonicalTargetDir);
+
+      vi.mocked(loadSettings).mockClear();
+      await agent.extMethod('qwen/settings/getCore', {});
+      expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(canonicalTargetDir);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+
+    mockConnectionState.resolve();
+    await agentPromise;
+  });
+
   it('allows a private Live managed relocation without a global folder trust rule', async () => {
     await withEmptyTrustedFolders(async (directory) => {
       const root = path.join(directory, 'Conversations');
@@ -9899,6 +9967,197 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
     await agentPromise;
   });
 
+  it('qwen/settings handlers resolve against worktree cwd set by createAndStoreSession', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qwen-wt-s1-'));
+    const repoRoot = path.join(tmpDir, 'repo');
+    const WORKTREE_DIR = path.join(repoRoot, '.qwen', 'worktrees', 'test');
+    await fs.mkdir(WORKTREE_DIR, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(WORKTREE_DIR, '.git'), 'gitdir: /fake');
+    const innerConfig = await setupSessionMocks('wt-settings-session');
+    innerConfig.getTargetDir = vi.fn().mockReturnValue(WORKTREE_DIR);
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    const { agent, agentPromise } = await bootAcpAgent();
+
+    await agent.newSession({ cwd: '/fake/project', mcpServers: [] });
+
+    vi.mocked(loadSettings).mockClear();
+    await agent.extMethod('qwen/settings/getCore', {});
+    expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(WORKTREE_DIR);
+
+    innerConfig.getTargetDir = vi.fn().mockReturnValue(process.cwd());
+    innerConfig.getSessionId = vi.fn().mockReturnValue('regular-session');
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    await agent.newSession({ cwd: '/fake/project', mcpServers: [] });
+
+    // The fallback loop scans all sessions for worktreeCwd; the first
+    // session's worktreeCwd is still set, so it wins over process.cwd().
+    vi.mocked(loadSettings).mockClear();
+    await agent.extMethod('qwen/settings/getCore', {});
+    expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(WORKTREE_DIR);
+
+    mockConnectionState.resolve();
+    await agentPromise;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('qwen/settings handlers fall back to process.cwd() after worktree session closes', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qwen-wt-s2-'));
+    const repoRoot = path.join(tmpDir, 'repo');
+    const WORKTREE_DIR = path.join(repoRoot, '.qwen', 'worktrees', 'test');
+    await fs.mkdir(WORKTREE_DIR, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(WORKTREE_DIR, '.git'), 'gitdir: /fake');
+    const innerConfig = await setupSessionMocks('wt-close-session');
+    innerConfig.getTargetDir = vi.fn().mockReturnValue(WORKTREE_DIR);
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    const { agent, agentPromise } = await bootAcpAgent();
+
+    await agent.newSession({ cwd: '/fake/project', mcpServers: [] });
+
+    vi.mocked(loadSettings).mockClear();
+    await agent.extMethod('qwen/settings/getCore', {});
+    expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(WORKTREE_DIR);
+
+    await agent.extMethod('qwen/control/session/close', {
+      sessionId: 'wt-close-session',
+    });
+
+    vi.mocked(loadSettings).mockClear();
+    await agent.extMethod('qwen/settings/getCore', {});
+    expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(process.cwd());
+
+    mockConnectionState.resolve();
+    await agentPromise;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('qwen/settings/getCore resolves per-session worktreeCwd via sessionId param', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qwen-wt-s3-'));
+    const repoRoot = path.join(tmpDir, 'repo');
+    const WORKTREE_DIR = path.join(repoRoot, '.qwen', 'worktrees', 'test');
+    await fs.mkdir(WORKTREE_DIR, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(WORKTREE_DIR, '.git'), 'gitdir: /fake');
+    const innerConfig = await setupSessionMocks('per-session-wt-id');
+    innerConfig.getTargetDir = vi.fn().mockReturnValue(WORKTREE_DIR);
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    const { agent, agentPromise } = await bootAcpAgent();
+
+    const newResult = (await agent.newSession({
+      cwd: '/fake/project',
+      mcpServers: [],
+    })) as { sessionId: string };
+    const sessionId = newResult.sessionId;
+
+    vi.mocked(loadSettings).mockClear();
+    await agent.extMethod('qwen/settings/getCore', { sessionId });
+    expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(WORKTREE_DIR);
+
+    mockConnectionState.resolve();
+    await agentPromise;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('qwen/settings/getCore falls through to configWt when worktreeCwd dir is deleted', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qwen-wt-s4-'));
+    const repoRoot = path.join(tmpDir, 'repo');
+    const WORKTREE_DIR = path.join(repoRoot, '.qwen', 'worktrees', 'deleted');
+    await fs.mkdir(WORKTREE_DIR, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(WORKTREE_DIR, '.git'), 'gitdir: /fake');
+    const innerConfig = await setupSessionMocks('deleted-wt-session');
+    innerConfig.getTargetDir = vi.fn().mockReturnValue(WORKTREE_DIR);
+    (innerConfig as Record<string, unknown>)['getActiveWorktree'] = vi
+      .fn()
+      .mockReturnValue(null);
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    const { agent, agentPromise } = await bootAcpAgent();
+
+    const newResult = (await agent.newSession({
+      cwd: '/fake/project',
+      mcpServers: [],
+    })) as { sessionId: string };
+    const sessionId = newResult.sessionId;
+
+    await fs.rm(WORKTREE_DIR, { recursive: true, force: true });
+    try {
+      vi.mocked(loadSettings).mockClear();
+      await agent.extMethod('qwen/settings/getCore', { sessionId });
+      expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(process.cwd());
+    } finally {
+      mockExistsSync.mockReturnValue(true);
+    }
+
+    mockConnectionState.resolve();
+    await agentPromise;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('qwen/settings/getCore uses configWt when worktreeCwd is deleted but activeWorktree exists', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qwen-wt-s5-'));
+    const repoRoot = path.join(tmpDir, 'repo');
+    const ACTIVE_WT = path.join(repoRoot, '.qwen', 'worktrees', 'active');
+    await fs.mkdir(ACTIVE_WT, { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.git'));
+    await fs.writeFile(path.join(ACTIVE_WT, '.git'), 'gitdir: /fake');
+    const innerConfig = await setupSessionMocks('active-wt-session');
+    innerConfig.getTargetDir = vi.fn().mockReturnValue('/fake/deleted-wt');
+    (innerConfig as Record<string, unknown>)['getActiveWorktree'] = vi
+      .fn()
+      .mockReturnValue(ACTIVE_WT);
+
+    const settings = makeCoreSettings();
+    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadCliConfig).mockResolvedValue(
+      innerConfig as unknown as Config,
+    );
+    const { agent, agentPromise } = await bootAcpAgent();
+
+    const newResult = (await agent.newSession({
+      cwd: '/fake/project',
+      mcpServers: [],
+    })) as { sessionId: string };
+    const sessionId = newResult.sessionId;
+
+    mockExistsSync.mockImplementation(
+      (p: string | Buffer | URL) => p === ACTIVE_WT,
+    );
+    try {
+      vi.mocked(loadSettings).mockClear();
+      await agent.extMethod('qwen/settings/getCore', { sessionId });
+      expect(vi.mocked(loadSettings)).toHaveBeenCalledWith(ACTIVE_WT);
+    } finally {
+      mockExistsSync.mockReturnValue(true);
+    }
+
+    mockConnectionState.resolve();
+    await agentPromise;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
   it('qwen/permissions/setRules validates scope and ruleType', async () => {
     const settings = makeCoreSettings();
     const { agent, agentPromise } = await bootCoreSettingsAgent(settings);
@@ -17948,12 +18207,22 @@ describe('sessionLanguage multi-session propagation', () => {
       getUserHooks: vi.fn().mockReturnValue({}),
       getProjectHooks: vi.fn().mockReturnValue({}),
     } as unknown as LoadedSettings;
+    const reloadedSettings = {
+      merged: { modelProviders: providerConfig },
+      getUserHooks: vi.fn().mockReturnValue({}),
+      getProjectHooks: vi.fn().mockReturnValue({}),
+    } as unknown as LoadedSettings;
     const cfg = makeConfig({
       getSessionId: vi.fn().mockReturnValue('s-reload'),
       getAuthType: vi.fn().mockReturnValue('openai'),
     });
 
-    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadSettings).mockImplementation((...args) => {
+      if (args[1] && (args[1] as Record<string, unknown>).skipLoadEnvironment) {
+        return reloadedSettings;
+      }
+      return settings;
+    });
     vi.mocked(loadCliConfig).mockResolvedValue(cfg as unknown as Config);
     vi.mocked(Session).mockImplementation(
       () =>
@@ -18012,6 +18281,11 @@ describe('sessionLanguage multi-session propagation', () => {
       getUserHooks: vi.fn().mockReturnValue({}),
       getProjectHooks: vi.fn().mockReturnValue({}),
     } as unknown as LoadedSettings;
+    const reloadedSettings = {
+      merged: { tools: { approvalMode: 'plan' } },
+      getUserHooks: vi.fn().mockReturnValue({}),
+      getProjectHooks: vi.fn().mockReturnValue({}),
+    } as unknown as LoadedSettings;
     let approvalMode = 'default';
     const cfg = makeConfig({
       getSessionId: vi.fn().mockReturnValue('s-plan-reload'),
@@ -18024,7 +18298,12 @@ describe('sessionLanguage multi-session propagation', () => {
     const clearActiveTodoPlanRevision = vi.fn();
     const clearTodoStopGuardTrust = vi.fn();
 
-    vi.mocked(loadSettings).mockReturnValue(settings);
+    vi.mocked(loadSettings).mockImplementation((...args) => {
+      if (args[1] && (args[1] as Record<string, unknown>).skipLoadEnvironment) {
+        return reloadedSettings;
+      }
+      return settings;
+    });
     vi.mocked(loadCliConfig).mockResolvedValue(cfg as unknown as Config);
     vi.mocked(Session).mockImplementation(
       () =>