@axiom-lattice/gateway 2.1.117 → 3.0.1

package/dist/index.js

@@ -35,8 +35,8 @@ function getContentTypeFromFilename(filename) {
   const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
-function getFilenameFromPath(path3) {
-  const segments = path3.replace(/\/+$/, "").split("/");
+function getFilenameFromPath(path4) {
+  const segments = path4.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
 }
 var EXT_TO_MIME;
@@ -703,17 +703,17 @@ function generateWechatUin() {
   buf.writeUInt32BE(Math.floor(Math.random() * 4294967295), 0);
   return buf.toString("base64url");
 }
-async function apiGet(path3, extraHeaders) {
-  const url = `${getBaseUrl()}${path3}`;
+async function apiGet(path4, extraHeaders) {
+  const url = `${getBaseUrl()}${path4}`;
   const headers = { ...extraHeaders };
   const res = await fetch(url, { headers });
   if (!res.ok) {
-    throw new Error(`iLink GET ${path3} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`iLink GET ${path4} failed: ${res.status} ${res.statusText}`);
   }
   return res.json();
 }
-async function apiPost(path3, body, botToken, signal) {
-  const url = `${getBaseUrl()}${path3}`;
+async function apiPost(path4, body, botToken, signal) {
+  const url = `${getBaseUrl()}${path4}`;
   const headers = {
     "Content-Type": "application/json",
     "AuthorizationType": "ilink_bot_token",
@@ -727,7 +727,7 @@ async function apiPost(path3, body, botToken, signal) {
     signal
   });
   if (!res.ok) {
-    throw new Error(`iLink POST ${path3} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`iLink POST ${path4} failed: ${res.status} ${res.statusText}`);
   }
   return res.json();
 }
@@ -1031,7 +1031,7 @@ var init_WechatChannelAdapter = __esm({
               installationId,
               error: err instanceof Error ? err.message : String(err)
             });
-            await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+            await new Promise((resolve3) => setTimeout(resolve3, reconnectDelay));
             reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
           }
           scheduleNextPoll();
@@ -1173,14 +1173,16 @@ function buildTextPart(text) {
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-async function streamChunksAsA2A(stream, taskId, sendEvent, onInterrupt) {
+async function streamChunksAsA2A(stream, taskId, contextId, sendEvent, onInterrupt) {
   let accumulatedText = "";
+  let interrupted = false;
   for await (const chunk of stream) {
     const chunkText = chunk.data?.content || "";
     const chunkType = chunk.type;
-    if (chunkType === import_protocols4.MessageChunkTypes.INTERRUPT) {
+    if (chunkType === import_protocols6.MessageChunkTypes.INTERRUPT) {
       sendEvent("status-update", {
         id: taskId,
+        contextId,
         status: {
           state: "input-required",
           message: {
@@ -1192,13 +1194,15 @@ async function streamChunksAsA2A(stream, taskId, sendEvent, onInterrupt) {
         final: false
       });
       onInterrupt?.();
-      continue;
+      interrupted = true;
+      break;
     }
-    if (chunkType === import_protocols4.MessageChunkTypes.AI || chunkType === import_protocols4.MessageChunkTypes.TOOL) {
+    if (chunkType === import_protocols6.MessageChunkTypes.AI || chunkType === import_protocols6.MessageChunkTypes.TOOL) {
       if (chunkText) {
         accumulatedText += chunkText;
         sendEvent("status-update", {
           id: taskId,
+          contextId,
           status: {
             state: "working",
             message: {
@@ -1212,7 +1216,7 @@ async function streamChunksAsA2A(stream, taskId, sendEvent, onInterrupt) {
       }
     }
   }
-  return accumulatedText;
+  return { text: accumulatedText, interrupted };
 }
 async function getTaskStatus(taskId) {
   const record = taskStore.get(taskId);
@@ -1266,13 +1270,48 @@ async function handleTasksSend(request, reply) {
     });
     return;
   }
+  const contextId = body.message.contextId;
+  const referenceTaskIds = body.message.referenceTaskIds;
   const taskId = body.id || (0, import_uuid10.v4)();
-  const threadId = (0, import_uuid10.v4)();
+  let threadId;
+  let resolvedReferenceTaskIds;
+  if (body.id) {
+    const existingTask = taskStore.get(body.id);
+    if (existingTask) {
+      if (existingTask.status === "input-required") {
+        threadId = existingTask.threadId;
+        resolvedReferenceTaskIds = referenceTaskIds;
+      } else if (existingTask.status === "completed" || existingTask.status === "failed" || existingTask.status === "canceled") {
+        threadId = (0, import_uuid10.v4)();
+        resolvedReferenceTaskIds = referenceTaskIds ? [...referenceTaskIds, body.id] : [body.id];
+      } else {
+        threadId = (0, import_uuid10.v4)();
+        resolvedReferenceTaskIds = referenceTaskIds;
+      }
+    } else {
+      threadId = (0, import_uuid10.v4)();
+      resolvedReferenceTaskIds = referenceTaskIds ? [...referenceTaskIds, body.id] : [body.id];
+    }
+  } else if (contextId && contextThreadMap.has(contextId)) {
+    threadId = contextThreadMap.get(contextId);
+    console.warn({
+      event: "a2a:deprecated:contextId_thread_reuse",
+      message: "contextId-based thread reuse is deprecated; use referenceTaskIds and application-layer conversation state instead",
+      contextId,
+      threadId
+    });
+    resolvedReferenceTaskIds = referenceTaskIds;
+  } else {
+    threadId = (0, import_uuid10.v4)();
+    resolvedReferenceTaskIds = referenceTaskIds;
+  }
   const tenantId = auth.tenantId || config.defaultTenantId;
   const now = isoNow();
   const record = {
     id: taskId,
     threadId,
+    contextId,
+    referenceTaskIds: resolvedReferenceTaskIds,
     assistantId,
     tenantId,
     projectId: auth.projectId || void 0,
@@ -1290,7 +1329,7 @@ async function handleTasksSend(request, reply) {
   taskStore.set(taskId, record);
   let agent;
   try {
-    agent = import_core55.agentInstanceManager.getAgent({
+    agent = import_core56.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
       tenant_id: tenantId,
@@ -1326,26 +1365,29 @@ data: ${JSON.stringify(data)}
     });
     record.messageId = result.messageId;
     const stream = agent.chunkStream(result.messageId, [
-      import_protocols4.MessageChunkTypes.MESSAGE_COMPLETED
+      import_protocols6.MessageChunkTypes.MESSAGE_COMPLETED
     ]);
-    const accumulatedText = await streamChunksAsA2A(stream, taskId, sendEvent, () => {
+    const { text: accumulatedText, interrupted } = await streamChunksAsA2A(stream, taskId, contextId, sendEvent, () => {
       record.status = "input-required";
       record.updatedAt = isoNow();
     });
-    record.status = "completed";
-    record.updatedAt = isoNow();
-    record.history.push({
-      role: "agent",
-      parts: [buildTextPart(accumulatedText)]
-    });
-    sendEvent("status-update", {
-      id: taskId,
-      status: {
-        state: "completed",
-        timestamp: isoNow()
-      },
-      final: true
-    });
+    if (!interrupted) {
+      record.status = "completed";
+      record.updatedAt = isoNow();
+      record.history.push({
+        role: "agent",
+        parts: [buildTextPart(accumulatedText)]
+      });
+      sendEvent("status-update", {
+        id: taskId,
+        contextId,
+        status: {
+          state: "completed",
+          timestamp: isoNow()
+        },
+        final: true
+      });
+    }
   } catch (err) {
     record.status = "failed";
     record.updatedAt = isoNow();
@@ -1355,6 +1397,7 @@ data: ${JSON.stringify(data)}
     });
     sendEvent("status-update", {
       id: taskId,
+      contextId,
       status: {
         state: "failed",
         timestamp: isoNow()
@@ -1382,7 +1425,7 @@ async function handleTasksCancel(request, reply) {
     return;
   }
   try {
-    const agent = import_core55.agentInstanceManager.getAgent({
+    const agent = import_core56.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1419,7 +1462,7 @@ async function handleTasksStream(request, reply) {
   }
   let agent;
   try {
-    agent = import_core55.agentInstanceManager.getAgent({
+    agent = import_core56.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1448,6 +1491,7 @@ data: ${JSON.stringify(data)}
   if (!record.messageId) {
     sendEvent("status-update", {
       id: taskId,
+      contextId: record.contextId,
       status: {
         state: record.status,
         timestamp: record.updatedAt
@@ -1459,17 +1503,20 @@ data: ${JSON.stringify(data)}
   }
   try {
     const stream = agent.chunkStream(record.messageId, [
-      import_protocols4.MessageChunkTypes.MESSAGE_COMPLETED
+      import_protocols6.MessageChunkTypes.MESSAGE_COMPLETED
     ]);
-    await streamChunksAsA2A(stream, taskId, sendEvent);
-    sendEvent("status-update", {
-      id: taskId,
-      status: {
-        state: record.status,
-        timestamp: record.updatedAt
-      },
-      final: true
-    });
+    const { interrupted } = await streamChunksAsA2A(stream, taskId, record.contextId, sendEvent);
+    if (!interrupted) {
+      sendEvent("status-update", {
+        id: taskId,
+        contextId: record.contextId,
+        status: {
+          state: record.status,
+          timestamp: record.updatedAt
+        },
+        final: true
+      });
+    }
   } catch (err) {
     sendEvent("error", {
       code: "STREAM_ERROR",
@@ -1614,14 +1661,15 @@ function registerA2ARoutes(app2) {
     handleApiKeyRotate
   );
 }
-var import_uuid10, import_core55, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
+var import_uuid10, import_core56, import_protocols6, taskStore, contextThreadMap, _a2aKeyStore, _storeKeyMap;
 var init_a2a = __esm({
   "src/routes/a2a.ts"() {
     "use strict";
     import_uuid10 = require("uuid");
-    import_core55 = require("@axiom-lattice/core");
-    import_protocols4 = require("@axiom-lattice/protocols");
+    import_core56 = require("@axiom-lattice/core");
+    import_protocols6 = require("@axiom-lattice/protocols");
     taskStore = /* @__PURE__ */ new Map();
+    contextThreadMap = /* @__PURE__ */ new Map();
     _a2aKeyStore = null;
     _storeKeyMap = /* @__PURE__ */ new Map();
   }
@@ -1632,12 +1680,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core56, ResourceController;
+var import_bcryptjs, import_core57, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core56 = require("@axiom-lattice/core");
+    import_core57 = require("@axiom-lattice/core");
     init_mime();
     ResourceController = class {
       constructor(deps) {
@@ -1652,14 +1700,14 @@ var init_resources = __esm({
         if (!workspaceId || !projectId) {
           return reply.status(400).send({ error: "x-workspace-id and x-project-id headers required" });
         }
-        const payload = (0, import_core56.createSharePayload)(
+        const payload = (0, import_core57.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core56.generateToken)();
+        const token = (0, import_core57.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -1811,7 +1859,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core56.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core57.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -1862,8 +1910,8 @@ var init_resources = __esm({
         return cookie.includes(`share_unlock_${token}=1`);
       }
       /** Returns true if the path has a file extension indicating it's a file, not a directory */
-      _isFilePath(path3) {
-        return /\.[a-zA-Z0-9]+$/.test(path3);
+      _isFilePath(path4) {
+        return /\.[a-zA-Z0-9]+$/.test(path4);
       }
       /**
        * Shared file resolution: directory → index.html, volume FS → sandbox, base tag, response.
@@ -1994,6 +2042,7 @@ __export(index_exports, {
   LatticeGateway: () => LatticeGateway
 });
 module.exports = __toCommonJS(index_exports);
+var import_config2 = require("dotenv/config");
 var import_fastify = __toESM(require("fastify"));
 var import_cors = __toESM(require("@fastify/cors"));
 var import_multipart = __toESM(require("@fastify/multipart"));
@@ -2005,8 +2054,375 @@ var import_url = require("url");
 
 // src/controllers/assistant.ts
 var import_core = require("@axiom-lattice/core");
+var import_protocols = require("@axiom-lattice/protocols");
 var import_crypto = require("crypto");
 var import_core2 = require("@axiom-lattice/core");
+
+// src/services/local-a2a.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_promises = require("timers/promises");
+var STDERR_TAIL_LIMIT = 4096;
+function readBooleanEnv(name, defaultValue, env = process.env) {
+  const value = env[name];
+  if (value === void 0) return defaultValue;
+  return value === "1" || value.toLowerCase() === "true";
+}
+function findWorkspaceRoot(startDir) {
+  let current = (0, import_node_path.resolve)(startDir);
+  const { root } = (0, import_node_path.parse)(current);
+  while (current !== root) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(current, "pnpm-workspace.yaml"))) {
+      return current;
+    }
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+  return null;
+}
+function resolveLocalA2AWorkingDirectory(options) {
+  if (options.envWorkdir) return options.envWorkdir;
+  if (options.commandCwd) return options.commandCwd;
+  return findWorkspaceRoot(options.currentCwd) || options.currentCwd;
+}
+function validateWorkingDirectory(cwd) {
+  try {
+    const stat2 = (0, import_node_fs.statSync)(cwd);
+    if (!stat2.isDirectory()) {
+      return `Working directory is not a directory: ${cwd}`;
+    }
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Working directory is not accessible: ${cwd} (${message})`;
+  }
+}
+function appendStderrTail(current, chunk) {
+  const next = `${current}${chunk}`;
+  if (next.length <= STDERR_TAIL_LIMIT) return next;
+  return next.slice(-STDERR_TAIL_LIMIT);
+}
+function formatExitMessage(exitReason, stderrTail) {
+  const stderr = stderrTail.trim();
+  return stderr ? `Exited before becoming ready (${exitReason}): ${stderr}` : `Exited before becoming ready (${exitReason})`;
+}
+async function probeReady(agentCardUrl, healthUrl, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    if (healthUrl) {
+      const resp = await fetch(healthUrl, { signal: controller.signal });
+      if (!resp.ok) return false;
+    }
+    const cardResp = await fetch(agentCardUrl, { signal: controller.signal });
+    return cardResp.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var _LocalA2AService = class _LocalA2AService {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+    this.autoStartEnabled = readBooleanEnv("LOCAL_A2A_AUTO_START", true);
+  }
+  static getInstance() {
+    if (!_LocalA2AService.instance) {
+      _LocalA2AService.instance = new _LocalA2AService();
+    }
+    return _LocalA2AService.instance;
+  }
+  getOrCreateState(runtimeId, localRuntime) {
+    let state = this.states.get(runtimeId);
+    if (!state) {
+      state = {
+        runtimeId,
+        label: localRuntime.label || runtimeId,
+        status: this.autoStartEnabled ? "stopped" : "disabled",
+        enabled: this.autoStartEnabled,
+        assistantId: runtimeId,
+        agentCardUrl: localRuntime.agentCardUrl,
+        healthUrl: localRuntime.healthUrl,
+        localRuntime
+      };
+      this.states.set(runtimeId, state);
+    } else {
+      state.localRuntime = localRuntime;
+      state.label = localRuntime.label || state.label;
+      state.agentCardUrl = localRuntime.agentCardUrl;
+      state.healthUrl = localRuntime.healthUrl;
+    }
+    return state;
+  }
+  async getRegisteredState(runtimeId, localRuntime) {
+    const state = this.getOrCreateState(runtimeId, localRuntime);
+    if (state.process && state.status === "running") {
+      const alive = await probeReady(
+        localRuntime.agentCardUrl,
+        localRuntime.healthUrl,
+        2e3
+      );
+      if (!alive) {
+        state.process = void 0;
+        state.pid = void 0;
+        state.status = "stopped";
+        state.message = "Process exited unexpectedly";
+      }
+    }
+    return this.snapshotState(state);
+  }
+  async startProvider(runtimeId, localRuntime) {
+    const state = this.getOrCreateState(runtimeId, localRuntime);
+    if (!state.enabled) {
+      state.status = "disabled";
+      state.message = "Disabled by configuration";
+      return this.snapshotState(state);
+    }
+    if (state.process && state.status === "running") {
+      return this.snapshotState(state);
+    }
+    state.enabled = true;
+    const { executable, args, cwd, env: cmdEnv } = localRuntime.command;
+    const resolvedCwd = resolveLocalA2AWorkingDirectory({
+      envWorkdir: process.env.LOCAL_A2A_WORKDIR || void 0,
+      commandCwd: cwd,
+      currentCwd: process.cwd()
+    });
+    const cwdError = validateWorkingDirectory(resolvedCwd);
+    if (cwdError) {
+      state.process = void 0;
+      state.pid = void 0;
+      state.status = "failed";
+      state.message = cwdError;
+      return this.snapshotState(state);
+    }
+    state.status = "starting";
+    state.message = "Starting";
+    let stderrTail = "";
+    const childEnv = cmdEnv ? { ...process.env, ...cmdEnv } : process.env;
+    const child = (0, import_node_child_process.spawn)(executable, args, {
+      cwd: resolvedCwd,
+      env: childEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    state.process = child;
+    state.pid = child.pid ?? void 0;
+    child.once("error", (error) => {
+      const current = this.states.get(runtimeId);
+      if (!current) return;
+      current.process = void 0;
+      current.pid = void 0;
+      current.status = "failed";
+      const stderr = stderrTail.trim();
+      current.message = stderr ? `Failed to start: ${error.message}: ${stderr}` : `Failed to start: ${error.message}`;
+    });
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text) console.log(`[local-a2a:${runtimeId}] ${text}`);
+    });
+    child.stderr.on("data", (chunk) => {
+      const rawText = chunk.toString("utf8");
+      stderrTail = appendStderrTail(stderrTail, rawText);
+      const text = rawText.trim();
+      if (text) console.error(`[local-a2a:${runtimeId}] ${text}`);
+    });
+    child.on("close", (code, signal) => {
+      const current = this.states.get(runtimeId);
+      if (!current) return;
+      current.process = void 0;
+      current.pid = void 0;
+      const exitReason = signal ?? code ?? "unknown";
+      if (current.status === "running") {
+        current.status = "stopped";
+        current.message = `Stopped (${exitReason})`;
+      } else if (current.status === "starting") {
+        current.status = "failed";
+        current.message = formatExitMessage(exitReason, stderrTail);
+      }
+    });
+    const ready = await this.waitUntilReady(localRuntime, state, 15e3);
+    if (!ready) {
+      if (state.process) {
+        state.process.kill("SIGTERM");
+      }
+      state.process = void 0;
+      state.pid = void 0;
+      if (state.status !== "failed") {
+        state.status = "failed";
+        state.message = "Server did not become ready";
+      }
+      return this.snapshotState(state);
+    }
+    state.status = "running";
+    state.message = "Running";
+    state.lastStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return this.snapshotState(state);
+  }
+  async stopProvider(runtimeId) {
+    const state = this.states.get(runtimeId);
+    if (!state) {
+      return this.emptyState(runtimeId);
+    }
+    const child = state.process;
+    if (child) {
+      child.kill("SIGTERM");
+      await (0, import_promises.setTimeout)(750);
+      if (child.exitCode === null) {
+        child.kill("SIGKILL");
+      }
+      state.process = void 0;
+    }
+    state.pid = void 0;
+    state.status = "stopped";
+    state.message = "Stopped";
+    state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return this.snapshotState(state);
+  }
+  async restartProvider(runtimeId, localRuntime) {
+    await this.stopProvider(runtimeId);
+    return this.startProvider(runtimeId, localRuntime);
+  }
+  removeState(runtimeId) {
+    const state = this.states.get(runtimeId);
+    if (state?.process) {
+      state.process.kill("SIGTERM");
+      state.process = void 0;
+    }
+    this.states.delete(runtimeId);
+  }
+  async waitUntilReady(localRuntime, state, timeoutMs) {
+    const start2 = Date.now();
+    while (Date.now() - start2 < timeoutMs) {
+      if (state.status === "failed") return false;
+      if (await probeReady(localRuntime.agentCardUrl, localRuntime.healthUrl, 1500)) {
+        return true;
+      }
+      await (0, import_promises.setTimeout)(500);
+    }
+    return false;
+  }
+  emptyState(runtimeId) {
+    return {
+      runtimeId,
+      label: runtimeId,
+      status: "stopped",
+      enabled: false
+    };
+  }
+  snapshotState(state) {
+    return {
+      runtimeId: state.runtimeId,
+      label: state.label,
+      status: state.status,
+      enabled: state.enabled,
+      assistantId: state.assistantId,
+      agentCardUrl: state.agentCardUrl,
+      healthUrl: state.healthUrl,
+      pid: state.pid,
+      message: state.message,
+      lastStartedAt: state.lastStartedAt,
+      lastStoppedAt: state.lastStoppedAt
+    };
+  }
+};
+_LocalA2AService.instance = null;
+var LocalA2AService = _LocalA2AService;
+var localA2AService = LocalA2AService.getInstance();
+
+// src/utils/a2a-url.ts
+var AGENT_CARD_PATH = "/.well-known/agent-card.json";
+function normalizeA2AAgentCardUrl(value, defaultProtocol = "https://") {
+  const raw = value?.trim() ?? "";
+  if (!raw) return "";
+  const withProtocol = /^https?:\/\//i.test(raw) ? raw : `${defaultProtocol}${raw.replace(/^\/+/, "")}`;
+  const trimmed = withProtocol.replace(/\/+$/, "");
+  if (trimmed.endsWith(AGENT_CARD_PATH)) {
+    return trimmed;
+  }
+  return `${trimmed}${AGENT_CARD_PATH}`;
+}
+
+// src/utils/local-a2a-runtime.ts
+function validateLocalRuntimeCommand(localRuntime) {
+  const runtime = localRuntime;
+  const executable = runtime.command?.executable;
+  if (typeof executable !== "string" || executable.trim().length === 0) {
+    return {
+      ok: false,
+      error: "Local managed A2A command executable is required"
+    };
+  }
+  const args = runtime.command?.args;
+  if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
+    return {
+      ok: false,
+      error: "Local managed A2A command args must be an array of strings"
+    };
+  }
+  return { ok: true };
+}
+function getAgentCardPort(agentCardUrl) {
+  let url;
+  try {
+    url = new URL(agentCardUrl);
+  } catch {
+    return null;
+  }
+  if (url.port) {
+    const port = Number(url.port);
+    return Number.isInteger(port) ? port : null;
+  }
+  if (url.protocol === "http:") return 80;
+  if (url.protocol === "https:") return 443;
+  return null;
+}
+function parseCommandPort(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const match = /^(--port|-p)(?:[=\s]+(\d+))?$/.exec(arg);
+    if (!match) continue;
+    const inlinePort = match[2];
+    if (inlinePort) return Number(inlinePort);
+    const nextArg = args[index + 1];
+    if (nextArg && /^\d+$/.test(nextArg)) {
+      return Number(nextArg);
+    }
+  }
+  return null;
+}
+function isLoopbackHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]";
+}
+function validateLocalRuntimePort(localRuntime, agentCardUrl) {
+  let url;
+  try {
+    url = new URL(agentCardUrl);
+  } catch {
+    return { ok: true };
+  }
+  if (!isLoopbackHost(url.hostname) || !url.port) {
+    return { ok: true };
+  }
+  const commandPort = parseCommandPort(localRuntime.command.args);
+  if (commandPort === null) {
+    return { ok: true };
+  }
+  const agentCardPort = Number(url.port);
+  if (commandPort === agentCardPort) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    error: `Local managed A2A command port (${commandPort}) does not match agentCardUrl port (${agentCardPort}). Update the command args or Agent Card URL so they use the same port.`
+  };
+}
+
+// src/controllers/assistant.ts
 function getTenantId(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -2136,6 +2552,79 @@ async function createAssistant(request, reply) {
     });
   }
   const id = data.id ?? (0, import_crypto.randomUUID)();
+  if (data.graphDefinition && data.graphDefinition.type === import_protocols.AgentType.A2A_REMOTE) {
+    const a2aConfig = data.graphDefinition;
+    const warnings = [];
+    const isLocalManaged = !!a2aConfig.localRuntime;
+    a2aConfig.agentCardUrl = normalizeA2AAgentCardUrl(
+      a2aConfig.agentCardUrl,
+      isLocalManaged ? "http://" : "https://"
+    );
+    if (a2aConfig.localRuntime) {
+      const commandValidation = validateLocalRuntimeCommand(
+        a2aConfig.localRuntime
+      );
+      if (!commandValidation.ok) {
+        return reply.status(400).send({
+          success: false,
+          message: commandValidation.error
+        });
+      }
+      a2aConfig.localRuntime.command.executable = a2aConfig.localRuntime.command.executable.trim();
+      a2aConfig.localRuntime.agentCardUrl = normalizeA2AAgentCardUrl(
+        a2aConfig.localRuntime.agentCardUrl || a2aConfig.agentCardUrl,
+        "http://"
+      );
+      a2aConfig.agentCardUrl = a2aConfig.localRuntime.agentCardUrl;
+      const portValidation = validateLocalRuntimePort(
+        a2aConfig.localRuntime,
+        a2aConfig.agentCardUrl
+      );
+      if (!portValidation.ok) {
+        return reply.status(400).send({
+          success: false,
+          message: portValidation.error
+        });
+      }
+    }
+    if (a2aConfig.localRuntime) {
+      const existingAssistants = await (0, import_core.getStoreLattice)("default", "assistant").store.getAllAssistants(tenantId);
+      const targetPort = getAgentCardPort(a2aConfig.localRuntime.agentCardUrl);
+      const duplicate = existingAssistants.find((a) => {
+        if (a.id === id) return false;
+        const gd = a.graphDefinition && typeof a.graphDefinition === "object" ? a.graphDefinition : void 0;
+        if (!gd || gd.type !== import_protocols.AgentType.A2A_REMOTE) return false;
+        const lr = gd.localRuntime;
+        if (!lr) return false;
+        const existingAgentCardUrl = normalizeA2AAgentCardUrl(lr.agentCardUrl, "http://");
+        const existingPort = getAgentCardPort(existingAgentCardUrl);
+        if (targetPort !== null && existingPort !== null) {
+          return existingPort === targetPort;
+        }
+        return existingAgentCardUrl === a2aConfig.localRuntime.agentCardUrl;
+      });
+      if (duplicate) {
+        const conflictDetail = targetPort === null ? `agentCardUrl "${a2aConfig.localRuntime.agentCardUrl}"` : `port ${targetPort}`;
+        return reply.status(409).send({
+          success: false,
+          message: `A local managed A2A assistant using ${conflictDetail} already exists: "${duplicate.name}". Each local managed A2A assistant needs a unique port.`
+        });
+      }
+    }
+    try {
+      const resp = await fetch(a2aConfig.agentCardUrl, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!resp.ok) {
+        warnings.push(`agentCardUrl returned HTTP ${resp.status}`);
+      }
+    } catch {
+      warnings.push(`agentCardUrl is not reachable: ${a2aConfig.agentCardUrl}`);
+    }
+    if (warnings.length > 0) {
+      console.warn(`[createAssistant] A2A warnings for ${a2aConfig.agentCardUrl}:`, warnings);
+    }
+  }
   return upsertAssistant(tenantId, id, data, reply, true);
 }
 async function updateAssistant(request, reply) {
@@ -2149,11 +2638,28 @@ async function deleteAssistant(request, reply) {
   const { id } = request.params;
   const storeLattice = (0, import_core.getStoreLattice)("default", "assistant");
   const assistantStore = storeLattice.store;
+  const storedAssistant = await assistantStore.getAssistantById(tenantId, id);
+  const graphDefinition = storedAssistant?.graphDefinition;
+  const hasLocalRuntime = graphDefinition && typeof graphDefinition === "object" ? !!graphDefinition.localRuntime : false;
+  if (storedAssistant && hasLocalRuntime) {
+    localA2AService.removeState(id);
+    const deleted2 = await assistantStore.deleteAssistant(tenantId, id);
+    if (!deleted2) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete assistant"
+      });
+    }
+    import_core2.eventBus.publish("assistant:deleted", { id, tenantId });
+    return {
+      success: true,
+      message: "Deleted local A2A assistant"
+    };
+  }
   const agentConfig = await import_core2.agentLatticeManager.getAgentConfigWithTenant(tenantId, id);
   const isCodeConfigured = !!agentConfig;
   if (isCodeConfigured) {
-    const exists2 = await assistantStore.hasAssistant(tenantId, id);
-    if (!exists2) {
+    if (!storedAssistant) {
       return reply.status(404).send({
         success: false,
         message: "Assistant not found (code-configured assistants cannot be deleted from code, only from store)"
@@ -2166,8 +2672,7 @@ async function deleteAssistant(request, reply) {
       message: "Deleted assistant from store (code-configured registration remains)"
     };
   }
-  const exists = await assistantStore.hasAssistant(tenantId, id);
-  if (!exists) {
+  if (!storedAssistant) {
     return reply.status(404).send({
       success: false,
       message: "Assistant not found"
@@ -2221,7 +2726,7 @@ var getAgentGraph = async (request, reply) => {
 // src/controllers/run.ts
 var import_uuid = require("uuid");
 var import_core3 = require("@axiom-lattice/core");
-var import_protocols = require("@axiom-lattice/protocols");
+var import_protocols2 = require("@axiom-lattice/protocols");
 function getUserId2(request) {
   const authUser = request.user;
   if (authUser?.id) return authUser.id;
@@ -2293,13 +2798,13 @@ var createRun = async (request, reply) => {
           command,
           custom_run_config: mergedConfig
         }, mode);
-        const stream = agent.chunkStream(result.messageId, [import_protocols.MessageChunkTypes.MESSAGE_COMPLETED, import_protocols.MessageChunkTypes.INTERRUPT, import_protocols.MessageChunkTypes.MESSAGE_FAILED]);
+        const stream = agent.chunkStream(result.messageId, [import_protocols2.MessageChunkTypes.MESSAGE_COMPLETED, import_protocols2.MessageChunkTypes.INTERRUPT, import_protocols2.MessageChunkTypes.MESSAGE_FAILED]);
         for await (const chunk of stream) {
           const success = reply.raw.write(`data: ${JSON.stringify(chunk)}
 
 `);
           if (!success) {
-            await new Promise((resolve) => reply.raw.once("drain", resolve));
+            await new Promise((resolve3) => reply.raw.once("drain", resolve3));
           }
         }
       } catch (error) {
@@ -3077,7 +3582,7 @@ var configService = new ConfigService();
 
 // src/services/queue_service.ts
 var import_core8 = require("@axiom-lattice/core");
-var import_protocols2 = require("@axiom-lattice/protocols");
+var import_protocols3 = require("@axiom-lattice/protocols");
 var import_queue_redis = require("@axiom-lattice/queue-redis");
 var DEFAULT_QUEUE_KEY = "default";
 var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
@@ -3088,7 +3593,7 @@ var setQueueServiceType = (type) => {
   const config = {
     name: "Default Queue Service",
     description: `Default ${type} queue service`,
-    type: type === "redis" ? import_protocols2.QueueType.REDIS : import_protocols2.QueueType.MEMORY,
+    type: type === "redis" ? import_protocols3.QueueType.REDIS : import_protocols3.QueueType.MEMORY,
     queueName,
     options: type === "redis" ? {
       redisUrl: process.env.REDIS_URL,
@@ -4216,7 +4721,7 @@ async function executeSqlQuery(client, body, reply) {
 
 // src/controllers/workflow-tracking.ts
 var import_core15 = require("@axiom-lattice/core");
-var import_protocols3 = require("@axiom-lattice/protocols");
+var import_protocols4 = require("@axiom-lattice/protocols");
 function getTenantId7(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
@@ -4660,7 +5165,7 @@ async function replyInboxTask(request, reply) {
     }).then((result) => {
       const stream = agent.chunkStream(
         result.messageId,
-        [import_protocols3.MessageChunkTypes.MESSAGE_COMPLETED]
+        [import_protocols4.MessageChunkTypes.MESSAGE_COMPLETED]
       );
       (async () => {
         for await (const _ of stream) {
@@ -4877,15 +5382,14 @@ function getStore() {
 async function listTasks(request, reply) {
   try {
     const tenantId = getTenantId9(request);
-    const userId = getUserId4(request);
     const query = request.query;
     const store2 = getStore();
     const tasks = await store2.list({
       tenantId,
-      ownerId: query.ownerId || userId,
       status: query.status,
       priority: query.priority,
-      ownerType: query.ownerType,
+      ...query.ownerId && { ownerId: query.ownerId },
+      ...query.ownerType && { ownerType: query.ownerType },
       metadata: query.metadata ? JSON.parse(query.metadata) : void 0,
       projectId: query.projectId,
       limit: query.limit ? parseInt(query.limit) : void 0,
@@ -6021,13 +6525,42 @@ function registerSandboxProxyRoutes(app2) {
 }
 
 // src/controllers/workspace.ts
-var fs = __toESM(require("fs/promises"));
-var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
 var import_core24 = require("@axiom-lattice/core");
 var import_core25 = require("@axiom-lattice/core");
 var import_core26 = require("@axiom-lattice/core");
 var import_uuid3 = require("uuid");
 init_mime();
+
+// src/utils/path-containment.ts
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var PathOutsideRootError = class extends Error {
+  constructor(rootPath, targetPath) {
+    super(`Path is outside the allowed root: ${targetPath}`);
+    this.rootPath = rootPath;
+    this.targetPath = targetPath;
+    this.name = "PathOutsideRootError";
+  }
+};
+function isPathWithinRoot(rootPath, targetPath) {
+  const relative2 = path.relative(rootPath, targetPath);
+  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2);
+}
+async function resolvePathWithinRoot(rootPath, targetPath) {
+  const [resolvedRoot, resolvedTarget] = await Promise.all([
+    fs.realpath(rootPath),
+    fs.realpath(targetPath)
+  ]);
+  if (!isPathWithinRoot(resolvedRoot, resolvedTarget)) {
+    throw new PathOutsideRootError(resolvedRoot, resolvedTarget);
+  }
+  return { rootPath: resolvedRoot, targetPath: resolvedTarget };
+}
+
+// src/controllers/workspace.ts
 var WorkspaceController = class {
   constructor() {
     this.workspaceStore = (0, import_core24.getStoreLattice)("default", "workspace").store;
@@ -6188,16 +6721,23 @@ var WorkspaceController = class {
         }),
         workspace
       };
-    } else {
-      console.log(`[getBackend] using FilesystemBackend rootDir=/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`);
-      return {
-        backend: new import_core25.FilesystemBackend({
-          rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
-          virtualMode: true
-        }),
-        workspace
-      };
     }
+    const rootDir = await this.getFilesystemRootDirectory(
+      tenantId,
+      workspaceId,
+      projectId
+    );
+    console.log(`[getBackend] using FilesystemBackend rootDir=${rootDir}`);
+    return {
+      backend: new import_core25.FilesystemBackend({
+        rootDir,
+        virtualMode: true
+      }),
+      workspace
+    };
+  }
+  async getFilesystemRootDirectory(tenantId, workspaceId, projectId) {
+    return `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
   }
   isBinaryContentType(filename) {
     const ext = filename.split(".").pop()?.toLowerCase() || "";
@@ -6386,21 +6926,21 @@ var WorkspaceController = class {
   async listPath(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const path3 = request.query.path || "/";
+    const path4 = request.query.path || "/";
     const assistantId = request.query.assistantId;
-    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path3} assistantId=${assistantId}`);
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path3);
-    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path3})`);
-    const files = await backend.lsInfo(path3);
+    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path4} assistantId=${assistantId}`);
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path4);
+    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path4})`);
+    const files = await backend.lsInfo(path4);
     console.log(`[listPath] result count=${files.length}`);
     return { success: true, data: files };
   }
   async readFile(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const { path: path3, offset = 0, limit = 1e3, assistantId } = request.query;
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path3);
-    const content = await backend.read(path3, Number(offset), Number(limit));
+    const { path: path4, offset = 0, limit = 1e3, assistantId } = request.query;
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path4);
+    const content = await backend.read(path4, Number(offset), Number(limit));
     return { success: true, data: { content, offset, limit } };
   }
   /**
@@ -6412,7 +6952,7 @@ var WorkspaceController = class {
    * - `path`: optional directory path relative to project root (e.g., "docs", "src/utils")
    * - `assistantId`: optional query parameter for sandbox identity matching
    * For sandbox storage, delegates to the sandbox upload API.
-   * For filesystem storage, writes directly under /lattice_store/workspaces/{workspaceId}/{projectId}.
+   * For filesystem storage, writes under the same project root used by the file backend.
    */
   async uploadFile(request, reply) {
     const tenantId = this.getTenantId(request);
@@ -6446,7 +6986,7 @@ var WorkspaceController = class {
           workspaceId,
           projectId
         };
-        const realPath = pathValue ? path.posix.join(pathValue, filename) : path.posix.join("/project/uploads", filename);
+        const realPath = pathValue ? path2.posix.join(pathValue, filename) : path2.posix.join("/project/uploads", filename);
         const isBinary = this.isBinaryContentType(filename);
         const volumeBackend = await sandboxManager.getVolumeBackendForPath(volumeConfig, realPath);
         if (volumeBackend && !isBinary) {
@@ -6457,7 +6997,7 @@ var WorkspaceController = class {
           const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
           await sandbox.file.uploadFile({ file: realPath, data: buffer });
         }
-        const relativePath = pathValue ? path.posix.join(pathValue, filename) : path.posix.join("/project/uploads", filename);
+        const relativePath = pathValue ? path2.posix.join(pathValue, filename) : path2.posix.join("/project/uploads", filename);
         const result2 = {
           path: relativePath,
           name: filename,
@@ -6467,14 +7007,43 @@ var WorkspaceController = class {
         };
         return reply.status(200).send({ success: true, data: result2 });
       }
-      const rootDir = `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
-      const targetDir = pathValue ? path.join(rootDir, pathValue) : rootDir;
-      const targetPath = path.join(targetDir, filename);
-      await fs.mkdir(path.dirname(targetPath), { recursive: true });
-      await fs.writeFile(targetPath, buffer);
-      const stat2 = await fs.stat(targetPath);
+      const rootDir = await this.getFilesystemRootDirectory(
+        tenantId,
+        workspaceId,
+        projectId
+      );
+      await fs2.mkdir(rootDir, { recursive: true });
+      const relativeDirectory = pathValue?.replace(/^[/\\]+/, "") || ".";
+      const targetDir = path2.resolve(rootDir, relativeDirectory);
+      if (!isPathWithinRoot(path2.resolve(rootDir), targetDir)) {
+        return reply.status(400).send({
+          success: false,
+          error: "Upload path must stay within the project directory"
+        });
+      }
+      await fs2.mkdir(targetDir, { recursive: true });
+      const [resolvedRoot, resolvedTargetDir] = await Promise.all([
+        fs2.realpath(rootDir),
+        fs2.realpath(targetDir)
+      ]);
+      if (!isPathWithinRoot(resolvedRoot, resolvedTargetDir)) {
+        return reply.status(400).send({
+          success: false,
+          error: "Upload path must stay within the project directory"
+        });
+      }
+      const safeFilename = path2.basename(filename);
+      if (safeFilename !== filename) {
+        return reply.status(400).send({
+          success: false,
+          error: "Invalid filename"
+        });
+      }
+      const targetPath = path2.join(resolvedTargetDir, safeFilename);
+      await fs2.writeFile(targetPath, buffer);
+      const stat2 = await fs2.stat(targetPath);
       const result = {
-        path: pathValue ? `/${pathValue}/${filename}` : `/${filename}`,
+        path: path2.posix.join("/", relativeDirectory, safeFilename),
         name: filename,
         is_dir: false,
         size: stat2.size,
@@ -6482,9 +7051,63 @@ var WorkspaceController = class {
       };
       return reply.status(200).send({ success: true, data: result });
     } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
       return reply.status(500).send({
         success: false,
-        error: `Upload handler error: ${error?.message || String(error)}`
+        error: `Upload handler error: ${message}`
+      });
+    }
+  }
+  /**
+   * Browse local filesystem directories for the folder picker.
+   *
+   * Security constraints:
+   * - Restricted to os.homedir()
+   * - Blacklists system directories
+   * - Returns only directory names, no file contents or hidden files
+   */
+  async browseFilesystem(request, reply) {
+    const homeDir = os.homedir();
+    const requestedPath = request.query.path || homeDir;
+    const SYSTEM_BLACKLIST = ["/etc", "/sys", "/proc", "/var", "/tmp", "/dev"];
+    try {
+      const resolved = await resolvePathWithinRoot(homeDir, requestedPath);
+      const normalized = resolved.targetPath;
+      for (const blacklisted of SYSTEM_BLACKLIST) {
+        if (isPathWithinRoot(blacklisted, normalized)) {
+          return reply.status(403).send({
+            success: false,
+            error: `Cannot browse system directory: ${blacklisted}`
+          });
+        }
+      }
+      const entries = await fs2.readdir(normalized, { withFileTypes: true });
+      const dirEntries = entries.filter((entry) => !entry.name.startsWith(".") && entry.isDirectory()).map((entry) => ({
+        name: entry.name,
+        path: path2.join(normalized, entry.name),
+        isDirectory: true
+      }));
+      const parentPath = path2.dirname(normalized);
+      const hasParent = parentPath !== normalized && isPathWithinRoot(resolved.rootPath, parentPath);
+      return {
+        success: true,
+        data: {
+          path: normalized,
+          parentPath: hasParent ? parentPath : void 0,
+          entries: dirEntries
+        }
+      };
+    } catch (error) {
+      if (error instanceof PathOutsideRootError) {
+        return reply.status(403).send({
+          success: false,
+          error: "Browse restricted to home directory"
+        });
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return reply.status(400).send({
+        success: false,
+        error: `Cannot read directory: ${message}`
       });
     }
   }
@@ -6545,6 +7168,10 @@ function registerWorkspaceRoutes(app2) {
     "/api/workspaces/:workspaceId/projects/:projectId/viewfile",
     controller.viewFile.bind(controller)
   );
+  app2.get(
+    "/api/filesystem/browse",
+    controller.browseFilesystem.bind(controller)
+  );
 }
 
 // src/controllers/database-configs.ts
@@ -6761,7 +7388,7 @@ async function testDatabaseConnection(request, reply) {
       await db.connect();
       await db.listTables();
       const latency = Date.now() - startTime;
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
       await db.disconnect();
       await import_core27.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
@@ -7590,11 +8217,12 @@ var EvalRunner = class {
   constructor() {
     this.runs = /* @__PURE__ */ new Map();
     this.eventEmitter = new import_events.EventEmitter();
+    this.processStartedAt = /* @__PURE__ */ new Date();
   }
   getEventEmitter() {
     return this.eventEmitter;
   }
-  async startRun(tenantId, projectId) {
+  async startRun(tenantId, projectId, suiteIds) {
     const store2 = this.getEvalStore();
     const project = await store2.getProjectById(tenantId, projectId);
     if (!project) throw new Error("Project not found");
@@ -7604,10 +8232,27 @@ var EvalRunner = class {
       }
     }
     const existingRuns = await store2.getRunsByTenant(tenantId, { projectId, status: "running" });
-    if (existingRuns.length > 0) {
+    for (const run of existingRuns) {
+      const orphaned = !this.runs.has(run.id) && run.createdAt < this.processStartedAt;
+      if (orphaned) {
+        await store2.updateRunStatus(tenantId, run.id, {
+          status: "failed",
+          error: "Gateway restarted \u2014 run orphaned",
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    const stillRunning = await store2.getRunsByTenant(tenantId, { projectId, status: "running" });
+    if (stillRunning.length > 0) {
       throw new Error("A run is already in progress for this project");
     }
-    const suites = await store2.getSuitesByProject(tenantId, projectId);
+    let suites = await store2.getSuitesByProject(tenantId, projectId);
+    if (suiteIds && suiteIds.length > 0) {
+      suites = suites.filter((s) => suiteIds.includes(s.id));
+      if (suites.length === 0) {
+        throw new Error("No suites match the requested suiteIds filter");
+      }
+    }
     const evalSuites = [];
     let totalCases = 0;
     for (const suite of suites) {
@@ -7650,6 +8295,9 @@ var EvalRunner = class {
     const runId = (0, import_uuid4.v4)();
     const concurrency = Math.max(1, Math.floor(project.concurrency) || 3);
     await store2.createRun(tenantId, projectId, runId, { totalCases, concurrency });
+    const tsc = project.targetServerConfig ?? {};
+    const workspaceId = tsc.workspace_id || "";
+    const projectIdFromConfig = tsc.project_id || "";
     const projectConfig = {
       projectName: project.name,
       version: project.version,
@@ -7657,7 +8305,9 @@ var EvalRunner = class {
       suites: evalSuites,
       judge_agent_config: { modelKey: resolvedJudgeModelKey },
       lattice_server_config: {
-        tenant_id: tenantId
+        tenant_id: tenantId,
+        workspace_id: workspaceId,
+        project_id: projectIdFromConfig
       },
       concurrency
     };
@@ -7701,6 +8351,15 @@ var EvalRunner = class {
     const runPromise = (async () => {
       try {
         const evalProject = new import_core31.LatticeEvalProject(projectConfig, onCaseComplete);
+        const calibration = await evalProject.calibrateJudge();
+        if (!calibration.ok) {
+          await store2.updateRunStatus(tenantId, runId, {
+            status: "failed",
+            error: `Judge calibration failed: ${calibration.reason}`,
+            completedAt: /* @__PURE__ */ new Date()
+          });
+          throw new Error(`Judge calibration failed: ${calibration.reason}`);
+        }
         const { report } = await evalProject.runAllSuitesBatch(concurrency, abortController.signal);
         if (!abortController.signal.aborted) {
           const completedCount = stats.passed + stats.failed;
@@ -8088,11 +8747,12 @@ function registerEvalRoutes(app2) {
     try {
       const tenantId = getTenantId14(request);
       const { pid } = request.params;
-      const runId = await evalRunner.startRun(tenantId, pid);
+      const body = request.body ?? {};
+      const runId = await evalRunner.startRun(tenantId, pid, body?.suiteIds);
       reply.status(202).send({ success: true, message: "Run started", data: { run_id: runId } });
     } catch (err) {
       const msg = err.message;
-      const code = msg === "Project not found" ? 404 : msg.includes("already in progress") ? 409 : 500;
+      const code = msg === "Project not found" ? 404 : msg.includes("already in progress") ? 409 : msg.includes("No suites match") ? 400 : 500;
       reply.status(code).send({ success: false, message: msg });
     }
   });
@@ -9072,8 +9732,8 @@ function getTenantId15(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice31 } = await import("@axiom-lattice/core");
-  const store2 = getStoreLattice31("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice32 } = await import("@axiom-lattice/core");
+  const store2 = getStoreLattice32("default", "channelInstallation").store;
   if (store2) return store2;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -9554,8 +10214,8 @@ var log = {
 };
 var connections = /* @__PURE__ */ new Map();
 var pending = /* @__PURE__ */ new Map();
-function getAgentIdFromPath(path3) {
-  const match = path3.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
+function getAgentIdFromPath(path4) {
+  const match = path4.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
   return match ? match[1] : null;
 }
 function handleBridgeConnection(socket, _request) {
@@ -9663,12 +10323,12 @@ async function handleBridgeProxy(request, reply) {
   };
   const timeout = 3e5;
   try {
-    const response = await new Promise((resolve, reject) => {
+    const response = await new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         pending.delete(requestId);
         reject(new Error(`Bridge request timeout after ${timeout}ms`));
       }, timeout);
-      pending.set(requestId, { resolve, reject, timer, agentId });
+      pending.set(requestId, { resolve: resolve3, reject, timer, agentId });
       try {
         if (conn.ws.readyState !== conn.ws.OPEN) {
           pending.delete(requestId);
@@ -9791,10 +10451,272 @@ var registerSTTRoutes = (app2) => {
   );
 };
 
+// src/controllers/local-a2a.ts
+var import_core39 = require("@axiom-lattice/core");
+var import_protocols5 = require("@axiom-lattice/protocols");
+function getTenantId18(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return request.headers["x-tenant-id"] || "default";
+}
+function getLocalRuntime(assistant) {
+  const graphDefinition = assistant.graphDefinition;
+  if (!graphDefinition || typeof graphDefinition !== "object") return void 0;
+  if (graphDefinition.type !== import_protocols5.AgentType.A2A_REMOTE) return void 0;
+  return graphDefinition.localRuntime;
+}
+async function getLocalA2AAssistants(tenantId) {
+  const storeLattice = (0, import_core39.getStoreLattice)("default", "assistant");
+  const assistants = await storeLattice.store.getAllAssistants(tenantId);
+  const results = [];
+  for (const assistant of assistants) {
+    const runtime = getLocalRuntime(assistant);
+    if (runtime) {
+      results.push({ assistant, localRuntime: runtime });
+    }
+  }
+  return results;
+}
+async function getLocalA2AAssistant(tenantId, assistantId) {
+  const storeLattice = (0, import_core39.getStoreLattice)("default", "assistant");
+  const assistant = await storeLattice.store.getAssistantById(tenantId, assistantId);
+  if (!assistant) return null;
+  const runtime = getLocalRuntime(assistant);
+  if (!runtime) return null;
+  return { assistant, localRuntime: runtime };
+}
+async function requireManagedAssistant(request, reply) {
+  const assistantId = request.params.assistantId;
+  if (!assistantId) {
+    reply.status(400).send({ success: false, error: "assistantId is required" });
+    return null;
+  }
+  const registered = await getLocalA2AAssistant(getTenantId18(request), assistantId);
+  if (!registered) {
+    reply.status(404).send({
+      success: false,
+      error: `Assistant ${assistantId} is not a local managed A2A assistant`
+    });
+    return null;
+  }
+  return { assistantId, localRuntime: registered.localRuntime };
+}
+async function getLocalA2AStatus(request, reply) {
+  const tenantId = getTenantId18(request);
+  const managed = await getLocalA2AAssistants(tenantId);
+  const states = await Promise.all(
+    managed.map(
+      ({ assistant, localRuntime }) => localA2AService.getRegisteredState(assistant.id, localRuntime)
+    )
+  );
+  reply.send({ success: true, data: { records: states, total: states.length } });
+}
+async function getLocalA2AProvider(request, reply) {
+  const registered = await requireManagedAssistant(request, reply);
+  if (!registered) return;
+  const state = await localA2AService.getRegisteredState(
+    registered.assistantId,
+    registered.localRuntime
+  );
+  reply.send({ success: true, data: state });
+}
+async function startLocalA2AProvider(request, reply) {
+  const registered = await requireManagedAssistant(request, reply);
+  if (!registered) return;
+  const state = await localA2AService.startProvider(
+    registered.assistantId,
+    registered.localRuntime
+  );
+  reply.send({ success: true, data: state });
+}
+async function stopLocalA2AProvider(request, reply) {
+  const registered = await requireManagedAssistant(request, reply);
+  if (!registered) return;
+  const state = await localA2AService.stopProvider(registered.assistantId);
+  reply.send({ success: true, data: state });
+}
+async function restartLocalA2AProvider(request, reply) {
+  const registered = await requireManagedAssistant(request, reply);
+  if (!registered) return;
+  const state = await localA2AService.restartProvider(
+    registered.assistantId,
+    registered.localRuntime
+  );
+  reply.send({ success: true, data: state });
+}
+
+// src/config/local-a2a-templates.ts
+var import_cli_path = require("@axiom-lattice/cli-a2a/cli-path");
+function buildCliA2ACommand(provider, agentName, agentDescription) {
+  return {
+    executable: process.execPath,
+    args: [
+      import_cli_path.cliA2AEntryPath,
+      "--provider",
+      provider,
+      "--hostname",
+      "localhost",
+      "--advertise-host",
+      "localhost",
+      "--agent-name",
+      agentName,
+      "--agent-description",
+      agentDescription,
+      "--log-level",
+      "info"
+    ]
+  };
+}
+var LOCAL_A2A_TEMPLATES = [
+  {
+    key: "claude",
+    name: "Claude Code",
+    command: buildCliA2ACommand(
+      "claude",
+      "Claude Code",
+      "Local Claude Code wrapper exposed through A2A."
+    )
+  },
+  {
+    key: "codex",
+    name: "Codex",
+    command: buildCliA2ACommand(
+      "codex",
+      "Codex",
+      "Local Codex wrapper exposed through A2A."
+    )
+  },
+  {
+    key: "opencode",
+    name: "OpenCode",
+    command: buildCliA2ACommand(
+      "opencode",
+      "OpenCode",
+      "Local OpenCode wrapper exposed through A2A."
+    )
+  }
+];
+
+// src/controllers/local-a2a-templates.ts
+async function getLocalA2ATemplates(_request, reply) {
+  reply.send({
+    success: true,
+    data: {
+      records: LOCAL_A2A_TEMPLATES,
+      total: LOCAL_A2A_TEMPLATES.length
+    }
+  });
+}
+
+// src/routes/a2a-test-connection.ts
+var import_node_crypto = require("crypto");
+function describeTestConnectionError(error, agentCardUrl) {
+  if (!(error instanceof Error)) {
+    return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
+  }
+  const cause = error.cause;
+  const causeParts = [];
+  if (cause instanceof Error) {
+    causeParts.push(cause.message);
+    const causeCode = cause.code;
+    if (causeCode && !causeParts.some((part) => part.includes(causeCode))) {
+      causeParts.push(causeCode);
+    }
+  } else if (typeof cause === "object" && cause !== null) {
+    const code = "code" in cause ? String(cause.code) : "";
+    const message = "message" in cause ? String(cause.message) : "";
+    if (message) causeParts.push(message);
+    if (code && !message.includes(code)) causeParts.push(code);
+  }
+  const detail = causeParts.length > 0 ? ` (${causeParts.join(", ")})` : "";
+  return `Failed to fetch agent card from ${agentCardUrl}: ${error.message}${detail}`;
+}
+async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
+  const commandValidation = validateLocalRuntimeCommand(localRuntime);
+  if (!commandValidation.ok) {
+    return { error: commandValidation.error };
+  }
+  const testRuntime = {
+    ...localRuntime,
+    agentCardUrl,
+    command: {
+      ...localRuntime.command,
+      executable: localRuntime.command.executable.trim()
+    }
+  };
+  const portValidation = validateLocalRuntimePort(testRuntime, agentCardUrl);
+  if (!portValidation.ok) {
+    return { error: portValidation.error };
+  }
+  const state = await localA2AService.startProvider(
+    `test-${(0, import_node_crypto.randomUUID)()}`,
+    testRuntime
+  );
+  if (state.status === "running") return { runtimeId: state.runtimeId };
+  const detail = state.message ? ` ${state.message}` : "";
+  localA2AService.removeState(state.runtimeId);
+  return { error: `Local managed A2A server could not start for connection test.${detail}` };
+}
+async function readShortResponseBody(resp) {
+  const body = await resp.text().catch(() => "");
+  return body.length > 500 ? `${body.slice(0, 500)}...` : body;
+}
+function registerA2ATestConnectionRoute(app2) {
+  app2.post("/api/a2a/test-connection", async (request, reply) => {
+    const { agentCardUrl, apiKey, localRuntime } = request.body ?? {};
+    const normalizedAgentCardUrl = normalizeA2AAgentCardUrl(
+      agentCardUrl,
+      localRuntime ? "http://" : "https://"
+    );
+    if (!normalizedAgentCardUrl) {
+      return reply.status(400).send({ success: false, error: "agentCardUrl is required" });
+    }
+    let testRuntimeId = null;
+    try {
+      const headers = {};
+      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+      if (localRuntime) {
+        const localStartResult = await ensureLocalRuntimeForConnectionTest(localRuntime, normalizedAgentCardUrl);
+        if ("error" in localStartResult) {
+          return reply.send({ success: true, data: { reachable: false, error: localStartResult.error } });
+        }
+        testRuntimeId = localStartResult.runtimeId;
+      }
+      const resp = await fetch(normalizedAgentCardUrl, { headers, signal: AbortSignal.timeout(8e3) });
+      if (!resp.ok) {
+        const body = await readShortResponseBody(resp);
+        const suffix = body ? `: ${body}` : "";
+        return reply.send({ success: true, data: { reachable: false, error: `HTTP ${resp.status} ${resp.statusText}${suffix}` } });
+      }
+      const card = await resp.json();
+      return reply.send({ success: true, data: { reachable: true, agentName: card.name, agentCard: card } });
+    } catch (error) {
+      return reply.send({
+        success: true,
+        data: {
+          reachable: false,
+          error: describeTestConnectionError(error, normalizedAgentCardUrl)
+        }
+      });
+    } finally {
+      if (testRuntimeId) {
+        localA2AService.removeState(testRuntimeId);
+      }
+    }
+  });
+}
+
 // src/routes/index.ts
 var registerLatticeRoutes = (app2, channelDeps) => {
   registerA2ABridgeRoutes(app2);
   registerSTTRoutes(app2);
+  app2.get("/api/local-a2a", getLocalA2AStatus);
+  app2.get("/api/local-a2a/templates", getLocalA2ATemplates);
+  app2.get("/api/local-a2a/:assistantId", getLocalA2AProvider);
+  app2.post("/api/local-a2a/:assistantId/start", startLocalA2AProvider);
+  app2.post("/api/local-a2a/:assistantId/stop", stopLocalA2AProvider);
+  app2.post("/api/local-a2a/:assistantId/restart", restartLocalA2AProvider);
+  registerA2ATestConnectionRoute(app2);
   app2.post("/api/runs", createRun);
   app2.post("/api/resume_stream", resumeStream);
   app2.post("/api/assistants/:assistantId/threads/:threadId/abort", abortRun);
@@ -10086,12 +11008,12 @@ function registerResourceRoutes(app2, controller) {
 }
 
 // src/export_registrations/index.ts
-var import_core52 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 
 // src/export_registrations/skill.registration.ts
-var import_core39 = require("@axiom-lattice/core");
+var import_core40 = require("@axiom-lattice/core");
 function getStore2() {
-  return (0, import_core39.getStoreLattice)("default", "skill").store;
+  return (0, import_core40.getStoreLattice)("default", "skill").store;
 }
 var skillRegistration = {
   entityType: "skill",
@@ -10166,9 +11088,9 @@ var skillRegistration = {
 };
 
 // src/export_registrations/agent.registration.ts
-var import_core40 = require("@axiom-lattice/core");
+var import_core41 = require("@axiom-lattice/core");
 function getStore3() {
-  return (0, import_core40.getStoreLattice)("default", "assistant").store;
+  return (0, import_core41.getStoreLattice)("default", "assistant").store;
 }
 var agentRegistration = {
   entityType: "agent",
@@ -10235,9 +11157,9 @@ var agentRegistration = {
 };
 
 // src/export_registrations/binding.registration.ts
-var import_core41 = require("@axiom-lattice/core");
+var import_core42 = require("@axiom-lattice/core");
 function getStore4() {
-  return (0, import_core41.getStoreLattice)("default", "channelBinding").store;
+  return (0, import_core42.getStoreLattice)("default", "channelBinding").store;
 }
 var bindingRegistration = {
   entityType: "binding",
@@ -10325,9 +11247,9 @@ var bindingRegistration = {
 };
 
 // src/export_registrations/database-config.registration.ts
-var import_core42 = require("@axiom-lattice/core");
+var import_core43 = require("@axiom-lattice/core");
 function getStore5() {
-  return (0, import_core42.getStoreLattice)("default", "database").store;
+  return (0, import_core43.getStoreLattice)("default", "database").store;
 }
 var databaseConfigRegistration = {
   entityType: "database_config",
@@ -10407,9 +11329,9 @@ var databaseConfigRegistration = {
 };
 
 // src/export_registrations/metrics-config.registration.ts
-var import_core43 = require("@axiom-lattice/core");
+var import_core44 = require("@axiom-lattice/core");
 function getStore6() {
-  return (0, import_core43.getStoreLattice)("default", "metrics").store;
+  return (0, import_core44.getStoreLattice)("default", "metrics").store;
 }
 var metricsConfigRegistration = {
   entityType: "metrics_config",
@@ -10489,9 +11411,9 @@ var metricsConfigRegistration = {
 };
 
 // src/export_registrations/mcp-config.registration.ts
-var import_core44 = require("@axiom-lattice/core");
+var import_core45 = require("@axiom-lattice/core");
 function getStore7() {
-  return (0, import_core44.getStoreLattice)("default", "mcp").store;
+  return (0, import_core45.getStoreLattice)("default", "mcp").store;
 }
 var mcpConfigRegistration = {
   entityType: "mcp_config",
@@ -10574,9 +11496,9 @@ var mcpConfigRegistration = {
 };
 
 // src/export_registrations/connection.registration.ts
-var import_core45 = require("@axiom-lattice/core");
+var import_core46 = require("@axiom-lattice/core");
 function getStore8() {
-  return (0, import_core45.getStoreLattice)("default", "connection").store;
+  return (0, import_core46.getStoreLattice)("default", "connection").store;
 }
 async function listAllConnections(tenantId) {
   const store2 = getStore8();
@@ -10658,9 +11580,9 @@ var connectionRegistration = {
 };
 
 // src/export_registrations/collection.registration.ts
-var import_core46 = require("@axiom-lattice/core");
+var import_core47 = require("@axiom-lattice/core");
 function getStore9() {
-  return (0, import_core46.getStoreLattice)("default", "collection").store;
+  return (0, import_core47.getStoreLattice)("default", "collection").store;
 }
 var collectionRegistration = {
   entityType: "collection",
@@ -10731,9 +11653,9 @@ var collectionRegistration = {
 };
 
 // src/export_registrations/channel-installation.registration.ts
-var import_core47 = require("@axiom-lattice/core");
+var import_core48 = require("@axiom-lattice/core");
 function getStore10() {
-  return (0, import_core47.getStoreLattice)("default", "channelInstallation").store;
+  return (0, import_core48.getStoreLattice)("default", "channelInstallation").store;
 }
 var channelInstallationRegistration = {
   entityType: "channel_installation",
@@ -10808,9 +11730,9 @@ var channelInstallationRegistration = {
 };
 
 // src/export_registrations/menu.registration.ts
-var import_core48 = require("@axiom-lattice/core");
+var import_core49 = require("@axiom-lattice/core");
 function getStore11() {
-  return (0, import_core48.getStoreLattice)("default", "menu").store;
+  return (0, import_core49.getStoreLattice)("default", "menu").store;
 }
 var menuRegistration = {
   entityType: "menu",
@@ -10888,9 +11810,9 @@ var menuRegistration = {
 };
 
 // src/export_registrations/task.registration.ts
-var import_core49 = require("@axiom-lattice/core");
+var import_core50 = require("@axiom-lattice/core");
 function getStore12() {
-  return (0, import_core49.getStoreLattice)("default", "task").store;
+  return (0, import_core50.getStoreLattice)("default", "task").store;
 }
 var taskRegistration = {
   entityType: "task",
@@ -10976,9 +11898,9 @@ var taskRegistration = {
 };
 
 // src/export_registrations/a2a-api-key.registration.ts
-var import_core50 = require("@axiom-lattice/core");
+var import_core51 = require("@axiom-lattice/core");
 function getStore13() {
-  return (0, import_core50.getStoreLattice)("default", "a2aApiKey").store;
+  return (0, import_core51.getStoreLattice)("default", "a2aApiKey").store;
 }
 var a2aApiKeyRegistration = {
   entityType: "a2a_api_key",
@@ -11049,9 +11971,9 @@ var a2aApiKeyRegistration = {
 };
 
 // src/export_registrations/eval.registration.ts
-var import_core51 = require("@axiom-lattice/core");
+var import_core52 = require("@axiom-lattice/core");
 function getStore14() {
-  return (0, import_core51.getStoreLattice)("default", "eval").store;
+  return (0, import_core52.getStoreLattice)("default", "eval").store;
 }
 var evalRegistration = {
   entityType: "eval",
@@ -11377,7 +12299,7 @@ var evalRegistration = {
 
 // src/export_registrations/index.ts
 function registerAllBuiltinEntities() {
-  const registry = import_core52.ExportableEntityRegistry.getInstance();
+  const registry = import_core53.ExportableEntityRegistry.getInstance();
   registry.register(skillRegistration);
   registry.register(agentRegistration);
   registry.register(bindingRegistration);
@@ -11394,7 +12316,7 @@ function registerAllBuiltinEntities() {
 }
 
 // src/router/MessageRouter.ts
-var import_core53 = require("@axiom-lattice/core");
+var import_core54 = require("@axiom-lattice/core");
 var import_crypto10 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
@@ -11555,7 +12477,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core53.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -11592,7 +12514,7 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core53.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
           const newThreadId = (0, import_crypto10.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
@@ -11632,7 +12554,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core53.agentInstanceManager.getAgent({
+        const agent = import_core54.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -11877,7 +12799,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core57 = require("@axiom-lattice/core");
+var import_core58 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -11942,7 +12864,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core54 = require("@axiom-lattice/core");
+var import_core55 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -11960,17 +12882,17 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core54.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core54.QueueMode.STEER);
+    const agent = import_core55.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core55.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core54.eventBus.publish(callback_event, {
+        import_core55.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core54.agentInstanceManager.getAgent({
+            const mainAgent = import_core55.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id,
@@ -12000,7 +12922,7 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core54.eventBus.publish(callback_event, {
+        import_core55.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
@@ -12019,11 +12941,11 @@ ${summary}`
       console.log(
         `\u5C06\u5728 ${delayMs}ms \u540E\u91CD\u8BD5\u4EFB\u52A1 (${nextRetryCount}/${maxRetries})`
       );
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core54.eventBus.publish(callback_event, {
+      import_core55.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -12060,7 +12982,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core54.eventBus.subscribe(import_core54.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core55.eventBus.subscribe(import_core55.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -12179,7 +13101,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core54.eventBus.publish(taskRequest.callback_event, {
+        import_core55.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -12194,8 +13116,8 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core58 = require("@axiom-lattice/core");
-var import_protocols5 = require("@axiom-lattice/protocols");
+var import_core59 = require("@axiom-lattice/core");
+var import_protocols7 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
@@ -12203,18 +13125,18 @@ process.on("unhandledRejection", (reason, promise) => {
 var DEFAULT_LOGGER_CONFIG = {
   name: "default",
   description: "Default logger for lattice-gateway service",
-  type: import_protocols5.LoggerType.PINO,
+  type: import_protocols7.LoggerType.PINO,
   serviceName: "lattice/gateway",
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger5 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core58.loggerLatticeManager.hasLattice("default")) {
-    import_core58.loggerLatticeManager.removeLattice("default");
+  if (import_core59.loggerLatticeManager.hasLattice("default")) {
+    import_core59.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core58.registerLoggerLattice)("default", config);
-  return (0, import_core58.getLoggerLattice)("default");
+  (0, import_core59.registerLoggerLattice)("default", config);
+  return (0, import_core59.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -12325,7 +13247,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core58.createSandboxProvider)({
+  return (0, import_core59.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -12341,7 +13263,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core58.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core59.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger5.info("MCP store not configured, skipping connection restoration");
@@ -12355,15 +13277,15 @@ async function restoreMcpConnections() {
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection2(config.config);
-        import_core58.mcpManager.addServer(config.key, connection);
+        import_core59.mcpManager.addServer(config.key, connection);
       } catch (err) {
         logger5.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
       }
     }
-    await import_core58.mcpManager.connect();
+    await import_core59.mcpManager.connect();
     for (const config of connectedConfigs) {
       try {
-        await import_core58.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        await import_core59.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
         logger5.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
       } catch (err) {
         logger5.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
@@ -12396,7 +13318,7 @@ var start = async (config) => {
       const { getStoreLattice: getStore15 } = await import("@axiom-lattice/core");
       const bindingStore = getStore15("default", "channelBinding").store;
       const installationStore = getStore15("default", "channelInstallation").store;
-      (0, import_core57.setBindingRegistry)(bindingStore);
+      (0, import_core58.setBindingRegistry)(bindingStore);
       const router = new MessageRouter({
         middlewares: [
           createDeduplicationMiddleware(),
@@ -12421,10 +13343,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core57.setEvalRunService)(evalRunner);
+    (0, import_core58.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core58.getStoreLattice)("default", "menu").store;
-      (0, import_core57.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core59.getStoreLattice)("default", "menu").store;
+      (0, import_core58.setMenuRegistry)(menuStore);
       logger5.info("Menu registry initialized");
     } catch {
     }
@@ -12433,17 +13355,17 @@ var start = async (config) => {
       setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
     }
     registerLatticeRoutes(app, channelDeps);
-    if (!import_core58.sandboxLatticeManager.hasLattice("default")) {
-      import_core58.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core59.sandboxLatticeManager.hasLattice("default")) {
+      import_core59.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger5.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core58.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core58.TokenCache();
+      const sharedResourceStore = (0, import_core59.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core59.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core58.sandboxLatticeManager,
+        sandboxManager: import_core59.sandboxLatticeManager,
         cache,
         logger: logger5
       });
@@ -12470,11 +13392,6 @@ var start = async (config) => {
     const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger5.info(`Lattice Gateway is running on port: ${target_port}`);
-    try {
-      logger5.info("AgentLifecycleManager initialized");
-    } catch (error) {
-      logger5.warn("Failed to initialize AgentLifecycleManager", { error });
-    }
     const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
       setQueueServiceType(queueServiceConfig.type);
@@ -12484,7 +13401,7 @@ var start = async (config) => {
       }
     }
     if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      import_core58.agentInstanceManager.restore().then((stats) => {
+      import_core59.agentInstanceManager.restore().then((stats) => {
         logger5.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
       }).catch((error) => {
         logger5.error("Agent recovery failed", { error });