@mastra/code-sdk 0.0.0-client-tool-results-20260912062135

package/dist/agents/prompts/index.js

@@ -0,0 +1,119 @@
+import { loadSettings, resolveLspSetting } from "../../onboarding/settings.js";
+import { buildModePrompt, buildModePromptFn } from "./build.js";
+import { getLocalPlansRelativeDir } from "../../utils/plans.js";
+import { planModePrompt } from "./plan.js";
+import { fastModePrompt } from "./fast.js";
+import { MC_TOOLS } from "../../tool-names.js";
+import { hasParallelKey, hasTavilyKey } from "../../tools/web-search.js";
+import "../../tools/index.js";
+import { AGENT_INSTRUCTIONS_HEADING, createGitRefInstructionReader, formatInstructionSource, loadAgentInstructions } from "./agent-instructions.js";
+import { modelSpecificPrompts } from "./model.js";
+import { buildToolGuidance } from "./tool-guidance.js";
+import { buildBasePrompt } from "@mastra/core/coding-agent";
+//#region src/agents/prompts/index.ts
+const modePrompts = {
+	build: buildModePromptFn,
+	plan: planModePrompt,
+	fast: fastModePrompt
+};
+/** Join prompt sections into the final system prompt string. */
+function joinPromptSections(sections) {
+	return sections.map((section) => section.content).filter(Boolean).join("\n\n");
+}
+/**
+* Build the full system prompt for a given mode and context.
+* Combines the base prompt with mode-specific instructions.
+*/
+function buildFullPrompt(ctx) {
+	return joinPromptSections(buildFullPromptSections(ctx));
+}
+/**
+* Build the system prompt as labeled sections. `buildFullPrompt` is the join of
+* these, so the two can never disagree about what the model receives.
+*/
+function buildFullPromptSections(ctx) {
+	const modelId = ctx.modelId;
+	const hasWebSearch = hasParallelKey() || hasTavilyKey() || !!modelId && (modelId.startsWith("anthropic/") || modelId.startsWith("openai/"));
+	const deniedTools = /* @__PURE__ */ new Set();
+	const permRules = ctx.state?.permissionRules;
+	if (permRules?.tools) {
+		for (const [name, policy] of Object.entries(permRules.tools)) if (policy === "deny") deniedTools.add(name);
+	}
+	if (resolveLspSetting(loadSettings().lsp) === false) deniedTools.add(MC_TOOLS.LSP_INSPECT);
+	const factoryProjectId = typeof ctx.state?.factoryProjectId === "string" ? ctx.state.factoryProjectId : void 0;
+	const toolGuidance = buildToolGuidance(ctx.modeId, {
+		hasWebSearch,
+		hasSubconscious: ctx.hasSubconscious === true,
+		hasSubagents: ctx.hasSubagents,
+		deniedTools,
+		plansDir: getLocalPlansRelativeDir({ factoryProjectId })
+	});
+	const base = buildBasePrompt({
+		projectPath: ctx.workingDir || "(no workspace attached)",
+		projectName: ctx.projectName || "unknown",
+		gitBranch: ctx.gitBranch,
+		platform: process.platform,
+		commonBinaries: ctx.commonBinaries,
+		date: ctx.currentDate,
+		mode: ctx.modeId,
+		modelId: ctx.modelId,
+		activePlan: ctx.state?.activePlan,
+		hasSubagents: ctx.hasSubagents !== false && !deniedTools.has("subagent"),
+		toolGuidance
+	});
+	const entry = modePrompts[ctx.modeId] || modePrompts.build;
+	const modeSpecific = (typeof entry === "function" ? entry(ctx) : entry) ?? "";
+	const modelSpecific = ctx.modelId ? modelSpecificPrompts[ctx.modelId] ?? "" : "";
+	const configDir = ctx.state?.configDir;
+	const untrustedCheckout = ctx.state?.untrustedCheckout === true;
+	const skipGlobalInstructions = ctx.state?.skipGlobalInstructions === true;
+	const baseRef = typeof ctx.state?.baseRef === "string" ? ctx.state.baseRef : void 0;
+	const projectReader = untrustedCheckout ? baseRef ? createGitRefInstructionReader(ctx.workingDir, baseRef) : {
+		exists: () => false,
+		read: () => ""
+	} : void 0;
+	const instructionSources = ctx.workingDir ? loadAgentInstructions(ctx.workingDir, configDir, projectReader, { skipGlobal: skipGlobalInstructions }) : [];
+	const instructionSections = instructionSources.map((source, index) => {
+		const isFirst = index === 0;
+		const isLast = index === instructionSources.length - 1;
+		let content = formatInstructionSource(source);
+		if (isFirst) content = `${AGENT_INSTRUCTIONS_HEADING}\n\n${content}`;
+		if (isLast) content = content.trimEnd();
+		return {
+			id: `agent-instructions:${source.path}:${index}`,
+			label: `${source.scope === "global" ? "Global" : "Project"} instructions`,
+			detail: source.ref ? `${source.path} (at ref ${source.ref})` : source.path,
+			content
+		};
+	});
+	const hostInstructions = ctx.hostInstructions?.trim() ?? "";
+	return [
+		{
+			id: "base-prompt",
+			label: "Base system prompt",
+			content: base
+		},
+		{
+			id: "host-instructions",
+			label: "Host instructions",
+			content: hostInstructions
+		},
+		...instructionSections,
+		{
+			id: "model-prompt",
+			label: "Model-specific prompt",
+			detail: ctx.modelId,
+			content: modelSpecific.trim()
+		},
+		{
+			id: "mode-prompt",
+			label: "Mode prompt",
+			detail: ctx.modeId,
+			content: modeSpecific.trim()
+		}
+	].filter((section) => Boolean(section.content));
+}
+//#endregion
+export { buildFullPrompt, buildFullPromptSections, buildModePrompt, buildModePromptFn, fastModePrompt, joinPromptSections, planModePrompt };
+
+//# sourceMappingURL=index.js.map

package/dist/agents/prompts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/prompts/index.ts"],"sourcesContent":["/**\n * Prompt system — exports the prompt builder and mode-specific prompts.\n */\n\nexport { buildModePrompt, buildModePromptFn } from './build.js';\nexport { planModePrompt } from './plan.js';\nexport { fastModePrompt } from './fast.js';\n\nimport { buildBasePrompt } from '@mastra/core/coding-agent';\nimport type { PromptContext as BasePromptContext } from '@mastra/core/coding-agent';\nimport { loadSettings, resolveLspSetting } from '../../onboarding/settings.js';\nimport { MC_TOOLS } from '../../tool-names.js';\nimport { hasParallelKey, hasTavilyKey } from '../../tools/index.js';\nimport { getLocalPlansRelativeDir } from '../../utils/plans.js';\nimport {\n  loadAgentInstructions,\n  formatInstructionSource,\n  createGitRefInstructionReader,\n  AGENT_INSTRUCTIONS_HEADING,\n} from './agent-instructions.js';\nimport { buildModePromptFn } from './build.js';\nimport { fastModePrompt } from './fast.js';\nimport { modelSpecificPrompts } from './model.js';\nimport { planModePrompt } from './plan.js';\nimport { buildToolGuidance } from './tool-guidance.js';\n\n// Extended prompt context that includes runtime information\nexport interface PromptContext extends Omit<BasePromptContext, 'toolGuidance'> {\n  modeId: string;\n  state?: any;\n  /** The subconscious knowledge tools are registered on the agent. */\n  hasSubconscious?: boolean;\n  hostInstructions?: string;\n  currentDate: string;\n  workingDir: string;\n}\n\nconst modePrompts: Record<string, string | ((ctx: PromptContext) => string)> = {\n  build: buildModePromptFn,\n  plan: planModePrompt,\n  fast: fastModePrompt,\n};\n\n/**\n * One labeled piece of the assembled system prompt.\n *\n * The system prompt is a single string by the time it reaches the model, which\n * makes it impossible to say which configuration source is responsible for\n * which share of the context window. Building it as labeled sections and\n * joining them at the end keeps that attribution available to the `/context`\n * audit while guaranteeing the audit measures the exact text that is sent —\n * a parallel \"describe the prompt\" path would drift and report numbers for a\n * prompt that is no longer assembled this way.\n */\nexport interface PromptSection {\n  /** Stable identifier, unique within a single build. */\n  id: string;\n  /** Human-readable label for display. */\n  label: string;\n  /** Optional provenance (e.g. the instruction file path). */\n  detail?: string;\n  /** The exact text contributed to the prompt. */\n  content: string;\n}\n\n/** Join prompt sections into the final system prompt string. */\nexport function joinPromptSections(sections: PromptSection[]): string {\n  return sections\n    .map(section => section.content)\n    .filter(Boolean)\n    .join('\\n\\n');\n}\n\n/**\n * Build the full system prompt for a given mode and context.\n * Combines the base prompt with mode-specific instructions.\n */\nexport function buildFullPrompt(ctx: PromptContext): string {\n  return joinPromptSections(buildFullPromptSections(ctx));\n}\n\n/**\n * Build the system prompt as labeled sections. `buildFullPrompt` is the join of\n * these, so the two can never disagree about what the model receives.\n */\nexport function buildFullPromptSections(ctx: PromptContext): PromptSection[] {\n  // Determine whether web search tools are available\n  const modelId = ctx.modelId;\n  const hasWebSearch =\n    hasParallelKey() ||\n    hasTavilyKey() ||\n    (!!modelId && (modelId.startsWith('anthropic/') || modelId.startsWith('openai/')));\n\n  // Collect per-tool deny rules so guidance omits denied tools\n  const deniedTools = new Set<string>();\n  const permRules = ctx.state?.permissionRules as { tools?: Record<string, string> } | undefined;\n  if (permRules?.tools) {\n    for (const [name, policy] of Object.entries(permRules.tools)) {\n      if (policy === 'deny') deniedTools.add(name);\n    }\n  }\n\n  // LSP is opt-in — when it is off the tool is never registered, so its\n  // guidance must not be advertised either.\n  if (resolveLspSetting(loadSettings().lsp) === false) deniedTools.add(MC_TOOLS.LSP_INSPECT);\n\n  // Build mode-aware tool guidance\n  const factoryProjectId = typeof ctx.state?.factoryProjectId === 'string' ? ctx.state.factoryProjectId : undefined;\n  const toolGuidance = buildToolGuidance(ctx.modeId, {\n    hasWebSearch,\n    hasSubconscious: ctx.hasSubconscious === true,\n    hasSubagents: ctx.hasSubagents,\n    deniedTools,\n    plansDir: getLocalPlansRelativeDir({ factoryProjectId }),\n  });\n\n  // Map new context to base context\n  const baseCtx: BasePromptContext = {\n    projectPath: ctx.workingDir || '(no workspace attached)',\n    projectName: ctx.projectName || 'unknown',\n    gitBranch: ctx.gitBranch,\n    platform: process.platform,\n    commonBinaries: ctx.commonBinaries,\n    date: ctx.currentDate,\n    mode: ctx.modeId,\n    modelId: ctx.modelId,\n    activePlan: ctx.state?.activePlan,\n    hasSubagents: ctx.hasSubagents !== false && !deniedTools.has('subagent'),\n    toolGuidance,\n  };\n\n  const base = buildBasePrompt(baseCtx);\n  const entry = modePrompts[ctx.modeId] || modePrompts.build;\n  const modeSpecific = (typeof entry === 'function' ? entry(ctx) : entry) ?? '';\n  const modelSpecific = ctx.modelId\n    ? (modelSpecificPrompts[ctx.modelId as keyof typeof modelSpecificPrompts] ?? '')\n    : '';\n\n  // The current task list is carried on the agent state-signal lane (see\n  // TaskStateProcessor) rather than injected into the cached system prompt. This\n  // keeps the prompt prefix stable across task updates (preserving prompt cache)\n  // while still surviving observational-memory truncation.\n\n  // Load and inject agent instructions from AGENTS.md/CLAUDE.md files.\n  // Untrusted checkouts (e.g. a PR branch under review) never read\n  // project-scope files off the working tree: their AGENTS.md is\n  // attacker-writable and would otherwise land in the system prompt as\n  // trusted configuration. When the session carries a trusted base ref, the\n  // project instructions are served from that ref instead (`git show`);\n  // without one, project-scope files are skipped entirely. Home-directory\n  // (global) instructions belong to whoever owns the machine, so hosts that\n  // run sessions for someone else opt out of them entirely.\n  const configDir = ctx.state?.configDir as string | undefined;\n  const untrustedCheckout = ctx.state?.untrustedCheckout === true;\n  const skipGlobalInstructions = ctx.state?.skipGlobalInstructions === true;\n  const baseRef = typeof ctx.state?.baseRef === 'string' ? ctx.state.baseRef : undefined;\n  const projectReader = untrustedCheckout\n    ? baseRef\n      ? createGitRefInstructionReader(ctx.workingDir, baseRef)\n      : { exists: () => false, read: () => '' }\n    : undefined;\n  // No working directory means a hosted session with no project attached:\n  // load NO instruction files at all — project locations would resolve\n  // against the server's own cwd, and global locations against the server's\n  // homedir. Neither belongs in a hosted session's prompt.\n  const instructionSources = ctx.workingDir\n    ? loadAgentInstructions(ctx.workingDir, configDir, projectReader, {\n        skipGlobal: skipGlobalInstructions,\n      })\n    : [];\n  // Emitted per source so each AGENTS.md/CLAUDE.md can be costed individually.\n  // The heading rides on the first source's section, which is exactly how\n  // `formatAgentInstructions` lays the block out, so joining the sections\n  // reproduces its output byte for byte.\n  const instructionSections: PromptSection[] = instructionSources.map((source, index) => {\n    const isFirst = index === 0;\n    const isLast = index === instructionSources.length - 1;\n    let content = formatInstructionSource(source);\n    if (isFirst) content = `${AGENT_INSTRUCTIONS_HEADING}\\n\\n${content}`;\n    // The block as a whole used to be trimmed, which only ever affected the\n    // trailing whitespace of the final source's content.\n    if (isLast) content = content.trimEnd();\n    return {\n      id: `agent-instructions:${source.path}:${index}`,\n      label: `${source.scope === 'global' ? 'Global' : 'Project'} instructions`,\n      detail: source.ref ? `${source.path} (at ref ${source.ref})` : source.path,\n      content,\n    };\n  });\n\n  const hostInstructions = ctx.hostInstructions?.trim() ?? '';\n\n  return [\n    { id: 'base-prompt', label: 'Base system prompt', content: base },\n    { id: 'host-instructions', label: 'Host instructions', content: hostInstructions },\n    ...instructionSections,\n    { id: 'model-prompt', label: 'Model-specific prompt', detail: ctx.modelId, content: modelSpecific.trim() },\n    { id: 'mode-prompt', label: 'Mode prompt', detail: ctx.modeId, content: modeSpecific.trim() },\n  ].filter(section => Boolean(section.content));\n}\n"],"mappings":"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"}

package/dist/agents/prompts/model.d.ts

@@ -0,0 +1,5 @@
+export declare const modelSpecificPrompts: {
+    'openai/gpt-5.4': string;
+    'openai/gpt-5.5': string;
+};
+//# sourceMappingURL=model.d.ts.map

package/dist/agents/prompts/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/agents/prompts/model.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB;;;CAiBhC,CAAC"}

package/dist/agents/prompts/model.js

@@ -0,0 +1,23 @@
+//#region src/agents/prompts/model.ts
+const modelSpecificPrompts = {
+	"openai/gpt-5.4": `<autonomy_and_persistence>
+Persist until the task is fully handled end-to-end within the current turn whenever feasible: do not stop at analysis or partial fixes; carry changes through implementation, verification, and a clear explanation of outcomes unless the user explicitly pauses or redirects you.
+
+Unless the user explicitly asks for a plan, asks a question about the code, is brainstorming potential solutions, or some other intent that makes it clear that code should not be written, assume the user wants you to make code changes or run tools to solve the user's problem. In these cases, it's bad to output your proposed solution in a message, you should go ahead and actually implement the change. If you encounter challenges or blockers, you should attempt to resolve them yourself.
+</autonomy_and_persistence>
+`,
+	"openai/gpt-5.5": `<coding_behavior>
+Work outcome-first: infer the user's goal, define what "done" means from the request and repo context, then choose an efficient path that reaches that outcome without sacrificing correctness, maintainability, or proof.
+
+For non-trivial multi-step or tool-heavy tasks, start with a short visible preamble that acknowledges the request and states the first action. Skip the preamble for direct answers and tiny edits. Keep later updates tied to meaningful decisions, findings, or results so the user and memory have useful context.
+
+Use efficient retrieval. Read enough code, docs, logs, and command output to act correctly, including neighboring implementations when conventions matter. Stop searching once you have sufficient evidence, but do not let brevity outrank correctness, security, or compatibility with existing patterns.
+
+For coding work, make focused changes that follow the surrounding conventions. Avoid unrequested features, broad refactors, speculative error handling, and comments that only explain the diff.
+</coding_behavior>
+`
+};
+//#endregion
+export { modelSpecificPrompts };
+
+//# sourceMappingURL=model.js.map

