@aiden-ade/sandbox-agent 0.1.32 → 0.1.33

package/dist/index.cjs

@@ -9255,7 +9255,7 @@ function resolveAgentConfigFileName(profile) {
     case "production":
       return "config.json";
     case "local":
-      return "config-dev.json";
+      return "config-local.json";
     case "staging":
       return "config-staging.json";
     case "custom":
@@ -13345,7 +13345,7 @@ Use these tools, in roughly this order of frequency:
 5. \`get_session_context\` \u2014 check what a worker accomplished
 6. \`update_task\` \u2014 keep status, priority, labels current
 7. \`send_session_message\` / \`start_task_session\` \u2014 continue a specific session or force a new session only when needed
-8. \`list_sessions\` / \`search\` / \`Read\` / \`Glob\` / \`Grep\` \u2014 situational awareness
+8. \`list_sessions\` / \`search\` / \`search_code_context\` / \`Read\` / \`Glob\` / \`Grep\` \u2014 situational awareness (\`search_code_context\` before grep for codebase discovery or implementation-answer questions; read exact cited files before claiming behavior)
 9. \`get_task_memory\` / \`update_task_memory\` \u2014 compatibility memory tools for older task summaries and session outcomes
 10. \`create_plan\` \u2014 document implementation plans and durable specs as artifacts
 11. \`add_task_comment\` \u2014 human-facing collaboration: answer questions, post explicit status updates, escalate blockers, or leave comments the user asked you to post. Do not use comments as running notes or memory.
@@ -13452,7 +13452,7 @@ You are a flexible general-purpose agent (an Aiden agent profile) for work that
 
 Your name is Aiden, General Agent.
 
-Clarify the goal only when required, inspect the relevant context first, then complete the requested work directly. Keep changes focused, avoid unrelated refactors, and validate the result before reporting back.
+Clarify the goal only when required, inspect the relevant context first, then complete the requested work directly. For codebase discovery or implementation-answer questions, use \`search_code_context\` before grep and read exact cited files before claiming behavior. Keep changes focused, avoid unrelated refactors, and validate the result before reporting back.
 
 Non-trivial implementations include tests. Break and plan before building when scope is wide.
 
@@ -13475,10 +13475,18 @@ Your job is to be the user's always-available teammate: answer questions, inspec
 ## How to work
 
 1. Start from the current team/chat context before asking for details.
-2. Clarify only when the request has multiple plausible meanings.
-3. Keep responses concise, concrete, and tied to the user's next step.
-4. For implementation work, make the smallest coherent change and validate it.
-5. For plans, PRDs, reviews, and test reports, use structured Aiden artifacts when task context exists.
+2. For codebase location, behavior, or implementation-answer questions, call \`search_code_context\` via Aiden MCP before grep or filesystem search, then read the exact cited files before claiming behavior.
+3. Clarify only when the request has multiple plausible meanings.
+4. Keep responses concise, concrete, and tied to the user's next step.
+5. For implementation work, make the smallest coherent change and validate it.
+6. For plans, PRDs, reviews, and test reports, use structured Aiden artifacts when task context exists.
+
+## Primary tools (code discovery)
+
+- \`mcp__aiden__search_code_context\` / \`search_code_context\` \u2014 find where code lives or how behavior is implemented (**use this first**)
+- \`mcp__aiden__code_context_status\` \u2014 confirm the team index is ready
+- \`Read\`, \`Grep\` \u2014 only after you have paths from the index, or for line-level edits in known files; read exact cited files before answering exact questions
+- Do **not** run repo-wide \`grep\` / \`rg\` / Bash find for "where is X" or "how does this work" questions when MCP code-context tools are available
 
 ## Rules
 
@@ -13524,7 +13532,8 @@ Workflow: Listen \u2192 Understand \u2192 Break down \u2192 Plan \u2192 Build \u
 
 ## Primary tools
 
-- \`Read\`, \`Glob\`, \`Grep\` \u2014 understand the codebase before touching it
+- \`mcp__aiden__search_code_context\` / \`search_code_context\` \u2014 find where code lives or how behavior is implemented (use BEFORE grep for discovery and implementation-answer questions)
+- \`Read\`, \`Glob\`, \`Grep\` \u2014 read exact cited files or narrow search after you have paths from the index
 - \`Edit\`, \`Write\` \u2014 make changes; prefer \`Edit\` over \`Write\` for existing files
 - \`Bash\` \u2014 run type-checks, tests, and read-only commands; never skip validation
 - \`get_session_context\` \u2014 check what prior sessions already did before redoing work
@@ -14015,6 +14024,47 @@ If neither native ask nor the MCP ask tool is available, ask ONE short plain-tex
 
 ### After the tool call
 The ask tool returns an empty/ack result and does NOT wait. Immediately end your turn. At most one short line like "Please pick an option above." \u2014 no restating the full questions in markdown. The user's answer (or skip) arrives as the next user message; continue from there.`;
+function buildAidenTeamScopePrompt(teamId) {
+  return [
+    `You are operating within team \`${teamId}\`.`,
+    "Use this teamId for MCP tools that accept it (search, list_tasks, search_code_context, etc.).",
+    "On code-context tools, teamId auto-resolves from the Aiden session when omitted \u2014 never invent or guess a teamId.",
+    "Do not call list_teams."
+  ].join(" ");
+}
+var AIDEN_CODE_CONTEXT_PROMPT = `## Codebase index (required for code discovery)
+
+This team has an indexed codebase. For questions about where code lives, how something works, how to answer from the codebase, or which files to read, use Aiden MCP code-context tools BEFORE local grep/find/bash search.
+
+### Required path for codebase questions
+Examples: "where is X configured", "which file handles Y", "how does Z work", "find code that \u2026", "why does this behavior happen?"
+1. Call \`mcp__aiden__search_code_context\` (MCP tool: \`search_code_context\`) with hybrid mode and topK 5.
+2. Optionally call \`mcp__aiden__code_context_status\` first when unsure indexing is ready.
+3. Use the result citations to choose exact paths, then \`Read\` those files before making claims, proposing edits, or changing code.
+4. For exact symbols, constants, routes, schema fields, or line-level behavior, verify in the cited file with \`Read\` or narrow \`Grep\` before answering.
+
+### Do NOT do this first
+- Do NOT start with \`grep\`, \`rg\`, \`find\`, or broad Bash filesystem search for codebase discovery or implementation-answer questions when \`search_code_context\` is available.
+- Do NOT use graphify or local graph tools for semantic "where is this implemented" questions \u2014 use \`search_code_context\`.
+- \`Read\` / \`Grep\` / \`Glob\` are for after you have specific paths from the index, or for line-level work in files already identified.
+
+### Follow-ups
+- Import/caller structure: \`code_graph_query\` after search when available.
+- Current breakage: \`code_lsp_diagnostics\` when available.
+
+If search returns no strong matches, say so and try one targeted local search in the most likely package \u2014 not repo-wide grep.`;
+function buildAidenTeamCodeContextOverlay(teamId) {
+  return [buildAidenTeamScopePrompt(teamId), AIDEN_CODE_CONTEXT_PROMPT].join("\n\n");
+}
+function buildCodeDiscoveryEnforcementTail() {
+  return [
+    "## MANDATORY \u2014 team code index (do this before Grep/graphify)",
+    "1. For codebase discovery or implementation-answer questions, call `mcp__aiden__search_code_context` (hybrid, topK 5). Omit teamId \u2014 Aiden session headers resolve it.",
+    "2. Optionally `mcp__aiden__code_context_status` if indexing readiness is unclear.",
+    "3. Read the exact cited files before answering, claiming behavior, or editing code; use narrow `Grep` only inside known paths.",
+    "Repo-wide grep, graphify, or Bash find **before** MCP on discovery/implementation-answer questions fails the task."
+  ].join("\n");
+}
 var PLAN_MODE_PROMPT = [
   "You are in Aiden plan mode.",
   "Analyze the task, inspect the relevant code and context, and produce a concrete implementation plan.",
@@ -14052,6 +14102,7 @@ function getAidenAgentPrompt(agentId) {
 }
 
 // ../shared/dist/types/frontend.js
+var EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
 var CLAUDE_48_EFFORT_LEVELS = [
   "minimal",
   "low",
@@ -14338,9 +14389,18 @@ var CLAUDE_5_EFFORT_LEVELS2 = [
 var CODEX_5X_EFFORT_LEVELS2 = ["low", "medium", "high", "xhigh"];
 var GPT_5_5_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
 var GPT_5_4_EFFORT_LEVELS = ["low", "medium", "high"];
+var GPT_5_6_EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+];
 var CURSOR_EFFORT_SUFFIXES = [
   { suffix: "-extra-high", level: "xhigh" },
   { suffix: "-xhigh", level: "xhigh" },
+  { suffix: "-ultra", level: "ultra" },
   { suffix: "-max", level: "max" },
   { suffix: "-high", level: "high" },
   { suffix: "-medium", level: "medium" },
@@ -14436,7 +14496,11 @@ function mergeEffortLevels(existing, discovered) {
   const merged = new Set(existing ?? []);
   for (const level of discovered)
     merged.add(level);
-  return Array.from(merged);
+  return orderEffortLevels(merged);
+}
+function orderEffortLevels(levels) {
+  const set = levels instanceof Set ? levels : new Set(levels);
+  return EFFORT_LEVELS.filter((level) => set.has(level));
 }
 function lookupKnownModelCapabilities(modelId) {
   for (const catalog of [AVAILABLE_MODELS, CURSOR_AGENT_MODELS]) {
@@ -14460,6 +14524,13 @@ function inferSlugModelCapabilities(providerKind, modelId) {
     if (id === "gpt-5.4" || id === "gpt-5.4-mini") {
       return { contextWindows: [], effortLevels: GPT_5_4_EFFORT_LEVELS };
     }
+    if (/^gpt-5\.6-/.test(id)) {
+      const hasUltra = id.includes("-sol") || id.includes("-terra");
+      return {
+        contextWindows: [],
+        effortLevels: hasUltra ? GPT_5_6_EFFORT_LEVELS : GPT_5_6_EFFORT_LEVELS.filter((level) => level !== "ultra")
+      };
+    }
     if (id.includes("codex") || /^gpt-5\.[0-3]/.test(id)) {
       return { contextWindows: [], effortLevels: CODEX_5X_EFFORT_LEVELS2 };
     }
@@ -14630,13 +14701,18 @@ function catalogModelsForProvider(providerKind, modelsFromConfig) {
 }
 
 // ../agent-core/dist/index.js
-var import_child_process = require("child_process");
 var import_fs2 = require("fs");
 var import_os2 = require("os");
 var import_path2 = require("path");
+var import_child_process = require("child_process");
+var import_fs3 = require("fs");
+var import_os3 = require("os");
+var import_path3 = require("path");
 var import_readline = require("readline");
 var import_child_process2 = require("child_process");
 var import_crypto = require("crypto");
+var import_child_process3 = require("child_process");
+var import_util10 = require("util");
 
 // ../shared/dist/constants/agent.js
 var INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set(["askuserquestion", "exitplanmode", "enterplanmode"]);
@@ -14925,18 +15001,289 @@ var PRIORITY_OPTIONS = [
 ];
 
 // ../agent-core/dist/index.js
-var import_fs3 = require("fs");
-var import_os3 = require("os");
-var import_path3 = require("path");
 var import_fs4 = require("fs");
 var import_os4 = require("os");
 var import_path4 = require("path");
 var import_fs5 = require("fs");
 var import_os5 = require("os");
 var import_path5 = require("path");
-var import_crypto2 = require("crypto");
 var import_fs6 = require("fs");
+var import_os6 = require("os");
 var import_path6 = require("path");
+var import_crypto2 = require("crypto");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
+var MANAGED_AIDEN_MCP_SERVER_NAMES = [
+  "aiden",
+  "aiden-prod",
+  "aiden-staging",
+  "aiden-local"
+];
+function parseJsonSafe(content) {
+  if (!content) return {};
+  try {
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function readFileOrNull(path) {
+  try {
+    if ((0, import_fs2.existsSync)(path)) return (0, import_fs2.readFileSync)(path, "utf-8");
+  } catch {
+  }
+  return null;
+}
+function writeFileSafe(path, content) {
+  (0, import_fs2.mkdirSync)((0, import_path2.dirname)(path), { recursive: true });
+  (0, import_fs2.writeFileSync)(path, content, "utf-8");
+}
+function formatTomlKey2(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function parseJsonStringOrNull(raw) {
+  try {
+    const value2 = JSON.parse(raw);
+    return typeof value2 === "string" ? value2 : null;
+  } catch {
+    return null;
+  }
+}
+function splitTomlInlineEntries(body) {
+  const entries = [];
+  let current = "";
+  let inString = false;
+  let escaping = false;
+  for (const char of body) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      escaping = inString;
+      continue;
+    }
+    if (char === '"') inString = !inString;
+    if (char === "," && !inString) {
+      if (current.trim()) entries.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) entries.push(current.trim());
+  return entries;
+}
+function parseTomlInlineStringTable(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return {};
+  const body = trimmed.slice(1, -1).trim();
+  if (!body) return {};
+  const headers = {};
+  for (const entry of splitTomlInlineEntries(body)) {
+    const equalsIndex = entry.indexOf("=");
+    if (equalsIndex < 0) continue;
+    const rawKey = entry.slice(0, equalsIndex).trim();
+    const rawValue = entry.slice(equalsIndex + 1).trim();
+    const key = rawKey.startsWith('"') ? parseJsonStringOrNull(rawKey) : rawKey;
+    const value2 = rawValue.startsWith('"') ? parseJsonStringOrNull(rawValue) : rawValue;
+    if (key && value2 !== null) headers[key] = value2;
+  }
+  return headers;
+}
+function buildTomlInlineStringTable(record) {
+  return `{ ${Object.entries(record).map(([key, value2]) => `${formatTomlKey2(key)} = ${JSON.stringify(value2)}`).join(", ")} }`;
+}
+function findManagedAidenServer(servers) {
+  for (const name of MANAGED_AIDEN_MCP_SERVER_NAMES) {
+    const server = servers[name];
+    if (server && typeof server === "object") {
+      return { name, server };
+    }
+  }
+  return null;
+}
+function buildSessionHeaders(input) {
+  const headers = {
+    "x-conversation-id": input.conversationId
+  };
+  if (input.teamId) headers["x-team-id"] = input.teamId;
+  if (input.allowedTools?.length) {
+    headers["x-allowed-tools"] = input.allowedTools.join(",");
+  }
+  return headers;
+}
+function getTomlSectionName(line) {
+  const match = line.match(/^\s*\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\]\s*$/);
+  return match?.[1] ?? match?.[2] ?? null;
+}
+function patchCodexTomlMcpConfig(content, sessionHeaders) {
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  const sectionStart = lines.findIndex((line) => {
+    const name = getTomlSectionName(line);
+    return Boolean(name && MANAGED_AIDEN_MCP_SERVER_NAMES.includes(name));
+  });
+  if (sectionStart < 0) return null;
+  let sectionEnd = lines.findIndex((line, index) => index > sectionStart && /^\s*\[/.test(line));
+  if (sectionEnd < 0) sectionEnd = lines.length;
+  const headerLineIndex = lines.findIndex(
+    (line, index) => index > sectionStart && index < sectionEnd && /^\s*http_headers\s*=/.test(line)
+  );
+  if (headerLineIndex >= 0) {
+    const rawInlineTable = lines[headerLineIndex]?.replace(/^\s*http_headers\s*=\s*/, "") ?? "";
+    const currentHeaders = parseTomlInlineStringTable(rawInlineTable);
+    lines[headerLineIndex] = `http_headers = ${buildTomlInlineStringTable({
+      ...currentHeaders,
+      ...sessionHeaders
+    })}`;
+  } else {
+    const insertAfterUrl = lines.findIndex(
+      (line, index) => index > sectionStart && index < sectionEnd && /^\s*url\s*=/.test(line)
+    );
+    lines.splice(
+      insertAfterUrl >= 0 ? insertAfterUrl + 1 : sectionStart + 1,
+      0,
+      `http_headers = ${buildTomlInlineStringTable(sessionHeaders)}`
+    );
+  }
+  const updated = lines.join(newline);
+  return updated.endsWith(newline) ? updated : `${updated}${newline}`;
+}
+function patchCodexTomlMcpTarget(target, sessionHeaders) {
+  if (!(0, import_fs2.existsSync)(target.guardDir)) return false;
+  const existing = readFileOrNull(target.configPath);
+  if (existing === null) return false;
+  const updated = patchCodexTomlMcpConfig(existing, sessionHeaders);
+  if (updated === null || updated === existing) return false;
+  writeFileSafe(target.configPath, updated);
+  return true;
+}
+function patchJsonMcpTarget(target, sessionHeaders) {
+  if (!(0, import_fs2.existsSync)(target.guardDir)) return false;
+  const existing = readFileOrNull(target.configPath);
+  const config = parseJsonSafe(existing);
+  const servers = target.readServers(config);
+  const match = findManagedAidenServer(servers);
+  if (!match) return false;
+  const currentHeaders = target.readHeaders(match.server) ?? {};
+  target.writeHeaders(match.server, { ...currentHeaders, ...sessionHeaders });
+  servers[match.name] = match.server;
+  target.writeServers(config, servers);
+  writeFileSafe(target.configPath, `${JSON.stringify(config, null, 2)}
+`);
+  return true;
+}
+function jsonMcpServersTarget(cli, home, configRelativePath, guardRelativePath) {
+  const configPath = (0, import_path2.join)(home, ...configRelativePath);
+  const guardDir = guardRelativePath.length > 0 ? (0, import_path2.join)(home, ...guardRelativePath) : home;
+  return {
+    cli,
+    configPath,
+    guardDir,
+    readServers: (config) => config.mcpServers ?? {},
+    writeServers: (config, servers) => {
+      config.mcpServers = servers;
+    },
+    readHeaders: (server) => server.headers,
+    writeHeaders: (server, headers) => {
+      server.headers = headers;
+    }
+  };
+}
+function buildCodexTomlTargets(home) {
+  return [
+    {
+      cli: "Codex",
+      configPath: (0, import_path2.join)(home, ".codex", "config.toml"),
+      guardDir: (0, import_path2.join)(home, ".codex")
+    }
+  ];
+}
+function buildJsonTargets(home) {
+  return [
+    jsonMcpServersTarget("Cursor", home, [".cursor", "mcp.json"], [".cursor"]),
+    jsonMcpServersTarget("Claude Code", home, [".claude.json"], []),
+    jsonMcpServersTarget("Kimi CLI", home, [".kimi", "mcp.json"], [".kimi"]),
+    jsonMcpServersTarget("Factory Droid", home, [".factory", "mcp.json"], [".factory"]),
+    {
+      cli: "OpenCode",
+      configPath: (0, import_path2.join)(home, ".config", "opencode", "opencode.json"),
+      guardDir: (0, import_path2.join)(home, ".config", "opencode"),
+      readServers: (config) => config.mcp ?? {},
+      writeServers: (config, servers) => {
+        config.mcp = servers;
+      },
+      readHeaders: (server) => server.headers,
+      writeHeaders: (server, headers) => {
+        server.headers = headers;
+      }
+    },
+    {
+      cli: "Amp",
+      configPath: (0, import_path2.join)(home, ".config", "amp", "settings.json"),
+      guardDir: (0, import_path2.join)(home, ".config", "amp"),
+      readServers: (config) => config["amp.mcpServers"] ?? {},
+      writeServers: (config, servers) => {
+        config["amp.mcpServers"] = servers;
+      },
+      readHeaders: (server) => server.headers,
+      writeHeaders: (server, headers) => {
+        server.headers = headers;
+      }
+    },
+    {
+      cli: "Antigravity",
+      configPath: (0, import_path2.join)(home, ".gemini", "settings.json"),
+      guardDir: (0, import_path2.join)(home, ".gemini"),
+      readServers: (config) => config.mcpServers ?? {},
+      writeServers: (config, servers) => {
+        config.mcpServers = servers;
+      },
+      readHeaders: (server) => server.headers,
+      writeHeaders: (server, headers) => {
+        server.headers = headers;
+      }
+    },
+    {
+      cli: "Antigravity CLI",
+      configPath: (0, import_path2.join)(home, ".gemini", "antigravity-cli", "settings.json"),
+      guardDir: (0, import_path2.join)(home, ".gemini"),
+      readServers: (config) => config.mcpServers ?? {},
+      writeServers: (config, servers) => {
+        config.mcpServers = servers;
+      },
+      readHeaders: (server) => server.headers,
+      writeHeaders: (server, headers) => {
+        server.headers = headers;
+      }
+    }
+  ];
+}
+function syncAidenMcpSessionHeaders(input) {
+  const home = input.homeDir ?? (0, import_os2.homedir)();
+  const sessionHeaders = buildSessionHeaders(input);
+  const written = [];
+  for (const target of buildCodexTomlTargets(home)) {
+    try {
+      if (patchCodexTomlMcpTarget(target, sessionHeaders)) {
+        written.push(target.cli);
+      }
+    } catch {
+    }
+  }
+  for (const target of buildJsonTargets(home)) {
+    try {
+      if (patchJsonMcpTarget(target, sessionHeaders)) {
+        written.push(target.cli);
+      }
+    } catch {
+    }
+  }
+  return written;
+}
 function buildPromptWithSystem(config, promptText) {
   const parts2 = [
     config.systemPrompt?.trim(),
@@ -14961,16 +15308,16 @@ function imageFileExtension(mimeType) {
 }
 function createImageTempDirectory(cwd) {
   const candidates = [
-    cwd ? (0, import_path2.join)(cwd, ".aiden-images-") : null,
-    (0, import_path2.join)((0, import_os2.tmpdir)(), "aiden-images-")
+    cwd ? (0, import_path3.join)(cwd, ".aiden-images-") : null,
+    (0, import_path3.join)((0, import_os3.tmpdir)(), "aiden-images-")
   ].filter((value2) => Boolean(value2));
   for (const candidate of candidates) {
     try {
-      return (0, import_fs2.mkdtempSync)(candidate);
+      return (0, import_fs3.mkdtempSync)(candidate);
     } catch {
     }
   }
-  return (0, import_fs2.mkdtempSync)((0, import_path2.join)((0, import_os2.tmpdir)(), "aiden-images-"));
+  return (0, import_fs3.mkdtempSync)((0, import_path3.join)((0, import_os3.tmpdir)(), "aiden-images-"));
 }
 function safeFilename(filename) {
   const safe = filename.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
@@ -14984,8 +15331,8 @@ function writeImagesToTempFiles(images, cwd) {
   const files = [];
   for (const img of images) {
     const ext = imageFileExtension(img.mimeType);
-    const filePath = (0, import_path2.join)(directory, `aiden-img-${img.id}.${ext}`);
-    (0, import_fs2.writeFileSync)(filePath, Buffer.from(img.data, "base64"));
+    const filePath = (0, import_path3.join)(directory, `aiden-img-${img.id}.${ext}`);
+    (0, import_fs3.writeFileSync)(filePath, Buffer.from(img.data, "base64"));
     paths.push(filePath);
     files.push({
       filename: img.filename,
@@ -15000,7 +15347,7 @@ function writeImagesToTempFiles(images, cwd) {
     files,
     cleanup: () => {
       try {
-        (0, import_fs2.rmSync)(directory, { recursive: true, force: true });
+        (0, import_fs3.rmSync)(directory, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15026,8 +15373,8 @@ function writeFilesToTempFiles(files, cwd) {
   }
   for (const file of dataFiles) {
     if (!directory || file.data === void 0) continue;
-    const filePath = (0, import_path2.join)(directory, `${file.id}-${safeFilename(file.filename)}`);
-    (0, import_fs2.writeFileSync)(filePath, Buffer.from(file.data, "base64"));
+    const filePath = (0, import_path3.join)(directory, `${file.id}-${safeFilename(file.filename)}`);
+    (0, import_fs3.writeFileSync)(filePath, Buffer.from(file.data, "base64"));
     paths.push(filePath);
     tempFiles.push({
       filename: file.filename,
@@ -15042,7 +15389,7 @@ function writeFilesToTempFiles(files, cwd) {
     cleanup: () => {
       if (!directory) return;
       try {
-        (0, import_fs2.rmSync)(directory, { recursive: true, force: true });
+        (0, import_fs3.rmSync)(directory, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15964,6 +16311,30 @@ function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
     }
   };
 }
+var execFileAsync = (0, import_util10.promisify)(import_child_process3.execFile);
+var flagSupportCache = /* @__PURE__ */ new Map();
+function helpAdvertisesFlag(helpText, flag) {
+  return helpText.includes(flag);
+}
+async function cliSupportsFlag(command, flag, env = {}) {
+  const key = `${command}::${flag}`;
+  const cached = flagSupportCache.get(key);
+  if (cached !== void 0) return cached;
+  let supported = false;
+  try {
+    const { stdout, stderr } = await execFileAsync(command, ["--help"], {
+      env: { ...process.env, ...env },
+      timeout: 5e3,
+      maxBuffer: 4 * 1024 * 1024
+    });
+    supported = helpAdvertisesFlag(`${stdout ?? ""}${stderr ?? ""}`, flag);
+  } catch (error) {
+    const withOutput = error;
+    supported = helpAdvertisesFlag(`${withOutput.stdout ?? ""}${withOutput.stderr ?? ""}`, flag);
+  }
+  flagSupportCache.set(key, supported);
+  return supported;
+}
 function stringField(record, key) {
   const value2 = record[key];
   return typeof value2 === "string" && value2.trim().length > 0 ? value2 : void 0;
@@ -16333,13 +16704,13 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
         args.push("--disallowedTools", disallowedTools.join(","));
       }
       const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
-      if (!resumeId) {
-        if (context.config.systemPrompt?.trim()) {
-          args.push("--system-prompt", context.config.systemPrompt.trim());
-        }
-        if (context.config.systemPromptAppend?.trim()) {
-          args.push("--append-system-prompt", context.config.systemPromptAppend.trim());
-        }
+      if (!resumeId && context.config.systemPrompt?.trim()) {
+        args.push("--system-prompt", context.config.systemPrompt.trim());
+      } else if (resumeId && context.config.systemPromptAppend?.trim()) {
+        args.push("--append-system-prompt", context.config.systemPromptAppend.trim());
+      }
+      if (context.config.teamId?.trim() && await cliSupportsFlag(command, "--approve-mcps", context.env)) {
+        args.push("--approve-mcps");
       }
       const baseModel = context.config.selectedModel?.trim();
       if (baseModel) {
@@ -16424,26 +16795,26 @@ function normalizeCodexMcpToolResult(output) {
   return raw;
 }
 function findCodexSessionLog(runtimeSessionId, codexHome) {
-  if (!runtimeSessionId || !(0, import_fs3.existsSync)(codexHome)) return null;
-  const root = (0, import_path3.join)(codexHome, "sessions");
-  if (!(0, import_fs3.existsSync)(root)) return null;
+  if (!runtimeSessionId || !(0, import_fs4.existsSync)(codexHome)) return null;
+  const root = (0, import_path4.join)(codexHome, "sessions");
+  if (!(0, import_fs4.existsSync)(root)) return null;
   const matches = [];
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_fs3.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_fs4.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path = (0, import_path3.join)(dir, entry.name);
+      const path = (0, import_path4.join)(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.includes(runtimeSessionId) && entry.name.endsWith(".jsonl")) {
         try {
-          matches.push({ path, mtimeMs: (0, import_fs3.statSync)(path).mtimeMs });
+          matches.push({ path, mtimeMs: (0, import_fs4.statSync)(path).mtimeMs });
         } catch {
           matches.push({ path, mtimeMs: 0 });
         }
@@ -16476,10 +16847,10 @@ function latestUserMessageLineIndex(lines) {
 async function replayCodexMcpToolEventsFromSessionLog(context, state) {
   const runtimeSessionId = state.runtimeSessionId;
   if (!runtimeSessionId) return;
-  const codexHome = context.env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path3.join)((0, import_os3.homedir)(), ".codex");
+  const codexHome = context.env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path4.join)((0, import_os4.homedir)(), ".codex");
   const logPath = findCodexSessionLog(runtimeSessionId, codexHome);
   if (!logPath) return;
-  const allLines = (0, import_fs3.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const allLines = (0, import_fs4.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
   const latestUserLineIndex = latestUserMessageLineIndex(allLines);
   const lines = latestUserLineIndex >= 0 ? allLines.slice(latestUserLineIndex + 1) : allLines;
   const emittedToolIds = /* @__PURE__ */ new Set();
@@ -17117,6 +17488,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         context.config.images,
         context.cwd
       );
+      const approveMcps = context.config.teamId?.trim() ? await cliSupportsFlag(command, "--approve-mcps", context.env) : false;
       try {
         return await createGenericCliBackend({
           kind: "cursor_agent_cli",
@@ -17129,10 +17501,12 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
               "--output-format",
               "stream-json",
               "--trust",
-              "--approve-mcps",
               "--workspace",
               ctx.cwd
             ];
+            if (approveMcps) {
+              args.push("--approve-mcps");
+            }
             const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
             if (shouldForceCursorAgent(ctx.config)) args.push("--force");
             if (ctx.config.mode === "plan" || ctx.config.mode === "review") {
@@ -17167,7 +17541,12 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
           // with zero output; without this watchdog only the 30-min server reaper
           // would end the run.
           startupTimeoutMs: 18e4,
-          augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
+          augmentPrompt: (ctx) => {
+            const prompt = buildPromptWithImagePathReferences(ctx, imageFiles);
+            return ctx.config.teamId?.trim() ? `${prompt}
+
+${buildCodeDiscoveryEnforcementTail()}` : prompt;
+          },
           parseStructuredLine: parseCursorStructuredLine
         }).run(context);
       } finally {
@@ -17305,174 +17684,259 @@ function createDroidCliBackend(command = "droid", defaultArgs = []) {
     }
   };
 }
+var ACP_PROTOCOL_VERSION = 1;
 function asRecord(value2) {
-  return value2 && typeof value2 === "object" ? value2 : null;
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
-function extractToolName2(parsed) {
-  for (const key of ["toolName", "name", "tool", "tool_name"]) {
-    const value2 = parsed[key];
-    if (typeof value2 === "string" && value2.trim()) return value2.trim();
+function asString(value2) {
+  return typeof value2 === "string" ? value2 : "";
+}
+function resumeSessionId(context) {
+  return context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim() || "";
+}
+function chunkText(content) {
+  const record = asRecord(content);
+  if (!record) return "";
+  if (typeof record.text === "string") return record.text;
+  return chunkText(record.content);
+}
+function toolResultText(update) {
+  const content = update.content;
+  if (Array.isArray(content)) {
+    const parts2 = content.map((item) => chunkText(item)).filter((text) => text.length > 0);
+    if (parts2.length) return parts2.join("\n");
   }
-  const toolCall = asRecord(parsed.toolCall) ?? asRecord(parsed.tool_call);
-  if (toolCall) {
-    for (const key of ["name", "toolName", "tool"]) {
-      const value2 = toolCall[key];
-      if (typeof value2 === "string" && value2.trim()) return value2.trim();
+  const rawOutput = update.rawOutput;
+  if (rawOutput !== void 0) return JSON.stringify(rawOutput, null, 2);
+  return "";
+}
+function toolMetaName(update) {
+  const meta = asRecord(update._meta);
+  const tool = asRecord(meta?.["x.ai/tool"]);
+  return asString(tool?.name);
+}
+function resolvePermission(params, context) {
+  const record = asRecord(params);
+  const options = Array.isArray(record?.options) ? record?.options : [];
+  const toolCall = asRecord(record?.toolCall);
+  const meta = asRecord(toolCall?._meta);
+  const tool = asRecord(meta?.["x.ai/tool"]);
+  const isReadOnlyTool = tool?.read_only === true || asString(tool?.kind) === "read";
+  const allow = !shouldUseReadOnlyRuntimePermissions(context.config) || isReadOnlyTool;
+  const allowKinds = ["allow_always", "allow_once", "allow"];
+  const rejectKinds = ["reject_always", "reject_once", "reject", "deny"];
+  const wanted = allow ? allowKinds : rejectKinds;
+  const chosen = options.find((option) => wanted.includes(asString(asRecord(option)?.kind))) ?? (allow ? options[0] : options[options.length - 1]);
+  const optionId = asString(asRecord(chosen)?.optionId);
+  if (!optionId) return { outcome: { outcome: "cancelled" } };
+  return { outcome: { outcome: "selected", optionId } };
+}
+function createGrokAcpDriver(imageFiles) {
+  let stdin = null;
+  let nextId = 0;
+  let initId = -1;
+  let sessionOpId = -1;
+  let promptId = -1;
+  let attemptedNewSession = false;
+  let finalized = false;
+  function write(message) {
+    try {
+      stdin?.write(`${JSON.stringify(message)}
+`);
+    } catch {
     }
   }
-  return "Grok Tool";
-}
-function extractToolId2(parsed, fallback) {
-  for (const key of ["toolCallId", "callId", "call_id", "id"]) {
-    const value2 = parsed[key];
-    if (typeof value2 === "string" && value2.trim()) return value2.trim();
+  function request(method, params) {
+    const id = ++nextId;
+    write({ jsonrpc: "2.0", id, method, params });
+    return id;
   }
-  const toolCall = asRecord(parsed.toolCall) ?? asRecord(parsed.tool_call);
-  if (toolCall) {
-    for (const key of ["id", "toolCallId", "callId"]) {
-      const value2 = toolCall[key];
-      if (typeof value2 === "string" && value2.trim()) return value2.trim();
-    }
+  function respond(id, result) {
+    write({ jsonrpc: "2.0", id, result });
   }
-  return fallback;
-}
-function extractToolArgs(parsed) {
-  for (const key of ["args", "arguments", "input", "params"]) {
-    if (parsed[key] !== void 0) return parsed[key];
+  function newSession(context) {
+    attemptedNewSession = true;
+    sessionOpId = request("session/new", { cwd: context.cwd, mcpServers: [] });
   }
-  const toolCall = asRecord(parsed.toolCall) ?? asRecord(parsed.tool_call);
-  if (toolCall) {
-    for (const key of ["args", "arguments", "input", "params"]) {
-      if (toolCall[key] !== void 0) return toolCall[key];
+  function beginSession(context, state) {
+    const resume = resumeSessionId(context);
+    if (resume) {
+      state.runtimeSessionId = resume;
+      sessionOpId = request("session/load", {
+        sessionId: resume,
+        cwd: context.cwd,
+        mcpServers: []
+      });
+      return;
     }
+    newSession(context);
   }
-  return parsed;
-}
-function extractToolResultText(parsed) {
-  for (const key of ["result", "output", "content", "data", "message"]) {
-    const value2 = parsed[key];
-    if (typeof value2 === "string" && value2.trim()) return value2;
+  function sendPrompt(context, state) {
+    const text = buildPromptWithImagePathReferences(context, imageFiles);
+    promptId = request("session/prompt", {
+      sessionId: state.runtimeSessionId,
+      prompt: [{ type: "text", text }]
+    });
   }
-  return JSON.stringify(parsed, null, 2);
-}
-function handleGrokStructuredEvent(parsed, context, state) {
-  const presenter = context.presenter;
-  const type = typeof parsed.type === "string" ? parsed.type : "";
-  if (!type) return false;
-  for (const key of ["sessionId", "session_id"]) {
-    const value2 = parsed[key];
-    if (typeof value2 === "string" && value2.trim()) {
-      state.runtimeSessionId = value2.trim();
-      break;
+  function finalize(state) {
+    if (finalized) return;
+    finalized = true;
+    state.resultReceived = true;
+    state.onResultReceived?.();
+    try {
+      stdin?.end();
+    } catch {
     }
   }
-  if (typeof parsed.model === "string" && parsed.model.trim()) {
-    state.activeModel = parsed.model.trim();
-  }
-  switch (type) {
-    case "thought":
-    case "thinking":
-    case "reasoning": {
-      const text = typeof parsed.data === "string" ? parsed.data : "";
-      if (!text) return true;
-      state.iterations = Math.max(state.iterations, 1);
-      void presenter.onThinking(text);
-      return true;
+  function handleResponse(message, context, state) {
+    if (message.error && message.id === sessionOpId && !attemptedNewSession) {
+      newSession(context);
+      return;
     }
-    case "text":
-    case "assistant":
-    case "message": {
-      const text = typeof parsed.data === "string" ? parsed.data : typeof parsed.text === "string" ? parsed.text : typeof parsed.content === "string" ? parsed.content : "";
-      if (!text) return true;
-      state.iterations = Math.max(state.iterations, 1);
-      state.summary += text;
-      void presenter.onAssistantText(text);
-      return true;
+    if (message.error) {
+      state.error = message.error.message?.trim() || "Grok agent error";
+      void context.presenter.onError(state.error);
+      finalize(state);
+      return;
     }
-    case "tool":
-    case "tool_call":
-    case "tool_use":
-    case "toolCall": {
-      const toolId = extractToolId2(parsed, `grok-tool-${Date.now()}`);
-      const toolName = extractToolName2(parsed);
-      const toolArgs = extractToolArgs(parsed);
-      const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
-      const status = typeof parsed.status === "string" ? parsed.status : "";
-      state.iterations = Math.max(state.iterations, 1);
-      if (subtype === "completed" || subtype === "result" || status === "completed" || status === "done" || parsed.result !== void 0 || parsed.output !== void 0) {
-        void presenter.onToolResult?.(toolId, extractToolResultText(parsed));
-        return true;
-      }
-      void presenter.onToolUse(toolName, toolArgs, toolId);
-      return true;
+    const result = asRecord(message.result);
+    if (message.id === initId) {
+      const modelState = asRecord(asRecord(result?._meta)?.modelState);
+      const model = asString(modelState?.currentModelId);
+      if (model) state.activeModel = model;
+      beginSession(context, state);
+      return;
     }
-    case "tool_result":
-    case "toolResult": {
-      const toolId = extractToolId2(parsed, `grok-tool-${Date.now()}`);
+    if (message.id === sessionOpId) {
+      const sessionId = asString(result?.sessionId);
+      if (sessionId) state.runtimeSessionId = sessionId;
       state.iterations = Math.max(state.iterations, 1);
-      void presenter.onToolResult?.(toolId, extractToolResultText(parsed));
-      return true;
-    }
-    case "error": {
-      const message = typeof parsed.message === "string" && parsed.message.trim() ? parsed.message.trim() : typeof parsed.data === "string" && parsed.data.trim() ? parsed.data.trim() : "Grok Build run failed";
-      state.error = message;
-      void presenter.onError(message);
-      state.resultReceived = true;
-      state.onResultReceived?.();
-      return true;
+      sendPrompt(context, state);
+      return;
     }
-    case "end":
-    case "result": {
-      const stopReason = typeof parsed.stopReason === "string" ? parsed.stopReason : "";
+    if (message.id === promptId) {
+      const meta = asRecord(result?._meta);
+      const model = asString(meta?.modelId) || state.activeModel || (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel.trim() : "grok");
+      const inputTokens = typeof meta?.inputTokens === "number" ? meta.inputTokens : 0;
+      const outputTokens = typeof meta?.outputTokens === "number" ? meta.outputTokens : 0;
+      const cacheReadTokens = typeof meta?.cachedReadTokens === "number" ? meta.cachedReadTokens : 0;
       state.iterations = Math.max(state.iterations, 1);
       state.usage = {
-        model: state.activeModel || (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel : "grok"),
+        model,
         numTurns: Math.max(state.iterations, 1),
-        durationMs: typeof parsed.duration_ms === "number" ? parsed.duration_ms : 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
+        durationMs: 0,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
         cacheCreationTokens: 0,
         costUsd: 0
       };
-      void presenter.onUsageUpdate?.({
-        model: state.usage.model,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
+      void context.presenter.onUsageUpdate?.({
+        model,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
         cacheCreationTokens: 0
       });
-      if ((stopReason.toLowerCase().includes("error") || parsed.is_error === true) && !state.error) {
+      const stopReason = asString(result?.stopReason).toLowerCase();
+      if (stopReason.includes("error") && !state.error) {
         state.error = "Grok Build run failed";
-        void presenter.onError(state.error);
+        void context.presenter.onError(state.error);
       }
-      state.resultReceived = true;
-      state.onResultReceived?.();
-      return true;
+      finalize(state);
+    }
+  }
+  function handleServerRequest(message, context, _state) {
+    const id = message.id;
+    switch (message.method) {
+      case "session/request_permission":
+        respond(id, resolvePermission(message.params, context));
+        return;
+      case "fs/read_text_file":
+        respond(id, { content: "" });
+        return;
+      default:
+        respond(id, null);
+    }
+  }
+  function handleNotification(message, context, state) {
+    const params = asRecord(message.params);
+    const update = asRecord(params?.update);
+    if (!update) return;
+    const presenter = context.presenter;
+    switch (asString(update.sessionUpdate)) {
+      case "agent_thought_chunk": {
+        const text = chunkText(update.content);
+        if (!text) return;
+        state.iterations = Math.max(state.iterations, 1);
+        void presenter.onThinking(text);
+        return;
+      }
+      case "agent_message_chunk": {
+        const text = chunkText(update.content);
+        if (!text) return;
+        state.iterations = Math.max(state.iterations, 1);
+        state.summary += text;
+        void presenter.onAssistantText(text);
+        return;
+      }
+      case "tool_call": {
+        const toolId = asString(update.toolCallId);
+        const toolName = asString(update.title) || toolMetaName(update) || "Grok Tool";
+        const input = update.rawInput ?? {};
+        state.iterations = Math.max(state.iterations, 1);
+        void presenter.onToolUse(toolName, input, toolId);
+        return;
+      }
+      case "tool_call_update": {
+        const status = asString(update.status).toLowerCase();
+        if (status !== "completed" && status !== "failed" && status !== "error") return;
+        const toolId = asString(update.toolCallId);
+        void presenter.onToolResult?.(toolId, toolResultText(update));
+        return;
+      }
+      default:
+        return;
     }
-    default:
-      return false;
   }
+  function handleLine(line, context, state) {
+    if (!stdin && state.stdin) stdin = state.stdin;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      if (line.trim().length > 0) void context.presenter.onLog(`[grok_cli] ${line}`);
+      return;
+    }
+    const message = asRecord(parsed);
+    if (!message) return;
+    if (message.id !== void 0 && message.method === void 0) {
+      handleResponse(message, context, state);
+      return;
+    }
+    if (message.method && message.id !== void 0) {
+      handleServerRequest(message, context, state);
+      return;
+    }
+    if (message.method) {
+      handleNotification(message, context, state);
+    }
+  }
+  function start(stdinStream, _context) {
+    stdin = stdinStream;
+    initId = request("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      }
+    });
+  }
+  return { start, handleLine };
 }
-var parseGrokStructuredLine = createStructuredLineParser(
-  "grok_cli",
-  handleGrokStructuredEvent
-);
 function isGrokCliModelId(model) {
   return model === "auto" || /^grok-/.test(model) || /^grok_/.test(model) || model.startsWith("grok-composer-");
 }
-function resolveGrokPermissionMode(config) {
-  if (shouldUseReadOnlyRuntimePermissions(config)) return "plan";
-  switch (config.mode) {
-    case "plan":
-    case "review":
-      return "plan";
-    case "ask":
-      return "dontAsk";
-    default:
-      return "bypassPermissions";
-  }
-}
 function createGrokCliBackend(command = "grok", defaultArgs = []) {
   return {
     kind: "grok_cli",
@@ -17482,34 +17946,17 @@ function createGrokCliBackend(command = "grok", defaultArgs = []) {
         context.config.images,
         context.cwd
       );
+      const driver = createGrokAcpDriver(imageFiles);
       try {
         return await createGenericCliBackend({
           kind: "grok_cli",
           supportTier: "structured",
           command,
           args: [],
-          buildArgs: (ctx, prompt) => {
-            const args = [
-              "-p",
-              prompt,
-              "--output-format",
-              "streaming-json",
-              "--cwd",
-              ctx.cwd,
-              "--permission-mode",
-              resolveGrokPermissionMode(ctx.config)
-            ];
-            if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
-              args.push("--always-approve");
-            }
-            const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
-            if (resumeId) args.push("--resume", resumeId);
-            const model = ctx.config.selectedModel?.trim();
-            if (model && isGrokCliModelId(model)) args.push("--model", model);
-            return [...args, ...defaultArgs];
-          },
-          augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
-          parseStructuredLine: parseGrokStructuredLine
+          buildArgs: (ctx) => buildGrokAgentArgs(ctx.config, defaultArgs),
+          keepStdinOpen: true,
+          stdinWriter: (stdin, ctx) => driver.start(stdin, ctx),
+          parseStructuredLine: driver.handleLine
         }).run(context);
       } finally {
         cleanup();
@@ -17517,10 +17964,20 @@ function createGrokCliBackend(command = "grok", defaultArgs = []) {
     }
   };
 }
+function buildGrokAgentArgs(config, defaultArgs = []) {
+  const args = ["agent"];
+  if (!shouldUseReadOnlyRuntimePermissions(config)) {
+    args.push("--always-approve");
+  }
+  const model = config.selectedModel?.trim();
+  if (model && isGrokCliModelId(model)) args.push("--model", model);
+  args.push(...defaultArgs, "stdio");
+  return args;
+}
 var DEFAULT_SKILL_ROOTS = [
-  (0, import_path4.join)((0, import_os4.homedir)(), ".agents", "skills"),
-  (0, import_path4.join)((0, import_os4.homedir)(), ".claude", "skills"),
-  (0, import_path4.join)((0, import_os4.homedir)(), ".config", "opencode", "skills")
+  (0, import_path5.join)((0, import_os5.homedir)(), ".agents", "skills"),
+  (0, import_path5.join)((0, import_os5.homedir)(), ".claude", "skills"),
+  (0, import_path5.join)((0, import_os5.homedir)(), ".config", "opencode", "skills")
 ];
 function parseFrontmatter(content) {
   if (!content.startsWith("---\n")) return {};
@@ -17536,12 +17993,12 @@ function parseFrontmatter(content) {
   return result;
 }
 function listSkillFiles(root) {
-  if (!(0, import_fs4.existsSync)(root)) return [];
+  if (!(0, import_fs5.existsSync)(root)) return [];
   const files = [];
-  for (const entry of (0, import_fs4.readdirSync)(root, { withFileTypes: true })) {
+  for (const entry of (0, import_fs5.readdirSync)(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillPath = (0, import_path4.join)(root, entry.name, "SKILL.md");
-    if ((0, import_fs4.existsSync)(skillPath)) files.push(skillPath);
+    const skillPath = (0, import_path5.join)(root, entry.name, "SKILL.md");
+    if ((0, import_fs5.existsSync)(skillPath)) files.push(skillPath);
   }
   return files;
 }
@@ -17550,7 +18007,7 @@ function loadInstalledSkills(roots = DEFAULT_SKILL_ROOTS) {
   for (const root of roots) {
     for (const skillPath of listSkillFiles(root)) {
       try {
-        const frontmatter = parseFrontmatter((0, import_fs4.readFileSync)(skillPath, "utf8"));
+        const frontmatter = parseFrontmatter((0, import_fs5.readFileSync)(skillPath, "utf8"));
         const name = frontmatter.name;
         const description = frontmatter.description;
         if (!name || !description || skills.has(name)) continue;
@@ -18047,40 +18504,40 @@ function parseSkillInvocation(text) {
 function candidateRoots(cwd) {
   const roots = [];
   if (cwd) {
-    roots.push((0, import_path5.join)(cwd, ".agents", "skills"));
-    roots.push((0, import_path5.join)(cwd, ".claude", "skills"));
-    roots.push((0, import_path5.join)(cwd, ".codex", "skills"));
-    if ((0, import_fs5.existsSync)(cwd)) {
+    roots.push((0, import_path6.join)(cwd, ".agents", "skills"));
+    roots.push((0, import_path6.join)(cwd, ".claude", "skills"));
+    roots.push((0, import_path6.join)(cwd, ".codex", "skills"));
+    if ((0, import_fs6.existsSync)(cwd)) {
       let entries = [];
       try {
-        entries = (0, import_fs5.readdirSync)(cwd, { withFileTypes: true });
+        entries = (0, import_fs6.readdirSync)(cwd, { withFileTypes: true });
       } catch {
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const child = (0, import_path5.join)(cwd, entry.name);
-        roots.push((0, import_path5.join)(child, ".agents", "skills"));
-        roots.push((0, import_path5.join)(child, ".claude", "skills"));
-        roots.push((0, import_path5.join)(child, ".codex", "skills"));
+        const child = (0, import_path6.join)(cwd, entry.name);
+        roots.push((0, import_path6.join)(child, ".agents", "skills"));
+        roots.push((0, import_path6.join)(child, ".claude", "skills"));
+        roots.push((0, import_path6.join)(child, ".codex", "skills"));
       }
     }
   }
-  const home = (0, import_os5.homedir)();
-  roots.push((0, import_path5.join)(home, ".agents", "skills"));
-  roots.push((0, import_path5.join)(home, ".claude", "skills"));
-  roots.push((0, import_path5.join)(home, ".codex", "skills"));
+  const home = (0, import_os6.homedir)();
+  roots.push((0, import_path6.join)(home, ".agents", "skills"));
+  roots.push((0, import_path6.join)(home, ".claude", "skills"));
+  roots.push((0, import_path6.join)(home, ".codex", "skills"));
   return Array.from(new Set(roots));
 }
 function resolveSkillInvocation(text, cwd) {
   const parsed = parseSkillInvocation(text);
   if (!parsed) return null;
   for (const root of candidateRoots(cwd)) {
-    const skillPath = (0, import_path5.join)(root, parsed.command, "SKILL.md");
-    if (!(0, import_fs5.existsSync)(skillPath)) continue;
+    const skillPath = (0, import_path6.join)(root, parsed.command, "SKILL.md");
+    if (!(0, import_fs6.existsSync)(skillPath)) continue;
     let content;
     try {
-      content = (0, import_fs5.readFileSync)(skillPath, "utf-8");
+      content = (0, import_fs6.readFileSync)(skillPath, "utf-8");
     } catch {
       continue;
     }
@@ -18326,8 +18783,14 @@ Prefer relative paths and keep your work scoped to this project.`
     }
     const lifecyclePrompt = buildTaskLifecyclePrompt(config);
     if (lifecyclePrompt) systemPromptParts.push(lifecyclePrompt);
+    const teamId = config.teamId;
+    const teamCodeOverlay = teamId ? buildAidenTeamCodeContextOverlay(teamId) : void 0;
+    if (teamCodeOverlay) {
+      systemPromptParts.push(teamCodeOverlay);
+    }
     const extra = this.buildExtraSystemPromptParts(config);
     systemPromptParts.push(...extra);
+    const mergedAppend = [config.systemPromptAppend?.trim(), teamCodeOverlay].filter((value2) => Boolean(value2 && value2.length > 0)).join("\n\n");
     return {
       ...config,
       backendKind,
@@ -18335,7 +18798,8 @@ Prefer relative paths and keep your work scoped to this project.`
       runtimeCommand: config.runtimeCommand || this.runtime.runtimeCommand,
       runtimeArgs: config.runtimeArgs || this.runtime.runtimeArgs,
       selectedModel: config.selectedModel || defaultSelectedModelForBackend(backendKind),
-      systemPrompt: systemPromptParts.join("\n\n") || void 0
+      systemPrompt: systemPromptParts.join("\n\n") || void 0,
+      systemPromptAppend: mergedAppend || void 0
     };
   }
   async runCliBackend(config, safeProjectPath) {
@@ -18479,6 +18943,21 @@ Prefer relative paths and keep your work scoped to this project.`
       this.presenter.onComplete(result);
       return result;
     }
+    if (initialConfig.conversationId) {
+      try {
+        const writtenClis = syncAidenMcpSessionHeaders({
+          conversationId: initialConfig.conversationId,
+          teamId: initialConfig.teamId
+        });
+        if (writtenClis.length > 0) {
+          void this.presenter.onLog(
+            `Synced Aiden MCP session headers to ${writtenClis.join(", ")}`
+          );
+        }
+      } catch (error) {
+        console.warn("[base-machine-agent] Failed to sync MCP session headers", error);
+      }
+    }
     try {
       return await this.runCliBackend(initialConfig, safeProjectPath);
     } catch (error) {
@@ -18520,8 +18999,8 @@ var MAX_SESSION_VIDEO_BYTES = 100 * 1024 * 1024;
 function isRecord(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-function shouldExtractGeneratedImagesFromToolResult(toolName, content, options = {}) {
-  return isGeneratedImageToolName(toolName) || isBrowserScreenshotToolName(toolName) || isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "image");
+function shouldExtractGeneratedImagesFromToolResult(toolName, _content, _options = {}) {
+  return isGeneratedImageToolName(toolName);
 }
 function collectStringValues(value2, out) {
   if (typeof value2 === "string") {
@@ -18585,14 +19064,14 @@ function normalizePath(candidate, cwd) {
   } catch {
   }
   if (path.startsWith("~/")) return null;
-  if ((0, import_path6.isAbsolute)(path)) return path;
-  return cwd ? (0, import_path6.join)(cwd, path) : null;
+  if ((0, import_path7.isAbsolute)(path)) return path;
+  return cwd ? (0, import_path7.join)(cwd, path) : null;
 }
 function resolveToolCwd(cwd, toolInput) {
   if (!isRecord(toolInput)) return cwd;
   const raw = typeof toolInput.cwd === "string" ? toolInput.cwd : typeof toolInput.workdir === "string" ? toolInput.workdir : typeof toolInput.workingDirectory === "string" ? toolInput.workingDirectory : null;
   if (!raw) return cwd;
-  return (0, import_path6.isAbsolute)(raw) || !cwd ? raw : (0, import_path6.join)(cwd, raw);
+  return (0, import_path7.isAbsolute)(raw) || !cwd ? raw : (0, import_path7.join)(cwd, raw);
 }
 function extractBrowserMediaPathHints(content, cwd, toolName, options = {}, kind = "video") {
   if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, kind)) return [];
@@ -18635,19 +19114,19 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
   const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
   for (const candidate of extractPathCandidates(content, options)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs6.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs7.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path6.extname)(path).toLowerCase();
+    const ext = (0, import_path7.extname)(path).toLowerCase();
     const mimeType = IMAGE_MIME_BY_EXT[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs6.statSync)(path);
+    const stat = (0, import_fs7.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
-    const buffer = (0, import_fs6.readFileSync)(path);
+    const buffer = (0, import_fs7.readFileSync)(path);
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
       id: (0, import_crypto2.randomUUID)(),
-      filename: (0, import_path6.basename)(path),
+      filename: (0, import_path7.basename)(path),
       mimeType,
       size: buffer.length,
       width,
@@ -18662,27 +19141,36 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
   return images;
 }
 function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, options = {}) {
-  if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "video")) return [];
+  const isImage = isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "image");
+  const isVideo = isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "video");
+  if (!isImage && !isVideo) return [];
   const media = [];
   const seen = /* @__PURE__ */ new Set();
   const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
-  for (const candidate of extractPathCandidates(content, options, "mp4|webm|mov")) {
+  const kind = isVideo ? "video" : "image";
+  const extensionsPattern = kind === "video" ? "mp4|webm|mov" : "png|jpe?g|gif|webp";
+  const maxBytes = kind === "video" ? MAX_SESSION_VIDEO_BYTES : MAX_GENERATED_IMAGE_BYTES;
+  const mimeByExt = kind === "video" ? VIDEO_MIME_BY_EXT : IMAGE_MIME_BY_EXT;
+  for (const candidate of extractPathCandidates(content, options, extensionsPattern)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs6.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs7.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path6.extname)(path).toLowerCase();
-    const mimeType = VIDEO_MIME_BY_EXT[ext];
+    const ext = (0, import_path7.extname)(path).toLowerCase();
+    const mimeType = mimeByExt[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs6.statSync)(path);
-    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_SESSION_VIDEO_BYTES) continue;
-    const buffer = (0, import_fs6.readFileSync)(path);
+    const stat = (0, import_fs7.statSync)(path);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes) continue;
+    const buffer = (0, import_fs7.readFileSync)(path);
+    const dimensions = kind === "image" ? readImageDimensions2(buffer, mimeType) : null;
     media.push({
       type: "session_media",
-      kind: "video",
+      kind,
       id: (0, import_crypto2.randomUUID)(),
-      filename: (0, import_path6.basename)(path),
+      filename: (0, import_path7.basename)(path),
       mimeType,
       size: buffer.length,
+      width: dimensions?.width,
+      height: dimensions?.height,
       data: buffer.toString("base64"),
       sourcePath: path,
       sourceHash: (0, import_crypto2.createHash)("sha256").update(buffer).digest("hex"),
@@ -18932,7 +19420,7 @@ ${meta.description}`);
     const workflowId = config.workflowId ?? process.env.AIDEN_WORKFLOW_ID;
     const workflowExecutionId = config.workflowExecutionId ?? process.env.AIDEN_WORKFLOW_EXECUTION_ID;
     const conversationId = config.conversationId ?? process.env.AIDEN_SESSION_ID;
-    const teamId = config.teamId;
+    const teamId = config.teamId ?? process.env.AIDEN_TEAM_ID;
     const artifactIds = [];
     if (teamId) artifactIds.push(`- teamId: "${teamId}"`);
     const isWorkflowSession = !!(workflowId || workflowExecutionId);
@@ -18970,11 +19458,6 @@ ${meta.description}`);
         ].join("\n")
       );
     }
-    if (teamId) {
-      parts2.push(
-        `You are operating within team \`${teamId}\`. Always use this as the \`teamId\` for all MCP tool calls that accept it (list_tasks, search, start_task_session, etc.). Do not call list_teams.`
-      );
-    }
     return parts2;
   }
 };
@@ -19163,20 +19646,40 @@ function extractModelIdsFromJson(value2) {
   }
   return [];
 }
-function extractCodexModelSlugsFromDebugJson(value2) {
+function normalizeCodexReasoningEffort(effort) {
+  const normalized = effort.trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "none") return "minimal";
+  if (normalized === "minimal" || normalized === "low" || normalized === "medium" || normalized === "high" || normalized === "xhigh" || normalized === "max" || normalized === "ultra") {
+    return normalized;
+  }
+  return null;
+}
+function extractCodexDiscoveredModelIdsFromDebugJson(value2) {
   if (!value2 || typeof value2 !== "object") return [];
   const models = value2.models;
   if (!Array.isArray(models)) return [];
-  const slugs = [];
+  const ids = [];
   for (const entry of models) {
     if (!entry || typeof entry !== "object") continue;
     const record = entry;
     const visibility = typeof record.visibility === "string" ? record.visibility.toLowerCase() : "list";
     if (visibility === "hidden" || visibility === "hide") continue;
     const slug = readModelId(record.slug);
-    if (slug) slugs.push(slug);
+    if (!slug) continue;
+    const reasoningLevels = record.supported_reasoning_levels;
+    if (Array.isArray(reasoningLevels) && reasoningLevels.length > 0) {
+      for (const levelEntry of reasoningLevels) {
+        if (!levelEntry || typeof levelEntry !== "object") continue;
+        const effort = typeof levelEntry.effort === "string" ? levelEntry.effort : null;
+        const normalized = effort ? normalizeCodexReasoningEffort(effort) : null;
+        if (normalized) ids.push(`${slug}-${normalized}`);
+      }
+      continue;
+    }
+    ids.push(slug);
   }
-  return [...new Set(slugs)];
+  return [...new Set(ids)];
 }
 function extractModelIdsFromText(value2) {
   const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
@@ -19267,8 +19770,8 @@ async function probeJsonOrTextModels(executable, env, argSets, options) {
     if (!result || result.error || result.status !== 0 || !result.stdout.trim()) continue;
     try {
       const parsed = JSON.parse(result.stdout);
-      const codexSlugs = extractCodexModelSlugsFromDebugJson(parsed);
-      if (codexSlugs.length > 0) return codexSlugs;
+      const codexModels = extractCodexDiscoveredModelIdsFromDebugJson(parsed);
+      if (codexModels.length > 0) return codexModels;
       const models = extractModelIdsFromJson(parsed);
       if (models.length > 0) return models;
     } catch {
@@ -19349,7 +19852,7 @@ async function discoverProviderModels(provider, executable, env) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.32";
+var AGENT_VERSION = "0.1.33";
 
 // src/daemon.ts
 var STAGING_API_URL = process.env.AIDEN_STAGING_API_URL ?? "https://api.staging.aiden-platform.com";
@@ -19609,7 +20112,14 @@ function readEndpointDefaults() {
 function writeConfig(config) {
   const configPath = getConfigPath();
   (0, import_node_fs7.mkdirSync)((0, import_node_path5.dirname)(configPath), { recursive: true, mode: 448 });
-  (0, import_node_fs7.writeFileSync)(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+  const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  try {
+    (0, import_node_fs7.writeFileSync)(pendingPath, JSON.stringify(config, null, 2), { mode: 384 });
+    (0, import_node_fs7.chmodSync)(pendingPath, 384);
+    (0, import_node_fs7.renameSync)(pendingPath, configPath);
+  } finally {
+    (0, import_node_fs7.rmSync)(pendingPath, { force: true });
+  }
 }
 function removeConfig() {
   const configPath = getConfigPath();
@@ -20329,6 +20839,7 @@ async function startDaemon(args) {
   }
   const activeAgents = /* @__PURE__ */ new Map();
   let disconnectedSinceMs = null;
+  let lastConnectError = null;
   const pendingDeliveryLost = [];
   const currentCapabilities = () => discoverCapabilities();
   const currentMetadata = () => collectRuntimeMetadataWithProviderLimits();
@@ -20397,6 +20908,7 @@ async function startDaemon(args) {
   }, VERSION_REFRESH_INTERVAL_MS);
   socket.on("connect", () => {
     disconnectedSinceMs = null;
+    lastConnectError = null;
     setConnectedRuntimeSocket(socket);
     pushLog(`connected runtime=${runtimeId}`);
     console.info("[aiden-agent] Daemon connected", { runtimeId, wsUrl, version: AGENT_VERSION });
@@ -20434,6 +20946,7 @@ async function startDaemon(args) {
   let lastConnectErrorLogAt = 0;
   socket.on("connect_error", (error) => {
     if (!socket.connected && disconnectedSinceMs === null) disconnectedSinceMs = Date.now();
+    lastConnectError = error.message;
     pushLog(`connect_error ${error.message}`);
     const now = Date.now();
     if (now - lastConnectErrorLogAt < 5e3) return;
@@ -20801,6 +21314,7 @@ async function startDaemon(args) {
           staleRunCount: runnerSummary.staleRunCount,
           lastRunActivityAtMs: runnerSummary.lastRunActivityAtMs,
           disconnectedSinceMs: runnerSummary.disconnectedSinceMs,
+          lastConnectError,
           daemonSessionId,
           heartbeatSeq,
           endpointProfile,