chainlesschain 0.41.1 → 0.42.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.41.1",
+  "version": "0.42.2",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/init.js

@@ -63,6 +63,93 @@ const TEMPLATES = {
 `,
     skills: ["debug", "summarize", "code-review"],
   },
+  "medical-triage": {
+    description:
+      "Medical triage assistant with symptom assessment and ESI classification",
+    rules: `# Project Rules
+
+## Medical Guidelines
+- Always ask for patient symptoms before providing guidance
+- Use standard ESI (Emergency Severity Index) levels 1-5
+- Never provide definitive diagnoses — recommend professional evaluation
+- Document all triage decisions with reasoning
+
+## AI Assistant Guidelines
+- Prioritize patient safety in all responses
+- Use clear, non-technical language when possible
+- Flag emergency symptoms immediately
+`,
+    skills: ["summarize"],
+    persona: {
+      name: "智能分诊助手",
+      role: "你是一个医疗分诊AI助手，帮助诊所工作人员根据症状和紧急��度对患者进行优先级分类。",
+      behaviors: [
+        "始终先询问患者症状再给出建议",
+        "使用标准分诊分类 (ESI 1-5)",
+        "绝不提供确定性诊断，建议专业评估",
+        "记录所有分诊决策及其理由",
+      ],
+      toolsPriority: ["read_file", "search_files"],
+      toolsDisabled: [],
+    },
+  },
+  "agriculture-expert": {
+    description:
+      "Agriculture expert assistant for crop management and farming advice",
+    rules: `# Project Rules
+
+## Agriculture Guidelines
+- Consider local climate and soil conditions
+- Recommend sustainable farming practices
+- Provide seasonal planting calendars when relevant
+- Reference pest management best practices
+
+## AI Assistant Guidelines
+- Ask about specific crops and region before advising
+- Use data-driven recommendations when possible
+- Warn about pesticide safety and environmental impact
+`,
+    skills: ["summarize"],
+    persona: {
+      name: "农业专家助手",
+      role: "你是一个农业技术AI助手，帮助农户进行作物管理、病虫害防治和产量优化。",
+      behaviors: [
+        "根据当地气候和土壤条件提供建议",
+        "推荐可持续的农业实践方法",
+        "提供季节性种植日历和管理建议",
+        "使用数据驱动的决策支持",
+      ],
+      toolsPriority: ["read_file", "search_files", "run_code"],
+      toolsDisabled: [],
+    },
+  },
+  "general-assistant": {
+    description: "General-purpose assistant without coding bias",
+    rules: `# Project Rules
+
+## General Guidelines
+- Focus on the user's domain and questions
+- Provide clear, well-structured responses
+- Use tools to manage files and information as needed
+
+## AI Assistant Guidelines
+- Adapt your communication style to the user's needs
+- Ask clarifying questions when requirements are ambiguous
+- Organize information in a logical, easy-to-follow manner
+`,
+    skills: ["summarize"],
+    persona: {
+      name: "通用AI助手",
+      role: "你是一个通用AI助手，根据用户的具体需求和项目上下文提供帮助。你不局限于编码任务，而是全面地协助用户完成各种工作。",
+      behaviors: [
+        "根据用户的领域调整回答风格",
+        "在需求不明确时主动询问",
+        "用清晰、结构化的方式组织信息",
+      ],
+      toolsPriority: ["read_file", "write_file", "search_files"],
+      toolsDisabled: [],
+    },
+  },
   empty: {
     description: "Bare project with minimal configuration",
     rules: `# Project Rules
@@ -82,7 +169,7 @@ export function registerInitCommand(program) {
     )
     .option(
       "-t, --template <name>",
-      "Project template (code-project, data-science, devops, empty)",
+      "Project template (code-project, data-science, devops, medical-triage, agriculture-expert, general-assistant, empty)",
       "empty",
     )
     .option("-y, --yes", "Skip prompts, use defaults")
@@ -147,6 +234,9 @@ export function registerInitCommand(program) {
             workspace: "./skills",
           },
         };
