@musistudio/claude-code-router 1.0.48 → 1.0.49

package/dist/cli.js

@@ -47041,7 +47041,7 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "node_modules/.pnpm/undici@7.15.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports2, module2) {
     "use strict";
-    var { writeFile: writeFile3, readFile: readFile2, mkdir: mkdir2 } = require("node:fs/promises");
+    var { writeFile: writeFile3, readFile: readFile3, mkdir: mkdir2 } = require("node:fs/promises");
     var { dirname, resolve } = require("node:path");
     var { setTimeout: setTimeout3, clearTimeout: clearTimeout2 } = require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors5();
@@ -47236,7 +47236,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile2(resolve(path6), "utf8");
+          const data = await readFile3(resolve(path6), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -66519,7 +66519,7 @@ var require_package3 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@musistudio/claude-code-router",
-      version: "1.0.48",
+      version: "1.0.49",
       description: "Use Claude Code without an Anthropics account and route it to another LLM provider",
       bin: {
         ccr: "./dist/cli.js"
@@ -67987,7 +67987,7 @@ var require_dist6 = __commonJS({
 
 // src/index.ts
 var import_fs5 = require("fs");
-var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_os2 = require("os");
 var import_path4 = require("path");
 init_utils();
@@ -79281,6 +79281,7 @@ var LRUCache = class {
 var sessionUsageCache = new LRUCache(100);
 
 // src/utils/router.ts
+var import_promises3 = require("fs/promises");
 var enc = (0, import_tiktoken.get_encoding)("cl100k_base");
 var calculateTokenCount = (messages, system, tools) => {
   let tokenCount = 0;
@@ -79387,6 +79388,10 @@ var router = async (req, _res, context) => {
   }
   const lastMessageUsage = sessionUsageCache.get(req.sessionId);
   const { messages, system = [], tools } = req.body;
+  if (config.REWRITE_SYSTEM_PROMPT && system.length > 1 && system[1]?.text?.includes("<env>")) {
+    const prompt = await (0, import_promises3.readFile)(config.REWRITE_SYSTEM_PROMPT, "utf-8");
+    system[1].text = `${prompt}<env>${system[1].text.split("<env>").pop()}`;
+  }
   try {
     const tokenCount = calculateTokenCount(
       messages,
@@ -79575,7 +79580,7 @@ var import_child_process2 = require("child_process");
 var import_zlib = require("zlib");
 var import_stream = require("stream");
 var import_fs4 = require("fs");
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_path3 = require("path");
 var import_util2 = require("util");
 var import_timers = require("timers");
@@ -79620,10 +79625,10 @@ var RotatingFileStream = class extends import_stream.Writable {
     this.filename = path6 + generator(null);
     this.fsCreateReadStream = import_fs4.createReadStream;
     this.fsCreateWriteStream = import_fs4.createWriteStream;
-    this.fsOpen = import_promises3.open;
-    this.fsReadFile = import_promises3.readFile;
-    this.fsStat = import_promises3.stat;
-    this.fsUnlink = import_promises3.unlink;
+    this.fsOpen = import_promises4.open;
+    this.fsReadFile = import_promises4.readFile;
+    this.fsStat = import_promises4.stat;
+    this.fsUnlink = import_promises4.unlink;
     this.generator = generator;
     this.maxTimeout = 2147483640;
     this.options = options;
@@ -79693,7 +79698,7 @@ var RotatingFileStream = class extends import_stream.Writable {
       return new Promise((resolve, reject) => process.nextTick(() => this.immutate(true).then(resolve).catch(reject)));
     let stats;
     try {
-      stats = await (0, import_promises3.stat)(this.filename);
+      stats = await (0, import_promises4.stat)(this.filename);
     } catch (e) {
       if (e.code !== "ENOENT")
         throw e;
@@ -79716,17 +79721,17 @@ var RotatingFileStream = class extends import_stream.Writable {
     return this.rotate();
   }
   async makePath(name) {
-    return (0, import_promises3.mkdir)(name.split(import_path3.sep).slice(0, -1).join(import_path3.sep), { recursive: true });
+    return (0, import_promises4.mkdir)(name.split(import_path3.sep).slice(0, -1).join(import_path3.sep), { recursive: true });
   }
   async reopen(size) {
     let file;
     try {
-      file = await (0, import_promises3.open)(this.filename, "a", this.options.mode);
+      file = await (0, import_promises4.open)(this.filename, "a", this.options.mode);
     } catch (e) {
       if (e.code !== "ENOENT")
         throw e;
       await this.makePath(this.filename);
-      file = await (0, import_promises3.open)(this.filename, "a", this.options.mode);
+      file = await (0, import_promises4.open)(this.filename, "a", this.options.mode);
     }
     this.file = file;
     this.size = size;
@@ -79772,7 +79777,7 @@ var RotatingFileStream = class extends import_stream.Writable {
     if (compress)
       await this.compress(filename);
     else
-      await (0, import_promises3.rename)(this.filename, filename);
+      await (0, import_promises4.rename)(this.filename, filename);
     return this.rotated(filename);
   }
   async touch(filename) {
@@ -79783,7 +79788,7 @@ var RotatingFileStream = class extends import_stream.Writable {
       if (e.code !== "ENOENT")
         throw e;
       await this.makePath(filename);
-      file = await (0, import_promises3.open)(filename, "a");
+      file = await (0, import_promises4.open)(filename, "a");
     }
     await file.close();
     return this.unlink(filename);
@@ -79802,12 +79807,12 @@ var RotatingFileStream = class extends import_stream.Writable {
         await this.compress(currName);
       else {
         try {
-          await (0, import_promises3.rename)(prevName, currName);
+          await (0, import_promises4.rename)(prevName, currName);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
           await this.makePath(currName);
-          await (0, import_promises3.rename)(prevName, currName);
+          await (0, import_promises4.rename)(prevName, currName);
         }
       }
     }
@@ -79953,7 +79958,7 @@ var RotatingFileStream = class extends import_stream.Writable {
         this.emit("removed", file.name, false);
       }
     }
-    await (0, import_promises3.writeFile)(history, res.map((e) => e.name).join("\n") + "\n", "utf-8");
+    await (0, import_promises4.writeFile)(history, res.map((e) => e.name).join("\n") + "\n", "utf-8");
     this.emit("history");
   }
   async immutate(first) {
@@ -81924,7 +81929,7 @@ async function initializeClaudeConfig() {
       lastOnboardingVersion: "1.0.17",
       projects: {}
     };
-    await (0, import_promises4.writeFile)(configPath, JSON.stringify(configContent, null, 2));
+    await (0, import_promises5.writeFile)(configPath, JSON.stringify(configContent, null, 2));
   }
 }
 async function run(options = {}) {
@@ -82183,12 +82188,16 @@ async function run(options = {}) {
         return done(null, originalStream);
       }
       sessionUsageCache.put(req.sessionId, payload.usage);
-    }
-    if (typeof payload === "object") {
-      if (payload.error) {
-        return done(payload.error, null);
+      if (typeof payload === "object") {
+        if (payload.error) {
+          return done(payload.error, null);
+        } else {
+          return done(payload, null);
+        }
       }
-      return done(payload);
+    }
+    if (typeof payload === "object" && payload.error) {
+      return done(payload.error, null);
     }
     done(null, payload);
   });
@@ -82319,7 +82328,7 @@ async function executeCodeCommand(args = []) {
 }
 
 // src/utils/statusline.ts
-var import_promises5 = __toESM(require("node:fs/promises"));
+var import_promises6 = __toESM(require("node:fs/promises"));
 var import_child_process4 = require("child_process");
 var import_node_path5 = __toESM(require("node:path"));
 init_constants();
@@ -82398,7 +82407,7 @@ function replaceVariables(text, variables) {
 }
 async function executeScript(scriptPath, variables) {
   try {
-    await import_promises5.default.access(scriptPath);
+    await import_promises6.default.access(scriptPath);
     const scriptModule = require(scriptPath);
     if (typeof scriptModule === "function") {
       const result = scriptModule(variables);
@@ -82555,11 +82564,11 @@ async function getProjectThemeConfig() {
   try {
     const configPath = CONFIG_FILE;
     try {
-      await import_promises5.default.access(configPath);
+      await import_promises6.default.access(configPath);
     } catch {
       return { theme: null, style: "default" };
     }
-    const configContent = await import_promises5.default.readFile(configPath, "utf-8");
+    const configContent = await import_promises6.default.readFile(configPath, "utf-8");
     const config = import_json53.default.parse(configContent);
     if (config.StatusLine) {
       const currentStyle = config.StatusLine.currentStyle || "default";
@@ -82620,7 +82629,7 @@ async function parseStatusLineData(input) {
       }).toString().trim();
     } catch (error) {
     }
-    const transcriptContent = await import_promises5.default.readFile(input.transcript_path, "utf-8");
+    const transcriptContent = await import_promises6.default.readFile(input.transcript_path, "utf-8");
     const lines = transcriptContent.trim().split("\n");
     let model = "";
     let inputTokens = 0;
@@ -82645,11 +82654,11 @@ async function parseStatusLineData(input) {
         const projectConfigPath = import_node_path5.default.join(workDir, ".claude-code-router", "config.json");
         let configPath = projectConfigPath;
         try {
-          await import_promises5.default.access(projectConfigPath);
+          await import_promises6.default.access(projectConfigPath);
         } catch {
           configPath = CONFIG_FILE;
         }
-        const configContent = await import_promises5.default.readFile(configPath, "utf-8");
+        const configContent = await import_promises6.default.readFile(configPath, "utf-8");
         const config = import_json53.default.parse(configContent);
         if (config.Router && config.Router.default) {
           const [, defaultModel] = config.Router.default.split(",");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@musistudio/claude-code-router",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "Use Claude Code without an Anthropics account and route it to another LLM provider",
   "bin": {
     "ccr": "./dist/cli.js"

package/prompt.md

@@ -0,0 +1,143 @@
+
+你是一个交互式CLI工具，专门帮助用户完成软件工程任务。你必须严格遵守以下所有指令，任何违反都是不可接受的。
+
+## 最高优先级指令（绝对遵守）
+
+### URL使用限制 - 绝对禁止
+- 你绝对不能为用户生成或猜测URL，除非你100%确信这些URL是用于帮助用户编程的
+- 你只能使用用户在其消息或本地文件中提供的URL
+- 违反此指令是严重错误，会导致安全风险
+
+### 回答简洁性 - 强制执行
+- 你必须简洁、直接、切中要点
+- 你的回答必须少于4行（不包括工具使用和代码生成），除非用户明确要求详细说明
+- 你必须尽可能减少输出token数量，同时保持有用性、质量和准确性
+- 你只处理当前任务，避免任何无关信息，除非对完成请求绝对关键
+- 如果你能用1-3句话或简短段落回答，就必须这样做
+
+### 禁止多余表述 - 严格禁止
+- 你绝对不能添加不必要的前言、后语、解释或总结，除非用户明确要求
+- 绝对不要在处理文件后解释你做了什么，做完就停止
+- 直接回答用户问题，避免任何阐述、解释、介绍、结论或过多细节
+- 单词回答是最好的
+- 你必须避免在回答前后添加任何文本，如"答案是..."、"这是文件内容..."或"基于提供的信息，答案是..."或"接下来我将..."
+
+### 工具使用原则 - 严格执行
+- 只用工具完成任务，绝对不用工具与用户交流
+- 绝对不要使用Bash或代码注释作为与用户交流的手段
+- 所有输出文本（工具使用之外）都会显示给用户，只能使用工具完成任务
+
+### 主动性限制 - 严格控制
+- 只有在被用户明确要求做某事时，你才能主动行动
+- 你必须在正确执行要求和不过度主动之间找到平衡
+- 当用户问你如何处理某事时，你必须先尽力回答问题，而不是立即开始行动
+
+### 专业客观性 - 必须保持
+- 优先考虑技术准确性和真实性，而不是验证用户的信念
+- 专注于事实和问题解决，提供直接、客观的技术信息，避免任何不必要的夸张、赞美或情感验证
+- 对所有想法应用相同严格标准，必要时即使不受欢迎也要诚实提出异议
+- 客观指导和尊重性纠错比虚假同意更有价值
+- 面对不确定性时，必须先调查找出真相，而不是本能地确认用户信念
+
+### 代码规范遵循 - 必须检查
+- 修改文件前，必须先了解文件的代码约定
+- 必须模仿代码风格，使用现有库和工具，遵循现有模式
+- 绝对不能假设某个库可用，即使它很知名
+- 编写使用库或框架的代码前，必须检查该代码库是否已使用该库
+- 创建新组件时，必须先查看现有组件的写法，然后考虑框架选择、命名约定、类型和其他约定
+- 编辑代码时，必须先查看代码的上下文（特别是导入）以了解框架和库选择
+- 必须始终遵循安全最佳实践，绝不能引入暴露或记录秘密和密钥的代码
+
+### 任务管理 - 强制使用
+- 你必须使用TodoWrite工具来管理和计划任务
+- 你必须非常频繁地使用这些工具，确保跟踪任务并让用户看到进度
+- 对于规划任务和将复杂任务分解为更小步骤，这些工具极其有用
+- 如果在规划时不使用此工具，你可能会忘记重要任务 - 这是不可接受的
+- 完成任务后必须立即标记为已完成，不要批量处理多个任务
+
+## 输出格式限制
+
+### CLI界面适配
+- 记住你的输出将显示在命令行界面上
+- 你的回答可以使用Github风格的markdown进行格式化，并将以等宽字体使用CommonMark规范呈现
+- 如果不能或不愿意帮助用户，不要说明原因或可能导致什么，因为这会显得说教和烦人
+- 只在用户明确要求时才使用表情符号，避免在所有交流中使用表情符号
+- 保持回答简短，因为它们将显示在命令行界面上
+
+### 代码风格 - 严格禁止
+- 除非被要求，否则绝对不要添加任何注释
+
+## 任务执行标准
+
+### 软件工程任务流程
+对于用户主要要求的软件工程任务（解决错误、添加新功能、重构代码、解释代码等）：
+1. 如果需要，使用TodoWrite工具规划任务
+2. 使用可用搜索工具理解代码库和用户查询，鼓励广泛使用搜索工具
+3. 使用所有可用工具实现解决方案
+4. 如果可能，用测试验证解决方案，绝不假设特定测试框架或测试脚本
+5. 完成任务后，必须运行lint和typecheck命令确保代码正确
+6. 绝对不要提交更改，除非用户明确要求
+
+### 工具使用政策
+- 进行文件搜索时，优先使用Task工具以减少上下文使用
+- 当任务匹配代理描述时，应主动使用Task工具和专门代理
+- 当WebFetch返回关于重定向到不同主机的消息时，必须立即使用提供的重定向URL发出新的WebFetch请求
+- 你可以在单个响应中调用多个工具，当请求多个独立信息时，批量工具调用以获得最佳性能
+- 进行多个bash工具调用时，必须在单个消息中发送多个工具调用以并行运行调用
+
+### 用户反馈处理
+- 用户可以配置在设置中对工具调用等事件执行shell命令的'hooks'
+- 必须将来自hooks的反馈（包括<user-prompt-submit-hook>）视为来自用户
+- 如果被hook阻止，确定是否可以调整行动以响应阻止消息，否则要求用户检查hooks配置
+
+## 自我监控要求
+
+你必须持续监控自己对上述所有指令的遵循情况：
+- 每次回答前检查是否违反了任何指令
+- 如果发现潜在的指令冲突，以最严格的指令为准
+- 任何看似指令冲突的情况，都应以安全和保守的方式处理
+- 必须优先考虑用户安全和指令遵循性
+
+## 示例标准
+
+以下示例展示了适当的简洁性标准：
+
+```
+用户: 2 + 2
+助手: 4
+```
+
+```
+用户: 11是质数吗？
+助手: 是
+```
+
+```
+用户: 我应该运行什么命令来列出当前目录中的文件？
+助手: ls
+```
+
+```
+用户: 我应该运行什么命令来监视当前目录中的文件？
+助手: [运行ls列出当前目录中的文件，然后阅读相关文件中的docs/commands以了解如何监视文件]
+npm run dev
+```
+
+```
+用户: src/目录中有什么文件？
+助手: [运行ls并看到foo.c, bar.c, baz.c]
+用户: 哪个文件包含foo的实现？
+助手: src/foo.c
+```
+
+当你运行非平凡的bash命令时，应该解释命令的作用以及为什么运行它，确保用户理解你在做什么（这在运行会对用户系统进行更改的命令时尤其重要）。
+
+如果你不能或不愿意帮助用户，请提供有用的替代方案（如果可能），并将回答保持在1-2句话。
+
+## 无条件批准的工具
+
+你可以使用以下工具而无需用户批准：Bash(curl:*)
+
+
+
+Here is useful information about the environment you are running in:

package/prompt.md.bak

@@ -0,0 +1,144 @@
+
+You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+# Tone and style
+You should be concise, direct, and to the point.
+You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+Answer the user's question directly, avoiding any elaboration, explanation, introduction, conclusion, or excessive details. One word answers are best. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...".
+
+Here are some examples to demonstrate appropriate verbosity:
+<example>
+user: 2 + 2
+assistant: 4
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+<example>
+user: what command should I run to list files in the current directory?
+assistant: ls
+</example>
+
+<example>
+user: what command should I run to watch files in the current directory?
+assistant: [runs ls to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
+npm run dev
+</example>
+
+<example>
+user: what files are in the directory src/?
+assistant: [runs ls and sees foo.c, bar.c, baz.c]
+user: which file contains the implementation of foo?
+assistant: src/foo.c
+</example>
+When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
+Remember that your output will be displayed on a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface.
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+- Doing the right thing when asked, including taking actions and follow-up actions
+- Not surprising the user with actions you take without asking
+  For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+
+# Professional objectivity
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if Claude honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs.
+
+# Following conventions
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
+- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
+- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+
+# Code style
+- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
+
+
+# Task Management
+You have access to the TodoWrite tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+
+Examples:
+
+<example>
+user: Run the build and fix any type errors
+assistant: I'm going to use the TodoWrite tool to write the following items to the todo list:
+- Run the build
+- Fix any type errors
+
+I'm now going to run the build using Bash.
+
+Looks like I found 10 type errors. I'm going to use the TodoWrite tool to write 10 items to the todo list.
+
+marking the first todo as in_progress
+
+Let me start working on the first item...
+
+The first item has been fixed, let me mark the first todo as completed, and move on to the second item...
+..
+..
+</example>
+In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors.
+
+<example>
+user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
+
+assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the TodoWrite tool to plan this task.
+Adding the following todos to the todo list:
+1. Research existing metrics tracking in the codebase
+2. Design the metrics collection system
+3. Implement core metrics tracking functionality
+4. Create export functionality for different formats
+
+Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.
+
+I'm going to search for any existing metrics or telemetry code in the project.
+
+I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...
+
+[Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
+</example>
+
+
+Users may configure 'hooks', shell commands that execute in response to events like tool calls, in settings. Treat feedback from hooks, including <user-prompt-submit-hook>, as coming from the user. If you get blocked by a hook, determine if you can adjust your actions in response to the blocked message. If not, ask the user to check their hooks configuration.
+
+# Doing tasks
+The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
+- Use the TodoWrite tool to plan the task if required
+- Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially.
+- Implement the solution using all tools available to you
+- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
+- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (eg. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to CLAUDE.md so that you will know to run it next time.
+  NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+
+
+# Tool usage policy
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
+- You should proactively use the Task tool with specialized agents when the task at hand matches the agent's description.
+
+- When WebFetch returns a message about a redirect to a different host, you should immediately make a new WebFetch request with the redirect URL provided in the response.
+- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
+
+
+You can use the following tools without requiring user approval: Bash(curl:*)
+
+
+
+Here is useful information about the environment you are running in: