fourmis-agents-sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -12,76 +27,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/tools/mcp-resources.ts
-var exports_mcp_resources = {};
-__export(exports_mcp_resources, {
-  createReadMcpResourceTool: () => createReadMcpResourceTool,
-  createListMcpResourcesTool: () => createListMcpResourcesTool
-});
-function createListMcpResourcesTool(mcpClient) {
-  return {
-    name: "mcp__list_resources",
-    description: "List available resources from MCP servers.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        server: {
-          type: "string",
-          description: "Optional server name to filter by. If omitted, lists resources from all servers."
-        }
-      }
-    },
-    async execute(input) {
-      const { server } = input ?? {};
-      try {
-        const resources = await mcpClient.listResources(server);
-        if (resources.length === 0) {
-          return { content: "No resources available." };
-        }
-        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
-        return { content: lines.join(`
-`) };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: `Error listing resources: ${message}`, isError: true };
-      }
-    }
-  };
-}
-function createReadMcpResourceTool(mcpClient) {
-  return {
-    name: "mcp__read_resource",
-    description: "Read a specific resource from an MCP server by URI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        server: {
-          type: "string",
-          description: "The MCP server name that hosts the resource."
-        },
-        uri: {
-          type: "string",
-          description: "The resource URI to read."
-        }
-      },
-      required: ["server", "uri"]
-    },
-    async execute(input) {
-      const { server, uri } = input;
-      if (!server || !uri) {
-        return { content: "Both 'server' and 'uri' are required.", isError: true };
-      }
-      try {
-        const content = await mcpClient.readResource(server, uri);
-        return { content };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: `Error reading resource: ${message}`, isError: true };
-      }
-    }
-  };
-}
-
 // src/auth/openai-oauth.ts
 var exports_openai_oauth = {};
 __export(exports_openai_oauth, {
@@ -95,25 +40,25 @@ __export(exports_openai_oauth, {
   decodeJwtPayload: () => decodeJwtPayload
 });
 import { randomBytes, createHash } from "crypto";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 function getHome() {
-  return process.env.HOME ?? homedir();
+  return process.env.HOME ?? homedir2();
 }
 function tokenDir() {
-  return join(getHome(), ".fourmis");
+  return join2(getHome(), ".fourmis");
 }
 function tokenPath() {
-  return join(tokenDir(), "openai-auth.json");
+  return join2(tokenDir(), "openai-auth.json");
 }
 function codexFallbackPath() {
-  return join(getHome(), ".codex", "auth.json");
+  return join2(getHome(), ".codex", "auth.json");
 }
 function loadTokens() {
   for (const p of [tokenPath(), codexFallbackPath()]) {
     try {
-      const raw = readFileSync(p, "utf-8");
+      const raw = readFileSync2(p, "utf-8");
       const data = JSON.parse(raw);
       if (data.access_token && data.account_id) {
         return data;
@@ -124,10 +69,10 @@ function loadTokens() {
 }
 function saveTokens(tokens) {
   const dir = tokenDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync(tokenPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync2(tokenPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function generateCodeVerifier() {
   return randomBytes(64).toString("base64url");
@@ -377,19 +322,19 @@ __export(exports_gemini_oauth, {
   isLoggedIn: () => isLoggedIn2,
   getValidToken: () => getValidToken2
 });
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 function getHome2() {
-  return process.env.HOME ?? homedir2();
+  return process.env.HOME ?? homedir3();
 }
 function tokenPath2() {
-  return join2(getHome2(), ".gemini", "oauth_creds.json");
+  return join3(getHome2(), ".gemini", "oauth_creds.json");
 }
 function loadTokens2() {
   const p = tokenPath2();
   try {
-    const raw = readFileSync2(p, "utf-8");
+    const raw = readFileSync3(p, "utf-8");
     const data = JSON.parse(raw);
     if (data.access_token && data.refresh_token) {
       return data;
@@ -402,12 +347,12 @@ function loadTokensSync2() {
 }
 function saveTokens2(tokens) {
   const p = tokenPath2();
-  const dir = join2(getHome2(), ".gemini");
-  if (!existsSync2(dir)) {
-    const { mkdirSync: mkdirSync2 } = __require("fs");
-    mkdirSync2(dir, { recursive: true });
+  const dir = join3(getHome2(), ".gemini");
+  if (!existsSync3(dir)) {
+    const { mkdirSync: mkdirSync3 } = __require("fs");
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync2(p, JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync3(p, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshAccessToken2(refreshToken) {
   const res = await fetch(GOOGLE_TOKEN_URL, {
@@ -461,330 +406,366 @@ var init_gemini_oauth = __esm(() => {
   GEMINI_CLIENT_SECRET = process.env.GEMINI_OAUTH_CLIENT_SECRET ?? ["GOCSPX", "4uHgMPm", "1o7Sk", "geV6Cu5clXFsxl"].join("-");
 });
 
-// src/types.ts
-function uuid() {
-  return crypto.randomUUID();
-}
-function emptyTokenUsage() {
+// src/tools/mcp-resources.ts
+var exports_mcp_resources = {};
+__export(exports_mcp_resources, {
+  createReadMcpResourceTool: () => createReadMcpResourceTool,
+  createListMcpResourcesTool: () => createListMcpResourcesTool
+});
+function createListMcpResourcesTool(mcpClient) {
   return {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadInputTokens: 0,
-    cacheCreationInputTokens: 0
+    name: "mcp__list_resources",
+    description: "List available resources from MCP servers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Optional server name to filter by. If omitted, lists resources from all servers."
+        }
+      }
+    },
+    async execute(input) {
+      const { server } = input ?? {};
+      try {
+        const resources = await mcpClient.listResources(server);
+        if (resources.length === 0) {
+          return { content: "No resources available." };
+        }
+        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
+        return { content: lines.join(`
+`) };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error listing resources: ${message}`, isError: true };
+      }
+    }
   };
 }
-function mergeUsage(a, b) {
+function createReadMcpResourceTool(mcpClient) {
   return {
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
-    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
+    name: "mcp__read_resource",
+    description: "Read a specific resource from an MCP server by URI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The MCP server name that hosts the resource."
+        },
+        uri: {
+          type: "string",
+          description: "The resource URI to read."
+        }
+      },
+      required: ["server", "uri"]
+    },
+    async execute(input) {
+      const { server, uri } = input;
+      if (!server || !uri) {
+        return { content: "Both 'server' and 'uri' are required.", isError: true };
+      }
+      try {
+        const content = await mcpClient.readResource(server, uri);
+        return { content };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error reading resource: ${message}`, isError: true };
+      }
+    }
   };
 }
 
-// src/agent-loop.ts
-async function* agentLoop(prompt, options) {
-  const {
-    provider,
-    model,
-    systemPrompt,
-    tools,
-    permissions,
-    cwd,
-    sessionId,
-    maxTurns,
-    maxBudgetUsd,
-    includeStreamEvents,
-    signal,
-    env,
-    debug,
-    hooks,
-    mcpClient,
-    previousMessages,
-    sessionLogger,
-    nativeMemoryTool
-  } = options;
-  const startTime = Date.now();
-  let apiTimeMs = 0;
-  let turns = 0;
-  let totalUsage = emptyTokenUsage();
-  let costUsd = 0;
-  const modelUsage = {};
-  if (mcpClient) {
-    await mcpClient.connectAll();
-    for (const tool of mcpClient.getTools()) {
-      tools.register(tool);
-    }
-    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
-    tools.register(createListMcpResourcesTool2(mcpClient));
-    tools.register(createReadMcpResourceTool2(mcpClient));
-  }
-  const messages = [
-    ...previousMessages ?? [],
-    { role: "user", content: prompt }
-  ];
-  if (sessionLogger) {
-    sessionLogger("user", prompt, null);
+// src/permissions.ts
+var SAFE_TOOLS = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch"]);
+var EDIT_TOOLS = new Set(["Write", "Edit", "NotebookEdit", "TodoWrite", "Config"]);
+var FS_COMMANDS = ["mkdir", "touch", "rm", "mv", "cp"];
+var DELEGATE_TOOLS = new Set(["Teammate", "Task", "TaskOutput", "TaskStop"]);
+function normalizeRules(rules) {
+  if (!rules)
+    return [];
+  return rules.map((r) => typeof r === "string" ? { toolName: r } : r);
+}
+function matchesRule(rules, toolName, input) {
+  for (const rule of rules) {
+    if (rule.toolName !== toolName)
+      continue;
+    if (!rule.ruleContent)
+      return true;
+    const inputStr = toolName === "Bash" ? String(input?.command ?? "") : JSON.stringify(input ?? {});
+    if (inputStr.includes(rule.ruleContent))
+      return true;
   }
-  yield {
-    type: "init",
-    sessionId,
-    model,
-    provider: provider.name,
-    tools: tools.list(),
-    cwd,
-    uuid: uuid()
-  };
-  if (hooks) {
-    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+  return false;
+}
+
+class PermissionManager {
+  mode;
+  canUseTool;
+  allowRules;
+  denyRules;
+  settingsManager;
+  constructor(mode = "default", canUseTool, permissions, settingsManager) {
+    this.mode = mode;
+    this.canUseTool = canUseTool;
+    this.allowRules = normalizeRules(permissions?.allow);
+    this.denyRules = normalizeRules(permissions?.deny);
+    this.settingsManager = settingsManager;
   }
-  while (true) {
-    if (signal.aborted) {
-      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
-      return;
+  async check(toolName, input, options) {
+    if (this.mode === "bypassPermissions") {
+      return { behavior: "allow" };
     }
-    if (turns >= maxTurns) {
-      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
-      return;
+    if (matchesRule(this.denyRules, toolName, input)) {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" is denied by permissions config.`
+      };
     }
-    if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
-      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
-      return;
-    }
-    const toolDefs = tools.getDefinitions();
-    const apiStart = Date.now();
-    let assistantTextParts = [];
-    let toolCalls = [];
-    let turnUsage = emptyTokenUsage();
-    const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
-    try {
-      const chunks = provider.chat({
-        model,
-        messages,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
-        systemPrompt,
-        signal,
-        nativeTools
-      });
-      for await (const chunk of chunks) {
-        switch (chunk.type) {
-          case "text_delta":
-            assistantTextParts.push(chunk.text);
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "text_delta", text: chunk.text, uuid: uuid() };
-            }
-            break;
-          case "thinking_delta":
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
-            }
-            break;
-          case "tool_call":
-            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
-            break;
-          case "usage":
-            turnUsage = mergeUsage(turnUsage, chunk.usage);
-            break;
-          case "done":
-            break;
-        }
+    if (this.mode === "plan") {
+      if (!SAFE_TOOLS.has(toolName)) {
+        return {
+          behavior: "deny",
+          message: `Tool "${toolName}" is not allowed in plan mode. Only read-only tools are available.`
+        };
       }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
-      return;
-    }
-    apiTimeMs += Date.now() - apiStart;
-    turns++;
-    totalUsage = mergeUsage(totalUsage, turnUsage);
-    const turnCost = provider.calculateCost(model, turnUsage);
-    costUsd += turnCost;
-    if (!modelUsage[model]) {
-      modelUsage[model] = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0,
-        totalCostUsd: 0
-      };
-    }
-    modelUsage[model].inputTokens += turnUsage.inputTokens;
-    modelUsage[model].outputTokens += turnUsage.outputTokens;
-    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
-    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
-    modelUsage[model].totalCostUsd += turnCost;
-    const assistantText = assistantTextParts.join("");
-    const assistantContent = [];
-    if (assistantText) {
-      assistantContent.push({ type: "text", text: assistantText });
+      return { behavior: "allow" };
     }
-    for (const call of toolCalls) {
-      assistantContent.push({
-        type: "tool_use",
-        id: call.id,
-        name: call.name,
-        input: call.input
-      });
+    if (this.mode === "delegate") {
+      if (!DELEGATE_TOOLS.has(toolName) && !SAFE_TOOLS.has(toolName)) {
+        return {
+          behavior: "deny",
+          message: `Tool "${toolName}" is not allowed in delegate mode. Only Teammate, Task, and read-only tools are available.`
+        };
+      }
+      return { behavior: "allow" };
     }
-    messages.push({ role: "assistant", content: assistantContent });
-    if (sessionLogger) {
-      sessionLogger("assistant", assistantContent, null);
+    if (matchesRule(this.allowRules, toolName, input)) {
+      return { behavior: "allow" };
     }
-    if (assistantText) {
-      yield { type: "text", text: assistantText, uuid: uuid() };
+    if (SAFE_TOOLS.has(toolName)) {
+      return { behavior: "allow" };
     }
-    if (toolCalls.length === 0) {
-      if (hooks) {
-        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+    if (this.mode === "acceptEdits") {
+      if (EDIT_TOOLS.has(toolName)) {
+        return { behavior: "allow" };
       }
-      if (hooks) {
-        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+      if (toolName === "Bash") {
+        const cmd = String(input?.command ?? "").trimStart();
+        if (FS_COMMANDS.some((fc) => cmd.startsWith(fc + " ") || cmd === fc)) {
+          return { behavior: "allow" };
+        }
       }
-      yield {
-        type: "result",
-        subtype: "success",
-        text: assistantText || null,
-        turns,
-        costUsd,
-        durationMs: Date.now() - startTime,
-        durationApiMs: apiTimeMs,
-        sessionId,
-        usage: totalUsage,
-        modelUsage,
-        uuid: uuid()
+    }
+    if (this.canUseTool) {
+      const result = await this.canUseTool(toolName, input, {
+        ...options,
+        toolUseID: options.toolUseId,
+        agentID: options.agentId
+      });
+      if (result.behavior === "allow" && result.updatedPermissions) {
+        this.applyPermissionUpdates(result.updatedPermissions);
+      }
+      return result;
+    }
+    if (this.mode === "dontAsk") {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" requires approval. In dontAsk mode, tools must be pre-approved via permissions config.`
       };
-      return;
     }
-    const toolResults = [];
-    for (const call of toolCalls) {
-      let hookDenied = false;
-      let hookUpdatedInput;
-      if (hooks) {
-        const hookResult = await hooks.fire("PreToolUse", { event: "PreToolUse", tool_name: call.name, tool_input: call.input, session_id: sessionId }, call.id, { signal });
-        if (hookResult) {
-          if (hookResult.permissionDecision === "deny") {
-            hookDenied = true;
+    return { behavior: "allow" };
+  }
+  applyPermissionUpdates(updates) {
+    for (const update of updates) {
+      if (this.settingsManager && update.destination !== "session" && update.destination !== "cliArg") {
+        this.settingsManager.persistUpdate(update);
+      }
+      switch (update.type) {
+        case "addRules":
+          for (const rule of update.rules) {
+            if (update.behavior === "allow") {
+              this.allowRules.push(rule);
+            } else if (update.behavior === "deny") {
+              this.denyRules.push(rule);
+            }
           }
-          if (hookResult.updatedInput !== undefined) {
-            hookUpdatedInput = hookResult.updatedInput;
+          break;
+        case "removeRules":
+          for (const rule of update.rules) {
+            if (update.behavior === "allow") {
+              this.allowRules = this.allowRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
+            } else if (update.behavior === "deny") {
+              this.denyRules = this.denyRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
+            }
           }
-        }
+          break;
+        case "replaceRules":
+          if (update.behavior === "allow") {
+            this.allowRules = [...update.rules];
+          } else if (update.behavior === "deny") {
+            this.denyRules = [...update.rules];
+          }
+          break;
+        case "setMode":
+          this.mode = update.mode;
+          break;
       }
-      if (hookDenied) {
-        const denyContent = "Denied by hook";
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: call.id,
-          content: denyContent,
-          is_error: true
-        });
-        if (hooks) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
-        }
+    }
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
+  getMode() {
+    return this.mode;
+  }
+}
+
+// src/settings.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+class SettingsManager {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  loadPermissions(sources) {
+    const allAllow = [];
+    const allDeny = [];
+    for (const source of sources) {
+      const path = this.sourceToPath(source);
+      const data = this.readJson(path);
+      if (!data?.permissions)
         continue;
-      }
-      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
-      const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
-      if (permResult.behavior === "deny") {
-        const denyContent = `Permission denied: ${permResult.message}`;
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: call.id,
-          content: denyContent,
-          is_error: true
-        });
-        if (hooks) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+      const perms = data.permissions;
+      if (Array.isArray(perms.allow)) {
+        for (const rule of perms.allow) {
+          if (typeof rule === "string") {
+            allAllow.push(this.parseRule(rule));
+          }
         }
-        continue;
       }
-      const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
-      yield {
-        type: "tool_use",
-        id: call.id,
-        name: call.name,
-        input: toolInput,
-        uuid: uuid()
-      };
-      let result;
-      if (call.name === "memory" && nativeMemoryTool) {
-        try {
-          const content = await nativeMemoryTool.execute(toolInput);
-          result = { content, isError: content.startsWith("Error:") };
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          result = { content: `Error: ${message}`, isError: true };
+      if (Array.isArray(perms.deny)) {
+        for (const rule of perms.deny) {
+          if (typeof rule === "string") {
+            allDeny.push(this.parseRule(rule));
+          }
         }
-      } else {
-        const toolCtx = {
-          cwd,
-          signal,
-          sessionId,
-          env
-        };
-        result = await tools.execute(call.name, toolInput, toolCtx);
       }
-      if (debug) {
-        console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
+    }
+    const result = {};
+    if (allAllow.length > 0)
+      result.allow = allAllow;
+    if (allDeny.length > 0)
+      result.deny = allDeny;
+    return result;
+  }
+  persistUpdate(update) {
+    const path = this.destinationToPath(update.destination);
+    if (!path)
+      return;
+    const data = this.readJson(path) ?? {};
+    if (!data.permissions)
+      data.permissions = {};
+    const perms = data.permissions;
+    switch (update.type) {
+      case "addRules": {
+        const key = update.behavior;
+        const existing = Array.isArray(perms[key]) ? perms[key] : [];
+        const newRules = update.rules.map((r) => this.serializeRule(r));
+        const set = new Set(existing);
+        for (const rule of newRules)
+          set.add(rule);
+        perms[key] = [...set];
+        break;
       }
-      if (hooks) {
-        if (result.isError) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: result.content, tool_error: true, session_id: sessionId }, call.id, { signal });
-        } else {
-          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
-          if (postResult?.additionalContext) {
-            result.content += `
-${postResult.additionalContext}`;
-          }
-        }
+      case "removeRules": {
+        const key = update.behavior;
+        if (!Array.isArray(perms[key]))
+          break;
+        const toRemove = new Set(update.rules.map((r) => this.serializeRule(r)));
+        perms[key] = perms[key].filter((r) => !toRemove.has(r));
+        break;
       }
-      yield {
-        type: "tool_result",
-        id: call.id,
-        name: call.name,
-        content: result.content,
-        isError: result.isError,
-        uuid: uuid()
-      };
-      toolResults.push({
-        type: "tool_result",
-        tool_use_id: call.id,
-        content: result.content,
-        is_error: result.isError
-      });
+      case "replaceRules": {
+        const key = update.behavior;
+        perms[key] = update.rules.map((r) => this.serializeRule(r));
+        break;
+      }
+      case "setMode": {
+        perms.defaultMode = update.mode;
+        break;
+      }
+      default:
+        return;
     }
-    messages.push({ role: "user", content: toolResults });
-    if (sessionLogger) {
-      sessionLogger("user", toolResults, null);
+    const dir = dirname(path);
+    if (!existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + `
+`);
+  }
+  sourceToPath(source) {
+    switch (source) {
+      case "user":
+        return join(homedir(), ".claude", "settings.json");
+      case "project":
+        return join(this.cwd, ".claude", "settings.json");
+      case "local":
+        return join(this.cwd, ".claude", "settings.local.json");
+    }
+  }
+  destinationToPath(destination) {
+    switch (destination) {
+      case "userSettings":
+        return join(homedir(), ".claude", "settings.json");
+      case "projectSettings":
+        return join(this.cwd, ".claude", "settings.json");
+      case "localSettings":
+        return join(this.cwd, ".claude", "settings.local.json");
+      default:
+        return null;
+    }
+  }
+  readJson(path) {
+    try {
+      const content = readFileSync(path, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
     }
   }
+  parseRule(s) {
+    const match = s.match(/^([^(]+)\((.+)\)$/);
+    if (match)
+      return { toolName: match[1], ruleContent: match[2] };
+    return { toolName: s };
+  }
+  serializeRule(rule) {
+    return rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : rule.toolName;
+  }
+}
+
+// src/types.ts
+function uuid() {
+  return crypto.randomUUID();
 }
-function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
+function emptyTokenUsage() {
   return {
-    type: "result",
-    subtype,
-    errors,
-    turns,
-    costUsd,
-    durationMs: Date.now() - startTime,
-    sessionId,
-    uuid: uuid()
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function mergeUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
+    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
   };
 }
 
@@ -1043,6 +1024,44 @@ class AnthropicAdapter {
       max_tokens: maxTokens,
       stream: true
     };
+    if (request.thinking) {
+      switch (request.thinking.type) {
+        case "adaptive":
+          params.thinking = { type: "adaptive" };
+          break;
+        case "disabled":
+          params.thinking = { type: "disabled" };
+          break;
+        case "enabled":
+          params.thinking = {
+            type: "enabled",
+            budget_tokens: request.thinking.budgetTokens
+          };
+          break;
+      }
+    } else if (request.thinkingBudget !== undefined) {
+      if (request.thinkingBudget <= 0) {
+        params.thinking = { type: "disabled" };
+      } else {
+        params.thinking = {
+          type: "enabled",
+          budget_tokens: Math.max(1024, request.thinkingBudget)
+        };
+      }
+    }
+    const outputConfig = {};
+    if (request.effort) {
+      outputConfig.effort = request.effort;
+    }
+    if (request.outputFormat?.type === "json_schema") {
+      outputConfig.format = {
+        type: "json_schema",
+        schema: request.outputFormat.schema
+      };
+    }
+    if (Object.keys(outputConfig).length > 0) {
+      params.output_config = outputConfig;
+    }
     if (this.oauthMode) {
       const systemBlocks = [
         { type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }
@@ -1167,11 +1186,12 @@ class AnthropicAdapter {
     switch (feature) {
       case "streaming":
       case "tool_calling":
-      case "image_input":
-      case "pdf_input":
       case "thinking":
       case "structured_output":
         return true;
+      case "image_input":
+      case "pdf_input":
+        return false;
       default:
         return false;
     }
@@ -2086,6 +2106,16 @@ class ToolRegistry {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  clearByPrefix(prefix) {
+    for (const name of this.tools.keys()) {
+      if (name.startsWith(prefix)) {
+        this.tools.delete(name);
+      }
+    }
+  }
   get(name) {
     return this.tools.get(name);
   }
@@ -2119,16 +2149,34 @@ class ToolRegistry {
 // src/tools/presets.ts
 var PRESETS = {
   coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  claude_code: [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "NotebookEdit",
+    "WebFetch",
+    "WebSearch",
+    "TodoWrite",
+    "Config",
+    "AskUserQuestion",
+    "ExitPlanMode"
+  ],
   readonly: ["Read", "Glob", "Grep"],
   minimal: ["Read", "Write", "Edit", "Glob", "Grep"]
 };
 function resolveToolNames(tools) {
   if (!tools)
-    return PRESETS.coding;
-  if (typeof tools === "string") {
-    return PRESETS[tools] ?? [tools];
+    return PRESETS.claude_code;
+  if (Array.isArray(tools)) {
+    return tools;
+  }
+  if (tools.type === "preset") {
+    return PRESETS[tools.preset] ?? PRESETS.claude_code;
   }
-  return tools;
+  throw new Error("Invalid tools option. Expected string[] or { type: 'preset', preset: 'claude_code' }.");
 }
 
 // src/tools/bash.ts
@@ -2152,17 +2200,58 @@ var BashTool = {
       timeout: {
         type: "number",
         description: "Timeout in milliseconds (max 600000)"
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "Run command asynchronously and return immediately."
+      },
+      dangerouslyDisableSandbox: {
+        type: "boolean",
+        description: "If true, explicitly request unsandboxed execution."
+      },
+      _simulatedSedEdit: {
+        type: "object",
+        properties: {
+          filePath: { type: "string" },
+          newContent: { type: "string" }
+        },
+        description: "Internal field for precomputed edit previews."
       }
     },
     required: ["command"]
   },
   async execute(input, ctx) {
-    const { command, timeout: timeoutMs, description } = input;
+    const {
+      command,
+      timeout: timeoutMs,
+      run_in_background,
+      description,
+      dangerouslyDisableSandbox,
+      _simulatedSedEdit
+    } = input;
     if (!command || typeof command !== "string") {
       return { content: "Error: command is required", isError: true };
     }
     const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     try {
+      if (run_in_background) {
+        const proc2 = Bun.spawn(["bash", "-c", command], {
+          cwd: ctx.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+          stdin: "ignore",
+          env: { ...process.env, ...ctx.env }
+        });
+        return {
+          content: `Background command started (pid ${proc2.pid ?? "unknown"}).`,
+          metadata: {
+            pid: proc2.pid ?? null,
+            run_in_background: true,
+            dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+            hasSimulatedSedEdit: !!_simulatedSedEdit
+          }
+        };
+      }
       const proc = Bun.spawn(["bash", "-c", command], {
         cwd: ctx.cwd,
         stdout: "pipe",
@@ -2194,7 +2283,11 @@ var BashTool = {
       return {
         content: output,
         isError: exitCode !== 0 ? true : undefined,
-        metadata: { exitCode }
+        metadata: {
+          exitCode,
+          dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+          hasSimulatedSedEdit: !!_simulatedSedEdit
+        }
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2223,12 +2316,17 @@ var ReadTool = {
       limit: {
         type: "number",
         description: "Number of lines to read"
+      },
+      pages: {
+        type: "array",
+        items: { type: "number" },
+        description: "Optional PDF page numbers (1-based)."
       }
     },
     required: ["file_path"]
   },
   async execute(input, ctx) {
-    const { file_path, offset, limit } = input;
+    const { file_path, offset, limit, pages } = input;
     if (!file_path) {
       return { content: "Error: file_path is required", isError: true };
     }
@@ -2239,6 +2337,12 @@ var ReadTool = {
       if (!exists) {
         return { content: `Error: File not found: ${resolvedPath}`, isError: true };
       }
+      if (Array.isArray(pages) && pages.length > 0 && resolvedPath.toLowerCase().endsWith(".pdf")) {
+        return {
+          content: "Error: PDF page extraction is not implemented in this runtime.",
+          isError: true
+        };
+      }
       const text = await file.text();
       const lines = text.split(`
 `);
@@ -2270,7 +2374,7 @@ function resolvePath(filePath, cwd) {
 
 // src/tools/write.ts
 import { mkdir } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var WriteTool = {
   name: "Write",
   description: "Writes content to a file. Creates parent directories if needed. " + "Overwrites existing files.",
@@ -2298,7 +2402,7 @@ var WriteTool = {
     }
     const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
     try {
-      const dir = dirname(resolvedPath);
+      const dir = dirname2(resolvedPath);
       await mkdir(dir, { recursive: true });
       await Bun.write(resolvedPath, content);
       const lines = content.split(`
@@ -2626,6 +2730,405 @@ async function collectFiles(dir, globPattern) {
   }
   return files;
 }
+
+// src/tools/notebook-edit.ts
+import { readFile, writeFile } from "fs/promises";
+function toSourceLines(text) {
+  const lines = text.split(`
+`);
+  return lines.map((line, idx) => idx < lines.length - 1 ? `${line}
+` : line);
+}
+var NotebookEditTool = {
+  name: "NotebookEdit",
+  description: "Edit a specific Jupyter notebook cell by id or index.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      notebook_path: { type: "string", description: "Path to .ipynb file." },
+      cell_id: { type: "string", description: "Cell id to edit." },
+      cell_index: { type: "number", description: "Cell index to edit if id is not provided." },
+      new_source: { type: "string", description: "New cell source content." }
+    },
+    required: ["notebook_path", "new_source"]
+  },
+  async execute(input, ctx) {
+    const {
+      notebook_path,
+      cell_id,
+      cell_index,
+      new_source
+    } = input ?? {};
+    if (!notebook_path)
+      return { content: "Error: notebook_path is required", isError: true };
+    if (new_source === undefined)
+      return { content: "Error: new_source is required", isError: true };
+    const filePath = notebook_path.startsWith("/") ? notebook_path : `${ctx.cwd}/${notebook_path}`;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const notebook = JSON.parse(raw);
+      if (!Array.isArray(notebook.cells)) {
+        return { content: "Error: notebook has no cells array", isError: true };
+      }
+      let targetIndex = -1;
+      if (cell_id) {
+        targetIndex = notebook.cells.findIndex((c) => c.id === cell_id);
+      } else if (typeof cell_index === "number") {
+        targetIndex = cell_index;
+      } else {
+        targetIndex = 0;
+      }
+      if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+        return {
+          content: `Error: cell not found (id=${cell_id ?? "n/a"}, index=${String(cell_index ?? "n/a")})`,
+          isError: true
+        };
+      }
+      const cell = notebook.cells[targetIndex];
+      cell.source = toSourceLines(new_source);
+      await writeFile(filePath, JSON.stringify(notebook, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Updated notebook cell ${targetIndex} in ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing notebook: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/web-fetch.ts
+var DEFAULT_TIMEOUT_MS = 20000;
+var MAX_OUTPUT = 80000;
+var WebFetchTool = {
+  name: "WebFetch",
+  description: "Fetches a URL and returns response text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch."
+      },
+      prompt: {
+        type: "string",
+        description: "Optional fetch intent/instructions."
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Timeout in milliseconds (default 20000)."
+      },
+      max_length: {
+        type: "number",
+        description: "Maximum output length (default 80000)."
+      }
+    },
+    required: ["url"]
+  },
+  async execute(input) {
+    const { url, timeout_ms, max_length } = input ?? {};
+    if (!url)
+      return { content: "Error: url is required", isError: true };
+    const timeout = Math.max(1000, timeout_ms ?? DEFAULT_TIMEOUT_MS);
+    const outLimit = Math.max(1000, max_length ?? MAX_OUTPUT);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      const contentType = res.headers.get("content-type") ?? "unknown";
+      let body = await res.text();
+      if (body.length > outLimit) {
+        body = body.slice(0, outLimit) + `
+... (truncated)`;
+      }
+      return {
+        content: [
+          `Status: ${res.status} ${res.statusText}`,
+          `Content-Type: ${contentType}`,
+          "",
+          body
+        ].join(`
+`),
+        isError: res.ok ? undefined : true
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error fetching URL: ${message}`, isError: true };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/tools/web-search.ts
+var SEARCH_ENDPOINT = "https://duckduckgo.com/html/";
+function stripTags(input) {
+  return input.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").trim();
+}
+var WebSearchTool = {
+  name: "WebSearch",
+  description: "Searches the web and returns top result links.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query."
+      },
+      max_results: {
+        type: "number",
+        description: "Maximum results to return (default 5)."
+      }
+    },
+    required: ["query"]
+  },
+  async execute(input) {
+    const { query, max_results } = input ?? {};
+    if (!query) {
+      return { content: "Error: query is required", isError: true };
+    }
+    const limit = Math.max(1, Math.min(20, max_results ?? 5));
+    try {
+      const url = `${SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}`;
+      const res = await fetch(url, {
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      if (!res.ok) {
+        return {
+          content: `Error searching web: ${res.status} ${res.statusText}`,
+          isError: true
+        };
+      }
+      const html = await res.text();
+      const matches = [...html.matchAll(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)];
+      if (matches.length === 0) {
+        return { content: "No search results found." };
+      }
+      const lines = [];
+      for (let i = 0;i < Math.min(limit, matches.length); i++) {
+        const href = stripTags(matches[i][1]);
+        const title = stripTags(matches[i][2]);
+        lines.push(`${i + 1}. ${title}
+   ${href}`);
+      }
+      return { content: lines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error searching web: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/ask-user-question.ts
+var AskUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: "Ask the user a clarifying question and wait for their response.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "Question to ask the user."
+      },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional fixed choices."
+      }
+    },
+    required: ["question"]
+  },
+  async execute(input) {
+    const { question, options } = input ?? {};
+    if (!question) {
+      return { content: "Error: question is required", isError: true };
+    }
+    const choices = Array.isArray(options) && options.length > 0 ? ` Choices: ${options.join(" | ")}` : "";
+    return {
+      content: `User interaction is not available in this runtime. Unanswered question: ${question}.${choices}`,
+      isError: true
+    };
+  }
+};
+
+// src/tools/todo-write.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+var TodoWriteTool = {
+  name: "TodoWrite",
+  description: "Write/update task todo items for the current session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+            activeForm: { type: "string" }
+          },
+          required: ["content", "status"]
+        }
+      }
+    },
+    required: ["todos"]
+  },
+  async execute(input, ctx) {
+    const { todos } = input ?? {};
+    if (!Array.isArray(todos)) {
+      return { content: "Error: todos must be an array", isError: true };
+    }
+    for (const todo of todos) {
+      if (!todo?.content || !todo?.status) {
+        return { content: "Error: each todo requires content and status", isError: true };
+      }
+    }
+    const filePath = join4(ctx.cwd, ".claude", "todos.json");
+    try {
+      await mkdir2(dirname3(filePath), { recursive: true });
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        todos
+      };
+      await writeFile2(filePath, JSON.stringify(payload, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Saved ${todos.length} todo item(s) to ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing todos: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/config.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join5, dirname as dirname4 } from "path";
+function scopePath(cwd, scope) {
+  if (scope === "project")
+    return join5(cwd, ".claude", "settings.json");
+  return join5(cwd, ".claude", "settings.local.json");
+}
+function setByPath(obj, keyPath, value) {
+  const keys = keyPath.split(".").filter(Boolean);
+  if (keys.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function getByPath(obj, keyPath) {
+  const keys = keyPath.split(".").filter(Boolean);
+  let current = obj;
+  for (const key of keys) {
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return;
+    current = current[key];
+  }
+  return current;
+}
+var ConfigTool = {
+  name: "Config",
+  description: "Read or update .claude settings values.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["get", "set", "list"]
+      },
+      key: {
+        type: "string",
+        description: "Dot-path key (for get/set)."
+      },
+      value: {
+        description: "Value for set action."
+      },
+      scope: {
+        type: "string",
+        enum: ["local", "project"]
+      }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const {
+      action,
+      key,
+      value,
+      scope = "local"
+    } = input ?? {};
+    if (!action) {
+      return { content: "Error: action is required", isError: true };
+    }
+    const filePath = scopePath(ctx.cwd, scope);
+    let data = {};
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      data = JSON.parse(raw);
+    } catch {
+      data = {};
+    }
+    if (action === "list") {
+      return { content: JSON.stringify(data, null, 2) };
+    }
+    if (!key) {
+      return { content: "Error: key is required for get/set", isError: true };
+    }
+    if (action === "get") {
+      const out = getByPath(data, key);
+      return { content: out === undefined ? "undefined" : JSON.stringify(out, null, 2) };
+    }
+    setByPath(data, key, value);
+    try {
+      await mkdir3(dirname4(filePath), { recursive: true });
+      await writeFile3(filePath, JSON.stringify(data, null, 2) + `
+`, "utf-8");
+      return { content: `Updated ${key} in ${filePath}` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing config: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/exit-plan-mode.ts
+var ExitPlanModeTool = {
+  name: "ExitPlanMode",
+  description: "Exit plan mode and resume normal execution permissions.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  async execute() {
+    return {
+      content: "Exiting plan mode.",
+      metadata: {
+        setPermissionMode: "default"
+      }
+    };
+  }
+};
 // src/tools/index.ts
 var ALL_TOOLS = {
   Bash: BashTool,
@@ -2633,7 +3136,14 @@ var ALL_TOOLS = {
   Write: WriteTool,
   Edit: EditTool,
   Glob: GlobTool,
-  Grep: GrepTool
+  Grep: GrepTool,
+  NotebookEdit: NotebookEditTool,
+  WebFetch: WebFetchTool,
+  WebSearch: WebSearchTool,
+  AskUserQuestion: AskUserQuestionTool,
+  TodoWrite: TodoWriteTool,
+  Config: ConfigTool,
+  ExitPlanMode: ExitPlanModeTool
 };
 function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   const registry = new ToolRegistry;
@@ -2648,277 +3158,299 @@ function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   return registry;
 }
 
-// src/permissions.ts
-var SAFE_TOOLS = new Set(["Read", "Glob", "Grep"]);
-var EDIT_TOOLS = new Set(["Write", "Edit"]);
-var FS_COMMANDS = ["mkdir", "touch", "rm", "mv", "cp"];
-var DELEGATE_TOOLS = new Set(["Teammate", "Task", "TaskOutput", "TaskStop"]);
-function normalizeRules(rules) {
-  if (!rules)
-    return [];
-  return rules.map((r) => typeof r === "string" ? { toolName: r } : r);
+// src/skills/frontmatter.ts
+import { parse } from "yaml";
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
 }
-function matchesRule(rules, toolName, input) {
-  for (const rule of rules) {
-    if (rule.toolName !== toolName)
-      continue;
-    if (!rule.ruleContent)
-      return true;
-    const inputStr = toolName === "Bash" ? String(input?.command ?? "") : JSON.stringify(input ?? {});
-    if (inputStr.includes(rule.ruleContent))
-      return true;
+function extractFrontmatter(content) {
+  const normalized = normalizeNewlines(content);
+  if (!normalized.startsWith("---")) {
+    return { yamlString: null, body: normalized };
   }
-  return false;
+  const endIndex = normalized.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { yamlString: null, body: normalized };
+  }
+  return {
+    yamlString: normalized.slice(4, endIndex),
+    body: normalized.slice(endIndex + 4).trim()
+  };
+}
+function parseFrontmatter(content) {
+  const { yamlString, body } = extractFrontmatter(content);
+  if (!yamlString) {
+    return { frontmatter: {}, body };
+  }
+  const parsed = parse(yamlString);
+  return { frontmatter: parsed ?? {}, body };
+}
+function stripFrontmatter(content) {
+  return parseFrontmatter(content).body;
 }
 
-class PermissionManager {
-  mode;
-  canUseTool;
-  allowRules;
-  denyRules;
-  settingsManager;
-  constructor(mode = "default", canUseTool, permissions, settingsManager) {
-    this.mode = mode;
-    this.canUseTool = canUseTool;
-    this.allowRules = normalizeRules(permissions?.allow);
-    this.denyRules = normalizeRules(permissions?.deny);
-    this.settingsManager = settingsManager;
+// src/skills/skills.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, realpathSync, statSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename, dirname as dirname5, isAbsolute, join as join6, resolve } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_COMPATIBILITY_LENGTH = 500;
+var CONFIG_DIR_NAME = ".claude";
+function shouldIgnore(name) {
+  return name.startsWith(".") || name === "node_modules";
+}
+function validateName(name, parentDirName) {
+  const errors = [];
+  if (name !== parentDirName) {
+    errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
   }
-  async check(toolName, input, options) {
-    if (this.mode === "bypassPermissions") {
-      return { behavior: "allow" };
-    }
-    if (matchesRule(this.denyRules, toolName, input)) {
-      return {
-        behavior: "deny",
-        message: `Tool "${toolName}" is denied by permissions config.`
-      };
-    }
-    if (this.mode === "plan") {
-      if (!SAFE_TOOLS.has(toolName)) {
-        return {
-          behavior: "deny",
-          message: `Tool "${toolName}" is not allowed in plan mode. Only read-only tools are available.`
-        };
-      }
-      return { behavior: "allow" };
-    }
-    if (this.mode === "delegate") {
-      if (!DELEGATE_TOOLS.has(toolName) && !SAFE_TOOLS.has(toolName)) {
-        return {
-          behavior: "deny",
-          message: `Tool "${toolName}" is not allowed in delegate mode. Only Teammate, Task, and read-only tools are available.`
-        };
-      }
-      return { behavior: "allow" };
-    }
-    if (matchesRule(this.allowRules, toolName, input)) {
-      return { behavior: "allow" };
-    }
-    if (SAFE_TOOLS.has(toolName)) {
-      return { behavior: "allow" };
-    }
-    if (this.mode === "acceptEdits") {
-      if (EDIT_TOOLS.has(toolName)) {
-        return { behavior: "allow" };
-      }
-      if (toolName === "Bash") {
-        const cmd = String(input?.command ?? "").trimStart();
-        if (FS_COMMANDS.some((fc) => cmd.startsWith(fc + " ") || cmd === fc)) {
-          return { behavior: "allow" };
-        }
-      }
-    }
-    if (this.canUseTool) {
-      const result = await this.canUseTool(toolName, input, options);
-      if (result.behavior === "allow" && result.updatedPermissions) {
-        this.applyPermissionUpdates(result.updatedPermissions);
-      }
-      return result;
-    }
-    if (this.mode === "dontAsk") {
-      return {
-        behavior: "deny",
-        message: `Tool "${toolName}" requires approval. In dontAsk mode, tools must be pre-approved via permissions config.`
-      };
-    }
-    return { behavior: "allow" };
+  if (name.length > MAX_NAME_LENGTH) {
+    errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
   }
-  applyPermissionUpdates(updates) {
-    for (const update of updates) {
-      if (this.settingsManager && update.destination !== "session" && update.destination !== "cliArg") {
-        this.settingsManager.persistUpdate(update);
-      }
-      switch (update.type) {
-        case "addRules":
-          for (const rule of update.rules) {
-            if (update.behavior === "allow") {
-              this.allowRules.push(rule);
-            } else if (update.behavior === "deny") {
-              this.denyRules.push(rule);
-            }
-          }
-          break;
-        case "removeRules":
-          for (const rule of update.rules) {
-            if (update.behavior === "allow") {
-              this.allowRules = this.allowRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
-            } else if (update.behavior === "deny") {
-              this.denyRules = this.denyRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
-            }
-          }
-          break;
-        case "replaceRules":
-          if (update.behavior === "allow") {
-            this.allowRules = [...update.rules];
-          } else if (update.behavior === "deny") {
-            this.denyRules = [...update.rules];
-          }
-          break;
-        case "setMode":
-          this.mode = update.mode;
-          break;
-      }
-    }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push(`name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)`);
   }
-  setMode(mode) {
-    this.mode = mode;
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push(`name must not start or end with a hyphen`);
   }
-  getMode() {
-    return this.mode;
+  if (name.includes("--")) {
+    errors.push(`name must not contain consecutive hyphens`);
   }
+  return errors;
 }
-
-// src/settings.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-
-class SettingsManager {
-  cwd;
-  constructor(cwd) {
-    this.cwd = cwd;
+function validateDescription(description) {
+  const errors = [];
+  if (!description || description.trim() === "") {
+    errors.push("description is required");
+  } else if (description.length > MAX_DESCRIPTION_LENGTH) {
+    errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+  }
+  return errors;
+}
+function validateCompatibility(compatibility) {
+  if (!compatibility)
+    return [];
+  if (compatibility.length > MAX_COMPATIBILITY_LENGTH) {
+    return [`compatibility exceeds ${MAX_COMPATIBILITY_LENGTH} characters (${compatibility.length})`];
   }
-  loadPermissions(sources) {
-    const allAllow = [];
-    const allDeny = [];
-    for (const source of sources) {
-      const path = this.sourceToPath(source);
-      const data = this.readJson(path);
-      if (!data?.permissions)
+  return [];
+}
+function loadSkillsFromDir(options) {
+  return loadSkillsFromDirInternal(options.dir, options.source, true);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
+  const skills = [];
+  const diagnostics = [];
+  if (!existsSync4(dir)) {
+    return { skills, diagnostics };
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name)) {
         continue;
-      const perms = data.permissions;
-      if (Array.isArray(perms.allow)) {
-        for (const rule of perms.allow) {
-          if (typeof rule === "string") {
-            allAllow.push(this.parseRule(rule));
-          }
-        }
       }
-      if (Array.isArray(perms.deny)) {
-        for (const rule of perms.deny) {
-          if (typeof rule === "string") {
-            allDeny.push(this.parseRule(rule));
-          }
+      const fullPath = join6(dir, entry.name);
+      let isDirectory = entry.isDirectory();
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const stats = statSync(fullPath);
+          isDirectory = stats.isDirectory();
+          isFile = stats.isFile();
+        } catch {
+          continue;
         }
       }
-    }
-    const result = {};
-    if (allAllow.length > 0)
-      result.allow = allAllow;
-    if (allDeny.length > 0)
-      result.deny = allDeny;
-    return result;
-  }
-  persistUpdate(update) {
-    const path = this.destinationToPath(update.destination);
-    if (!path)
-      return;
-    const data = this.readJson(path) ?? {};
-    if (!data.permissions)
-      data.permissions = {};
-    const perms = data.permissions;
-    switch (update.type) {
-      case "addRules": {
-        const key = update.behavior;
-        const existing = Array.isArray(perms[key]) ? perms[key] : [];
-        const newRules = update.rules.map((r) => this.serializeRule(r));
-        const set = new Set(existing);
-        for (const rule of newRules)
-          set.add(rule);
-        perms[key] = [...set];
-        break;
-      }
-      case "removeRules": {
-        const key = update.behavior;
-        if (!Array.isArray(perms[key]))
-          break;
-        const toRemove = new Set(update.rules.map((r) => this.serializeRule(r)));
-        perms[key] = perms[key].filter((r) => !toRemove.has(r));
-        break;
-      }
-      case "replaceRules": {
-        const key = update.behavior;
-        perms[key] = update.rules.map((r) => this.serializeRule(r));
-        break;
+      if (isDirectory) {
+        const subResult = loadSkillsFromDirInternal(fullPath, source, false);
+        skills.push(...subResult.skills);
+        diagnostics.push(...subResult.diagnostics);
+        continue;
       }
-      case "setMode": {
-        perms.defaultMode = update.mode;
-        break;
+      if (!isFile)
+        continue;
+      const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+      const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+      if (!isRootMd && !isSkillMd)
+        continue;
+      const result = loadSkillFromFile(fullPath, source);
+      if (result.skill) {
+        skills.push(result.skill);
       }
-      default:
-        return;
-    }
-    const dir = dirname2(path);
-    if (!existsSync3(dir))
-      mkdirSync2(dir, { recursive: true });
-    writeFileSync3(path, JSON.stringify(data, null, 2) + `
-`);
-  }
-  sourceToPath(source) {
-    switch (source) {
-      case "user":
-        return join3(homedir3(), ".claude", "settings.json");
-      case "project":
-        return join3(this.cwd, ".claude", "settings.json");
-      case "local":
-        return join3(this.cwd, ".claude", "settings.local.json");
-    }
-  }
-  destinationToPath(destination) {
-    switch (destination) {
-      case "userSettings":
-        return join3(homedir3(), ".claude", "settings.json");
-      case "projectSettings":
-        return join3(this.cwd, ".claude", "settings.json");
-      case "localSettings":
-        return join3(this.cwd, ".claude", "settings.local.json");
-      default:
-        return null;
+      diagnostics.push(...result.diagnostics);
     }
+  } catch {}
+  return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+  const diagnostics = [];
+  try {
+    const rawContent = readFileSync4(filePath, "utf-8");
+    const { frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname5(filePath);
+    const parentDirName = basename(skillDir);
+    const descErrors = validateDescription(frontmatter.description);
+    for (const error of descErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const name = frontmatter.name || parentDirName;
+    const nameErrors = validateName(name, parentDirName);
+    for (const error of nameErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const compatErrors = validateCompatibility(frontmatter.compatibility);
+    for (const error of compatErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    if (!frontmatter.description || frontmatter.description.trim() === "") {
+      return { skill: null, diagnostics };
+    }
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(/\s+/).filter(Boolean) : undefined;
+    return {
+      skill: {
+        name,
+        description: frontmatter.description,
+        filePath,
+        baseDir: skillDir,
+        source,
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        allowedTools
+      },
+      diagnostics
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "failed to parse skill file";
+    diagnostics.push({ type: "warning", message, path: filePath });
+    return { skill: null, diagnostics };
   }
-  readJson(path) {
-    try {
-      const content = readFileSync3(path, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
+}
+function normalizePath(input) {
+  const trimmed = input.trim();
+  if (trimmed === "~")
+    return homedir4();
+  if (trimmed.startsWith("~/"))
+    return join6(homedir4(), trimmed.slice(2));
+  if (trimmed.startsWith("~"))
+    return join6(homedir4(), trimmed.slice(1));
+  return trimmed;
+}
+function resolveSkillPath(p, cwd) {
+  const normalized = normalizePath(p);
+  return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
+}
+function loadSkills(options = {}) {
+  const { cwd = process.cwd(), skillPaths = [], includeDefaults = true } = options;
+  const skillMap = new Map;
+  const realPathSet = new Set;
+  const allDiagnostics = [];
+  const collisionDiagnostics = [];
+  function addSkills(result) {
+    allDiagnostics.push(...result.diagnostics);
+    for (const skill of result.skills) {
+      let realPath;
+      try {
+        realPath = realpathSync(skill.filePath);
+      } catch {
+        realPath = skill.filePath;
+      }
+      if (realPathSet.has(realPath))
+        continue;
+      const existing = skillMap.get(skill.name);
+      if (existing) {
+        collisionDiagnostics.push({
+          type: "collision",
+          message: `name "${skill.name}" collision`,
+          path: skill.filePath,
+          collision: {
+            resourceType: "skill",
+            name: skill.name,
+            winnerPath: existing.filePath,
+            loserPath: skill.filePath
+          }
+        });
+      } else {
+        skillMap.set(skill.name, skill);
+        realPathSet.add(realPath);
+      }
     }
   }
-  parseRule(s) {
-    const match = s.match(/^([^(]+)\((.+)\)$/);
-    if (match)
-      return { toolName: match[1], ruleContent: match[2] };
-    return { toolName: s };
+  if (includeDefaults) {
+    const userSkillsDir = join6(homedir4(), CONFIG_DIR_NAME, "skills");
+    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    addSkills(loadSkillsFromDirInternal(userSkillsDir, "user", true));
+    addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
   }
-  serializeRule(rule) {
-    return rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : rule.toolName;
+  for (const rawPath of skillPaths) {
+    const resolvedPath = resolveSkillPath(rawPath, cwd);
+    if (!existsSync4(resolvedPath)) {
+      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+      continue;
+    }
+    try {
+      const stats = statSync(resolvedPath);
+      if (stats.isDirectory()) {
+        addSkills(loadSkillsFromDirInternal(resolvedPath, "path", true));
+      } else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+        const result = loadSkillFromFile(resolvedPath, "path");
+        if (result.skill) {
+          addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+        } else {
+          allDiagnostics.push(...result.diagnostics);
+        }
+      } else {
+        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "failed to read skill path";
+      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+    }
   }
+  return {
+    skills: Array.from(skillMap.values()),
+    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
+  };
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSkillsForPrompt(skills) {
+  const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+  if (visibleSkills.length === 0) {
+    return "";
+  }
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    if (skill.allowedTools?.length) {
+      lines.push(`    <allowed-tools>${escapeXml(skill.allowedTools.join(" "))}</allowed-tools>`);
+    }
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
 }
-
 // src/utils/system-prompt.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 var CORE_IDENTITY = `You are an AI coding agent. You help users with software engineering tasks by reading, writing, and modifying code. You have access to tools that let you interact with the filesystem and execute commands.
 
 You are highly capable and can help users complete complex tasks that would otherwise be too difficult or time-consuming.`;
@@ -2976,39 +3508,552 @@ function buildSystemPrompt(context) {
     if (guidelines) {
       sections.push(guidelines);
     }
-  }
-  sections.push(CODING_GUIDELINES);
-  if (context.cwd) {
-    sections.push(`# Environment
-
-Working directory: ${context.cwd}`);
-    const instructions = readProjectInstructions(context.cwd);
-    if (instructions) {
-      sections.push(`# Project Instructions
-
-${instructions}`);
+  }
+  sections.push(CODING_GUIDELINES);
+  if (context.cwd) {
+    sections.push(`# Environment
+
+Working directory: ${context.cwd}`);
+    if (context.additionalDirectories && context.additionalDirectories.length > 0) {
+      sections.push(`Additional allowed directories:
+${context.additionalDirectories.map((d) => `- ${d}`).join(`
+`)}`);
+    }
+    if (context.loadProjectInstructions) {
+      const instructions = readProjectInstructions(context.cwd);
+      if (instructions) {
+        sections.push(`# Project Instructions
+
+${instructions}`);
+      }
+    }
+  }
+  if (context.skills && context.skills.length > 0) {
+    const skillsPrompt = formatSkillsForPrompt(context.skills);
+    if (skillsPrompt) {
+      sections.push(`# Skills
+
+${skillsPrompt}`);
+    }
+  }
+  if (context.customPrompt) {
+    sections.push(context.customPrompt);
+  }
+  return sections.join(`
+
+`);
+}
+function readProjectInstructions(cwd) {
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    try {
+      const content = readFileSync5(join7(cwd, name), "utf-8").trim();
+      if (content)
+        return content;
+    } catch {}
+  }
+  return null;
+}
+
+// src/agent-loop.ts
+function makeModelUsageEntry() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    totalCostUsd: 0
+  };
+}
+function makeErrorResult(params) {
+  return {
+    type: "result",
+    subtype: params.subtype,
+    duration_ms: Date.now() - params.startTime,
+    duration_api_ms: params.apiTimeMs,
+    is_error: true,
+    num_turns: params.turns,
+    stop_reason: null,
+    total_cost_usd: params.costUsd,
+    usage: params.usage,
+    modelUsage: params.modelUsage,
+    permission_denials: params.permissionDenials,
+    errors: params.errors,
+    uuid: uuid(),
+    session_id: params.sessionId
+  };
+}
+function extractStructuredJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Empty result text; expected JSON output." };
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return { ok: true, value: JSON.parse(candidate) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Invalid JSON output: ${message}` };
+  }
+}
+async function* agentLoop(prompt, options) {
+  const {
+    provider,
+    model,
+    fallbackModel,
+    modelState,
+    maxThinkingTokensState,
+    thinking,
+    effort,
+    outputFormat,
+    systemPrompt,
+    tools,
+    permissions,
+    cwd,
+    sessionId,
+    maxTurns,
+    maxBudgetUsd,
+    includePartialMessages,
+    signal,
+    env,
+    debug,
+    hooks,
+    mcpClient,
+    previousMessages,
+    sessionLogger,
+    nativeMemoryTool,
+    initMeta
+  } = options;
+  const effectiveModelState = modelState ?? { current: model };
+  const startTime = Date.now();
+  let apiTimeMs = 0;
+  let turns = 0;
+  let totalUsage = emptyTokenUsage();
+  let costUsd = 0;
+  const modelUsage = {};
+  const permissionDenials = [];
+  if (mcpClient) {
+    await mcpClient.connectAll();
+    for (const tool of mcpClient.getTools()) {
+      tools.register(tool);
+    }
+    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
+    tools.register(createListMcpResourcesTool2(mcpClient));
+    tools.register(createReadMcpResourceTool2(mcpClient));
+  }
+  const messages = [
+    ...previousMessages ?? [],
+    { role: "user", content: prompt }
+  ];
+  if (sessionLogger) {
+    sessionLogger("user", prompt, null);
+  }
+  yield {
+    type: "system",
+    subtype: "init",
+    apiKeySource: "user",
+    claude_code_version: "fourmis-agent-sdk",
+    session_id: sessionId,
+    model: effectiveModelState.current,
+    tools: tools.list(),
+    cwd,
+    mcp_servers: (mcpClient?.status() ?? []).map((s) => ({ name: s.name, status: s.status })),
+    permissionMode: permissions.getMode(),
+    agents: initMeta?.agents,
+    betas: initMeta?.betas,
+    slash_commands: initMeta?.slashCommands ?? [],
+    output_style: initMeta?.outputStyle ?? "default",
+    skills: initMeta?.skills ?? [],
+    plugins: (initMeta?.plugins ?? []).map((p) => ({ name: p.path.split("/").pop() ?? p.path, path: p.path })),
+    uuid: uuid()
+  };
+  if (hooks) {
+    await hooks.fire("Setup", {
+      event: "Setup",
+      hook_event_name: "Setup",
+      trigger: "init",
+      session_id: sessionId,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
+  }
+  if (hooks) {
+    await hooks.fire("SessionStart", {
+      event: "SessionStart",
+      hook_event_name: "SessionStart",
+      session_id: sessionId,
+      source: "startup",
+      model: effectiveModelState.current,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
+  }
+  while (true) {
+    if (signal.aborted) {
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: ["Aborted"],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
+      return;
+    }
+    if (turns >= maxTurns) {
+      yield makeErrorResult({
+        subtype: "error_max_turns",
+        errors: [`Reached maximum turns (${maxTurns})`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
+      return;
+    }
+    if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
+      yield makeErrorResult({
+        subtype: "error_max_budget_usd",
+        errors: [],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
+      return;
+    }
+    const activeModel = effectiveModelState.current;
+    const toolDefs = tools.getDefinitions();
+    const apiStart = Date.now();
+    let assistantTextParts = [];
+    const toolCalls = [];
+    let turnUsage = emptyTokenUsage();
+    let turnStopReason = null;
+    const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
+    try {
+      const chunks = provider.chat({
+        model: activeModel,
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        systemPrompt,
+        signal,
+        nativeTools,
+        thinkingBudget: maxThinkingTokensState?.current,
+        thinking,
+        effort,
+        outputFormat
+      });
+      for await (const chunk of chunks) {
+        switch (chunk.type) {
+          case "text_delta":
+            assistantTextParts.push(chunk.text);
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "text_delta", text: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
+            }
+            break;
+          case "thinking_delta":
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "thinking_delta", thinking: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
+            }
+            break;
+          case "tool_call":
+            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
+            break;
+          case "usage":
+            turnUsage = mergeUsage(turnUsage, chunk.usage);
+            break;
+          case "done":
+            turnStopReason = chunk.stopReason ?? null;
+            break;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (fallbackModel && activeModel !== fallbackModel) {
+        effectiveModelState.current = fallbackModel;
+        yield {
+          type: "system",
+          subtype: "status",
+          status: null,
+          permissionMode: permissions.getMode(),
+          uuid: uuid(),
+          session_id: sessionId
+        };
+        continue;
+      }
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: [`API error: ${message}`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
+      return;
+    }
+    apiTimeMs += Date.now() - apiStart;
+    turns++;
+    totalUsage = mergeUsage(totalUsage, turnUsage);
+    const turnCost = provider.calculateCost(activeModel, turnUsage);
+    costUsd += turnCost;
+    if (!modelUsage[activeModel]) {
+      modelUsage[activeModel] = makeModelUsageEntry();
+    }
+    modelUsage[activeModel].inputTokens += turnUsage.inputTokens;
+    modelUsage[activeModel].outputTokens += turnUsage.outputTokens;
+    modelUsage[activeModel].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
+    modelUsage[activeModel].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
+    modelUsage[activeModel].totalCostUsd += turnCost;
+    modelUsage[activeModel].webSearchRequests = (modelUsage[activeModel].webSearchRequests ?? 0) + (turnUsage.webSearchRequests ?? 0);
+    modelUsage[activeModel].costUSD = modelUsage[activeModel].totalCostUsd;
+    modelUsage[activeModel].contextWindow = provider.getContextWindow(activeModel);
+    const assistantText = assistantTextParts.join("");
+    const assistantContent = [];
+    if (assistantText) {
+      assistantContent.push({ type: "text", text: assistantText });
+    }
+    for (const call of toolCalls) {
+      assistantContent.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: call.input
+      });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    if (sessionLogger) {
+      sessionLogger("assistant", assistantContent, null);
+    }
+    yield {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: assistantContent
+      },
+      parent_tool_use_id: null,
+      uuid: uuid(),
+      session_id: sessionId
+    };
+    if (toolCalls.length === 0) {
+      let structuredOutput;
+      if (outputFormat?.type === "json_schema") {
+        const parsed = extractStructuredJson(assistantText);
+        if (!parsed.ok) {
+          yield makeErrorResult({
+            subtype: "error_max_structured_output_retries",
+            errors: [parsed.error],
+            turns,
+            costUsd,
+            sessionId,
+            startTime,
+            apiTimeMs,
+            usage: totalUsage,
+            modelUsage,
+            permissionDenials
+          });
+          return;
+        }
+        structuredOutput = parsed.value;
+      }
+      if (hooks) {
+        await hooks.fire("Stop", {
+          event: "Stop",
+          hook_event_name: "Stop",
+          session_id: sessionId,
+          text: assistantText || undefined,
+          stop_reason: turnStopReason ?? undefined
+        }, undefined, {
+          signal
+        });
+      }
+      if (hooks) {
+        await hooks.fire("SessionEnd", {
+          event: "SessionEnd",
+          hook_event_name: "SessionEnd",
+          session_id: sessionId,
+          reason: "other"
+        }, undefined, { signal });
+      }
+      yield {
+        type: "result",
+        subtype: "success",
+        duration_ms: Date.now() - startTime,
+        duration_api_ms: apiTimeMs,
+        is_error: false,
+        num_turns: turns,
+        result: assistantText,
+        stop_reason: turnStopReason,
+        total_cost_usd: costUsd,
+        usage: totalUsage,
+        modelUsage,
+        permission_denials: permissionDenials,
+        structured_output: structuredOutput,
+        uuid: uuid(),
+        session_id: sessionId
+      };
+      return;
+    }
+    const toolResults = [];
+    for (const call of toolCalls) {
+      let hookDenied = false;
+      let hookUpdatedInput;
+      if (hooks) {
+        const hookResult = await hooks.fire("PreToolUse", {
+          event: "PreToolUse",
+          hook_event_name: "PreToolUse",
+          tool_name: call.name,
+          tool_input: call.input,
+          session_id: sessionId
+        }, call.id, { signal });
+        if (hookResult) {
+          if (hookResult.permissionDecision === "deny") {
+            hookDenied = true;
+          }
+          if (hookResult.updatedInput !== undefined) {
+            hookUpdatedInput = hookResult.updatedInput;
+          }
+        }
+      }
+      if (hookDenied) {
+        const denyContent = "Denied by hook";
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
+      const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
+      if (permResult.behavior === "deny") {
+        const denyContent = `Permission denied: ${permResult.message}`;
+        permissionDenials.push({
+          tool_name: call.name,
+          tool_use_id: call.id,
+          tool_input: inputAfterHook ?? {}
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
+      let result;
+      if (call.name === "memory" && nativeMemoryTool) {
+        try {
+          const content = await nativeMemoryTool.execute(toolInput);
+          result = { content, isError: content.startsWith("Error:") };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          result = { content: `Error: ${message}`, isError: true };
+        }
+      } else {
+        const toolCtx = {
+          cwd,
+          signal,
+          sessionId,
+          env
+        };
+        result = await tools.execute(call.name, toolInput, toolCtx);
+      }
+      if (call.name === "ExitPlanMode") {
+        permissions.setMode("default");
+      }
+      if (debug) {
+        console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
+      }
+      if (hooks) {
+        if (result.isError) {
+          await hooks.fire("PostToolUseFailure", {
+            event: "PostToolUseFailure",
+            hook_event_name: "PostToolUseFailure",
+            tool_name: call.name,
+            tool_result: result.content,
+            tool_error: true,
+            session_id: sessionId
+          }, call.id, { signal });
+        } else {
+          const postResult = await hooks.fire("PostToolUse", {
+            event: "PostToolUse",
+            hook_event_name: "PostToolUse",
+            tool_name: call.name,
+            tool_result: result.content,
+            session_id: sessionId
+          }, call.id, { signal });
+          if (postResult?.additionalContext) {
+            result.content += `
+${postResult.additionalContext}`;
+          }
+        }
+      }
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: call.id,
+        content: result.content,
+        is_error: result.isError
+      });
+    }
+    messages.push({ role: "user", content: toolResults });
+    if (sessionLogger) {
+      sessionLogger("user", toolResults, null);
     }
+    yield {
+      type: "user",
+      message: {
+        role: "user",
+        content: toolResults
+      },
+      parent_tool_use_id: null,
+      isSynthetic: true,
+      uuid: uuid(),
+      session_id: sessionId
+    };
   }
-  if (context.customPrompt) {
-    sections.push(context.customPrompt);
-  }
-  return sections.join(`
-
-`);
-}
-function readProjectInstructions(cwd) {
-  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
-    try {
-      const content = readFileSync4(join4(cwd, name), "utf-8").trim();
-      if (content)
-        return content;
-    } catch {}
-  }
-  return null;
 }
 
 // src/query.ts
-function createQuery(generator, abortController) {
+function unsupported(methodName) {
+  return Promise.reject(new Error(`Query.${methodName} is not supported in this runtime yet.`));
+}
+function createQuery(generator, abortController, controls) {
   const query = {
     next: generator.next.bind(generator),
     return: generator.return.bind(generator),
@@ -3019,6 +4064,71 @@ function createQuery(generator, abortController) {
     async interrupt() {
       abortController.abort();
     },
+    async setPermissionMode(mode) {
+      if (!controls?.setPermissionMode)
+        return unsupported("setPermissionMode");
+      await controls.setPermissionMode(mode);
+    },
+    async setModel(model) {
+      if (!controls?.setModel)
+        return unsupported("setModel");
+      await controls.setModel(model);
+    },
+    async setMaxThinkingTokens(maxThinkingTokens) {
+      if (!controls?.setMaxThinkingTokens)
+        return unsupported("setMaxThinkingTokens");
+      await controls.setMaxThinkingTokens(maxThinkingTokens);
+    },
+    async initializationResult() {
+      if (!controls?.initializationResult)
+        return unsupported("initializationResult");
+      return controls.initializationResult();
+    },
+    async supportedCommands() {
+      if (!controls?.supportedCommands)
+        return unsupported("supportedCommands");
+      return controls.supportedCommands();
+    },
+    async supportedModels() {
+      if (!controls?.supportedModels)
+        return unsupported("supportedModels");
+      return controls.supportedModels();
+    },
+    async mcpServerStatus() {
+      if (!controls?.mcpServerStatus)
+        return unsupported("mcpServerStatus");
+      return controls.mcpServerStatus();
+    },
+    async accountInfo() {
+      if (!controls?.accountInfo)
+        return unsupported("accountInfo");
+      return controls.accountInfo();
+    },
+    async rewindFiles(userMessageId, options) {
+      if (!controls?.rewindFiles)
+        return unsupported("rewindFiles");
+      return controls.rewindFiles(userMessageId, options);
+    },
+    async reconnectMcpServer(serverName) {
+      if (!controls?.reconnectMcpServer)
+        return unsupported("reconnectMcpServer");
+      await controls.reconnectMcpServer(serverName);
+    },
+    async toggleMcpServer(serverName, enabled) {
+      if (!controls?.toggleMcpServer)
+        return unsupported("toggleMcpServer");
+      await controls.toggleMcpServer(serverName, enabled);
+    },
+    async setMcpServers(servers) {
+      if (!controls?.setMcpServers)
+        return unsupported("setMcpServers");
+      return controls.setMcpServers(servers);
+    },
+    async streamInput(stream) {
+      if (!controls?.streamInput)
+        return unsupported("streamInput");
+      await controls.streamInput(stream);
+    },
     close() {
       abortController.abort();
       generator.return(undefined);
@@ -3040,7 +4150,10 @@ var HOOK_EVENTS = [
   "SubagentStart",
   "SubagentStop",
   "PreCompact",
-  "PermissionRequest"
+  "PermissionRequest",
+  "Setup",
+  "TeammateIdle",
+  "TaskCompleted"
 ];
 var TOOL_EVENTS = new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure"]);
 
@@ -3072,9 +4185,31 @@ class HookManager {
         }
       }
       for (const callback of entry.hooks) {
-        const result = await callback(input, toolUseId, { signal });
+        const timeoutMs = typeof entry.timeout === "number" && entry.timeout > 0 ? Math.floor(entry.timeout * 1000) : null;
+        const invoke = callback(input, toolUseId, { signal });
+        const result = timeoutMs ? await Promise.race([
+          invoke,
+          new Promise((resolve2) => {
+            setTimeout(() => resolve2({}), timeoutMs);
+          })
+        ]) : await invoke;
         if (result) {
           hasOutput = true;
+          if (result.continue === false && !result.permissionDecision) {
+            merged.permissionDecision = "deny";
+          }
+          if (result.decision) {
+            if (result.decision.behavior === "deny") {
+              merged.permissionDecision = "deny";
+            } else {
+              if (!merged.permissionDecision) {
+                merged.permissionDecision = "allow";
+              }
+              if (result.decision.updatedInput !== undefined) {
+                merged.updatedInput = result.decision.updatedInput;
+              }
+            }
+          }
           if (result.permissionDecision) {
             if (!merged.permissionDecision || result.permissionDecision === "deny") {
               merged.permissionDecision = result.permissionDecision;
@@ -3104,14 +4239,29 @@ import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 class McpClientManager {
   configs;
   servers = new Map;
+  disabled = new Set;
   constructor(configs) {
-    this.configs = configs;
+    this.configs = { ...configs };
   }
   async connectAll() {
     const entries = Object.entries(this.configs);
     await Promise.all(entries.map(([name, config]) => this.connectOne(name, config)));
   }
   async connectOne(name, config) {
+    if (this.disabled.has(name)) {
+      this.servers.set(name, {
+        name,
+        client: null,
+        tools: [],
+        status: {
+          name,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
+      });
+      return;
+    }
     try {
       const client = new Client({ name: `fourmis-${name}`, version: "1.0.0" });
       if (config.type === "sdk") {
@@ -3145,13 +4295,25 @@ class McpClientManager {
       const tools = (toolsResult.tools ?? []).map((t) => ({
         name: t.name,
         description: t.description,
-        inputSchema: t.inputSchema
+        inputSchema: t.inputSchema,
+        annotations: t.annotations ? {
+          readOnly: t.annotations.readOnly,
+          destructive: t.annotations.destructive,
+          openWorld: t.annotations.openWorld
+        } : undefined
       }));
       this.servers.set(name, {
         name,
         client,
         tools,
-        status: { name, status: "connected", tools }
+        status: {
+          name,
+          status: "connected",
+          tools,
+          serverInfo: { name, version: "1.0.0" },
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
       });
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
@@ -3159,10 +4321,22 @@ class McpClientManager {
         name,
         client: null,
         tools: [],
-        status: { name, status: "failed", error }
+        status: {
+          name,
+          status: "failed",
+          error,
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
       });
     }
   }
+  toStatusConfig(config) {
+    if (config.type === "sdk") {
+      return { type: "sdk", name: config.name };
+    }
+    return config;
+  }
   getTools() {
     const result = [];
     for (const [serverName, server] of this.servers) {
@@ -3202,64 +4376,294 @@ class McpClientManager {
       return { content: `MCP tool error: ${message}`, isError: true };
     }
   }
-  async listResources(serverName) {
-    const result = [];
-    const serversToQuery = serverName ? [this.servers.get(serverName)].filter(Boolean) : [...this.servers.values()];
-    for (const server of serversToQuery) {
-      if (server.status.status !== "connected")
+  async listResources(serverName) {
+    const result = [];
+    const serversToQuery = serverName ? [this.servers.get(serverName)].filter(Boolean) : [...this.servers.values()];
+    for (const server of serversToQuery) {
+      if (server.status.status !== "connected")
+        continue;
+      try {
+        const resources = await server.client.listResources();
+        for (const r of resources.resources ?? []) {
+          result.push({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+            server: server.name
+          });
+        }
+      } catch {}
+    }
+    return result;
+  }
+  async readResource(serverName, uri) {
+    const server = this.servers.get(serverName);
+    if (!server || server.status.status !== "connected") {
+      throw new Error(`MCP server "${serverName}" is not connected`);
+    }
+    const result = await server.client.readResource({ uri });
+    const contents = result.contents ?? [];
+    return contents.map((c) => {
+      if ("text" in c)
+        return c.text;
+      if ("blob" in c)
+        return `[binary data: ${c.mimeType ?? "unknown"}]`;
+      return "";
+    }).join("");
+  }
+  status() {
+    const result = [];
+    for (const [name, config] of Object.entries(this.configs)) {
+      const server = this.servers.get(name);
+      if (server) {
+        result.push(server.status);
+      } else if (this.disabled.has(name)) {
+        result.push({
+          name,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        });
+      } else {
+        result.push({
+          name,
+          status: "pending",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        });
+      }
+    }
+    return result;
+  }
+  async reconnectServer(serverName) {
+    const config = this.configs[serverName];
+    if (!config) {
+      throw new Error(`MCP server "${serverName}" is not configured`);
+    }
+    await this.closeOne(serverName);
+    await this.connectOne(serverName, config);
+    const status = this.servers.get(serverName)?.status;
+    if (!status || status.status !== "connected") {
+      throw new Error(status?.error ?? `Failed to reconnect MCP server "${serverName}"`);
+    }
+  }
+  async toggleServer(serverName, enabled) {
+    const config = this.configs[serverName];
+    if (!config) {
+      throw new Error(`MCP server "${serverName}" is not configured`);
+    }
+    if (!enabled) {
+      this.disabled.add(serverName);
+      await this.closeOne(serverName);
+      this.servers.set(serverName, {
+        name: serverName,
+        client: null,
+        tools: [],
+        status: {
+          name: serverName,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
+      });
+      return;
+    }
+    this.disabled.delete(serverName);
+    await this.reconnectServer(serverName);
+  }
+  async setServers(servers) {
+    const prevNames = new Set(Object.keys(this.configs));
+    const nextNames = new Set(Object.keys(servers));
+    const added = [...nextNames].filter((n) => !prevNames.has(n));
+    const removed = [...prevNames].filter((n) => !nextNames.has(n));
+    const errors = {};
+    for (const name of removed) {
+      await this.closeOne(name);
+      delete this.configs[name];
+      this.disabled.delete(name);
+      this.servers.delete(name);
+    }
+    for (const [name, config] of Object.entries(servers)) {
+      const prev = this.configs[name];
+      this.configs[name] = config;
+      if (this.disabled.has(name))
+        continue;
+      if (!prev || JSON.stringify(this.toStatusConfig(prev)) !== JSON.stringify(this.toStatusConfig(config))) {
+        await this.closeOne(name);
+        await this.connectOne(name, config);
+      }
+      const status = this.servers.get(name)?.status;
+      if (!status || status.status === "failed") {
+        errors[name] = status?.error ?? "Failed to connect";
+      }
+    }
+    return { added, removed, errors };
+  }
+  async closeOne(serverName) {
+    const existing = this.servers.get(serverName);
+    if (existing?.client) {
+      try {
+        await existing.client.close();
+      } catch {}
+    }
+  }
+  async closeAll() {
+    for (const [name] of this.servers) {
+      await this.closeOne(name);
+    }
+    this.servers.clear();
+  }
+}
+
+// src/utils/session-store.ts
+import { readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir5 } from "os";
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function sanitizeCwd(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+function sessionsDir(cwd) {
+  return join8(homedir5(), ".claude", "projects", sanitizeCwd(cwd));
+}
+function ensureDir(dir) {
+  mkdirSync3(dir, { recursive: true });
+}
+function logMessage(dir, sessionId, entry) {
+  ensureDir(dir);
+  const filePath = join8(dir, `${sessionId}.jsonl`);
+  appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+}
+function createSessionLogger(cwd, sessionId, model) {
+  const dir = sessionsDir(cwd);
+  let lastUuid = null;
+  return (role, content, parentUuid) => {
+    const entryUuid = uuid();
+    let normalizedContent = content;
+    if (role === "user" && typeof content === "string") {
+      normalizedContent = [{ type: "text", text: content }];
+    }
+    const entry = {
+      type: role,
+      uuid: entryUuid,
+      parentUuid: parentUuid ?? lastUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      cwd,
+      isSidechain: false,
+      userType: "external",
+      message: {
+        role,
+        content: normalizedContent,
+        ...role === "assistant" && model ? { model } : {}
+      },
+      ...role === "user" ? { permissionMode: "default" } : {}
+    };
+    logMessage(dir, sessionId, entry);
+    lastUuid = entryUuid;
+    return entryUuid;
+  };
+}
+function findLatestSession(cwd) {
+  const dir = sessionsDir(cwd);
+  try {
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const filePath = join8(dir, f);
+      try {
+        return { name: f, mtime: statSync2(filePath).mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+    if (files.length === 0)
+      return null;
+    return files[0].name.replace(/\.jsonl$/, "");
+  } catch {
+    return null;
+  }
+}
+function loadSessionMessages(cwd, sessionId, resumeSessionAt) {
+  const dir = sessionsDir(cwd);
+  const filePath = join8(dir, `${sessionId}.jsonl`);
+  let lines;
+  try {
+    lines = readFileSync6(filePath, "utf-8").trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+  const messages = [];
+  let reachedResumePoint = false;
+  for (const line of lines) {
+    if (resumeSessionAt && reachedResumePoint)
+      break;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "user" && entry.type !== "assistant")
         continue;
-      try {
-        const resources = await server.client.listResources();
-        for (const r of resources.resources ?? []) {
-          result.push({
-            uri: r.uri,
-            name: r.name,
-            description: r.description,
-            mimeType: r.mimeType,
-            server: server.name
+      if (entry.isMeta === true)
+        continue;
+      const message = entry.message;
+      if (!message)
+        continue;
+      const role = entry.type === "user" ? "user" : "assistant";
+      let content;
+      if (typeof message.content === "string") {
+        content = message.content;
+      } else if (Array.isArray(message.content)) {
+        const normalizedBlocks = [];
+        for (const c of message.content) {
+          if (!c || typeof c !== "object")
+            continue;
+          const block = c;
+          if (typeof block.type !== "string")
+            continue;
+          if (block.type === "text" && typeof block.text === "string") {
+            normalizedBlocks.push({ type: "text", text: block.text });
+            continue;
+          }
+          if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            normalizedBlocks.push({
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input ?? {}
+            });
+            continue;
+          }
+          if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            normalizedBlocks.push({
+              type: "tool_result",
+              tool_use_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : safeStringify(block.content),
+              is_error: typeof block.is_error === "boolean" ? block.is_error : undefined
+            });
+            continue;
+          }
+          normalizedBlocks.push({
+            type: "text",
+            text: `[session:${block.type}] ${safeStringify(block)}`
           });
         }
-      } catch {}
-    }
-    return result;
-  }
-  async readResource(serverName, uri) {
-    const server = this.servers.get(serverName);
-    if (!server || server.status.status !== "connected") {
-      throw new Error(`MCP server "${serverName}" is not connected`);
-    }
-    const result = await server.client.readResource({ uri });
-    const contents = result.contents ?? [];
-    return contents.map((c) => {
-      if ("text" in c)
-        return c.text;
-      if ("blob" in c)
-        return `[binary data: ${c.mimeType ?? "unknown"}]`;
-      return "";
-    }).join("");
-  }
-  status() {
-    const result = [];
-    for (const [name] of Object.entries(this.configs)) {
-      const server = this.servers.get(name);
-      if (server) {
-        result.push(server.status);
+        content = normalizedBlocks;
       } else {
-        result.push({ name, status: "pending" });
+        continue;
       }
-    }
-    return result;
-  }
-  async closeAll() {
-    for (const [, server] of this.servers) {
-      if (server.client) {
-        try {
-          await server.client.close();
-        } catch {}
+      messages.push({ role, content });
+      if (resumeSessionAt && entry.uuid === resumeSessionAt) {
+        reachedResumePoint = true;
       }
-    }
-    this.servers.clear();
+    } catch {}
   }
+  return messages;
 }
 
 // src/agents/tools.ts
@@ -3282,6 +4686,15 @@ function createTaskTool(ctx) {
           type: "string",
           description: "The type of agent to use. Must match a registered agent definition."
         },
+        model: {
+          type: "string",
+          enum: ["sonnet", "opus", "haiku"],
+          description: "Optional model family hint for this subagent."
+        },
+        resume: {
+          type: "string",
+          description: "Optional session ID to resume this subagent from."
+        },
         run_in_background: {
           type: "boolean",
           description: "If true, run the task in the background and return a task ID."
@@ -3289,16 +4702,35 @@ function createTaskTool(ctx) {
         max_turns: {
           type: "number",
           description: "Maximum number of turns for the subagent."
+        },
+        name: {
+          type: "string",
+          description: "Optional display name for the spawned subagent."
+        },
+        team_name: {
+          type: "string",
+          description: "Optional team name context for this subagent."
+        },
+        mode: {
+          type: "string",
+          enum: ["acceptEdits", "bypassPermissions", "default", "delegate", "dontAsk", "plan"],
+          description: "Permission mode hint for the spawned subagent."
         }
       },
-      required: ["prompt", "subagent_type"]
+      required: ["description", "prompt", "subagent_type"]
     },
     async execute(input, toolCtx) {
       const {
+        description,
         prompt,
         subagent_type,
+        model: requestedModel,
+        resume,
         run_in_background,
-        max_turns
+        max_turns,
+        name,
+        team_name,
+        mode
       } = input;
       const agentDef = ctx.agents[subagent_type];
       if (!agentDef) {
@@ -3312,28 +4744,53 @@ function createTaskTool(ctx) {
         await ctx.parentHooks.fire("SubagentStart", { event: "SubagentStart", agent_type: subagent_type, session_id: toolCtx.sessionId }, undefined, { signal: toolCtx.signal });
       }
       const provider = agentDef.provider ? getProvider(agentDef.provider) : ctx.parentProvider;
-      const model = agentDef.model ?? ctx.parentModel;
-      let subTools;
-      if (agentDef.tools) {
-        subTools = buildToolRegistry(agentDef.tools);
-      } else {
-        subTools = buildToolRegistry(resolveToolNames("coding"));
-      }
+      const modelAliases = {
+        sonnet: "claude-sonnet-4-5-20250929",
+        opus: "claude-opus-4-5-20251101",
+        haiku: "claude-haiku-4-5-20251001"
+      };
+      const model = requestedModel ? modelAliases[requestedModel] : agentDef.model ?? ctx.parentModel;
+      const baseTools = agentDef.tools ?? resolveToolNames({ type: "preset", preset: "claude_code" });
+      const subTools = buildToolRegistry(baseTools, undefined, agentDef.disallowedTools);
       const maxTurns = max_turns ?? agentDef.maxTurns ?? 10;
-      const sessionId = uuid();
+      const sessionId = resume ?? uuid();
+      const previousMessages = resume ? loadSessionMessages(ctx.parentCwd, resume) : undefined;
       const abortController = new AbortController;
       if (toolCtx.signal) {
         toolCtx.signal.addEventListener("abort", () => abortController.abort(), { once: true });
       }
-      const systemPrompt = `${agentDef.prompt}
+      const systemPromptParts = [
+        agentDef.prompt,
+        `You are a subagent of type "${subagent_type}". ${agentDef.description}`,
+        `Task summary: ${description}`
+      ];
+      if (agentDef.criticalSystemReminder_EXPERIMENTAL) {
+        systemPromptParts.push(`Critical reminder: ${agentDef.criticalSystemReminder_EXPERIMENTAL}`);
+      }
+      if (agentDef.skills && agentDef.skills.length > 0) {
+        systemPromptParts.push(`Available skills:
+${agentDef.skills.map((s) => `- ${s}`).join(`
+`)}`);
+      }
+      if (name) {
+        systemPromptParts.push(`Subagent name: ${name}`);
+      }
+      if (team_name) {
+        systemPromptParts.push(`Team context: ${team_name}`);
+      }
+      if (mode) {
+        systemPromptParts.push(`Permission mode hint: ${mode}`);
+      }
+      const systemPrompt = systemPromptParts.join(`
 
-You are a subagent of type "${subagent_type}". ${agentDef.description}`;
+`);
       const runAgent = async () => {
         const messages = [];
         let resultText = "";
         for await (const msg of agentLoop(prompt, {
           provider,
           model,
+          modelState: { current: model },
           systemPrompt,
           tools: subTools,
           permissions: ctx.parentPermissions,
@@ -3341,18 +4798,23 @@ You are a subagent of type "${subagent_type}". ${agentDef.description}`;
           sessionId,
           maxTurns,
           maxBudgetUsd: 5,
-          includeStreamEvents: false,
+          includePartialMessages: false,
           signal: abortController.signal,
           env: ctx.parentEnv,
           debug: ctx.parentDebug,
-          hooks: ctx.parentHooks
+          hooks: ctx.parentHooks,
+          previousMessages
         })) {
           messages.push(msg);
-          if (msg.type === "text") {
-            resultText += msg.text;
+          if (msg.type === "assistant") {
+            for (const block of msg.message.content) {
+              if (block.type === "text") {
+                resultText += block.text;
+              }
+            }
           }
           if (msg.type === "result" && msg.subtype === "success") {
-            resultText = msg.text ?? resultText;
+            resultText = msg.result || resultText;
           }
         }
         return resultText || "Subagent completed with no text output.";
@@ -3490,7 +4952,7 @@ class TaskManager {
     if (!block) {
       return `Task "${id}" is still running.`;
     }
-    const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    const timeoutPromise = new Promise((resolve2) => setTimeout(resolve2, timeoutMs));
     await Promise.race([task.promise, timeoutPromise]);
     if (task.status === "running") {
       return `Task "${id}" is still running (timed out after ${timeoutMs}ms).`;
@@ -3511,115 +4973,12 @@ class TaskManager {
   }
 }
 
-// src/utils/session-store.ts
-import { readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync3, readdirSync, statSync } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
-function sanitizeCwd(cwd) {
-  return cwd.replace(/[/.]/g, "-");
-}
-function sessionsDir(cwd) {
-  return join5(homedir4(), ".claude", "projects", sanitizeCwd(cwd));
-}
-function ensureDir(dir) {
-  mkdirSync3(dir, { recursive: true });
-}
-function logMessage(dir, sessionId, entry) {
-  ensureDir(dir);
-  const filePath = join5(dir, `${sessionId}.jsonl`);
-  appendFileSync(filePath, JSON.stringify(entry) + `
-`);
-}
-function createSessionLogger(cwd, sessionId, model) {
-  const dir = sessionsDir(cwd);
-  let lastUuid = null;
-  return (role, content, parentUuid) => {
-    const entryUuid = uuid();
-    let normalizedContent = content;
-    if (role === "user" && typeof content === "string") {
-      normalizedContent = [{ type: "text", text: content }];
-    }
-    const entry = {
-      type: role,
-      uuid: entryUuid,
-      parentUuid: parentUuid ?? lastUuid,
-      sessionId,
-      timestamp: new Date().toISOString(),
-      cwd,
-      isSidechain: false,
-      userType: "external",
-      message: {
-        role,
-        content: normalizedContent,
-        ...role === "assistant" && model ? { model } : {}
-      },
-      ...role === "user" ? { permissionMode: "default" } : {}
-    };
-    logMessage(dir, sessionId, entry);
-    lastUuid = entryUuid;
-    return entryUuid;
-  };
-}
-function findLatestSession(cwd) {
-  const dir = sessionsDir(cwd);
-  try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
-      const filePath = join5(dir, f);
-      try {
-        return { name: f, mtime: statSync(filePath).mtimeMs };
-      } catch {
-        return null;
-      }
-    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
-    if (files.length === 0)
-      return null;
-    return files[0].name.replace(/\.jsonl$/, "");
-  } catch {
-    return null;
-  }
-}
-function loadSessionMessages(cwd, sessionId) {
-  const dir = sessionsDir(cwd);
-  const filePath = join5(dir, `${sessionId}.jsonl`);
-  let lines;
-  try {
-    lines = readFileSync5(filePath, "utf-8").trim().split(`
-`).filter(Boolean);
-  } catch {
-    return [];
-  }
-  const messages = [];
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-      if (entry.type !== "user" && entry.type !== "assistant")
-        continue;
-      if (entry.isMeta === true)
-        continue;
-      const message = entry.message;
-      if (!message)
-        continue;
-      const role = entry.type === "user" ? "user" : "assistant";
-      let content;
-      if (typeof message.content === "string") {
-        content = message.content;
-      } else if (Array.isArray(message.content)) {
-        content = message.content.filter((c) => c.type === "text" || c.type === "tool_use" || c.type === "tool_result").map((c) => c);
-      } else {
-        continue;
-      }
-      messages.push({ role, content });
-    } catch {}
-  }
-  return messages;
-}
-
 // src/memory/memory-handler.ts
-import { readdir, stat, readFile, writeFile, rm, rename, mkdir as mkdir2 } from "fs/promises";
-import { join as join6, resolve, relative } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { readdir, stat, readFile as readFile3, writeFile as writeFile4, rm, rename, mkdir as mkdir4 } from "fs/promises";
+import { join as join9, resolve as resolve2, relative as relative2 } from "path";
+import { existsSync as existsSync5 } from "fs";
 function createMemoryHandler(memoryDir) {
-  const absMemoryDir = resolve(memoryDir);
+  const absMemoryDir = resolve2(memoryDir);
   function resolvePath2(logicalPath) {
     let cleaned = logicalPath;
     if (cleaned.startsWith("/memories")) {
@@ -3631,15 +4990,15 @@ function createMemoryHandler(memoryDir) {
     if (cleaned.includes("..") || cleaned.includes("%2e") || cleaned.includes("%2E")) {
       throw new Error(`Path traversal detected: ${logicalPath}`);
     }
-    const absPath = cleaned === "" ? absMemoryDir : resolve(absMemoryDir, cleaned);
-    const rel = relative(absMemoryDir, absPath);
-    if (rel.startsWith("..") || resolve(absPath) !== absPath && !absPath.startsWith(absMemoryDir)) {
+    const absPath = cleaned === "" ? absMemoryDir : resolve2(absMemoryDir, cleaned);
+    const rel = relative2(absMemoryDir, absPath);
+    if (rel.startsWith("..") || resolve2(absPath) !== absPath && !absPath.startsWith(absMemoryDir)) {
       throw new Error(`Path traversal detected: ${logicalPath}`);
     }
     return absPath;
   }
   function toLogicalPath(absPath) {
-    const rel = relative(absMemoryDir, absPath);
+    const rel = relative2(absMemoryDir, absPath);
     return rel === "" ? "/memories" : `/memories/${rel}`;
   }
   function formatSize(bytes) {
@@ -3662,7 +5021,7 @@ function createMemoryHandler(memoryDir) {
       for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
-        const entryPath = join6(dirPath, entry.name);
+        const entryPath = join9(dirPath, entry.name);
         const entryStat = await stat(entryPath);
         lines.push(`${formatSize(entryStat.size)}	${toLogicalPath(entryPath)}`);
         if (entry.isDirectory()) {
@@ -3695,7 +5054,7 @@ function createMemoryHandler(memoryDir) {
   }
   async function handleView(cmd) {
     const absPath = resolvePath2(cmd.path);
-    if (!existsSync4(absPath)) {
+    if (!existsSync5(absPath)) {
       return `The path ${cmd.path} does not exist. Please provide a valid path.`;
     }
     const s = await stat(absPath);
@@ -3705,31 +5064,31 @@ function createMemoryHandler(memoryDir) {
 ${lines.join(`
 `)}`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const formatted = formatFileContent(content, cmd.view_range);
     return `Here's the content of ${cmd.path} with line numbers:
 ${formatted}`;
   }
   async function handleCreate(cmd) {
     const absPath = resolvePath2(cmd.path);
-    if (existsSync4(absPath)) {
+    if (existsSync5(absPath)) {
       return `Error: File ${cmd.path} already exists`;
     }
-    const parentDir = resolve(absPath, "..");
-    await mkdir2(parentDir, { recursive: true });
-    await writeFile(absPath, cmd.file_text, "utf-8");
+    const parentDir = resolve2(absPath, "..");
+    await mkdir4(parentDir, { recursive: true });
+    await writeFile4(absPath, cmd.file_text, "utf-8");
     return `File created successfully at: ${cmd.path}`;
   }
   async function handleStrReplace(cmd) {
     const absPath = resolvePath2(cmd.path);
-    if (!existsSync4(absPath)) {
+    if (!existsSync5(absPath)) {
       return `Error: The path ${cmd.path} does not exist. Please provide a valid path.`;
     }
     const s = await stat(absPath);
     if (s.isDirectory()) {
       return `Error: The path ${cmd.path} does not exist. Please provide a valid path.`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const lines = content.split(`
 `);
     const matchingLines = [];
@@ -3752,7 +5111,7 @@ ${formatted}`;
       return `No replacement was performed. Multiple occurrences of old_str \`${cmd.old_str}\` in lines: ${matchingLines.join(", ")}. Please ensure it is unique`;
     }
     const newContent = content.replace(cmd.old_str, cmd.new_str);
-    await writeFile(absPath, newContent, "utf-8");
+    await writeFile4(absPath, newContent, "utf-8");
     const newLines = newContent.split(`
 `);
     const replaceLine = matchingLines[0];
@@ -3765,14 +5124,14 @@ ${snippet}`;
   }
   async function handleInsert(cmd) {
     const absPath = resolvePath2(cmd.path);
-    if (!existsSync4(absPath)) {
+    if (!existsSync5(absPath)) {
       return `Error: The path ${cmd.path} does not exist`;
     }
     const s = await stat(absPath);
     if (s.isDirectory()) {
       return `Error: The path ${cmd.path} does not exist`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const lines = content.split(`
 `);
     if (cmd.insert_line < 0 || cmd.insert_line > lines.length) {
@@ -3781,13 +5140,13 @@ ${snippet}`;
     const insertLines = cmd.insert_text.split(`
 `);
     lines.splice(cmd.insert_line, 0, ...insertLines);
-    await writeFile(absPath, lines.join(`
+    await writeFile4(absPath, lines.join(`
 `), "utf-8");
     return `The file ${cmd.path} has been edited.`;
   }
   async function handleDelete(cmd) {
     const absPath = resolvePath2(cmd.path);
-    if (!existsSync4(absPath)) {
+    if (!existsSync5(absPath)) {
       return `Error: The path ${cmd.path} does not exist`;
     }
     await rm(absPath, { recursive: true, force: true });
@@ -3796,20 +5155,20 @@ ${snippet}`;
   async function handleRename(cmd) {
     const oldAbs = resolvePath2(cmd.old_path);
     const newAbs = resolvePath2(cmd.new_path);
-    if (!existsSync4(oldAbs)) {
+    if (!existsSync5(oldAbs)) {
       return `Error: The path ${cmd.old_path} does not exist`;
     }
-    if (existsSync4(newAbs)) {
+    if (existsSync5(newAbs)) {
       return `Error: The destination ${cmd.new_path} already exists`;
     }
-    const parentDir = resolve(newAbs, "..");
-    await mkdir2(parentDir, { recursive: true });
+    const parentDir = resolve2(newAbs, "..");
+    await mkdir4(parentDir, { recursive: true });
     await rename(oldAbs, newAbs);
     return `Successfully renamed ${cmd.old_path} to ${cmd.new_path}`;
   }
   async function execute(cmd) {
-    if (!existsSync4(absMemoryDir)) {
-      await mkdir2(absMemoryDir, { recursive: true });
+    if (!existsSync5(absMemoryDir)) {
+      await mkdir4(absMemoryDir, { recursive: true });
     }
     switch (cmd.command) {
       case "view":
@@ -3914,26 +5273,73 @@ function createMemoryTool(config) {
     }
   };
 }
-
 // src/api.ts
 var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_BUDGET_USD = 5;
 function query(params) {
-  const { prompt, options = {} } = params;
+  const { options = {} } = params;
+  const prompt = params.prompt;
+  if (typeof prompt !== "string") {
+    throw new Error("query({ prompt: AsyncIterable }) is not supported in single-prompt mode yet. Use Query.streamInput() in a streaming session.");
+  }
   const providerName = options.provider ?? "anthropic";
   const provider = getProvider(providerName, {
     apiKey: options.apiKey,
     baseUrl: options.baseUrl
   });
   const model = options.model ?? DEFAULT_MODEL;
+  const fallbackModel = options.fallbackModel;
+  const modelState = { current: model };
+  const resolvedThinkingBudget = (() => {
+    if (options.thinking) {
+      switch (options.thinking.type) {
+        case "disabled":
+          return 0;
+        case "enabled":
+          return options.thinking.budgetTokens;
+        case "adaptive":
+          return;
+      }
+    }
+    return options.maxThinkingTokens;
+  })();
+  const maxThinkingTokensState = { current: resolvedThinkingBudget };
+  if (options.permissionMode === "bypassPermissions" && options.allowDangerouslySkipPermissions !== true) {
+    throw new Error('permissionMode "bypassPermissions" requires allowDangerouslySkipPermissions: true');
+  }
   const toolNames = resolveToolNames(options.tools);
   const registry = buildToolRegistry(toolNames, undefined, options.disallowedTools);
-  const systemPrompt = options.systemPrompt ?? buildSystemPrompt({
-    tools: registry.list(),
-    cwd: options.cwd,
-    customPrompt: options.appendSystemPrompt
-  });
+  let skills = [];
+  {
+    const skillsResult = loadSkills({
+      cwd: options.cwd,
+      skillPaths: options.skillPaths,
+      includeDefaults: options.includeDefaultSkills !== false
+    });
+    skills = skillsResult.skills;
+    if (options.debug && skillsResult.diagnostics.length > 0) {
+      for (const d of skillsResult.diagnostics) {
+        console.warn(`[skills] ${d.type}: ${d.message} (${d.path})`);
+      }
+    }
+  }
+  const systemPrompt = (() => {
+    if (typeof options.systemPrompt === "string") {
+      return options.systemPrompt;
+    }
+    const appendedPrompt = typeof options.systemPrompt === "object" ? [options.systemPrompt.append, options.appendSystemPrompt].filter(Boolean).join(`
+
+`) : options.appendSystemPrompt;
+    return buildSystemPrompt({
+      tools: registry.list(),
+      cwd: options.cwd,
+      additionalDirectories: options.additionalDirectories,
+      loadProjectInstructions: Array.isArray(options.settingSources) && options.settingSources.includes("project"),
+      customPrompt: appendedPrompt,
+      skills
+    });
+  })();
   let settingsManager;
   let mergedPermissions = options.permissions;
   if (options.settingSources && options.settingSources.length > 0) {
@@ -3979,7 +5385,7 @@ function query(params) {
       }
     }
   } else if (options.resume) {
-    previousMessages = loadSessionMessages(cwd, options.resume);
+    previousMessages = loadSessionMessages(cwd, options.resume, options.resumeSessionAt);
     if (options.forkSession) {
       sessionId = uuid();
     } else {
@@ -3988,18 +5394,28 @@ function query(params) {
   }
   const persistSession = options.persistSession !== false;
   const sessionLogger = persistSession ? createSessionLogger(cwd, sessionId, model) : undefined;
-  const abortController = new AbortController;
+  const abortController = options.abortController ?? new AbortController;
   if (options.signal) {
     options.signal.addEventListener("abort", () => abortController.abort(), { once: true });
   }
   const hookManager = options.hooks ? new HookManager(options.hooks) : undefined;
   const mcpClient = options.mcpServers && Object.keys(options.mcpServers).length > 0 ? new McpClientManager(options.mcpServers) : undefined;
+  const syncMcpTools = () => {
+    if (!mcpClient)
+      return;
+    registry.clearByPrefix("mcp__");
+    for (const tool of mcpClient.getTools()) {
+      registry.register(tool);
+    }
+    registry.register(createListMcpResourcesTool(mcpClient));
+    registry.register(createReadMcpResourceTool(mcpClient));
+  };
   if (options.agents && Object.keys(options.agents).length > 0) {
     const taskManager = new TaskManager;
     const agentCtx = {
       agents: options.agents,
       parentProvider: provider,
-      parentModel: model,
+      parentModel: modelState.current,
       parentPermissions: permissions,
       parentHooks: hookManager,
       parentCwd: cwd,
@@ -4023,6 +5439,12 @@ function query(params) {
   const generator = agentLoop(prompt, {
     provider,
     model,
+    modelState,
+    maxThinkingTokensState,
+    fallbackModel,
+    thinking: options.thinking,
+    effort: options.effort,
+    outputFormat: options.outputFormat,
     systemPrompt,
     tools: registry,
     permissions,
@@ -4030,7 +5452,7 @@ function query(params) {
     sessionId,
     maxTurns: options.maxTurns ?? DEFAULT_MAX_TURNS,
     maxBudgetUsd: options.maxBudgetUsd ?? DEFAULT_MAX_BUDGET_USD,
-    includeStreamEvents: options.includeStreamEvents ?? false,
+    includePartialMessages: options.includePartialMessages ?? false,
     signal: abortController.signal,
     env: options.env,
     debug: options.debug,
@@ -4038,9 +5460,95 @@ function query(params) {
     mcpClient,
     previousMessages,
     sessionLogger,
-    nativeMemoryTool
+    nativeMemoryTool,
+    initMeta: {
+      betas: options.betas,
+      outputStyle: "default",
+      slashCommands: skills.map((s) => `/${s.name}`),
+      skills: skills.map((s) => s.name),
+      plugins: options.plugins,
+      agents: options.agents ? Object.keys(options.agents) : undefined
+    }
   });
-  return createQuery(generator, abortController);
+  const controls = {
+    async setPermissionMode(mode) {
+      permissions.setMode(mode);
+    },
+    async setModel(nextModel) {
+      modelState.current = nextModel ?? model;
+    },
+    async setMaxThinkingTokens(maxThinkingTokens) {
+      maxThinkingTokensState.current = maxThinkingTokens ?? undefined;
+    },
+    async initializationResult() {
+      const models = provider.listModels ? await provider.listModels() : [];
+      return {
+        commands: skills.map((s) => ({
+          name: s.name,
+          description: s.description,
+          argumentHint: ""
+        })),
+        output_style: "default",
+        available_output_styles: ["default"],
+        models,
+        account: {}
+      };
+    },
+    async supportedCommands() {
+      return skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        argumentHint: ""
+      }));
+    },
+    async supportedModels() {
+      return provider.listModels ? await provider.listModels() : [];
+    },
+    async mcpServerStatus() {
+      return mcpClient ? mcpClient.status() : [];
+    },
+    async accountInfo() {
+      return {
+        tokenSource: options.apiKey ? "api-key" : "runtime",
+        apiKeySource: options.apiKey ? "explicit" : "env_or_oauth"
+      };
+    },
+    async rewindFiles(_userMessageId, _options) {
+      if (!options.enableFileCheckpointing) {
+        return {
+          canRewind: false,
+          error: "File checkpointing is disabled. Set enableFileCheckpointing: true."
+        };
+      }
+      return {
+        canRewind: false,
+        error: "File checkpoint rewind is not implemented in fourmis-agent-sdk yet."
+      };
+    },
+    async reconnectMcpServer(serverName) {
+      if (!mcpClient)
+        throw new Error("No MCP servers are configured for this query.");
+      await mcpClient.reconnectServer(serverName);
+      syncMcpTools();
+    },
+    async toggleMcpServer(serverName, enabled) {
+      if (!mcpClient)
+        throw new Error("No MCP servers are configured for this query.");
+      await mcpClient.toggleServer(serverName, enabled);
+      syncMcpTools();
+    },
+    async setMcpServers(servers) {
+      if (!mcpClient)
+        throw new Error("No MCP client is available for this query.");
+      const result = await mcpClient.setServers(servers);
+      syncMcpTools();
+      return result;
+    },
+    async streamInput() {
+      throw new Error("Query.streamInput is not implemented for single-prompt query mode.");
+    }
+  };
+  return createQuery(generator, abortController, controls);
 }
 
 // src/mcp/server.ts
@@ -4068,25 +5576,37 @@ function createMcpServer(opts) {
   };
 }
 export {
+  stripFrontmatter,
   registerProvider,
   query,
+  parseFrontmatter,
   tool as mcpTool,
+  loadSkillsFromDir,
+  loadSkills,
   getProvider,
+  formatSkillsForPrompt,
   createNativeMemoryTool,
   createMemoryTool,
   createMemoryHandler,
   createMcpServer,
   WriteTool,
+  WebSearchTool,
+  WebFetchTool,
   ToolRegistry,
+  TodoWriteTool,
   TaskManager,
   SettingsManager,
   ReadTool,
   PRESETS,
+  NotebookEditTool,
   McpClientManager,
   HookManager,
   HOOK_EVENTS,
   GrepTool,
   GlobTool,
+  ExitPlanModeTool,
   EditTool,
-  BashTool
+  ConfigTool,
+  BashTool,
+  AskUserQuestionTool
 };