pulse-coder-engine 0.0.1-alpha.4 → 0.0.1-alpha.6

package/dist/built-in/index.cjs

@@ -30,9 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/built-in/index.ts
 var built_in_exports = {};
 __export(built_in_exports, {
+  BuiltInPlanModeService: () => BuiltInPlanModeService,
   BuiltInSkillRegistry: () => BuiltInSkillRegistry,
   SubAgentPlugin: () => SubAgentPlugin,
   builtInMCPPlugin: () => builtInMCPPlugin,
+  builtInPlanModePlugin: () => builtInPlanModePlugin,
   builtInPlugins: () => builtInPlugins,
   builtInSkillsPlugin: () => builtInSkillsPlugin,
   default: () => built_in_default
@@ -274,10 +276,410 @@ var builtInSkillsPlugin = {
   }
 };
 
+// src/built-in/plan-mode-plugin/index.ts
+var PLANNING_POLICY = {
+  mode: "planning",
+  allowedCategories: ["read", "search", "other"],
+  disallowedCategories: ["write", "execute"],
+  notes: "Planning mode is prompt-constrained only. Disallowed tool attempts are observed and logged, not hard-blocked."
+};
+var EXECUTING_POLICY = {
+  mode: "executing",
+  allowedCategories: ["read", "search", "write", "execute", "other"],
+  disallowedCategories: []
+};
+var EXECUTE_PATTERNS = [
+  /开始执行/i,
+  /按这个计划做/i,
+  /可以改代码了/i,
+  /直接实现/i,
+  /go\s+ahead/i,
+  /proceed/i,
+  /implement\s+it/i,
+  /start\s+implement/i,
+  /start\s+coding/i
+];
+var NEGATIVE_PATTERNS = [
+  /先不(要)?执行/i,
+  /先别执行/i,
+  /不要执行/i,
+  /暂时不要执行/i,
+  /先别改代码/i,
+  /先不要改代码/i,
+  /先不要实现/i,
+  /not\s+now/i,
+  /hold\s+off/i,
+  /do\s+not\s+(start|execute|implement|proceed)/i,
+  /don't\s+(start|execute|implement|proceed)/i
+];
+var PLAN_PATTERNS = [/先计划/i, /先分析/i, /先出方案/i, /plan\s+first/i, /analysis\s+first/i];
+function appendSystemPrompt(base, append) {
+  if (!append.trim()) {
+    return base ?? { append: "" };
+  }
+  if (!base) {
+    return { append };
+  }
+  if (typeof base === "string") {
+    return `${base}
+
+${append}`;
+  }
+  if (typeof base === "function") {
+    return () => `${base()}
+
+${append}`;
+  }
+  const currentAppend = base.append.trim();
+  return {
+    append: currentAppend ? `${currentAppend}
+
+${append}` : append
+  };
+}
+var KNOWN_TOOL_META = {
+  read: {
+    category: "read",
+    risk: "low",
+    description: "Read file contents from the workspace."
+  },
+  ls: {
+    category: "read",
+    risk: "low",
+    description: "List files and directories."
+  },
+  grep: {
+    category: "search",
+    risk: "low",
+    description: "Search text content across files."
+  },
+  tavily: {
+    category: "search",
+    risk: "low",
+    description: "Search web results from external sources."
+  },
+  skill: {
+    category: "search",
+    risk: "low",
+    description: "Load procedural guidance from installed skills."
+  },
+  write: {
+    category: "write",
+    risk: "high",
+    description: "Create or overwrite file content."
+  },
+  edit: {
+    category: "write",
+    risk: "high",
+    description: "Modify existing files using exact replacements."
+  },
+  bash: {
+    category: "execute",
+    risk: "high",
+    description: "Execute shell commands."
+  },
+  clarify: {
+    category: "other",
+    risk: "low",
+    description: "Ask the user a targeted clarification question."
+  }
+};
+var BuiltInPlanModeService = class {
+  constructor(logger, eventEmitter, initialMode = "executing") {
+    this.logger = logger;
+    this.eventEmitter = eventEmitter;
+    this.mode = initialMode;
+    this.emitEvent("mode_entered", { reason: "initialize" });
+  }
+  mode;
+  events = [];
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode, reason = "manual") {
+    if (this.mode === mode) {
+      return;
+    }
+    this.mode = mode;
+    this.emitEvent("mode_entered", { reason });
+  }
+  detectIntent(input) {
+    const text = input.trim();
+    if (!text) {
+      return "UNCLEAR";
+    }
+    if (NEGATIVE_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "PLAN_ONLY";
+    }
+    if (EXECUTE_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "EXECUTE_NOW";
+    }
+    if (PLAN_PATTERNS.some((pattern) => pattern.test(text))) {
+      return "PLAN_ONLY";
+    }
+    return "UNCLEAR";
+  }
+  processContextMessages(messages) {
+    const userInput = this.getLatestUserText(messages);
+    const modeBefore = this.mode;
+    if (!userInput) {
+      return {
+        modeBefore,
+        modeAfter: this.mode,
+        switched: false,
+        intent: "UNCLEAR",
+        userInput: ""
+      };
+    }
+    const intent = this.detectIntent(userInput);
+    if (intent === "EXECUTE_NOW") {
+      this.emitEvent("execution_intent_detected", { intent, userInput });
+      if (this.mode === "planning") {
+        this.mode = "executing";
+        this.emitEvent("mode_switched_by_intent", {
+          from: "planning",
+          to: "executing",
+          userInput
+        });
+        this.emitEvent("mode_entered", {
+          reason: "intent",
+          from: "planning"
+        });
+      }
+    }
+    return {
+      modeBefore,
+      modeAfter: this.mode,
+      switched: modeBefore !== this.mode,
+      intent,
+      userInput
+    };
+  }
+  getModePolicy(mode = this.mode) {
+    return mode === "planning" ? PLANNING_POLICY : EXECUTING_POLICY;
+  }
+  getToolMetadata(toolNames) {
+    return Array.from(new Set(toolNames)).sort().map((name) => this.inferToolMeta(name));
+  }
+  buildPromptAppend(toolNames, transition) {
+    const mode = this.mode;
+    const policy = this.getModePolicy(mode);
+    const toolMeta = this.getToolMetadata(toolNames);
+    const shownTools = toolMeta.slice(0, 40);
+    const omittedCount = toolMeta.length - shownTools.length;
+    const lines = [
+      "## Plan Mode Policy (Built-in Plugin)",
+      `Current mode: ${mode.toUpperCase()}`,
+      `Allowed tool categories: ${policy.allowedCategories.join(", ")}`,
+      `Disallowed tool categories: ${policy.disallowedCategories.join(", ") || "none"}`,
+      policy.notes ? `Policy notes: ${policy.notes}` : ""
+    ].filter(Boolean);
+    if (mode === "planning") {
+      lines.push(
+        "Planning objective: prioritize reading, analysis, and plan generation.",
+        "In planning mode, do not intentionally perform write/edit/execute actions.",
+        "If implementation is requested but intent is not explicit, ask for execution authorization.",
+        "Before each tool call in planning mode, self-check category compliance.",
+        "Plan format must include: goals, assumptions, steps, risks, validation approach."
+      );
+    } else {
+      lines.push(
+        "Executing objective: follow the agreed plan before broad exploration.",
+        "Make targeted edits and keep changes scoped.",
+        "Report what changed and how it was validated."
+      );
+    }
+    if (transition?.switched && transition.modeAfter === "executing") {
+      lines.push(
+        "Mode transition: the latest user message explicitly authorized execution.",
+        "In your next reply, acknowledge switching to EXECUTING mode before implementation details."
+      );
+    }
+    lines.push("Tool metadata (prompt-level policy reference):");
+    for (const meta of shownTools) {
+      lines.push(`- ${meta.name}: category=${meta.category}, risk=${meta.risk}, ${meta.description}`);
+    }
+    if (omittedCount > 0) {
+      lines.push(`- ... ${omittedCount} additional tool(s) omitted for brevity.`);
+    }
+    return lines.join("\n");
+  }
+  applyHooks(baseHooks) {
+    return {
+      onBeforeToolCall: async (name, input) => {
+        this.observePotentialPolicyViolation(name, input);
+        if (baseHooks?.onBeforeToolCall) {
+          const nextInput = await baseHooks.onBeforeToolCall(name, input);
+          return nextInput ?? input;
+        }
+        return input;
+      },
+      onAfterToolCall: async (name, input, output) => {
+        if (baseHooks?.onAfterToolCall) {
+          const nextOutput = await baseHooks.onAfterToolCall(name, input, output);
+          return nextOutput ?? output;
+        }
+        return output;
+      }
+    };
+  }
+  getEvents(limit = 50) {
+    return this.events.slice(-Math.max(0, limit));
+  }
+  observePotentialPolicyViolation(toolName, input) {
+    if (this.mode !== "planning") {
+      return;
+    }
+    const meta = this.inferToolMeta(toolName);
+    const policy = this.getModePolicy("planning");
+    if (!policy.disallowedCategories.includes(meta.category)) {
+      return;
+    }
+    this.emitEvent("disallowed_tool_attempt_in_planning", {
+      toolName,
+      category: meta.category,
+      risk: meta.risk,
+      input
+    });
+  }
+  inferToolMeta(name) {
+    const knownMeta = KNOWN_TOOL_META[name];
+    if (knownMeta) {
+      return {
+        name,
+        ...knownMeta
+      };
+    }
+    if (name.startsWith("mcp_")) {
+      return {
+        name,
+        category: "execute",
+        risk: "medium",
+        description: "MCP external tool invocation."
+      };
+    }
+    if (name.endsWith("_agent")) {
+      return {
+        name,
+        category: "execute",
+        risk: "high",
+        description: "Sub-agent task execution tool."
+      };
+    }
+    if (/read|list|cat/i.test(name)) {
+      return {
+        name,
+        category: "read",
+        risk: "low",
+        description: "Likely a read-only inspection tool inferred by name."
+      };
+    }
+    if (/search|find|query|grep/i.test(name)) {
+      return {
+        name,
+        category: "search",
+        risk: "low",
+        description: "Likely a search tool inferred by name."
+      };
+    }
+    if (/write|edit|patch|update|create|delete|remove/i.test(name)) {
+      return {
+        name,
+        category: "write",
+        risk: "high",
+        description: "Likely a file-modifying tool inferred by name."
+      };
+    }
+    if (/bash|exec|run|shell|deploy|build|test/i.test(name)) {
+      return {
+        name,
+        category: "execute",
+        risk: "high",
+        description: "Likely a command execution tool inferred by name."
+      };
+    }
+    return {
+      name,
+      category: "other",
+      risk: "low",
+      description: "Tool category could not be inferred with high confidence."
+    };
+  }
+  getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      const message = messages[i];
+      if (message.role !== "user") {
+        continue;
+      }
+      return this.messageContentToText(message.content);
+    }
+    return "";
+  }
+  messageContentToText(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    const textParts = [];
+    for (const part of content) {
+      if (typeof part === "string") {
+        textParts.push(part);
+        continue;
+      }
+      if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+        textParts.push(part.text);
+      }
+    }
+    return textParts.join("\n");
+  }
+  emitEvent(name, payload) {
+    const event = {
+      name,
+      mode: this.mode,
+      timestamp: Date.now(),
+      payload
+    };
+    this.events.push(event);
+    if (this.events.length > 500) {
+      this.events.shift();
+    }
+    this.eventEmitter.emit(name, event);
+    this.eventEmitter.emit("plan_mode_event", event);
+    if (name === "disallowed_tool_attempt_in_planning") {
+      this.logger.warn("[PlanMode] Soft violation detected in planning mode", payload);
+      return;
+    }
+    this.logger.info(`[PlanMode] ${name}`, payload);
+  }
+};
+var builtInPlanModePlugin = {
+  name: "pulse-coder-engine/built-in-plan-mode",
+  version: "1.0.0",
+  async initialize(context) {
+    const service = new BuiltInPlanModeService(context.logger, context.events, "executing");
+    context.registerRunHook("plan-mode", ({ context: runContext, tools, systemPrompt, hooks }) => {
+      const transition = service.processContextMessages(runContext.messages);
+      const append = service.buildPromptAppend(Object.keys(tools), transition);
+      const finalSystemPrompt = appendSystemPrompt(systemPrompt, append);
+      return {
+        systemPrompt: finalSystemPrompt,
+        hooks: service.applyHooks(hooks)
+      };
+    });
+    context.registerService("planMode", service);
+    context.registerService("planModeService", service);
+    context.logger.info("[PlanMode] Built-in plan mode plugin initialized", {
+      mode: service.getMode()
+    });
+  }
+};
+
 // src/built-in/sub-agent-plugin/index.ts
 var import_zod10 = require("zod");
