cursor-feedback 2.4.0 → 2.5.0

package/.cursor/rules/learned-conventions.mdc

@@ -0,0 +1,9 @@
+---
+description: 从对话反馈中积累的编码约定和偏好
+alwaysApply: true
+---
+
+# 编码约定
+
+## 发布流程
+- 发版（npm / Open VSX / VS Code Marketplace）前必须经用户明确确认，绝不能改完代码直接发。改动完成后先提交 + 跑冒烟，向用户汇报并等确认后再走发版流程。

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.5.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.4.1...v2.5.0) (2026-07-06)
+
+
+### Features
+
+* /help 完整用法说明；全角斜杠／归一化；持久化「发版需用户确认」规则 ([d345b55](https://github.com/jianger666/cursor-feedback-extension/commit/d345b55da22cad9e1a838999f0d58dd36ffa10b2))
+* slash commands case-insensitive + /help command, malformed /model //cwd args no longer fall through to feedback routing ([a4bceeb](https://github.com/jianger666/cursor-feedback-extension/commit/a4bceebb588898c82acb797e8f5abefb7a457550))
+
+
+### Code Refactoring
+
+* **cli:** /new 工作目录简化为「显式指定>主目录」与 IDE 窗口解耦；移除 /cwd；新增 /projects 查项目路径、/new 支持项目名匹配 ([0752a32](https://github.com/jianger666/cursor-feedback-extension/commit/0752a3232de0e712b977f9f01ba988613cd7597c))
+
+### [2.4.1](https://github.com/jianger666/cursor-feedback-extension/compare/v2.4.0...v2.4.1) (2026-07-06)
+
+
+### Bug Fixes
+
+* **cli:** CLI 会话全局锁——多窗口/守护多实例并存时 /new /stop 跨实例一致 ([679c3ef](https://github.com/jianger666/cursor-feedback-extension/commit/679c3ef3ce43af768be939d4059a452cd3d20178))
+
 ## [2.4.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.3.1...v2.4.0) (2026-07-06)
 
 

package/README.md

@@ -270,11 +270,13 @@ Send these directly in the bot chat:
 
 | Command | What it does |
 |---------|--------------|
-| `/new task description` | Launch a headless CLI session for the task (in the active window's workspace, or the `/cwd` default) |
-| `/new /abs/path task description` | Launch with an explicit working directory |
+| `/new task description` | Launch a headless CLI session for the task (in your home directory by default) |
+| `/new /abs/path task description` | Launch in an explicit working directory |
+| `/new project-name task description` | Launch in a project Cursor has opened before (unique folder-name match) |
+| `/projects` | List project paths Cursor has opened (to look up / copy into `/new`) |
 | `/stop` | Terminate the running CLI session |
 | `/model [modelId]` | Show / set the session model (persisted) |
-| `/cwd [dir]` | Show / set the default working directory (persisted) |
+| `/help` | Show command usage |
 
 - Sessions run in **non-interactive mode** with `maxMode=false` force-written before spawn — on request-based plans each session costs exactly 1 request, never Max billing.
 - The launched agent talks to you through this extension's feedback cards: confirmations and progress reports are pushed to Feishu; just reply to the cards.

package/README_CN.md

@@ -274,11 +274,13 @@ npm install -g cursor-feedback
 
 | 命令 | 作用 |
 |------|------|
-| `/new 任务描述` | 拉起一个 headless CLI 会话跑这个任务（默认在活跃窗口工作区 / `/cwd` 设置的目录） |
+| `/new 任务描述` | 拉起一个 headless CLI 会话跑这个任务（默认在主目录） |
 | `/new /绝对路径 任务描述` | 指定工作目录拉起 |
+| `/new 项目名 任务描述` | 在 Cursor 打开过的项目里拉起（目录名唯一匹配） |
+| `/projects` | 列出 Cursor 打开过的项目路径（供查路径 / 复制给 `/new`） |
 | `/stop` | 终止运行中的 CLI 会话 |
 | `/model [模型id]` | 查看 / 设置会话模型（持久化） |
-| `/cwd [目录]` | 查看 / 设置默认工作目录（持久化） |
+| `/help` | 查看命令用法 |
 
 - 会话以**非交互模式**运行，拉起前强制写入 `maxMode=false`——按次计费套餐固定只扣 1 次请求，永远不会走 Max 计费。
 - 拉起的 Agent 也通过本插件的反馈卡片与你沟通：需要确认、汇报进展都会推到飞书，直接回复卡片即可。

package/dist/cli-launcher.js

@@ -62,15 +62,113 @@ class CliLauncher {
         this.taskBrief = '';
         this.stopRequested = false;
     }
+    /* ---------- 磁盘全局会话锁 ----------
+     * 「同时只跑一个 CLI 会话」必须全局生效：多窗口 + 守护进程是多实例并存，
+     * 飞书把 /new、/stop 推给哪个实例是不确定的（长连接负载均衡）。只看本实例的
+     * child 会被击穿：A 拉了会话，下一条 /new 推给 B，B 以为空闲又拉一个。
+     * 锁文件记录会话进程 pid，任何实例都能据此判忙 / 跨实例终止；
+     * 持锁进程崩溃后锁自动失效（pid 探活），不会死锁。 */
+    lockPath() {
+        return path.join(os.homedir(), '.cursor-feedback', 'cli-session.lock');
+    }
+    readLock() {
+        try {
+            const j = JSON.parse(fs.readFileSync(this.lockPath(), 'utf-8'));
+            return typeof j.pid === 'number' ? j : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static pidAlive(pid) {
+        if (!pid || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * pid 是否确实是 cursor-agent 会话进程。防 pid 复用：锁残留（极端崩溃）后系统把同号
+     * pid 分给了无关进程，跨实例 /stop 若不校验会误杀无辜。校验失败按「不是会话」处理。
+     */
+    static pidLooksLikeAgent(pid) {
+        try {
+            if (process.platform === 'win32') {
+                const out = (0, child_process_1.execFileSync)('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], {
+                    encoding: 'utf-8',
+                });
+                return /cursor-agent|node|cmd\.exe/i.test(out);
+            }
+            const out = (0, child_process_1.execFileSync)('ps', ['-o', 'command=', '-p', String(pid)], { encoding: 'utf-8' });
+            return /cursor-agent/i.test(out);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** 当前全局是否有活跃会话（锁存在且会话进程活着；死锁视为无会话） */
+    aliveLock() {
+        const lock = this.readLock();
+        if (!lock)
+            return null;
+        // pid=0 = 另一个实例刚抢到锁、spawn 还没完成：以它的实例进程判活，避免这瞬间被当死锁误清
+        const alive = lock.pid > 0
+            ? CliLauncher.pidAlive(lock.pid)
+            : CliLauncher.pidAlive(lock.ownerPid);
+        if (!alive) {
+            // 持锁会话已死（实例崩溃 / 强杀），清掉残锁
+            fs.rmSync(this.lockPath(), { force: true });
+            return null;
+        }
+        return lock;
+    }
+    /** 原子抢锁：wx 独占创建。返回是否抢到（false = 别的实例刚抢先） */
+    tryAcquireLock(task) {
+        // 先清死锁，再独占创建（两个实例同时 /new 时只有一个 wx 成功）
+        this.aliveLock();
+        const lock = { pid: 0, task, startedAt: Date.now(), ownerPid: process.pid };
+        try {
+            fs.mkdirSync(path.dirname(this.lockPath()), { recursive: true });
+            fs.writeFileSync(this.lockPath(), JSON.stringify(lock), { flag: 'wx' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    updateLockPid(pid) {
+        const lock = this.readLock();
+        if (lock && lock.ownerPid === process.pid) {
+            fs.writeFileSync(this.lockPath(), JSON.stringify({ ...lock, pid }));
+        }
+    }
+    releaseLock() {
+        const lock = this.readLock();
+        if (lock && lock.ownerPid === process.pid) {
+            fs.rmSync(this.lockPath(), { force: true });
+        }
+    }
+    /** 全局视角：是否有会话在跑（本实例或其他实例拉起的都算） */
     isRunning() {
-        return this.child !== null;
+        return this.child !== null || this.aliveLock() !== null;
     }
-    /** 正在运行的会话描述（用于「已有会话在跑」的回执） */
+    /** 正在运行的会话描述（用于「已有会话在跑」的回执；含其他实例拉起的会话） */
     describe() {
-        if (!this.child)
-            return '';
-        const mins = Math.round((Date.now() - this.startedAt) / 60000);
-        return `「${this.taskBrief}」（已运行 ${mins} 分钟）`;
+        if (this.child) {
+            const mins = Math.round((Date.now() - this.startedAt) / 60000);
+            return `「${this.taskBrief}」（已运行 ${mins} 分钟）`;
+        }
+        const lock = this.aliveLock();
+        if (lock) {
+            const brief = lock.task.length > 40 ? lock.task.slice(0, 40) + '…' : lock.task;
+            const mins = Math.round((Date.now() - lock.startedAt) / 60000);
+            return `「${brief}」（已运行 ${mins} 分钟，由另一个窗口实例托管）`;
+        }
+        return '';
     }
     settingsPath() {
         return path.join(os.homedir(), '.cursor-feedback', 'cli.json');
@@ -96,12 +194,61 @@ class CliLauncher {
             this.readSettings().model ||
             CliLauncher.DEFAULT_MODEL);
     }
-    /** /cwd 设置的默认工作目录（存在才返回） */
-    defaultCwd() {
-        const d = this.readSettings().defaultCwd;
-        if (d && fs.existsSync(d))
-            return d;
-        return null;
+    /** Cursor IDE 的 storage.json 路径（平台相关） */
+    static storageJsonPath() {
+        if (process.platform === 'darwin') {
+            return path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'storage.json');
+        }
+        if (process.platform === 'win32') {
+            return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'storage.json');
+        }
+        return path.join(os.homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'storage.json');
+    }
+    /**
+     * 用户在 Cursor IDE 里打开过的项目目录（供手机上查路径 / 按项目名拉起会话）。
+     * 数据源是 IDE 的 storage.json：backupWorkspaces.folders 是当前/最近打开的窗口（排前面），
+     * profileAssociations.workspaces 是历史打开过的全部工作区。只返回仍然存在的目录。
+     */
+    listProjects() {
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(CliLauncher.storageJsonPath(), 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+        const uris = [
+            ...(raw.backupWorkspaces?.folders || []).map((f) => f.folderUri || ''),
+            ...Object.keys(raw.profileAssociations?.workspaces || {}),
+        ];
+        const seen = new Set();
+        const result = [];
+        for (const uri of uris) {
+            if (!uri.startsWith('file://'))
+                continue;
+            let dir;
+            try {
+                dir = decodeURIComponent(uri.replace(/^file:\/\//, ''));
+            }
+            catch {
+                continue;
+            }
+            // Windows 的 URI 形如 file:///c%3A/... → 去掉开头多余的 /
+            if (process.platform === 'win32' && /^\/[a-zA-Z]:/.test(dir))
+                dir = dir.slice(1);
+            const key = dir.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            try {
+                if (fs.statSync(dir).isDirectory())
+                    result.push(dir);
+            }
+            catch {
+                // 已删除的目录不展示
+            }
+        }
+        return result;
     }
     /**
      * 定位 cursor-agent 可执行文件。安装脚本默认放在 ~/.local/bin（mac/linux 是
@@ -182,17 +329,24 @@ class CliLauncher {
      * @returns 启动失败时返回错误说明字符串；成功返回 null，结果经 onDone 回调
      */
     start(task, cwd, onDone) {
-        if (this.child)
+        if (this.isRunning())
             return '已有一个 CLI 会话在运行：' + this.describe();
+        // 原子抢全局锁：两个实例同时收到 /new 时只有一个能抢到
+        if (!this.tryAcquireLock(task)) {
+            return '已有一个 CLI 会话在运行：' + (this.describe() || '（另一个窗口实例刚刚抢先拉起）');
+        }
         try {
             this.ensureMaxModeOff();
         }
         catch (e) {
+            this.releaseLock();
             return '写入 cli-config.json 失败：' + e;
         }
         const bin = this.findBinary();
-        if (!bin)
+        if (!bin) {
+            this.releaseLock();
             return '找不到 cursor-agent，可通过环境变量 CURSOR_AGENT_PATH 指定路径。';
+        }
         const workDir = fs.existsSync(cwd) ? cwd : os.homedir();
         const prompt = this.buildPrompt(task);
         let stdout = '';
@@ -225,12 +379,14 @@ class CliLauncher {
             });
         }
         catch (e) {
+            this.releaseLock();
             return '拉起 cursor-agent 失败：' + e;
         }
         this.child = child;
         this.startedAt = Date.now();
         this.taskBrief = task.length > 40 ? task.slice(0, 40) + '…' : task;
         this.stopRequested = false;
+        this.updateLockPid(child.pid || 0);
         clog(`CLI 会话已拉起: pid=${child.pid} cwd=${workDir} model=${this.model()}`);
         let timedOut = false;
         const killTimer = setTimeout(() => {
@@ -243,8 +399,12 @@ class CliLauncher {
         const finish = (code) => {
             clearTimeout(killTimer);
             const elapsedMs = Date.now() - this.startedAt;
-            const stopped = this.stopRequested;
+            // 跨实例 /stop 会在锁上打 stopRequested 标记再杀进程，这里一并算「主动终止」
+            const lockAtFinish = this.readLock();
+            const stopped = this.stopRequested ||
+                !!(lockAtFinish && lockAtFinish.ownerPid === process.pid && lockAtFinish.stopRequested);
             this.child = null;
+            this.releaseLock();
             clog(`CLI 会话结束: code=${code} elapsed=${Math.round(elapsedMs / 1000)}s timedOut=${timedOut} stopped=${stopped}`);
             onDone({
                 code,
@@ -263,20 +423,60 @@ class CliLauncher {
         child.on('close', (code) => finish(code));
         return null;
     }
-    /** 用户 /stop 主动终止会话。返回是否有会话被终止。 */
+    /**
+     * 用户 /stop 主动终止会话。返回是否有会话被终止。
+     * 跨实例：会话可能由另一个窗口实例托管（飞书把 /stop 推给了不同实例），
+     * 此时按锁里的 pid 直接终止会话进程，托管实例的 close 回调会自然收尾并回执。
+     */
     stop() {
-        if (!this.child)
-            return false;
-        this.stopRequested = true;
-        CliLauncher.killTree(this.child, 'SIGTERM');
-        // SIGTERM 5s 内没退出则补 SIGKILL
-        const child = this.child;
-        setTimeout(() => {
-            if (this.child === child) {
-                CliLauncher.killTree(child, 'SIGKILL');
+        if (this.child) {
+            this.stopRequested = true;
+            CliLauncher.killTree(this.child, 'SIGTERM');
+            // SIGTERM 5s 内没退出则补 SIGKILL
+            const child = this.child;
+            setTimeout(() => {
+                if (this.child === child) {
+                    CliLauncher.killTree(child, 'SIGKILL');
+                }
+            }, 5000);
+            return true;
+        }
+        const lock = this.aliveLock();
+        if (lock && lock.pid > 0) {
+            if (!CliLauncher.pidLooksLikeAgent(lock.pid)) {
+                // pid 已被无关进程复用（残锁）：清锁但绝不误杀
+                clog(`锁 pid=${lock.pid} 不是 cursor-agent（已被复用），清除残锁`);
+                fs.rmSync(this.lockPath(), { force: true });
+                return false;
+            }
+            clog(`跨实例终止 CLI 会话: pid=${lock.pid}（由 ${lock.ownerPid} 托管）`);
+            try {
+                // 先在锁上打「主动终止」标记，托管实例收尾时据此报「已终止」而非「异常退出」
+                fs.writeFileSync(this.lockPath(), JSON.stringify({ ...lock, stopRequested: true }));
             }
-        }, 5000);
-        return true;
+            catch {
+                // 标记失败只影响收尾文案
+            }
+            try {
+                // 会话进程是托管实例 detached 出来的进程组组长，杀整组
+                if (process.platform === 'win32') {
+                    (0, child_process_1.spawn)('taskkill', ['/pid', String(lock.pid), '/T', '/F'], { stdio: 'ignore' });
+                }
+                else {
+                    try {
+                        process.kill(-lock.pid, 'SIGTERM');
+                    }
+                    catch {
+                        process.kill(lock.pid, 'SIGTERM');
+                    }
+                }
+            }
+            catch {
+                // 进程刚好自己结束了
+            }
+            return true;
+        }
+        return false;
     }
     /**
      * 终止整个进程树：POSIX 杀进程组（detached spawn 后 child.pid 即组长），

package/dist/mcp-server.js

@@ -396,7 +396,8 @@ class McpFeedbackServer {
             if (!text && images.length === 0 && files.length === 0)
                 return;
             // 斜杠命令优先于反馈路由：用户显式输入命令时不应被当成对某张卡片的回复或排队消息。
-            if (/^\/(new|stop|model|cwd)\b/.test(text) && this.handleCliCommand(text, chatId))
+            // 大小写不敏感：手机输入法常自动把句首字母大写（/New），必须容错。
+            if (/^\s*[/／](new|stop|model|cwd|help|projects)\b/i.test(text) && this.handleCliCommand(text, chatId))
                 return;
             if (parentId) {
                 // 用户「回复」了某条卡片 → 用 parent_id 精确路由
@@ -494,13 +495,51 @@ class McpFeedbackServer {
     }
     /**
      * 处理飞书斜杠命令。返回是否已消费该消息。
-     * - /new [工作目录] 任务描述：拉起一个 headless CLI 会话（非交互 + maxMode=false，扣 1 次请求）
+     * - /new [目录或项目名] 任务描述：拉起 headless CLI 会话（非交互 + maxMode=false，扣 1 次请求）。
+     *   工作目录刻意保持简单：显式指定 > 主目录，与当前开着哪些 IDE 窗口无关。
+     * - /projects：列出 Cursor 打开过的项目路径（供手机上查路径 / 复制给 /new）
      * - /stop：终止运行中的 CLI 会话
      * - /model [模型id]：查看 / 设置 CLI 会话模型（持久化；无论选什么模型都强制 maxMode=false）
-     * - /cwd [目录]：查看 / 设置默认工作目录（持久化；IDE 不开时 /new 用它）
      */
-    handleCliCommand(text, chatId) {
-        if (/^\/stop\b/.test(text)) {
+    handleCliCommand(rawText, chatId) {
+        // 输入容错：首尾空格（飞书入站已 trim，这里兜底；trim 同样覆盖全角空格 U+3000）；
+        // 全角斜杠「／」归一化（中文输入法常见）；命令词大小写不敏感（手机输入法自动把句首
+        // 大写成 /New）。任务正文原样保留。
+        const text = rawText.trim().replace(/^／/, '/');
+        if (/^\/help\b/i.test(text)) {
+            this.feishu.replyText(chatId, '📖 命令一览（大小写、首尾空格都不敏感）\n\n' +
+                '🚀 /new 任务描述\n' +
+                '拉起一个全新的 AI 会话跑任务，电脑不用开着 Cursor（需已开启常驻服务）。\n' +
+                '· 默认工作目录是主目录；可在任务前指定项目：\n' +
+                '  /new /Users/me/proj 帮我修下测试\n' +
+                '  /new crm-web 帮我修下测试（项目名唯一时自动匹配到完整路径）\n' +
+                '· 非交互模式 + 强制 maxMode=false，每次会话固定只扣 1 次请求\n' +
+                '· AI 需要沟通时会发反馈卡片，直接回复即可；同时只能跑一个会话\n\n' +
+                '📁 /projects\n' +
+                '列出 Cursor 打开过的项目路径（查路径 / 复制给 /new，也可直接用项目名）\n\n' +
+                '🛑 /stop\n' +
+                '终止运行中的 CLI 会话（任何窗口拉起的都能停）\n\n' +
+                '🧠 /model [模型id]\n' +
+                '查看 / 设置会话模型（持久化；无论选什么模型都不会走 Max 计费）\n\n' +
+                '❓ /help\n' +
+                '看这份帮助\n\n' +
+                '💬 不带斜杠的消息照常作为反馈：回复某张卡片就送达那个请求，直接发送则给当前等待中的 AI。');
+            return true;
+        }
+        if (/^\/projects\b/i.test(text)) {
+            const projects = this.cliLauncher.listProjects();
+            if (!projects.length) {
+                this.feishu.replyText(chatId, '没有找到 Cursor 打开过的项目记录。可以直接用绝对路径：/new /绝对路径 任务描述');
+            }
+            else {
+                const lines = projects.slice(0, 20).map((p) => `· ${path.basename(p)} — ${p}`);
+                this.feishu.replyText(chatId, `Cursor 打开过的项目（共 ${projects.length} 个${projects.length > 20 ? '，只列最近 20 个' : ''}）：\n` +
+                    lines.join('\n') +
+                    '\n\n用法：/new 项目名 任务描述（项目名唯一时直接匹配），或 /new 完整路径 任务描述');
+            }
+            return true;
+        }
+        if (/^\/stop\b/i.test(text)) {
             if (this.cliLauncher.stop()) {
                 this.feishu.replyText(chatId, '🛑 正在终止 CLI 会话…结束后我会再发一条收尾消息。');
             }
@@ -509,7 +548,7 @@ class McpFeedbackServer {
             }
             return true;
         }
-        const mModel = text.match(/^\/model(?:\s+(\S+))?\s*$/);
+        const mModel = text.match(/^\/model(?:\s+(\S+))?\s*$/i);
         if (mModel) {
             if (mModel[1]) {
                 this.cliLauncher.writeSettings({ model: mModel[1] });
@@ -520,52 +559,59 @@ class McpFeedbackServer {
             }
             return true;
         }
-        const mCwd = text.match(/^\/cwd(?:\s+(\S+))?\s*$/);
-        if (mCwd) {
-            if (mCwd[1]) {
-                const dir = this.expandDirToken(mCwd[1]);
-                if (!dir) {
-                    this.feishu.replyText(chatId, `❌ 目录不存在或不是有效路径：${mCwd[1]}`);
-                }
-                else {
-                    this.cliLauncher.writeSettings({ defaultCwd: dir });
-                    this.feishu.replyText(chatId, `✅ 默认工作目录已设为 ${dir}\n之后 /new 不带路径时都用它。`);
-                }
-            }
-            else {
-                const cur = this.cliLauncher.defaultCwd();
-                this.feishu.replyText(chatId, `当前默认工作目录：${cur || '（未设置，回退到活跃窗口工作区或主目录）'}\n设置：/cwd 绝对路径`);
-            }
+        // /cwd 已移除（工作目录简化为「/new 里显式指定，否则主目录」），给老用户指个路
+        if (/^\/cwd\b/i.test(text)) {
+            this.feishu.replyText(chatId, '/cwd 已移除。现在直接在 /new 里指定：/new 项目名或/绝对路径 任务描述；不指定就在主目录跑。\n用 /projects 可以查项目路径。');
+            return true;
+        }
+        // /model 带了多余参数（如 /model a b）：不落入反馈路由（用户明显在敲命令），回用法提示
+        if (/^\/model\b/i.test(text)) {
+            this.feishu.replyText(chatId, '参数不对。用法：/model 模型id（只接受一个参数，留空为查看当前模型）');
             return true;
         }
-        const m = text.match(/^\/new\s*([\s\S]*)$/);
+        const m = text.match(/^\/new\b\s*([\s\S]*)$/i);
         if (!m)
             return false;
         let task = (m[1] || '').trim();
         if (!task) {
-            this.feishu.replyText(chatId, '用法：/new 任务描述\n' +
-                '可选在任务前带一个已存在的目录作为工作目录：\n' +
+            this.feishu.replyText(chatId, '用法：/new 任务描述（默认在主目录跑）\n' +
+                '可选在任务前带工作目录（绝对路径或项目名）：\n' +
                 '/new /Users/me/proj 帮我看下测试为什么挂了\n' +
-                '相关命令：/cwd 设默认目录、/model 设模型、/stop 终止会话。');
+                '/new my-blog 帮我看下测试为什么挂了\n' +
+                '相关命令：/projects 查项目路径、/model 设模型、/stop 终止会话。');
             return true;
         }
         if (this.cliLauncher.isRunning()) {
             this.feishu.replyText(chatId, '已有一个 CLI 会话在运行：' + this.cliLauncher.describe() + '\n发 /stop 可先终止它。');
             return true;
         }
-        // 工作目录优先级：命令里显式路径 > /cwd 持久化默认目录 > 本实例归属窗口 > 主目录。
-        // 注意 ownerWorkspace 是小写归一化路径，macOS 默认大小写不敏感文件系统下可直接使用。
-        let cwd = this.cliLauncher.defaultCwd() ||
-            (this.ownerWorkspace && fs.existsSync(this.ownerWorkspace)
-                ? this.ownerWorkspace
-                : os.homedir());
-        const explicitDir = this.expandDirToken(task.split(/\s+/)[0]);
+        // 工作目录刻意保持简单、与 IDE 窗口无关：命令里显式指定（路径或项目名）> 主目录。
+        let cwd = os.homedir();
+        const firstToken = task.split(/\s+/)[0];
+        const explicitDir = this.expandDirToken(firstToken);
         if (explicitDir) {
             cwd = explicitDir;
-            task = task.slice(task.split(/\s+/)[0].length).trim();
+            task = task.slice(firstToken.length).trim();
+        }
+        else {
+            // 首词不是路径 → 试着当项目名匹配（Cursor 打开过的项目，按目录名精确匹配、忽略大小写）。
+            // 唯一命中才采用；多个重名让用户用完整路径消歧；没命中就当作任务正文的第一个词。
+            const matches = this.cliLauncher
+                .listProjects()
+                .filter((p) => path.basename(p).toLowerCase() === firstToken.toLowerCase());
+            if (matches.length === 1) {
+                cwd = matches[0];
+                task = task.slice(firstToken.length).trim();
+            }
+            else if (matches.length > 1) {
+                this.feishu.replyText(chatId, `有 ${matches.length} 个同名项目「${firstToken}」：\n` +
+                    matches.map((p) => `· ${p}`).join('\n') +
+                    '\n请用完整路径：/new 完整路径 任务描述');
+                return true;
+            }
         }
         if (!task) {
-            this.feishu.replyText(chatId, '只给了目录没给任务。用法：/new [工作目录] 任务描述');
+            this.feishu.replyText(chatId, '只给了目录没给任务。用法：/new [目录或项目名] 任务描述');
             return true;
         }
         const err = this.cliLauncher.start(task, cwd, (result) => this.onCliSessionDone(result, chatId));

package/package.json

@@ -2,7 +2,7 @@
   "name": "cursor-feedback",
   "displayName": "Cursor Feedback",
   "description": "One Cursor conversation, unlimited AI interactions - Save your monthly request quota! Interactive feedback loop for AI chat via MCP",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",