farming-code 2.2.19 → 2.2.22

package/backend/workspace-file-service.js

@@ -404,6 +404,17 @@ function metadataFileVersion(relativePath, stat) {
   return sha1(Buffer.from(`${relativePath}:${stat.size}:${stat.mtimeMs}`, 'utf8'));
 }
 
+function workspaceEntryVersion(stat) {
+  return sha1(Buffer.from([
+    stat.dev,
+    stat.ino,
+    stat.mode,
+    stat.size,
+    stat.mtimeMs,
+    stat.ctimeMs,
+  ].join(':'), 'utf8'));
+}
+
 async function readTextPrefix(target, maxBytes) {
   const handle = await fsp.open(target, 'r');
   try {
@@ -1122,7 +1133,12 @@ class WorkspaceFileService {
     this.gitStatusInlineTimeoutMs = options.gitStatusInlineTimeoutMs ?? DEFAULT_GIT_STATUS_INLINE_TIMEOUT_MS;
     this.gitStatusTimeoutMs = options.gitStatusTimeoutMs ?? DEFAULT_GIT_STATUS_TIMEOUT_MS;
     this.gitStatusCache = new Map();
+    this.mutationQueues = new Map();
+    this.flushWorkspaceWrites = options.flushWorkspaceWrites !== false;
     this.watchers = new Map();
+    this.watcherSubscriptionGeneration = 0;
+    this.watcherLifecycleGeneration = 0;
+    this.disposed = false;
     this.watchOptions = options.watchOptions || {};
     this.watchDepth = Number.isFinite(options.watchDepth) ? Math.max(0, options.watchDepth) : DEFAULT_WATCH_DEPTH;
     this.commandRunner = options.commandRunner || new CommandRunner(options.commandRunnerOptions);
@@ -1136,6 +1152,33 @@ class WorkspaceFileService {
     });
   }
 
+  async runWorkspaceMutation(workspaceRoot, operation) {
+    const root = await this.resolveRoot(workspaceRoot);
+    const previous = this.mutationQueues.get(root) || Promise.resolve();
+    let release;
+    const current = new Promise(resolve => {
+      release = resolve;
+    });
+    const tail = previous.then(() => current);
+    this.mutationQueues.set(root, tail);
+    await previous;
+    try {
+      return await operation(root);
+    } finally {
+      release();
+      if (this.mutationQueues.get(root) === tail) {
+        this.mutationQueues.delete(root);
+      }
+    }
+  }
+
+  async waitForWorkspaceMutations(workspaceRoot) {
+    const root = await this.resolveRoot(workspaceRoot);
+    const pending = this.mutationQueues.get(root);
+    if (pending) await pending;
+    return root;
+  }
+
   async execRipgrep(args, options = {}) {
     try {
       return await this.execFile(this.rgPath, args, options);
@@ -1618,7 +1661,8 @@ class WorkspaceFileService {
   }
 
   async listTree(workspaceRoot, userPath = '', options = {}) {
-    const { root, target, relativePath, external: parentExternal = false } = await this.resolvePath(workspaceRoot, userPath, options);
+    const root = await this.waitForWorkspaceMutations(workspaceRoot);
+    const { target, relativePath, external: parentExternal = false } = await this.resolvePath(root, userPath, options);
     const stat = await fsp.stat(target);
     if (!stat.isDirectory()) {
       throw new WorkspaceFileError('path must be a directory', 400);
@@ -1679,6 +1723,7 @@ class WorkspaceFileService {
           type,
           size: targetStat.size,
           mtimeMs: targetStat.mtimeMs,
+          version: workspaceEntryVersion(entryStat),
           ...(symbolicLink ? { symbolicLink: true } : {}),
           ...(external ? { external: true } : {}),
           ...(readOnly ? { readOnly: true } : {}),
@@ -2198,6 +2243,25 @@ class WorkspaceFileService {
   }
 
   async writeFile(workspaceRoot, userPath, content, options = {}) {
+    return this.runWorkspaceMutation(workspaceRoot, root => (
+      this.writeFileUnlocked(root, userPath, content, options)
+    ));
+  }
+
+  async flushWorkspaceFileHandle(handle) {
+    if (!this.flushWorkspaceWrites) return;
+    try {
+      await handle.datasync();
+    } catch (error) {
+      if (!['EINVAL', 'ENOSYS', 'ENOTSUP', 'EOPNOTSUPP'].includes(error?.code)) {
+        throw error;
+      }
+      this.flushWorkspaceWrites = false;
+      console.warn('Workspace file datasync is unsupported; disabling it for this server process:', error);
+    }
+  }
+
+  async writeFileUnlocked(workspaceRoot, userPath, content, options = {}) {
     if (typeof content !== 'string') {
       throw new WorkspaceFileError('content must be a string', 400);
     }
@@ -2211,9 +2275,13 @@ class WorkspaceFileService {
     const overwrite = options.overwrite === true;
     let currentMode = 0o666;
     let currentSha1 = '';
+    let currentStat = null;
     let exists = false;
+    let symbolicLink = false;
 
     try {
+      const requestedStat = await fsp.lstat(target);
+      symbolicLink = requestedStat.isSymbolicLink();
       const realTarget = await fsp.realpath(target);
       if (!isInside(root, realTarget)) {
         throw new WorkspaceFileError('symlinks outside the workspace are not allowed', 403);
@@ -2225,26 +2293,37 @@ class WorkspaceFileService {
     }
 
     try {
-      const stat = await fsp.stat(writeTarget);
-      if (!stat.isFile()) {
+      currentStat = await fsp.stat(writeTarget);
+      if (!currentStat.isFile()) {
         throw new WorkspaceFileError('path must be a file', 400);
       }
-      if (stat.size > this.maxFileSize) {
-        throw new WorkspaceFileError('existing file is too large to overwrite safely', 413, { size: stat.size });
+      if (currentStat.size > this.maxFileSize) {
+        throw new WorkspaceFileError('existing file is too large to overwrite safely', 413, { size: currentStat.size });
       }
       if (await isProbablyBinaryFile(writeTarget)) {
         throw new WorkspaceFileError('binary files cannot be overwritten as text', 415);
       }
       const currentBuffer = await fsp.readFile(writeTarget);
       currentSha1 = sha1(currentBuffer);
-      currentMode = stat.mode;
+      currentMode = currentStat.mode;
       exists = true;
     } catch (error) {
       if (error instanceof WorkspaceFileError) throw error;
       if (error.code !== 'ENOENT') throw error;
     }
 
+    const desiredSha1 = sha1(Buffer.from(content, 'utf8'));
     if (baseSha1 && currentSha1 && baseSha1 !== currentSha1 && !overwrite) {
+      if (currentSha1 === desiredSha1) {
+        return {
+          path: relativePath,
+          content,
+          size: Buffer.byteLength(content, 'utf8'),
+          mtimeMs: currentStat.mtimeMs,
+          sha1: desiredSha1,
+          ...(symbolicLink ? { symbolicLink: true } : {}),
+        };
+      }
       throw new WorkspaceFileError('file changed on disk', 409, {
         path: relativePath,
         currentSha1,
@@ -2256,16 +2335,48 @@ class WorkspaceFileService {
 
     const tempPath = path.join(
       path.dirname(writeTarget),
-      `.${path.basename(writeTarget)}.farming-${process.pid}-${Date.now()}.tmp`
+      `.${path.basename(writeTarget)}.farming-${process.pid}-${crypto.randomUUID()}.tmp`
     );
-    await fsp.writeFile(tempPath, content, { mode: currentMode });
-    await fsp.rename(tempPath, writeTarget);
+    let tempHandle = null;
+    let committedStat = null;
+    try {
+      tempHandle = await fsp.open(tempPath, 'wx', currentMode);
+      await tempHandle.writeFile(content);
+      await this.flushWorkspaceFileHandle(tempHandle);
+      committedStat = await tempHandle.stat();
+      await tempHandle.close();
+      tempHandle = null;
+      await fsp.rename(tempPath, writeTarget);
+    } catch (error) {
+      if (tempHandle) {
+        await tempHandle.close().catch(() => {});
+      }
+      await fsp.unlink(tempPath).catch(unlinkError => {
+        if (unlinkError.code !== 'ENOENT') {
+          console.error('Failed to clean up workspace file temporary:', unlinkError);
+        }
+      });
+      throw error;
+    }
     this.invalidateGitStatus(root);
 
-    return this.readFile(workspaceRoot, relativePath);
+    return {
+      path: relativePath,
+      content,
+      size: Buffer.byteLength(content, 'utf8'),
+      mtimeMs: committedStat.mtimeMs,
+      sha1: desiredSha1,
+      ...(symbolicLink ? { symbolicLink: true } : {}),
+    };
   }
 
-  async moveEntry(workspaceRoot, sourcePath, targetDirectory = '') {
+  async moveEntry(workspaceRoot, sourcePath, targetDirectory = '', options = {}) {
+    return this.runWorkspaceMutation(workspaceRoot, root => (
+      this.moveEntryUnlocked(root, sourcePath, targetDirectory, options)
+    ));
+  }
+
+  async moveEntryUnlocked(workspaceRoot, sourcePath, targetDirectory = '', options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedSource = normalizeUserPath(sourcePath);
     const normalizedTargetDirectory = normalizeUserPath(targetDirectory);
@@ -2310,6 +2421,13 @@ class WorkspaceFileService {
     }
 
     const sourceStat = await fsp.lstat(source.target);
+    const sourceVersion = workspaceEntryVersion(sourceStat);
+    if (options.expectedVersion && options.expectedVersion !== sourceVersion) {
+      throw new WorkspaceFileError('source changed on disk', 409, {
+        path: source.relativePath,
+        currentVersion: sourceVersion,
+      });
+    }
     if (sourceStat.isDirectory() && isInside(source.target, target)) {
       throw new WorkspaceFileError('directory cannot be moved into itself', 400);
     }
@@ -2323,6 +2441,7 @@ class WorkspaceFileService {
     }
 
     await fsp.rename(source.target, target);
+    const targetStat = await fsp.lstat(target);
     this.invalidateGitStatus(root);
 
     return {
@@ -2330,10 +2449,18 @@ class WorkspaceFileService {
       targetPath,
       sourceDirectory: parentDirectory(source.relativePath),
       targetDirectory: normalizedTargetDirectory,
+      sourceVersion,
+      targetVersion: workspaceEntryVersion(targetStat),
     };
   }
 
   async createEntry(workspaceRoot, parentPath = '', name, type = 'file', content = '') {
+    return this.runWorkspaceMutation(workspaceRoot, root => (
+      this.createEntryUnlocked(root, parentPath, name, type, content)
+    ));
+  }
+
+  async createEntryUnlocked(workspaceRoot, parentPath = '', name, type = 'file', content = '') {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedParentPath = normalizeUserPath(parentPath);
     const entryName = normalizeEntryName(name);
@@ -2368,43 +2495,59 @@ class WorkspaceFileService {
       throw new WorkspaceFileError('ignored paths cannot be changed', 403);
     }
 
-    try {
-      await fsp.lstat(target);
-      throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
-    } catch (error) {
-      if (error instanceof WorkspaceFileError) throw error;
-      if (error.code !== 'ENOENT') throw error;
-    }
-
     if (entryType === 'directory') {
-      await fsp.mkdir(target);
+      try {
+        await fsp.mkdir(target);
+      } catch (error) {
+        if (error.code === 'EEXIST') {
+          throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
+        }
+        throw error;
+      }
+      const stat = await fsp.lstat(target);
       this.invalidateGitStatus(root);
       return {
         entry: {
           name: entryName,
           path: targetPath,
           type: 'directory',
-          size: 0,
-          mtimeMs: Date.now(),
+          size: stat.size,
+          mtimeMs: stat.mtimeMs,
+          version: workspaceEntryVersion(stat),
         },
       };
     }
 
-    await fsp.writeFile(target, String(content || ''));
+    try {
+      await fsp.writeFile(target, String(content || ''), { flag: 'wx' });
+    } catch (error) {
+      if (error.code === 'EEXIST') {
+        throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
+      }
+      throw error;
+    }
+    const stat = await fsp.lstat(target);
     this.invalidateGitStatus(root);
     return {
       entry: {
         name: entryName,
         path: targetPath,
         type: 'file',
-        size: Buffer.byteLength(String(content || ''), 'utf8'),
-        mtimeMs: Date.now(),
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        version: workspaceEntryVersion(stat),
       },
       file: await this.readFile(workspaceRoot, targetPath),
     };
   }
 
-  async renameEntry(workspaceRoot, sourcePath, name) {
+  async renameEntry(workspaceRoot, sourcePath, name, options = {}) {
+    return this.runWorkspaceMutation(workspaceRoot, root => (
+      this.renameEntryUnlocked(root, sourcePath, name, options)
+    ));
+  }
+
+  async renameEntryUnlocked(workspaceRoot, sourcePath, name, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedSource = normalizeUserPath(sourcePath);
     const entryName = normalizeEntryName(name);
@@ -2432,6 +2575,15 @@ class WorkspaceFileService {
       };
     }
 
+    const sourceStat = await fsp.lstat(source.target);
+    const sourceVersion = workspaceEntryVersion(sourceStat);
+    if (options.expectedVersion && options.expectedVersion !== sourceVersion) {
+      throw new WorkspaceFileError('source changed on disk', 409, {
+        path: source.relativePath,
+        currentVersion: sourceVersion,
+      });
+    }
+
     try {
       await fsp.lstat(target);
       throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
@@ -2441,6 +2593,7 @@ class WorkspaceFileService {
     }
 
     await fsp.rename(source.target, target);
+    const targetStat = await fsp.lstat(target);
     this.invalidateGitStatus(root);
 
     return {
@@ -2448,10 +2601,18 @@ class WorkspaceFileService {
       targetPath,
       sourceDirectory: parentDirectory(source.relativePath),
       targetDirectory: parentDirectory(targetPath),
+      sourceVersion,
+      targetVersion: workspaceEntryVersion(targetStat),
     };
   }
 
-  async deleteEntry(workspaceRoot, userPath) {
+  async deleteEntry(workspaceRoot, userPath, options = {}) {
+    return this.runWorkspaceMutation(workspaceRoot, root => (
+      this.deleteEntryUnlocked(root, userPath, options)
+    ));
+  }
+
+  async deleteEntryUnlocked(workspaceRoot, userPath, options = {}) {
     const { root, target, relativePath } = await this.resolveEntryPath(workspaceRoot, userPath);
     if (!relativePath) {
       throw new WorkspaceFileError('workspace root cannot be deleted', 400);
@@ -2461,6 +2622,13 @@ class WorkspaceFileService {
     }
 
     const stat = await fsp.lstat(target);
+    const version = workspaceEntryVersion(stat);
+    if (options.expectedVersion && options.expectedVersion !== version) {
+      throw new WorkspaceFileError('entry changed on disk', 409, {
+        path: relativePath,
+        currentVersion: version,
+      });
+    }
     const type = stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : stat.isSymbolicLink() ? 'symlink' : 'other';
     if (stat.isDirectory()) {
       await fsp.rm(target, { recursive: true, force: false });
@@ -2473,6 +2641,7 @@ class WorkspaceFileService {
       path: relativePath,
       parentDirectory: parentDirectory(relativePath),
       type,
+      version,
     };
   }
 
@@ -2975,12 +3144,17 @@ class WorkspaceFileService {
   }
 
   async subscribe(workspaceRoot, callback) {
+    if (this.disposed) return async () => {};
+    const lifecycleGeneration = this.watcherLifecycleGeneration;
     const root = await this.resolveRoot(workspaceRoot);
+    if (this.disposed || this.watcherLifecycleGeneration !== lifecycleGeneration) return async () => {};
     const watchRoot = path.resolve(workspaceRoot);
     let record = this.watchers.get(root);
 
     if (!record) {
       const subscribers = new Set();
+      const generation = this.watcherSubscriptionGeneration + 1;
+      this.watcherSubscriptionGeneration = generation;
 
       const emit = (eventType, absolutePath) => {
         const relative = relativeFromRoot(watchRoot, absolutePath);
@@ -3003,56 +3177,112 @@ class WorkspaceFileService {
         });
       };
 
-      const configuredIgnored = this.watchOptions.ignored;
-      const ignored = (candidatePath) => {
-        const relative = path.relative(watchRoot, candidatePath);
-        if (shouldHidePath(relative)) return true;
-        if (typeof configuredIgnored === 'function') return configuredIgnored(candidatePath);
-        if (configuredIgnored instanceof RegExp) return configuredIgnored.test(candidatePath);
-        if (Array.isArray(configuredIgnored)) {
-          return configuredIgnored.some(pattern => (
-            pattern instanceof RegExp ? pattern.test(candidatePath) : String(candidatePath).includes(String(pattern))
-          ));
-        }
-        return false;
+      record = {
+        watcher: null,
+        subscribers,
+        generation,
+        cancelled: false,
+        cancelInitialization: null,
+        closePromise: null,
+        ready: null,
       };
-      const chokidar = await loadChokidar();
-      const watcher = chokidar.watch(watchRoot, {
-        ignoreInitial: true,
-        depth: this.watchDepth,
-        ...this.watchOptions,
-        ignored,
-      });
-
-      ['add', 'change', 'unlink', 'addDir', 'unlinkDir'].forEach((eventType) => {
-        watcher.on(eventType, filePath => emit(eventType, filePath));
-      });
-      watcher.on('error', emitError);
-      const ready = new Promise(resolve => watcher.once('ready', resolve));
-
-      record = { watcher, subscribers, ready };
       this.watchers.set(root, record);
+      record.ready = (async () => {
+        const configuredIgnored = this.watchOptions.ignored;
+        const ignored = (candidatePath) => {
+          const relative = path.relative(watchRoot, candidatePath);
+          if (shouldHidePath(relative)) return true;
+          if (typeof configuredIgnored === 'function') return configuredIgnored(candidatePath);
+          if (configuredIgnored instanceof RegExp) return configuredIgnored.test(candidatePath);
+          if (Array.isArray(configuredIgnored)) {
+            return configuredIgnored.some(pattern => (
+              pattern instanceof RegExp ? pattern.test(candidatePath) : String(candidatePath).includes(String(pattern))
+            ));
+          }
+          return false;
+        };
+        const chokidar = await loadChokidar();
+        if (
+          record.cancelled
+          || this.watchers.get(root)?.generation !== generation
+        ) return false;
+        const watcher = chokidar.watch(watchRoot, {
+          ignoreInitial: true,
+          depth: this.watchDepth,
+          ...this.watchOptions,
+          ignored,
+        });
+        record.watcher = watcher;
+
+        ['add', 'change', 'unlink', 'addDir', 'unlinkDir'].forEach((eventType) => {
+          watcher.on(eventType, filePath => emit(eventType, filePath));
+        });
+        watcher.on('error', emitError);
+        const initialized = await new Promise(resolve => {
+          let settled = false;
+          const finish = value => {
+            if (settled) return;
+            settled = true;
+            resolve(value);
+          };
+          watcher.once('ready', () => finish(true));
+          record.cancelInitialization = () => finish(false);
+        });
+        record.cancelInitialization = null;
+        return initialized
+          && !record.cancelled
+          && this.watchers.get(root)?.generation === generation;
+      })();
     }
 
-    await record.ready;
     record.subscribers.add(callback);
-    return async () => {
+    let initialized = false;
+    try {
+      initialized = await record.ready;
+    } catch (error) {
       record.subscribers.delete(callback);
-      if (record.subscribers.size === 0) {
+      if (record.subscribers.size === 0 && this.watchers.get(root)?.generation === record.generation) {
         this.watchers.delete(root);
-        const closeResult = record.watcher.close();
-        if (closeResult && typeof closeResult.then === 'function') {
-          await closeResult;
-        }
+        await this.closeWorkspaceWatcherRecord(record);
+      }
+      throw error;
+    }
+    if (!initialized) {
+      record.subscribers.delete(callback);
+      return async () => {};
+    }
+    return async () => {
+      if (!record.subscribers.delete(callback)) return;
+      if (
+        record.subscribers.size === 0
+        && this.watchers.get(root)?.generation === record.generation
+      ) {
+        this.watchers.delete(root);
+        await this.closeWorkspaceWatcherRecord(record);
       }
     };
   }
 
+  async closeWorkspaceWatcherRecord(record) {
+    if (record.closePromise) return record.closePromise;
+    record.cancelled = true;
+    record.cancelInitialization?.();
+    record.closePromise = (async () => {
+      await record.ready?.catch(() => false);
+      if (!record.watcher) return;
+      const closeResult = record.watcher.close();
+      if (closeResult && typeof closeResult.then === 'function') await closeResult;
+    })();
+    return record.closePromise;
+  }
+
   async dispose() {
     const watchers = Array.from(this.watchers.values());
     this.watchers.clear();
+    this.disposed = true;
+    this.watcherLifecycleGeneration += 1;
     this.gitStatusCache.clear();
-    await Promise.all(watchers.map(record => record.watcher.close()));
+    await Promise.all(watchers.map(record => this.closeWorkspaceWatcherRecord(record)));
     if (this.ownsCommandRunner) {
       this.commandRunner.dispose();
     }

package/dist/acp/codex-acp-1.1.4.js

@@ -26066,6 +26066,17 @@ var CodexAcpClient = class {
       additionalDirectories
     };
   }
+  async forkSession(request) {
+    const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
+    await this.refreshSkills(request.cwd, additionalDirectories);
+    const response = await this.codexClient.threadFork({
+      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
+      cwd: request.cwd,
+      modelProvider: await this.getResumeModelProvider(),
+      threadId: request.sessionId
+    });
+    return { sessionId: response.thread.id };
+  }
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
@@ -28211,6 +28222,7 @@ var CodexAcpServer = class _CodexAcpServer {
         sessionCapabilities: {
           resume: {},
           list: {},
+          fork: {},
           close: {},
           delete: {},
           additionalDirectories: {}
@@ -28512,6 +28524,22 @@ You have been logged out. Please try again.`);
       ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
+  async unstable_forkSession(params) {
+    logger.log("Forking session...", { sessionId: params.sessionId });
+    const sessionState = this.sessions.get(params.sessionId);
+    if (!sessionState) {
+      throw RequestError.invalidParams(void 0, `Unknown session: ${params.sessionId}`);
+    }
+    if (this.activePrompts.has(sessionState.sessionId)) {
+      throw RequestError.invalidRequest({ details: "Cannot fork an active Codex turn" });
+    }
+    const response = await this.runWithProcessCheck(() => this.codexAcpClient.forkSession(params));
+    logger.log("Session forked", {
+      sourceSessionId: params.sessionId,
+      sessionId: response.sessionId
+    });
+    return response;
+  }
   async resumeSession(params) {
     logger.log("Resuming session...", { sessionId: params.sessionId });
     const [sessionId, modelState, modeState] = await this.getOrCreateSession(params);
@@ -30074,6 +30102,9 @@ var CodexAppServerClient = class {
   async threadResume(params) {
     return await this.sendRequest({ method: "thread/resume", params });
   }
+  async threadFork(params) {
+    return await this.sendRequest({ method: "thread/fork", params });
+  }
   getThreadSettings(threadId) {
     return this.threadSettings.get(threadId);
   }
@@ -30714,5 +30745,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).onRequest(STEER_METHOD, steerParamsParser, (ctx) => getAgent().extMethod(STEER_METHOD, ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().unstable_forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).onRequest(STEER_METHOD, steerParamsParser, (ctx) => getAgent().extMethod(STEER_METHOD, ctx.params)).connect(acpJsonStream);
 }