package/dist/agents/prompts/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","names":[],"sources":["../../../src/agents/prompts/model.ts"],"sourcesContent":["export const modelSpecificPrompts = {\n  'openai/gpt-5.4': `<autonomy_and_persistence>\nPersist until the task is fully handled end-to-end within the current turn whenever feasible: do not stop at analysis or partial fixes; carry changes through implementation, verification, and a clear explanation of outcomes unless the user explicitly pauses or redirects you.\n\nUnless the user explicitly asks for a plan, asks a question about the code, is brainstorming potential solutions, or some other intent that makes it clear that code should not be written, assume the user wants you to make code changes or run tools to solve the user's problem. In these cases, it's bad to output your proposed solution in a message, you should go ahead and actually implement the change. If you encounter challenges or blockers, you should attempt to resolve them yourself.\n</autonomy_and_persistence>\n`,\n  'openai/gpt-5.5': `<coding_behavior>\nWork outcome-first: infer the user's goal, define what \"done\" means from the request and repo context, then choose an efficient path that reaches that outcome without sacrificing correctness, maintainability, or proof.\n\nFor non-trivial multi-step or tool-heavy tasks, start with a short visible preamble that acknowledges the request and states the first action. Skip the preamble for direct answers and tiny edits. Keep later updates tied to meaningful decisions, findings, or results so the user and memory have useful context.\n\nUse efficient retrieval. Read enough code, docs, logs, and command output to act correctly, including neighboring implementations when conventions matter. Stop searching once you have sufficient evidence, but do not let brevity outrank correctness, security, or compatibility with existing patterns.\n\nFor coding work, make focused changes that follow the surrounding conventions. Avoid unrequested features, broad refactors, speculative error handling, and comments that only explain the diff.\n</coding_behavior>\n`,\n};\n"],"mappings":";AAAA,MAAa,uBAAuB;CAClC,kBAAkB;;;;;;CAMlB,kBAAkB;;;;;;;;;;AAUpB"}

package/dist/agents/prompts/plan.d.ts

@@ -0,0 +1,6 @@
+interface PlanPromptContext {
+    state?: Record<string, unknown>;
+}
+export declare function planModePrompt(ctx: PlanPromptContext): string;
+export {};
+//# sourceMappingURL=plan.d.ts.map

package/dist/agents/prompts/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/agents/prompts/plan.ts"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAuG7D"}

package/dist/agents/prompts/plan.js

@@ -0,0 +1,111 @@
+import { getLocalPlansRelativeDir } from "../../utils/plans.js";
+//#region src/agents/prompts/plan.ts
+/**
+* Plan mode prompt — read-only exploration and planning.
+*/
+function planModePrompt(ctx) {
+	const plansDir = getLocalPlansRelativeDir({ factoryProjectId: typeof ctx.state?.factoryProjectId === "string" ? ctx.state.factoryProjectId : void 0 });
+	const examplePath = `${plansDir}/add-dark-mode.md`;
+	return `
+# Plan Mode — READ-ONLY (except plan files)
+
+You are in PLAN mode. Your job is to explore the codebase and design an implementation plan — NOT to make changes to the project.
+
+## CRITICAL: Read-Only Mode (project files)
+
+This mode is **read-only for project files**. You must NOT modify the project.
+
+- Do NOT modify, create, or delete project files
+- Do NOT run commands that change state (no git commit, no npm install, no file creation)
+- Do NOT run build commands, tests, or scripts that have side effects
+
+The ONE exception is plan files: you CAN create and edit markdown files inside \`${plansDir}/\` (e.g. \`${examplePath}\`). You may NOT write anywhere else.
+
+If the user asks you to make changes while in Plan mode, explain that you're in read-only mode and they should switch to Build mode (\`/mode build\`) first.
+
+## Exploration Strategy
+
+Before writing any plan, build a mental model of the codebase:
+1. Start with the directory structure (\`view\` on the project root or relevant subdirectory).
+2. Find the relevant entry points and core files using \`search_content\` and \`find_files\`.
+3. Read the actual code — don't assume based on file names alone.
+4. Trace data flow: where does input come from, how is it transformed, where does it go?
+5. Identify existing patterns the codebase uses (naming, structure, error handling, testing).
+
+## Goal-Ready Plans
+
+The submit_plan approval UI can let the user approve the plan normally or start it as a persistent goal. Write plans so they can be carried out as a goal if the user chooses that option:
+- Make the desired outcome explicit and verifiable.
+- Break work into ordered, actionable steps that can be executed autonomously.
+- Include constraints, risks, blockers, and decision points that may require user input.
+- Include concrete verification criteria so the goal judge can tell when the work is done.
+
+## Your Plan Output
+
+Produce a clear, step-by-step plan with this structure:
+
+### Overview
+One paragraph: what the change does and why.
+
+### Complexity Estimate
+- **Size**: Small (1-2 files) / Medium (3-5 files) / Large (6+ files)
+- **Risk**: Low (additive, no breaking changes) / Medium (modifies existing behavior) / High (architectural, affects many consumers)
+- **Dependencies**: List any new packages, external services, or migration steps needed.
+
+### Steps
+For each step:
+1. **File**: path to create or modify
+2. **Change**: what to add/modify/remove, with enough specificity to implement directly
+3. **Why**: brief rationale connecting this step to the overall goal
+
+### Verification
+- What tests to run
+- What to check manually
+- What could go wrong
+
+## Plan File Workflow
+
+Write each plan to its own markdown file under \`${plansDir}/\` (e.g. \`${examplePath}\`). Start the file with a \`# Title\` heading describing the plan.
+
+1. **First submission**: Write your plan to a file under \`${plansDir}/\` using \`write_file\`, then call \`submit_plan\` with the \`path\` to that file.
+2. **Reading**: Use \`view\` to read a plan file.
+3. **Editing**: Use \`string_replace_lsp\` for targeted edits to specific sections.
+
+**Reuse the same file while you keep iterating on the same plan.** Only create a NEW file when you're starting a genuinely different plan — that keeps each plan available to look back at and keeps revision diffs meaningful.
+
+## IMMEDIATE ACTION: Write plan file, then call submit_plan
+
+As soon as your plan is complete:
+1. Write it to a file under \`${plansDir}/\` using \`write_file\`
+2. Call \`submit_plan\` with the \`path\` to that file
+
+**CRITICAL:** Do NOT generate a long text response describing your plan. The plan content belongs in the plan file, not in your text output or the \`submit_plan\` arguments.
+
+\`\`\`javascript
+submit_plan({
+  path: "${examplePath}"
+})
+\`\`\`
+
+The user will see the plan rendered inline and can:
+- **Approve** — automatically switches to Build mode for implementation
+- **Start as goal** — approves the plan and enters goal mode so the agent keeps working toward the plan until judged complete, paused, or waiting for user input
+- **Request changes** — rejects the plan; the agent stops immediately and the user provides revision feedback in their next chat message
+
+## Revision Workflow
+
+If the user requests changes, you will be stopped immediately. Wait for their next message — it will contain their revision feedback. When you receive it:
+1. Use \`view\` to read the SAME plan file
+2. Use \`string_replace_lsp\` to make targeted edits based on feedback
+3. Use \`view\` to re-read the updated file
+4. Call \`submit_plan\` again with the same \`path\` — editing the file alone does NOT resubmit it
+
+The user will see a diff of what changed between the previous and revised plan. Use \`string_replace_lsp\` for targeted edits so the diff is clear and meaningful — do NOT rewrite the entire plan from scratch for small changes, and do NOT move the plan to a new file for a revision.
+
+Do NOT start implementing until the plan is approved.
+`;
+}
+//#endregion
+export { planModePrompt };
+
+//# sourceMappingURL=plan.js.map

