mastracode 0.26.0-alpha.5 → 0.26.0

package/dist/{chunk-QO4KIOLG.js → chunk-GT3A3LAA.js}

@@ -1,4 +1,4 @@
-import { getPlansDir, setAuthStorage, loadSettings, MEMORY_GATEWAY_PROVIDER, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmRoleModel, releaseThreadLock, acquireThreadLock, saveSettings, OBSERVABILITY_AUTH_PREFIX, mastra, getCustomProviderId, getEffectiveThinkingLevel, createCodexMiddleware, THINKING_LEVEL_TO_REASONING_EFFORT, buildOpenAICodexOAuthFetch, openaiCodexProvider } from './chunk-F3TKSK3C.js';
+import { getLocalPlansRelativeDir, getPlansDir, setAuthStorage, loadSettings, MEMORY_GATEWAY_PROVIDER, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmRoleModel, releaseThreadLock, acquireThreadLock, saveSettings, OBSERVABILITY_AUTH_PREFIX, mastra, getCustomProviderId, getEffectiveThinkingLevel, createCodexMiddleware, THINKING_LEVEL_TO_REASONING_EFFORT, buildOpenAICodexOAuthFetch, openaiCodexProvider, isPlanFilePath } from './chunk-NDCWIAKG.js';
 import { AuthStorage, DEFAULT_OM_MODEL_ID, DEFAULT_CONFIG_DIR, validateConfigDirName, detectProject, getResourceIdOverride, getStorageConfig, getObservabilityDatabasePath, getVectorDatabasePath, getCurrentGitBranchAsync, getOmScope, DEFAULT_REF_THRESHOLD, DEFAULT_OBS_THRESHOLD, getGitHubCopilotBaseUrl, fetchCopilotModels, getDatabasePath, COPILOT_HEADERS, getAppDataDir } from './chunk-Z5EMG7I2.js';
 import { getToolCategory, MC_TOOLS, TOOL_NAME_OVERRIDES } from './chunk-UOFNLVKF.js';
 import { createHash } from 'crypto';
@@ -7,7 +7,7 @@ import os__default, { hostname, homedir } from 'os';
 import * as path from 'path';
 import path__default, { normalize, join, dirname } from 'path';
 import { Agent } from '@mastra/core/agent';
-import { Harness } from '@mastra/core/harness';
+import { AgentController } from '@mastra/core/agent-controller';
 import { PROVIDER_REGISTRY, MastraModelGateway, MastraGateway, ModelRouterLanguageModel, GATEWAY_AUTH_HEADER, GatewayRegistry } from '@mastra/core/llm';
 import { Mastra } from '@mastra/core/mastra';
 import { StreamErrorRetryProcessor, PrefillErrorHandler, ProviderHistoryCompat, AgentsMDInjector, isBadRequestError } from '@mastra/core/processors';
