metame-cli 1.6.2 → 1.6.3

package/index.js

@@ -1532,7 +1532,18 @@ if (AUTO_UPDATE.enabled) {
             timeout: 60000,
             ...(process.platform === 'win32' ? { shell: process.env.COMSPEC || true } : {}),
           });
-          console.log(`${icon("ok")} Updated to ${latest}. Restart metame to use the new version.`);
+          // Auto-restart the running daemon so the new code takes effect immediately.
+          // Safe by design: requestDaemonRestart short-circuits with status 'not_running'
+          // when no daemon.pid exists, and the current CLI process is never itself the
+          // daemon (metame daemon spawns a separate node process via DAEMON_SCRIPT).
+          const restart = requestDaemonRestart({ reason: 'auto-update' });
+          if (restart.ok) {
+            console.log(`${icon("ok")} Updated to ${latest}. Daemon restart requested (${restart.status}).`);
+          } else if (restart.status === 'not_running') {
+            console.log(`${icon("ok")} Updated to ${latest}.`);
+          } else {
+            console.log(`${icon("ok")} Updated to ${latest}. Daemon restart failed (${restart.status}); run \`metame restart\`.`);
+          }
         } catch (e) {
           const msg = e.stderr ? e.stderr.toString().trim().split('\n').pop() : '';
           console.log(`${icon("warn")} Auto-update failed${msg ? ': ' + msg : ''}. Run manually: npm install -g metame-cli`);
@@ -2080,17 +2091,44 @@ if (isDaemon) {
         console.log("  Skipped.\n");
       }
 
+      // Tiny cross-platform "open URL in default browser" helper. Fire-and-
+      // forget — if the GUI isn't available (SSH/Docker/CI), we silently fall
+      // back and the user copy-pastes the URL from the terminal output.
+      const tryOpenInBrowser = (url) => {
+        try {
+          const { spawn: _spawn } = require('child_process');
+          const platform = process.platform;
+          const cmd = platform === 'darwin'
+            ? 'open'
+            : platform === 'win32'
+              ? 'cmd'
+              : 'xdg-open';
+          const args = platform === 'win32' ? ['/c', 'start', '""', url] : [url];
+          const child = _spawn(cmd, args, {
+            stdio: 'ignore',
+            detached: true,
+            ...(platform === 'win32' ? { shell: false, windowsHide: true } : {}),
+          });
+          child.on('error', () => { /* GUI unavailable, ignore */ });
+          child.unref();
+          return true;
+        } catch { return false; }
+      };
+
       // --- Feishu Setup ---
       console.log(`━━━ ${icon("feishu")} Feishu (Lark) Setup ━━━`);
       console.log("");
+      const FEISHU_CONSOLE_URL = 'https://open.feishu.cn/app';
       console.log("Step 1: Create an App");
-      console.log("  • Go to: https://open.feishu.cn/app");
+      console.log(`  • Opening browser to ${FEISHU_CONSOLE_URL} ...`);
+      const opened = tryOpenInBrowser(FEISHU_CONSOLE_URL);
+      if (!opened) console.log(`  • Open this URL manually: ${FEISHU_CONSOLE_URL}`);
       console.log("  • Click '创建企业自建应用' (Create Enterprise App)");
       console.log("  • Fill in app name and description");
       console.log("");
       console.log("Step 2: Get Credentials");
       console.log("  • In left sidebar → '凭证与基础信息' (Credentials)");
-      console.log("  • Copy App ID and App Secret");
+      console.log("  • Copy App ID and App Secret — you'll paste them below.");
       console.log("");
       console.log("Step 3: Enable Bot");
       console.log("  • In left sidebar → '应用能力' → '机器人' (Bot)");
@@ -2103,12 +2141,14 @@ if (isDaemon) {
       console.log("");
       console.log("Step 5: Add Permissions");
       console.log("  • In left sidebar → '权限管理' (Permissions)");
-      console.log("  • Search and enable these 5 permissions:");
+      console.log("  • Search and enable these 7 permissions:");
       console.log("    → im:message                       (获取与发送单聊、群组消息)");
       console.log("    → im:message.p2p_msg:readonly      (读取用户发给机器人的单聊消息)");
       console.log("    → im:message.group_at_msg:readonly (接收群聊中@机器人消息事件)");
       console.log("    → im:message:send_as_bot           (以应用的身份发消息)");
-      console.log("    → im:resource                      (文件上传下载 - for file transfer)");
+      console.log("    → im:resource                      (文件上传下载 - send-to-user skill)");
+      console.log("    → im:chat                          (创建群聊 - 自动建 agent 群)");
+      console.log("    → im:chat.member                   (邀请用户进群 - 自动建 agent 群)");
       console.log("");
       console.log("Step 6: Publish");
       console.log("  • In left sidebar → '版本管理与发布' (Version Management)");
@@ -2125,7 +2165,47 @@ if (isDaemon) {
           cfg.feishu.app_id = feishuAppId;
           cfg.feishu.app_secret = feishuSecret;
           if (!cfg.feishu.allowed_chat_ids) cfg.feishu.allowed_chat_ids = [];
-          console.log(`  ${icon("ok")} Feishu configured!`);
+
+          // Immediate credential validation — catches "wrong app_secret",
+          // "app not published", "permission missing" etc. up front instead
+          // of after the user has finished setup and tried to send a message.
+          //
+          // CAUTION: feishu-adapter.js triggers a synchronous SDK auto-install
+          // (and process.exit(1) on failure) at module-load time when the
+          // @larksuiteoapi/node-sdk is missing. We MUST avoid that path here:
+          // (a) it would block the wizard for tens of seconds, and (b) an
+          // install failure would kill `metame daemon init` outright,
+          // bypassing our try/catch. Pre-check via require.resolve and skip
+          // validation if the SDK isn't already available — the daemon will
+          // install it lazily on first start and validate then.
+          console.log(`\n  ${icon("info")} Validating credentials with Feishu...`);
+          let sdkResolved = null;
+          try {
+            sdkResolved = require.resolve('@larksuiteoapi/node-sdk');
+          } catch { /* not yet installed */ }
+          if (!sdkResolved) {
+            console.log(`  ${icon("info")} Skipped: Feishu SDK not installed yet (will validate on first daemon start).`);
+          } else {
+            try {
+              const feishuAdapter = require(path.join(__dirname, 'scripts', 'feishu-adapter.js'));
+              const bot = feishuAdapter.createBot({
+                app_id: feishuAppId,
+                app_secret: feishuSecret,
+              });
+              const validation = await bot.validateCredentials();
+              if (validation && validation.ok) {
+                console.log(`  ${icon("ok")} Credentials valid. Feishu configured!`);
+              } else {
+                console.log(`  ${icon("warn")}  Credentials accepted but Feishu rejected the test call:`);
+                console.log(`     ${validation && validation.error ? validation.error : 'unknown error'}`);
+                console.log("     Common causes: app not published yet, wrong app_secret,");
+                console.log("     missing im:message permission. Daemon will still start; fix");
+                console.log("     in the console and re-run `metame restart`.");
+              }
+            } catch (e) {
+              console.log(`  ${icon("warn")}  Validation skipped (${e.message}). Config saved anyway.`);
+            }
+          }
           console.log("  Note: allowed_chat_ids is empty = deny all users.");
           console.log("        Add chat IDs to daemon.yaml or use /agent bind from target chat.\n");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.6.2",
+    "version": "1.6.3",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/agent-intent-shared.js

@@ -68,13 +68,20 @@ function classifyAgentIntent(input) {
   if (hasThirdPartyName && hasAgentWord && !isAboutOurAgents) return null;
 
   const hasAgentContext = /(agent|智能体|工作区|人设|绑定|当前群|这个群|chat|workspace)/i.test(text);
+  // Question-form prefixes ("如何/怎么/能不能/可以吗") indicate the user is
+  // asking ABOUT creating an agent, not requesting one — exclude from create intent.
+  const isQuestion = /^(如何|怎么|怎样|能不能|可不可以|可以吗|是否)/i.test(text) || /(吗\?|吗？|\?$|？$)/.test(text);
   const wantsList = /(列出|查看|显示|有哪些|list|show)/i.test(text) && /(agent|智能体|工作区|绑定)/i.test(text);
   const wantsUnbind = /(解绑|取消绑定|断开绑定|unbind|unassign)/i.test(text) && hasAgentContext;
   const wantsEditRole =
     ((/(角色|职责|人设)/i.test(text) && /(改|修改|调整|更新|变成|改成|改为)/i.test(text)) ||
     /(把这个agent|把当前agent|当前群.*角色|当前群.*职责)/i.test(text));
+  // Relaxed: a bare "新建 agent" with no path is enough — daemon will derive
+  // a default workspace at ~/AGI/<name>/ if no path is given.
   const wantsCreate =
-    (/(创建|新建|新增|搞一个|加一个|create)/i.test(text) && /(agent|智能体|人设|工作区)/i.test(text) && (directAction || hasWorkspacePath));
+    /(创建|新建|新增|搞一个|加一个|create)/i.test(text)
+    && /(agent|智能体|人设|工作区)/i.test(text)
+    && !isQuestion;
   const wantsBind =
     !wantsCreate &&
     (/(绑定|bind)/i.test(text) && hasAgentContext && (directAction || hasWorkspacePath));
@@ -89,10 +96,12 @@ function classifyAgentIntent(input) {
     /(?:怎么|如何|手册|文档|说明).{0,12}(配置|管理|使用).{0,12}(agent|智能体|机器人|bot)/i.test(text) ||
     /(?:agent|智能体|机器人|bot).{0,12}(怎么|如何).{0,12}(配置|管理|使用)/i.test(text);
 
+  // wantsCreate is checked BEFORE wantsList so that "新建 agent 用于查看 X"
+  // (which contains both 新建 and 查看) is correctly routed to create.
+  if (wantsCreate) return { action: 'create', workspaceDir };
   if (wantsList) return { action: 'list', workspaceDir };
   if (wantsUnbind) return { action: 'unbind', workspaceDir };
   if (wantsEditRole) return { action: 'edit_role', workspaceDir };
-  if (wantsCreate) return { action: 'create', workspaceDir };
   if (wantsBind) return { action: 'bind', workspaceDir };
   if (wantsAgentDoc) return { action: 'agent_doc', workspaceDir };
   if (wantsActivate) return { action: 'activate', workspaceDir };

package/scripts/core/session-source-db.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const VALID_ENGINES = new Set(['claude', 'codex', 'unknown']);
+const VALID_STATUSES = new Set(['indexed', 'summarized', 'extracted', 'error', 'archived']);
+
+function normalizeEngine(engine) {
+  const value = String(engine || 'unknown').trim().toLowerCase();
+  return VALID_ENGINES.has(value) ? value : 'unknown';
+}
+
+function normalizeStatus(status) {
+  const value = String(status || 'indexed').trim().toLowerCase();
+  return VALID_STATUSES.has(value) ? value : 'indexed';
+}
+
+function stableId({ engine, sessionId, sourceHash }) {
+  const seed = `${normalizeEngine(engine)}:${String(sessionId || '').trim()}:${String(sourceHash || '').trim()}`;
+  return `ss_${crypto.createHash('sha256').update(seed).digest('hex').slice(0, 24)}`;
+}
+
+function requireSessionSource(source) {
+  if (!source || typeof source !== 'object') throw new Error('session source is required');
+  const sessionId = String(source.sessionId || source.session_id || '').trim();
+  if (!sessionId) throw new Error('session source requires sessionId');
+  const sourceHash = String(source.sourceHash || source.source_hash || '').trim();
+  if (!sourceHash) throw new Error('session source requires sourceHash');
+  return { sessionId, sourceHash };
+}
+
+function upsertSessionSource(db, source) {
+  const { sessionId, sourceHash } = requireSessionSource(source);
+  const engine = normalizeEngine(source.engine);
+  const id = stableId({ engine, sessionId, sourceHash });
+  const status = normalizeStatus(source.status);
+
+  db.prepare(`
+    INSERT INTO session_sources (
+      id, engine, session_id, project, scope, agent_key, cwd,
+      source_path, source_hash, source_size, first_ts, last_ts,
+      message_count, tool_call_count, tool_error_count,
+      status, error_message, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    ON CONFLICT(engine, session_id, source_hash) DO UPDATE SET
+      project=excluded.project,
+      scope=excluded.scope,
+      agent_key=excluded.agent_key,
+      cwd=excluded.cwd,
+      source_path=excluded.source_path,
+      source_size=excluded.source_size,
+      first_ts=excluded.first_ts,
+      last_ts=excluded.last_ts,
+      message_count=excluded.message_count,
+      tool_call_count=excluded.tool_call_count,
+      tool_error_count=excluded.tool_error_count,
+      status=excluded.status,
+      error_message=excluded.error_message,
+      updated_at=datetime('now')
+  `).run(
+    id,
+    engine,
+    sessionId,
+    source.project || '*',
+    source.scope || null,
+    source.agentKey || source.agent_key || null,
+    source.cwd || null,
+    source.sourcePath || source.source_path || null,
+    sourceHash,
+    Number(source.sourceSize || source.source_size || 0) || 0,
+    source.firstTs || source.first_ts || null,
+    source.lastTs || source.last_ts || null,
+    Number(source.messageCount || source.message_count || 0) || 0,
+    Number(source.toolCallCount || source.tool_call_count || 0) || 0,
+    Number(source.toolErrorCount || source.tool_error_count || 0) || 0,
+    status,
+    source.errorMessage || source.error_message || null,
+  );
+
+  return { ok: true, id };
+}
+
+function getSessionSource(db, { engine = 'unknown', sessionId, sourceHash }) {
+  if (!sessionId || !sourceHash) return null;
+  return db.prepare(`
+    SELECT * FROM session_sources
+    WHERE engine = ? AND session_id = ? AND source_hash = ?
+    LIMIT 1
+  `).get(normalizeEngine(engine), String(sessionId), String(sourceHash)) || null;
+}
+
+function findSessionSources(db, { project = null, scope = null, engine = null, limit = 20 } = {}) {
+  const clauses = [];
+  const params = [];
+  if (project) { clauses.push('(project = ? OR project = ?)'); params.push(project, '*'); }
+  if (scope) { clauses.push('(scope = ? OR scope IS NULL)'); params.push(scope); }
+  if (engine) { clauses.push('engine = ?'); params.push(normalizeEngine(engine)); }
+  const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
+  return db.prepare(`
+    SELECT * FROM session_sources
+    ${where}
+    ORDER BY COALESCE(last_ts, updated_at, created_at) DESC
+    LIMIT ?
+  `).all(...params, Number(limit) || 20);
+}
+
+function markSessionSourceStatus(db, id, status, errorMessage = null) {
+  if (!id) return { ok: false, changed: 0 };
+  const normalized = normalizeStatus(status);
+  const result = db.prepare(`
+    UPDATE session_sources
+    SET status = ?, error_message = ?, updated_at = datetime('now')
+    WHERE id = ?
+  `).run(normalized, errorMessage || null, id);
+  return { ok: true, changed: result.changes || 0 };
+}
+
+module.exports = {
+  upsertSessionSource,
+  getSessionSource,
+  findSessionSources,
+  markSessionSourceStatus,
+  _internal: { normalizeEngine, normalizeStatus, stableId },
+};

package/scripts/daemon-agent-intent.js

@@ -88,7 +88,7 @@ function createAgentIntentHandler(deps) {
       backupConfig,
     } = deps;
 
-  return async function handleAgentIntent(bot, chatId, text, config) {
+  return async function handleAgentIntent(bot, chatId, text, config, senderId = null) {
     if (!agentTools || !text || text.startsWith('/')) return false;
     const key = String(chatId);
     if (hasFreshPendingFlow(key) || hasFreshPendingFlow(key + ':edit')) return false;
@@ -188,15 +188,6 @@ function createAgentIntentHandler(deps) {
     }
 
     if (intent.action === 'create') {
-      if (!intent.workspaceDir) {
-        await bot.sendMessage(chatId, [
-          '我可以帮你创建 Agent，还差一个工作目录。',
-          '例如：`给这个群创建一个 Agent，目录是 ~/projects/foo`',
-          'Windows 也可以直接发：`C:\\\\work\\\\foo`',
-          '也可以直接回我一个路径（`~/`、`/`、`./`、`../`、`C:\\\\` 开头都行）。',
-        ].join('\n'));
-        return true;
-      }
       const agentName = deriveAgentName(input, intent.workspaceDir);
       const roleDelta = deriveCreateRoleDelta(input);
       const inferredEngine = inferAgentEngineFromText(input);
@@ -204,7 +195,7 @@ function createAgentIntentHandler(deps) {
         agentTools,
         chatId,
         agentName,
-        workspaceDir: intent.workspaceDir,
+        workspaceDir: intent.workspaceDir, // empty string OK — agent-tools derives ~/AGI/<name>/
         roleDescription: roleDelta,
         pendingActivations,
         skipChatBinding: true,
@@ -212,6 +203,8 @@ function createAgentIntentHandler(deps) {
         attachOrCreateSession,
         normalizeCwd,
         getDefaultEngine,
+        bot,                  // for optional auto-create-chat
+        senderOpenId: senderId,
       });
       if (!res.ok) {
         await bot.sendMessage(chatId, `❌ 创建 Agent 失败: ${res.error}`);
@@ -220,10 +213,53 @@ function createAgentIntentHandler(deps) {
       const data = res.data || {};
       const projName = projectNameFromResult(data, agentName);
       const engineTip = data.project && data.project.engine ? `\n引擎: ${data.project.engine}` : '';
-      await bot.sendMessage(chatId,
-        `✅ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}\n\n` +
-        `**下一步**: 在新群里发送 \`/activate\` 完成绑定（30分钟内有效）`
-      );
+      // If createWorkspaceAgent auto-created a Feishu chat and bound it, the
+      // bot has already messaged the new chat — just confirm in the source chat.
+      if (data.autoChat && data.autoChat.chatId && !data.autoChat.error) {
+        await bot.sendMessage(chatId,
+          `✅ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}\n\n` +
+          `已自动建好飞书群「${data.autoChat.name}」并把你拉进群里——直接打开新群和它对话即可。`
+        );
+      } else if (data.autoChat && data.autoChat.chatId && data.autoChat.error) {
+        // Chat was created but binding failed mid-way — give the user a clear
+        // recovery path so they don't end up with an orphan group.
+        await bot.sendMessage(chatId,
+          `⚠️ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}\n\n` +
+          `飞书群「${data.autoChat.name}」也已建好，但自动绑定失败:${data.autoChat.error}\n\n` +
+          `**手动恢复**: 在新群里发送 \`/activate\` 即可补绑（30分钟内有效）；\n` +
+          `或在任意群发 \`/agent bind ${projName} ${data.cwd || ''}\` 直接指定绑定。`
+        );
+      } else {
+        // Existing-user upgrade path: the most common failure here is missing
+        // im:chat / im:chat.member permissions on the user's Feishu app
+        // (older installs predate Fix 1's expanded permission list). Detect
+        // that case and tell the user exactly what to fix, instead of
+        // burying it in a generic "自动建群失败" line.
+        const autoErr = (data.autoChat && data.autoChat.error) || '';
+        const autoCode = data.autoChat && data.autoChat.code;
+        const isPermissionError = autoCode === 99991663
+          || /im:chat|权限|permission|forbidden|scope/i.test(autoErr);
+        if (isPermissionError) {
+          await bot.sendMessage(chatId,
+            `⚠️ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}\n\n` +
+            `自动建群失败:飞书应用缺少 \`im:chat\` 或 \`im:chat.member\` 权限。\n\n` +
+            `**修复方法**(2 分钟):\n` +
+            `1. 打开 https://open.feishu.cn/app 找到这个应用\n` +
+            `2. 左侧「权限管理」搜索并开通这两个权限:\n` +
+            `   • \`im:chat\`(创建群聊)\n` +
+            `   • \`im:chat.member\`(邀请用户进群)\n` +
+            `3. 左侧「版本管理与发布」→ 创建新版本 → 申请发布\n` +
+            `4. 回这里再说一次「新建 agent ${projName}」即可\n\n` +
+            `也可以**手动**:在飞书新建群,把 bot 拉进去,发送 \`/activate\`(30 分钟内有效)。`
+          );
+        } else {
+          const fallbackHint = autoErr ? `\n（自动建群失败:${autoErr}）` : '';
+          await bot.sendMessage(chatId,
+            `✅ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}${fallbackHint}\n\n` +
+            `**下一步**: 在新群里发送 \`/activate\` 完成绑定（30分钟内有效）`
+          );
+        }
+      }
       return true;
     }
 

package/scripts/daemon-agent-tools.js

@@ -33,6 +33,24 @@ function createAgentTools(deps) {
     return normalizeCwd ? normalizeCwd(expanded) : path.resolve(expanded);
   }
 
+  // Derive a default workspace path "~/AGI/<safeName>" when the user names the
+  // agent but skips the path. The directory is created on demand so the rest
+  // of the pipeline (CLAUDE.md write, daemon.yaml entry) can proceed without
+  // forcing the user to mkdir manually.
+  function deriveDefaultWorkspaceDir(safeName) {
+    const cleanName = String(safeName || '').replace(/[\\/:*?"<>|]/g, '').trim();
+    if (!cleanName) return null;
+    return path.join(HOME, 'AGI', cleanName);
+  }
+
+  function ensureWorkspaceDir(dir) {
+    if (!dir) return false;
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+    } catch { return false; }
+  }
+
   function getAdapterKey(chatId) {
     return typeof chatId === 'number' ? 'telegram' : 'feishu';
   }
@@ -87,11 +105,27 @@ function createAgentTools(deps) {
         const existing = cfg.projects[projectKey];
         if (existing && existing.cwd) resolvedDir = resolveWorkspaceDir(existing.cwd);
       }
+      // No path supplied and no prior project → derive ~/AGI/<safeName>/.
+      if (!resolvedDir) {
+        const defaultDir = deriveDefaultWorkspaceDir(safeName);
+        if (defaultDir && ensureWorkspaceDir(defaultDir)) {
+          resolvedDir = resolveWorkspaceDir(defaultDir);
+        }
+      }
       if (!resolvedDir) {
         return { ok: false, error: 'workspaceDir is required for a new agent' };
       }
+      // If the resolved path doesn't exist yet but is the derived default,
+      // mkdir on the spot. Stay strict for user-supplied paths so typos don't
+      // silently spawn directories in the wrong place.
       if (!fs.existsSync(resolvedDir)) {
-        return { ok: false, error: `workspaceDir not found: ${resolvedDir}` };
+        const defaultDir = deriveDefaultWorkspaceDir(safeName);
+        const isDefault = defaultDir && resolveWorkspaceDir(defaultDir) === resolvedDir;
+        if (isDefault && ensureWorkspaceDir(resolvedDir)) {
+          // ok — created it
+        } else {
+          return { ok: false, error: `workspaceDir not found: ${resolvedDir}` };
+        }
       }
       if (!fs.statSync(resolvedDir).isDirectory()) {
         return { ok: false, error: `workspaceDir is not a directory: ${resolvedDir}` };
@@ -236,9 +270,24 @@ ${safeDelta}
       // Create the project entry without touching chat_agent_map
       const safeName = sanitizeText(agentName, 120);
       if (!safeName) return { ok: false, error: 'agentName is required' };
-      const resolvedDir = resolveWorkspaceDir(workspaceDir);
+      let resolvedDir = resolveWorkspaceDir(workspaceDir);
+      // Same default-derivation rule as bindAgentToChat: when the user names
+      // the agent but doesn't pin a path, anchor it under ~/AGI/<safeName>/.
+      if (!resolvedDir) {
+        const defaultDir = deriveDefaultWorkspaceDir(safeName);
+        if (defaultDir && ensureWorkspaceDir(defaultDir)) {
+          resolvedDir = resolveWorkspaceDir(defaultDir);
+        }
+      }
       if (!resolvedDir) return { ok: false, error: 'workspaceDir is required' };
-      if (!fs.existsSync(resolvedDir) || !fs.statSync(resolvedDir).isDirectory()) {
+      if (!fs.existsSync(resolvedDir)) {
+        const defaultDir = deriveDefaultWorkspaceDir(safeName);
+        const isDefault = defaultDir && resolveWorkspaceDir(defaultDir) === resolvedDir;
+        if (!(isDefault && ensureWorkspaceDir(resolvedDir))) {
+          return { ok: false, error: `workspaceDir not found or not a directory: ${resolvedDir}` };
+        }
+      }
+      if (!fs.statSync(resolvedDir).isDirectory()) {
         return { ok: false, error: `workspaceDir not found or not a directory: ${resolvedDir}` };
       }
       const cfg = loadConfig();

package/scripts/daemon-agent-workflow.js

@@ -181,6 +181,11 @@ async function createWorkspaceAgent({
   normalizeCwd,
   getDefaultEngine,
   legacyCreate,
+  // Optional: enable auto-create-chat when set. Requires the bot to expose
+  // createChat (currently only feishu-adapter) and a senderOpenId so the
+  // human creator can be invited into the new chat.
+  bot = null,
+  senderOpenId = null,
 }) {
   let res;
   if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
@@ -198,6 +203,99 @@ async function createWorkspaceAgent({
 
   const data = res.data || {};
   if (skipChatBinding) {
+    // Try the one-shot path: create a Feishu chat for this agent right now,
+    // invite the human creator, and bind chat→agent so /activate is unneeded.
+    // Pre-conditions: caller provided a bot with createChat, a senderOpenId
+    // that looks like Feishu open_id, and bindAgentToChat is wired up.
+    const canAutoCreate = bot
+      && typeof bot.createChat === 'function'
+      && typeof senderOpenId === 'string' && senderOpenId.startsWith('ou_')
+      && agentTools && typeof agentTools.bindAgentToChat === 'function';
+
+    if (canAutoCreate) {
+      const projName = (data.project && data.project.name) || agentName || data.projectKey;
+      const chatName = `MetaMe · ${projName}`;
+      const createRes = await bot.createChat({
+        name: chatName,
+        description: `Agent ${projName} — auto-created`,
+        ownerOpenId: senderOpenId,
+        inviteOpenIds: [senderOpenId],
+      });
+      if (createRes.ok && createRes.chatId) {
+        const newChatId = createRes.chatId;
+        const bindRes = await agentTools.bindAgentToChat(newChatId, projName, data.cwd, { engine });
+        if (bindRes.ok) {
+          // Skip /activate — directly attach the session in the new chat.
+          attachBoundSession({
+            attachOrCreateSession,
+            projectKey: data.projectKey,
+            chatId: newChatId,
+            cwd: data.cwd,
+            name: projName,
+            engine: data.project && data.project.engine,
+            normalizeCwd,
+            getDefaultEngine,
+          });
+          // Greeting in the freshly created chat so the user sees the bot is alive.
+          try {
+            await bot.sendMessage(newChatId, `🤖 ${projName} 已上线。直接说话即可，本群已绑定到 \`${data.projectKey}\`。`);
+          } catch { /* non-fatal */ }
+          return {
+            ok: true,
+            data: { ...data, autoChat: { chatId: newChatId, name: chatName } },
+          };
+        }
+        // Bind failed AFTER chat was created — keep enough info for recovery.
+        // Surface chatId/name so the user knows which chat exists, and write
+        // pendingActivations so /activate from inside that new chat works.
+        if (data.projectKey && pendingActivations) {
+          pendingActivations.set(data.projectKey, {
+            agentKey: data.projectKey,
+            agentName: projName,
+            cwd: data.cwd,
+            createdByChatId: String(chatId),
+            createdAt: Date.now(),
+            // Hint for downstream: the chat already exists, /activate from it.
+            preCreatedChatId: newChatId,
+            preCreatedChatName: chatName,
+          });
+        }
+        return {
+          ok: true,
+          data: {
+            ...data,
+            autoChat: {
+              chatId: newChatId,
+              name: chatName,
+              error: `bind failed: ${bindRes.error}`,
+              recoverable: true,
+            },
+          },
+        };
+      }
+      // createChat failed — fall through to /activate path with diagnostic.
+      const errSummary = createRes.error || 'unknown';
+      // Forward the underlying error code (e.g. 99991663 = permission denied)
+      // so the caller can give a targeted upgrade hint instead of a generic
+      // "auto-create failed" message.
+      const errCode = createRes.code || null;
+      // Still register pendingActivations so user can /activate manually.
+      if (data.projectKey && pendingActivations) {
+        pendingActivations.set(data.projectKey, {
+          agentKey: data.projectKey,
+          agentName: projName,
+          cwd: data.cwd,
+          createdByChatId: String(chatId),
+          createdAt: Date.now(),
+        });
+      }
+      return {
+        ok: true,
+        data: { ...data, autoChat: { error: errSummary, code: errCode } },
+      };
+    }
+
+    // No auto-create — original /activate flow.
     if (data.projectKey && pendingActivations) {
       pendingActivations.set(data.projectKey, {
         agentKey: data.projectKey,

package/scripts/daemon-bridges.js

@@ -49,7 +49,7 @@ function createBridgeStarter(deps) {
     return text || null;
   }
 
-  async function applyUserAcl({ bot, chatId, text, config, senderId, bypassAcl }) {
+  async function applyUserAcl({ bot, chatId, text, config, senderId, bypassAcl, fromAllowedChat }) {
     const trimmed = String(text || '').trim();
     const normalizedSenderId = normalizeSenderId(senderId);
     if (!trimmed || bypassAcl || !userAcl) {
@@ -58,10 +58,15 @@ function createBridgeStarter(deps) {
 
     let userCtx;
     try {
-      userCtx = userAcl.resolveUserCtx(normalizedSenderId, config || {});
+      userCtx = userAcl.resolveUserCtx(normalizedSenderId, config || {}, { fromAllowedChat: !!fromAllowedChat });
     } catch {
       return { blocked: false, readOnly: false, senderId: normalizedSenderId };
     }
+    // Audit trail for implicit-admin upgrades — these users are NOT in users.yaml
+    // and gain admin via group-whitelist trust, so make their action visible.
+    if (userCtx && userCtx.implicitAdmin) {
+      try { log('INFO', `[ACL] implicit admin via allowed_chat_ids: chat=${chatId} sender=${normalizedSenderId}`); } catch { /* non-fatal */ }
+    }
 
     const userCmd = userAcl.handleUserCommand(trimmed, userCtx);
     if (userCmd && userCmd.handled) {
@@ -803,6 +808,7 @@ function createBridgeStarter(deps) {
             config: liveCfg,
             senderId,
             bypassAcl: !isAllowedChat && !!isBindCmd,
+            fromAllowedChat: isAllowedChat,
           });
           if (acl.blocked) return;
           log('INFO', `Feishu file from ${chatId}: ${fileInfo.fileName} (key: ${fileInfo.fileKey}, msgId: ${fileInfo.messageId}, type: ${fileInfo.msgType})`);
@@ -850,6 +856,7 @@ function createBridgeStarter(deps) {
             config: liveCfg,
             senderId,
             bypassAcl: !isAllowedChat && !!isBindCmd,
+            fromAllowedChat: isAllowedChat,
           });
           if (acl.blocked) return;
           log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);

package/scripts/daemon-command-router.js

@@ -593,7 +593,7 @@ function createCommandRouter(deps) {
         return;
       }
 
-      if (await tryHandleAgentIntent(bot, chatId, text, config)) {
+      if (await tryHandleAgentIntent(bot, chatId, text, config, senderId)) {
         return;
       }
     }