package/dist/agents/prompts/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","names":[],"sources":["../../../src/agents/prompts/plan.ts"],"sourcesContent":["/**\n * Plan mode prompt — read-only exploration and planning.\n */\nimport { getLocalPlansRelativeDir } from '../../utils/plans.js';\n\ninterface PlanPromptContext {\n  state?: Record<string, unknown>;\n}\n\nexport function planModePrompt(ctx: PlanPromptContext): string {\n  const factoryProjectId = typeof ctx.state?.factoryProjectId === 'string' ? ctx.state.factoryProjectId : undefined;\n  const plansDir = getLocalPlansRelativeDir({ factoryProjectId });\n  const examplePath = `${plansDir}/add-dark-mode.md`;\n\n  return `\n# Plan Mode — READ-ONLY (except plan files)\n\nYou are in PLAN mode. Your job is to explore the codebase and design an implementation plan — NOT to make changes to the project.\n\n## CRITICAL: Read-Only Mode (project files)\n\nThis mode is **read-only for project files**. You must NOT modify the project.\n\n- Do NOT modify, create, or delete project files\n- Do NOT run commands that change state (no git commit, no npm install, no file creation)\n- Do NOT run build commands, tests, or scripts that have side effects\n\nThe ONE exception is plan files: you CAN create and edit markdown files inside \\`${plansDir}/\\` (e.g. \\`${examplePath}\\`). You may NOT write anywhere else.\n\nIf the user asks you to make changes while in Plan mode, explain that you're in read-only mode and they should switch to Build mode (\\`/mode build\\`) first.\n\n## Exploration Strategy\n\nBefore writing any plan, build a mental model of the codebase:\n1. Start with the directory structure (\\`view\\` on the project root or relevant subdirectory).\n2. Find the relevant entry points and core files using \\`search_content\\` and \\`find_files\\`.\n3. Read the actual code — don't assume based on file names alone.\n4. Trace data flow: where does input come from, how is it transformed, where does it go?\n5. Identify existing patterns the codebase uses (naming, structure, error handling, testing).\n\n## Goal-Ready Plans\n\nThe submit_plan approval UI can let the user approve the plan normally or start it as a persistent goal. Write plans so they can be carried out as a goal if the user chooses that option:\n- Make the desired outcome explicit and verifiable.\n- Break work into ordered, actionable steps that can be executed autonomously.\n- Include constraints, risks, blockers, and decision points that may require user input.\n- Include concrete verification criteria so the goal judge can tell when the work is done.\n\n## Your Plan Output\n\nProduce a clear, step-by-step plan with this structure:\n\n### Overview\nOne paragraph: what the change does and why.\n\n### Complexity Estimate\n- **Size**: Small (1-2 files) / Medium (3-5 files) / Large (6+ files)\n- **Risk**: Low (additive, no breaking changes) / Medium (modifies existing behavior) / High (architectural, affects many consumers)\n- **Dependencies**: List any new packages, external services, or migration steps needed.\n\n### Steps\nFor each step:\n1. **File**: path to create or modify\n2. **Change**: what to add/modify/remove, with enough specificity to implement directly\n3. **Why**: brief rationale connecting this step to the overall goal\n\n### Verification\n- What tests to run\n- What to check manually\n- What could go wrong\n\n## Plan File Workflow\n\nWrite each plan to its own markdown file under \\`${plansDir}/\\` (e.g. \\`${examplePath}\\`). Start the file with a \\`# Title\\` heading describing the plan.\n\n1. **First submission**: Write your plan to a file under \\`${plansDir}/\\` using \\`write_file\\`, then call \\`submit_plan\\` with the \\`path\\` to that file.\n2. **Reading**: Use \\`view\\` to read a plan file.\n3. **Editing**: Use \\`string_replace_lsp\\` for targeted edits to specific sections.\n\n**Reuse the same file while you keep iterating on the same plan.** Only create a NEW file when you're starting a genuinely different plan — that keeps each plan available to look back at and keeps revision diffs meaningful.\n\n## IMMEDIATE ACTION: Write plan file, then call submit_plan\n\nAs soon as your plan is complete:\n1. Write it to a file under \\`${plansDir}/\\` using \\`write_file\\`\n2. Call \\`submit_plan\\` with the \\`path\\` to that file\n\n**CRITICAL:** Do NOT generate a long text response describing your plan. The plan content belongs in the plan file, not in your text output or the \\`submit_plan\\` arguments.\n\n\\`\\`\\`javascript\nsubmit_plan({\n  path: \"${examplePath}\"\n})\n\\`\\`\\`\n\nThe user will see the plan rendered inline and can:\n- **Approve** — automatically switches to Build mode for implementation\n- **Start as goal** — approves the plan and enters goal mode so the agent keeps working toward the plan until judged complete, paused, or waiting for user input\n- **Request changes** — rejects the plan; the agent stops immediately and the user provides revision feedback in their next chat message\n\n## Revision Workflow\n\nIf the user requests changes, you will be stopped immediately. Wait for their next message — it will contain their revision feedback. When you receive it:\n1. Use \\`view\\` to read the SAME plan file\n2. Use \\`string_replace_lsp\\` to make targeted edits based on feedback\n3. Use \\`view\\` to re-read the updated file\n4. Call \\`submit_plan\\` again with the same \\`path\\` — editing the file alone does NOT resubmit it\n\nThe user will see a diff of what changed between the previous and revised plan. Use \\`string_replace_lsp\\` for targeted edits so the diff is clear and meaningful — do NOT rewrite the entire plan from scratch for small changes, and do NOT move the plan to a new file for a revision.\n\nDo NOT start implementing until the plan is approved.\n`;\n}\n"],"mappings":";;;;;AASA,SAAgB,eAAe,KAAgC;CAE7D,MAAM,WAAW,yBAAyB,EAAE,kBADnB,OAAO,IAAI,OAAO,qBAAqB,WAAW,IAAI,MAAM,mBAAmB,KAAA,EAC3C,CAAC;CAC9D,MAAM,cAAc,GAAG,SAAS;CAEhC,OAAO;;;;;;;;;;;;;mFAa0E,SAAS,cAAc,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA8CnE,SAAS,cAAc,YAAY;;6DAEzB,SAAS;;;;;;;;;gCAStC,SAAS;;;;;;;WAO9B,YAAY;;;;;;;;;;;;;;;;;;;;;AAqBvB"}

package/dist/agents/prompts/tool-guidance.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mode-specific tool behavioral guidance.
+ * Generates tool usage instructions that match the actual registered tool names
+ * and are scoped to what's available in the current mode.
+ */
+interface ToolGuidanceOptions {
+    hasWebSearch?: boolean;
+    hasSubagents?: boolean;
+    /** Subconscious knowledge tools are registered (experimental subconscious enabled). */
+    hasSubconscious?: boolean;
+    /** Tool names that have been denied — omit their guidance sections. */
+    deniedTools?: Set<string>;
+    /** Workspace-relative directory where plan mode can write plans. */
+    plansDir?: string;
+}
+export declare function buildToolGuidance(modeId: string, options?: ToolGuidanceOptions): string;
+export {};
+//# sourceMappingURL=tool-guidance.d.ts.map

package/dist/agents/prompts/tool-guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-guidance.d.ts","sourceRoot":"","sources":["../../../src/agents/prompts/tool-guidance.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,UAAU,mBAAmB;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uFAAuF;IACvF,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA+Q3F"}

package/dist/agents/prompts/tool-guidance.js

@@ -0,0 +1,180 @@
+import { MC_TOOLS } from "../../tool-names.js";
+//#region src/agents/prompts/tool-guidance.ts
+/**
+* Mode-specific tool behavioral guidance.
+* Generates tool usage instructions that match the actual registered tool names
+* and are scoped to what's available in the current mode.
+*/
+function buildToolGuidance(modeId, options = {}) {
+	const denied = options.deniedTools ?? /* @__PURE__ */ new Set();
+	const plansDir = options.plansDir ?? ".mastracode/plans";
+	const sections = [];
+	sections.push(`# Tool Usage Rules
+
+IMPORTANT: You can ONLY call tools by their exact registered names listed below. Shell commands like \`git\`, \`npm\`, \`ls\`, etc. are NOT tools — they must be run via the \`execute_command\` tool.
+
+You have access to the following tools. Use the RIGHT tool for the job:`);
+	const readTools = [];
+	if (!denied.has(MC_TOOLS.VIEW)) readTools.push(`
+**${MC_TOOLS.VIEW}** — Read file contents
+- Use this to read files before editing them. NEVER propose changes to code you haven't read.
+- Use \`offset\` (1-indexed start line) and \`limit\` (number of lines) for large files.
+- Example: Read lines 50-100: \`{ path: "src/big-file.ts", offset: 50, limit: 51 }\`
+- To list directories, use \`${MC_TOOLS.FIND_FILES}\` instead.`);
+	if (!denied.has(MC_TOOLS.SEARCH_CONTENT)) readTools.push(`
+**${MC_TOOLS.SEARCH_CONTENT}** — Search file contents using regex
+- Preferred for content search (finding functions, variables, error messages, imports, etc.)
+- Use \`path\` to filter by directory or glob pattern. Supports \`contextLines\`, \`caseSensitive\`, and \`maxCount\`.
+- Example: Find a function: \`{ pattern: "function handleSubmit", path: "**/*.ts" }\`
+- Example: Find imports: \`{ pattern: "from ['\\"\\]express['\\"\\]", path: "**/*.ts" }\`
+- Respects .gitignore by default.`);
+	if (!denied.has(MC_TOOLS.FIND_FILES)) readTools.push(`
+**${MC_TOOLS.FIND_FILES}** — List files and directories as a tree
+- Preferred for exploring project structure and finding files by pattern.
+- Returns tree-style output. Respects .gitignore by default.
+- Example: List project root: \`{ path: "./" }\`
+- Example: Find test files: \`{ path: "./src", pattern: "**/*.test.ts" }\`
+- Example: Find config files: \`{ pattern: "*.config.{js,ts,json}" }\``);
+	if (!denied.has(MC_TOOLS.EXECUTE_COMMAND)) readTools.push(`
+**${MC_TOOLS.EXECUTE_COMMAND}** — Run shell commands
+- Use for: git, npm/pnpm, docker, build tools, test runners, and other terminal operations.
+- Prefer dedicated tools for: file reading (${MC_TOOLS.VIEW}), file search (${MC_TOOLS.SEARCH_CONTENT}/${MC_TOOLS.FIND_FILES}), file editing (${MC_TOOLS.STRING_REPLACE_LSP}/${MC_TOOLS.WRITE_FILE}).
+- Commands have a 30-second default timeout. Use \`timeout\` for longer commands, \`cwd\` for working directory.
+- Use the \`tail\` parameter or pipe to \`| tail -N\` to limit output — the full output streams to the user, only the tail is returned to you. If you're building any kind of package you should be tailing.
+- Good: Run independent commands in parallel when possible.
+- Bad: Running \`cat file.txt\` — use the ${MC_TOOLS.VIEW} tool instead.`);
+	if (!denied.has(MC_TOOLS.LSP_INSPECT)) readTools.push(`
+**${MC_TOOLS.LSP_INSPECT}** — Inspect code using Language Server Protocol
+- Use this for type information, hover docs, go-to-definition, and finding implementations for a symbol.
+- Best when you already know the file and line and need semantic code intelligence rather than raw file contents.
+- Input: \`path\` (absolute file path), \`line\` (1-indexed line number), \`match\` (the exact line content with exactly one \`<<<\` cursor marker).
+- Output includes: \`hover\`, \`definition\` (compact location with preview), and \`implementation\` (compact usage/implementation locations).
+- Example: \`{ path: "/abs/path/src/foo.ts", line: 10, match: "const foo = <<<bar()" }\` — inspect the symbol at the \`<<<\` position.
+- Use \`${MC_TOOLS.VIEW}\` when you need to read the implementation or surrounding code.
+- Use \`${MC_TOOLS.SEARCH_CONTENT}\` or \`${MC_TOOLS.FIND_FILES}\` first if you do not yet know where the symbol is.`);
+	if (!denied.has(MC_TOOLS.NOTIFICATION_INBOX)) readTools.push(`
+**${MC_TOOLS.NOTIFICATION_INBOX}** — Inspect and manage notification inbox records
+- Use this when a \`<notification-summary>\` says pending notifications exist.
+- Use \`{ "action": "list", "status": "pending" }\` or \`{ "action": "search", "query": "..." }\` to find notification records for the current thread.
+- Use \`read\` to deliver unread notification signals into the chat and mark them seen; the tool result summarizes the count instead of exposing notification contents.
+- Use \`dismiss\` or \`archive\` only when the user asks or the notification is no longer relevant.`);
+	if (readTools.length > 0) sections.push(readTools.join("\n"));
+	if (modeId !== "plan") {
+		const writeTools = [];
+		if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) writeTools.push(`
+**${MC_TOOLS.STRING_REPLACE_LSP}** — Edit files by replacing exact text
+- You MUST read a file with \`${MC_TOOLS.VIEW}\` before editing it.
+- \`old_string\` must be an exact match of existing text in the file.
+- Provide enough surrounding context in \`old_string\` to make it unique.
+- Use \`replace_all: true\` to replace all occurrences (default: false, requires unique match).
+- For creating new files, use \`${MC_TOOLS.WRITE_FILE}\` instead.
+- Good: Include 2-3 lines of surrounding context to ensure uniqueness.
+- Bad: Using just \`return true;\` — too common, will match multiple places.`);
+		if (!denied.has(MC_TOOLS.WRITE_FILE)) writeTools.push(`
+**${MC_TOOLS.WRITE_FILE}** — Create new files or overwrite existing ones
+- Use this to create new files.
+- If overwriting an existing file, you MUST have read it first with \`${MC_TOOLS.VIEW}\`.
+- Prefer editing existing files over creating new ones.`);
+		if (writeTools.length > 0) sections.push(writeTools.join("\n"));
+	}
+	if (options.hasWebSearch) {
+		const webTools = [];
+		if (!denied.has("web_search")) webTools.push("**web_search**");
+		if (!denied.has("web_extract")) webTools.push("**web_extract**");
+		if (webTools.length > 0) sections.push(`
+${webTools.join(" / ")} — Search the web / extract page content
+- Use for looking up documentation, error messages, package APIs.`);
+	}
+	if (options.hasSubconscious) {
+		const knowledgeTools = [
+			"knowledge_search",
+			"knowledge_read",
+			"knowledge_browse"
+		].filter((name) => !denied.has(name));
+		const hasAskMemory = !denied.has("ask_memory");
+		if (knowledgeTools.length > 0 || hasAskMemory) {
+			const lines = [`
+# Subconscious Memory
+
+A background memory system (the "subconscious") runs alongside you. After conversations, it extracts durable knowledge — decisions, preferences, people, files, repos, work items — into a knowledge graph scoped to this project, visible across your sessions here. It also delivers reminders (\`<remembered>\`) and pinned knowledge into your context on its own; you do not manage those directly.`];
+			if (knowledgeTools.length > 0) {
+				const bullets = [];
+				if (knowledgeTools.includes("knowledge_search")) bullets.push("- Use `knowledge_search` for a quick lexical + semantic lookup when you need a specific fact (a past decision, a person's role, what a file is for). Cheaper than re-deriving it from the codebase or asking the user.");
+				if (knowledgeTools.includes("knowledge_read")) bullets.push("- Use `knowledge_read` to open a node by name or ID and see the records about it.");
+				if (knowledgeTools.includes("knowledge_browse")) bullets.push("- Use `knowledge_browse` to list nodes by kind or name prefix, or to walk a node's mentions and backlinks.");
+				if (!denied.has("recall")) bullets.push("- Prefer these over `recall` when the question is about durable facts rather than what was said in a specific past conversation.");
+				lines.push(`
+${knowledgeTools.map((name) => `**${name}**`).join(" / ")} — Query the knowledge graph directly
+${bullets.join("\n")}`);
+			}
+			if (hasAskMemory) lines.push(`
+**ask_memory** — Ask the reminder sidekick a question about existing memory
+- Use only when the answer is not already in your context and a direct search is not enough: open-ended questions ("what did we decide about X and why?") or questions that need synthesis across several memories. It answers from what is already remembered; it does not store anything.
+- It is ASYNCHRONOUS. The tool returns as soon as the question is accepted; the answer arrives later as one or more \`<remind-answer source="subconscious" agent="remind" replyId="…" moreComing="true|false">\` messages in your context. Keep working — do not poll or wait, and do not re-ask the same question.
+- Treat a message with \`moreComing="true"\` as partial; the reply is complete only when \`moreComing="false"\` arrives. Fold the answer into your work and cite it as remembered context rather than as something you verified yourself.`);
+			sections.push(lines.join("\n"));
+		}
+	}
+	const taskTools = [];
+	const canUpdateTask = !denied.has("task_update");
+	const canCompleteTask = !denied.has("task_complete");
+	const canCheckTasks = !denied.has("task_check");
+	const canWriteTasks = !denied.has("task_write");
+	const patchToolGuidance = canUpdateTask && canCompleteTask ? "- Prefer task_update or task_complete when changing one existing task." : canUpdateTask ? "- Prefer task_update when changing one existing task." : canCompleteTask ? "- Prefer task_complete when marking one existing task completed." : "- Use task_write with the full task list when changing existing tasks.";
+	if (canWriteTasks) taskTools.push(`
+**task_write** — Track tasks for complex multi-step work
+- Use when a task requires 3 or more distinct steps or actions.
+- Use task_write to create the initial task list or replace the whole list after replanning.
+- Each task has: id (stable identifier), content (imperative form), status (pending, in_progress, or completed), activeForm (present continuous form shown during execution).
+- Keep task IDs stable across updates. If you omit IDs, the tool result returns generated IDs.
+${patchToolGuidance}
+- Mark tasks \`in_progress\` BEFORE starting work. Only ONE task should be \`in_progress\` at a time.
+- Mark tasks \`completed\` IMMEDIATELY after finishing each task. Do not batch completions.`);
+	if (canUpdateTask) taskTools.push(`
+**task_update** — Patch one tracked task by ID
+- Use this for targeted changes to one existing task.
+- Provide the task ID and only the fields that changed: content, status, or activeForm.`);
+	if (canCompleteTask) {
+		const idSource = canCheckTasks ? "Use task_check if you need the current IDs before completing a task." : canWriteTasks ? "Use IDs returned by task_write." : "Use only task IDs already visible in the current task list.";
+		taskTools.push(`
+**task_complete** — Mark one tracked task completed by ID
+- Use this immediately after finishing a tracked task.
+- ${idSource}`);
+	}
+	if (canCheckTasks) taskTools.push(`
+**task_check** — Check completion status of tasks
+- Use this BEFORE finishing tracked work to verify all tasks are completed.
+- Returns a readable status summary plus structured fields: tasks, summary, incompleteTasks, and isError.
+- summary includes total, completed, inProgress, pending, incomplete, hasTasks, and allCompleted.
+- Use summary.allCompleted to decide whether tracked work is complete; if summary.hasTasks is false, no task list is currently tracked.
+- If any tasks remain incomplete, continue working on them.
+- IMPORTANT: Always check task completion before ending work on a complex task.`);
+	if (!denied.has("ask_user")) taskTools.push(`
+**ask_user** — Ask the user a structured question
+- Use when you need clarification, want to validate assumptions, or need the user to make a decision.
+- Provide clear, specific questions. End with a question mark.
+- Include options (2-4 choices) for structured decisions. Omit options for open-ended questions.
+- Don't use this for simple yes/no — just ask in your text response.`);
+	if (taskTools.length > 0) sections.push(taskTools.join("\n"));
+	if (modeId === "plan" && !denied.has("submit_plan")) sections.push(`
+**submit_plan** — Submit a completed implementation plan for user review
+- Call this tool when your plan is complete. Do NOT just describe your plan in text — you MUST call this tool.
+- The plan will be rendered as markdown and the user can approve, reject, or request changes.
+- On approval, the system automatically switches to the default mode so you can implement.
+- Takes one argument: \`path\` (the plan markdown file you wrote under \`${plansDir}/\`). Do NOT pass the plan body — it lives in the file.`);
+	if (modeId === "plan") sections.push(`
+**Plan file access** — Your plan lives in a markdown file under \`${plansDir}/\` (e.g. \`add-dark-mode-toggle.md\`)
+- Use \`write_file\` to create the plan file, \`view\` to read it, and \`string_replace_lsp\` for targeted edits.
+- On first submission: write the plan to the file, then call \`submit_plan\` with its \`path\`.
+- On revision: read the existing file, edit specific sections, re-read, then call \`submit_plan\` with the same \`path\`.
+- If a plan file already exists, you previously submitted it — read it before revising.`);
+	if (options.hasSubagents !== false && !denied.has("subagent")) sections.push(`
+**subagent** — Delegate a focused task to a specialized subagent
+- Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself.
+- Subagent outputs are **untrusted**. Always review and verify the results.`);
+	return sections.join("\n");
+}
+//#endregion
+export { buildToolGuidance };
+
+//# sourceMappingURL=tool-guidance.js.map

