feat(acp): support /cd command in ACP sessions

packages/acp-bridge/src/bridge.ts

@@ -48,6 +48,7 @@ import {
 } from './status.js';
 import {
   BranchWhilePromptActiveError,
+  CdWhilePromptActiveError,
   SessionNotFoundError,
   RestoreInProgressError,
   InvalidSessionScopeError,
@@ -81,6 +82,8 @@ import type {
   AcpSessionBridge,
   MidTurnQueueEntry,
   BridgeDaemonStatusSnapshot,
+  ChangeSessionCwdRequest,
+  ChangeSessionCwdResult,
 } from './bridgeTypes.js';
 import type { BridgeOptions, BridgeTelemetry } from './bridgeOptions.js';
 import { MCP_RESTART_SERVER_DEADLINE_MS } from './mcpTimeouts.js';
@@ -3474,6 +3477,65 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
       return branchResult;
     },
 
+    async changeSessionCwd(
+      sessionId: string,
+      req: ChangeSessionCwdRequest,
+      context?: BridgeClientRequestContext,
+    ): Promise<ChangeSessionCwdResult> {
+      if (shuttingDown) throw new Error('AcpSessionBridge is shutting down');
+
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId,
+      );
+
+      // Chain onto promptQueue and update tail — ensures:
+      // 1. cd waits for any in-flight prompt to complete
+      // 2. Subsequent prompts wait for cd to complete (prevents stale config.cwd)
+      const cdResult = entry.promptQueue.then(async () => {
+        if (entry.promptActive) {
+          throw new CdWhilePromptActiveError(sessionId);
+        }
+
+        const ci = await ensureChannel();
+        return (await withTimeout(
+          ci.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionCd, {
+            sessionId,
+            path: req.path,
+          }),
+          initTimeoutMs,
+          'changeSessionCwd',
+        )) as { previousCwd: string; newCwd: string; warnings: string[] };
+      });
+
+      // Update queue tail (same pattern as sendPrompt L3090)
+      entry.promptQueue = cdResult.then(
+        () => undefined,
+        () => undefined,
+      );
+
+      const result = await cdResult;
+
+      // Only update state and broadcast if directory actually changed
+      if (result.previousCwd !== result.newCwd) {
+        entry.workspaceCwd = result.newCwd;
+        entry.events.publish({
+          type: 'session_cwd_changed',
+          data: {
+            sessionId,
+            previousCwd: result.previousCwd,
+            newCwd: result.newCwd,
+          },
+          ...(originatorClientId ? { originatorClientId } : {}),
+        });
+      }
+
+      return { sessionId, ...result };
+    },
+
     async closeSession(sessionId, context, closeOpts) {
       return closeSessionImpl(sessionId, context, closeOpts);
     },

packages/acp-bridge/src/bridgeErrors.ts

@@ -501,3 +501,14 @@ export class BranchWhilePromptActiveError extends Error {
     this.sessionId = sessionId;
   }
 }
+
+export class CdWhilePromptActiveError extends Error {
+  readonly sessionId: string;
+  constructor(sessionId: string) {
+    super(
+      `Cannot change directory for session ${sessionId}: a prompt is currently active`,
+    );
+    this.name = 'CdWhilePromptActiveError';
+    this.sessionId = sessionId;
+  }
+}

packages/acp-bridge/src/bridgeTypes.ts

@@ -123,6 +123,17 @@ export interface BridgeForkAgentResult {
   launched: boolean;
 }
 
