nextclaw-core 0.2.8 → 0.4.0

package/dist/index.js

@@ -93,9 +93,11 @@ var MemoryStore = class {
     this.workspace = workspace;
     this.memoryDir = ensureDir(join(workspace, "memory"));
     this.memoryFile = join(this.memoryDir, "MEMORY.md");
+    this.workspaceMemoryFile = join(workspace, "MEMORY.md");
   }
   memoryDir;
   memoryFile;
+  workspaceMemoryFile;
   getTodayFile() {
     return join(this.memoryDir, `${todayDate()}.md`);
   }
@@ -127,6 +129,12 @@ ${content}`;
     }
     return "";
   }
+  readWorkspaceMemory() {
+    if (existsSync2(this.workspaceMemoryFile)) {
+      return readFileSync(this.workspaceMemoryFile, "utf-8");
+    }
+    return "";
+  }
   writeLongTerm(content) {
     writeFileSync(this.memoryFile, content, "utf-8");
   }
@@ -152,6 +160,11 @@ ${content}`;
   }
   getMemoryContext() {
     const parts = [];
+    const workspaceMemory = this.readWorkspaceMemory();
+    if (workspaceMemory) {
+      parts.push(`## Workspace Memory
+${workspaceMemory}`);
+    }
     const longTerm = this.readLongTerm();
     if (longTerm) {
       parts.push(`## Long-term Memory
@@ -372,27 +385,50 @@ ${this.stripFrontmatter(content)}`);
 };
 
 // src/agent/context.ts
-var BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"];
+var DEFAULT_CONTEXT_CONFIG = {
+  bootstrap: {
+    files: ["AGENTS.md", "SOUL.md", "USER.md", "IDENTITY.md", "TOOLS.md", "BOOT.md", "BOOTSTRAP.md", "HEARTBEAT.md"],
+    minimalFiles: ["AGENTS.md", "SOUL.md", "TOOLS.md", "IDENTITY.md"],
+    heartbeatFiles: ["HEARTBEAT.md"],
+    perFileChars: 4e3,
+    totalChars: 12e3
+  },
+  memory: {
+    enabled: true,
+    maxChars: 8e3
+  }
+};
 var ContextBuilder = class {
-  constructor(workspace) {
+  constructor(workspace, contextConfig) {
     this.workspace = workspace;
     this.memory = new MemoryStore(workspace);
     this.skills = new SkillsLoader(workspace, join3(fileURLToPath2(new URL("..", import.meta.url)), "skills"));
+    this.contextConfig = {
+      bootstrap: {
+        ...DEFAULT_CONTEXT_CONFIG.bootstrap,
+        ...contextConfig?.bootstrap ?? {}
+      },
+      memory: {
+        ...DEFAULT_CONTEXT_CONFIG.memory,
+        ...contextConfig?.memory ?? {}
+      }
+    };
   }
   memory;
   skills;
-  buildSystemPrompt(skillNames) {
+  contextConfig;
+  buildSystemPrompt(skillNames, sessionKey) {
     const parts = [];
     parts.push(this.getIdentity());
-    const bootstrap = this.loadBootstrapFiles();
+    const bootstrap = this.loadBootstrapFiles(sessionKey);
     if (bootstrap) {
-      parts.push(bootstrap);
+      parts.push(`# Workspace Context
+
+${bootstrap}`);
     }
-    const memory = this.memory.getMemoryContext();
+    const memory = this.buildMemorySection();
     if (memory) {
-      parts.push(`# Memory
-
-${memory}`);
+      parts.push(memory);
     }
     const alwaysSkills = this.skills.getAlwaysSkills();
     if (alwaysSkills.length) {
@@ -424,13 +460,17 @@ ${skillsSummary}`);
   }
   buildMessages(params) {
     const messages = [];
-    let systemPrompt = this.buildSystemPrompt(params.skillNames);
+    let systemPrompt = this.buildSystemPrompt(params.skillNames, params.sessionKey);
     if (params.channel && params.chatId) {
       systemPrompt += `
 
 ## Current Session
 Channel: ${params.channel}
 Chat ID: ${params.chatId}`;
+    }
+    if (params.sessionKey) {
+      systemPrompt += `
+Session: ${params.sessionKey}`;
     }
     messages.push({ role: "system", content: systemPrompt });
     messages.push(...params.history);
@@ -462,12 +502,78 @@ Chat ID: ${params.chatId}`;
     const now = (/* @__PURE__ */ new Date()).toLocaleString();
     return `# ${APP_NAME} \u{1F916}
 
-You are ${APP_NAME}, a helpful AI assistant. You have access to tools that allow you to:
-- Read, write, and edit files
-- Execute shell commands
-- Search the web and fetch web pages
-- Send messages to users on chat channels
-- Spawn subagents for complex background tasks
+You are a personal assistant running inside ${APP_NAME}.
+
+## Instruction Priority
+1) System message (this prompt)
+2) AGENTS.md \u2014 operational rules
+3) SOUL.md \u2014 personality and tone
+4) IDENTITY.md \u2014 product identity
+5) USER.md \u2014 user preferences and context
+6) TOOLS.md \u2014 tool usage guidance
+7) BOOT.md / BOOTSTRAP.md \u2014 project context
+8) HEARTBEAT.md \u2014 recurring tasks
+
+If instructions conflict, follow the highest priority source.
+
+## Tooling
+Tool names are case-sensitive. Use only the tools listed here:
+- read_file, write_file, edit_file, list_dir
+- exec (shell commands)
+- web_search, web_fetch
+- message (action=send)
+- sessions_list, sessions_history, sessions_send
+- spawn (create subagent), subagents (list/steer/kill)
+- memory_search, memory_get
+- cron
+- gateway
+
+TOOLS.md does not change tool availability; it is guidance only.
+Do not use exec/curl for provider messaging; use message/sessions_send instead.
+
+## Tool Call Style
+- Default: do not narrate routine, low-risk tool calls.
+- Narrate only when it helps (multi-step work, complex problems, sensitive actions, or if the user asks).
+- Keep narration brief and value-dense.
+
+## Messaging
+- Normal replies go to the current session automatically.
+- Cross-session messaging: use sessions_send(sessionKey, message).
+- Proactive channel send: use message with channel/chatId.
+- Sub-agent orchestration: use subagents(action=list|steer|kill) and spawn.
+- Do not poll subagents list / sessions_list in a loop; only check on-demand.
+- If you use message (action=send) to deliver your user-visible reply, respond with ONLY: NO_REPLY (avoid duplicate replies).
+- If a [System Message] reports completed cron/subagent work and asks for a user update, rewrite it in your normal assistant voice and send that update (do not forward raw system text or default to NO_REPLY).
+
+## Reply Tags
+- [[reply_to_current]] replies to the triggering message.
+- [[reply_to:<id>]] replies to a specific message id.
+- Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).
+- Tags are stripped before sending.
+
+## Memory Recall
+Before answering anything about prior work, decisions, dates, people, preferences, or todos:
+1) Run memory_search on MEMORY.md + memory/*.md.
+2) Use memory_get to pull only the needed lines.
+If low confidence after search, say you checked.
+
+## Silent Replies
+When you have nothing to say, respond with ONLY: NO_REPLY
+- Never append it to a real response.
+- Do not wrap it in quotes or markdown.
+- Correct: NO_REPLY
+- Wrong: "NO_REPLY" or "Here you go... NO_REPLY"
+
+## ${APP_NAME} CLI Quick Reference
+${APP_NAME} is controlled via subcommands. Do not invent commands.
+- ${APP_NAME.toLowerCase()} start | stop | status
+- ${APP_NAME.toLowerCase()} gateway status | start | stop | restart
+If unsure, ask the user to run \`${APP_NAME.toLowerCase()} help\` and paste the output.
+
+## ${APP_NAME} Self-Update
+- Only run update.run when the user explicitly asks for an update.
+- Actions: config.get, config.schema, config.apply (validate + write full config, then restart), config.patch (merge + restart), update.run (update deps or git, then restart).
+- After restart, the last active session will be pinged automatically.
 
 ## Current Time
 ${now}
@@ -481,26 +587,83 @@ Your workspace is at: ${this.workspace}
 - Daily notes: ${this.workspace}/memory/YYYY-MM-DD.md
 - Custom skills: ${this.workspace}/skills/{skill-name}/SKILL.md
 
-IMPORTANT: When responding to direct questions or conversations, reply directly with your text response.
-Only use the 'message' tool when you need to send a message to a specific chat channel (like WhatsApp).
-For normal conversation, just respond with text - do not call the message tool.
-
-Always be helpful, accurate, and concise. When using tools, explain what you're doing.
-When remembering something, write to ${this.workspace}/memory/MEMORY.md`;
+## Behavior
+- For normal conversation, respond with plain text; do not call the message tool.
+- Use the message tool only when you need to send a reply to a specific chat channel.
+- When using tools, briefly explain what you're doing.
+- When remembering something, write to ${this.workspace}/memory/MEMORY.md`;
   }
-  loadBootstrapFiles() {
+  loadBootstrapFiles(sessionKey) {
     const parts = [];
-    for (const filename of BOOTSTRAP_FILES) {
+    const { perFileChars, totalChars } = this.contextConfig.bootstrap;
+    const fileList = this.selectBootstrapFiles(sessionKey);
+    const totalLimit = totalChars > 0 ? totalChars : Number.POSITIVE_INFINITY;
+    let remaining = totalLimit;
+    for (const filename of fileList) {
       const filePath = join3(this.workspace, filename);
       if (existsSync4(filePath)) {
-        const content = readFileSync3(filePath, "utf-8");
+        const raw = readFileSync3(filePath, "utf-8").trim();
+        if (!raw) {
+          continue;
+        }
+        const perFileLimit = perFileChars > 0 ? perFileChars : raw.length;
+        const allowed = Math.min(perFileLimit, remaining);
+        if (allowed <= 0) {
+          break;
+        }
+        const content = this.truncateText(raw, allowed);
         parts.push(`## ${filename}
 
 ${content}`);
+        remaining -= content.length;
+        if (remaining <= 0) {
+          break;
+        }
       }
     }
     return parts.join("\n\n");
   }
+  selectBootstrapFiles(sessionKey) {
+    const { files, minimalFiles, heartbeatFiles } = this.contextConfig.bootstrap;
+    if (!sessionKey) {
+      return files;
+    }
+    if (sessionKey === "heartbeat") {
+      return dedupeStrings([...minimalFiles, ...heartbeatFiles]);
+    }
+    if (sessionKey.startsWith("cron:") || sessionKey.startsWith("subagent:")) {
+      return minimalFiles;
+    }
+    return files;
+  }
+  buildMemorySection() {
+    const memoryConfig = this.contextConfig.memory;
+    if (!memoryConfig.enabled) {
+      return "";
+    }
+    const memory = this.memory.getMemoryContext();
+    if (!memory) {
+      return "";
+    }
+    const truncated = this.truncateText(memory, memoryConfig.maxChars);
+    return `# Memory
+
+${truncated}`;
+  }
+  truncateText(text, limit) {
+    if (limit <= 0 || text.length <= limit) {
+      return text;
+    }
+    const omitted = text.length - limit;
+    const suffix = `
+
+...[truncated ${omitted} chars]`;
+    if (suffix.length >= limit) {
+      return text.slice(0, limit).trimEnd();
+    }
+    const head = text.slice(0, limit - suffix.length).trimEnd();
+    return `${head}${suffix}`;
+  }
   buildUserContent(text, media) {
     if (!media.length) {
       return text;
@@ -532,6 +695,18 @@ function guessImageMime(path) {
   if (ext === ".webp") return "image/webp";
   return null;
 }
+function dedupeStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
 
 // src/agent/tools/registry.ts
 var ToolRegistry = class {
@@ -898,7 +1073,7 @@ function truncateOutput(result, maxLen = 1e4) {
 }
 
 // src/agent/tools/web.ts
-import { fetch } from "undici";
+import { fetch as fetch2 } from "undici";
 var WebSearchTool = class extends Tool {
   constructor(apiKey, maxResults = 5) {
     super();
@@ -930,7 +1105,7 @@ var WebSearchTool = class extends Tool {
     const url = new URL("https://api.search.brave.com/res/v1/web/search");
     url.searchParams.set("q", query);
     url.searchParams.set("count", String(maxResults));
-    const response = await fetch(url.toString(), {
+    const response = await fetch2(url.toString(), {
       headers: {
         "Accept": "application/json",
         "X-Subscription-Token": this.apiKey
@@ -973,7 +1148,7 @@ var WebFetchTool = class extends Tool {
   }
   async execute(params) {
     const url = String(params.url ?? "");
-    const response = await fetch(url, { headers: { "User-Agent": APP_USER_AGENT } });
+    const response = await fetch2(url, { headers: { "User-Agent": APP_USER_AGENT } });
     if (!response.ok) {
       return `Error: Fetch failed (${response.status})`;
     }
@@ -1000,11 +1175,16 @@ var MessageTool = class extends Tool {
     return {
       type: "object",
       properties: {
+        action: { type: "string", enum: ["send"], description: "Action to perform" },
         content: { type: "string", description: "Message to send" },
+        message: { type: "string", description: "Alias for content" },
         channel: { type: "string", description: "Channel name" },
-        chatId: { type: "string", description: "Chat ID" }
+        chatId: { type: "string", description: "Chat ID" },
+        to: { type: "string", description: "Alias for chatId" },
+        replyTo: { type: "string", description: "Message ID to reply to" },
+        silent: { type: "boolean", description: "Send without notification where supported" }
       },
-      required: ["content"]
+      required: []
     };
   }
   setContext(channel, chatId) {
@@ -1012,15 +1192,25 @@ var MessageTool = class extends Tool {
     this.chatId = chatId;
   }
   async execute(params) {
-    const content = String(params.content ?? "");
+    const action = params.action ? String(params.action) : "send";
+    if (action !== "send") {
+      return `Error: Unsupported action '${action}'`;
+    }
+    const content = String(params.content ?? params.message ?? "");
+    if (!content) {
+      return "Error: content/message is required";
+    }
     const channel = String(params.channel ?? this.channel);
-    const chatId = String(params.chatId ?? this.chatId);
+    const chatId = String(params.chatId ?? params.to ?? this.chatId);
+    const replyTo = params.replyTo ? String(params.replyTo) : void 0;
+    const silent = typeof params.silent === "boolean" ? params.silent : void 0;
     await this.sendCallback({
       channel,
       chatId,
       content,
+      replyTo,
       media: [],
-      metadata: {}
+      metadata: silent !== void 0 ? { silent } : {}
     });
     return `Message sent to ${channel}:${chatId}`;
   }
@@ -1129,6 +1319,707 @@ var CronTool = class extends Tool {
   }
 };
 
+// src/agent/tools/sessions.ts
+import crypto from "crypto";
+var DEFAULT_LIMIT = 20;
+var DEFAULT_MESSAGE_LIMIT = 0;
+var MAX_MESSAGE_LIMIT = 20;
+var HISTORY_MAX_BYTES = 80 * 1024;
+var HISTORY_TEXT_MAX_CHARS = 4e3;
+var toInt = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : fallback;
+};
+var parseSessionKey2 = (key) => {
+  const trimmed = key.trim();
+  if (!trimmed.includes(":")) {
+    return null;
+  }
+  const [channel, chatId] = trimmed.split(":", 2);
+  if (!channel || !chatId) {
+    return null;
+  }
+  return { channel, chatId };
+};
+var classifySessionKind = (key) => {
+  if (key.startsWith("cron:") || key === "heartbeat") {
+    return "cron";
+  }
+  if (key.startsWith("hook:")) {
+    return "hook";
+  }
+  if (key.startsWith("subagent:") || key.startsWith("node:")) {
+    return "node";
+  }
+  if (key.startsWith("system:")) {
+    return "other";
+  }
+  return "main";
+};
+var truncateHistoryText = (text) => {
+  if (text.length <= HISTORY_TEXT_MAX_CHARS) {
+    return { text, truncated: false };
+  }
+  return { text: `${text.slice(0, HISTORY_TEXT_MAX_CHARS)}
+\u2026(truncated)\u2026`, truncated: true };
+};
+var sanitizeHistoryMessage = (msg) => {
+  const entry = { ...msg };
+  const res = truncateHistoryText(entry.content ?? "");
+  return { message: { ...entry, content: res.text }, truncated: res.truncated };
+};
+var jsonBytes = (value) => {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return Buffer.byteLength(String(value), "utf8");
+  }
+};
+var enforceHistoryHardCap = (items) => {
+  const bytes = jsonBytes(items);
+  if (bytes <= HISTORY_MAX_BYTES) {
+    return items;
+  }
+  const last = items.at(-1);
+  if (last && jsonBytes([last]) <= HISTORY_MAX_BYTES) {
+    return [last];
+  }
+  return [{ role: "assistant", content: "[sessions_history omitted: message too large]" }];
+};
+var toTimestamp = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+};
+var SessionsListTool = class extends Tool {
+  constructor(sessions) {
+    super();
+    this.sessions = sessions;
+  }
+  get name() {
+    return "sessions_list";
+  }
+  get description() {
+    return "List available sessions with timestamps";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        kinds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by session kinds (main/group/cron/hook/other)"
+        },
+        limit: { type: "integer", minimum: 1, description: "Maximum number of sessions to return" },
+        activeMinutes: { type: "integer", minimum: 1, description: "Only include active sessions" },
+        messageLimit: { type: "integer", minimum: 0, description: "Include last N messages (max 20)" }
+      }
+    };
+  }
+  async execute(params) {
+    const limit = toInt(params.limit, DEFAULT_LIMIT);
+    const rawKinds = Array.isArray(params.kinds) ? params.kinds.map((k) => String(k).toLowerCase()) : [];
+    const kinds = rawKinds.length ? new Set(rawKinds) : null;
+    const activeMinutes = toInt(params.activeMinutes, 0);
+    const messageLimit = Math.min(toInt(params.messageLimit, DEFAULT_MESSAGE_LIMIT), MAX_MESSAGE_LIMIT);
+    const now = Date.now();
+    const sessions = this.sessions.listSessions().sort((a, b) => (toTimestamp(b.updated_at) ?? 0) - (toTimestamp(a.updated_at) ?? 0)).filter((entry) => {
+      if (activeMinutes > 0 && entry.updated_at) {
+        const updated = Date.parse(String(entry.updated_at));
+        if (Number.isFinite(updated) && now - updated > activeMinutes * 60 * 1e3) {
+          return false;
+        }
+      }
+      if (kinds) {
+        const kind = classifySessionKind(String(entry.key ?? ""));
+        if (!kinds.has(kind)) {
+          return false;
+        }
+      }
+      return true;
+    }).slice(0, limit).map((entry) => {
+      const key = String(entry.key ?? "");
+      const kind = classifySessionKind(key);
+      const parsed = parseSessionKey2(key);
+      const metadata = entry.metadata ?? {};
+      const label = typeof metadata.label === "string" ? metadata.label : typeof metadata.session_label === "string" ? metadata.session_label : void 0;
+      const displayName = typeof metadata.displayName === "string" ? metadata.displayName : typeof metadata.display_name === "string" ? metadata.display_name : void 0;
+      const deliveryContext = metadata.deliveryContext && typeof metadata.deliveryContext === "object" ? metadata.deliveryContext : void 0;
+      const updatedAt = toTimestamp(entry.updated_at);
+      const createdAt = toTimestamp(entry.created_at);
+      const base = {
+        key,
+        kind,
+        channel: parsed?.channel,
+        label,
+        displayName,
+        deliveryContext,
+        updatedAt,
+        createdAt,
+        sessionId: key,
+        lastChannel: typeof metadata.last_channel === "string" ? metadata.last_channel : parsed?.channel ?? void 0,
+        lastTo: typeof metadata.last_to === "string" ? metadata.last_to : parsed?.chatId ?? void 0,
+        lastAccountId: typeof metadata.last_account_id === "string" ? metadata.last_account_id : void 0,
+        transcriptPath: entry.path
+      };
+      if (messageLimit > 0) {
+        const session = this.sessions.getIfExists(key);
+        if (session) {
+          const filtered = session.messages.filter((msg) => msg.role !== "tool");
+          const recent = filtered.slice(-messageLimit).map((msg) => ({
+            role: msg.role,
+            content: msg.content,
+            timestamp: msg.timestamp
+          }));
+          const sanitized = recent.map((msg) => sanitizeHistoryMessage(msg).message);
+          base.messages = sanitized;
+        }
+      }
+      return base;
+    });
+    return JSON.stringify({ sessions }, null, 2);
+  }
+};
+var SessionsHistoryTool = class extends Tool {
+  constructor(sessions) {
+    super();
+    this.sessions = sessions;
+  }
+  get name() {
+    return "sessions_history";
+  }
+  get description() {
+    return "Fetch recent messages from a session";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        sessionKey: { type: "string", description: "Session key in the format channel:chatId" },
+        limit: { type: "integer", minimum: 1, description: "Maximum number of messages to return" },
+        includeTools: { type: "boolean", description: "Include tool messages" }
+      },
+      required: ["sessionKey"]
+    };
+  }
+  async execute(params) {
+    const sessionKey = String(params.sessionKey ?? "").trim();
+    if (!sessionKey) {
+      return "Error: sessionKey is required";
+    }
+    let session = this.sessions.getIfExists(sessionKey);
+    if (!session) {
+      const candidates = this.sessions.listSessions();
+      const match = candidates.find((entry) => {
+        const key = typeof entry.key === "string" ? entry.key : "";
+        if (key === sessionKey || key.endsWith(`:${sessionKey}`)) {
+          return true;
+        }
+        const meta = entry.metadata;
+        const metaLabel = meta?.label ?? meta?.session_label;
+        return typeof metaLabel === "string" && metaLabel.trim() === sessionKey;
+      });
+      const resolvedKey = match && typeof match.key === "string" ? match.key : "";
+      if (resolvedKey) {
+        session = this.sessions.getIfExists(resolvedKey);
+      }
+    }
+    if (!session) {
+      return `Error: session '${sessionKey}' not found`;
+    }
+    const limit = toInt(params.limit, DEFAULT_LIMIT);
+    const includeTools = typeof params.includeTools === "boolean" ? params.includeTools : false;
+    const filtered = includeTools ? session.messages : session.messages.filter((msg) => msg.role !== "tool");
+    const recent = filtered.slice(-limit).map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      timestamp: msg.timestamp
+    }));
+    const sanitized = recent.map((msg) => sanitizeHistoryMessage(msg).message);
+    const capped = enforceHistoryHardCap(sanitized);
+    return JSON.stringify({ sessionKey, messages: capped }, null, 2);
+  }
+};
+var SessionsSendTool = class extends Tool {
+  constructor(sessions, bus) {
+    super();
+    this.sessions = sessions;
+    this.bus = bus;
+  }
+  get name() {
+    return "sessions_send";
+  }
+  get description() {
+    return "Send a message to another session (cross-channel delivery)";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        sessionKey: { type: "string", description: "Target session key in the format channel:chatId" },
+        label: { type: "string", description: "Session label (if sessionKey not provided)" },
+        agentId: { type: "string", description: "Optional agent id (unused in local runtime)" },
+        message: { type: "string", description: "Message content to send" },
+        timeoutSeconds: { type: "number", description: "Optional timeout in seconds" },
+        content: { type: "string", description: "Alias for message" },
+        replyTo: { type: "string", description: "Message ID to reply to" },
+        silent: { type: "boolean", description: "Send without notification where supported" }
+      },
+      required: []
+    };
+  }
+  async execute(params) {
+    const runId = crypto.randomUUID();
+    const sessionKeyParam = String(params.sessionKey ?? "").trim();
+    const labelParam = String(params.label ?? "").trim();
+    if (sessionKeyParam && labelParam) {
+      return JSON.stringify(
+        { runId, status: "error", error: "Provide either sessionKey or label (not both)" },
+        null,
+        2
+      );
+    }
+    let sessionKey = sessionKeyParam;
+    const message = String(params.message ?? params.content ?? "");
+    if (!message) {
+      return JSON.stringify({ runId, status: "error", error: "message is required" }, null, 2);
+    }
+    if (!sessionKey) {
+      const label = labelParam;
+      if (!label) {
+        return JSON.stringify({ runId, status: "error", error: "sessionKey or label is required" }, null, 2);
+      }
+      const candidates = this.sessions.listSessions();
+      const match = candidates.find((entry) => {
+        const key = typeof entry.key === "string" ? entry.key : "";
+        if (key === label || key.endsWith(`:${label}`)) {
+          return true;
+        }
+        const meta = entry.metadata;
+        const metaLabel = meta?.label ?? meta?.session_label;
+        return typeof metaLabel === "string" && metaLabel.trim() === label;
+      });
+      sessionKey = match && typeof match.key === "string" ? match.key : "";
+      if (!sessionKey) {
+        return JSON.stringify(
+          { runId, status: "error", error: `no session found for label '${label}'` },
+          null,
+          2
+        );
+      }
+    }
+    const parsed = parseSessionKey2(sessionKey);
+    if (!parsed) {
+      return JSON.stringify(
+        { runId, status: "error", error: "sessionKey must be in the format channel:chatId" },
+        null,
+        2
+      );
+    }
+    const replyTo = params.replyTo ? String(params.replyTo) : void 0;
+    const silent = typeof params.silent === "boolean" ? params.silent : void 0;
+    const outbound = {
+      channel: parsed.channel,
+      chatId: parsed.chatId,
+      content: message,
+      replyTo,
+      media: [],
+      metadata: silent !== void 0 ? { silent } : {}
+    };
+    await this.bus.publishOutbound(outbound);
+    const session = this.sessions.getOrCreate(sessionKey);
+    this.sessions.addMessage(session, "assistant", message, { via: "sessions_send" });
+    this.sessions.save(session);
+    return JSON.stringify(
+      { runId, status: "ok", sessionKey: `${parsed.channel}:${parsed.chatId}` },
+      null,
+      2
+    );
+  }
+};
+
+// src/agent/tools/memory.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
+import { join as join4, resolve as resolve4 } from "path";
+var DEFAULT_LIMIT2 = 20;
+var DEFAULT_CONTEXT_LINES = 0;
+var toInt2 = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : fallback;
+};
+var normalizeQuery = (value) => String(value ?? "").trim();
+var isWithin = (child, parent) => {
+  const resolvedChild = resolve4(child);
+  const resolvedParent = resolve4(parent);
+  return resolvedChild === resolvedParent || resolvedChild.startsWith(`${resolvedParent}/`);
+};
+var getMemoryFiles = (workspace) => {
+  const files = [];
+  const workspaceMemory = join4(workspace, "MEMORY.md");
+  if (existsSync6(workspaceMemory)) {
+    files.push(workspaceMemory);
+  }
+  const memoryDir = join4(workspace, "memory");
+  if (existsSync6(memoryDir)) {
+    const entries = readdirSync4(memoryDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) {
+        continue;
+      }
+      files.push(join4(memoryDir, entry));
+    }
+  }
+  return files;
+};
+var MemorySearchTool = class extends Tool {
+  constructor(workspace) {
+    super();
+    this.workspace = workspace;
+  }
+  get name() {
+    return "memory_search";
+  }
+  get description() {
+    return "Mandatory recall step: search MEMORY.md + memory/*.md; returns snippets with path + lines.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        maxResults: { type: "integer", minimum: 1, description: "Maximum number of matches to return" },
+        minScore: { type: "number", description: "Minimum score (ignored for local search)" }
+      },
+      required: ["query"]
+    };
+  }
+  async execute(params) {
+    const query = normalizeQuery(params.query);
+    if (!query) {
+      return "Error: query is required";
+    }
+    const limit = toInt2(params.maxResults ?? params.limit, DEFAULT_LIMIT2);
+    const contextLines = toInt2(params.contextLines, DEFAULT_CONTEXT_LINES);
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    const files = getMemoryFiles(this.workspace);
+    for (const filePath of files) {
+      const content = readFileSync5(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i += 1) {
+        if (lines[i].toLowerCase().includes(lowerQuery)) {
+          const start = Math.max(0, i - contextLines);
+          const end = Math.min(lines.length, i + contextLines + 1);
+          const snippet = lines.slice(start, end).join("\n");
+          results.push({ path: filePath, line: i + 1, text: snippet, score: 1 });
+          if (results.length >= limit) {
+            return JSON.stringify(
+              { results, provider: "local", model: "regex", fallback: false, citations: "off" },
+              null,
+              2
+            );
+          }
+        }
+      }
+    }
+    return JSON.stringify(
+      { results, provider: "local", model: "regex", fallback: false, citations: "off" },
+      null,
+      2
+    );
+  }
+};
+var MemoryGetTool = class extends Tool {
+  constructor(workspace) {
+    super();
+    this.workspace = workspace;
+  }
+  get name() {
+    return "memory_get";
+  }
+  get description() {
+    return "Safe snippet read from MEMORY.md or memory/*.md; use after memory_search.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to memory file (relative or absolute)" },
+        from: { type: "integer", minimum: 1, description: "Start line (1-based)" },
+        lines: { type: "integer", minimum: 1, description: "Number of lines to read" }
+      },
+      required: ["path"]
+    };
+  }
+  async execute(params) {
+    const pathParam = String(params.path ?? "").trim();
+    if (!pathParam) {
+      return "Error: path is required";
+    }
+    const resolvedPath = resolve4(this.workspace, pathParam);
+    const memoryDir = join4(this.workspace, "memory");
+    const workspaceMemory = join4(this.workspace, "MEMORY.md");
+    if (!isWithin(resolvedPath, this.workspace)) {
+      return "Error: path must be within workspace";
+    }
+    if (!(resolvedPath === resolve4(workspaceMemory) || isWithin(resolvedPath, memoryDir))) {
+      return "Error: path must be MEMORY.md or memory/*.md within workspace";
+    }
+    if (!existsSync6(resolvedPath)) {
+      return `Error: file not found: ${resolvedPath}`;
+    }
+    const content = readFileSync5(resolvedPath, "utf-8");
+    const lines = content.split("\n");
+    const startLine = toInt2(params.from ?? params.startLine, 1);
+    const requestedLines = toInt2(params.lines ?? params.endLine, Math.max(lines.length - startLine + 1, 1));
+    const endLine = Math.min(lines.length, startLine + requestedLines - 1);
+    const startIdx = Math.max(0, startLine - 1);
+    const endIdx = Math.min(lines.length, endLine);
+    const selected = lines.slice(startIdx, endIdx);
+    const numbered = selected.map((line, idx) => `${startIdx + idx + 1}: ${line}`);
+    return JSON.stringify(
+      { path: pathParam, from: startLine, lines: endIdx - startIdx, text: numbered.join("\n") },
+      null,
+      2
+    );
+  }
+};
+
+// src/agent/tools/gateway.ts
+var GatewayTool = class extends Tool {
+  constructor(controller) {
+    super();
+    this.controller = controller;
+  }
+  get name() {
+    return "gateway";
+  }
+  get description() {
+    return "Restart or update gateway config (config.get/schema/apply/patch) and trigger restart.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "restart",
+            "config.get",
+            "config.schema",
+            "config.apply",
+            "config.patch",
+            "update.run"
+          ],
+          description: "Action to perform"
+        },
+        delayMs: { type: "number", description: "Restart delay (ms)" },
+        reason: { type: "string", description: "Optional reason for the action" },
+        gatewayUrl: { type: "string", description: "Optional gateway url (unused in local runtime)" },
+        gatewayToken: { type: "string", description: "Optional gateway token (unused in local runtime)" },
+        timeoutMs: { type: "number", description: "Optional timeout (ms)" },
+        raw: { type: "string", description: "Raw config JSON string for apply/patch" },
+        baseHash: { type: "string", description: "Config base hash (from config.get)" },
+        sessionKey: { type: "string", description: "Session key for restart notification" },
+        note: { type: "string", description: "Completion note for config apply/patch" },
+        restartDelayMs: { type: "number", description: "Restart delay after apply/patch (ms)" }
+      },
+      required: ["action"]
+    };
+  }
+  async execute(params) {
+    const action = String(params.action ?? "");
+    if (!this.controller) {
+      return JSON.stringify({ ok: false, error: "gateway controller not available in this runtime" }, null, 2);
+    }
+    if (action === "config.get") {
+      if (!this.controller.getConfig) {
+        return JSON.stringify({ ok: false, error: "config.get not supported" }, null, 2);
+      }
+      const result = await this.controller.getConfig();
+      return JSON.stringify({ ok: true, result }, null, 2);
+    }
+    if (action === "config.schema") {
+      if (!this.controller.getConfigSchema) {
+        return JSON.stringify({ ok: false, error: "config.schema not supported" }, null, 2);
+      }
+      const result = await this.controller.getConfigSchema();
+      return JSON.stringify({ ok: true, result }, null, 2);
+    }
+    if (action === "config.apply" || action === "config.patch") {
+      const raw = params.raw;
+      if (typeof raw !== "string" || !raw.trim()) {
+        return JSON.stringify({ ok: false, error: "raw config string is required" }, null, 2);
+      }
+      const note = typeof params.note === "string" ? params.note.trim() || void 0 : void 0;
+      const restartDelayMs = typeof params.restartDelayMs === "number" && Number.isFinite(params.restartDelayMs) ? Math.floor(params.restartDelayMs) : void 0;
+      let baseHash = typeof params.baseHash === "string" && params.baseHash.trim() ? params.baseHash.trim() : void 0;
+      if (!baseHash && this.controller.getConfig) {
+        const snapshot = await this.controller.getConfig();
+        if (snapshot && typeof snapshot === "object") {
+          const hashValue = snapshot.hash;
+          if (typeof hashValue === "string" && hashValue.trim()) {
+            baseHash = hashValue.trim();
+          }
+        }
+      }
+      const sessionKey = typeof params.sessionKey === "string" && params.sessionKey.trim() ? params.sessionKey.trim() : void 0;
+      if (action === "config.apply") {
+        if (!this.controller.applyConfig) {
+          return JSON.stringify({ ok: false, error: "config.apply not supported" }, null, 2);
+        }
+        const result2 = await this.controller.applyConfig({
+          raw,
+          baseHash,
+          note,
+          restartDelayMs,
+          sessionKey
+        });
+        return JSON.stringify({ ok: true, result: result2 }, null, 2);
+      }
+      if (!this.controller.patchConfig) {
+        return JSON.stringify({ ok: false, error: "config.patch not supported" }, null, 2);
+      }
+      const result = await this.controller.patchConfig({
+        raw,
+        baseHash,
+        note,
+        restartDelayMs,
+        sessionKey
+      });
+      return JSON.stringify({ ok: true, result }, null, 2);
+    }
+    if (action === "restart") {
+      if (!this.controller.restart) {
+        return JSON.stringify({ ok: false, error: "restart not supported" }, null, 2);
+      }
+      const delayMs = typeof params.delayMs === "number" && Number.isFinite(params.delayMs) ? Math.floor(params.delayMs) : void 0;
+      const reason = typeof params.reason === "string" ? params.reason.trim() || void 0 : void 0;
+      const result = await this.controller.restart({ delayMs, reason });
+      return JSON.stringify({ ok: true, result: result ?? "Restart scheduled" }, null, 2);
+    }
+    if (action === "update.run") {
+      if (!this.controller.updateRun) {
+        return JSON.stringify({ ok: false, error: "update.run not supported in this runtime" }, null, 2);
+      }
+      const restartDelayMs = typeof params.restartDelayMs === "number" && Number.isFinite(params.restartDelayMs) ? Math.floor(params.restartDelayMs) : void 0;
+      const timeoutMs = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs) ? Math.max(1, Math.floor(params.timeoutMs)) : void 0;
+      const sessionKey = typeof params.sessionKey === "string" && params.sessionKey.trim() ? params.sessionKey.trim() : void 0;
+      const note = typeof params.note === "string" ? params.note.trim() || void 0 : void 0;
+      const result = await this.controller.updateRun({ note, restartDelayMs, timeoutMs, sessionKey });
+      return JSON.stringify({ ok: true, result }, null, 2);
+    }
+    return JSON.stringify({ ok: false, error: `Unknown action: ${action}` }, null, 2);
+  }
+};
+
+// src/agent/tools/subagents.ts
+var SubagentsTool = class extends Tool {
+  constructor(manager) {
+    super();
+    this.manager = manager;
+  }
+  get name() {
+    return "subagents";
+  }
+  get description() {
+    return "Manage running subagents (list/steer/kill)";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "kill", "steer"],
+          description: "Action to perform"
+        },
+        target: { type: "string", description: "Subagent target (id/label/last/index)" },
+        message: { type: "string", description: "Steer instruction for a running subagent" },
+        recentMinutes: { type: "number", description: "Only list recent runs" },
+        id: { type: "string", description: "Alias for target" },
+        note: { type: "string", description: "Alias for message" }
+      },
+      required: ["action"]
+    };
+  }
+  async execute(params) {
+    const action = String(params.action ?? "");
+    if (action === "list") {
+      const recentMinutes = typeof params.recentMinutes === "number" && Number.isFinite(params.recentMinutes) ? Math.max(1, Math.floor(params.recentMinutes)) : null;
+      const runs = this.manager.listRuns();
+      const now = Date.now();
+      const filtered = recentMinutes ? runs.filter((run) => {
+        const startedAt = Date.parse(run.startedAt);
+        const doneAt = run.doneAt ? Date.parse(run.doneAt) : NaN;
+        const ts = Number.isFinite(doneAt) ? doneAt : startedAt;
+        return Number.isFinite(ts) && now - ts <= recentMinutes * 60 * 1e3;
+      }) : runs;
+      return JSON.stringify({ runs: filtered }, null, 2);
+    }
+    if (action === "kill") {
+      const target = String(params.target ?? params.id ?? "").trim();
+      if (!target) {
+        return "Error: target is required for kill";
+      }
+      const resolved = resolveTarget(target, this.manager.listRuns());
+      if (!resolved) {
+        return `Error: subagent not found (${target})`;
+      }
+      const ok = this.manager.cancelRun(resolved.id);
+      return ok ? `Subagent ${resolved.id} killed` : `Subagent ${resolved.id} not found`;
+    }
+    if (action === "steer") {
+      const target = String(params.target ?? params.id ?? "").trim();
+      const note = String(params.message ?? params.note ?? "").trim();
+      if (!target || !note) {
+        return "Error: target and message are required for steer";
+      }
+      const resolved = resolveTarget(target, this.manager.listRuns());
+      if (!resolved) {
+        return `Error: subagent not found (${target})`;
+      }
+      const ok = this.manager.steerRun(resolved.id, note);
+      return ok ? `Subagent ${resolved.id} steer applied` : `Subagent ${resolved.id} not running`;
+    }
+    return "Error: invalid action";
+  }
+};
+function resolveTarget(token, runs) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const sorted = [...runs].sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
+  if (trimmed === "last") {
+    return sorted[0] ?? null;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const idx = Number.parseInt(trimmed, 10);
+    if (Number.isFinite(idx) && idx > 0 && idx <= sorted.length) {
+      return sorted[idx - 1];
+    }
+  }
+  const byId = runs.find((run) => run.id === trimmed);
+  if (byId) {
+    return byId;
+  }
+  const lower = trimmed.toLowerCase();
+  const byLabel = runs.filter((run) => run.label.toLowerCase() === lower);
+  if (byLabel.length === 1) {
+    return byLabel[0];
+  }
+  return null;
+}
+
 // src/agent/subagent.ts
 import { randomUUID } from "crypto";
 var SubagentManager = class {
@@ -1136,6 +2027,8 @@ var SubagentManager = class {
     this.options = options;
   }
   runningTasks = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
+  steerQueue = /* @__PURE__ */ new Map();
   async spawn(params) {
     const taskId = randomUUID().slice(0, 8);
     const displayLabel = params.label ?? `${params.task.slice(0, 30)}${params.task.length > 30 ? "..." : ""}`;
@@ -1143,6 +2036,16 @@ var SubagentManager = class {
       channel: params.originChannel ?? "cli",
       chatId: params.originChatId ?? "direct"
     };
+    this.runs.set(taskId, {
+      id: taskId,
+      label: displayLabel,
+      task: params.task,
+      origin,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      cancelled: false
+    });
+    this.steerQueue.set(taskId, []);
     const background = this.runSubagent({
       taskId,
       task: params.task,
@@ -1150,11 +2053,23 @@ var SubagentManager = class {
       origin
     });
     this.runningTasks.set(taskId, background);
-    background.finally(() => this.runningTasks.delete(taskId));
+    background.finally(() => {
+      this.runningTasks.delete(taskId);
+      const run = this.runs.get(taskId);
+      if (run && run.status === "running") {
+        run.status = run.cancelled ? "cancelled" : "done";
+        run.doneAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      this.steerQueue.delete(taskId);
+    });
     return `Subagent [${displayLabel}] started (id: ${taskId}). I'll notify you when it completes.`;
   }
   async runSubagent(params) {
     try {
+      const run = this.runs.get(params.taskId);
+      if (run?.cancelled) {
+        return;
+      }
       const tools = new ToolRegistry();
       const allowedDir = this.options.restrictToWorkspace ? this.options.workspace : void 0;
       tools.register(new ReadFileTool(allowedDir));
@@ -1178,7 +2093,13 @@ var SubagentManager = class {
       let finalResult = null;
       while (iteration < 15) {
         iteration += 1;
-        const response = await this.options.provider.chat({
+        const queued = this.steerQueue.get(params.taskId);
+        if (queued && queued.length) {
+          for (const note of queued.splice(0, queued.length)) {
+            messages.push({ role: "user", content: `Steer: ${note}` });
+          }
+        }
+        const response = await this.options.providerManager.get().chat({
           messages,
           tools: tools.getDefinitions(),
           model: this.options.model
@@ -1201,25 +2122,38 @@ var SubagentManager = class {
           finalResult = response.content ?? "";
           break;
         }
+        if (this.runs.get(params.taskId)?.cancelled) {
+          return;
+        }
       }
       if (!finalResult) {
         finalResult = "Task completed but no final response was generated.";
       }
-      await this.announceResult({
-        label: params.label,
-        task: params.task,
-        result: finalResult,
-        origin: params.origin,
-        status: "ok"
-      });
+      const runAfter = this.runs.get(params.taskId);
+      if (runAfter && !runAfter.cancelled) {
+        runAfter.status = "done";
+        runAfter.doneAt = (/* @__PURE__ */ new Date()).toISOString();
+        await this.announceResult({
+          label: params.label,
+          task: params.task,
+          result: finalResult,
+          origin: params.origin,
+          status: "ok"
+        });
+      }
     } catch (err) {
-      await this.announceResult({
-        label: params.label,
-        task: params.task,
-        result: `Error: ${String(err)}`,
-        origin: params.origin,
-        status: "error"
-      });
+      const runAfter = this.runs.get(params.taskId);
+      if (runAfter && !runAfter.cancelled) {
+        runAfter.status = "error";
+        runAfter.doneAt = (/* @__PURE__ */ new Date()).toISOString();
+        await this.announceResult({
+          label: params.label,
+          task: params.task,
+          result: `Error: ${String(err)}`,
+          origin: params.origin,
+          status: "error"
+        });
+      }
     }
   }
   async announceResult(params) {
@@ -1276,11 +2210,43 @@ When you have completed the task, provide a clear summary of your findings or ac
   getRunningCount() {
     return this.runningTasks.size;
   }
+  listRuns() {
+    return Array.from(this.runs.values()).map((run) => ({
+      id: run.id,
+      label: run.label,
+      status: run.status,
+      startedAt: run.startedAt,
+      doneAt: run.doneAt
+    }));
+  }
+  steerRun(id, note) {
+    const run = this.runs.get(id);
+    if (!run || run.cancelled || run.status !== "running") {
+      return false;
+    }
+    const queue = this.steerQueue.get(id);
+    if (!queue) {
+      return false;
+    }
+    queue.push(note);
+    return true;
+  }
+  cancelRun(id) {
+    const run = this.runs.get(id);
+    if (!run) {
+      return false;
+    }
+    run.cancelled = true;
+    run.status = "cancelled";
+    run.doneAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.steerQueue.delete(id);
+    return true;
+  }
 };
 
 // src/session/manager.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6, readdirSync as readdirSync4, unlinkSync } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7, readdirSync as readdirSync5, unlinkSync } from "fs";
+import { join as join5 } from "path";
 var SessionManager = class {
   constructor(workspace) {
     this.workspace = workspace;
@@ -1290,7 +2256,7 @@ var SessionManager = class {
   cache = /* @__PURE__ */ new Map();
   getSessionPath(key) {
     const safeKey = safeFilename(key.replace(/:/g, "_"));
-    return join4(this.sessionsDir, `${safeKey}.jsonl`);
+    return join5(this.sessionsDir, `${safeKey}.jsonl`);
   }
   getOrCreate(key) {
     const cached = this.cache.get(key);
@@ -1308,6 +2274,17 @@ var SessionManager = class {
     this.cache.set(key, session);
     return session;
   }
+  getIfExists(key) {
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const loaded = this.load(key);
+    if (loaded) {
+      this.cache.set(key, loaded);
+    }
+    return loaded;
+  }
   addMessage(session, role, content, extra = {}) {
     const msg = {
       role,
@@ -1328,11 +2305,11 @@ var SessionManager = class {
   }
   load(key) {
     const path = this.getSessionPath(key);
-    if (!existsSync6(path)) {
+    if (!existsSync7(path)) {
       return null;
     }
     try {
-      const lines = readFileSync5(path, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync6(path, "utf-8").split("\n").filter(Boolean);
       const messages = [];
       let metadata = {};
       let createdAt = /* @__PURE__ */ new Date();
@@ -1378,7 +2355,7 @@ var SessionManager = class {
   delete(key) {
     this.cache.delete(key);
     const path = this.getSessionPath(key);
-    if (existsSync6(path)) {
+    if (existsSync7(path)) {
       unlinkSync(path);
       return true;
     }
@@ -1386,12 +2363,12 @@ var SessionManager = class {
   }
   listSessions() {
     const sessions = [];
-    for (const entry of readdirSync4(this.sessionsDir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(this.sessionsDir, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
         continue;
       }
-      const path = join4(this.sessionsDir, entry.name);
-      const firstLine = readFileSync5(path, "utf-8").split("\n")[0];
+      const path = join5(this.sessionsDir, entry.name);
+      const firstLine = readFileSync6(path, "utf-8").split("\n")[0];
       if (!firstLine) {
         continue;
       }
@@ -1402,7 +2379,8 @@ var SessionManager = class {
             key: entry.name.replace(/\.jsonl$/, "").replace(/_/g, ":"),
             created_at: data.created_at,
             updated_at: data.updated_at,
-            path
+            path,
+            metadata: data.metadata ?? {}
           });
         }
       } catch {
@@ -1413,18 +2391,34 @@ var SessionManager = class {
   }
 };
 
+// src/agent/tokens.ts
+var SILENT_REPLY_TOKEN = "NO_REPLY";
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isSilentReplyText(text, token = SILENT_REPLY_TOKEN) {
+  if (!text) {
+    return false;
+  }
+  const escaped = escapeRegExp(token);
+  const prefix = new RegExp(`^\\s*${escaped}(?=$|\\W)`);
+  if (prefix.test(text)) {
+    return true;
+  }
+  const suffix = new RegExp(`\\b${escaped}\\b\\W*$`);
+  return suffix.test(text);
+}
+
 // src/agent/loop.ts
 var AgentLoop = class {
   constructor(options) {
     this.options = options;
-    this.context = new ContextBuilder(options.workspace);
+    this.context = new ContextBuilder(options.workspace, options.contextConfig);
     this.sessions = options.sessionManager ?? new SessionManager(options.workspace);
     this.tools = new ToolRegistry();
     this.subagents = new SubagentManager({
-      provider: options.provider,
+      providerManager: options.providerManager,
       workspace: options.workspace,
       bus: options.bus,
-      model: options.model ?? options.provider.getDefaultModel(),
+      model: options.model ?? options.providerManager.get().getDefaultModel(),
       braveApiKey: options.braveApiKey ?? void 0,
       execConfig: options.execConfig ?? { timeout: 60 },
       restrictToWorkspace: options.restrictToWorkspace ?? false
@@ -1455,6 +2449,13 @@ var AgentLoop = class {
     this.tools.register(messageTool);
     const spawnTool = new SpawnTool(this.subagents);
     this.tools.register(spawnTool);
+    this.tools.register(new SessionsListTool(this.sessions));
+    this.tools.register(new SessionsHistoryTool(this.sessions));
+    this.tools.register(new SessionsSendTool(this.sessions, this.options.bus));
+    this.tools.register(new MemorySearchTool(this.options.workspace));
+    this.tools.register(new MemoryGetTool(this.options.workspace));
+    this.tools.register(new SubagentsTool(this.subagents));
+    this.tools.register(new GatewayTool(this.options.gatewayController));
     if (this.options.cronService) {
       const cronTool = new CronTool(this.options.cronService);
       this.tools.register(cronTool);
@@ -1502,6 +2503,20 @@ var AgentLoop = class {
     }
     const sessionKey = sessionKeyOverride ?? `${msg.channel}:${msg.chatId}`;
     const session = this.sessions.getOrCreate(sessionKey);
+    const messageId = msg.metadata?.message_id;
+    if (messageId) {
+      session.metadata.last_message_id = messageId;
+    }
+    const sessionLabel = msg.metadata?.session_label;
+    if (sessionLabel) {
+      session.metadata.label = sessionLabel;
+    }
+    session.metadata.last_channel = msg.channel;
+    session.metadata.last_to = msg.chatId;
+    const accountId = msg.metadata?.account_id ?? msg.metadata?.accountId;
+    if (accountId) {
+      session.metadata.last_account_id = accountId;
+    }
     const messageTool = this.tools.get("message");
     if (messageTool instanceof MessageTool) {
       messageTool.setContext(msg.channel, msg.chatId);
@@ -1519,14 +2534,15 @@ var AgentLoop = class {
       currentMessage: msg.content,
       media: msg.media,
       channel: msg.channel,
-      chatId: msg.chatId
+      chatId: msg.chatId,
+      sessionKey
     });
     let iteration = 0;
     let finalContent = null;
     const maxIterations = this.options.maxIterations ?? 20;
     while (iteration < maxIterations) {
       iteration += 1;
-      const response = await this.options.provider.chat({
+      const response = await this.options.providerManager.get().chat({
         messages,
         tools: this.tools.getDefinitions(),
         model: this.options.model ?? void 0
@@ -1553,6 +2569,13 @@ var AgentLoop = class {
     if (!finalContent) {
       finalContent = "I've completed processing but have no response to give.";
     }
+    const { content: cleanedContent, replyTo } = parseReplyTags(finalContent, messageId);
+    finalContent = cleanedContent;
+    if (isSilentReplyText(finalContent, SILENT_REPLY_TOKEN)) {
+      this.sessions.addMessage(session, "user", msg.content);
+      this.sessions.save(session);
+      return null;
+    }
     this.sessions.addMessage(session, "user", msg.content);
     this.sessions.addMessage(session, "assistant", finalContent);
     this.sessions.save(session);
@@ -1560,6 +2583,7 @@ var AgentLoop = class {
       channel: msg.channel,
       chatId: msg.chatId,
       content: finalContent,
+      replyTo,
       media: [],
       metadata: msg.metadata ?? {}
     };
@@ -1584,14 +2608,15 @@ var AgentLoop = class {
       history: this.sessions.getHistory(session),
       currentMessage: msg.content,
       channel: originChannel,
-      chatId: originChatId
+      chatId: originChatId,
+      sessionKey
     });
     let iteration = 0;
     let finalContent = null;
     const maxIterations = this.options.maxIterations ?? 20;
     while (iteration < maxIterations) {
       iteration += 1;
-      const response = await this.options.provider.chat({
+      const response = await this.options.providerManager.get().chat({
         messages,
         tools: this.tools.getDefinitions(),
         model: this.options.model ?? void 0
@@ -1618,6 +2643,11 @@ var AgentLoop = class {
     if (!finalContent) {
       finalContent = "Background task completed.";
     }
+    const { content: cleanedContent, replyTo } = parseReplyTags(finalContent, void 0);
+    finalContent = cleanedContent;
+    if (isSilentReplyText(finalContent, SILENT_REPLY_TOKEN)) {
+      return null;
+    }
     this.sessions.addMessage(session, "user", `[System: ${msg.senderId}] ${msg.content}`);
     this.sessions.addMessage(session, "assistant", finalContent);
     this.sessions.save(session);
@@ -1625,11 +2655,27 @@ var AgentLoop = class {
       channel: originChannel,
       chatId: originChatId,
       content: finalContent,
+      replyTo,
       media: [],
       metadata: {}
     };
   }
 };
+function parseReplyTags(content, currentMessageId) {
+  let replyTo;
+  const replyCurrent = /\[\[\s*reply_to_current\s*\]\]/gi;
+  if (replyCurrent.test(content)) {
+    replyTo = currentMessageId;
+    content = content.replace(replyCurrent, "").trim();
+  }
+  const replyId = /\[\[\s*reply_to\s*:\s*([^\]]+?)\s*\]\]/i;
+  const match = content.match(replyId);
+  if (match && match[1]) {
+    replyTo = match[1].trim();
+    content = content.replace(replyId, "").trim();
+  }
+  return { content, replyTo };
+}
 
 // src/bus/queue.ts
 var AsyncQueue = class {
@@ -1647,8 +2693,8 @@ var AsyncQueue = class {
     if (this.items.length > 0) {
       return this.items.shift();
     }
-    return new Promise((resolve5) => {
-      this.waiters.push(resolve5);
+    return new Promise((resolve6) => {
+      this.waiters.push(resolve6);
     });
   }
   size() {
@@ -1798,9 +2844,9 @@ var BaseChannel = class {
 };
 
 // src/providers/transcription.ts
-import { createReadStream, existsSync as existsSync7 } from "fs";
+import { createReadStream, existsSync as existsSync8 } from "fs";
 import { basename } from "path";
-import { FormData, fetch as fetch2 } from "undici";
+import { FormData, fetch as fetch3 } from "undici";
 var GroqTranscriptionProvider = class {
   apiKey;
   apiUrl = "https://api.groq.com/openai/v1/audio/transcriptions";
@@ -1811,13 +2857,13 @@ var GroqTranscriptionProvider = class {
     if (!this.apiKey) {
       return "";
     }
-    if (!existsSync7(filePath)) {
+    if (!existsSync8(filePath)) {
       return "";
     }
     const form = new FormData();
     form.append("file", createReadStream(filePath), basename(filePath));
     form.append("model", "whisper-large-v3");
-    const response = await fetch2(this.apiUrl, {
+    const response = await fetch3(this.apiUrl, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`
@@ -1833,7 +2879,7 @@ var GroqTranscriptionProvider = class {
 };
 
 // src/channels/telegram.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
 var BOT_COMMANDS = [
   { command: "start", description: "Start the bot" },
@@ -1920,10 +2966,20 @@ Just send me a text message to chat!`;
     }
     this.stopTyping(msg.chatId);
     const htmlContent = markdownToTelegramHtml(msg.content ?? "");
+    const silent = msg.metadata?.silent === true;
+    const replyTo = msg.replyTo ? Number(msg.replyTo) : void 0;
+    const options = {
+      parse_mode: "HTML",
+      ...replyTo ? { reply_to_message_id: replyTo } : {},
+      ...silent ? { disable_notification: true } : {}
+    };
     try {
-      await this.bot.sendMessage(Number(msg.chatId), htmlContent, { parse_mode: "HTML" });
+      await this.bot.sendMessage(Number(msg.chatId), htmlContent, options);
     } catch {
-      await this.bot.sendMessage(Number(msg.chatId), msg.content ?? "");
+      await this.bot.sendMessage(Number(msg.chatId), msg.content ?? "", {
+        ...replyTo ? { reply_to_message_id: replyTo } : {},
+        ...silent ? { disable_notification: true } : {}
+      });
     }
   }
   async handleIncoming(message) {
@@ -1945,7 +3001,7 @@ Just send me a text message to chat!`;
     }
     const { fileId, mediaType, mimeType } = resolveMedia(message);
     if (fileId && mediaType) {
-      const mediaDir = join5(getDataPath(), "media");
+      const mediaDir = join6(getDataPath(), "media");
       mkdirSync2(mediaDir, { recursive: true });
       const extension = getExtension(mediaType, mimeType);
       const downloaded = await this.bot.downloadFile(fileId, mediaDir);
@@ -2077,7 +3133,7 @@ var WhatsAppChannel = class extends BaseChannel {
     const bridgeUrl = this.config.bridgeUrl;
     while (this.running) {
       try {
-        await new Promise((resolve5, reject) => {
+        await new Promise((resolve6, reject) => {
           const ws = new WebSocket(bridgeUrl);
           this.ws = ws;
           ws.on("open", () => {
@@ -2090,7 +3146,7 @@ var WhatsAppChannel = class extends BaseChannel {
           ws.on("close", () => {
             this.connected = false;
             this.ws = null;
-            resolve5();
+            resolve6();
           });
           ws.on("error", (_err) => {
             this.connected = false;
@@ -2173,17 +3229,18 @@ var WhatsAppChannel = class extends BaseChannel {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 
 // src/channels/discord.ts
 import {
   Client as Client2,
   GatewayIntentBits,
-  Partials
+  Partials,
+  MessageFlags
 } from "discord.js";
-import { fetch as fetch3 } from "undici";
-import { join as join6 } from "path";
+import { fetch as fetch4 } from "undici";
+import { join as join7 } from "path";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
 var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 var DiscordChannel = class extends BaseChannel {
@@ -2237,6 +3294,9 @@ var DiscordChannel = class extends BaseChannel {
     if (msg.replyTo) {
       payload.reply = { messageReference: msg.replyTo };
     }
+    if (msg.metadata?.silent === true) {
+      payload.flags = MessageFlags.SuppressNotifications;
+    }
     await textChannel.send(payload);
   }
   async handleIncoming(message) {
@@ -2254,7 +3314,7 @@ var DiscordChannel = class extends BaseChannel {
       contentParts.push(message.content);
     }
     if (message.attachments.size) {
-      const mediaDir = join6(getDataPath(), "media");
+      const mediaDir = join7(getDataPath(), "media");
       mkdirSync3(mediaDir, { recursive: true });
       for (const attachment of message.attachments.values()) {
         if (attachment.size && attachment.size > MAX_ATTACHMENT_BYTES) {
@@ -2262,14 +3322,14 @@ var DiscordChannel = class extends BaseChannel {
           continue;
         }
         try {
-          const res = await fetch3(attachment.url);
+          const res = await fetch4(attachment.url);
           if (!res.ok) {
             contentParts.push(`[attachment: ${attachment.name ?? "file"} - download failed]`);
             continue;
           }
           const buffer = Buffer.from(await res.arrayBuffer());
           const filename = `${attachment.id}_${(attachment.name ?? "file").replace(/\//g, "_")}`;
-          const filePath = join6(mediaDir, filename);
+          const filePath = join7(mediaDir, filename);
           writeFileSync4(filePath, buffer);
           mediaPaths.push(filePath);
           contentParts.push(`[attachment: ${filePath}]`);
@@ -2515,9 +3575,9 @@ function parseMdTable(tableText) {
 
 // src/channels/mochat.ts
 import { io } from "socket.io-client";
-import { fetch as fetch4 } from "undici";
-import { join as join7 } from "path";
-import { mkdirSync as mkdirSync4, existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { fetch as fetch5 } from "undici";
+import { join as join8 } from "path";
+import { mkdirSync as mkdirSync4, existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 var MAX_SEEN_MESSAGE_IDS = 2e3;
 var CURSOR_SAVE_DEBOUNCE_MS = 500;
 var AsyncLock = class {
@@ -2536,8 +3596,8 @@ var MochatChannel = class extends BaseChannel {
   socket = null;
   wsConnected = false;
   wsReady = false;
-  stateDir = join7(getDataPath(), "mochat");
-  cursorPath = join7(this.stateDir, "session_cursors.json");
+  stateDir = join8(getDataPath(), "mochat");
+  cursorPath = join8(this.stateDir, "session_cursors.json");
   sessionCursor = {};
   cursorSaveTimer = null;
   sessionSet = /* @__PURE__ */ new Set();
@@ -2723,15 +3783,15 @@ var MochatChannel = class extends BaseChannel {
       socket.on(eventName, notifyHandler(eventName));
     });
     this.socket = socket;
-    return new Promise((resolve5) => {
-      const timer = setTimeout(() => resolve5(false), timeout);
+    return new Promise((resolve6) => {
+      const timer = setTimeout(() => resolve6(false), timeout);
       socket.once("connect", () => {
         clearTimeout(timer);
-        resolve5(true);
+        resolve6(true);
       });
       socket.once("connect_error", () => {
         clearTimeout(timer);
-        resolve5(false);
+        resolve6(false);
       });
     });
   }
@@ -2793,17 +3853,17 @@ var MochatChannel = class extends BaseChannel {
     if (!this.socket) {
       return { result: false, message: "socket not connected" };
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       this.socket?.timeout(1e4).emit(eventName, payload, (err, response) => {
         if (err) {
-          resolve5({ result: false, message: String(err) });
+          resolve6({ result: false, message: String(err) });
           return;
         }
         if (response && typeof response === "object") {
-          resolve5(response);
+          resolve6(response);
           return;
         }
-        resolve5({ result: true, data: response });
+        resolve6({ result: true, data: response });
       });
     });
   }
@@ -3226,11 +4286,11 @@ var MochatChannel = class extends BaseChannel {
     }
   }
   async loadSessionCursors() {
-    if (!existsSync8(this.cursorPath)) {
+    if (!existsSync9(this.cursorPath)) {
       return;
     }
     try {
-      const raw = readFileSync6(this.cursorPath, "utf-8");
+      const raw = readFileSync7(this.cursorPath, "utf-8");
       const data = JSON.parse(raw);
       const cursors = data.cursors;
       if (cursors && typeof cursors === "object") {
@@ -3259,7 +4319,7 @@ var MochatChannel = class extends BaseChannel {
   }
   async postJson(path, payload) {
     const url = `${this.config.baseUrl.trim().replace(/\/$/, "")}${path}`;
-    const response = await fetch4(url, {
+    const response = await fetch5(url, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3459,12 +4519,12 @@ function readGroupId(metadata) {
   return null;
 }
 function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 
 // src/channels/dingtalk.ts
 import { DWClient, EventAck, TOPIC_ROBOT } from "dingtalk-stream";
-import { fetch as fetch5 } from "undici";
+import { fetch as fetch6 } from "undici";
 var DingTalkChannel = class extends BaseChannel {
   name = "dingtalk";
   client = null;
@@ -3511,7 +4571,7 @@ var DingTalkChannel = class extends BaseChannel {
         title: `${APP_TITLE} Reply`
       })
     };
-    const response = await fetch5(url, {
+    const response = await fetch6(url, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3565,7 +4625,7 @@ var DingTalkChannel = class extends BaseChannel {
       appKey: this.config.clientId,
       appSecret: this.config.clientSecret
     };
-    const response = await fetch5(url, {
+    const response = await fetch6(url, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(payload)
@@ -3589,7 +4649,7 @@ var DingTalkChannel = class extends BaseChannel {
 import { ImapFlow } from "imapflow";
 import { simpleParser } from "mailparser";
 import nodemailer from "nodemailer";
-var sleep3 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+var sleep3 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
 var EmailChannel = class extends BaseChannel {
   name = "email";
   lastSubjectByChat = /* @__PURE__ */ new Map();
@@ -4186,8 +5246,8 @@ var ChannelManager = class {
 };
 
 // src/config/loader.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve5 } from "path";
 import { z as z2 } from "zod";
 
 // src/config/schema.ts
@@ -4257,7 +5317,10 @@ var PROVIDERS = [
     detectByBaseKeyword: "",
     defaultApiBase: "",
     stripModelPrefix: false,
-    modelOverrides: []
+    modelOverrides: [],
+    supportsWireApi: true,
+    wireApiOptions: ["auto", "chat", "responses"],
+    defaultWireApi: "auto"
   },
   {
     name: "deepseek",
@@ -4549,13 +5612,39 @@ var AgentDefaultsSchema = z.object({
   temperature: z.number().default(0.7),
   maxToolIterations: z.number().int().default(20)
 });
+var ContextBootstrapSchema = z.object({
+  files: z.array(z.string()).default([
+    "AGENTS.md",
+    "SOUL.md",
+    "USER.md",
+    "IDENTITY.md",
+    "TOOLS.md",
+    "BOOT.md",
+    "BOOTSTRAP.md",
+    "HEARTBEAT.md"
+  ]),
+  minimalFiles: z.array(z.string()).default(["AGENTS.md", "SOUL.md", "TOOLS.md", "IDENTITY.md"]),
+  heartbeatFiles: z.array(z.string()).default(["HEARTBEAT.md"]),
+  perFileChars: z.number().int().default(4e3),
+  totalChars: z.number().int().default(12e3)
+});
+var ContextMemorySchema = z.object({
+  enabled: z.boolean().default(true),
+  maxChars: z.number().int().default(8e3)
+});
+var ContextConfigSchema = z.object({
+  bootstrap: ContextBootstrapSchema.default({}),
+  memory: ContextMemorySchema.default({})
+});
 var AgentsConfigSchema = z.object({
-  defaults: AgentDefaultsSchema.default({})
+  defaults: AgentDefaultsSchema.default({}),
+  context: ContextConfigSchema.default({})
 });
 var ProviderConfigSchema = z.object({
   apiKey: z.string().default(""),
   apiBase: z.string().nullable().default(null),
-  extraHeaders: z.record(z.string()).nullable().default(null)
+  extraHeaders: z.record(z.string()).nullable().default(null),
+  wireApi: z.enum(["auto", "chat", "responses"]).default("auto")
 });
 var ProvidersConfigSchema = z.object({
   anthropic: ProviderConfigSchema.default({}),
@@ -4649,16 +5738,16 @@ function getApiBase(config, model) {
 
 // src/config/loader.ts
 function getConfigPath() {
-  return resolve4(getDataPath(), "config.json");
+  return resolve5(getDataPath(), "config.json");
 }
 function getDataDir() {
   return getDataPath();
 }
 function loadConfig(configPath) {
   const path = configPath ?? getConfigPath();
-  if (existsSync9(path)) {
+  if (existsSync10(path)) {
     try {
-      const raw = readFileSync7(path, "utf-8");
+      const raw = readFileSync8(path, "utf-8");
       const data = JSON.parse(raw);
       const migrated = migrateConfig(data);
       return ConfigSchema.parse(migrated);
@@ -4671,7 +5760,7 @@ function loadConfig(configPath) {
 }
 function saveConfig(config, configPath) {
   const path = configPath ?? getConfigPath();
-  mkdirSync5(resolve4(path, ".."), { recursive: true });
+  mkdirSync5(resolve5(path, ".."), { recursive: true });
   writeFileSync6(path, JSON.stringify(config, null, 2));
 }
 function migrateConfig(data) {
@@ -4696,7 +5785,7 @@ var isPlainObject = (value) => {
 };
 var RELOAD_RULES = [
   { prefix: "channels", kind: "restart-channels" },
-  { prefix: "providers", kind: "restart-required" },
+  { prefix: "providers", kind: "reload-providers" },
   { prefix: "agents.defaults.model", kind: "restart-required" },
   { prefix: "agents.defaults.maxTokens", kind: "restart-required" },
   { prefix: "agents.defaults.temperature", kind: "restart-required" },
@@ -4745,6 +5834,7 @@ function buildReloadPlan(changedPaths) {
   const plan = {
     changedPaths,
     restartChannels: false,
+    reloadProviders: false,
     restartRequired: [],
     noopPaths: []
   };
@@ -4758,6 +5848,10 @@ function buildReloadPlan(changedPaths) {
       plan.restartChannels = true;
       continue;
     }
+    if (rule.kind === "reload-providers") {
+      plan.reloadProviders = true;
+      continue;
+    }
     if (rule.kind === "restart-required") {
       plan.restartRequired.push(path);
       continue;
@@ -4768,7 +5862,7 @@ function buildReloadPlan(changedPaths) {
 }
 
 // src/cron/service.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname2 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import cronParser from "cron-parser";
@@ -4806,9 +5900,9 @@ var CronService = class {
     if (this.store) {
       return this.store;
     }
-    if (existsSync10(this.storePath)) {
+    if (existsSync11(this.storePath)) {
       try {
-        const data = JSON.parse(readFileSync8(this.storePath, "utf-8"));
+        const data = JSON.parse(readFileSync9(this.storePath, "utf-8"));
         const jobs = (data.jobs ?? []).map((job) => ({
           id: String(job.id),
           name: String(job.name),
@@ -5011,8 +6105,8 @@ var CronService = class {
 };
 
 // src/heartbeat/service.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
+import { join as join9 } from "path";
 var DEFAULT_HEARTBEAT_INTERVAL_S = 30 * 60;
 var HEARTBEAT_PROMPT = "Read HEARTBEAT.md in your workspace (if it exists).\nFollow any instructions or tasks listed there.\nIf nothing needs attention, reply with just: HEARTBEAT_OK";
 var HEARTBEAT_OK_TOKEN = "HEARTBEAT_OK";
@@ -5040,12 +6134,12 @@ var HeartbeatService = class {
   running = false;
   timer = null;
   get heartbeatFile() {
-    return join8(this.workspace, "HEARTBEAT.md");
+    return join9(this.workspace, "HEARTBEAT.md");
   }
   readHeartbeatFile() {
-    if (existsSync11(this.heartbeatFile)) {
+    if (existsSync12(this.heartbeatFile)) {
       try {
-        return readFileSync9(this.heartbeatFile, "utf-8");
+        return readFileSync10(this.heartbeatFile, "utf-8");
       } catch {
         return null;
       }
@@ -5107,10 +6201,12 @@ var OpenAICompatibleProvider = class extends LLMProvider {
   client;
   defaultModel;
   extraHeaders;
+  wireApi;
   constructor(options) {
     super(options.apiKey, options.apiBase);
     this.defaultModel = options.defaultModel;
     this.extraHeaders = options.extraHeaders ?? null;
+    this.wireApi = options.wireApi ?? "auto";
     this.client = new OpenAI({
       apiKey: options.apiKey ?? void 0,
       baseURL: options.apiBase ?? void 0,
@@ -5121,6 +6217,22 @@ var OpenAICompatibleProvider = class extends LLMProvider {
     return this.defaultModel;
   }
   async chat(params) {
+    if (this.wireApi === "chat") {
+      return this.chatCompletions(params);
+    }
+    if (this.wireApi === "responses") {
+      return this.chatResponses(params);
+    }
+    try {
+      return await this.chatCompletions(params);
+    } catch (error) {
+      if (this.shouldFallbackToResponses(error)) {
+        return await this.chatResponses(params);
+      }
+      throw error;
+    }
+  }
+  async chatCompletions(params) {
     const model = params.model ?? this.defaultModel;
     const temperature = params.temperature ?? 0.7;
     const maxTokens = params.maxTokens ?? 4096;
@@ -5166,6 +6278,141 @@ var OpenAICompatibleProvider = class extends LLMProvider {
       reasoningContent
     };
   }
+  async chatResponses(params) {
+    const model = params.model ?? this.defaultModel;
+    const input = this.toResponsesInput(params.messages);
+    const body = { model, input };
+    if (params.tools && params.tools.length) {
+      body.tools = params.tools;
+    }
+    const base = this.apiBase ?? "https://api.openai.com/v1";
+    const responseUrl = new URL("responses", base.endsWith("/") ? base : `${base}/`);
+    const response = await fetch(responseUrl.toString(), {
+      method: "POST",
+      headers: {
+        "Authorization": this.apiKey ? `Bearer ${this.apiKey}` : "",
+        "Content-Type": "application/json",
+        ...this.extraHeaders ?? {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Responses API failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+    const responseAny = await response.json();
+    const outputItems = responseAny.output ?? [];
+    const toolCalls = [];
+    const contentParts = [];
+    let reasoningContent = null;
+    for (const item of outputItems) {
+      const itemAny = item;
+      if (itemAny.type === "reasoning" && Array.isArray(itemAny.summary)) {
+        const summaryText = itemAny.summary.map((entry) => typeof entry === "string" ? entry : String(entry.text ?? "")).filter(Boolean).join("\n");
+        reasoningContent = summaryText || reasoningContent;
+      }
+      if (itemAny.type === "message" && Array.isArray(itemAny.content)) {
+        for (const part of itemAny.content) {
+          const partAny = part;
+          if (partAny?.type === "output_text" || partAny?.type === "text") {
+            const text = String(partAny?.text ?? "");
+            if (text) {
+              contentParts.push(text);
+            }
+          }
+        }
+      }
+      if (itemAny.type === "tool_call" || itemAny.type === "function_call") {
+        const itemFunction = itemAny.function;
+        const name = String(itemAny.name ?? itemFunction?.name ?? "");
+        const rawArgs = itemAny.arguments ?? itemFunction?.arguments ?? itemAny.input ?? itemFunction?.input ?? "{}";
+        let args = {};
+        try {
+          args = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
+        } catch {
+          args = {};
+        }
+        toolCalls.push({
+          id: String(itemAny.id ?? itemAny.call_id ?? `${name}-${toolCalls.length}`),
+          name,
+          arguments: args
+        });
+      }
+    }
+    const usage = responseAny.usage ?? {};
+    return {
+      content: contentParts.join("") || null,
+      toolCalls,
+      finishReason: responseAny.status ?? "stop",
+      usage: {
+        prompt_tokens: usage.input_tokens ?? usage.prompt_tokens ?? 0,
+        completion_tokens: usage.output_tokens ?? usage.completion_tokens ?? 0,
+        total_tokens: usage.total_tokens ?? 0
+      },
+      reasoningContent
+    };
+  }
+  shouldFallbackToResponses(error) {
+    const err = error;
+    const status = err?.status;
+    const message = err?.message ?? "";
+    if (status === 404) {
+      return true;
+    }
+    if (message.includes("Cannot POST") && message.includes("chat/completions")) {
+      return true;
+    }
+    if (message.includes("chat/completions") && message.includes("404")) {
+      return true;
+    }
+    return false;
+  }
+  toResponsesInput(messages) {
+    const input = [];
+    for (const msg of messages) {
+      const role = String(msg.role ?? "user");
+      const content = msg.content;
+      if (role === "tool") {
+        const callId = typeof msg.tool_call_id === "string" ? msg.tool_call_id : "";
+        const outputText = typeof content === "string" ? content : Array.isArray(content) ? JSON.stringify(content) : String(content ?? "");
+        input.push({
+          type: "function_call_output",
+          call_id: callId,
+          output: outputText
+        });
+        continue;
+      }
+      const output = { role };
+      if (Array.isArray(content) || typeof content === "string") {
+        output.content = content;
+      } else {
+        output.content = String(content ?? "");
+      }
+      if (typeof msg.reasoning_content === "string" && msg.reasoning_content) {
+        output.reasoning = msg.reasoning_content;
+      }
+      input.push(output);
+      if (Array.isArray(msg.tool_calls)) {
+        for (const call of msg.tool_calls) {
+          const callAny = call;
+          const functionAny = callAny.function ?? {};
+          const callId = String(callAny.id ?? callAny.call_id ?? "");
+          const name = String(functionAny.name ?? callAny.name ?? "");
+          const args = String(functionAny.arguments ?? callAny.arguments ?? "{}");
+          if (!callId || !name) {
+            continue;
+          }
+          input.push({
+            type: "function_call",
+            name,
+            arguments: args,
+            call_id: callId
+          });
+        }
+      }
+    }
+    return input;
+  }
 };
 
 // src/providers/litellm_provider.ts
@@ -5181,11 +6428,14 @@ var LiteLLMProvider = class extends LLMProvider {
     this.extraHeaders = options.extraHeaders ?? null;
     this.providerName = options.providerName ?? null;
     this.gatewaySpec = findGateway(this.providerName, options.apiKey ?? null, options.apiBase ?? null) ?? void 0;
+    const providerSpec = this.providerName ? findProviderByName(this.providerName) : void 0;
+    const wireApi = providerSpec?.supportsWireApi ? options.wireApi ?? providerSpec.defaultWireApi ?? "auto" : void 0;
     this.client = new OpenAICompatibleProvider({
       apiKey: options.apiKey ?? null,
       apiBase: options.apiBase ?? null,
       defaultModel: options.defaultModel,
-      extraHeaders: options.extraHeaders ?? null
+      extraHeaders: options.extraHeaders ?? null,
+      wireApi
     });
   }
   getDefaultModel() {
@@ -5263,6 +6513,20 @@ var LiteLLMProvider = class extends LLMProvider {
     return findProviderByModel(model) ?? (this.providerName ? findProviderByName(this.providerName) : void 0);
   }
 };
+
+// src/providers/provider_manager.ts
+var ProviderManager = class {
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  get() {
+    return this.provider;
+  }
+  set(next) {
+    this.provider = next;
+  }
+};
 export {
   APP_NAME,
   APP_REPLY_SUBJECT,
@@ -5275,6 +6539,9 @@ export {
   ChannelManager,
   ChannelsConfigSchema,
   ConfigSchema,
+  ContextBootstrapSchema,
+  ContextConfigSchema,
+  ContextMemorySchema,
   CronService,
   DEFAULT_CONFIG_FILE,
   DEFAULT_CONFIG_PATH,
@@ -5290,6 +6557,7 @@ export {
   ExecToolConfigSchema,
   FeishuConfigSchema,
   GatewayConfigSchema,
+  GatewayTool,
   HEARTBEAT_OK_TOKEN,
   HEARTBEAT_PROMPT,
   HeartbeatService,
@@ -5301,6 +6569,7 @@ export {
   MochatMentionSchema,
   PROVIDERS,
   ProviderConfigSchema,
+  ProviderManager,
   ProvidersConfigSchema,
   QQConfigSchema,
   SKILL_METADATA_KEY,