@@ -21,7 +21,7 @@ import { Observability, SensitiveDataFilter, MastraStorageExporter, MastraPlatfo
 import { spawn, execFile } from 'child_process';
 import { createTavilySearchTool, createTavilyExtractTool } from '@mastra/tavily';
 import { estimateTokenCount, sliceByTokens } from 'tokenx';
-import { LocalFilesystem, createWorkspaceTools, Workspace, LocalSandbox } from '@mastra/core/workspace';
+import { LocalFilesystem, createWorkspaceTools, Workspace, LocalSandbox, WORKSPACE_TOOLS } from '@mastra/core/workspace';
 import { z } from 'zod';
 import * as fs from 'fs';
 import fs__default, { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync } from 'fs';
@@ -316,7 +316,10 @@ When something breaks:
 `;
 
 // src/agents/prompts/plan.ts
-var planModePrompt = `
+function planModePrompt(_ctx) {
+  const plansDir = getLocalPlansRelativeDir();
+  const examplePath = `${plansDir}/add-dark-mode.md`;
+  return `
 # Plan Mode \u2014 READ-ONLY (except plan files)
 
 You are in PLAN mode. Your job is to explore the codebase and design an implementation plan \u2014 NOT to make changes to the project.
@@ -329,7 +332,7 @@ This mode is **read-only for project files**. You must NOT modify the project.
 - 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 your plan file: you CAN write to \`.mastracode/plans/\` to create and edit your plan.
+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.
 
@@ -375,24 +378,25 @@ For each step:
 
 ## Plan File Workflow
 
-Your plan lives as a \`.md\` file in \`.mastracode/plans/\` \u2014 the filename is derived from your plan title (e.g. \`add-dark-mode-toggle.md\`). Use regular workspace tools to manage it:
+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 \`.mastracode/plans/<slug>.md\` using \`write_file\`, then call \`submit_plan\` with the plan content.
-2. **Reading**: Use \`view\` to read the plan file.
+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 \u2014 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 \`.mastracode/plans/<slug>.md\` (slugified from your title) using \`write_file\`
-2. Call \`submit_plan\` with the plan content
+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 file and the \`submit_plan\` tool call, not in your text output.
+**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({
-  title: "short descriptive title",
-  plan: "your full plan in markdown"
+  path: "${examplePath}"
 })
 \`\`\`
 
@@ -404,17 +408,16 @@ The user will see the plan rendered inline and can:
 ## Revision Workflow
 
 If the user requests changes, you will be stopped immediately. Wait for their next message \u2014 it will contain their revision feedback. When you receive it:
-1. Use \`view\` to read your plan file in \`.mastracode/plans/\`
+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 full updated plan content
+4. Call \`submit_plan\` again with the same \`path\` \u2014 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 \u2014 do NOT rewrite the entire plan from scratch for small changes.
-
-**IMPORTANT**: If a plan file already exists in \`.mastracode/plans/\`, you previously submitted a plan that was rejected. Read it to see your previous attempt before revising.
+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 \u2014 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.
 `;
+}
 
 // src/agents/prompts/fast.ts
 var fastModePrompt = `
@@ -505,10 +508,62 @@ Error: ${r.error}`);
     }
   });
 }