+export interface ChangeSessionCwdRequest {
+  path: string;
+}
+
+export interface ChangeSessionCwdResult {
+  sessionId: string;
+  previousCwd: string;
+  newCwd: string;
+  warnings: string[];
+}
+
 /** Sparse summary used by `GET /workspace/:id/sessions`. */
 export interface BridgeSessionSummary {
   sessionId: string;
@@ -301,6 +312,21 @@ export interface AcpSessionBridge {
     context?: BridgeClientRequestContext,
   ): Promise<BridgeBranchedSession>;
 
+  /**
+   * Change the working directory of a live session. The session must be
+   * idle (no active prompt). Chains onto `entry.promptQueue` and updates
+   * the tail to prevent concurrent mutations.
+   *
+   * Throws `CdWhilePromptActiveError` when a prompt is running,
+   * `SessionNotFoundError` for unknown ids, and `InvalidClientIdError`
+   * when the caller's client id is not bound to the session.
+   */
+  changeSessionCwd(
+    sessionId: string,
+    req: ChangeSessionCwdRequest,
+    context?: BridgeClientRequestContext,
+  ): Promise<ChangeSessionCwdResult>;
+
   /**
    * Forward a prompt to the agent. Concurrent prompts against the same
    * session FIFO-serialize through a per-session queue.

packages/acp-bridge/src/status.ts

@@ -143,6 +143,7 @@ export const SERVE_CONTROL_EXT_METHODS = {
   workspaceMcpRuntimeRemove: 'qwen/control/workspace/mcp/runtime-remove',
   workspaceReload: 'qwen/control/workspace/reload',
   workspaceExtensionsRefresh: 'qwen/control/workspace/extensions/refresh',
+  sessionCd: 'qwen/control/session/cd',
 } as const;
 
 export type ServeStatus =

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

@@ -172,7 +172,11 @@ import {
   getCurrentLanguage,
   SUPPORTED_LANGUAGES,
 } from '../i18n/index.js';
-import { isWorkspaceTrusted } from '../config/trustedFolders.js';
+import {
+  isWorkspaceTrusted,
+  isFolderTrustEnabled,
+  loadTrustedFolders,
+} from '../config/trustedFolders.js';
 import {
   ACP_PREFLIGHT_KINDS,
   STATUS_SCHEMA_VERSION,
@@ -5511,6 +5515,106 @@ class QwenAgent implements Agent {
         await this.closeStoredSession(sessionId);
         return { sessionId, closed: true };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionCd: {
+        const sessionId = params['sessionId'];
+        const targetPath = params['path'];
+        if (typeof sessionId !== 'string' || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            undefined,
+            'Invalid or missing sessionId',
+          );
+        }
+        if (
+          typeof targetPath !== 'string' ||
+          targetPath.length === 0 ||
+          !path.isAbsolute(targetPath)
+        ) {
+          throw RequestError.invalidParams(
+            undefined,
+            'Invalid or missing path (must be an absolute path)',
+          );
+        }
+
+        const session = this.sessionOrThrow(sessionId);
+        const config = session.getConfig();
+
+        // Restrictive sandbox check
+        if (config.isRestrictiveSandbox()) {
+          throw new RequestError(-32003, 'Restrictive sandbox mode active', {
+            errorKind: 'restrictive_sandbox',
+          });
+        }
+
+        // Verify directory exists
+        let stats;
+        try {
+          stats = await fs.stat(targetPath);
+        } catch {
+          throw new RequestError(-32002, `Directory not found: ${targetPath}`, {
+            errorKind: 'directory_not_found',
+            path: targetPath,
+          });
+        }
+        if (!stats.isDirectory()) {
+          throw new RequestError(-32002, `Not a directory: ${targetPath}`, {
+            errorKind: 'directory_not_found',
+            path: targetPath,
+          });
+        }
+
+        // Canonicalize path
+        const canonicalPath = await fs.realpath(targetPath);
+
+        // Noop check
+        const previousCwd = config.getTargetDir();
+        if (canonicalPath === previousCwd) {
+          return { previousCwd, newCwd: canonicalPath, warnings: [] };
+        }
+
+        // Trust check
+        if (isFolderTrustEnabled(this.settings.merged)) {
+          const trustedFolders = loadTrustedFolders();
+          if (trustedFolders.isPathTrusted(canonicalPath) !== true) {
+            throw new RequestError(
+              -32001,
+              `Directory not trusted: ${canonicalPath}`,
+              { errorKind: 'directory_not_trusted', path: canonicalPath },
+            );
+          }
+        }
+
+        // Relocate working directory (skip process.chdir for ACP)
+        const warnings: string[] = [];
+        const relocation = await config.relocateWorkingDirectory(
+          canonicalPath,
+          canonicalPath,
+          { skipProcessChdir: true },
+        );
+        if (relocation.memoryRefreshError) {
+          warnings.push(
+            `Memory refresh failed: ${
+              relocation.memoryRefreshError instanceof Error
+                ? relocation.memoryRefreshError.message
+                : String(relocation.memoryRefreshError)
+            }`,
+          );
+        }
+
+        // Update model context
+        try {
+          await config
+            .getGeminiClient()
+            ?.addWorkingDirectoryChangedContext(previousCwd, canonicalPath);
+        } catch (error) {
+          warnings.push(
+            `Model context refresh failed: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          );
+        }
+
+        return { previousCwd, newCwd: canonicalPath, warnings };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
         const sessionId = params['sessionId'];
         const mode = params['mode'];

packages/cli/src/serve/acp-session-bridge.ts

@@ -81,6 +81,7 @@ export type {
 
 export {
   BranchWhilePromptActiveError,
+  CdWhilePromptActiveError,
   SessionNotFoundError,
   RestoreInProgressError,
   InvalidSessionScopeError,

packages/cli/src/serve/server.ts

@@ -80,6 +80,7 @@ import {
   canonicalizeWorkspace,
   CancelSentinelCollisionError,
   BranchWhilePromptActiveError,
+  CdWhilePromptActiveError,
   createAcpSessionBridge,
   InvalidClientIdError,
   InvalidPermissionOptionError,
@@ -3324,6 +3325,74 @@ export function createServeApp(
     }
   });
 
+  app.post('/session/:id/cd', mutate(), async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const body = safeBody(req);
+    const targetPath = body['path'];
+    if (
+      typeof targetPath !== 'string' ||
+      targetPath.length === 0 ||
+      !path.isAbsolute(targetPath)
+    ) {
+      res.status(400).json({
+        error: '`path` is required and must be an absolute path',
+        code: 'invalid_path',
+      });
+      return;
+    }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    try {
+      const result = await bridge.changeSessionCwd(
+        sessionId,
+        { path: targetPath },
+        clientId !== undefined ? { clientId } : undefined,
+      );
+      res.status(200).json(result);
+    } catch (err) {
+      // Map ACP child errorKind codes to HTTP responses
+      if (err && typeof err === 'object') {
+        const data = (err as { data?: unknown }).data;
+        if (data && typeof data === 'object') {
+          const kind = (data as { errorKind?: unknown }).errorKind;
+          if (kind === 'restrictive_sandbox') {
+            res.status(403).json({
+              error:
+                (err as { message?: string }).message ??
+                'Restrictive sandbox mode active',
+              code: 'restrictive_sandbox',
+            });
+            return;
+          }
+          if (kind === 'directory_not_found') {
+            res.status(400).json({
+              error:
+                (err as { message?: string }).message ?? 'Directory not found',
+              code: 'directory_not_found',
+              path: (data as { path?: string }).path,
+            });
+            return;
+          }
+          if (kind === 'directory_not_trusted') {
+            res.status(403).json({
+              error:
+                (err as { message?: string }).message ??
+                'Directory not trusted',
+              code: 'directory_not_trusted',
+              path: (data as { path?: string }).path,
+            });
+            return;
+          }
+        }
+      }
+      sendBridgeError(res, err, {
+        route: 'POST /session/:id/cd',
+        sessionId,
+      });
+    }
+  });
+
   app.get('/session/:id/status', (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -5766,6 +5835,14 @@ function sendBridgeErrorImpl(
     });
     return;
   }
+  if (err instanceof CdWhilePromptActiveError) {
+    res.status(409).json({
+      error: err.message,
+      code: 'session_busy',
+      sessionId: err.sessionId,
+    });
+    return;
+  }
   if (err instanceof TrustGateError) {
     // Trust-folder rejection. 403 because the workspace's trust posture
     // forbids the privileged mode.