@within-7/minto 0.4.0 → 0.4.2

package/dist/entrypoints/cli.js

@@ -31,15 +31,10 @@ import {
 import { cwd } from "process";
 import { dateToFilename, logError, parseLogFilename } from "../utils/log.js";
 import { initDebugLogger } from "../utils/debugLogger.js";
-import { Onboarding } from "../components/Onboarding.js";
-import { TrustDialog } from "../components/TrustDialog.js";
 import {
   checkHasTrustDialogAccepted
 } from "../utils/config.js";
 import { isDefaultSlowAndCapableModel } from "../utils/model.js";
-import { LogList } from "../screens/LogList.js";
-import { ResumeConversation } from "../screens/ResumeConversation.js";
-import { startMCPServer } from "./mcp.js";
 import { getCwd, setCwd, setOriginalCwd } from "../utils/state.js";
 import { omit } from "lodash-es";
 import { getBuiltInCommands, getCommands } from "../commands.js";
@@ -47,35 +42,8 @@ import { getNextAvailableLogForkNumber, loadLogList } from "../utils/log.js";
 import { loadMessagesFromLog } from "../utils/conversationRecovery.js";
 import { cleanupOldMessageFilesInBackground } from "../utils/cleanup.js";
 import { runLogRotationInBackground, shouldRotate } from "../utils/logRotation.js";
-import {
-  handleListApprovedTools,
-  handleRemoveApprovedTool
-} from "../commands/approvedTools.js";
-import {
-  addMcpServer,
-  getMcpServer,
-  listMCPServers,
-  parseEnvVars,
-  removeMcpServer,
-  getClients,
-  ensureConfigScope
-} from "../services/mcpClient.js";
-import { handleMcprcServerApprovals } from "../services/mcpServerApproval.js";
-import {
-  fetchTeamConfig,
-  loadTeamConfigFromFile,
-  applyTeamConfig,
-  addMarketplaces,
-  installPlugins,
-  installRemoteAgents,
-  installInlineAgents,
-  installTeamHooks
-} from "../utils/teamConfig.js";
 import { cursorShow } from "ansi-escapes";
-import {
-  getLatestVersion,
-  assertMinVersion
-} from "../utils/autoUpdater.js";
+import { assertMinVersion } from "../utils/autoUpdater.js";
 import { ensureConfigDirs } from "../utils/configPaths.js";
 import { runStartupMigration } from "../utils/migration/index.js";
 import {
@@ -92,11 +60,6 @@ import { ConfigParseError } from "../utils/errors.js";
 import { grantReadPermissionForOriginalDir } from "../utils/permissions/filesystem.js";
 import { MACRO } from "../constants/macros.js";
 import { SEMANTIC_COLORS } from "../constants/colors.js";
-import {
-  needsSync as needsCCSync,
-  syncFromClaudeCode,
-  hasClaudeCodeInstallation
-} from "../utils/claudeCodeSync.js";
 function completeOnboarding() {
   const config = getGlobalConfig();
   saveGlobalConfig({
@@ -133,6 +96,7 @@ async function showSetupScreens(safeMode, print, rawModeSupported) {
     }
     await clearTerminal();
     const { render } = await import("ink");
+    const { Onboarding } = await import("../components/Onboarding.js");
     await new Promise((resolve) => {
       render(
         /* @__PURE__ */ React.createElement(
@@ -166,6 +130,7 @@ async function showSetupScreens(safeMode, print, rawModeSupported) {
           };
           (async () => {
             const { render } = await import("ink");
+            const { TrustDialog } = await import("../components/TrustDialog.js");
             render(/* @__PURE__ */ React.createElement(TrustDialog, { onDone }), {
               exitOnCtrlC: false
             });
@@ -174,6 +139,7 @@ async function showSetupScreens(safeMode, print, rawModeSupported) {
       }
     }
     if (process.env.USER_TYPE === "ant") {
+      const { handleMcprcServerApprovals } = await import("../services/mcpServerApproval.js");
       await handleMcprcServerApprovals();
     }
   }
@@ -191,12 +157,7 @@ async function setup(cwd2, safeMode) {
   }
   await setCwd(cwd2);
   grantReadPermissionForOriginalDir();
-  let agentLoader;
-  try {
-    agentLoader = await import("../utils/agentLoader.js");
-  } catch {
-    agentLoader = await import("../utils/agentLoader.js");
-  }
+  const agentLoader = await import("../utils/agentLoader.js");
   const { startAgentWatcher, clearAgentCache } = agentLoader;
   await startAgentWatcher(() => {
     console.log("\u2705 Agent configurations hot-reloaded");
@@ -231,6 +192,11 @@ async function setup(cwd2, safeMode) {
   }
   try {
     const cfg = getGlobalConfig();
+    const {
+      hasClaudeCodeInstallation,
+      needsSync: needsCCSync,
+      syncFromClaudeCode
+    } = await import("../utils/claudeCodeSync.js");
     if (hasClaudeCodeInstallation() && needsCCSync()) {
       const shouldSync = cfg.autoSyncClaudeCode === true || cfg.autoSyncClaudeCode === void 0;
       if (shouldSync) {
@@ -297,6 +263,164 @@ if (process.env.NODE_ENV !== "test") {
     throw error;
   });
 }
+async function runHeadlessAgent(options) {
+  const {
+    cwd: agentCwd,
+    teamName,
+    agentId,
+    agentName,
+    agentType,
+    prompt,
+    maxTurns,
+    model,
+    permissionMode,
+    planModeRequired,
+    agentColor,
+    parentSessionId
+  } = options;
+  await setCwd(agentCwd);
+  try {
+    enableConfigs();
+  } catch {
+  }
+  process.env.MINTO_TEAM_NAME = teamName;
+  process.env.CLAUDE_CODE_TEAM_NAME = teamName;
+  process.env.MINTO_AGENT_ID = agentId;
+  process.env.CLAUDE_CODE_AGENT_ID = agentId;
+  process.env.MINTO_AGENT_TYPE = agentType;
+  process.env.CLAUDE_CODE_AGENT_TYPE = agentType;
+  process.env.MINTO_AGENT_NAME = agentName;
+  process.env.CLAUDE_CODE_AGENT_NAME = agentName;
+  process.env.MINTO_HEADLESS = "1";
+  if (parentSessionId) process.env.MINTO_PARENT_SESSION_ID = parentSessionId;
+  if (agentColor) process.env.MINTO_AGENT_COLOR = agentColor;
+  if (planModeRequired) {
+    process.env.MINTO_PLAN_MODE_REQUIRED = "1";
+    process.env.CLAUDE_CODE_PLAN_MODE_REQUIRED = "1";
+  }
+  if (permissionMode) process.env.MINTO_AGENT_MODE = permissionMode;
+  const { loadTeam, getTeam } = await import("../services/agentTeams/teamManager.js");
+  const { markTeammateIdle } = await import("../services/agentTeams/teammateSpawner.js");
+  loadTeam(teamName);
+  const { getAgentPrompt } = await import("../constants/prompts/index.js");
+  const { getContext: getContext2 } = await import("../context.js");
+  const { getBuiltInTools: getBuiltInTools2 } = await import("../tools.js");
+  const { hasPermissionsToUseTool: hasPermissionsToUseTool2 } = await import("../permissions.js");
+  const { query } = await import("../query.js");
+  const { createUserMessage } = await import("../utils/messages.js");
+  const { getMaxThinkingTokens } = await import("../utils/thinking.js");
+  const { dateToFilename: dateToFilename2 } = await import("../utils/log.js");
+  let teamDiscovery = "";
+  const entry = getTeam(teamName);
+  if (entry) {
+    const otherMembers = entry.team.members.filter((m) => m.id !== agentId && m.name !== agentName).map((m) => `  - ${m.name} (${m.agentType}): ${m.status}`).join("\n");
+    if (otherMembers) {
+      teamDiscovery = `
+Team members:
+${otherMembers}`;
+    }
+  }
+  const teamContext = `
+# Agent Teammate Communication
+
+You are agent "${agentName}" in team "${teamName}".
+
+## CRITICAL: Reporting Results
+
+**You MUST use the SendMessage tool to report your results to the team lead.** Your text output is NOT visible to the team lead or any teammate. The ONLY way to deliver your findings is via SendMessage.
+
+When you finish your task:
+1. Use SendMessage with type "message", recipient "team-lead", and your findings as content
+2. Include a brief summary in the summary field
+3. Do NOT just output text \u2014 it will be lost
+
+## Communication
+
+- Use SendMessage with type \`message\` to send messages to specific teammates
+- Use SendMessage with type \`broadcast\` sparingly for team-wide announcements
+- Do NOT send acknowledgment messages ("Got it", "\u5DF2\u6536\u5230") \u2014 only send when you have actionable content
+- ALWAYS respond in the same language as the user's original request
+
+Team: ${teamName}
+Your agent ID: ${agentId}
+Your agent type: ${agentType}${teamDiscovery}
+`;
+  const effectivePrompt = `<system-reminder>
+${teamContext}
+</system-reminder>
+
+` + prompt;
+  const messages = [createUserMessage(effectivePrompt)];
+  const agentTools = await getBuiltInTools2(false);
+  const messageLogName = dateToFilename2(/* @__PURE__ */ new Date());
+  const agentModel = model || process.env.MINTO_AGENT_MODEL || "task";
+  const [taskPrompt, context, maxThinkingTokens] = await Promise.all([
+    getAgentPrompt(),
+    getContext2(),
+    getMaxThinkingTokens(messages)
+  ]);
+  const abortController = new AbortController();
+  process.on("message", (msg) => {
+    if (msg?.type === "abort" || msg?.type === "shutdown") {
+      abortController.abort();
+    }
+  });
+  let turnCount = 0;
+  try {
+    for await (const message of query(
+      messages,
+      taskPrompt,
+      context,
+      hasPermissionsToUseTool2,
+      {
+        abortController,
+        messageId: void 0,
+        options: {
+          safeMode: false,
+          tools: agentTools,
+          commands: [],
+          forkNumber: 0,
+          messageLogName,
+          verbose: false,
+          maxThinkingTokens,
+          model: agentModel
+        },
+        readFileTimestamps: {},
+        setToolJSX: () => {
+        }
+      }
+    )) {
+      messages.push(message);
+      if (message.type !== "assistant") continue;
+      if (entry) {
+        const unread = entry.mailbox.getUnread(agentId);
+        if (unread.length > 0) {
+          const {
+            formatTeamMessagesForInjection,
+            humanizeProtocolMessage
+          } = require("../services/agentTeams/messageFormatter");
+          const humanized = unread.map((m) => {
+            const friendly = humanizeProtocolMessage(m.text);
+            return friendly ? { ...m, summary: friendly } : m;
+          });
+          const deliveryText = formatTeamMessagesForInjection(humanized);
+          messages.push(createUserMessage(deliveryText));
+          entry.mailbox.markRead(unread.map((m) => m.id));
+        }
+      }
+      turnCount++;
+      if (maxTurns && turnCount >= maxTurns) break;
+    }
+  } catch (error) {
+    console.error(
+      `[headless-agent] ${agentId} error:`,
+      error instanceof Error ? error.message : error
+    );
+  }
+  await markTeammateIdle(teamName, agentId, agentName).catch(() => {
+  });
+  process.exit(0);
+}
 async function main() {
   const configDirsResult = ensureConfigDirs();
   if (configDirsResult.errors.length > 0) {
@@ -349,7 +473,8 @@ async function main() {
     }
   };
   if (!process.stdin.isTTY && !process.env.CI && // Input hijacking breaks MCP.
-  !process.argv.includes("mcp")) {
+  !process.argv.includes("mcp") && // Headless agents have piped stdin with no writer — reading would block forever.
+  !process.env.MINTO_HEADLESS) {
     inputPrompt = await stdin();
     if (process.platform !== "win32") {
       try {
@@ -360,6 +485,10 @@ async function main() {
       }
     }
   }
+  if (process.env.MINTO_HEADLESS) {
+    await parseArgs(inputPrompt, renderContext, false);
+    return;
+  }
   const stdinStream = renderContext?.stdin || process.stdin;
   const rawModeCheck = validateRawModeSupport(stdinStream);
   renderContext.rawModeSupported = rawModeCheck.supported;
@@ -392,7 +521,11 @@ async function parseArgs(stdinContent, renderContext, rawModeSupported) {
 
 Slash commands available during an interactive session:
 ${commandList}`
-  ).argument("[prompt]", "Your prompt", String).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-d, --debug", "Enable debug mode", () => true).option(
+  ).argument("[prompt]", "Your prompt", String).option("--cwd <cwd>", "The current working directory", String, cwd()).option(
+    "-c, --continue",
+    "Load the most recent conversation in the current directory",
+    () => true
+  ).option("-d, --debug", "Enable debug mode", () => true).option(
     "--debug-verbose",
     "Enable verbose debug terminal output",
     () => true
@@ -406,7 +539,7 @@ ${commandList}`
     () => true
   ).option(
     "--free",
-    "Enable Free safety mode (project directory operations auto-allowed, outside requires confirmation)",
+    "Enable Free safety mode (device-wide full permission, all operations auto-allowed)",
     () => true
   ).option(
     "--smart",
@@ -417,13 +550,9 @@ ${commandList}`
     "Enable Strict safety mode (all write operations need confirmation)",
     () => true
   ).option(
-    "-n, --new",
-    "Start a new conversation (skip auto-resume)",
-    () => true
-  ).option(
-    "-r, --resume",
-    "Select a previous conversation to resume",
-    () => true
+    "-r, --resume [session]",
+    "Resume a specific session by ID, or show an interactive picker to choose a session",
+    String
   ).option(
     "-l, --lang <language>",
     "Set interface language (en, zh-CN)",
@@ -432,6 +561,50 @@ ${commandList}`
     "--plugin-dir <dir>",
     "Additional plugin directory to scan (merged with defaults)",
     String
+  ).option(
+    "--teammate-mode <mode>",
+    "Teammate display mode: auto, in-process, tmux",
+    String
+  ).option(
+    "--headless-agent",
+    "Run as a teammate agent process (internal use)",
+    () => true
+  ).option("--team <name>", "Team name (used with --headless-agent)", String).option(
+    "--agent-id <id>",
+    "Agent ID within team (used with --headless-agent)",
+    String
+  ).option(
+    "--agent-name <name>",
+    "Agent display name (used with --headless-agent)",
+    String
+  ).option(
+    "--agent-type <type>",
+    "Agent type/role (used with --headless-agent)",
+    String
+  ).option(
+    "--max-turns <n>",
+    "Maximum API round-trips (used with --headless-agent)",
+    parseInt
+  ).option(
+    "--model <name>",
+    "Model to use (used with --headless-agent)",
+    String
+  ).option(
+    "--permission-mode <mode>",
+    "Permission mode override (used with --headless-agent)",
+    String
+  ).option(
+    "--plan-mode-required",
+    "Force plan mode for this agent (used with --headless-agent)",
+    () => true
+  ).option(
+    "--agent-color <color>",
+    "Agent display color (used with --headless-agent)",
+    String
+  ).option(
+    "--parent-session-id <id>",
+    "Parent session ID (used with --headless-agent)",
+    String
   ).action(
     async (prompt, {
       cwd: cwd2,
@@ -442,11 +615,41 @@ ${commandList}`
       free,
       smart,
       strict,
-      new: startNew,
-      resume: selectResume,
+      continue: continueSession,
+      resume: resumeSession,
       lang,
-      pluginDir
+      pluginDir,
+      teammateMode,
+      headlessAgent,
+      team: teamName,
+      agentId,
+      agentName,
+      agentType,
+      maxTurns,
+      model: cliModel,
+      permissionMode,
+      planModeRequired,
+      agentColor,
+      parentSessionId
     }) => {
+      if (headlessAgent) {
+        await runHeadlessAgent({
+          cwd: cwd2,
+          teamName,
+          agentId,
+          agentName,
+          agentType,
+          prompt: prompt || "",
+          maxTurns,
+          // CLI args override env var fallbacks (CC-compatible format)
+          model: cliModel || process.env.MINTO_AGENT_MODEL,
+          permissionMode: permissionMode || process.env.MINTO_AGENT_MODE,
+          planModeRequired: planModeRequired || process.env.MINTO_PLAN_MODE_REQUIRED === "1",
+          agentColor,
+          parentSessionId: parentSessionId || process.env.MINTO_PARENT_SESSION_ID
+        });
+        return;
+      }
       if (lang && isLanguageSupported(lang)) {
         setLanguage(lang);
       }
@@ -456,7 +659,7 @@ ${commandList}`
       }
       const envSafetyMode = process.env.MINTO_SAFETY_MODE;
       const safetyMode = envSafetyMode ? envSafetyMode : strict ? "strict" : smart ? "smart" : free ? "free" : "yolo";
-      const safeMode = safetyMode !== "yolo";
+      const safeMode = safetyMode !== "yolo" && safetyMode !== "free";
       const inkPromise = import("ink");
       const replPromise = import("../screens/REPL.js");
       await showSetupScreens(safeMode, print, rawModeSupported);
@@ -495,10 +698,62 @@ ${commandList}`
         if (renderContext?.fallbackMode) {
           requireRawModeOrExit(process.stdin, true);
         }
-        if (selectResume) {
+        if (resumeSession) {
+          if (typeof resumeSession === "string") {
+            const logs2 = await loadLogList(CACHE_PATHS.messages());
+            const matchedLog = logs2.find(
+              (log) => log.date === resumeSession || log.fullPath.includes(resumeSession)
+            );
+            if (!matchedLog) {
+              console.error(
+                `Session not found: ${resumeSession}
+Use "minto -r" to see available sessions.`
+              );
+              process.exit(1);
+            }
+            const { deserializeMessages } = await import("../utils/conversationRecovery.js");
+            const { render: render2 } = await inkPromise;
+            const { REPL } = await replPromise;
+            await prepareTerminalForREPL();
+            render2(
+              /* @__PURE__ */ React.createElement(
+                REPL,
+                {
+                  commands,
+                  debug,
+                  messageLogName: matchedLog.date,
+                  initialPrompt: "",
+                  shouldShowPromptInput: true,
+                  verbose,
+                  tools,
+                  safeMode,
+                  safetyMode,
+                  mcpClients: [],
+                  isDefaultModel,
+                  initialUpdateVersion: null,
+                  initialUpdateCommands: null,
+                  enableArchitect: enableArchitect ?? getCurrentProjectConfig().enableArchitectTool,
+                  fallbackMode: renderContext?.fallbackMode,
+                  initialMessages: deserializeMessages(
+                    matchedLog.messages,
+                    tools
+                  ),
+                  initialForkNumber: getNextAvailableLogForkNumber(
+                    matchedLog.date,
+                    matchedLog.forkNumber ?? 1,
+                    0
+                  ),
+                  isResumedConversation: true
+                }
+              ),
+              renderContext
+            );
+            return;
+          }
           const logs = await loadLogList(CACHE_PATHS.messages());
           const context2 = {};
           const { render } = await import("ink");
+          const { ResumeConversation } = await import("../screens/ResumeConversation.js");
           const { unmount } = render(
             /* @__PURE__ */ React.createElement(
               ResumeConversation,
@@ -515,8 +770,54 @@ ${commandList}`
           context2.unmount = unmount;
           return;
         }
+        if (continueSession) {
+          const logs = await loadLogList(CACHE_PATHS.messages());
+          const projectLog = logs.find((log) => {
+            const firstMsg = log.messages[0];
+            return firstMsg?.cwd === cwd2;
+          });
+          if (projectLog) {
+            const { deserializeMessages } = await import("../utils/conversationRecovery.js");
+            const { render } = await inkPromise;
+            const { REPL } = await replPromise;
+            await prepareTerminalForREPL();
+            render(
+              /* @__PURE__ */ React.createElement(
+                REPL,
+                {
+                  commands,
+                  debug,
+                  messageLogName: projectLog.date,
+                  initialPrompt: inputPrompt || "",
+                  shouldShowPromptInput: true,
+                  verbose,
+                  tools,
+                  safeMode,
+                  safetyMode,
+                  mcpClients: [],
+                  isDefaultModel,
+                  initialUpdateVersion: null,
+                  initialUpdateCommands: null,
+                  enableArchitect: enableArchitect ?? getCurrentProjectConfig().enableArchitectTool,
+                  fallbackMode: renderContext?.fallbackMode,
+                  initialMessages: deserializeMessages(
+                    projectLog.messages,
+                    tools
+                  ),
+                  initialForkNumber: getNextAvailableLogForkNumber(
+                    projectLog.date,
+                    projectLog.forkNumber ?? 1,
+                    0
+                  ),
+                  isResumedConversation: true
+                }
+              ),
+              renderContext
+            );
+            return;
+          }
+        }
         const messageLogName = dateToFilename(/* @__PURE__ */ new Date());
-        const shouldAutoResume = !startNew && !inputPrompt;
         {
           const { render } = await inkPromise;
           const { REPL } = await replPromise;
@@ -539,8 +840,7 @@ ${commandList}`
                 initialUpdateVersion: null,
                 initialUpdateCommands: null,
                 enableArchitect: enableArchitect ?? getCurrentProjectConfig().enableArchitectTool,
-                fallbackMode: renderContext?.fallbackMode,
-                autoResume: shouldAutoResume
+                fallbackMode: renderContext?.fallbackMode
               }
             ),
             renderContext
@@ -552,24 +852,24 @@ ${commandList}`
   const config = program.command("config").description(
     `Manage configuration (eg. ${PRODUCT_COMMAND} config set -g theme dark)`
   );
-  config.command("get <key>").description("Get a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
+  config.command("get <key>").description("Get a config value").option("--cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
     await setup(cwd2, false);
     console.log(getConfigForCLI(key, global ?? false));
     process.exit(0);
   });
-  config.command("set <key> <value>").description("Set a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, value, { cwd: cwd2, global }) => {
+  config.command("set <key> <value>").description("Set a config value").option("--cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, value, { cwd: cwd2, global }) => {
     await setup(cwd2, false);
     setConfigForCLI(key, value, global ?? false);
     console.log(`Set ${key} to ${value}`);
     process.exit(0);
   });
-  config.command("remove <key>").description("Remove a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
+  config.command("remove <key>").description("Remove a config value").option("--cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
     await setup(cwd2, false);
     deleteConfigForCLI(key, global ?? false);
     console.log(`Removed ${key}`);
     process.exit(0);
   });
-  config.command("list").description("List all config values").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config", false).action(async ({ cwd: cwd2, global }) => {
+  config.command("list").description("List all config values").option("--cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config", false).action(async ({ cwd: cwd2, global }) => {
     await setup(cwd2, false);
     console.log(
       JSON.stringify(
@@ -595,6 +895,16 @@ ${commandList}`
         plugins: shouldInstallPlugins
       } = options;
       try {
+        const {
+          fetchTeamConfig,
+          loadTeamConfigFromFile,
+          applyTeamConfig,
+          addMarketplaces,
+          installPlugins,
+          installRemoteAgents,
+          installInlineAgents,
+          installTeamHooks
+        } = await import("../utils/teamConfig.js");
         console.log(`Loading configuration from ${source}...`);
         const teamConfig = source.startsWith("http://") || source.startsWith("https://") ? await fetchTeamConfig(source) : loadTeamConfigFromFile(source);
         console.log("Applying configuration...");
@@ -688,13 +998,21 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
       }
     }
   );
+  program.command("login").description("Login and auto-configure available models").option("-u, --user <user>", "Username").option("-p, --password <password>", "Password").action(async (options) => {
+    await setup(getCwd(), false);
+    const { handleLoginCLI } = await import("../services/mintoAuth.js");
+    await handleLoginCLI(options.user, options.password);
+    process.exit(0);
+  });
   const allowedTools = program.command("approved-tools").description("Manage approved tools");
   allowedTools.command("list").description("List all approved tools").action(async () => {
+    const { handleListApprovedTools } = await import("../commands/approvedTools.js");
     const result = handleListApprovedTools(getCwd());
     console.log(result);
     process.exit(0);
   });
   allowedTools.command("remove <tool>").description("Remove a tool from the list of approved tools").action(async (tool) => {
+    const { handleRemoveApprovedTool } = await import("../commands/approvedTools.js");
     const result = handleRemoveApprovedTool(tool);
     console.log(result.message);
     process.exit(result.success ? 0 : 1);
@@ -708,6 +1026,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     }
     try {
       await setup(providedCwd, false);
+      const { startMCPServer } = await import("./mcp.js");
       await startMCPServer(providedCwd);
     } catch (error) {
       console.error("Error: Failed to start MCP server:", error);
@@ -720,6 +1039,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "project"
   ).action(async (name, url, options) => {
     try {
+      const { addMcpServer, ensureConfigScope } = await import("../services/mcpClient.js");
       const scope = ensureConfigScope(options.scope);
       addMcpServer(name, { type: "sse", url }, scope);
       console.log(
@@ -740,6 +1060,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "Set environment variables (e.g. -e KEY=value)"
   ).action(async (name, commandOrUrl, args, options) => {
     try {
+      const { addMcpServer, parseEnvVars, ensureConfigScope } = await import("../services/mcpClient.js");
       if (!name) {
         console.log("Interactive wizard mode: Enter the server details");
         const { createInterface } = await import("readline");
@@ -847,6 +1168,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "project"
   ).action(async (name, options) => {
     try {
+      const { removeMcpServer, ensureConfigScope } = await import("../services/mcpClient.js");
       const scope = ensureConfigScope(options.scope);
       removeMcpServer(name, scope);
       console.log(`Removed MCP server ${name} from ${scope} config`);
@@ -856,7 +1178,8 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
       process.exit(1);
     }
   });
-  mcp.command("list").description("List configured MCP servers").action(() => {
+  mcp.command("list").description("List configured MCP servers").action(async () => {
+    const { listMCPServers } = await import("../services/mcpClient.js");
     const servers = listMCPServers();
     if (Object.keys(servers).length === 0) {
       console.log(
@@ -883,6 +1206,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "project"
   ).action(async (name, jsonStr, options) => {
     try {
+      const { addMcpServer, ensureConfigScope } = await import("../services/mcpClient.js");
       const scope = ensureConfigScope(options.scope);
       let serverConfig;
       try {
@@ -919,7 +1243,8 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
       process.exit(1);
     }
   });
-  mcp.command("get <name>").description("Get details about an MCP server").action((name) => {
+  mcp.command("get <name>").description("Get details about an MCP server").action(async (name) => {
+    const { getMcpServer } = await import("../services/mcpClient.js");
     const server = getMcpServer(name);
     if (!server) {
       console.error(`No MCP server found with name: ${name}`);
@@ -954,6 +1279,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "project"
   ).action(async (options) => {
     try {
+      const { addMcpServer, getMcpServer, ensureConfigScope } = await import("../services/mcpClient.js");
       const scope = ensureConfigScope(options.scope);
       const platform = process.platform;
       const { existsSync: existsSync2, readFileSync } = await import("fs");
@@ -1163,6 +1489,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
   program.command("update").description("Show manual upgrade commands (no auto-install)").action(async () => {
     console.log(`Current version: ${MACRO.VERSION}`);
     console.log("Checking for updates...");
+    const { getLatestVersion } = await import("../utils/autoUpdater.js");
     const latestVersion = await getLatestVersion();
     if (!latestVersion) {
       console.error("Failed to check for updates");
@@ -1173,8 +1500,8 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
       process.exit(0);
     }
     console.log(`New version available: ${latestVersion}`);
-    const { getUpdateCommandSuggestions: getUpdateCommandSuggestions2 } = await import("../utils/autoUpdater.js");
-    const cmds = await getUpdateCommandSuggestions2();
+    const { getUpdateCommandSuggestions } = await import("../utils/autoUpdater.js");
+    const cmds = await getUpdateCommandSuggestions();
     console.log("\nRun one of the following commands to update:");
     for (const c of cmds) console.log(`  ${c}`);
     if (process.platform !== "win32") {
@@ -1188,11 +1515,12 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "[number]",
     "A number (0, 1, 2, etc.) to display a specific log",
     parseInt
-  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
+  ).option("--cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
     await setup(cwd2, false);
     const context2 = {};
     (async () => {
       const { render } = await import("ink");
+      const { LogList } = await import("../screens/LogList.js");
       const { unmount } = render(
         /* @__PURE__ */ React.createElement(LogList, { context: context2, type: "messages", logNumber: number }),
         renderContextWithExitOnCtrlC
@@ -1205,9 +1533,9 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
   ).argument(
     "[identifier]",
     "A number (0, 1, 2, etc.) or file path to resume a specific conversation"
-  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-e, --enable-architect", "Enable the Architect tool", () => true).option("-v, --verbose", "Do not truncate message output", () => true).option(
+  ).option("--cwd <cwd>", "The current working directory", String, cwd()).option("-e, --enable-architect", "Enable the Architect tool", () => true).option("-v, --verbose", "Do not truncate message output", () => true).option(
     "--free",
-    "Enable Free safety mode (project directory operations auto-allowed, outside requires confirmation)",
+    "Enable Free safety mode (device-wide full permission, all operations auto-allowed)",
     () => true
   ).option(
     "--smart",
@@ -1221,9 +1549,10 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     async (identifier, { cwd: cwd2, enableArchitect, free, smart, strict, verbose }) => {
       const envSafetyMode = process.env.MINTO_SAFETY_MODE;
       const safetyMode = envSafetyMode ? envSafetyMode : strict ? "strict" : smart ? "smart" : free ? "free" : "yolo";
-      const safeMode = safetyMode !== "yolo";
+      const safeMode = safetyMode !== "yolo" && safetyMode !== "free";
       await setup(cwd2, safeMode);
       assertMinVersion();
+      const { getClients } = await import("../services/mcpClient.js");
       const [tools, commands2, logs, mcpClients] = await Promise.all([
         getTools(
           enableArchitect ?? getCurrentProjectConfig().enableArchitectTool
@@ -1295,6 +1624,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
         const context2 = {};
         (async () => {
           const { render } = await import("ink");
+          const { ResumeConversation } = await import("../screens/ResumeConversation.js");
           const { unmount } = render(
             /* @__PURE__ */ React.createElement(
               ResumeConversation,
@@ -1319,11 +1649,12 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     "[number]",
     "A number (0, 1, 2, etc.) to display a specific log",
     parseInt
-  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
+  ).option("--cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
     await setup(cwd2, false);
     const context2 = {};
     (async () => {
       const { render } = await import("ink");
+      const { LogList } = await import("../screens/LogList.js");
       const { unmount } = render(
         /* @__PURE__ */ React.createElement(LogList, { context: context2, type: "errors", logNumber: number }),
         renderContextWithExitOnCtrlC
@@ -1334,7 +1665,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
   const context = program.command("context").description(
     `Set static context (eg. ${PRODUCT_COMMAND} context add-file ./src/*.py)`
   );
-  context.command("get <key>").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).description("Get a value from context").action(async (key, { cwd: cwd2 }) => {
+  context.command("get <key>").option("--cwd <cwd>", "The current working directory", String, cwd()).description("Get a value from context").action(async (key, { cwd: cwd2 }) => {
     await setup(cwd2, false);
     const context2 = omit(
       await getContext(),
@@ -1344,13 +1675,13 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     console.log(context2[key]);
     process.exit(0);
   });
-  context.command("set <key> <value>").description("Set a value in context").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (key, value, { cwd: cwd2 }) => {
+  context.command("set <key> <value>").description("Set a value in context").option("--cwd <cwd>", "The current working directory", String, cwd()).action(async (key, value, { cwd: cwd2 }) => {
     await setup(cwd2, false);
     setContext(key, value);
     console.log(`Set context.${key} to "${value}"`);
     process.exit(0);
   });
-  context.command("list").description("List all context values").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async ({ cwd: cwd2 }) => {
+  context.command("list").description("List all context values").option("--cwd <cwd>", "The current working directory", String, cwd()).action(async ({ cwd: cwd2 }) => {
     await setup(cwd2, false);
     const context2 = omit(
       await getContext(),
@@ -1361,7 +1692,7 @@ Run "${PRODUCT_COMMAND}" to start using your configured setup.`
     console.log(JSON.stringify(context2, null, 2));
     process.exit(0);
   });
-  context.command("remove <key>").description("Remove a value from context").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (key, { cwd: cwd2 }) => {
+  context.command("remove <key>").description("Remove a value from context").option("--cwd <cwd>", "The current working directory", String, cwd()).action(async (key, { cwd: cwd2 }) => {
     await setup(cwd2, false);
     removeContext(key);
     console.log(`Removed context.${key}`);