-
-// src/agents/tool-availability.ts
+var PLAN_MODE_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE,
+  WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE
+]);
+function getRequestContextValue(requestContext, key) {
+  if (!requestContext) return void 0;
+  if (typeof requestContext.get === "function") {
+    return requestContext.get(key);
+  }
+  return requestContext[key];
+}
+function getHarnessContext(context) {
+  const requestContext = context?.requestContext;
+  const harness = getRequestContextValue(requestContext, "harness");
+  return harness && typeof harness === "object" ? harness : void 0;
+}
+function getHarnessState(harness) {
+  const state = harness?.session?.state?.get?.();
+  return state && typeof state === "object" ? state : void 0;
+}
+function getHarnessModeId(harness) {
+  const modeId = harness?.session?.modeId ?? getHarnessState(harness)?.modeId;
+  return typeof modeId === "string" ? modeId : void 0;
+}
+function getHarnessProjectPath(harness) {
+  const projectPath = getHarnessState(harness)?.projectPath;
+  return typeof projectPath === "string" ? projectPath : void 0;
+}
+function getToolInputPath(input) {
+  const toolPath = input?.path;
+  return typeof toolPath === "string" ? toolPath : void 0;
+}
+var PLAN_DIR_HINT = `${getLocalPlansRelativeDir()}/`;
+function guardPlanModePlanFileWrites({ workspaceToolName, input, context }) {
+  if (!PLAN_MODE_WRITE_TOOL_NAMES.has(workspaceToolName)) return;
+  const harness = getHarnessContext(context);
+  if (getHarnessModeId(harness) !== "plan") return;
+  const projectPath = getHarnessProjectPath(harness);
+  const inputPath = getToolInputPath(input);
+  if (!projectPath || !inputPath) {
+    return {
+      proceed: false,
+      output: `Plan mode can only write plan files inside ${PLAN_DIR_HINT}.`
+    };
+  }
+  if (isPlanFilePath(projectPath, inputPath)) return;
+  return {
+    proceed: false,
+    output: `Plan mode can only write plan files inside ${PLAN_DIR_HINT}. Refusing to edit ${inputPath}.`
+  };
+}
 var MASTRACODE_WORKSPACE_TOOLS = {
-  ...TOOL_NAME_OVERRIDES
+  ...TOOL_NAME_OVERRIDES,
+  hooks: {
+    beforeToolCall: guardPlanModePlanFileWrites
+  }
 };
 var PLAN_MODE_AVAILABLE_TOOLS = [
   // Read-only exploration tools
@@ -517,9 +572,8 @@ var PLAN_MODE_AVAILABLE_TOOLS = [
   MC_TOOLS.SEARCH_CONTENT,
   MC_TOOLS.FILE_STAT,
   MC_TOOLS.LSP_INSPECT,
-  // Plan file writing (visibility gated by availableTools; the shared workspace
-  // is mode-agnostic and does not path-restrict these — plan-mode instructions
-  // scope writes to .mastracode/plans/)
+  // Plan file writing. Tool hooks enforce that these can only write `.md`
+  // files inside `.mastracode/plans/` while the session is in plan mode.
   MC_TOOLS.WRITE_FILE,
   MC_TOOLS.STRING_REPLACE_LSP,
   // Plan delivery tools
@@ -623,7 +677,7 @@ function detectPackageRunner(projectPath) {
   return "npx --yes";
 }
 function getDynamicWorkspace({ requestContext, mastra: mastra2 }) {
-  const ctx = requestContext.get("harness");
+  const ctx = requestContext.get("controller");
   const state = ctx?.getState();
   const rawProjectPath = state?.projectPath;
   if (!rawProjectPath) {
@@ -695,8 +749,8 @@ function isPathAllowed(targetPath, projectRoot, allowedPaths = []) {
   return roots.some((root) => resolved === root || resolved.startsWith(root + path.sep));
 }
 function getAllowedPathsFromContext(toolContext) {
-  const harnessCtx = toolContext?.requestContext?.get("harness");
-  const state = harnessCtx?.getState?.() ?? harnessCtx?.session?.state?.get?.();
+  const agentControllerCtx = toolContext?.requestContext?.get("controller");
+  const state = agentControllerCtx?.getState?.() ?? agentControllerCtx?.session?.state?.get?.();
   const projectPath = state?.projectPath ? path.resolve(state.projectPath) : process.cwd();
   const configDir = state?.configDir ?? DEFAULT_CONFIG_DIR;
   const skillPaths = buildSkillPaths(projectPath, configDir);
@@ -726,7 +780,7 @@ var requestSandboxAccessTool = createTool({
   resumeSchema: z.union([z.string(), z.array(z.string())]),
   execute: async ({ path: requestedPath, reason }, context) => {
     try {
-      const harnessCtx = context?.requestContext?.get("harness");
+      const agentControllerCtx = context?.requestContext?.get("controller");
       const expanded = expandTilde(requestedPath);
       const absolutePath = path.isAbsolute(expanded) ? expanded : path.resolve(process.cwd(), expanded);
       const projectRoot = process.cwd();
@@ -752,13 +806,13 @@ var requestSandboxAccessTool = createTool({
       const answerText = Array.isArray(resumeData) ? resumeData.join(", ") : String(resumeData);
       const approved = answerText.toLowerCase().startsWith("y") || answerText.toLowerCase() === "approve";
       if (approved) {
-        const currentAllowed = harnessCtx?.getState()?.sandboxAllowedPaths ?? [];
+        const currentAllowed = agentControllerCtx?.getState()?.sandboxAllowedPaths ?? [];
         if (!currentAllowed.includes(absolutePath)) {
-          await harnessCtx?.setState({
+          await agentControllerCtx?.setState({
             sandboxAllowedPaths: [...currentAllowed, absolutePath]
           });
         }
-        const fs4 = harnessCtx?.workspace?.filesystem ?? context?.workspace?.filesystem;
+        const fs4 = agentControllerCtx?.workspace?.filesystem ?? context?.workspace?.filesystem;
         if (fs4 instanceof LocalFilesystem) {
           fs4.setAllowedPaths((prev) => [...prev, absolutePath]);
         }
@@ -1033,14 +1087,14 @@ ${patchToolGuidance}
 - Call this tool when your plan is complete. Do NOT just describe your plan in text \u2014 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 two arguments: \`title\` (short descriptive title) and \`plan\` (full plan in markdown).`);
+- Takes one argument: \`path\` (the plan markdown file you wrote under \`.mastracode/plans/\`). Do NOT pass the plan body \u2014 it lives in the file.`);
   }
   if (modeId === "plan") {
     sections.push(`
-**Plan file access** \u2014 Your plan lives in \`.mastracode/plans/\` with a filename derived from the title (e.g. \`add-dark-mode-toggle.md\`)
+**Plan file access** \u2014 Your plan lives in a markdown file under \`.mastracode/plans/\` (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\`.
-- On revision: read the existing file, edit specific sections, re-read, then call \`submit_plan\` with updated content.
+- 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 \u2014 read it before revising.`);
   }
   if (!denied.has("subagent")) {
@@ -1093,9 +1147,9 @@ function buildFullPrompt(ctx) {
 
 // src/agents/instructions.ts
 async function getDynamicInstructions({ requestContext }) {
-  const harnessContext = requestContext.get("harness");
-  const state = harnessContext?.getState();
-  const modeId = harnessContext?.session?.modeId ?? "build";
+  const agentControllerContext = requestContext.get("controller");
+  const state = agentControllerContext?.getState();
+  const modeId = agentControllerContext?.session?.modeId ?? "build";
   const projectPath = state?.projectPath ?? process.cwd();
   const promptCtx = {
     projectPath,
@@ -1105,7 +1159,7 @@ async function getDynamicInstructions({ requestContext }) {
     commonBinaries: await detectCommonBinariesAsync(),
     date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     mode: modeId,
-    modelId: harnessContext?.session?.modelId || void 0,
+    modelId: agentControllerContext?.session?.modelId || void 0,
     activePlan: state?.activePlan ?? null,
     modeId,
     currentDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
@@ -1668,6 +1722,29 @@ var MastraCodeGateway = class _MastraCodeGateway extends MastraModelGateway {
   static getMemoryGatewayApiKey() {
     return authStorage.getStoredApiKey(MEMORY_GATEWAY_PROVIDER) ?? process.env["MASTRA_GATEWAY_API_KEY"];
   }
+  /**
+   * Claim an unprefixed model id (e.g. a bare `anthropic/...`) when this gateway
+   * can authenticate it via OAuth or a stored/env credential. This lets the
+   * shared gateway router select MastraCode for auth resolution, so the status
+   * bar and `/api-keys` reflect OAuth logins instead of only checking env vars.
+   */
+  handlesModel(modelId) {
+    const parsed = parseGatewayRouterId(modelId, this);
+    if (!parsed.providerId || !parsed.modelId) return false;
+    if (this.#routeThroughMastraGateway && this.#mastraGatewayApiKey) return true;
+    const customProvider = this.#getCustomProviders().find(
+      (provider) => parsed.providerId === getCustomProviderId(provider.name)
+    );
+    if (customProvider?.apiKey) return true;
+    return hasResolvedAuth(
+      _MastraCodeGateway.resolveProviderAuth({
+        gatewayId: this.id,
+        providerId: parsed.providerId,
+        modelId: parsed.modelId,
+        routerId: modelId
+      })
+    );
+  }
   static resolveProviderAuth(request, memoryGatewayApiKey) {
     if (request.gatewayId === "mastra" && memoryGatewayApiKey) {
       return { apiKey: memoryGatewayApiKey, source: "gateway" };
@@ -1878,11 +1955,11 @@ var MastraCodeGateway = class _MastraCodeGateway extends MastraModelGateway {
 };
 
 // src/agents/model.ts
-function getHarnessHeaders(requestContext) {
-  const harnessContext = requestContext?.get("harness");
+function getAgentControllerHeaders(requestContext) {
+  const agentControllerContext = requestContext?.get("controller");
   const headers = {
-    ...harnessContext?.threadId ? { "x-thread-id": harnessContext.threadId } : {},
-    ...harnessContext?.resourceId ? { "x-resource-id": harnessContext.resourceId } : {}
+    ...agentControllerContext?.threadId ? { "x-thread-id": agentControllerContext.threadId } : {},
+    ...agentControllerContext?.resourceId ? { "x-resource-id": agentControllerContext.resourceId } : {}
   };
   return Object.keys(headers).length > 0 ? headers : void 0;
 }
@@ -1891,7 +1968,7 @@ function createMastraCodeGateway(options) {
 }
 function resolveModel(modelId, options) {
   reloadAuthStorage();
-  const headers = getHarnessHeaders(options?.requestContext);
+  const headers = getAgentControllerHeaders(options?.requestContext);
   const settings = loadSettings();
   const isMastraGatewayModel = modelId.startsWith(MASTRA_GATEWAY_PREFIX);
   const normalizedModelId = stripMastraGatewayPrefix(modelId);
@@ -1924,12 +2001,12 @@ function resolveModel(modelId, options) {
   });
 }
 function getDynamicModel({ requestContext }) {
-  const harnessContext = requestContext.get("harness");
-  const modelId = harnessContext?.session?.modelId;
+  const agentControllerContext = requestContext.get("controller");
+  const modelId = agentControllerContext?.session?.modelId;
   if (!modelId) {
     throw new Error("No model selected. Use /models to select a model first.");
   }
-  const thinkingLevel = harnessContext?.state?.thinkingLevel;
+  const thinkingLevel = agentControllerContext?.state?.thinkingLevel;
   return resolveModel(modelId, { thinkingLevel, requestContext });
 }
 function getGoalJudgeModel({ requestContext }, settingsPath) {
@@ -1941,18 +2018,18 @@ function getGoalJudgeModel({ requestContext }, settingsPath) {
 // src/agents/memory.ts
 var cachedMemory = null;
 var cachedMemoryKey = null;
-function getHarnessState(requestContext) {
-  const ctx = requestContext.get("harness");
+function getAgentControllerState(requestContext) {
+  const ctx = requestContext.get("controller");
   return ctx?.getState();
 }
 function getObserverModel({ requestContext }) {
-  const state = getHarnessState(requestContext);
+  const state = getAgentControllerState(requestContext);
   return resolveModel(state?.observerModelId ?? DEFAULT_OM_MODEL_ID, {
     requestContext
   });
 }
 function getReflectorModel({ requestContext }) {
-  const state = getHarnessState(requestContext);
+  const state = getAgentControllerState(requestContext);
   return resolveModel(state?.reflectorModelId ?? DEFAULT_OM_MODEL_ID, {
     requestContext
   });
@@ -1982,7 +2059,7 @@ Don't say "Agent did x", say "did x". It will be assumed the agent did what was
 Drop caveman for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question, and anything that requires remembering verbatim content. Resume caveman after clear part done`;
 function getDynamicMemory(storage, vector) {
   return ({ requestContext }) => {
-    const state = getHarnessState(requestContext);
+    const state = getAgentControllerState(requestContext);
     const omScope = state?.omScope ?? getOmScope(state?.projectPath);
     const obsThreshold = state?.observationThreshold ?? DEFAULT_OBS_THRESHOLD;
     const refThreshold = state?.reflectionThreshold ?? DEFAULT_REF_THRESHOLD;
@@ -2125,7 +2202,7 @@ var planMode = {
 
 ## Rules
 - You have READ-ONLY access to the project. You cannot modify project files or run commands.
-- The one exception is the plan file: you can write and edit files in \`.mastracode/plans/\` using \`write_file\`, \`view\`, and \`string_replace_lsp\`.
+- The one exception is plan files: you can create and edit markdown files inside \`.mastracode/plans/\` using \`write_file\`, \`view\`, and \`string_replace_lsp\`. You may not write anywhere else.
 - First, explore the codebase to understand existing patterns, architecture, and conventions.
 - Produce a concrete, actionable plan \u2014 not vague suggestions.
 
@@ -2136,11 +2213,13 @@ var planMode = {
 - **Parallelize**: Make multiple independent tool calls when exploring different areas
 
 ## Plan Delivery
-- Write your plan to \`.mastracode/plans/<slug>.md\` (slugified from your title) using \`write_file\`, then call \`submit_plan\`.
-- Do NOT output the plan as text \u2014 it MUST go through the submit_plan tool call.
+- Write your plan to a markdown file under \`.mastracode/plans/\` (e.g. \`.mastracode/plans/add-dark-mode.md\`) using \`write_file\`, then call \`submit_plan({ path })\` with the path to that file (never the plan body).
+- Start the file with a \`# Title\` heading describing the plan.
+- Reuse the same file while iterating on the same plan; only create a new file for a genuinely different plan so each plan stays available to review.
+- Do NOT output the plan as text \u2014 it MUST live in the plan file.
 - Be concise: reference files by path and line number, don't include raw contents.
 - Focus on actionable details, not general observations.
-- If a plan file already exists in \`.mastracode/plans/\`, you previously submitted a plan \u2014 read it before revising.`,
+- To revise after "Request changes", edit the same file in place with \`string_replace_lsp\`, and call \`submit_plan\` again with the same path.`,
   metadata: {
     default: false
   },
@@ -2265,7 +2344,7 @@ function createToolHooks(hookManager) {
 }
 function createDynamicTools(mcpManager, extraTools, disabledTools, storage) {
   return function getDynamicTools({ requestContext }) {
-    const ctx = requestContext.get("harness");
+    const ctx = requestContext.get("controller");
     const state = ctx?.getState();
     const modelId = ctx?.session?.modelId;
     const isAnthropicModel = modelId?.startsWith("anthropic/");
@@ -3148,12 +3227,16 @@ var HookManager = class {
 function loadMcpConfig(projectDir, configDirName = DEFAULT_CONFIG_DIR) {
   const claudeConfig = loadClaudeSettings(projectDir);
   const globalConfig = loadSingleConfig2(getGlobalMcpPath(configDirName));
+  const rootConfig = loadSingleConfig2(getRootMcpPath(projectDir));
   const projectConfig = loadSingleConfig2(getProjectMcpPath(projectDir, configDirName));
-  return mergeConfigs2(claudeConfig, globalConfig, projectConfig);
+  return mergeConfigs2(claudeConfig, globalConfig, rootConfig, projectConfig);
 }
 function getProjectMcpPath(projectDir, configDirName = DEFAULT_CONFIG_DIR) {
   return path.join(projectDir, configDirName, "mcp.json");
 }
+function getRootMcpPath(projectDir) {
+  return path.join(projectDir, ".mcp.json");
+}
 function getGlobalMcpPath(configDirName = DEFAULT_CONFIG_DIR) {
   return path.join(os.homedir(), configDirName, "mcp.json");
 }
@@ -3693,6 +3776,21 @@ function createMcpManager(projectDir, configDirName = DEFAULT_CONFIG_DIR, extraS
 
 // src/processors/plan-rejection-abort.ts
 var PLAN_REJECTED_PREFIX = "Plan was not approved";
+function resultText(result) {
+  if (typeof result === "string") return result;
+  if (result && typeof result === "object") {
+    const content = result.content;
+    if (typeof content === "string") return content;
+  }
+  return "";
+}
+function isPlanRejection(inv) {
+  if (!inv || inv.state !== "result" || inv.toolName !== "submit_plan") return false;
+  return resultText(inv.result).startsWith(PLAN_REJECTED_PREFIX);
+}
+function isPlanRejectionResultPart(part) {
+  return part.type === "tool_result" && part.name === "submit_plan" && resultText(part.result).startsWith(PLAN_REJECTED_PREFIX);
+}
 var PlanRejectionAbortProcessor = class {
   id = "plan-rejection-abort";
   async processInputStep({ messages, stepNumber, abort }) {
@@ -3701,18 +3799,24 @@ var PlanRejectionAbortProcessor = class {
       const msg = messages[i];
       if (!msg || msg.role !== "assistant") continue;
       const content = msg.content;
-      const parts = content?.parts;
-      if (!Array.isArray(parts)) break;
+      const parts = Array.isArray(content) ? content : Array.isArray(content?.parts) ? content.parts : [];
       for (const part of parts) {
         if (!part || typeof part !== "object") continue;
         const p = part;
-        if (p.type !== "tool-invocation") continue;
-        const inv = p.toolInvocation;
-        if (!inv || inv.state !== "result" || inv.toolName !== "submit_plan") continue;
-        const result = inv.result;
-        const text = typeof result === "string" ? result : typeof result?.content === "string" ? result.content : "";
-        if (text.startsWith(PLAN_REJECTED_PREFIX)) {
+        if (p.type === "tool-invocation" && isPlanRejection(p.toolInvocation)) {
+          abort("Plan rejected by user \u2014 no further response needed");
+          return void 0;
+        }
+        if (isPlanRejectionResultPart(p)) {
+          abort("Plan rejected by user \u2014 no further response needed");
+          return void 0;
+        }
+      }
+      const legacy = !Array.isArray(content) && Array.isArray(content?.toolInvocations) ? content.toolInvocations : [];
+      for (const inv of legacy) {
+        if (isPlanRejection(inv)) {
           abort("Plan rejected by user \u2014 no further response needed");
+          return void 0;
         }
       }
       break;
@@ -3721,10 +3825,10 @@ var PlanRejectionAbortProcessor = class {
   }
 };
 var stateSchema = z.object({
-  // Session-scoped selection. The legacy Harness stores these in its state and
+  // Session-scoped selection.
   // validates state against this schema, so they MUST be declared here — Zod
   // strips unknown keys on parse, which would otherwise silently discard the
-  // seeded model and leave the harness with no model selected.
+  // seeded model and leave the controller with no model selected.
   currentModelId: z.string().optional(),
   modeId: z.string().optional(),
   subagentModelId: z.string().optional(),
@@ -4046,7 +4150,7 @@ function resolveCloudObservabilityConfig(settings, authStorage2, resourceId) {
     projectId: process.env.MASTRA_PROJECT_ID
   };
 }
-async function createMastraCodeHarness(config) {
+async function createMastraCodeAgentController(config) {
   const cwd = config?.cwd ?? process.cwd();
   const homeDir = config?.homeDir ?? config?.initialState?.homeDir;
   const configDir = config?.configDir ?? DEFAULT_CONFIG_DIR;
@@ -4147,11 +4251,11 @@ async function createMastraCodeHarness(config) {
       default: {
         serviceName: "mastracode",
         // Only these requestContext keys are stored on spans — prevents leaking
-        // large objects (harness state, workspace, env vars) into trace data.
-        // Use dot-notation because these are nested inside the 'harness' key.
+        // large objects (controller state, workspace, env vars) into trace data.
+        // Use dot-notation because these are nested inside the 'controller' key.
         //
         // Session identifiers:
-        //   threadId, resourceId, session.modeId, harnessId
+        //   threadId, resourceId, session.modeId, agentControllerId
         // Environment & project:
         //   state.projectName, state.gitBranch
         // Model configuration:
@@ -4163,26 +4267,26 @@ async function createMastraCodeHarness(config) {
         //   state.observationThreshold, state.reflectionThreshold
         requestContextKeys: [
           // Session identifiers
-          "harness.threadId",
-          "harness.resourceId",
-          "harness.session.modeId",
-          "harness.harnessId",
+          "controller.threadId",
+          "controller.resourceId",
+          "controller.session.modeId",
+          "controller.controllerId",
           // Environment & project
-          "harness.state.projectName",
-          "harness.state.gitBranch",
+          "controller.state.projectName",
+          "controller.state.gitBranch",
           // Model configuration
-          "harness.session.modelId",
-          "harness.state.subagentModelId",
+          "controller.session.modelId",
+          "controller.state.subagentModelId",
           // Agent settings
-          "harness.state.yolo",
-          "harness.state.thinkingLevel",
-          "harness.state.smartEditing",
+          "controller.state.yolo",
+          "controller.state.thinkingLevel",
+          "controller.state.smartEditing",
           // Observational memory settings
-          "harness.state.omScope",
-          "harness.state.observerModelId",
-          "harness.state.reflectorModelId",
-          "harness.state.observationThreshold",
-          "harness.state.reflectionThreshold"
+          "controller.state.omScope",
+          "controller.state.observerModelId",
+          "controller.state.reflectorModelId",
+          "controller.state.observationThreshold",
+          "controller.state.reflectionThreshold"
         ],
         exporters: [
           // Only persist traces locally when DuckDB observability is available
@@ -4206,13 +4310,13 @@ async function createMastraCodeHarness(config) {
     cwd: project.rootPath,
     gitcrawlCommand: process.env.MASTRACODE_GITCRAWL_BIN ?? process.env.GITCRAWL_BIN ?? process.env.MASTRACODE_GITCRAWL_COMMAND ?? process.env.GITCRAWL_COMMAND,
     getNotificationStreamOptions: async ({ resourceId, threadId }) => {
-      const session = await harness.getSessionByResource(resourceId) ?? activeSession;
+      const session = await controller.getSessionByResource(resourceId) ?? activeSession;
       const modeId = session.mode.get();
-      const defaultModeModelId = harness.listModes().find((mode) => mode.id === modeId)?.defaultModelId;
+      const defaultModeModelId = controller.listModes().find((mode) => mode.id === modeId)?.defaultModelId;
       const modelId = session.model.get() || activeSession?.model.get() || defaultModeModelId || "";
       const requestContext = new RequestContext();
-      const harnessContext = {
-        harnessId: harness.id,
+      const agentControllerContext = {
+        controllerId: controller.id,
         state: session.state.get(),
         getState: () => session.state.get(),
         setState: (updates) => session.state.set(updates),
@@ -4229,10 +4333,10 @@ async function createMastraCodeHarness(config) {
             update: (updater) => session.state.update(updater)
           }
         },
-        workspace: harness.getWorkspace(),
+        workspace: controller.getWorkspace(),
         getSubagentModelId: (params) => session.subagents.model.get(params ?? {})
       };
-      requestContext.set("harness", harnessContext);
+      requestContext.set("controller", agentControllerContext);
       return {
         memory: { thread: threadId, resource: resourceId },
         requestContext,
@@ -4290,8 +4394,8 @@ async function createMastraCodeHarness(config) {
       new PlanRejectionAbortProcessor(),
       new AgentsMDInjector({
         getIgnoredInstructionPaths: ({ requestContext }) => {
-          const harnessContext = requestContext?.get("harness");
-          const state = harnessContext?.getState();
+          const agentControllerContext = requestContext?.get("controller");
+          const state = agentControllerContext?.getState();
           return getStaticallyLoadedInstructionPaths(state?.projectPath ?? project.rootPath);
         }
       }),
@@ -4423,7 +4527,7 @@ async function createMastraCodeHarness(config) {
     }
   }
   const typedStateSchema = stateSchema;
-  const harness = new Harness({
+  const controller = new AgentController({
     id: "mastra-code",
     resourceId: project.resourceId,
     storage,
@@ -4436,6 +4540,7 @@ async function createMastraCodeHarness(config) {
     gateways: [mastraCodeGateway],
     workspace: config?.workspace ?? ((args) => getDynamicWorkspace(args)),
     browser: config?.browser,
+    idGenerator: config?.idGenerator,
     toolCategoryResolver: getToolCategory,
     initialState: {
       projectPath: project.rootPath,
@@ -4464,10 +4569,9 @@ async function createMastraCodeHarness(config) {
       acquire: acquireThreadLock,
       release: releaseThreadLock
     }
-    // , harnessV1
   });
   return {
-    harness,
+    controller,
     storage,
     observability,
     memory,
@@ -4534,32 +4638,32 @@ async function wireSessionConcerns(base, session) {
   await restoreOMThreadStateForCurrentThread(omThreadStateSession).catch(() => {
   });
 }
-async function bootLocalHarness(config) {
-  const base = await createMastraCodeHarness(config);
-  const { harness, sessionId, ownerId } = base;
-  await harness.init();
-  await harness.getMastra()?.startWorkers();
-  const session = await harness.createSession({ id: sessionId, ownerId });
+async function bootLocalAgentController(config) {
+  const base = await createMastraCodeAgentController(config);
+  const { controller, sessionId, ownerId } = base;
+  await controller.init();
+  await controller.getMastra()?.startWorkers();
+  const session = await controller.createSession({ id: sessionId, ownerId });
   await wireSessionConcerns(base, session);
   return { ...base, session };
 }
-async function mountHarnessOnMastra(config) {
-  const base = await createMastraCodeHarness(config);
-  const { harness, storage } = base;
-  const harnessId = config?.harnessId ?? harness.id;
+async function mountAgentControllerOnMastra(config) {
+  const base = await createMastraCodeAgentController(config);
+  const { controller, storage } = base;
+  const controllerId = config?.controllerId ?? controller.id;
   let mastra2;
   if (config?.mastra) {
     mastra2 = config.mastra;
-    harness.__registerMastra(mastra2);
+    controller.__registerMastra(mastra2);
   } else {
-    mastra2 = new Mastra({ harnesses: { [harnessId]: harness }, storage });
+    mastra2 = new Mastra({ agentControllers: { [controllerId]: controller }, storage });
   }
-  await harness.init();
-  await harness.getMastra()?.startWorkers();
+  await controller.init();
+  await controller.getMastra()?.startWorkers();
   return { ...base, mastra: mastra2 };
 }
-var createMastraCode = bootLocalHarness;
+var createMastraCode = bootLocalAgentController;
 
-export { bootLocalHarness, createAuthStorage, createMastraCode, createMastraCodeHarness, mountHarnessOnMastra, wireSessionConcerns };
-//# sourceMappingURL=chunk-QO4KIOLG.js.map
-//# sourceMappingURL=chunk-QO4KIOLG.js.map
+export { bootLocalAgentController, createAuthStorage, createMastraCode, createMastraCodeAgentController, mountAgentControllerOnMastra, wireSessionConcerns };
+//# sourceMappingURL=chunk-GT3A3LAA.js.map
+//# sourceMappingURL=chunk-GT3A3LAA.js.map