-var import_fs8 = require("fs");
-var import_path2 = __toESM(require("path"), 1);
+var import_fs9 = require("fs");
+var import_path3 = __toESM(require("path"), 1);
 
 // src/ai/index.ts
 var import_ai = require("ai");
@@ -309,8 +711,9 @@ var CLARIFICATION_TIMEOUT = Number(process.env.CLARIFICATION_TIMEOUT ?? 3e5);
 var CLARIFICATION_ENABLED = process.env.CLARIFICATION_ENABLED !== "false";
 
 // src/prompt/system.ts
-var generateSystemPrompt = () => {
-  const basePrompt = `
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var DEFAULT_PROMPT = `
 You are Pulse Coder, the best coding agent on the planet.
 
 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.
@@ -390,7 +793,7 @@ Use the 'clarify' tool when you genuinely need information from the user to proc
 - Explain briefly what would change based on the answer
 
 Example usage: Call clarify with a question, optional context, and optional default answer. The tool will pause and wait for the user's response.
-- For substantial work, summarize clearly; follow final\u2011answer formatting.
+- For substantial work, summarize clearly; follow final-answer formatting.
 - Skip heavy formatting for simple confirmations.
 - Don't dump large files you've written; reference paths only.
 - No "save/copy this file" - User is on the same machine.
@@ -404,19 +807,19 @@ Example usage: Call clarify with a question, optional context, and optional defa
 ## Final answer structure and style guidelines
 
 - Plain text; CLI handles styling. Use structure only when it helps scanability.
-- Headers: optional; short Title Case (1-3 words) wrapped in **\u2026**; no blank line before the first bullet; add only if they truly help.
-- Bullets: use - ; merge related points; keep to one line when possible; 4\u20136 per list ordered by importance; keep phrasing consistent.
+- Headers: optional; short Title Case (1-3 words) wrapped in **...**; no blank line before the first bullet; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4-6 per list ordered by importance; keep phrasing consistent.
 - Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
 - Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
-- Structure: group related bullets; order sections general \u2192 specific \u2192 supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
-- Tone: collaborative, concise, factual; present tense, active voice; self\u2011contained; no "above/below"; parallel wording.
-- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short\u2014wrap/reformat if long; avoid naming formatting styles in answers.
-- Adaptation: code explanations \u2192 precise, structured with code refs; simple tasks \u2192 lead with outcome; big changes \u2192 logical walkthrough + rationale + next actions; casual one-offs \u2192 plain sentences, no headers/bullets.
+- Structure: group related bullets; order sections general -> specific -> supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short-wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations -> precise, structured with code refs; simple tasks -> lead with outcome; big changes -> logical walkthrough + rationale + next actions; casual one-offs -> plain sentences, no headers/bullets.
 - File References: When referencing files in your response follow the below rules:
   * Use inline code to make file paths clickable.
   * Each reference should have a stand alone path. Even if it's the same file.
-  * Accepted: absolute, workspace\u2011relative, a/ or b/ diff prefixes, or bare filename/suffix.
-  * Optionally include line/column (1\u2011based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
+  * Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
+  * Optionally include line/column (1-based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
   * Do not use URIs like file://, vscode://, or https://.
   * Do not provide range of lines
   * Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repoprojectmain.rs:12:5
@@ -430,7 +833,24 @@ Here is some useful information about the environment you are running in:
 <files>
 
 </files>`;
-  return basePrompt;
+var AGENTS_FILE_REGEX = /^agents\.md$/i;
+var loadAgentsPrompt = () => {
+  try {
+    const cwd = process.cwd();
+    const entries = import_fs3.default.readdirSync(cwd, { withFileTypes: true });
+    const target = entries.find((entry) => entry.isFile() && AGENTS_FILE_REGEX.test(entry.name));
+    if (!target) {
+      return null;
+    }
+    const filePath = import_path.default.join(cwd, target.name);
+    const content = import_fs3.default.readFileSync(filePath, "utf8").trim();
+    return content.length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+};
+var generateSystemPrompt = () => {
+  return loadAgentsPrompt() ?? DEFAULT_PROMPT;
 };
 
 // src/ai/index.ts
@@ -742,7 +1162,7 @@ function sleep(ms) {
 
 // src/tools/read.ts
 var import_zod2 = __toESM(require("zod"), 1);
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 
 // src/tools/utils.ts
 var truncateOutput = (output) => {
@@ -768,14 +1188,14 @@ var ReadTool = {
     limit: import_zod2.default.number().optional().describe("The number of lines to read. Only provide if the file is too large to read at once.")
   }),
   execute: async ({ filePath, offset, limit }) => {
-    if (!(0, import_fs3.existsSync)(filePath)) {
+    if (!(0, import_fs4.existsSync)(filePath)) {
       throw new Error(`File does not exist: ${filePath}`);
     }
-    const stats = (0, import_fs3.statSync)(filePath);
+    const stats = (0, import_fs4.statSync)(filePath);
     if (stats.isDirectory()) {
       throw new Error(`Cannot read directory: ${filePath}. Use 'ls' tool to list directory contents.`);
     }
-    const content = (0, import_fs3.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
     const lines = content.split("\n");
     const totalLines = lines.length;
     if (offset === void 0 && limit === void 0) {
@@ -803,8 +1223,8 @@ var ReadTool = {
 
 // src/tools/write.ts
 var import_zod3 = __toESM(require("zod"), 1);
-var import_fs4 = require("fs");
-var import_path = require("path");
+var import_fs5 = require("fs");
+var import_path2 = require("path");
 var WriteTool = {
   name: "write",
   description: "Write contents to a file. Automatically creates parent directories if they do not exist. Will overwrite existing files.",
@@ -813,12 +1233,12 @@ var WriteTool = {
     content: import_zod3.default.string().describe("The content to write to the file")
   }),
   execute: async ({ filePath, content }) => {
-    const fileExists = (0, import_fs4.existsSync)(filePath);
-    const dir = (0, import_path.dirname)(filePath);
-    if (!(0, import_fs4.existsSync)(dir)) {
-      (0, import_fs4.mkdirSync)(dir, { recursive: true });
+    const fileExists = (0, import_fs5.existsSync)(filePath);
+    const dir = (0, import_path2.dirname)(filePath);
+    if (!(0, import_fs5.existsSync)(dir)) {
+      (0, import_fs5.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs4.writeFileSync)(filePath, content, "utf-8");
+    (0, import_fs5.writeFileSync)(filePath, content, "utf-8");
     const bytes = Buffer.byteLength(content, "utf-8");
     return {
       success: true,
@@ -830,7 +1250,7 @@ var WriteTool = {
 
 // src/tools/edit.ts
 var import_zod4 = __toESM(require("zod"), 1);
-var import_fs5 = require("fs");
+var import_fs6 = require("fs");
 var EditTool = {
   name: "edit",
   description: "Performs exact string replacements in files. Use this to edit existing files by replacing old_string with new_string.",
@@ -844,7 +1264,7 @@ var EditTool = {
     if (oldString === newString) {
       throw new Error("old_string and new_string must be different");
     }
-    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
     if (!content.includes(oldString)) {
       throw new Error(`old_string not found in file: ${filePath}`);
     }
@@ -868,7 +1288,7 @@ var EditTool = {
       newContent = content.slice(0, index) + newString + content.slice(index + oldString.length);
       replacements = 1;
     }
-    (0, import_fs5.writeFileSync)(filePath, newContent, "utf-8");
+    (0, import_fs6.writeFileSync)(filePath, newContent, "utf-8");
     const changedIndex = newContent.indexOf(newString);
     const contextLength = 200;
     const start = Math.max(0, changedIndex - contextLength);
@@ -887,7 +1307,7 @@ var EditTool = {
 // src/tools/grep.ts
 var import_zod5 = __toESM(require("zod"), 1);
 var import_child_process = require("child_process");
-var import_fs6 = require("fs");
+var import_fs7 = require("fs");
 var GrepTool = {
   name: "grep",
   description: "A powerful search tool built on ripgrep. Supports regex patterns, file filtering, and multiple output modes.",
@@ -905,7 +1325,7 @@ var GrepTool = {
   }),
   execute: async ({
     pattern,
-    path: path3 = ".",
+    path: path4 = ".",
     glob,
     type,
     outputMode = "files_with_matches",
@@ -940,11 +1360,11 @@ var GrepTool = {
     if (type) {
       args.push("--type", type);
     }
-    if (path3 && path3 !== ".") {
-      if (!(0, import_fs6.existsSync)(path3)) {
-        throw new Error(`Path does not exist: ${path3}`);
+    if (path4 && path4 !== ".") {
+      if (!(0, import_fs7.existsSync)(path4)) {
+        throw new Error(`Path does not exist: ${path4}`);
       }
-      args.push(path3);
+      args.push(path4);
     }
     let command = args.map((arg) => {
       if (arg.includes(" ") || arg.includes("$") || arg.includes("*")) {
@@ -992,15 +1412,15 @@ Command: ${command}`
 
 // src/tools/ls.ts
 var import_zod6 = __toESM(require("zod"), 1);
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var LsTool = {
   name: "ls",
   description: "List files and directories in a given path",
   inputSchema: import_zod6.default.object({
     path: import_zod6.default.string().optional().describe("The path to list files from (defaults to current directory)")
   }),
-  execute: async ({ path: path3 = "." }) => {
-    const files = (0, import_fs7.readdirSync)(path3);
+  execute: async ({ path: path4 = "." }) => {
+    const files = (0, import_fs8.readdirSync)(path4);
     return { files };
   }
 };
@@ -1171,8 +1591,8 @@ var ConfigLoader = class {
     const fileInfos = [];
     for (let configDir of configDirs) {
       try {
-        await import_fs8.promises.access(configDir);
-        const files = await import_fs8.promises.readdir(configDir);
+        await import_fs9.promises.access(configDir);
+        const files = await import_fs9.promises.readdir(configDir);
         fileInfos.push({ files, configDir });
       } catch {
         continue;
@@ -1189,7 +1609,7 @@ var ConfigLoader = class {
         const files = fileInfo.files;
         for (const file of files) {
           if (file.endsWith(".md")) {
-            const config = await this.parseConfig(import_path2.default.join(fileInfo.configDir, file));
+            const config = await this.parseConfig(import_path3.default.join(fileInfo.configDir, file));
             if (config) configs.push(config);
           }
         }
@@ -1201,7 +1621,7 @@ var ConfigLoader = class {
   }
   async parseConfig(filePath) {
     try {
-      const content = await import_fs8.promises.readFile(filePath, "utf-8");
+      const content = await import_fs9.promises.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let name = "";
       let description = "";
@@ -1230,7 +1650,7 @@ var ConfigLoader = class {
         }
       }
       if (!name) {
-        name = import_path2.default.basename(filePath, ".md");
+        name = import_path3.default.basename(filePath, ".md");
       }
       return {
         name: name.trim(),
@@ -1313,14 +1733,17 @@ var SubAgentPlugin = class {
 var builtInPlugins = [
   builtInMCPPlugin,
   builtInSkillsPlugin,
+  builtInPlanModePlugin,
   new SubAgentPlugin()
 ];
 var built_in_default = builtInPlugins;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BuiltInPlanModeService,
   BuiltInSkillRegistry,
   SubAgentPlugin,
   builtInMCPPlugin,
+  builtInPlanModePlugin,
   builtInPlugins,
   builtInSkillsPlugin
 });