@ngandu/ulicode 0.0.6

package/dist/chunk-OXFO76JC.js

@@ -0,0 +1,2633 @@
+import { logRuntimeProfile, lspManager, loadSettingsCached, loadAgentDefinitionsCached, createHarnessSubagentsFromDefinitions, createHarnessModesFromDefinitions, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmModel, getSubagentModeMap, releaseThreadLock, acquireThreadLock, getCustomProviderId, toCustomProviderModelId, saveSettings, getModeDefinition, getAllowedSubagentIdsForMode } from './chunk-PKRLG6A4.js';
+import { AuthStorage, detectProject, getResourceIdOverride, getStorageConfig, getCurrentGitBranch, getOmScope, getDatabasePath } from './chunk-3YYDXNUH.js';
+import { getToolCategory, TOOL_NAME_OVERRIDES, MC_TOOLS } from './chunk-MS5RYNRK.js';
+import { Agent } from '@mastra/core/agent';
+import { Harness } from '@mastra/core/harness';
+import { PROVIDER_REGISTRY, ModelRouterLanguageModel, ModelsDevGateway, NetlifyGateway } from '@mastra/core/llm';
+import { createTool } from '@mastra/core/tools';
+import { tavily } from '@tavily/core';
+import { z } from 'zod';
+import { Tiktoken } from 'js-tiktoken/lite';
+import o200k_base from 'js-tiktoken/ranks/o200k_base';
+import * as os from 'os';
+import os__default, { homedir } from 'os';
+import * as path from 'path';
+import path__default, { join, dirname } from 'path';
+import { LocalFilesystem, Workspace, LocalSandbox, createWorkspaceTools } from '@mastra/core/workspace';
+import * as fs4 from 'fs';
+import fs4__default, { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { Memory } from '@mastra/memory';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { wrapLanguageModel } from 'ai';
+import { spawn } from 'child_process';
+import { MCPClient } from '@mastra/mcp';
+import { LibSQLStore } from '@mastra/libsql';
+import { PostgresStore } from '@mastra/pg';
+
+// src/agents/prompts/base.ts
+function buildBasePrompt(ctx) {
+  return `You are Ulicode, an interactive CLI coding agent that helps users with software engineering tasks.
+
+# Environment
+Working directory: ${ctx.projectPath}
+Project: ${ctx.projectName}
+${ctx.gitBranch ? `Git branch: ${ctx.gitBranch}` : "Not a git repository"}
+Platform: ${ctx.platform}
+Date: ${ctx.date}
+Current mode: ${ctx.mode}
+
+# Tone and Style
+- Your output is displayed on a command line interface. Keep responses concise.
+- Use Github-flavored markdown for formatting.
+- Only use emojis if the user explicitly requests it.
+- Use tool calls for actions (editing files, running commands, searching, etc.). Use text for communication \u2014 talk to the user in text, not via tools, except for communication tools like \`submit_plan\`, \`ask_user\`, and \`task_write\`.
+- Prioritize technical accuracy over validating the user's beliefs. Be direct and objective. Respectful correction is more valuable than false agreement.
+
+${ctx.toolGuidance}
+
+# How to Work on Tasks
+
+## Start by Understanding
+- Read relevant code before making changes. Use search_content/find_files to find related files.
+- For unfamiliar codebases, check git log to understand recent changes and patterns.
+- Identify existing conventions (naming, structure, error handling) and follow them.
+
+## Work Incrementally
+- Focus on ONE thing at a time. Complete it fully before moving to the next.
+- Leave the codebase in a clean state after each change \u2014 no half-implemented features.
+- For multi-step tasks, use tasks to track progress and ensure nothing is missed.
+
+## Verify Before Moving On
+- After each change, verify it works. Don't assume \u2014 actually test it.
+- Run the relevant tests, check for type errors, or manually verify the behavior.
+- If something breaks, fix it immediately. Don't pile more changes on top of broken code.
+
+# Coding Philosophy
+
+- **Avoid over-engineering.** Only make changes that are directly requested or clearly necessary.
+- **Don't add extras.** No unrequested features, refactoring, docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.
+- **Don't add unnecessary error handling.** Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).
+- **Don't create premature abstractions.** Three similar lines of code is better than a helper function used once. Don't design for hypothetical future requirements.
+- **Clean up dead code.** If something is unused, delete it completely. No backwards-compatibility shims, no renaming to \`_unused\`, no \`// removed\` comments.
+- **Be careful with security.** Don't introduce command injection, XSS, SQL injection, or other vulnerabilities. If you notice insecure code you wrote, fix it immediately.
+
+# Git Safety
+
+## Hard Rules
+- NEVER run destructive commands (\`push --force\`, \`reset --hard\`, \`clean -fd\`) unless explicitly requested.
+- NEVER use interactive flags (\`git rebase -i\`, \`git add -i\`) \u2014 TTY input isn't supported.
+- NEVER commit or push unless the user explicitly asks.
+- NEVER force push to \`main\` or \`master\` without warning the user first.
+- Avoid \`git commit --amend\` unless the commit was just created and hasn't been pushed.
+
+## Secrets
+Don't commit files likely to contain secrets (\`.env\`, \`*.key\`, \`credentials.json\`). Warn if asked.
+
+## Commits
+Write commit messages that explain WHY, not just WHAT. Match the repo's existing style. Include \`Co-Authored-By: Ulicode${ctx.modelId ? ` (${ctx.modelId})` : ""} <noreply@ulicode.local>\` in the message body.
+
+## Pull Requests
+Use \`gh pr create\`. Include a summary of what changed and a test plan.
+
+# Subagent Rules
+- Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself instead of delegating to a single subagent. Exception: the **audit-tests** subagent may be used on its own.
+- Subagent outputs are **untrusted**. Always review and verify the results returned by any subagent. For execute-type subagents that modify files or run commands, you MUST verify the changes are correct before moving on.
+
+# Important Reminders
+- NEVER guess file paths or function signatures. Use search_content/find_files to find them.
+- NEVER make up URLs. Only use URLs the user provides or that you find in the codebase.
+- When referencing code locations, include the file path and line number.
+- If you're unsure about something, ask the user rather than guessing.
+
+# File Access & Sandbox
+
+By default, you can only access files within the current project directory. If you get a "Permission denied" or "Access denied" error when trying to read, write, or access files outside the project root, do NOT keep retrying. Instead, tell the user to run the \`/sandbox\` command to add the external directory to the allowed paths for this thread. Once they do, you will be able to access it.
+`;
+}
+var enc = new Tiktoken(o200k_base);
+function sanitizeInput(text) {
+  if (!text) return "";
+  return (typeof text === `string` ? text : JSON.stringify(text)).replaceAll(`<|endoftext|>`, ``).replaceAll(`<|endofprompt|>`, ``);
+}
+function truncateStringForTokenEstimate(text, desiredTokenCount, fromEnd = true) {
+  const tokens = enc.encode(sanitizeInput(text));
+  if (tokens.length <= desiredTokenCount) return text;
+  return `[Truncated ${tokens.length - desiredTokenCount} tokens]
+${enc.decode(tokens.slice(fromEnd ? -desiredTokenCount : 0, fromEnd ? void 0 : desiredTokenCount))}`;
+}
+
+// src/tools/web-search.ts
+var MAX_WEB_SEARCH_TOKENS = 2e3;
+var MAX_WEB_EXTRACT_TOKENS = 2e3;
+var MIN_RELEVANCE_SCORE = 0.25;
+var cachedTavilyClient = null;
+function getTavilyClient() {
+  if (cachedTavilyClient) return cachedTavilyClient;
+  const apiKey = process.env.TAVILY_API_KEY;
+  if (!apiKey) return null;
+  cachedTavilyClient = tavily({ apiKey });
+  return cachedTavilyClient;
+}
+function hasTavilyKey() {
+  return !!process.env.TAVILY_API_KEY;
+}
+function createWebSearchTool() {
+  return createTool({
+    id: "web-search",
+    description: "Search the web for information. Use this to find documentation, look up error messages, check package APIs, or research any topic. Returns relevant web results with content snippets and optionally images.",
+    inputSchema: z.object({
+      query: z.string().describe("The search query"),
+      searchDepth: z.enum(["basic", "advanced"]).optional().default("basic").describe("Search depth - 'basic' for quick searches, 'advanced' for more thorough results"),
+      maxResults: z.number().optional().default(10).describe("Maximum number of results to return"),
+      includeImages: z.boolean().optional().default(false).describe("Whether to include related images in results")
+    }),
+    execute: async (context) => {
+      const tavilyClient = getTavilyClient();
+      if (!tavilyClient) {
+        return "No results (TAVILY_API_KEY not configured)";
+      }
+      try {
+        const response = await tavilyClient.search(context.query, {
+          searchDepth: context.searchDepth || "basic",
+          maxResults: context.maxResults || 10,
+          includeAnswer: true,
+          includeImages: context.includeImages || false
+        });
+        const filteredResults = response.results.filter((r) => (r.score ?? 1) >= MIN_RELEVANCE_SCORE);
+        const parts = [];
+        if (response.answer) {
+          parts.push(`Answer: ${response.answer}`);
+        }
+        for (const r of filteredResults) {
+          parts.push(`## ${r.title}
+${r.url}
+${r.content}`);
+        }
+        const images = (response.images || []).map((img) => typeof img === "string" ? img : img.url || "").filter(Boolean);
+        if (images.length > 0) {
+          parts.push(`Images:
+${images.join("\n")}`);
+        }
+        const text = parts.join("\n\n");
+        return truncateStringForTokenEstimate(text, MAX_WEB_SEARCH_TOKENS);
+      } catch {
+        return "No results";
+      }
+    }
+  });
+}
+function createWebExtractTool() {
+  return createTool({
+    id: "web-extract",
+    description: "Extract content from one or more URLs. Use this to read web pages, documentation, articles, or any URL. Returns the raw content in markdown format. You can provide up to 20 URLs at once.",
+    inputSchema: z.object({
+      urls: z.array(z.string()).min(1).max(20).describe("URLs to extract content from (max 20)"),
+      extractDepth: z.enum(["basic", "advanced"]).optional().default("basic").describe("Extraction depth - 'basic' for simple text, 'advanced' for JS-rendered pages"),
+      includeImages: z.boolean().optional().default(false).describe("Whether to include extracted image URLs")
+    }),
+    execute: async (context) => {
+      const tavilyClient = getTavilyClient();
+      if (!tavilyClient) {
+        return "Extraction failed (TAVILY_API_KEY not configured)";
+      }
+      try {
+        const response = await tavilyClient.extract(context.urls, {
+          extractDepth: context.extractDepth || "basic",
+          includeImages: context.includeImages || false
+        });
+        const parts = [];
+        for (const r of response.results || []) {
+          parts.push(`## ${r.url}
+${r.rawContent}`);
+        }
+        for (const r of response.failedResults || []) {
+          parts.push(`## ${r.url}
+Error: ${r.error}`);
+        }
+        const text = parts.join("\n\n");
+        return truncateStringForTokenEstimate(text, MAX_WEB_EXTRACT_TOKENS);
+      } catch (error) {
+        return `Extraction failed: ${String(error)}`;
+      }
+    }
+  });
+}
+var ulicodeLocalSkillsPath = path__default.join(process.cwd(), ".ulicode", "skills");
+var uliLocalSkillsPath = path__default.join(process.cwd(), ".uli-cli", "skills");
+var pulseLocalSkillsPath = path__default.join(process.cwd(), ".pulse", "skills");
+var mastraCodeLocalSkillsPath = path__default.join(process.cwd(), ".mastracode", "skills");
+var claudeLocalSkillsPath = path__default.join(process.cwd(), ".claude", "skills");
+var ulicodeGlobalSkillsPath = path__default.join(os__default.homedir(), ".ulicode", "skills");
+var uliGlobalSkillsPath = path__default.join(os__default.homedir(), ".uli-cli", "skills");
+var pulseGlobalSkillsPath = path__default.join(os__default.homedir(), ".pulse", "skills");
+var mastraCodeGlobalSkillsPath = path__default.join(os__default.homedir(), ".mastracode", "skills");
+var claudeGlobalSkillsPath = path__default.join(os__default.homedir(), ".claude", "skills");
+function collectSkillPaths(skillsDirs) {
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    if (!fs4__default.existsSync(skillsDir)) continue;
+    const resolved = fs4__default.realpathSync(skillsDir);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      paths.push(skillsDir);
+    }
+    try {
+      const entries = fs4__default.readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) {
+          const linkPath = path__default.join(skillsDir, entry.name);
+          const realPath = fs4__default.realpathSync(linkPath);
+          const stat = fs4__default.statSync(realPath);
+          if (stat.isDirectory()) {
+            const realParent = path__default.dirname(realPath);
+            if (!seen.has(realParent)) {
+              seen.add(realParent);
+              paths.push(realParent);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return paths;
+}
+var skillPathsCache = null;
+var skillPathsLogged = false;
+function getSkillPaths() {
+  if (skillPathsCache) {
+    return [...skillPathsCache];
+  }
+  const startTime = performance.now();
+  skillPathsCache = collectSkillPaths([
+    ulicodeLocalSkillsPath,
+    uliLocalSkillsPath,
+    pulseLocalSkillsPath,
+    mastraCodeLocalSkillsPath,
+    claudeLocalSkillsPath,
+    ulicodeGlobalSkillsPath,
+    uliGlobalSkillsPath,
+    pulseGlobalSkillsPath,
+    mastraCodeGlobalSkillsPath,
+    claudeGlobalSkillsPath
+  ]);
+  logRuntimeProfile("workspace.skill_path_scan", performance.now() - startTime, {
+    count: skillPathsCache.length
+  });
+  if (!skillPathsLogged && skillPathsCache.length > 0) {
+    console.info(`Skills loaded from:`);
+    for (const p of skillPathsCache) {
+      console.info(`  - ${p}`);
+    }
+    skillPathsLogged = true;
+  }
+  return [...skillPathsCache];
+}
+var WORKSPACE_ID_PREFIX = "mastra-code-workspace";
+function detectPackageRunner(projectPath) {
+  if (existsSync(join(projectPath, "pnpm-lock.yaml"))) return "pnpm dlx";
+  if (existsSync(join(projectPath, "bun.lockb")) || existsSync(join(projectPath, "bun.lock"))) return "bunx";
+  if (existsSync(join(projectPath, "yarn.lock"))) return "yarn dlx";
+  if (existsSync(join(projectPath, "package-lock.json"))) return "npx --yes";
+  return "npx --yes";
+}
+function getDynamicWorkspace({ requestContext, mastra }) {
+  const ctx = requestContext.get("harness");
+  const state = ctx?.getState?.();
+  const modeId = ctx?.modeId ?? "build";
+  const rawProjectPath = state?.projectPath;
+  if (!rawProjectPath) {
+    throw new Error("Project path is required");
+  }
+  const projectPath = path__default.resolve(rawProjectPath);
+  const workspaceId = `${WORKSPACE_ID_PREFIX}-${projectPath}`;
+  const sandboxPaths = state?.sandboxAllowedPaths ?? [];
+  const skillPaths = getSkillPaths();
+  const allowedPaths = [...skillPaths, ...sandboxPaths.map((p) => path__default.resolve(p))];
+  const isPlanMode = modeId === "plan";
+  const isAskMode = modeId === "ask";
+  const planModeTools = {
+    mastra_workspace_write_file: { ...TOOL_NAME_OVERRIDES.mastra_workspace_write_file, enabled: false },
+    mastra_workspace_edit_file: { ...TOOL_NAME_OVERRIDES.mastra_workspace_edit_file, enabled: false },
+    mastra_workspace_ast_edit: { ...TOOL_NAME_OVERRIDES.mastra_workspace_ast_edit, enabled: false }
+  };
+  const askModeTools = {
+    mastra_workspace_write_file: { ...TOOL_NAME_OVERRIDES.mastra_workspace_write_file, enabled: false },
+    mastra_workspace_edit_file: { ...TOOL_NAME_OVERRIDES.mastra_workspace_edit_file, enabled: false },
+    mastra_workspace_ast_edit: { ...TOOL_NAME_OVERRIDES.mastra_workspace_ast_edit, enabled: false },
+    mastra_workspace_delete: { ...TOOL_NAME_OVERRIDES.mastra_workspace_delete, enabled: false },
+    mastra_workspace_mkdir: { ...TOOL_NAME_OVERRIDES.mastra_workspace_mkdir, enabled: false },
+    mastra_workspace_execute_command: { ...TOOL_NAME_OVERRIDES.mastra_workspace_execute_command, enabled: false },
+    mastra_workspace_get_process_output: { ...TOOL_NAME_OVERRIDES.mastra_workspace_get_process_output, enabled: false },
+    mastra_workspace_kill_process: { ...TOOL_NAME_OVERRIDES.mastra_workspace_kill_process, enabled: false }
+  };
+  const toolsConfig = isAskMode ? { ...TOOL_NAME_OVERRIDES, ...askModeTools } : isPlanMode ? { ...TOOL_NAME_OVERRIDES, ...planModeTools } : TOOL_NAME_OVERRIDES;
+  let existing;
+  try {
+    existing = mastra?.getWorkspaceById(workspaceId);
+  } catch {
+  }
+  if (existing) {
+    existing.filesystem.setAllowedPaths(allowedPaths);
+    existing.setToolsConfig(toolsConfig);
+    return existing;
+  }
+  const userLsp = loadSettingsCached().lsp ?? {};
+  const mcModulePath = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const lspConfig = {
+    ...userLsp,
+    packageRunner: userLsp.packageRunner || detectPackageRunner(projectPath),
+    // Detected runner is the fallback — user's packageRunner always wins
+    searchPaths: [mcModulePath, ...userLsp.searchPaths ?? []]
+  };
+  const startTime = performance.now();
+  const workspace = new Workspace({
+    id: workspaceId,
+    name: "Ulicode Workspace",
+    filesystem: new LocalFilesystem({
+      basePath: projectPath,
+      allowedPaths
+    }),
+    sandbox: new LocalSandbox({
+      workingDirectory: projectPath,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        CLICOLOR_FORCE: "1",
+        TERM: process.env.TERM || "xterm-256color",
+        CI: "true",
+        NONINTERACTIVE: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      }
+    }),
+    tools: toolsConfig,
+    ...skillPaths.length > 0 ? { skills: skillPaths } : {},
+    lsp: lspConfig
+  });
+  logRuntimeProfile("workspace.create", performance.now() - startTime, {
+    workspaceId,
+    modeId,
+    skillPathCount: skillPaths.length
+  });
+  return workspace;
+}
+
+// src/tools/utils.ts
+function isPathAllowed(targetPath, projectRoot, allowedPaths = []) {
+  const resolved = path.resolve(targetPath);
+  const roots = [projectRoot, ...allowedPaths].map((p) => path.resolve(p));
+  return roots.some((root) => resolved === root || resolved.startsWith(root + path.sep));
+}
+function getAllowedPathsFromContext(toolContext) {
+  const skillPaths = getSkillPaths();
+  if (!toolContext?.requestContext) {
+    return [...skillPaths];
+  }
+  const harnessCtx = toolContext.requestContext.get("harness");
+  const sandboxPaths = harnessCtx?.getState?.()?.sandboxAllowedPaths ?? harnessCtx?.state?.sandboxAllowedPaths ?? [];
+  return [...skillPaths, ...sandboxPaths];
+}
+
+// src/tools/request-sandbox-access.ts
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return `${os.homedir()}/${p.slice(2).replace(/\\/g, "/")}`;
+  }
+  return p;
+}
+function formatPathForMessage(requestedPath, resolvedPath) {
+  if (requestedPath.startsWith("~/") || requestedPath.startsWith("~\\")) {
+    return `${os.homedir()}/${requestedPath.slice(2).replace(/\\/g, "/")}`;
+  }
+  if (requestedPath === "~") {
+    return os.homedir();
+  }
+  return resolvedPath;
+}
+var requestCounter = 0;
+var requestSandboxAccessTool = createTool({
+  id: "request_access",
+  description: `Request permission to access a directory outside the current project. Use this when you need to read or write files in a directory that is not within the project root. The user will be prompted to approve or deny the request.`,
+  inputSchema: z.object({
+    path: z.string().min(1).describe("The absolute path to the directory you need access to."),
+    reason: z.string().min(1).describe("Brief explanation of why you need access to this directory.")
+  }),
+  execute: async ({ path: requestedPath, reason }, context) => {
+    try {
+      const harnessCtx = context?.requestContext?.get("harness");
+      const expanded = expandTilde(requestedPath);
+      const absolutePath = path.isAbsolute(expanded) ? expanded : path.resolve(process.cwd(), expanded);
+      const displayPath = formatPathForMessage(requestedPath, absolutePath);
+      const projectRoot = process.cwd();
+      const allowedPaths = getAllowedPathsFromContext(context);
+      if (isPathAllowed(absolutePath, projectRoot, allowedPaths)) {
+        return {
+          content: `Access already granted: "${displayPath}" is within the project root or allowed paths.`,
+          isError: false
+        };
+      }
+      if (!harnessCtx?.emitEvent || !harnessCtx?.registerQuestion) {
+        return {
+          content: `Cannot request sandbox access: TUI context not available. The user should manually run /sandbox add ${displayPath}`,
+          isError: true
+        };
+      }
+      const questionId = `sandbox_${++requestCounter}_${Date.now()}`;
+      const answer = await new Promise((resolve3) => {
+        harnessCtx.registerQuestion({ questionId, resolve: resolve3 });
+        harnessCtx.emitEvent({
+          type: "sandbox_access_request",
+          questionId,
+          path: absolutePath,
+          reason
+        });
+      });
+      const approved = answer.toLowerCase().startsWith("y") || answer.toLowerCase() === "approve";
+      if (approved) {
+        const currentAllowed = harnessCtx.getState?.()?.sandboxAllowedPaths ?? [];
+        if (!currentAllowed.includes(absolutePath)) {
+          harnessCtx.setState?.({
+            sandboxAllowedPaths: [...currentAllowed, absolutePath]
+          });
+        }
+        const fs5 = context?.workspace?.filesystem;
+        if (fs5 instanceof LocalFilesystem) {
+          fs5.setAllowedPaths((prev) => [...prev, absolutePath]);
+        }
+        return {
+          content: `Access granted: "${displayPath}" has been added to allowed paths. You can now access files in this directory.`,
+          isError: false
+        };
+      } else {
+        return {
+          content: `Access denied: The user declined access to "${displayPath}".`,
+          isError: false
+        };
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Failed to request sandbox access: ${msg}`,
+        isError: true
+      };
+    }
+  }
+});
+var INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md"];
+var PROJECT_LOCATIONS = [
+  "",
+  // project root
+  ".claude",
+  ".ulicode",
+  ".uli-cli",
+  ".pulse",
+  ".mastracode"
+];
+var GLOBAL_LOCATIONS = [
+  ".claude",
+  ".ulicode",
+  ".uli-cli",
+  ".pulse",
+  ".mastracode",
+  ".config/claude",
+  ".config/ulicode",
+  ".config/uli-cli",
+  ".config/pulse",
+  ".config/mastracode"
+];
+var instructionCache = /* @__PURE__ */ new Map();
+function findInstructionFile(basePath) {
+  for (const filename of INSTRUCTION_FILES) {
+    const fullPath = join(basePath, filename);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function loadAgentInstructions(projectPath) {
+  const sources = [];
+  const home = homedir();
+  for (const location of GLOBAL_LOCATIONS) {
+    const basePath = join(home, location);
+    const filePath = findInstructionFile(basePath);
+    if (filePath) {
+      try {
+        const content = readFileSync(filePath, "utf-8").trim();
+        if (content) {
+          sources.push({ path: filePath, content, scope: "global" });
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  for (const location of PROJECT_LOCATIONS) {
+    const basePath = location ? join(projectPath, location) : projectPath;
+    const filePath = findInstructionFile(basePath);
+    if (filePath) {
+      try {
+        const content = readFileSync(filePath, "utf-8").trim();
+        if (content) {
+          sources.push({ path: filePath, content, scope: "project" });
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  return sources;
+}
+function loadAgentInstructionsCached(projectPath) {
+  const cached = instructionCache.get(projectPath);
+  if (cached) {
+    return cached.map((source) => ({ ...source }));
+  }
+  const sources = loadAgentInstructions(projectPath);
+  instructionCache.set(
+    projectPath,
+    sources.map((source) => ({ ...source }))
+  );
+  return sources.map((source) => ({ ...source }));
+}
+function formatAgentInstructions(sources) {
+  if (sources.length === 0) return "";
+  const sections = sources.map((source) => {
+    const label = source.scope === "global" ? "Global" : "Project";
+    return `<!-- ${label} instructions from ${source.path} -->
+${source.content}`;
+  });
+  return `
+# Agent Instructions
+
+${sections.join("\n\n")}
+`;
+}
+
+// src/agents/prompts/tool-guidance.ts
+function buildToolGuidance(modeId, options = {}) {
+  const denied = options.deniedTools ?? /* @__PURE__ */ new Set();
+  const sections = [];
+  const isAskMode = modeId === "ask";
+  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 \u2014 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}** \u2014 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}** \u2014 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}** \u2014 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 (!isAskMode && !denied.has(MC_TOOLS.EXECUTE_COMMAND)) {
+    readTools.push(`
+**${MC_TOOLS.EXECUTE_COMMAND}** \u2014 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 \u2014 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\` \u2014 use the ${MC_TOOLS.VIEW} tool instead.`);
+  }
+  if (readTools.length > 0) {
+    sections.push(readTools.join("\n"));
+  }
+  if (modeId !== "plan" && modeId !== "ask") {
+    const writeTools = [];
+    if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) {
+      writeTools.push(`
+**${MC_TOOLS.STRING_REPLACE_LSP}** \u2014 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;\` \u2014 too common, will match multiple places.`);
+    }
+    if (!denied.has(MC_TOOLS.WRITE_FILE)) {
+      writeTools.push(`
+**${MC_TOOLS.WRITE_FILE}** \u2014 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(" / ")} \u2014 Search the web / extract page content
+- Use for looking up documentation, error messages, package APIs.`);
+    }
+  }
+  const taskTools = [];
+  if (!isAskMode && !denied.has("task_write")) {
+    taskTools.push(`
+**task_write** \u2014 Track tasks for complex multi-step work
+- Use when a task requires 3 or more distinct steps or actions.
+- Pass the FULL task list each time (replaces previous list).
+- 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.
+- Each task has: content (imperative form), status (pending|in_progress|completed), activeForm (present continuous form shown during execution).`);
+  }
+  if (!isAskMode && !denied.has("task_check")) {
+    taskTools.push(`
+**task_check** \u2014 Check completion status of tasks
+- Use this BEFORE deciding you're done with a task to verify all tasks are completed.
+- Returns the number of completed, in progress, and pending tasks.
+- 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** \u2014 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 \u2014 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** \u2014 Submit a completed implementation plan for user review
+- 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).`);
+  }
+  if (!isAskMode && !denied.has("subagent")) {
+    sections.push(`
+**subagent** \u2014 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");
+}
+
+// src/agents/prompts/index.ts
+function buildModePromptFromDefinition(ctx, promptBody) {
+  if (ctx.modeId === "build" && ctx.activePlan) {
+    return `# Approved Plan
+
+**${ctx.activePlan.title}**
+
+${ctx.activePlan.plan}
+
+---
+
+Implement the approved plan above. Follow the steps in order and verify each step works before moving on.
+
+${promptBody}`;
+  }
+  return promptBody;
+}
+function buildFullPrompt(ctx) {
+  const modelId = ctx.state?.currentModelId;
+  const hasWebSearch = hasTavilyKey() || !!modelId && modelId.startsWith("anthropic/");
+  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);
+    }
+  }
+  const toolGuidance = buildToolGuidance(ctx.modeId, { hasWebSearch, deniedTools });
+  const baseCtx = {
+    projectPath: ctx.workingDir,
+    projectName: ctx.projectName || "unknown",
+    gitBranch: ctx.gitBranch,
+    platform: process.platform,
+    date: ctx.currentDate,
+    mode: ctx.modeId,
+    modelId: ctx.modelId,
+    toolGuidance
+  };
+  const base = buildBasePrompt(baseCtx);
+  const modeDefinition = getModeDefinition(ctx.workingDir, ctx.modeId) ?? getModeDefinition(ctx.workingDir, "build");
+  const modeSpecific = buildModePromptFromDefinition(ctx, modeDefinition?.instructions ?? "");
+  let taskSection = "";
+  const tasks = ctx.state?.tasks;
+  if (tasks && tasks.length > 0) {
+    const lines = tasks.map((t) => {
+      const icon = t.status === "completed" ? "\u2713" : t.status === "in_progress" ? "\u25B8" : "\u25CB";
+      return `  ${icon} [${t.status}] ${t.content}`;
+    });
+    taskSection = `
+<current-task-list>
+${lines.join("\n")}
+</current-task-list>
+`;
+  }
+  const instructionSources = loadAgentInstructionsCached(ctx.workingDir);
+  const instructionsSection = formatAgentInstructions(instructionSources);
+  return base + taskSection + instructionsSection + "\n" + modeSpecific;
+}
+
+// src/agents/instructions.ts
+var promptBuildCount = 0;
+function getDynamicInstructions({ requestContext }) {
+  const startTime = performance.now();
+  const harnessContext = requestContext.get("harness");
+  const state = harnessContext?.state;
+  const modeId = harnessContext?.modeId ?? "build";
+  const projectPath = state?.projectPath ?? process.cwd();
+  const promptCtx = {
+    projectName: state?.projectName ?? "",
+    gitBranch: getCurrentGitBranch(projectPath) ?? state?.gitBranch,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    modelId: state?.currentModelId || void 0,
+    activePlan: state?.activePlan ?? null,
+    modeId,
+    currentDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    workingDir: state?.projectPath ?? process.cwd(),
+    state
+  };
+  const prompt = buildFullPrompt(promptCtx);
+  promptBuildCount += 1;
+  const durationMs = performance.now() - startTime;
+  if (promptBuildCount === 1 || durationMs >= 20) {
+    logRuntimeProfile("prompt.build", durationMs, {
+      count: promptBuildCount,
+      modeId,
+      projectPath
+    });
+  }
+  return prompt;
+}
+
+// src/constants.ts
+var DEFAULT_OM_MODEL_ID = process.env.DEFAULT_OM_MODEL_ID ?? "google/gemini-2.5-flash";
+var DEFAULT_OBS_THRESHOLD = 3e4;
+var DEFAULT_REF_THRESHOLD = 4e4;
+var claudeCodeIdentity = "You are Claude Code, Anthropic's official CLI for Claude.";
+var authStorageInstance = null;
+function getAuthStorage() {
+  if (!authStorageInstance) {
+    authStorageInstance = new AuthStorage();
+  }
+  return authStorageInstance;
+}
+function setAuthStorage(storage) {
+  authStorageInstance = storage ?? null;
+}
+var claudeCodeMiddleware = {
+  specificationVersion: "v3",
+  transformParams: async ({ params }) => {
+    const systemMessage = {
+      role: "system",
+      content: claudeCodeIdentity
+    };
+    if (params.temperature) {
+      delete params.topP;
+    }
+    return {
+      ...params,
+      prompt: [systemMessage, ...params.prompt]
+    };
+  }
+};
+var promptCacheMiddleware = {
+  specificationVersion: "v3",
+  transformParams: async ({ params }) => {
+    const prompt = [...params.prompt];
+    const cacheControl = { type: "ephemeral", ttl: "5m" };
+    const addCacheToMessage = (msg) => {
+      if (typeof msg.content === "string") {
+        return {
+          ...msg,
+          providerOptions: {
+            ...msg.providerOptions,
+            anthropic: { ...msg.providerOptions?.anthropic, cacheControl }
+          }
+        };
+      }
+      if (Array.isArray(msg.content) && msg.content.length > 0) {
+        const content = [...msg.content];
+        const lastPart = content[content.length - 1];
+        content[content.length - 1] = {
+          ...lastPart,
+          providerOptions: {
+            ...lastPart.providerOptions,
+            anthropic: { ...lastPart.providerOptions?.anthropic, cacheControl }
+          }
+        };
+        return { ...msg, content };
+      }
+      return msg;
+    };
+    let lastSystemIdx = -1;
+    for (let i = prompt.length - 1; i >= 0; i--) {
+      if (prompt[i].role === "system") {
+        lastSystemIdx = i;
+        break;
+      }
+    }
+    if (lastSystemIdx >= 0) {
+      prompt[lastSystemIdx] = addCacheToMessage(prompt[lastSystemIdx]);
+    }
+    const lastIdx = prompt.length - 1;
+    if (lastIdx >= 0 && lastIdx !== lastSystemIdx) {
+      prompt[lastIdx] = addCacheToMessage(prompt[lastIdx]);
+    }
+    return { ...params, prompt };
+  }
+};
+function opencodeClaudeMaxProvider(modelId = "claude-sonnet-4-20250514") {
+  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    const anthropic2 = createAnthropic({
+      apiKey: "test-api-key"
+    });
+    return wrapLanguageModel({
+      model: anthropic2(modelId),
+      middleware: [claudeCodeMiddleware, promptCacheMiddleware]
+    });
+  }
+  const oauthFetch = async (url, init) => {
+    const authStorage2 = getAuthStorage();
+    authStorage2.reload();
+    const storedCred = authStorage2.get("anthropic");
+    if (storedCred?.type === "api_key") {
+      throw new Error(
+        "Anthropic API key credential is configured, but Claude Max OAuth provider requires OAuth credentials."
+      );
+    }
+    const accessToken = await authStorage2.getApiKey("anthropic");
+    if (!accessToken) {
+      throw new Error("Not logged in to Anthropic. Run /login first.");
+    }
+    return fetch(url, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20,claude-code-20250219,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
+        "anthropic-version": "2023-06-01"
+      }
+    });
+  };
+  const anthropic = createAnthropic({
+    // Provide a dummy API key - the actual auth is handled via OAuth in oauthFetch
+    // This prevents the SDK from throwing "API key is missing" at model creation time
+    apiKey: "oauth-placeholder",
+    fetch: oauthFetch
+  });
+  return wrapLanguageModel({
+    model: anthropic(modelId),
+    middleware: [claudeCodeMiddleware, promptCacheMiddleware]
+  });
+}
+var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var authStorageInstance2 = null;
+function getAuthStorage2() {
+  if (!authStorageInstance2) {
+    authStorageInstance2 = new AuthStorage();
+  }
+  return authStorageInstance2;
+}
+function setAuthStorage2(storage) {
+  authStorageInstance2 = storage ?? null;
+}
+var CODEX_INSTRUCTIONS = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;
+var GPT5_MODEL_RE = /^gpt-5(?:\.|-|$)/;
+function getEffectiveThinkingLevel(modelId, level) {
+  if (GPT5_MODEL_RE.test(modelId) && level === "off") {
+    return "low";
+  }
+  return level;
+}
+var THINKING_LEVEL_TO_REASONING_EFFORT = {
+  off: void 0,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh"
+};
+function createCodexMiddleware(reasoningEffort) {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      if (params.temperature !== void 0 && params.temperature !== null) {
+        delete params.topP;
+      }
+      params.providerOptions = {
+        ...params.providerOptions,
+        openai: {
+          ...params.providerOptions?.openai ?? {},
+          instructions: CODEX_INSTRUCTIONS,
+          // Codex API requires store to be false
+          store: false,
+          // Enable reasoning for Codex models — without this, the model
+          // skips the reasoning/action phase and goes straight to final_answer,
+          // resulting in narration instead of tool calls.
+          ...reasoningEffort ? { reasoningEffort } : {}
+        }
+      };
+      return params;
+    }
+  };
+}
+function openaiCodexProvider(modelId = "codex-mini-latest", options) {
+  const requestedLevel = options?.thinkingLevel ?? "medium";
+  const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);
+  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
+  const middleware = createCodexMiddleware(reasoningEffort);
+  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    const openai2 = createOpenAI({
+      apiKey: "test-api-key"
+    });
+    return wrapLanguageModel({
+      model: openai2.responses(modelId),
+      middleware: [middleware]
+    });
+  }
+  const oauthFetch = async (url, init) => {
+    const authStorage2 = getAuthStorage2();
+    authStorage2.reload();
+    const cred = authStorage2.get("openai-codex");
+    if (!cred || cred.type !== "oauth") {
+      throw new Error("Not logged in to OpenAI Codex. Run /login first.");
+    }
+    let accessToken = cred.access;
+    if (Date.now() >= cred.expires) {
+      const refreshedToken = await authStorage2.getApiKey("openai-codex");
+      if (!refreshedToken) {
+        throw new Error("Failed to refresh OpenAI Codex token. Please /login again.");
+      }
+      accessToken = refreshedToken;
+      authStorage2.reload();
+    }
+    const accountId = cred.accountId;
+    const headers = new Headers();
+    if (init?.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          if (key.toLowerCase() !== "authorization") {
+            headers.set(key, value);
+          }
+        });
+      } else if (Array.isArray(init.headers)) {
+        for (const [key, value] of init.headers) {
+          if (key.toLowerCase() !== "authorization" && value !== void 0) {
+            headers.set(key, String(value));
+          }
+        }
+      } else {
+        for (const [key, value] of Object.entries(init.headers)) {
+          if (key.toLowerCase() !== "authorization" && value !== void 0) {
+            headers.set(key, String(value));
+          }
+        }
+      }
+    }
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    if (accountId) {
+      headers.set("ChatGPT-Account-Id", accountId);
+    }
+    const parsed = url instanceof URL ? url : new URL(typeof url === "string" ? url : url.url);
+    const shouldRewrite = parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions");
+    const finalUrl = shouldRewrite ? new URL(CODEX_API_ENDPOINT) : parsed;
+    return fetch(finalUrl, {
+      ...init,
+      headers
+    });
+  };
+  const openai = createOpenAI({
+    // Use a dummy API key since we're using OAuth
+    apiKey: "oauth-dummy-key",
+    fetch: oauthFetch
+  });
+  return wrapLanguageModel({
+    model: openai.responses(modelId),
+    middleware: [middleware]
+  });
+}
+
+// src/agents/model.ts
+var authStorage = new AuthStorage();
+var OPENAI_PREFIX = "openai/";
+var GOOGLE_PREFIX = "google/";
+var CODEX_OPENAI_MODEL_REMAPS = {
+  "gpt-5.3": "gpt-5.3-codex",
+  "gpt-5.2": "gpt-5.2-codex",
+  "gpt-5.1": "gpt-5.1-codex",
+  "gpt-5.1-mini": "gpt-5.1-codex-mini",
+  "gpt-5": "gpt-5-codex"
+};
+function remapOpenAIModelForCodexOAuth(modelId) {
+  if (!modelId.startsWith(OPENAI_PREFIX)) {
+    return modelId;
+  }
+  const openaiModelId = modelId.substring(OPENAI_PREFIX.length);
+  if (openaiModelId.includes("-codex")) {
+    return modelId;
+  }
+  const codexModelId = CODEX_OPENAI_MODEL_REMAPS[openaiModelId];
+  if (!codexModelId) {
+    return modelId;
+  }
+  return `${OPENAI_PREFIX}${codexModelId}`;
+}
+function getAnthropicApiKey() {
+  const storedCred = authStorage.get("anthropic");
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  return void 0;
+}
+function getOpenAIApiKey() {
+  const storedCred = authStorage.get("openai-codex");
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  return void 0;
+}
+function getGoogleApiKey() {
+  const storedCred = authStorage.get("google");
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  return void 0;
+}
+function anthropicApiKeyProvider(modelId, apiKey) {
+  const anthropic = createAnthropic({ apiKey });
+  return wrapLanguageModel({
+    model: anthropic(modelId),
+    middleware: [promptCacheMiddleware]
+  });
+}
+function openaiApiKeyProvider(modelId, apiKey) {
+  const openai = createOpenAI({ apiKey });
+  return wrapLanguageModel({
+    model: openai.responses(modelId),
+    middleware: []
+  });
+}
+function resolveModel(modelId, options) {
+  authStorage.reload();
+  const [providerId, modelName] = modelId.split("/", 2);
+  const settings = loadSettingsCached();
+  const customProvider = providerId && modelName ? settings.customProviders.find((provider) => {
+    return providerId === getCustomProviderId(provider.name);
+  }) : void 0;
+  if (customProvider) {
+    return new ModelRouterLanguageModel({
+      id: modelId,
+      url: customProvider.url,
+      apiKey: customProvider.apiKey
+    });
+  }
+  const isAnthropicModel = modelId.startsWith("anthropic/");
+  const isOpenAIModel = modelId.startsWith(OPENAI_PREFIX);
+  const isGoogleModel = modelId.startsWith(GOOGLE_PREFIX);
+  const isMoonshotModel = modelId.startsWith("moonshotai/");
+  if (isMoonshotModel) {
+    if (!process.env.MOONSHOT_AI_API_KEY) {
+      throw new Error(`Need MOONSHOT_AI_API_KEY`);
+    }
+    return createAnthropic({
+      apiKey: process.env.MOONSHOT_AI_API_KEY,
+      baseURL: "https://api.moonshot.ai/anthropic/v1",
+      name: "moonshotai.anthropicv1"
+    })(modelId.substring("moonshotai/".length));
+  } else if (isAnthropicModel) {
+    const bareModelId = modelId.substring("anthropic/".length);
+    const storedCred = authStorage.get("anthropic");
+    if (storedCred?.type === "oauth") {
+      return opencodeClaudeMaxProvider(bareModelId);
+    }
+    if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+      return anthropicApiKeyProvider(bareModelId, storedCred.key.trim());
+    }
+    const apiKey = getAnthropicApiKey();
+    if (apiKey) {
+      return anthropicApiKeyProvider(bareModelId, apiKey);
+    }
+    return opencodeClaudeMaxProvider(bareModelId);
+  } else if (isOpenAIModel) {
+    const bareModelId = modelId.substring(OPENAI_PREFIX.length);
+    const storedCred = authStorage.get("openai-codex");
+    if (storedCred?.type === "oauth") {
+      const resolvedModelId = options?.remapForCodexOAuth ? remapOpenAIModelForCodexOAuth(modelId) : modelId;
+      return openaiCodexProvider(resolvedModelId.substring(OPENAI_PREFIX.length), {
+        thinkingLevel: options?.thinkingLevel
+      });
+    }
+    const apiKey = getOpenAIApiKey();
+    if (apiKey) {
+      return openaiApiKeyProvider(bareModelId, apiKey);
+    }
+    return new ModelRouterLanguageModel(modelId);
+  } else if (isGoogleModel) {
+    const bareModelId = modelId.substring(GOOGLE_PREFIX.length);
+    const apiKey = getGoogleApiKey();
+    if (apiKey) {
+      return new ModelRouterLanguageModel({
+        providerId: "google",
+        modelId: bareModelId,
+        apiKey
+      });
+    }
+    return new ModelRouterLanguageModel(modelId);
+  } else {
+    return new ModelRouterLanguageModel(modelId);
+  }
+}
+function getDynamicModel({ requestContext }) {
+  const harnessContext = requestContext.get("harness");
+  const modelId = harnessContext?.state?.currentModelId;
+  if (!modelId) {
+    throw new Error("No model selected. Use /models to select a model first.");
+  }
+  const thinkingLevel = harnessContext?.state?.thinkingLevel;
+  return resolveModel(modelId, { thinkingLevel });
+}
+
+// src/agents/memory.ts
+var cachedMemory = null;
+var cachedMemoryKey = null;
+function getHarnessState(requestContext) {
+  return requestContext.get("harness")?.getState?.();
+}
+function getObserverModel({ requestContext }) {
+  const state = getHarnessState(requestContext);
+  return resolveModel(state?.observerModelId ?? DEFAULT_OM_MODEL_ID, { remapForCodexOAuth: true });
+}
+function getReflectorModel({ requestContext }) {
+  const state = getHarnessState(requestContext);
+  return resolveModel(state?.reflectorModelId ?? DEFAULT_OM_MODEL_ID, { remapForCodexOAuth: true });
+}
+function getDynamicMemory(storage) {
+  return ({ requestContext }) => {
+    const state = getHarnessState(requestContext);
+    const omScope = state?.omScope ?? getOmScope(state?.projectPath);
+    const obsThreshold = state?.observationThreshold ?? DEFAULT_OBS_THRESHOLD;
+    const refThreshold = state?.reflectionThreshold ?? DEFAULT_REF_THRESHOLD;
+    const observerPreviousObservationTokens = 1e3;
+    const cacheKey = `${obsThreshold}:${refThreshold}:${omScope}:${observerPreviousObservationTokens}`;
+    if (cachedMemory && cachedMemoryKey === cacheKey) {
+      return cachedMemory;
+    }
+    const isResourceScope = omScope === "resource";
+    cachedMemory = new Memory({
+      storage,
+      options: {
+        observationalMemory: {
+          enabled: true,
+          scope: omScope,
+          observation: {
+            bufferTokens: isResourceScope ? false : 1 / 5,
+            bufferActivation: isResourceScope ? void 0 : 2e3,
+            model: getObserverModel,
+            messageTokens: obsThreshold,
+            blockAfter: 2,
+            previousObserverTokens: observerPreviousObservationTokens
+          },
+          reflection: {
+            bufferActivation: isResourceScope ? void 0 : 1 / 2,
+            blockAfter: 1.1,
+            model: getReflectorModel,
+            observationTokens: refThreshold
+          }
+        }
+      }
+    });
+    cachedMemoryKey = cacheKey;
+    return cachedMemory;
+  };
+}
+function buildSubagentMeta(modelId, durationMs, toolCalls) {
+  const tools = toolCalls.map((toolCall) => `${toolCall.name}:${toolCall.isError ? "err" : "ok"}`).join(",");
+  return `
+<subagent-meta modelId="${modelId}" durationMs="${durationMs}" tools="${tools}" />`;
+}
+function createScopedSubagentTool(opts) {
+  const { subagents, resolveModel: resolveModel2, harnessTools, fallbackModelId } = opts;
+  const subagentIds = subagents.map((subagent) => subagent.id);
+  const typeDescriptions = subagents.map((subagent) => `- **${subagent.id}** (${subagent.name}): ${subagent.description}`).join("\n");
+  return createTool({
+    id: "subagent",
+    description: `Delegate a focused task to a specialized subagent. The subagent runs independently with a constrained toolset, then returns its findings as text.
+
+Available agent types:
+${typeDescriptions}
+
+The subagent runs in its own context - it does NOT see the parent conversation history. Write a clear, self-contained task description.
+
+Use this tool when:
+- You want to run multiple investigations in parallel
+- The task is self-contained and can be delegated`,
+    inputSchema: z.object({
+      agentType: z.enum(subagentIds).describe("Type of subagent to spawn"),
+      task: z.string().describe(
+        "Clear, self-contained description of what the subagent should do. Include all relevant context - the subagent cannot see the parent conversation."
+      ),
+      modelId: z.string().optional().describe("Optional model ID override for this task.")
+    }),
+    execute: async ({ agentType, task, modelId }, context) => {
+      const definition = subagents.find((subagent2) => subagent2.id === agentType);
+      if (!definition) {
+        return {
+          content: `Unknown agent type: ${agentType}. Valid types: ${subagentIds.join(", ")}`,
+          isError: true
+        };
+      }
+      const harnessCtx = context?.requestContext?.get("harness");
+      const emitEvent = harnessCtx?.emitEvent;
+      const abortSignal = harnessCtx?.abortSignal;
+      const toolCallId = context?.agent?.toolCallId ?? "unknown";
+      const mergedTools = { ...definition.tools ?? {} };
+      if (definition.allowedHarnessTools && harnessTools) {
+        for (const toolId of definition.allowedHarnessTools) {
+          if (harnessTools[toolId] && !mergedTools[toolId]) {
+            mergedTools[toolId] = harnessTools[toolId];
+          }
+        }
+      }
+      const harnessModelId = harnessCtx?.getSubagentModelId?.({ agentType }) ?? void 0;
+      const resolvedModelId = modelId ?? harnessModelId ?? definition.defaultModelId ?? fallbackModelId;
+      if (!resolvedModelId) {
+        return { content: "No model ID available for subagent. Configure defaultModelId.", isError: true };
+      }
+      let model;
+      try {
+        model = resolveModel2(resolvedModelId);
+      } catch (error) {
+        return {
+          content: `Failed to resolve model "${resolvedModelId}": ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+      const workspace = context?.workspace;
+      const subagent = new Agent({
+        id: `subagent-${definition.id}`,
+        name: `${definition.name} Subagent`,
+        instructions: definition.instructions,
+        model,
+        tools: mergedTools,
+        workspace
+      });
+      const allWorkspaceToolNames = workspace ? new Set(Object.keys(createWorkspaceTools(workspace))) : void 0;
+      const allowedWorkspaceTools = definition.allowedWorkspaceTools ? new Set(definition.allowedWorkspaceTools) : void 0;
+      const startTime = Date.now();
+      emitEvent?.({
+        type: "subagent_start",
+        toolCallId,
+        agentType,
+        task,
+        modelId: resolvedModelId
+      });
+      let partialText = "";
+      const toolCallLog = [];
+      try {
+        const response = await subagent.stream(task, {
+          maxSteps: definition.maxSteps ?? (definition.stopWhen ? void 0 : 50),
+          stopWhen: definition.stopWhen,
+          abortSignal,
+          requireToolApproval: false,
+          requestContext: context?.requestContext,
+          prepareStep: allowedWorkspaceTools && allWorkspaceToolNames ? ({ tools }) => ({
+            activeTools: Object.keys(tools ?? {}).filter((toolName) => {
+              return !allWorkspaceToolNames.has(toolName) || allowedWorkspaceTools.has(toolName);
+            })
+          }) : void 0
+        });
+        for await (const chunk of response.fullStream) {
+          switch (chunk.type) {
+            case "text-delta":
+              partialText += chunk.payload.text;
+              emitEvent?.({
+                type: "subagent_text_delta",
+                toolCallId,
+                agentType,
+                textDelta: chunk.payload.text
+              });
+              break;
+            case "tool-call":
+              toolCallLog.push({ name: chunk.payload.toolName, toolCallId: chunk.payload.toolCallId });
+              emitEvent?.({
+                type: "subagent_tool_start",
+                toolCallId,
+                agentType,
+                subToolName: chunk.payload.toolName,
+                subToolArgs: chunk.payload.args
+              });
+              break;
+            case "tool-result": {
+              const isError = chunk.payload.isError ?? false;
+              for (let index = toolCallLog.length - 1; index >= 0; index -= 1) {
+                if (toolCallLog[index].toolCallId === chunk.payload.toolCallId && toolCallLog[index].isError === void 0) {
+                  toolCallLog[index].isError = isError;
+                  break;
+                }
+              }
+              emitEvent?.({
+                type: "subagent_tool_end",
+                toolCallId,
+                agentType,
+                subToolName: chunk.payload.toolName,
+                subToolResult: chunk.payload.result,
+                isError
+              });
+              break;
+            }
+          }
+        }
+        if (abortSignal?.aborted) {
+          const durationMs2 = Date.now() - startTime;
+          const abortResult = partialText ? `[Aborted by user]
+
+Partial output:
+${partialText}` : "[Aborted by user]";
+          emitEvent?.({ type: "subagent_end", toolCallId, agentType, result: abortResult, isError: false, durationMs: durationMs2 });
+          return { content: abortResult + buildSubagentMeta(resolvedModelId, durationMs2, toolCallLog), isError: false };
+        }
+        const fullOutput = await response.getFullOutput();
+        const resultText = fullOutput.text || partialText;
+        const durationMs = Date.now() - startTime;
+        emitEvent?.({ type: "subagent_end", toolCallId, agentType, result: resultText, isError: false, durationMs });
+        return { content: resultText + buildSubagentMeta(resolvedModelId, durationMs, toolCallLog), isError: false };
+      } catch (error) {
+        const isAbort = error instanceof Error && (error.name === "AbortError" || error.message.includes("abort") || error.message.includes("cancel"));
+        const durationMs = Date.now() - startTime;
+        if (isAbort) {
+          const abortResult = partialText ? `[Aborted by user]
+
+Partial output:
+${partialText}` : "[Aborted by user]";
+          emitEvent?.({ type: "subagent_end", toolCallId, agentType, result: abortResult, isError: false, durationMs });
+          return { content: abortResult + buildSubagentMeta(resolvedModelId, durationMs, toolCallLog), isError: false };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        emitEvent?.({ type: "subagent_end", toolCallId, agentType, result: message, isError: true, durationMs });
+        return {
+          content: `Subagent "${definition.name}" failed: ${message}${buildSubagentMeta(resolvedModelId, durationMs, toolCallLog)}`,
+          isError: true
+        };
+      }
+    }
+  });
+}
+function applyModeScopedSubagentGuardrails(opts) {
+  const originalBuildToolsets = opts.harness.buildToolsets.bind(opts.harness);
+  opts.harness.buildToolsets = async (requestContext) => {
+    const toolsets = await originalBuildToolsets(requestContext);
+    const builtInTools = toolsets.harnessBuiltIn;
+    if (!builtInTools?.subagent) {
+      return toolsets;
+    }
+    const currentModeId = opts.harness.getCurrentModeId();
+    const allowedSubagentIds = new Set(opts.getAllowedSubagentIdsForMode(currentModeId));
+    if (allowedSubagentIds.size === 0) {
+      delete builtInTools.subagent;
+      return toolsets;
+    }
+    const modeScopedSubagents = opts.subagents.filter((subagent) => allowedSubagentIds.has(subagent.id));
+    builtInTools.subagent = createScopedSubagentTool({
+      subagents: modeScopedSubagents,
+      resolveModel: opts.resolveModel,
+      harnessTools: toolsets.harness,
+      fallbackModelId: opts.harness.getCurrentMode().defaultModelId
+    });
+    return toolsets;
+  };
+}
+function wrapToolWithHooks(toolName, tool, hookManager) {
+  if (!hookManager || typeof tool?.execute !== "function") {
+    return tool;
+  }
+  return {
+    ...tool,
+    async execute(input, toolContext) {
+      const preResult = await hookManager.runPreToolUse(toolName, input);
+      if (!preResult.allowed) {
+        return {
+          error: preResult.blockReason ?? `Blocked by PreToolUse hook for tool "${toolName}"`
+        };
+      }
+      let output;
+      let toolError = false;
+      try {
+        output = await tool.execute(input, toolContext);
+        return output;
+      } catch (error) {
+        toolError = true;
+        output = {
+          error: error instanceof Error ? error.message : String(error)
+        };
+        throw error;
+      } finally {
+        await hookManager.runPostToolUse(toolName, input, output, toolError).catch(() => void 0);
+      }
+    }
+  };
+}
+function createDynamicTools(mcpManager, extraTools, hookManager, disabledTools) {
+  return function getDynamicTools({ requestContext }) {
+    const ctx = requestContext.get("harness");
+    const state = ctx?.getState?.();
+    const modeId = ctx?.modeId ?? "build";
+    const modelId = state?.currentModelId;
+    const isAnthropicModel = modelId?.startsWith("anthropic/");
+    const isOpenAIModel = modelId?.startsWith("openai/");
+    const tools = {
+      request_access: requestSandboxAccessTool
+    };
+    if (hasTavilyKey()) {
+      tools.web_search = createWebSearchTool();
+      tools.web_extract = createWebExtractTool();
+    } else if (isAnthropicModel) {
+      const anthropic = createAnthropic({});
+      tools.web_search = anthropic.tools.webSearch_20250305();
+    } else if (isOpenAIModel) {
+      const openai = createOpenAI({});
+      tools.web_search = openai.tools.webSearch();
+    }
+    if (mcpManager) {
+      const mcpTools = mcpManager.getTools();
+      Object.assign(tools, mcpTools);
+    }
+    if (extraTools) {
+      const resolved = typeof extraTools === "function" ? extraTools({ requestContext }) : extraTools;
+      for (const [name, tool] of Object.entries(resolved)) {
+        if (!(name in tools)) {
+          tools[name] = tool;
+        }
+      }
+    }
+    if (modeId === "ask") {
+      delete tools.request_access;
+    }
+    if (disabledTools?.length) {
+      for (const toolName of disabledTools) {
+        delete tools[toolName];
+      }
+    }
+    const permissionRules = state?.permissionRules;
+    if (permissionRules?.tools) {
+      for (const [name, policy] of Object.entries(permissionRules.tools)) {
+        if (policy === "deny") {
+          delete tools[name];
+        }
+      }
+    }
+    for (const [toolName, tool] of Object.entries(tools)) {
+      tools[toolName] = wrapToolWithHooks(toolName, tool, hookManager);
+    }
+    return tools;
+  };
+}
+var VALID_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "UserPromptSubmit",
+  "SessionStart",
+  "SessionEnd"
+];
+function loadHooksConfig(projectDir) {
+  const globalPath = getGlobalHooksPath();
+  const projectPath = getProjectHooksPath(projectDir);
+  const globalConfig = loadSingleConfig(
+    globalPath,
+    getLegacyUliCliGlobalHooksPath(),
+    getLegacyPulseGlobalHooksPath(),
+    getLegacyMastraGlobalHooksPath()
+  );
+  const projectConfig = loadSingleConfig(
+    projectPath,
+    getLegacyUliCliProjectHooksPath(projectDir),
+    getLegacyPulseProjectHooksPath(projectDir),
+    getLegacyMastraProjectHooksPath(projectDir)
+  );
+  return mergeConfigs(globalConfig, projectConfig);
+}
+function getProjectHooksPath(projectDir) {
+  return path.join(projectDir, ".ulicode", "hooks.json");
+}
+function getGlobalHooksPath() {
+  return path.join(os.homedir(), ".ulicode", "hooks.json");
+}
+function getLegacyUliCliProjectHooksPath(projectDir) {
+  return path.join(projectDir, ".uli-cli", "hooks.json");
+}
+function getLegacyUliCliGlobalHooksPath() {
+  return path.join(os.homedir(), ".uli-cli", "hooks.json");
+}
+function getLegacyPulseProjectHooksPath(projectDir) {
+  return path.join(projectDir, ".pulse", "hooks.json");
+}
+function getLegacyPulseGlobalHooksPath() {
+  return path.join(os.homedir(), ".pulse", "hooks.json");
+}
+function getLegacyMastraProjectHooksPath(projectDir) {
+  return path.join(projectDir, ".mastracode", "hooks.json");
+}
+function getLegacyMastraGlobalHooksPath() {
+  return path.join(os.homedir(), ".mastracode", "hooks.json");
+}
+function loadSingleConfig(filePath, ...fallbackPaths) {
+  try {
+    const resolvedPath = [filePath, ...fallbackPaths].find((candidate) => candidate && fs4.existsSync(candidate)) ?? null;
+    if (!resolvedPath) return {};
+    const raw = fs4.readFileSync(resolvedPath, "utf-8");
+    return validateConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+function validateConfig(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const config = {};
+  const obj = raw;
+  for (const event of VALID_EVENTS) {
+    if (Array.isArray(obj[event])) {
+      const hooks = obj[event].filter(isValidHook);
+      if (hooks.length > 0) {
+        config[event] = hooks;
+      }
+    }
+  }
+  return config;
+}
+function isValidHook(raw) {
+  if (!raw || typeof raw !== "object") return false;
+  const obj = raw;
+  return obj.type === "command" && typeof obj.command === "string";
+}
+function mergeConfigs(global, project) {
+  const merged = {};
+  for (const event of VALID_EVENTS) {
+    const combined = [...global[event] ?? [], ...project[event] ?? []];
+    if (combined.length > 0) {
+      merged[event] = combined;
+    }
+  }
+  return merged;
+}
+
+// src/hooks/types.ts
+function isBlockingEvent(event) {
+  return event === "PreToolUse" || event === "Stop" || event === "UserPromptSubmit";
+}
+
+// src/hooks/executor.ts
+var DEFAULT_TIMEOUT = 1e4;
+var FORCE_KILL_GRACE_MS = 250;
+async function executeHook(hook, stdinPayload) {
+  const timeout = hook.timeout ?? DEFAULT_TIMEOUT;
+  const startTime = Date.now();
+  return new Promise((resolve3) => {
+    const isWindows = process.platform === "win32";
+    const shell = isWindows ? "cmd" : "/bin/sh";
+    const shellArgs = isWindows ? ["/c", hook.command] : ["-c", hook.command];
+    const child = spawn(shell, shellArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: stdinPayload.cwd,
+      env: {
+        ...process.env,
+        MASTRA_HOOK_EVENT: stdinPayload.hook_event_name
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let resolved = false;
+    let forceKillTimer;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      forceKillTimer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, FORCE_KILL_GRACE_MS);
+    }, timeout);
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      if (resolved) return;
+      resolved = true;
+      let parsedStdout;
+      if (stdout.trim()) {
+        try {
+          parsedStdout = JSON.parse(stdout.trim());
+        } catch {
+        }
+      }
+      const result = {
+        hook,
+        exitCode: exitCode ?? 1,
+        stdout: parsedStdout,
+        stderr: stderr.trim() || void 0,
+        timedOut,
+        durationMs: Date.now() - startTime
+      };
+      logRuntimeProfile("hooks.execute", result.durationMs, {
+        event: stdinPayload.hook_event_name,
+        command: hook.command,
+        timedOut,
+        exitCode: result.exitCode
+      });
+      resolve3(result);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      if (resolved) return;
+      resolved = true;
+      const result = {
+        hook,
+        exitCode: 1,
+        stderr: error.message,
+        timedOut: false,
+        durationMs: Date.now() - startTime
+      };
+      logRuntimeProfile("hooks.execute", result.durationMs, {
+        event: stdinPayload.hook_event_name,
+        command: hook.command,
+        timedOut: false,
+        exitCode: result.exitCode,
+        error: error.message
+      });
+      resolve3(result);
+    });
+    try {
+      child.stdin?.write(JSON.stringify(stdinPayload));
+      child.stdin?.end();
+    } catch {
+    }
+  });
+}
+function matchesHook(hook, context) {
+  if (!hook.matcher) return true;
+  if (hook.matcher.tool_name) {
+    if (!context.tool_name) return false;
+    try {
+      return new RegExp(hook.matcher.tool_name).test(context.tool_name);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function runHooksForEvent(hooks, stdinPayload, matchContext = {}) {
+  const results = [];
+  const warnings = [];
+  let additionalContext;
+  const applicable = hooks.filter((h) => matchesHook(h, matchContext));
+  if (applicable.length === 0) {
+    return { allowed: true, results: [], warnings: [] };
+  }
+  const blocking = isBlockingEvent(stdinPayload.hook_event_name);
+  if (!blocking) {
+    const concurrentResults = await Promise.all(applicable.map((hook) => executeHook(hook, stdinPayload)));
+    for (const result of concurrentResults) {
+      results.push(result);
+      if (result.stdout?.additionalContext) {
+        additionalContext = additionalContext ? `${additionalContext}
+${result.stdout.additionalContext}` : result.stdout.additionalContext;
+      }
+      if (result.timedOut) {
+        warnings.push(`Hook timed out after ${result.hook.timeout ?? DEFAULT_TIMEOUT}ms: ${result.hook.command}`);
+        continue;
+      }
+      if (result.exitCode === 0) continue;
+      const warnMsg = result.stderr || `Hook exited with code ${result.exitCode}`;
+      warnings.push(`${result.hook.description || result.hook.command}: ${warnMsg}`);
+    }
+    return { allowed: true, additionalContext, results, warnings };
+  }
+  for (const hook of applicable) {
+    const result = await executeHook(hook, stdinPayload);
+    results.push(result);
+    if (result.stdout?.additionalContext) {
+      additionalContext = additionalContext ? `${additionalContext}
+${result.stdout.additionalContext}` : result.stdout.additionalContext;
+    }
+    if (result.timedOut) {
+      warnings.push(`Hook timed out after ${hook.timeout ?? DEFAULT_TIMEOUT}ms: ${hook.command}`);
+      continue;
+    }
+    if (result.exitCode === 2 && blocking) {
+      const reason = result.stdout?.reason || result.stderr || `Blocked by hook: ${hook.description || hook.command}`;
+      return {
+        allowed: false,
+        blockReason: reason,
+        additionalContext,
+        results,
+        warnings
+      };
+    }
+    if (result.exitCode === 0) continue;
+    const warnMsg = result.stderr || `Hook exited with code ${result.exitCode}`;
+    warnings.push(`${hook.description || hook.command}: ${warnMsg}`);
+  }
+  return { allowed: true, additionalContext, results, warnings };
+}
+
+// src/hooks/manager.ts
+var HookManager = class {
+  config;
+  projectDir;
+  sessionId;
+  constructor(projectDir, sessionId) {
+    this.projectDir = projectDir;
+    this.sessionId = sessionId;
+    this.config = loadHooksConfig(projectDir);
+  }
+  reload() {
+    this.config = loadHooksConfig(this.projectDir);
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  hasHooks() {
+    return Object.keys(this.config).length > 0;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getConfigPaths() {
+    return {
+      project: getProjectHooksPath(this.projectDir),
+      global: getGlobalHooksPath()
+    };
+  }
+  // =========================================================================
+  // Event Methods
+  // =========================================================================
+  async runPreToolUse(toolName, toolInput) {
+    const hooks = this.config.PreToolUse;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "PreToolUse",
+      tool_name: toolName,
+      tool_input: toolInput
+    };
+    return runHooksForEvent(hooks, stdin, { tool_name: toolName });
+  }
+  async runPostToolUse(toolName, toolInput, toolOutput, toolError) {
+    const hooks = this.config.PostToolUse;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "PostToolUse",
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_output: toolOutput,
+      tool_error: toolError
+    };
+    return runHooksForEvent(hooks, stdin, { tool_name: toolName });
+  }
+  async runUserPromptSubmit(userMessage) {
+    const hooks = this.config.UserPromptSubmit;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "UserPromptSubmit",
+      user_message: userMessage
+    };
+    return runHooksForEvent(hooks, stdin);
+  }
+  async runStop(assistantMessage, stopReason) {
+    const hooks = this.config.Stop;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "Stop",
+      assistant_message: assistantMessage,
+      stop_reason: stopReason
+    };
+    return runHooksForEvent(hooks, stdin);
+  }
+  async runSessionStart() {
+    const hooks = this.config.SessionStart;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "SessionStart"
+    };
+    return runHooksForEvent(hooks, stdin);
+  }
+  async runSessionEnd() {
+    const hooks = this.config.SessionEnd;
+    if (!hooks || hooks.length === 0) {
+      return { allowed: true, results: [], warnings: [] };
+    }
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "SessionEnd"
+    };
+    return runHooksForEvent(hooks, stdin);
+  }
+  /**
+   * Fire notification hooks (non-blocking, fire-and-forget).
+   * Called when the TUI is waiting for user input.
+   */
+  runNotification(reason, message) {
+    const hooks = this.config.Notification;
+    if (!hooks || hooks.length === 0) return;
+    const stdin = {
+      session_id: this.sessionId,
+      cwd: this.projectDir,
+      hook_event_name: "Notification",
+      reason,
+      message
+    };
+    runHooksForEvent(hooks, stdin).catch(() => {
+    });
+  }
+};
+function loadMcpConfig(projectDir) {
+  const claudeConfig = loadClaudeSettings(projectDir);
+  const globalConfig = loadSingleConfig2(
+    getGlobalMcpPath(),
+    getLegacyUliCliGlobalMcpPath(),
+    getLegacyPulseGlobalMcpPath(),
+    getLegacyMastraGlobalMcpPath()
+  );
+  const projectConfig = loadSingleConfig2(
+    getProjectMcpPath(projectDir),
+    getLegacyUliCliProjectMcpPath(projectDir),
+    getLegacyPulseProjectMcpPath(projectDir),
+    getLegacyMastraProjectMcpPath(projectDir)
+  );
+  return mergeConfigs2(claudeConfig, globalConfig, projectConfig);
+}
+function getProjectMcpPath(projectDir) {
+  return path.join(projectDir, ".ulicode", "mcp.json");
+}
+function getGlobalMcpPath() {
+  return path.join(os.homedir(), ".ulicode", "mcp.json");
+}
+function getLegacyUliCliProjectMcpPath(projectDir) {
+  return path.join(projectDir, ".uli-cli", "mcp.json");
+}
+function getLegacyUliCliGlobalMcpPath() {
+  return path.join(os.homedir(), ".uli-cli", "mcp.json");
+}
+function getLegacyPulseProjectMcpPath(projectDir) {
+  return path.join(projectDir, ".pulse", "mcp.json");
+}
+function getLegacyPulseGlobalMcpPath() {
+  return path.join(os.homedir(), ".pulse", "mcp.json");
+}
+function getLegacyMastraProjectMcpPath(projectDir) {
+  return path.join(projectDir, ".mastracode", "mcp.json");
+}
+function getLegacyMastraGlobalMcpPath() {
+  return path.join(os.homedir(), ".mastracode", "mcp.json");
+}
+function getClaudeSettingsPath(projectDir) {
+  return path.join(projectDir, ".claude", "settings.local.json");
+}
+function loadSingleConfig2(filePath, ...fallbackPaths) {
+  try {
+    const resolvedPath = [filePath, ...fallbackPaths].find((candidate) => candidate && fs4.existsSync(candidate)) ?? null;
+    if (!resolvedPath) return {};
+    const raw = fs4.readFileSync(resolvedPath, "utf-8");
+    return validateConfig2(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+function loadClaudeSettings(projectDir) {
+  try {
+    const filePath = getClaudeSettingsPath(projectDir);
+    if (!fs4.existsSync(filePath)) return {};
+    const raw = fs4.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.mcpServers && typeof parsed.mcpServers === "object") {
+      return validateConfig2({ mcpServers: parsed.mcpServers });
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function classifyServerEntry(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { kind: "skip", reason: "Invalid entry: expected an object" };
+  }
+  const obj = raw;
+  const hasCommand = typeof obj.command === "string";
+  const hasUrl = typeof obj.url === "string";
+  if (hasCommand && hasUrl) {
+    return { kind: "skip", reason: 'Cannot specify both "command" and "url"' };
+  }
+  if (hasCommand) {
+    return { kind: "stdio" };
+  }
+  if (hasUrl) {
+    try {
+      new URL(obj.url);
+    } catch {
+      return { kind: "skip", reason: `Invalid URL: "${obj.url}"` };
+    }
+    return { kind: "http" };
+  }
+  return { kind: "skip", reason: 'Missing required field: "command" (stdio) or "url" (http)' };
+}
+function validateConfig2(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const obj = raw;
+  if (!obj.mcpServers || typeof obj.mcpServers !== "object") return {};
+  const servers = {};
+  const skippedServers = [];
+  const rawServers = obj.mcpServers;
+  for (const [name, entry] of Object.entries(rawServers)) {
+    const classification = classifyServerEntry(entry);
+    if (classification.kind === "stdio") {
+      const e = entry;
+      servers[name] = {
+        command: e.command,
+        args: Array.isArray(e.args) ? e.args : void 0,
+        env: typeof e.env === "object" && e.env !== null ? e.env : void 0
+      };
+    } else if (classification.kind === "http") {
+      const e = entry;
+      servers[name] = {
+        url: e.url,
+        headers: typeof e.headers === "object" && e.headers !== null ? e.headers : void 0
+      };
+    } else {
+      skippedServers.push({ name, reason: classification.reason });
+    }
+  }
+  const result = {};
+  if (Object.keys(servers).length > 0) {
+    result.mcpServers = servers;
+  }
+  if (skippedServers.length > 0) {
+    result.skippedServers = skippedServers;
+  }
+  return result;
+}
+function mergeConfigs2(...configs) {
+  const merged = {};
+  const allSkipped = [];
+  for (const config of configs) {
+    if (config.mcpServers) {
+      for (const [name, server] of Object.entries(config.mcpServers)) {
+        merged[name] = server;
+      }
+    }
+    if (config.skippedServers) {
+      allSkipped.push(...config.skippedServers);
+    }
+  }
+  const validNames = new Set(Object.keys(merged));
+  const filteredSkipped = allSkipped.filter((s) => !validNames.has(s.name));
+  const skippedMap = /* @__PURE__ */ new Map();
+  for (const s of filteredSkipped) {
+    skippedMap.set(s.name, s);
+  }
+  const result = {};
+  if (Object.keys(merged).length > 0) {
+    result.mcpServers = merged;
+  }
+  if (skippedMap.size > 0) {
+    result.skippedServers = Array.from(skippedMap.values());
+  }
+  return result;
+}
+
+// src/mcp/manager.ts
+function getTransport(cfg) {
+  return "url" in cfg ? "http" : "stdio";
+}
+function createMcpManager(projectDir, extraServers) {
+  const applyExtraServers = (base) => {
+    if (!extraServers || Object.keys(extraServers).length === 0) return base;
+    return { ...base, mcpServers: { ...base.mcpServers, ...extraServers } };
+  };
+  let config = applyExtraServers(loadMcpConfig(projectDir));
+  let client = null;
+  let tools = {};
+  let serverStatuses = /* @__PURE__ */ new Map();
+  let initialized = false;
+  function buildServerDefs(servers) {
+    const defs = {};
+    for (const [name, cfg] of Object.entries(servers)) {
+      if ("url" in cfg) {
+        const httpCfg = cfg;
+        defs[name] = {
+          url: new URL(httpCfg.url),
+          requestInit: httpCfg.headers ? { headers: httpCfg.headers } : void 0
+        };
+      } else {
+        defs[name] = { command: cfg.command, args: cfg.args, env: cfg.env };
+      }
+    }
+    return defs;
+  }
+  async function connectAndCollectTools() {
+    const servers = config.mcpServers;
+    if (!servers || Object.keys(servers).length === 0) {
+      return;
+    }
+    client = new MCPClient({
+      id: "mastra-code-mcp",
+      servers: buildServerDefs(servers)
+    });
+    const serverNames = Object.keys(servers);
+    try {
+      tools = await client.listTools();
+      for (const name of serverNames) {
+        const prefix = `${name}_`;
+        const serverToolNames = Object.keys(tools).filter((t) => t.startsWith(prefix));
+        serverStatuses.set(name, {
+          name,
+          connected: true,
+          toolCount: serverToolNames.length,
+          toolNames: serverToolNames,
+          transport: getTransport(servers[name])
+        });
+      }
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      for (const name of serverNames) {
+        serverStatuses.set(name, {
+          name,
+          connected: false,
+          toolCount: 0,
+          toolNames: [],
+          transport: getTransport(servers[name]),
+          error: errMsg
+        });
+      }
+    }
+  }
+  async function disconnect() {
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+      client = null;
+    }
+  }
+  return {
+    async init() {
+      if (initialized) return;
+      await connectAndCollectTools();
+      initialized = true;
+    },
+    async reload() {
+      await disconnect();
+      config = applyExtraServers(loadMcpConfig(projectDir));
+      tools = {};
+      serverStatuses = /* @__PURE__ */ new Map();
+      initialized = false;
+      await connectAndCollectTools();
+      initialized = true;
+    },
+    disconnect,
+    getTools() {
+      return { ...tools };
+    },
+    hasServers() {
+      const hasConfigured = config.mcpServers !== void 0 && Object.keys(config.mcpServers).length > 0;
+      const hasSkipped = config.skippedServers !== void 0 && config.skippedServers.length > 0;
+      return hasConfigured || hasSkipped;
+    },
+    getServerStatuses() {
+      return Array.from(serverStatuses.values());
+    },
+    getSkippedServers() {
+      return [...config.skippedServers ?? []];
+    },
+    getConfigPaths() {
+      return {
+        project: getProjectMcpPath(projectDir),
+        global: getGlobalMcpPath(),
+        claude: getClaudeSettingsPath(projectDir)
+      };
+    },
+    getConfig() {
+      return config;
+    }
+  };
+}
+var stateSchema = z.object({
+  projectPath: z.string().optional(),
+  projectName: z.string().optional(),
+  gitBranch: z.string().optional(),
+  lastCommand: z.string().optional(),
+  currentModelId: z.string().default(""),
+  // Subagent model settings (per-thread/per-mode)
+  subagentModelId: z.string().optional(),
+  // Thread-level default for subagents
+  // Observational Memory model settings
+  observerModelId: z.string().default(DEFAULT_OM_MODEL_ID),
+  reflectorModelId: z.string().default(DEFAULT_OM_MODEL_ID),
+  // Observational Memory threshold settings
+  observationThreshold: z.number().default(3e4),
+  reflectionThreshold: z.number().default(4e4),
+  // Observational Memory scope — 'thread' (per-conversation) or 'resource' (shared across threads)
+  omScope: z.enum(["thread", "resource"]).optional(),
+  // Thinking level for model reasoning effort
+  thinkingLevel: z.enum(["off", "low", "medium", "high", "xhigh"]).default("off"),
+  // YOLO mode — auto-approve all tool calls
+  yolo: z.boolean().default(false),
+  // Permission rules — per-category and per-tool approval policies
+  permissionRules: z.object({
+    categories: z.record(z.string(), z.enum(["allow", "ask", "deny"])).default({}),
+    tools: z.record(z.string(), z.enum(["allow", "ask", "deny"])).default({})
+  }).default({ categories: {}, tools: {} }),
+  // Smart editing mode — use AST-based analysis for code edits
+  smartEditing: z.boolean().default(true),
+  // Notification mode — alert when TUI needs user attention
+  notifications: z.enum(["bell", "system", "both", "off"]).default("off"),
+  // Task list (persisted per-thread)
+  tasks: z.array(
+    z.object({
+      content: z.string(),
+      status: z.enum(["pending", "in_progress", "completed"]),
+      activeForm: z.string()
+    })
+  ).default([]),
+  // Sandbox allowed paths (per-thread, absolute paths allowed in addition to project root)
+  sandboxAllowedPaths: z.array(z.string()).default([]),
+  // Active plan (set when a plan is approved in Plan mode)
+  activePlan: z.object({
+    title: z.string(),
+    plan: z.string(),
+    approvedAt: z.string()
+  }).nullable().default(null)
+});
+var CACHE_DIR = path__default.join(os__default.homedir(), ".cache", "mastra");
+var CACHE_FILE = path__default.join(CACHE_DIR, "gateway-refresh-time");
+var GLOBAL_PROVIDER_REGISTRY_JSON = path__default.join(CACHE_DIR, "provider-registry.json");
+var GLOBAL_PROVIDER_TYPES_DTS = path__default.join(CACHE_DIR, "provider-types.generated.d.ts");
+var DEFAULT_SYNC_INTERVAL_MS = 5 * 60 * 1e3;
+var isSyncing = false;
+async function atomicWriteFile(filePath, content) {
+  const randomSuffix = Math.random().toString(36).substring(2, 15);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomSuffix}.tmp`;
+  try {
+    await fs4__default.promises.writeFile(tempPath, content, "utf-8");
+    await fs4__default.promises.rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await fs4__default.promises.unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function fetchProvidersFromGateways() {
+  const allProviders = {};
+  const allModels = {};
+  const gateways = [new ModelsDevGateway({}), new NetlifyGateway()];
+  for (const gateway of gateways) {
+    try {
+      const providers = await gateway.fetchProviders();
+      const isProviderRegistry = gateway.id === "models.dev";
+      for (const [providerId, config] of Object.entries(providers)) {
+        const typeProviderId = isProviderRegistry ? providerId : providerId === gateway.id ? gateway.id : `${gateway.id}/${providerId}`;
+        allProviders[typeProviderId] = config;
+        allModels[typeProviderId] = config.models.sort();
+      }
+    } catch (error) {
+      console.warn(`[GatewaySync] Failed to fetch from ${gateway.id}:`, error);
+    }
+  }
+  return { providers: allProviders, models: allModels };
+}
+function generateTypesContent(models) {
+  const providerModelsEntries = Object.entries(models).map(([provider, modelList]) => {
+    const modelsList = modelList.map((m) => `'${m}'`);
+    const needsQuotes = /[^a-zA-Z0-9_$]/.test(provider);
+    const providerKey = needsQuotes ? `'${provider}'` : provider;
+    const singleLine = `  readonly ${providerKey}: readonly [${modelsList.join(", ")}];`;
+    if (singleLine.length > 120) {
+      const formattedModels = modelList.map((m) => `    '${m}',`).join("\n");
+      return `  readonly ${providerKey}: readonly [
+${formattedModels}
+  ];`;
+    }
+    return singleLine;
+  }).join("\n");
+  return `/**
+ * THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+ * Generated from model gateway providers
+ */
+
+export type ProviderModelsMap = {
+${providerModelsEntries}
+};
+
+export type Provider = keyof ProviderModelsMap;
+
+export interface ProviderModels {
+  [key: string]: string[];
+}
+
+export type ModelRouterModelId =
+  | {
+      [P in Provider]: \`\${P}/\${ProviderModelsMap[P][number]}\`;
+    }[Provider]
+  | (string & {});
+
+export type ModelForProvider<P extends Provider> = ProviderModelsMap[P][number];
+`;
+}
+function getLastSyncTime() {
+  try {
+    if (!fs4__default.existsSync(CACHE_FILE)) {
+      return null;
+    }
+    const timestamp = fs4__default.readFileSync(CACHE_FILE, "utf-8").trim();
+    return new Date(parseInt(timestamp, 10));
+  } catch {
+    return null;
+  }
+}
+function saveLastSyncTime(date) {
+  try {
+    if (!fs4__default.existsSync(CACHE_DIR)) {
+      fs4__default.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    fs4__default.writeFileSync(CACHE_FILE, date.getTime().toString(), "utf-8");
+  } catch (error) {
+    console.warn("[GatewaySync] Failed to save sync time:", error);
+  }
+}
+async function syncGateways(force = false) {
+  if (isSyncing && !force) {
+    return;
+  }
+  if (!force) {
+    const lastSync = getLastSyncTime();
+    if (lastSync) {
+      const timeSinceSync = Date.now() - lastSync.getTime();
+      if (timeSinceSync < DEFAULT_SYNC_INTERVAL_MS) {
+        return;
+      }
+    }
+  }
+  isSyncing = true;
+  try {
+    const { providers, models } = await fetchProvidersFromGateways();
+    await fs4__default.promises.mkdir(CACHE_DIR, { recursive: true });
+    const registryData = {
+      providers,
+      models,
+      version: "1.0.0"
+    };
+    await atomicWriteFile(GLOBAL_PROVIDER_REGISTRY_JSON, JSON.stringify(registryData, null, 2));
+    const typesContent = generateTypesContent(models);
+    await atomicWriteFile(GLOBAL_PROVIDER_TYPES_DTS, typesContent);
+    const now = /* @__PURE__ */ new Date();
+    saveLastSyncTime(now);
+  } catch (error) {
+    console.error("[GatewaySync] \u274C Sync failed:", error);
+  } finally {
+    isSyncing = false;
+  }
+}
+function createFallbackLibSQL() {
+  return new LibSQLStore({
+    id: "mastra-code-storage",
+    url: `file:${getDatabasePath()}`
+  });
+}
+async function createStorage(config) {
+  if (config.backend === "pg") {
+    return createPgStorage(config);
+  }
+  return {
+    storage: new LibSQLStore({
+      id: "mastra-code-storage",
+      url: config.url,
+      ...config.authToken ? { authToken: config.authToken } : {}
+    })
+  };
+}
+async function createPgStorage(config) {
+  if (!config.connectionString && !config.host) {
+    return {
+      storage: createFallbackLibSQL(),
+      warning: "PostgreSQL backend selected but no connection info configured. Using LibSQL fallback. Set a connection string via /settings."
+    };
+  }
+  const base = {
+    id: "mastra-code-storage",
+    ...config.schemaName ? { schemaName: config.schemaName } : {},
+    ...config.disableInit ? { disableInit: config.disableInit } : {},
+    ...config.skipDefaultIndexes ? { skipDefaultIndexes: config.skipDefaultIndexes } : {}
+  };
+  const store = config.connectionString ? new PostgresStore({ ...base, connectionString: config.connectionString }) : new PostgresStore({
+    ...base,
+    host: config.host,
+    port: config.port,
+    database: config.database,
+    user: config.user,
+    password: config.password
+  });
+  try {
+    await store.init();
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    const target = config.connectionString ?? `${config.host}:${config.port ?? 5432}`;
+    try {
+      await store.close();
+    } catch {
+    }
+    return {
+      storage: createFallbackLibSQL(),
+      warning: `Failed to connect to PostgreSQL at ${target}: ${msg}
+Using LibSQL fallback. Fix the connection via /settings.`
+    };
+  }
+  return { storage: store };
+}
+
+// src/index.ts
+var PROVIDER_TO_OAUTH_ID = {
+  anthropic: "anthropic",
+  openai: "openai-codex"
+};
+function createAuthStorage() {
+  const authStorage2 = new AuthStorage();
+  setAuthStorage(authStorage2);
+  setAuthStorage2(authStorage2);
+  return authStorage2;
+}
+async function createMastraCode(config) {
+  const cwd = config?.cwd ?? process.cwd();
+  const authStorage2 = createAuthStorage();
+  const project = detectProject(cwd);
+  const resourceIdOverride = getResourceIdOverride(project.rootPath);
+  if (resourceIdOverride) {
+    project.resourceId = resourceIdOverride;
+    project.resourceIdOverride = true;
+  }
+  lspManager.prewarmWorkspace(project.rootPath);
+  const globalSettings = loadSettingsCached();
+  const storageConfig = config?.storage ?? getStorageConfig(project.rootPath, globalSettings.storage);
+  const storageResult = await createStorage(storageConfig);
+  const storage = storageResult.storage;
+  const storageWarning = storageResult.warning;
+  const memory = getDynamicMemory(storage);
+  const mcpManager = config?.disableMcp ? void 0 : createMcpManager(project.rootPath, config?.mcpServers);
+  const hookManager = config?.disableHooks ? void 0 : new HookManager(project.rootPath, "session-init");
+  if (hookManager?.hasHooks()) {
+    const hookConfig = hookManager.getConfig();
+    const hookCount = Object.values(hookConfig).reduce((sum, hooks) => sum + (hooks?.length ?? 0), 0);
+    console.info(`Hooks: ${hookCount} hook(s) configured`);
+  }
+  const codeAgent = new Agent({
+    id: "code-agent",
+    name: "Code Agent",
+    instructions: getDynamicInstructions,
+    model: getDynamicModel,
+    tools: createDynamicTools(mcpManager, config?.extraTools, hookManager, config?.disabledTools)
+  });
+  const agentRegistry = loadAgentDefinitionsCached(project.rootPath);
+  const defaultSubagents = createHarnessSubagentsFromDefinitions(agentRegistry);
+  const defaultModes = createHarnessModesFromDefinitions(agentRegistry, codeAgent);
+  const defaultHeartbeatHandlers = [
+    {
+      id: "gateway-sync",
+      intervalMs: 5 * 60 * 1e3,
+      handler: () => syncGateways()
+    }
+  ];
+  const anthropicCred = authStorage2.get("anthropic");
+  const openaiCred = authStorage2.get("openai-codex");
+  const startupAccess = {
+    anthropic: anthropicCred?.type === "oauth" ? "oauth" : anthropicCred?.type === "api_key" && anthropicCred.key.trim().length > 0 ? "apikey" : false,
+    openai: openaiCred?.type === "oauth" ? "oauth" : openaiCred?.type === "api_key" && openaiCred.key.trim().length > 0 ? "apikey" : false,
+    google: authStorage2.get("google")?.type === "api_key" && authStorage2.get("google").key?.trim().length ? "apikey" : process.env.GOOGLE_GENERATIVE_AI_API_KEY ? "apikey" : false,
+    cerebras: process.env.CEREBRAS_API_KEY ? "apikey" : false,
+    deepseek: process.env.DEEPSEEK_API_KEY ? "apikey" : false
+  };
+  try {
+    const registry = PROVIDER_REGISTRY;
+    for (const [provider, config2] of Object.entries(registry)) {
+      if (startupAccess[provider]) continue;
+      if (provider === "anthropic" || provider === "openai") continue;
+      const envVars = config2?.apiKeyEnvVar;
+      const envVarList = Array.isArray(envVars) ? envVars : envVars ? [envVars] : [];
+      if (envVarList.some((envVar) => process.env[envVar])) {
+        startupAccess[provider] = "apikey";
+      }
+    }
+  } catch {
+  }
+  const builtinPacks = getAvailableModePacks(startupAccess, [], agentRegistry.modes);
+  const builtinOmPacks = getAvailableOmPacks(startupAccess);
+  const effectiveDefaults = resolveModelDefaults(globalSettings, builtinPacks);
+  const effectiveOmModel = resolveOmModel(globalSettings, builtinOmPacks);
+  const modes = (config?.modes ?? defaultModes).map((mode) => {
+    const savedModel = effectiveDefaults[mode.id];
+    return savedModel ? { ...mode, defaultModelId: savedModel } : mode;
+  });
+  const subagentModeMap = getSubagentModeMap(agentRegistry);
+  const subagents = (config?.subagents ?? defaultSubagents).map((sa) => {
+    const modeId = subagentModeMap[sa.id];
+    const model = modeId ? effectiveDefaults[modeId] : void 0;
+    let filtered = sa;
+    if (config?.disabledTools?.length) {
+      if (sa.allowedWorkspaceTools) {
+        filtered = {
+          ...filtered,
+          allowedWorkspaceTools: sa.allowedWorkspaceTools.filter((t) => !config.disabledTools.includes(t))
+        };
+      }
+      if (sa.tools) {
+        filtered = {
+          ...filtered,
+          tools: Object.fromEntries(Object.entries(sa.tools).filter(([k]) => !config.disabledTools.includes(k)))
+        };
+      }
+    }
+    return model ? { ...filtered, defaultModelId: model } : filtered;
+  });
+  const globalInitialState = {};
+  if (effectiveOmModel) {
+    globalInitialState.observerModelId = effectiveOmModel;
+    globalInitialState.reflectorModelId = effectiveOmModel;
+  }
+  if (globalSettings.preferences.yolo !== null) {
+    globalInitialState.yolo = globalSettings.preferences.yolo;
+  }
+  globalInitialState.thinkingLevel = globalSettings.preferences.thinkingLevel;
+  if (config?.omScope) {
+    globalInitialState.omScope = config.omScope;
+  }
+  for (const [key, modelId] of Object.entries(globalSettings.models.subagentModels)) {
+    if (key === "_default") {
+      globalInitialState.subagentModelId = modelId;
+    } else {
+      globalInitialState[`subagentModelId_${key}`] = modelId;
+    }
+  }
+  const harness = new Harness({
+    id: "mastra-code",
+    resourceId: project.resourceId,
+    storage,
+    memory,
+    stateSchema,
+    subagents,
+    resolveModel: (modelId) => resolveModel(modelId),
+    toolCategoryResolver: getToolCategory,
+    initialState: {
+      projectPath: project.rootPath,
+      projectName: project.name,
+      gitBranch: project.gitBranch,
+      yolo: true,
+      ...globalInitialState,
+      ...config?.initialState
+    },
+    workspace: config?.workspace ?? getDynamicWorkspace,
+    modes,
+    heartbeatHandlers: config?.heartbeatHandlers ?? defaultHeartbeatHandlers,
+    modelAuthChecker: (provider) => {
+      const oauthId = PROVIDER_TO_OAUTH_ID[provider];
+      if (oauthId && authStorage2.isLoggedIn(oauthId)) {
+        return true;
+      }
+      if (provider === "anthropic") {
+        const cred = authStorage2.get("anthropic");
+        if (cred?.type === "api_key" && cred.key.trim().length > 0) {
+          return true;
+        }
+      }
+      if (provider === "openai") {
+        const cred = authStorage2.get("openai-codex");
+        if (cred?.type === "api_key" && cred.key.trim().length > 0) {
+          return true;
+        }
+      }
+      if (provider === "google") {
+        const cred = authStorage2.get("google");
+        if (cred?.type === "api_key" && cred.key.trim().length > 0) {
+          return true;
+        }
+      }
+      const customProvider = loadSettingsCached().customProviders.find((entry) => {
+        return provider === getCustomProviderId(entry.name);
+      });
+      if (customProvider) {
+        return true;
+      }
+      return void 0;
+    },
+    modelUseCountProvider: () => loadSettingsCached().modelUseCounts,
+    modelUseCountTracker: (modelId) => {
+      try {
+        const settings = loadSettingsCached();
+        settings.modelUseCounts[modelId] = (settings.modelUseCounts[modelId] ?? 0) + 1;
+        saveSettings(settings);
+      } catch (error) {
+        console.error("Failed to persist model usage count", error);
+      }
+    },
+    customModelCatalogProvider: () => {
+      const settings = loadSettingsCached();
+      const customModels = [];
+      for (const provider of settings.customProviders) {
+        const providerId = getCustomProviderId(provider.name);
+        for (const modelName of provider.models) {
+          customModels.push({
+            id: toCustomProviderModelId(provider.name, modelName),
+            provider: providerId,
+            modelName,
+            hasApiKey: true,
+            apiKeyEnvVar: void 0
+          });
+        }
+      }
+      return customModels;
+    },
+    threadLock: {
+      acquire: acquireThreadLock,
+      release: releaseThreadLock
+    }
+  });
+  applyModeScopedSubagentGuardrails({
+    harness,
+    subagents,
+    resolveModel: (modelId) => resolveModel(modelId),
+    getAllowedSubagentIdsForMode: (modeId) => getAllowedSubagentIdsForMode(agentRegistry, modeId)
+  });
+  if (hookManager) {
+    harness.subscribe((event) => {
+      if (event.type === "thread_changed") {
+        hookManager.setSessionId(event.threadId);
+      } else if (event.type === "thread_created") {
+        hookManager.setSessionId(event.thread.id);
+      }
+    });
+  }
+  return { harness, mcpManager, hookManager, authStorage: authStorage2, resolveModel, storageWarning };
+}
+
+export { createAuthStorage, createMastraCode };
+//# sourceMappingURL=chunk-OXFO76JC.js.map
+//# sourceMappingURL=chunk-OXFO76JC.js.map