chainlesschain 0.41.1 → 0.42.3

package/README.md

@@ -9,6 +9,20 @@ npm install -g chainlesschain
 chainlesschain setup
 ```
 
+After installation, three equivalent commands are available:
+
+| Command          | Description                                                       |
+| ---------------- | ----------------------------------------------------------------- |
+| `chainlesschain` | Full name                                                         |
+| `cc`             | Shortest alias, recommended for daily use                         |
+| `clc`            | ChainLessChain abbreviation, avoids `cc` conflict with C compiler |
+| `clchain`        | chainlesschain abbreviation, easy to recognize                    |
+
+```bash
+cc setup       # equivalent to: chainlesschain setup
+clchain start  # equivalent to: chainlesschain start
+```
+
 ## Requirements
 
 - **Node.js** >= 22.12.0

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "chainlesschain",
-  "version": "0.41.1",
+  "version": "0.42.3",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
-    "chainlesschain": "./bin/chainlesschain.js"
+    "chainlesschain": "./bin/chainlesschain.js",
+    "cc": "./bin/chainlesschain.js",
+    "clc": "./bin/chainlesschain.js",
+    "clchain": "./bin/chainlesschain.js"
   },
   "main": "src/index.js",
   "scripts": {

package/src/commands/agent.js

@@ -7,6 +7,7 @@
  */
 
 import { startAgentRepl } from "../repl/agent-repl.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 export function registerAgentCommand(program) {
   program
@@ -15,21 +16,21 @@ export function registerAgentCommand(program) {
     .description(
       "Start an agentic AI session (reads/writes files, runs commands)",
     )
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option("--session <id>", "Resume a previous agent session")
     .action(async (options) => {
+      const config = loadConfig();
       await startAgentRepl({
-        model: options.model,
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        apiKey: options.apiKey,
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
         sessionId: options.session,
       });
     });

package/src/commands/ask.js

@@ -1,12 +1,13 @@
 /**
  * Single-shot AI question command
- * chainlesschain ask "What is..." [--model qwen2:7b] [--provider ollama] [--json]
+ * chainlesschain ask "What is..." [--model] [--provider] [--json]
  */
 
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 /**
  * Send a single question to an LLM provider
@@ -84,24 +85,25 @@ export function registerAskCommand(program) {
     .command("ask")
     .description("Ask a question to the AI (single-shot)")
     .argument("<question>", "The question to ask")
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option("--json", "Output as JSON")
     .action(async (question, options) => {
+      const config = loadConfig();
+      const resolvedOptions = {
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
+      };
       const spinner = ora("Thinking...").start();
       try {
-        const answer = await queryLLM(question, {
-          model: options.model,
-          provider: options.provider,
-          baseUrl: options.baseUrl,
-          apiKey: options.apiKey,
-        });
+        const answer = await queryLLM(question, resolvedOptions);
 
         spinner.stop();
 

package/src/commands/chat.js

@@ -1,20 +1,20 @@
 /**
  * Interactive AI chat command
- * chainlesschain chat [--model qwen2:7b] [--provider ollama] [--agent]
+ * chainlesschain chat [--model] [--provider] [--agent]
  */
 
 import { startChatRepl } from "../repl/chat-repl.js";
 import { startAgentRepl } from "../repl/agent-repl.js";
+import { loadConfig } from "../lib/config-manager.js";
 
 export function registerChatCommand(program) {
   program
     .command("chat")
     .description("Start an interactive AI chat session")
-    .option("--model <model>", "Model name", "qwen2:7b")
+    .option("--model <model>", "Model name")
     .option(
       "--provider <provider>",
       "LLM provider (ollama, openai, volcengine, deepseek, ...)",
-      "ollama",
     )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
@@ -24,11 +24,12 @@ export function registerChatCommand(program) {
     )
     .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
+      const config = loadConfig();
       const replOptions = {
-        model: options.model,
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        apiKey: options.apiKey,
+        model: options.model || config.llm?.model || "qwen2:7b",
+        provider: options.provider || config.llm?.provider || "ollama",
+        baseUrl: options.baseUrl || config.llm?.baseUrl,
+        apiKey: options.apiKey || config.llm?.apiKey,
         sessionId: options.session,
       };
 

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,50 @@
 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 true; // Already at the target version
+  }
+
+  try {
+    logger.info("Updating CLI package...");
+    execSync(`npm install -g chainlesschain@${targetVersion}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+    // Verify the update actually took effect
+    try {
+      const newVersion = execSync("chainlesschain --version", {
+        encoding: "utf-8",
+        stdio: "pipe",
+      }).trim();
+      if (newVersion === targetVersion) {
+        logger.success(`CLI updated to v${targetVersion}`);
+        return true;
+      }
+      logger.warn(
+        `CLI update ran but version is still ${newVersion}. Please run manually:\n  npm install -g chainlesschain@${targetVersion}`,
+      );
+      return false;
+    } catch (_verifyErr) {
+      // Cannot verify, assume success
+      logger.success(`CLI updated to v${targetVersion}`);
+      return true;
+    }
+  } 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}`,
+    );
+    return false;
+  }
+}
+
 export function registerUpdateCommand(program) {
   program
     .command("update")
@@ -64,7 +104,21 @@ export function registerUpdateCommand(program) {
         }
 
         await downloadRelease(result.latestVersion, { force: options.force });
-        logger.success(`Updated to v${result.latestVersion}`);
+        logger.success("Application already installed");
+
+        // Self-update the CLI npm package
+        const cliUpdated = await selfUpdateCli(result.latestVersion);
+
+        if (cliUpdated) {
+          logger.success(`Updated to v${result.latestVersion}`);
+        } else {
+          logger.warn(
+            `Application binary updated, but CLI version remains at ${VERSION}.`,
+          );
+          logger.info(
+            `To complete the update, run:\n  npm install -g chainlesschain@${result.latestVersion}`,
+          );
+        }
         logger.info("Restart ChainlessChain to use the new version.");
       } catch (err) {
         if (err.name === "ExitPromptError") {

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