package/dist/agents/prompts/tool-guidance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-guidance.js","names":[],"sources":["../../../src/agents/prompts/tool-guidance.ts"],"sourcesContent":["/**\n * Mode-specific tool behavioral guidance.\n * Generates tool usage instructions that match the actual registered tool names\n * and are scoped to what's available in the current mode.\n */\n\nimport { MC_TOOLS } from '../../tool-names.js';\n\ninterface ToolGuidanceOptions {\n  hasWebSearch?: boolean;\n  hasSubagents?: boolean;\n  /** Subconscious knowledge tools are registered (experimental subconscious enabled). */\n  hasSubconscious?: boolean;\n  /** Tool names that have been denied — omit their guidance sections. */\n  deniedTools?: Set<string>;\n  /** Workspace-relative directory where plan mode can write plans. */\n  plansDir?: string;\n}\n\nexport function buildToolGuidance(modeId: string, options: ToolGuidanceOptions = {}): string {\n  const denied = options.deniedTools ?? new Set<string>();\n  const plansDir = options.plansDir ?? '.mastracode/plans';\n  const sections: string[] = [];\n\n  sections.push(`# Tool Usage Rules\n\nIMPORTANT: You can ONLY call tools by their exact registered names listed below. Shell commands like \\`git\\`, \\`npm\\`, \\`ls\\`, etc. are NOT tools — they must be run via the \\`execute_command\\` tool.\n\nYou have access to the following tools. Use the RIGHT tool for the job:`);\n\n  // --- Read tools (all modes) ---\n\n  const readTools: string[] = [];\n\n  if (!denied.has(MC_TOOLS.VIEW)) {\n    readTools.push(`\n**${MC_TOOLS.VIEW}** — Read file contents\n- Use this to read files before editing them. NEVER propose changes to code you haven't read.\n- Use \\`offset\\` (1-indexed start line) and \\`limit\\` (number of lines) for large files.\n- Example: Read lines 50-100: \\`{ path: \"src/big-file.ts\", offset: 50, limit: 51 }\\`\n- To list directories, use \\`${MC_TOOLS.FIND_FILES}\\` instead.`);\n  }\n\n  if (!denied.has(MC_TOOLS.SEARCH_CONTENT)) {\n    readTools.push(`\n**${MC_TOOLS.SEARCH_CONTENT}** — Search file contents using regex\n- Preferred for content search (finding functions, variables, error messages, imports, etc.)\n- Use \\`path\\` to filter by directory or glob pattern. Supports \\`contextLines\\`, \\`caseSensitive\\`, and \\`maxCount\\`.\n- Example: Find a function: \\`{ pattern: \"function handleSubmit\", path: \"**/*.ts\" }\\`\n- Example: Find imports: \\`{ pattern: \"from ['\\\\\"\\\\]express['\\\\\"\\\\]\", path: \"**/*.ts\" }\\`\n- Respects .gitignore by default.`);\n  }\n\n  if (!denied.has(MC_TOOLS.FIND_FILES)) {\n    readTools.push(`\n**${MC_TOOLS.FIND_FILES}** — List files and directories as a tree\n- Preferred for exploring project structure and finding files by pattern.\n- Returns tree-style output. Respects .gitignore by default.\n- Example: List project root: \\`{ path: \"./\" }\\`\n- Example: Find test files: \\`{ path: \"./src\", pattern: \"**/*.test.ts\" }\\`\n- Example: Find config files: \\`{ pattern: \"*.config.{js,ts,json}\" }\\``);\n  }\n\n  if (!denied.has(MC_TOOLS.EXECUTE_COMMAND)) {\n    readTools.push(`\n**${MC_TOOLS.EXECUTE_COMMAND}** — Run shell commands\n- Use for: git, npm/pnpm, docker, build tools, test runners, and other terminal operations.\n- Prefer dedicated tools for: file reading (${MC_TOOLS.VIEW}), file search (${MC_TOOLS.SEARCH_CONTENT}/${MC_TOOLS.FIND_FILES}), file editing (${MC_TOOLS.STRING_REPLACE_LSP}/${MC_TOOLS.WRITE_FILE}).\n- Commands have a 30-second default timeout. Use \\`timeout\\` for longer commands, \\`cwd\\` for working directory.\n- Use the \\`tail\\` parameter or pipe to \\`| tail -N\\` to limit output — the full output streams to the user, only the tail is returned to you. If you're building any kind of package you should be tailing.\n- Good: Run independent commands in parallel when possible.\n- Bad: Running \\`cat file.txt\\` — use the ${MC_TOOLS.VIEW} tool instead.`);\n  }\n\n  if (!denied.has(MC_TOOLS.LSP_INSPECT)) {\n    readTools.push(`\n**${MC_TOOLS.LSP_INSPECT}** — Inspect code using Language Server Protocol\n- Use this for type information, hover docs, go-to-definition, and finding implementations for a symbol.\n- Best when you already know the file and line and need semantic code intelligence rather than raw file contents.\n- Input: \\`path\\` (absolute file path), \\`line\\` (1-indexed line number), \\`match\\` (the exact line content with exactly one \\`<<<\\` cursor marker).\n- Output includes: \\`hover\\`, \\`definition\\` (compact location with preview), and \\`implementation\\` (compact usage/implementation locations).\n- Example: \\`{ path: \"/abs/path/src/foo.ts\", line: 10, match: \"const foo = <<<bar()\" }\\` — inspect the symbol at the \\`<<<\\` position.\n- Use \\`${MC_TOOLS.VIEW}\\` when you need to read the implementation or surrounding code.\n- Use \\`${MC_TOOLS.SEARCH_CONTENT}\\` or \\`${MC_TOOLS.FIND_FILES}\\` first if you do not yet know where the symbol is.`);\n  }\n\n  if (!denied.has(MC_TOOLS.NOTIFICATION_INBOX)) {\n    readTools.push(`\n**${MC_TOOLS.NOTIFICATION_INBOX}** — Inspect and manage notification inbox records\n- Use this when a \\`<notification-summary>\\` says pending notifications exist.\n- Use \\`{ \"action\": \"list\", \"status\": \"pending\" }\\` or \\`{ \"action\": \"search\", \"query\": \"...\" }\\` to find notification records for the current thread.\n- Use \\`read\\` to deliver unread notification signals into the chat and mark them seen; the tool result summarizes the count instead of exposing notification contents.\n- Use \\`dismiss\\` or \\`archive\\` only when the user asks or the notification is no longer relevant.`);\n  }\n\n  if (readTools.length > 0) {\n    sections.push(readTools.join('\\n'));\n  }\n\n  // --- Write/edit tools (build & fast only) ---\n\n  if (modeId !== 'plan') {\n    const writeTools: string[] = [];\n\n    if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) {\n      writeTools.push(`\n**${MC_TOOLS.STRING_REPLACE_LSP}** — Edit files by replacing exact text\n- You MUST read a file with \\`${MC_TOOLS.VIEW}\\` before editing it.\n- \\`old_string\\` must be an exact match of existing text in the file.\n- Provide enough surrounding context in \\`old_string\\` to make it unique.\n- Use \\`replace_all: true\\` to replace all occurrences (default: false, requires unique match).\n- For creating new files, use \\`${MC_TOOLS.WRITE_FILE}\\` instead.\n- Good: Include 2-3 lines of surrounding context to ensure uniqueness.\n- Bad: Using just \\`return true;\\` — too common, will match multiple places.`);\n    }\n\n    if (!denied.has(MC_TOOLS.WRITE_FILE)) {\n      writeTools.push(`\n**${MC_TOOLS.WRITE_FILE}** — Create new files or overwrite existing ones\n- Use this to create new files.\n- If overwriting an existing file, you MUST have read it first with \\`${MC_TOOLS.VIEW}\\`.\n- Prefer editing existing files over creating new ones.`);\n    }\n\n    if (writeTools.length > 0) {\n      sections.push(writeTools.join('\\n'));\n    }\n  }\n\n  // --- Web tools (all modes, conditionally available) ---\n\n  if (options.hasWebSearch) {\n    const webTools: string[] = [];\n    if (!denied.has('web_search')) webTools.push('**web_search**');\n    if (!denied.has('web_extract')) webTools.push('**web_extract**');\n    if (webTools.length > 0) {\n      sections.push(`\n${webTools.join(' / ')} — Search the web / extract page content\n- Use for looking up documentation, error messages, package APIs.`);\n    }\n  }\n\n  // --- Subconscious knowledge tools (all modes, conditionally available) ---\n\n  if (options.hasSubconscious) {\n    const knowledgeTools = ['knowledge_search', 'knowledge_read', 'knowledge_browse'].filter(name => !denied.has(name));\n    const hasAskMemory = !denied.has('ask_memory');\n    if (knowledgeTools.length > 0 || hasAskMemory) {\n      const lines = [\n        `\n# Subconscious Memory\n\nA background memory system (the \"subconscious\") runs alongside you. After conversations, it extracts durable knowledge — decisions, preferences, people, files, repos, work items — into a knowledge graph scoped to this project, visible across your sessions here. It also delivers reminders (\\`<remembered>\\`) and pinned knowledge into your context on its own; you do not manage those directly.`,\n      ];\n      if (knowledgeTools.length > 0) {\n        const bullets: string[] = [];\n        if (knowledgeTools.includes('knowledge_search')) {\n          bullets.push(\n            \"- Use `knowledge_search` for a quick lexical + semantic lookup when you need a specific fact (a past decision, a person's role, what a file is for). Cheaper than re-deriving it from the codebase or asking the user.\",\n          );\n        }\n        if (knowledgeTools.includes('knowledge_read')) {\n          bullets.push('- Use `knowledge_read` to open a node by name or ID and see the records about it.');\n        }\n        if (knowledgeTools.includes('knowledge_browse')) {\n          bullets.push(\n            \"- Use `knowledge_browse` to list nodes by kind or name prefix, or to walk a node's mentions and backlinks.\",\n          );\n        }\n        if (!denied.has('recall')) {\n          bullets.push(\n            '- Prefer these over `recall` when the question is about durable facts rather than what was said in a specific past conversation.',\n          );\n        }\n        lines.push(`\n${knowledgeTools.map(name => `**${name}**`).join(' / ')} — Query the knowledge graph directly\n${bullets.join('\\n')}`);\n      }\n      if (hasAskMemory) {\n        lines.push(`\n**ask_memory** — Ask the reminder sidekick a question about existing memory\n- Use only when the answer is not already in your context and a direct search is not enough: open-ended questions (\"what did we decide about X and why?\") or questions that need synthesis across several memories. It answers from what is already remembered; it does not store anything.\n- It is ASYNCHRONOUS. The tool returns as soon as the question is accepted; the answer arrives later as one or more \\`<remind-answer source=\"subconscious\" agent=\"remind\" replyId=\"…\" moreComing=\"true|false\">\\` messages in your context. Keep working — do not poll or wait, and do not re-ask the same question.\n- Treat a message with \\`moreComing=\"true\"\\` as partial; the reply is complete only when \\`moreComing=\"false\"\\` arrives. Fold the answer into your work and cite it as remembered context rather than as something you verified yourself.`);\n      }\n      sections.push(lines.join('\\n'));\n    }\n  }\n\n  // --- Task management tools (all modes) ---\n\n  const taskTools: string[] = [];\n  const canUpdateTask = !denied.has('task_update');\n  const canCompleteTask = !denied.has('task_complete');\n  const canCheckTasks = !denied.has('task_check');\n  const canWriteTasks = !denied.has('task_write');\n  const patchToolGuidance =\n    canUpdateTask && canCompleteTask\n      ? '- Prefer task_update or task_complete when changing one existing task.'\n      : canUpdateTask\n        ? '- Prefer task_update when changing one existing task.'\n        : canCompleteTask\n          ? '- Prefer task_complete when marking one existing task completed.'\n          : '- Use task_write with the full task list when changing existing tasks.';\n\n  if (canWriteTasks) {\n    taskTools.push(`\n**task_write** — Track tasks for complex multi-step work\n- Use when a task requires 3 or more distinct steps or actions.\n- Use task_write to create the initial task list or replace the whole list after replanning.\n- Each task has: id (stable identifier), content (imperative form), status (pending, in_progress, or completed), activeForm (present continuous form shown during execution).\n- Keep task IDs stable across updates. If you omit IDs, the tool result returns generated IDs.\n${patchToolGuidance}\n- Mark tasks \\`in_progress\\` BEFORE starting work. Only ONE task should be \\`in_progress\\` at a time.\n- Mark tasks \\`completed\\` IMMEDIATELY after finishing each task. Do not batch completions.`);\n  }\n\n  if (canUpdateTask) {\n    taskTools.push(`\n**task_update** — Patch one tracked task by ID\n- Use this for targeted changes to one existing task.\n- Provide the task ID and only the fields that changed: content, status, or activeForm.`);\n  }\n\n  if (canCompleteTask) {\n    const idSource = canCheckTasks\n      ? 'Use task_check if you need the current IDs before completing a task.'\n      : canWriteTasks\n        ? 'Use IDs returned by task_write.'\n        : 'Use only task IDs already visible in the current task list.';\n    taskTools.push(`\n**task_complete** — Mark one tracked task completed by ID\n- Use this immediately after finishing a tracked task.\n- ${idSource}`);\n  }\n\n  if (canCheckTasks) {\n    taskTools.push(`\n**task_check** — Check completion status of tasks\n- Use this BEFORE finishing tracked work to verify all tasks are completed.\n- Returns a readable status summary plus structured fields: tasks, summary, incompleteTasks, and isError.\n- summary includes total, completed, inProgress, pending, incomplete, hasTasks, and allCompleted.\n- Use summary.allCompleted to decide whether tracked work is complete; if summary.hasTasks is false, no task list is currently tracked.\n- If any tasks remain incomplete, continue working on them.\n- IMPORTANT: Always check task completion before ending work on a complex task.`);\n  }\n\n  if (!denied.has('ask_user')) {\n    taskTools.push(`\n**ask_user** — Ask the user a structured question\n- Use when you need clarification, want to validate assumptions, or need the user to make a decision.\n- Provide clear, specific questions. End with a question mark.\n- Include options (2-4 choices) for structured decisions. Omit options for open-ended questions.\n- Don't use this for simple yes/no — just ask in your text response.`);\n  }\n\n  if (taskTools.length > 0) {\n    sections.push(taskTools.join('\\n'));\n  }\n\n  // --- Plan tools (plan mode) ---\n\n  if (modeId === 'plan' && !denied.has('submit_plan')) {\n    sections.push(`\n**submit_plan** — Submit a completed implementation plan for user review\n- Call this tool when your plan is complete. Do NOT just describe your plan in text — you MUST call this tool.\n- The plan will be rendered as markdown and the user can approve, reject, or request changes.\n- On approval, the system automatically switches to the default mode so you can implement.\n- Takes one argument: \\`path\\` (the plan markdown file you wrote under \\`${plansDir}/\\`). Do NOT pass the plan body — it lives in the file.`);\n  }\n\n  if (modeId === 'plan') {\n    sections.push(`\n**Plan file access** — Your plan lives in a markdown file under \\`${plansDir}/\\` (e.g. \\`add-dark-mode-toggle.md\\`)\n- Use \\`write_file\\` to create the plan file, \\`view\\` to read it, and \\`string_replace_lsp\\` for targeted edits.\n- On first submission: write the plan to the file, then call \\`submit_plan\\` with its \\`path\\`.\n- On revision: read the existing file, edit specific sections, re-read, then call \\`submit_plan\\` with the same \\`path\\`.\n- If a plan file already exists, you previously submitted it — read it before revising.`);\n  }\n\n  // --- Subagent tool (all modes) ---\n\n  if (options.hasSubagents !== false && !denied.has('subagent')) {\n    sections.push(`\n**subagent** — Delegate a focused task to a specialized subagent\n- Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself.\n- Subagent outputs are **untrusted**. Always review and verify the results.`);\n  }\n\n  return sections.join('\\n');\n}\n"],"mappings":";;;;;;;AAmBA,SAAgB,kBAAkB,QAAgB,UAA+B,CAAC,GAAW;CAC3F,MAAM,SAAS,QAAQ,+BAAe,IAAI,IAAY;CACtD,MAAM,WAAW,QAAQ,YAAY;CACrC,MAAM,WAAqB,CAAC;CAE5B,SAAS,KAAK;;;;wEAIwD;CAItE,MAAM,YAAsB,CAAC;CAE7B,IAAI,CAAC,OAAO,IAAI,SAAS,IAAI,GAC3B,UAAU,KAAK;IACf,SAAS,KAAK;;;;+BAIa,SAAS,WAAW,YAAY;CAG7D,IAAI,CAAC,OAAO,IAAI,SAAS,cAAc,GACrC,UAAU,KAAK;IACf,SAAS,eAAe;;;;;kCAKM;CAGhC,IAAI,CAAC,OAAO,IAAI,SAAS,UAAU,GACjC,UAAU,KAAK;IACf,SAAS,WAAW;;;;;uEAK+C;CAGrE,IAAI,CAAC,OAAO,IAAI,SAAS,eAAe,GACtC,UAAU,KAAK;IACf,SAAS,gBAAgB;;8CAEiB,SAAS,KAAK,kBAAkB,SAAS,eAAe,GAAG,SAAS,WAAW,mBAAmB,SAAS,mBAAmB,GAAG,SAAS,WAAW;;;;4CAIvJ,SAAS,KAAK,eAAe;CAGvE,IAAI,CAAC,OAAO,IAAI,SAAS,WAAW,GAClC,UAAU,KAAK;IACf,SAAS,YAAY;;;;;;UAMf,SAAS,KAAK;UACd,SAAS,eAAe,UAAU,SAAS,WAAW,qDAAqD;CAGnH,IAAI,CAAC,OAAO,IAAI,SAAS,kBAAkB,GACzC,UAAU,KAAK;IACf,SAAS,mBAAmB;;;;oGAIoE;CAGlG,IAAI,UAAU,SAAS,GACrB,SAAS,KAAK,UAAU,KAAK,IAAI,CAAC;CAKpC,IAAI,WAAW,QAAQ;EACrB,MAAM,aAAuB,CAAC;EAE9B,IAAI,CAAC,OAAO,IAAI,SAAS,kBAAkB,GACzC,WAAW,KAAK;IAClB,SAAS,mBAAmB;gCACA,SAAS,KAAK;;;;kCAIZ,SAAS,WAAW;;6EAEuB;EAGzE,IAAI,CAAC,OAAO,IAAI,SAAS,UAAU,GACjC,WAAW,KAAK;IAClB,SAAS,WAAW;;wEAEgD,SAAS,KAAK;wDAC9B;EAGpD,IAAI,WAAW,SAAS,GACtB,SAAS,KAAK,WAAW,KAAK,IAAI,CAAC;CAEvC;CAIA,IAAI,QAAQ,cAAc;EACxB,MAAM,WAAqB,CAAC;EAC5B,IAAI,CAAC,OAAO,IAAI,YAAY,GAAG,SAAS,KAAK,gBAAgB;EAC7D,IAAI,CAAC,OAAO,IAAI,aAAa,GAAG,SAAS,KAAK,iBAAiB;EAC/D,IAAI,SAAS,SAAS,GACpB,SAAS,KAAK;EAClB,SAAS,KAAK,KAAK,EAAE;kEAC2C;CAEhE;CAIA,IAAI,QAAQ,iBAAiB;EAC3B,MAAM,iBAAiB;GAAC;GAAoB;GAAkB;EAAkB,CAAC,CAAC,QAAO,SAAQ,CAAC,OAAO,IAAI,IAAI,CAAC;EAClH,MAAM,eAAe,CAAC,OAAO,IAAI,YAAY;EAC7C,IAAI,eAAe,SAAS,KAAK,cAAc;GAC7C,MAAM,QAAQ,CACZ;;;yYAIF;GACA,IAAI,eAAe,SAAS,GAAG;IAC7B,MAAM,UAAoB,CAAC;IAC3B,IAAI,eAAe,SAAS,kBAAkB,GAC5C,QAAQ,KACN,wNACF;IAEF,IAAI,eAAe,SAAS,gBAAgB,GAC1C,QAAQ,KAAK,mFAAmF;IAElG,IAAI,eAAe,SAAS,kBAAkB,GAC5C,QAAQ,KACN,4GACF;IAEF,IAAI,CAAC,OAAO,IAAI,QAAQ,GACtB,QAAQ,KACN,kIACF;IAEF,MAAM,KAAK;EACjB,eAAe,KAAI,SAAQ,KAAK,KAAK,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE;EACtD,QAAQ,KAAK,IAAI,GAAG;GAChB;GACA,IAAI,cACF,MAAM,KAAK;;;;0OAIuN;GAEpO,SAAS,KAAK,MAAM,KAAK,IAAI,CAAC;EAChC;CACF;CAIA,MAAM,YAAsB,CAAC;CAC7B,MAAM,gBAAgB,CAAC,OAAO,IAAI,aAAa;CAC/C,MAAM,kBAAkB,CAAC,OAAO,IAAI,eAAe;CACnD,MAAM,gBAAgB,CAAC,OAAO,IAAI,YAAY;CAC9C,MAAM,gBAAgB,CAAC,OAAO,IAAI,YAAY;CAC9C,MAAM,oBACJ,iBAAiB,kBACb,2EACA,gBACE,0DACA,kBACE,qEACA;CAEV,IAAI,eACF,UAAU,KAAK;;;;;;EAMjB,kBAAkB;;4FAEwE;CAG1F,IAAI,eACF,UAAU,KAAK;;;wFAGqE;CAGtF,IAAI,iBAAiB;EACnB,MAAM,WAAW,gBACb,yEACA,gBACE,oCACA;EACN,UAAU,KAAK;;;IAGf,UAAU;CACZ;CAEA,IAAI,eACF,UAAU,KAAK;;;;;;;gFAO6D;CAG9E,IAAI,CAAC,OAAO,IAAI,UAAU,GACxB,UAAU,KAAK;;;;;qEAKkD;CAGnE,IAAI,UAAU,SAAS,GACrB,SAAS,KAAK,UAAU,KAAK,IAAI,CAAC;CAKpC,IAAI,WAAW,UAAU,CAAC,OAAO,IAAI,aAAa,GAChD,SAAS,KAAK;;;;;2EAKyD,SAAS,wDAAwD;CAG1I,IAAI,WAAW,QACb,SAAS,KAAK;oEACkD,SAAS;;;;wFAIW;CAKtF,IAAI,QAAQ,iBAAiB,SAAS,CAAC,OAAO,IAAI,UAAU,GAC1D,SAAS,KAAK;;;4EAG0D;CAG1E,OAAO,SAAS,KAAK,IAAI;AAC3B"}