+        if (tmpl.persona) {
+          config.persona = tmpl.persona;
+        }
         fs.writeFileSync(
           path.join(ccDir, "config.json"),
           JSON.stringify(config, null, 2),
@@ -156,6 +246,36 @@ export function registerInitCommand(program) {
         // rules.md
         fs.writeFileSync(path.join(ccDir, "rules.md"), tmpl.rules, "utf-8");
 
+        // Create auto-activated persona skill if template has persona
+        if (tmpl.persona) {
+          const personaSkillDir = path.join(
+            ccDir,
+            "skills",
+            `${template}-persona`,
+          );
+          fs.mkdirSync(personaSkillDir, { recursive: true });
+          const skillMd = `---
+name: ${template}-persona
+display-name: ${tmpl.persona.name || template} Persona
+category: persona
+activation: auto
+user-invocable: false
+description: Auto-activated persona for ${template} projects
+---
+
+# ${tmpl.persona.name || template}
+
+${tmpl.persona.role || ""}
+
+${tmpl.persona.behaviors?.map((b) => `- ${b}`).join("\n") || ""}
+`;
+          fs.writeFileSync(
+            path.join(personaSkillDir, "SKILL.md"),
+            skillMd,
+            "utf-8",
+          );
+        }
+
         logger.success(
           `Initialized ChainlessChain project in ${chalk.cyan(cwd)}`,
         );

package/src/commands/persona.js

@@ -0,0 +1,178 @@
+/**
+ * Persona management command
+ * chainlesschain persona [show|set|reset]
+ *
+ * Manage project-level AI persona configuration.
+ */
+
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { logger } from "../lib/logger.js";
+import { findProjectRoot, loadProjectConfig } from "../lib/project-detector.js";
+
+export function registerPersonaCommand(program) {
+  const persona = program
+    .command("persona")
+    .description("Manage project AI persona configuration");
+
+  // persona show
+  persona
+    .command("show")
+    .description("Show the current project persona")
+    .action(() => {
+      const projectRoot = findProjectRoot(process.cwd());
+      if (!projectRoot) {
+        logger.error(
+          "Not inside a ChainlessChain project. Run `chainlesschain init` first.",
+        );
+        process.exit(1);
+      }
+
+      const config = loadProjectConfig(projectRoot);
+      if (!config?.persona) {
+        logger.log("No persona configured. Using default coding assistant.");
+        logger.log(
+          `\nSet one with: ${chalk.cyan('chainlesschain persona set --name "My Assistant" --role "Your role description"')}`,
+        );
+        return;
+      }
+
+      const p = config.persona;
+      logger.log(chalk.bold("Current Persona:"));
+      logger.log(`  Name: ${chalk.cyan(p.name || "(unnamed)")}`);
+      logger.log(`  Role: ${p.role || "(no role defined)"}`);
+      if (p.behaviors?.length > 0) {
+        logger.log("  Behaviors:");
+        for (const b of p.behaviors) {
+          logger.log(`    - ${b}`);
+        }
+      }
+      if (p.toolsPriority?.length > 0) {
+        logger.log(
+          `  Preferred tools: ${chalk.gray(p.toolsPriority.join(", "))}`,
+        );
+      }
+      if (p.toolsDisabled?.length > 0) {
+        logger.log(
+          `  Disabled tools: ${chalk.red(p.toolsDisabled.join(", "))}`,
+        );
+      }
+    });
+
+  // persona set
+  persona
+    .command("set")
+    .description("Set or update the project persona")
+    .option("-n, --name <name>", "Persona display name")
+    .option("-r, --role <role>", "Role description (system prompt override)")
+    .option(
+      "-b, --behavior <behavior>",
+      "Add a behavior guideline (repeatable)",
+      collectValues,
+      [],
+    )
+    .option(
+      "--tools-priority <tools>",
+      "Comma-separated list of preferred tools",
+    )
+    .option(
+      "--tools-disabled <tools>",
+      "Comma-separated list of disabled tools",
+    )
+    .action((options) => {
+      const projectRoot = findProjectRoot(process.cwd());
+      if (!projectRoot) {
+        logger.error(
+          "Not inside a ChainlessChain project. Run `chainlesschain init` first.",
+        );
+        process.exit(1);
+      }
+
+      const configPath = path.join(
+        projectRoot,
+        ".chainlesschain",
+        "config.json",
+      );
+      let config;
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      } catch {
+        logger.error("Failed to read config.json");
+        process.exit(1);
+      }
+
+      const existing = config.persona || {};
+      const updated = { ...existing };
+
+      if (options.name) updated.name = options.name;
+      if (options.role) updated.role = options.role;
+      if (options.behavior?.length > 0) {
+        updated.behaviors = [
+          ...(existing.behaviors || []),
+          ...options.behavior,
+        ];
+      }
+      if (options.toolsPriority) {
+        updated.toolsPriority = options.toolsPriority
+          .split(",")
+          .map((s) => s.trim());
+      }
+      if (options.toolsDisabled) {
+        updated.toolsDisabled = options.toolsDisabled
+          .split(",")
+          .map((s) => s.trim());
+      }
+
+      config.persona = updated;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+
+      logger.success("Persona updated.");
+      logger.log(`  Name: ${chalk.cyan(updated.name || "(unnamed)")}`);
+      logger.log(`  Role: ${updated.role || "(no role defined)"}`);
+    });
+
+  // persona reset
+  persona
+    .command("reset")
+    .description(
+      "Remove the project persona, restoring the default coding assistant",
+    )
+    .action(() => {
+      const projectRoot = findProjectRoot(process.cwd());
+      if (!projectRoot) {
+        logger.error(
+          "Not inside a ChainlessChain project. Run `chainlesschain init` first.",
+        );
+        process.exit(1);
+      }
+
+      const configPath = path.join(
+        projectRoot,
+        ".chainlesschain",
+        "config.json",
+      );
+      let config;
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      } catch {
+        logger.error("Failed to read config.json");
+        process.exit(1);
+      }
+
+      if (!config.persona) {
+        logger.log("No persona configured. Nothing to reset.");
+        return;
+      }
+
+      delete config.persona;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      logger.success(
+        "Persona removed. The default coding assistant will be used.",
+      );
+    });
+}
+
+function collectValues(value, previous) {
+  return previous.concat([value]);
+}

package/src/commands/setup.js

@@ -104,9 +104,15 @@ async function runSetup(options) {
     apiKey = await askPassword(`Enter ${providerInfo.name} API key:`);
   }
 
-  if (provider === "custom") {
-    baseUrl = await askInput("Enter API base URL:");
-    model = await askInput("Enter model name:");
+  if (provider === "custom" || providerInfo.isProxy) {
+    baseUrl = await askInput(
+      "Enter API base URL:",
+      providerInfo.defaultBaseUrl || "",
+    );
+    model = await askInput(
+      "Enter model name:",
+      providerInfo.defaultModel || "",
+    );
   } else {
     const customizeModel = await askConfirm(
       `Use default model (${model})?`,

package/src/commands/update.js

@@ -1,10 +1,31 @@
 import chalk from "chalk";
+import { execSync } from "node:child_process";
 import { checkForUpdates } from "../lib/version-checker.js";
 import { downloadRelease } from "../lib/downloader.js";
 import { VERSION } from "../constants.js";
 import { askConfirm } from "../lib/prompts.js";
 import logger from "../lib/logger.js";
 
+async function selfUpdateCli(targetVersion) {
+  if (VERSION === targetVersion) {
+    return; // Already at the target version
+  }
+
+  try {
+    logger.info("Updating CLI package...");
+    execSync(`npm install -g chainlesschain@${targetVersion}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+    logger.success(`CLI updated to v${targetVersion}`);
+  } catch (_err) {
+    // npm global install may fail due to permissions; guide the user
+    logger.warn(
+      `CLI self-update failed. Please run manually:\n  npm install -g chainlesschain@${targetVersion}`,
+    );
+  }
+}
+
 export function registerUpdateCommand(program) {
   program
     .command("update")
@@ -64,6 +85,10 @@ export function registerUpdateCommand(program) {
         }
 
         await downloadRelease(result.latestVersion, { force: options.force });
+
+        // Self-update the CLI npm package
+        await selfUpdateCli(result.latestVersion);
+
         logger.success(`Updated to v${result.latestVersion}`);
         logger.info("Restart ChainlessChain to use the new version.");
       } catch (err) {

package/src/constants.js

@@ -27,11 +27,11 @@ export const DEFAULT_PORTS = {
 };
 
 export const LLM_PROVIDERS = {
-  ollama: {
-    name: "Ollama (Local)",
-    defaultBaseUrl: "http://localhost:11434",
-    defaultModel: "qwen2:7b",
-    requiresApiKey: false,
+  volcengine: {
+    name: "Volcengine (火山引擎/豆包)",
+    defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+    defaultModel: "doubao-seed-1-6-251015",
+    requiresApiKey: true,
   },
   openai: {
     name: "OpenAI",
@@ -39,10 +39,10 @@ export const LLM_PROVIDERS = {
     defaultModel: "gpt-4o",
     requiresApiKey: true,
   },
-  dashscope: {
-    name: "DashScope (Alibaba)",
-    defaultBaseUrl: "https://dashscope.aliyuncs.com/api/v1",
-    defaultModel: "qwen-max",
+  anthropic: {
+    name: "Anthropic (Claude)",
+    defaultBaseUrl: "https://api.anthropic.com/v1",
+    defaultModel: "claude-sonnet-4-6",
     requiresApiKey: true,
   },
   deepseek: {
@@ -51,8 +51,65 @@ export const LLM_PROVIDERS = {
     defaultModel: "deepseek-chat",
     requiresApiKey: true,
   },
+  dashscope: {
+    name: "DashScope (阿里通义)",
+    defaultBaseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    defaultModel: "qwen-max",
+    requiresApiKey: true,
+  },
+  gemini: {
+    name: "Google Gemini",
+    defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    defaultModel: "gemini-2.0-flash",
+    requiresApiKey: true,
+  },
+  kimi: {
+    name: "Kimi (月之暗面)",
+    defaultBaseUrl: "https://api.moonshot.cn/v1",
+    defaultModel: "moonshot-v1-auto",
+    requiresApiKey: true,
+  },
+  minimax: {
+    name: "MiniMax (海螺AI)",
+    defaultBaseUrl: "https://api.minimax.chat/v1",
+    defaultModel: "MiniMax-Text-01",
+    requiresApiKey: true,
+  },
+  mistral: {
+    name: "Mistral AI",
+    defaultBaseUrl: "https://api.mistral.ai/v1",
+    defaultModel: "mistral-large-latest",
+    requiresApiKey: true,
+  },
+  ollama: {
+    name: "Ollama (本地部署)",
+    defaultBaseUrl: "http://localhost:11434",
+    defaultModel: "qwen2:7b",
+    requiresApiKey: false,
+  },
+  "openai-proxy": {
+    name: "OpenAI 中转站 (API2D/CloseAI等)",
+    defaultBaseUrl: "",
+    defaultModel: "gpt-4o",
+    requiresApiKey: true,
+    isProxy: true,
+  },
+  "anthropic-proxy": {
+    name: "Anthropic 中转站 (Claude代理)",
+    defaultBaseUrl: "",
+    defaultModel: "claude-sonnet-4-6",
+    requiresApiKey: true,
+    isProxy: true,
+  },
+  "gemini-proxy": {
+    name: "Gemini 中转站 (Google代理)",
+    defaultBaseUrl: "",
+    defaultModel: "gemini-2.0-flash",
+    requiresApiKey: true,
+    isProxy: true,
+  },
   custom: {
-    name: "Custom Provider",
+    name: "自定义 Provider (自建服务/vLLM/TGI等)",
     defaultBaseUrl: "",
     defaultModel: "",
     requiresApiKey: true,
@@ -83,10 +140,10 @@ export const DEFAULT_CONFIG = {
     database: null,
   },
   llm: {
-    provider: "ollama",
+    provider: "volcengine",
     apiKey: null,
-    baseUrl: "http://localhost:11434",
-    model: "qwen2:7b",
+    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+    model: "doubao-seed-1-6-251015",
   },
   enterprise: {
     serverUrl: null,

package/src/index.js

@@ -35,6 +35,7 @@ import { registerWalletCommand } from "./commands/wallet.js";
 import { registerOrgCommand } from "./commands/org.js";
 import { registerPluginCommand } from "./commands/plugin.js";
 import { registerInitCommand } from "./commands/init.js";
+import { registerPersonaCommand } from "./commands/persona.js";
 import { registerCoworkCommand } from "./commands/cowork.js";
 
 // Phase 6: Advanced AI & Hooks
@@ -97,8 +98,9 @@ export function createProgram() {
     .option("--verbose", "Enable verbose output")
     .option("--quiet", "Suppress non-essential output");
 
-  // Project initialization
+  // Project initialization & persona
   registerInitCommand(program);
+  registerPersonaCommand(program);
 
   // Existing commands
   registerSetupCommand(program);

package/src/lib/agent-core.js

@@ -22,6 +22,7 @@ import { getPlanModeManager } from "./plan-mode.js";
 import { CLISkillLoader } from "./skill-loader.js";
 import { executeHooks, HookEvents } from "./hook-manager.js";
 import { detectPython } from "./cli-anything-bridge.js";
+import { findProjectRoot, loadProjectConfig } from "./project-detector.js";
 
 // ─── Tool definitions ────────────────────────────────────────────────────
 
@@ -331,6 +332,126 @@ ${envLines.join("\n")}
 Current working directory: ${cwd || process.cwd()}`;
 }
 
+// ─── Persona support ─────────────────────────────────────────────────────
+
+/**
+ * Load persona configuration from project config.json
+ * @param {string} cwd - working directory
+ * @returns {object|null} persona object or null
+ */
+function _loadProjectPersona(cwd) {
+  try {
+    const projectRoot = findProjectRoot(cwd || process.cwd());
+    if (!projectRoot) return null;
+    const config = loadProjectConfig(projectRoot);
+    return config?.persona || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a persona-specific system prompt
+ * @param {object} persona - persona configuration
+ * @param {string[]} envLines - environment info lines
+ * @param {string} cwd - working directory
+ * @returns {string}
+ */
+function _buildPersonaPrompt(persona, envLines, cwd) {
+  const lines = [];
+  lines.push(`You are ${persona.name || "AI Assistant"}.`);
+  if (persona.role) {
+    lines.push("");
+    lines.push(persona.role);
+  }
+  if (persona.behaviors?.length > 0) {
+    lines.push("");
+    lines.push("Key behaviors:");
+    for (const b of persona.behaviors) {
+      lines.push(`- ${b}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    "You have access to tools that let you read files, write files, edit files, run shell commands, and search the codebase. When the user asks you to do something, USE THE TOOLS to actually do it.",
+  );
+  if (persona.toolsPriority?.length > 0) {
+    lines.push(`\nPreferred tools: ${persona.toolsPriority.join(", ")}`);
+  }
+  lines.push(`\n## Environment\n${envLines.join("\n")}`);
+  lines.push(`\nCurrent working directory: ${cwd || process.cwd()}`);
+  return lines.join("\n");
+}
+
+/**
+ * Build the full system prompt with persona, rules.md, and auto-activated persona skills.
+ * Single entry point used by both agent-repl and ws-session-manager.
+ *
+ * Priority order:
+ *  1. config.json persona → replaces base system prompt
+ *  2. Auto-activated persona skills → appended
+ *  3. rules.md → appended
+ *  4. Default hardcoded prompt → fallback when no persona
+ *
+ * @param {string} [cwd] - working directory
+ * @returns {string} complete system prompt
+ */
+export function buildSystemPrompt(cwd) {
+  const dir = cwd || process.cwd();
+
+  // Check for project persona
+  const persona = _loadProjectPersona(dir);
+  let prompt;
+  if (persona) {
+    const env = getEnvironmentInfo();
+    const envLines = [
+      `OS: ${env.os} (${env.arch})`,
+      env.python
+        ? `Python: ${env.python}${env.pip ? " + pip" : ""}`
+        : "Python: not found",
+      env.node ? `Node.js: ${env.node}` : "Node.js: not found",
+      `Git: ${env.git ? "available" : "not found"}`,
+    ];
+    prompt = _buildPersonaPrompt(persona, envLines, dir);
+  } else {
+    prompt = getBaseSystemPrompt(dir);
+  }
+
+  // Append auto-activated persona skills
+  try {
+    const loader = new CLISkillLoader();
+    const allSkills = loader.getResolvedSkills();
+    const personaSkills = allSkills.filter(
+      (s) => s.category === "persona" && s.activation === "auto",
+    );
+    for (const p of personaSkills) {
+      if (p.body?.trim()) {
+        prompt += `\n\n## Persona: ${p.displayName}\n${p.body}`;
+      }
+    }
+  } catch {
+    // Non-critical — skill loader may not be available
+  }
+
+  // Append rules.md
+  try {
+    const projectRoot = findProjectRoot(dir);
+    if (projectRoot) {
+      const rulesPath = path.join(projectRoot, ".chainlesschain", "rules.md");
+      if (fs.existsSync(rulesPath)) {
+        const content = fs.readFileSync(rulesPath, "utf-8");
+        if (content.trim()) {
+          prompt += `\n\n## Project Rules\n${content}`;
+        }
+      }
+    }
+  } catch {
+    // Non-critical
+  }
+
+  return prompt;
+}
+
 // ─── Tool execution ──────────────────────────────────────────────────────
 
 /**
@@ -349,6 +470,14 @@ export async function executeTool(name, args, context = {}) {
   const skillLoader = context.skillLoader || _defaultSkillLoader;
   const cwd = context.cwd || process.cwd();
 
+  // Persona toolsDisabled guard
+  const persona = _loadProjectPersona(cwd);
+  if (persona?.toolsDisabled?.includes(name)) {
+    return {
+      error: `Tool "${name}" is disabled by project persona configuration.`,
+    };
+  }
+
   // Plan mode: check if tool is allowed
   const planManager = getPlanModeManager();
   if (planManager.isActive() && !planManager.isToolAllowed(name)) {
@@ -837,6 +966,15 @@ async function _executeRunCode(args, cwd) {
 export async function chatWithTools(rawMessages, options) {
   const { provider, model, baseUrl, apiKey, contextEngine: ce } = options;
 
+  // Filter tools based on persona.toolsDisabled
+  let tools = AGENT_TOOLS;
+  const persona = _loadProjectPersona(options.cwd);
+  if (persona?.toolsDisabled?.length > 0) {
+    tools = AGENT_TOOLS.filter(
+      (t) => !persona.toolsDisabled.includes(t.function.name),
+    );
+  }
+
   const lastUserMsg = [...rawMessages].reverse().find((m) => m.role === "user");
   const messages = ce
     ? ce.buildOptimizedMessages(rawMessages, {
@@ -851,7 +989,7 @@ export async function chatWithTools(rawMessages, options) {
       body: JSON.stringify({
         model,
         messages,
-        tools: AGENT_TOOLS,
+        tools,
         stream: false,
       }),
     });
@@ -868,7 +1006,7 @@ export async function chatWithTools(rawMessages, options) {
     const systemMsgs = messages.filter((m) => m.role === "system");
     const otherMsgs = messages.filter((m) => m.role !== "system");
 
-    const anthropicTools = AGENT_TOOLS.map((t) => ({
+    const anthropicTools = tools.map((t) => ({
       name: t.function.name,
       description: t.function.description,
       input_schema: t.function.parameters,
@@ -959,7 +1097,7 @@ export async function chatWithTools(rawMessages, options) {
     body: JSON.stringify({
       model: model || defaultModels[provider] || "gpt-4o-mini",
       messages,
-      tools: AGENT_TOOLS,
+      tools,
     }),
   });
 

package/src/lib/llm-providers.js

@@ -80,7 +80,7 @@ export const BUILT_IN_PROVIDERS = {
   },
   volcengine: {
     name: "volcengine",
-    displayName: "Volcengine (豆包)",
+    displayName: "Volcengine (火山引擎/豆包)",
     baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
     apiKeyEnv: "VOLCENGINE_API_KEY",
     models: [
@@ -91,6 +91,27 @@ export const BUILT_IN_PROVIDERS = {
     ],
     free: false,
   },
+  kimi: {
+    name: "kimi",
+    displayName: "Kimi (月之暗面)",
+    baseUrl: "https://api.moonshot.cn/v1",
+    apiKeyEnv: "MOONSHOT_API_KEY",
+    models: [
+      "moonshot-v1-auto",
+      "moonshot-v1-8k",
+      "moonshot-v1-32k",
+      "moonshot-v1-128k",
+    ],
+    free: false,
+  },
+  minimax: {
+    name: "minimax",
+    displayName: "MiniMax (海螺AI)",
+    baseUrl: "https://api.minimax.chat/v1",
+    apiKeyEnv: "MINIMAX_API_KEY",
+    models: ["MiniMax-Text-01", "abab6.5s-chat", "abab5.5-chat"],
+    free: false,
+  },
 };
 
 /**
@@ -323,7 +344,7 @@ export class LLMProviderRegistry {
       return { ok: true, elapsed: Date.now() - start, response: text.trim() };
     }
 
-    // OpenAI-compatible (openai, deepseek, dashscope, mistral, volcengine)
+    // OpenAI-compatible (openai, deepseek, dashscope, mistral, volcengine, kimi, minimax)
     const key = this.getApiKey(name);
     if (!key) throw new Error(`${provider.apiKeyEnv} not set`);
     const res = await fetch(`${provider.baseUrl}/chat/completions`, {

package/src/lib/skill-loader.js

@@ -212,6 +212,7 @@ export class CLISkillLoader {
             description: data.description || "",
             version: data.version || "1.0.0",
             category: data.category || "uncategorized",
+            activation: data.activation || "manual",
             tags: data.tags || [],
             userInvocable: data.userInvocable !== false,
             handler: data.handler || null,
@@ -265,6 +266,16 @@ export class CLISkillLoader {
     return this.loadAll();
   }
 
+  /**
+   * Get auto-activated persona skills
+   * @returns {object[]} skills with category "persona" and activation "auto"
+   */
+  getAutoActivatedPersonas() {
+    return this.getResolvedSkills().filter(
+      (s) => s.category === "persona" && s.activation === "auto",
+    );
+  }
+
   /**
    * Clear the cache
    */

package/src/lib/task-model-selector.js

@@ -30,6 +30,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-chat",
     dashscope: "qwen-plus",
     gemini: "gemini-2.0-flash",
+    kimi: "moonshot-v1-auto",
+    minimax: "MiniMax-Text-01",
     mistral: "mistral-medium-latest",
     ollama: "qwen2.5:7b",
   },
@@ -40,6 +42,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-coder",
     dashscope: "qwen-max",
     gemini: "gemini-2.0-pro",
+    kimi: "moonshot-v1-auto",
+    minimax: "MiniMax-Text-01",
     mistral: "mistral-large-latest",
     ollama: "qwen2.5-coder:14b",
   },
@@ -50,6 +54,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-reasoner",
     dashscope: "qwen-max",
     gemini: "gemini-2.0-pro",
+    kimi: "moonshot-v1-128k",
+    minimax: "MiniMax-Text-01",
     mistral: "mistral-large-latest",
     ollama: "qwen2.5:14b",
   },
@@ -60,6 +66,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-chat",
     dashscope: "qwen-turbo",
     gemini: "gemini-2.0-flash",
+    kimi: "moonshot-v1-8k",
+    minimax: "abab6.5s-chat",
     mistral: "mistral-small-latest",
     ollama: "qwen2:7b",
   },
@@ -70,6 +78,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-chat",
     dashscope: "qwen-plus",
     gemini: "gemini-2.0-flash",
+    kimi: "moonshot-v1-auto",
+    minimax: "MiniMax-Text-01",
     mistral: "mistral-large-latest",
     ollama: "qwen2:7b",
   },
@@ -80,6 +90,8 @@ const TASK_MODEL_MAP = {
     deepseek: "deepseek-chat",
     dashscope: "qwen-max",
     gemini: "gemini-2.0-pro",
+    kimi: "moonshot-v1-128k",
+    minimax: "MiniMax-Text-01",
     mistral: "mistral-large-latest",
     ollama: "qwen2:7b",
   },

package/src/lib/ws-session-manager.js

@@ -18,7 +18,7 @@ import {
   getSession as dbGetSession,
   listSessions as dbListSessions,
 } from "./session-manager.js";
-import { getBaseSystemPrompt } from "./agent-core.js";
+import { buildSystemPrompt } from "./agent-core.js";
 
 /**
  * @typedef {object} Session
@@ -88,16 +88,7 @@ export class WSSessionManager {
       options.model || (provider === "ollama" ? "qwen2.5:7b" : null);
     const baseUrl = options.baseUrl || "http://localhost:11434";
 
-    // Load project context
-    let rulesContent = null;
-    try {
-      const rulesPath = path.join(projectRoot, ".chainlesschain", "rules.md");
-      if (fs.existsSync(rulesPath)) {
-        rulesContent = fs.readFileSync(rulesPath, "utf8");
-      }
-    } catch (_err) {
-      // Non-critical
-    }
+    // Project context (rules.md, persona) is now loaded by buildSystemPrompt()
 
     // Create plan manager (non-singleton, per-session)
     const planManager = new PlanModeManager();
@@ -125,11 +116,8 @@ export class WSSessionManager {
       // Non-critical
     }
 
-    // Build initial system prompt
-    let systemPrompt = getBaseSystemPrompt(projectRoot);
-    if (rulesContent) {
-      systemPrompt += `\n\n## Project Rules\n${rulesContent}`;
-    }
+    // Build initial system prompt (includes persona + rules.md)
+    const systemPrompt = buildSystemPrompt(projectRoot);
 
     const messages = [{ role: "system", content: systemPrompt }];
 
@@ -158,7 +146,7 @@ export class WSSessionManager {
       apiKey: options.apiKey || null,
       baseUrl,
       projectRoot,
-      rulesContent,
+      rulesContent: null,
       planManager,
       contextEngine,
       permanentMemory,

package/src/repl/agent-repl.js

@@ -40,7 +40,7 @@ import { CLIPermanentMemory } from "../lib/permanent-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
 import {
   AGENT_TOOLS,
-  getBaseSystemPrompt,
+  buildSystemPrompt,
   executeTool as coreExecuteTool,
   agentLoop as coreAgentLoop,
   formatToolArgs,
@@ -150,7 +150,7 @@ export async function startAgentRepl(options = {}) {
   }
 
   const messages = [
-    { role: "system", content: getBaseSystemPrompt(process.cwd()) },
+    { role: "system", content: buildSystemPrompt(process.cwd()) },
   ];
 
   // Load resumed session messages