@axiom-lattice/core 4.4.0 → 5.0.0

package/dist/index.mjs

@@ -445,11 +445,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key5, tool71) {
+  registerExistingTool(key5, tool68) {
     const config = {
-      name: tool71.name,
-      description: tool71.description,
-      schema: tool71.schema,
+      name: tool68.name,
+      description: tool68.description,
+      schema: tool68.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -457,7 +457,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key: key5,
       config,
-      client: tool71
+      client: tool68
     };
     this.register(key5, toolLattice);
   }
@@ -468,14 +468,14 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key - tool lattice key (no tenant prefix)
    * @param tool - the StructuredTool client
    */
-  registerExistingToolWithTenant(tenantId2, key5, tool71) {
+  registerExistingToolWithTenant(tenantId2, key5, tool68) {
     const config = {
-      name: tool71.name,
-      description: tool71.description,
-      schema: tool71.schema,
+      name: tool68.name,
+      description: tool68.description,
+      schema: tool68.schema,
       needUserApprove: false
     };
-    const toolLattice = { key: key5, config, client: tool71 };
+    const toolLattice = { key: key5, config, client: tool68 };
     this.registerWithTenant(tenantId2, key5, toolLattice);
   }
   /**
@@ -525,8 +525,8 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key5, config, executor) => toolLatticeManager.registerLattice(key5, config, executor);
-var registerExistingTool = (key5, tool71) => toolLatticeManager.registerExistingTool(key5, tool71);
-var registerExistingToolWithTenant = (tenantId2, key5, tool71) => toolLatticeManager.registerExistingToolWithTenant(tenantId2, key5, tool71);
+var registerExistingTool = (key5, tool68) => toolLatticeManager.registerExistingTool(key5, tool68);
+var registerExistingToolWithTenant = (tenantId2, key5, tool68) => toolLatticeManager.registerExistingToolWithTenant(tenantId2, key5, tool68);
 var getToolLattice = (key5) => toolLatticeManager.getToolLattice(key5);
 var getToolClientWithTenant = (tenantId2, key5) => toolLatticeManager.getToolClientWithTenant(tenantId2, key5);
 var getToolDefinition = (key5) => toolLatticeManager.getToolDefinition(key5);
@@ -1363,15 +1363,15 @@ ${body}` : `${frontmatter}
     const resourcesDir = path.join(skillDir, "resources");
     try {
       const entries = await fs.readdir(resourcesDir, { withFileTypes: true, recursive: true });
-      const resources3 = [];
+      const resources2 = [];
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           const fullPath = path.join(entry.path, entry.name);
           const relativePath = path.relative(resourcesDir, fullPath);
-          resources3.push(relativePath.replace(/\\/g, "/"));
+          resources2.push(relativePath.replace(/\\/g, "/"));
         }
       }
-      return resources3.sort();
+      return resources2.sort();
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -11661,11 +11661,11 @@ var PluginRegistry = class {
         if (!isRecord2(rawDefinition) || typeof rawDefinition.version !== "string" || rawDefinition.version.trim().length === 0 || typeof rawDefinition.content !== "string") {
           throw new Error(`Plugin "${key5}": skill "${name}" version and content must be a string`);
         }
-        const resources3 = rawDefinition.resources;
-        if (resources3 !== void 0 && !isRecord2(resources3)) {
+        const resources2 = rawDefinition.resources;
+        if (resources2 !== void 0 && !isRecord2(resources2)) {
           throw new Error(`Plugin "${key5}": skill "${name}" resources must be an object`);
         }
-        for (const [path8, resource] of Object.entries(resources3 ?? {})) {
+        for (const [path8, resource] of Object.entries(resources2 ?? {})) {
           try {
             validateRelativePath(path8, "resource");
           } catch {
@@ -12818,7 +12818,7 @@ function isSafeUiPath(path8) {
 }
 function validateSandboxPluginManifest(args) {
   const diagnostics = [];
-  const error = (code, message, pluginType, tool71) => diagnostics.push({ level: "error", code, message, pluginType, tool: tool71 });
+  const error = (code, message, pluginType, tool68) => diagnostics.push({ level: "error", code, message, pluginType, tool: tool68 });
   const raw = args.raw;
   if (!isRecord5(raw)) {
     error("MANIFEST_NOT_OBJECT", "manifest must be a JSON object", args.dirName);
@@ -13826,9 +13826,9 @@ function freezeMetadata(metadata) {
     ...resourceSelector ? { resourceSelector } : {}
   });
 }
-function toolName(tool71) {
-  if (typeof tool71 !== "object" || tool71 === null || !("name" in tool71)) return void 0;
-  return typeof tool71.name === "string" ? tool71.name : void 0;
+function toolName(tool68) {
+  if (typeof tool68 !== "object" || tool68 === null || !("name" in tool68)) return void 0;
+  return typeof tool68.name === "string" ? tool68.name : void 0;
 }
 function schemaHasConnectionKey(schema6) {
   const definition = isRecord7(schema6._def) ? schema6._def : void 0;
@@ -13836,10 +13836,10 @@ function schemaHasConnectionKey(schema6) {
   const fields = typeof shape === "function" ? shape() : shape;
   return isRecord7(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
 }
-function hasConnectionKeySchema(tool71) {
-  if (!isRecord7(tool71) || !isRecord7(tool71.schema)) return false;
-  if (schemaHasConnectionKey(tool71.schema)) return true;
-  const definition = isRecord7(tool71.schema._def) ? tool71.schema._def : void 0;
+function hasConnectionKeySchema(tool68) {
+  if (!isRecord7(tool68) || !isRecord7(tool68.schema)) return false;
+  if (schemaHasConnectionKey(tool68.schema)) return true;
+  const definition = isRecord7(tool68.schema._def) ? tool68.schema._def : void 0;
   if (Array.isArray(definition?.options) && definition.options.length > 0) {
     return definition.options.every(
       (option) => isRecord7(option) && schemaHasConnectionKey(option)
@@ -13894,8 +13894,8 @@ var CapabilityToolRegistry = class {
    * @remarks Standard connection authorization is captured only for tools whose
    * schema declares `connectionKey`; legacy selectors remain explicit metadata.
    */
-  register(name, metadata, tool71) {
-    this.registerInternal(name, metadata, hasConnectionKeySchema(tool71));
+  register(name, metadata, tool68) {
+    this.registerInternal(name, metadata, hasConnectionKeySchema(tool68));
   }
   /**
    * Registers all tools actually exposed by a middleware instance.
@@ -13906,13 +13906,13 @@ var CapabilityToolRegistry = class {
    * @returns Nothing.
    */
   registerMiddleware(capabilityType, middleware, resourceSelectors = {}) {
-    for (const tool71 of middleware.tools ?? []) {
-      const name = toolName(tool71);
+    for (const tool68 of middleware.tools ?? []) {
+      const name = toolName(tool68);
       if (name) {
         this.registerInternal(name, {
           capabilityType,
           resourceSelector: resourceSelectors[name]
-        }, hasConnectionKeySchema(tool71));
+        }, hasConnectionKeySchema(tool68));
       }
     }
   }
@@ -14604,9 +14604,9 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool71 = getToolClientWithTenant(params.tenantId ?? "default", t.key);
-      return tool71;
-    }).filter((tool71) => tool71 !== void 0);
+      const tool68 = getToolClientWithTenant(params.tenantId ?? "default", t.key);
+      return tool68;
+    }).filter((tool68) => tool68 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
@@ -15779,8 +15779,8 @@ function validateCapability(value, index) {
         fieldPath: `/capabilities/${index}/allowedTools`
       });
     }
-    for (const [toolIndex, tool71] of capability.allowedTools.entries()) {
-      if (typeof tool71 !== "string") {
+    for (const [toolIndex, tool68] of capability.allowedTools.entries()) {
+      if (typeof tool68 !== "string") {
         throw new CapabilityBundleValidationError(
           "CAPABILITY_BUNDLE_INVALID_CAPABILITY",
           "allowedTools entries must be strings",
@@ -15794,10 +15794,10 @@ function validateCapability(value, index) {
         fieldPath: `/capabilities/${index}/allowedTools`
       });
     }
-    const toolNames = new Set(plugin.meta.tools.map((tool71) => tool71.name));
-    for (const [toolIndex, tool71] of capability.allowedTools.entries()) {
-      if (typeof tool71 !== "string" || !toolNames.has(tool71)) {
-        throw new CapabilityBundleValidationError("CAPABILITY_BUNDLE_UNKNOWN_TOOL", `Unknown tool '${String(tool71)}'`, {
+    const toolNames = new Set(plugin.meta.tools.map((tool68) => tool68.name));
+    for (const [toolIndex, tool68] of capability.allowedTools.entries()) {
+      if (typeof tool68 !== "string" || !toolNames.has(tool68)) {
+        throw new CapabilityBundleValidationError("CAPABILITY_BUNDLE_UNKNOWN_TOOL", `Unknown tool '${String(tool68)}'`, {
           capabilityType,
           fieldPath: `/capabilities/${index}/allowedTools/${toolIndex}`
         });
@@ -16280,7 +16280,7 @@ function applyStaticCeiling(capabilities, staticMiddleware) {
     const projectTools = capability.allowedTools;
     const staticTools = ceiling.allowedTools;
     const effectiveStaticTools = staticTools?.length === 0 ? void 0 : staticTools;
-    const allowedTools = projectTools === void 0 ? effectiveStaticTools : effectiveStaticTools === void 0 ? projectTools : projectTools.filter((tool71) => effectiveStaticTools.includes(tool71));
+    const allowedTools = projectTools === void 0 ? effectiveStaticTools : effectiveStaticTools === void 0 ? projectTools : projectTools.filter((tool68) => effectiveStaticTools.includes(tool68));
     runtime[capability.type] = structuredClone({
       ...capability,
       config: applyStaticResourceCeiling(capability, ceiling),
@@ -22040,7 +22040,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClientWithTenant(params.tenantId ?? "default", t.key);
       return toolClient;
-    }).filter((tool71) => tool71 !== void 0);
+    }).filter((tool68) => tool68 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -23688,7 +23688,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClientWithTenant(params.tenantId ?? "default", t.key);
       return toolClient;
-    }).filter((tool71) => tool71 !== void 0);
+    }).filter((tool68) => tool68 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -28080,7 +28080,7 @@ function requireSkillDeclaration(skillLoaded) {
   return void 0;
 }
 async function validateAgentReferences(input, tenantId2) {
-  const availableTools = getAvailableTools(tenantId2).map((tool71) => tool71.key);
+  const availableTools = getAvailableTools(tenantId2).map((tool68) => tool68.key);
   const availableMiddlewareTypes = getAvailableMiddlewareTypes();
   const availableCustomMiddlewareKeys = CustomMiddlewareRegistry.list().filter(
     (key5) => CustomMiddlewareRegistry.get(key5) !== void 0
@@ -31065,15 +31065,15 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     const metaByName = new Map(metaList.map((m) => [m.name, m.meta]));
     this.unregisterServerTools(tenantId2, serverKey);
     const keys = [];
-    for (const tool71 of tools) {
-      if (rt.selectedTools && !rt.selectedTools.includes(tool71.name)) continue;
-      const meta = metaByName.get(tool71.name);
+    for (const tool68 of tools) {
+      if (rt.selectedTools && !rt.selectedTools.includes(tool68.name)) continue;
+      const meta = metaByName.get(tool68.name);
       const rawVisibility = meta?.ui?.visibility;
       const visibility = Array.isArray(rawVisibility) ? rawVisibility : typeof rawVisibility === "string" ? [rawVisibility] : void 0;
       if (visibility && !visibility.includes("model")) continue;
       const ref = extractAppsRef(meta, serverKey);
-      const registered = ref ? wrapMcpToolWithUi(tool71, ref) : tool71;
-      const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool71.name);
+      const registered = ref ? wrapMcpToolWithUi(tool68, ref) : tool68;
+      const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool68.name);
       try {
         toolLatticeManager.registerExistingToolWithTenant(tenantId2, toolKey, registered);
         keys.push(toolKey);
@@ -38862,10 +38862,10 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
             lockIdentity
           );
           let result2 = pluginSkill.definition.content;
-          const resources3 = Object.entries(pluginSkill.definition.resources ?? {});
-          if (resources3.length > 0) {
+          const resources2 = Object.entries(pluginSkill.definition.resources ?? {});
+          if (resources2.length > 0) {
             result2 += "\n\n---\n\n**Resources** (synced to the sandbox; use `read_file` to access):\n";
-            for (const [resourcePath, resource] of resources3) {
+            for (const [resourcePath, resource] of resources2) {
               result2 += `- ${resourcePath} (mime type: ${resource.mimeType ?? "not specified"})
 `;
             }
@@ -38892,10 +38892,10 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
             `/root/.agents/skills/${input.skill_name}/resources`,
             { recursive: false }
           );
-          const resources3 = resourcesResult.files.map((f) => f.path.split("/").pop()).filter(Boolean);
-          if (resources3.length > 0) {
+          const resources2 = resourcesResult.files.map((f) => f.path.split("/").pop()).filter(Boolean);
+          if (resources2.length > 0) {
             result += "\n\n---\n\n**Resources** (use `read_file` tool to access):\n";
-            resources3.forEach((r) => {
+            resources2.forEach((r) => {
               result += `- ${r}
 `;
             });
@@ -39217,1554 +39217,13 @@ var skillPlugin = {
   })
 };
 
-// src/middlewares/semanticMetricsMiddleware.ts
+// src/middlewares/collectionMiddleware.ts
 import { createMiddleware as createMiddleware20 } from "langchain";
 
-// src/tool_lattice/semantic_metrics/metrics_datasource_tool.ts
+// src/tool_lattice/collection/list_collections.ts
 import z57 from "zod";
 import { tool as tool51 } from "langchain";
 
-// src/tool_lattice/semantic_metrics/types.ts
-function readToolRunConfig(exeConfig) {
-  return exeConfig?.configurable?.runConfig;
-}
-function resolveDatasourceId(input, exeConfig) {
-  const id = input.datasourceId ?? readToolRunConfig(exeConfig)?.metricsDataSource?.datasourceId;
-  if (id === void 0 || id === null || id === "") {
-    throw new Error("datasourceId is required (provide it or set runConfig.metricsDataSource.datasourceId)");
-  }
-  return Number(id);
-}
-function assertDatasourceSelected(scope, datasourceId) {
-  if (scope.unrestricted) return;
-  if (!scope.ids.includes(datasourceId)) {
-    throw new Error(
-      `DATASOURCE_NOT_SELECTED: datasource ${datasourceId} is not in the effective scope [${scope.ids.join(", ")}]`
-    );
-  }
-}
-function effectiveDatasourceScope(connectionScope) {
-  return connectionScope.length > 0 ? { unrestricted: false, ids: [...connectionScope] } : { unrestricted: true, ids: [] };
-}
-var DDL_DML_KEYWORDS = [
-  "insert",
-  "update",
-  "delete",
-  "drop",
-  "alter",
-  "create",
-  "truncate",
-  "grant",
-  "revoke",
-  "merge",
-  "replace",
-  "upsert"
-];
-var DDL_DML_RE = new RegExp(`\\b(?:${DDL_DML_KEYWORDS.join("|")})\\b`, "i");
-var SELECT_INTO_RE = /\bselect\b[\s\S]*?\binto\b/i;
-function validateSql(sql) {
-  const trimmed = sql.trim();
-  if (!trimmed) {
-    return { ok: false, reason: "SQL is empty" };
-  }
-  const withoutComments = trimmed.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ");
-  const statements = withoutComments.split(";").map((s) => s.trim()).filter(Boolean);
-  if (statements.length > 1) {
-    return { ok: false, reason: "Multiple statements are not allowed" };
-  }
-  const firstKeyword = withoutComments.trim().split(/\s+/)[0].toLowerCase();
-  if (firstKeyword !== "select" && firstKeyword !== "with") {
-    return { ok: false, reason: `Only SELECT or WITH queries are allowed (got "${firstKeyword}")` };
-  }
-  if (SELECT_INTO_RE.test(withoutComments)) {
-    return { ok: false, reason: "SELECT INTO is not allowed (creates a table)" };
-  }
-  if (DDL_DML_RE.test(withoutComments)) {
-    return { ok: false, reason: "Only read-only queries are allowed (DML/DDL detected)" };
-  }
-  return { ok: true };
-}
-
-// src/tool_lattice/semantic_metrics/SemanticMetricsV2Client.ts
-var NO_CONNECTION_HINT = "No semantic-metrics connection is configured for this tenant. Add a connection of type 'semantic-metrics' for the tenant, then select it (connections) or enable connectAll in the agent's middleware config.";
-async function resolveMetricsClientFromSelector(selector, scope, connectionKey) {
-  let resolved;
-  try {
-    resolved = await resolvePluginConnections(selector.connectionType, selector, scope);
-  } catch (error) {
-    if (error instanceof Error && error.message === "ConnectionStore not configured") {
-      throw new Error(NO_CONNECTION_HINT);
-    }
-    throw error;
-  }
-  const available = resolved.map((c) => c.key).join(", ");
-  if (resolved.length === 0) {
-    throw new Error(NO_CONNECTION_HINT);
-  }
-  const key5 = connectionKey?.trim() || (resolved.length === 1 ? resolved[0].key : "");
-  if (!key5) {
-    throw new Error(
-      `connectionKey is required. Available connections: ${available}`
-    );
-  }
-  const entry = resolved.find((c) => c.key === key5);
-  if (!entry) {
-    throw new Error(`Connection "${key5}" not found. Available connections: ${available}`);
-  }
-  const config = entry.config;
-  return new SemanticMetricsV2Client(config);
-}
-var SemanticMetricsV2Client = class {
-  /**
-   * @param config - Connection configuration (server URL, optional API key and headers).
-   */
-  constructor(config) {
-    this.config = config;
-    this.baseUrl = config.serverUrl.replace(/\/$/, "");
-  }
-  /**
-   * Build default request headers: `Accept: application/json`, custom headers,
-   * and a Bearer `Authorization` header when an API key is configured.
-   *
-   * @returns Merged headers.
-   */
-  getHeaders() {
-    const headers = {
-      Accept: "application/json",
-      ...this.config.headers ?? {}
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    return headers;
-  }
-  /**
-   * Numeric selected resource ids of this connection (normalized).
-   *
-   * Reads `selectedEntities` — the standard connection resource-selection
-   * field written by the connection UI (`connection.discover` + selection).
-   *
-   * @returns The selected resource ids; empty when unrestricted.
-   */
-  getSelectedEntities() {
-    const raw = this.config.selectedEntities;
-    if (!Array.isArray(raw)) return [];
-    return raw.map((v) => Number(v)).filter((n) => Number.isFinite(n));
-  }
-  /**
-   * Perform a JSON request against the base URL.
-   *
-   * The Metrics Server wraps every response as `{ code, message, data }`. A
-   * `code` of 200 resolves to `data`; any other `code` throws a business error
-   * carrying the server message (regardless of HTTP status). Non-envelope
-   * bodies are returned as-is.
-   *
-   * @param path - Path appended to the base URL (must start with `/`).
-   * @param init - Optional `fetch` init overrides (method, body, per-call headers).
-   * @returns The unwrapped `data` payload of the response envelope.
-   * @throws When the server returns a non-200 `code`, or the HTTP response is not OK.
-   */
-  async request(path8, init = {}) {
-    const response = await fetch(`${this.baseUrl}${path8}`, {
-      ...init,
-      method: init.method ?? "GET",
-      headers: { ...this.getHeaders(), ...init.headers ?? {} }
-    });
-    const text = await response.text().catch(() => "");
-    const parsed = this.parseBody(text);
-    if (parsed?.envelope === true) {
-      if (parsed.code !== 200) {
-        throw new Error(`API ${parsed.code}: ${parsed.message || "Unknown error"}`);
-      }
-      return parsed.data;
-    }
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
-    }
-    return parsed?.value ?? void 0;
-  }
-  /**
-   * Parse a response body text. Detects the server envelope `{ code, message, data }`.
-   *
-   * @param text - Raw response body text.
-   * @returns `{ envelope: true, code, message, data }` for an envelope body,
-   *   `{ envelope: false, value }` for anything else (or `{ envelope: false }` when empty/invalid).
-   */
-  parseBody(text) {
-    if (!text.trim()) return { envelope: false };
-    try {
-      const value = JSON.parse(text);
-      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        const record = value;
-        if (typeof record.code === "number") {
-          return {
-            envelope: true,
-            code: record.code,
-            message: typeof record.message === "string" ? record.message : void 0,
-            data: record.data
-          };
-        }
-      }
-      return { envelope: false, value };
-    } catch {
-      return { envelope: false, value: text };
-    }
-  }
-  /**
-   * POST a JSON body to a path.
-   *
-   * @param path - Path appended to the base URL.
-   * @param body - Payload serialized as JSON.
-   * @returns Parsed JSON response body.
-   */
-  post(path8, body) {
-    return this.request(path8, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * PUT a JSON body to a path.
-   *
-   * @param path - Path appended to the base URL.
-   * @param body - Payload serialized as JSON.
-   * @returns Parsed JSON response body.
-   */
-  put(path8, body) {
-    return this.request(path8, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * List all datasources.
-   *
-   * @returns Parsed JSON response body.
-   */
-  listDatasources() {
-    return this.request("/datasources");
-  }
-  /**
-   * Get table grants for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getTableGrants(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/table-grants`);
-  }
-  /**
-   * Run a read-only SQL query against a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param input - Query input: `sql` (SELECT/WITH only), optional `params`, `maxRows`, `debug`.
-   * @returns Parsed JSON response body.
-   * @throws When `sql` fails read-only validation (rejected before any fetch).
-   */
-  async queryDatasource(datasourceId, input) {
-    const validation = validateSql(input.sql);
-    if (!validation.ok) throw new Error(`SQL_NOT_ALLOWED: ${validation.reason}`);
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/query`, input);
-  }
-  /**
-   * Test a datasource connection.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  testDatasource(datasourceId) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/test`, {});
-  }
-  /**
-   * Get connection-pool status for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getPoolStatus(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/pool`);
-  }
-  /**
-   * List table metadata for a datasource, auto-paginating.
-   *
-   * The server pages this collection (`page`/`pageSize`, default page size 20),
-   * so requests aggregate every page into one `{ items, total }` result.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns `{ items: [...], total }` covering all pages.
-   */
-  async listTables(datasourceId) {
-    return this.listMetaPage(`/datasources/${encodeURIComponent(datasourceId)}/meta/tables`);
-  }
-  /**
-   * Shared pagination walk for the paged meta collections (`{items,total,page,pageSize}`).
-   *
-   * @param basePath - Collection path (tables or metrics).
-   * @returns `{ items, total }` aggregated across all pages.
-   */
-  async listMetaPage(basePath) {
-    const pageSize = 100;
-    const items = [];
-    let total = Number.POSITIVE_INFINITY;
-    for (let page = 1; items.length < total; page += 1) {
-      const body = await this.request(`${basePath}?page=${page}&pageSize=${pageSize}`);
-      const record = body !== null && typeof body === "object" ? body : {};
-      const batch = Array.isArray(record.items) ? record.items : [];
-      items.push(...batch);
-      total = typeof record.total === "number" ? record.total : items.length;
-      if (batch.length === 0) break;
-    }
-    return { items, total: items.length };
-  }
-  /**
-   * Get metadata for a single table.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param tableKey - Table key.
-   * @returns Parsed JSON response body.
-   */
-  getTable(datasourceId, tableKey) {
-    return this.request(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`
-    );
-  }
-  /**
-   * Create a table definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param payload - Table definition payload.
-   * @returns Parsed JSON response body.
-   */
-  createTable(datasourceId, payload) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/meta/tables`, payload);
-  }
-  /**
-   * Update a table definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param tableKey - Table key.
-   * @param payload - Table definition payload.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * Update a published table meta via read-modify-write.
-   *
-   * The server's PUT replaces the whole payload, so the current payload is
-   * fetched first and the incoming fields are merged on top; fields not
-   * mentioned are preserved.
-   */
-  async updateTable(datasourceId, tableKey, payload) {
-    const existing = await this.readMetaPayload(`${this.baseUrl}/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`);
-    return this.put(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`,
-      { payload: { ...existing, ...payload } }
-    );
-  }
-  /**
-   * List metric definitions for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * List metric metadata for a datasource, auto-paginating.
-   *
-   * The server pages this collection (`page`/`pageSize`, default page size 20),
-   * so requests aggregate every page into one `{ items, total }` result.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns `{ items: [...], total }` covering all pages.
-   */
-  async listMetrics(datasourceId) {
-    return this.listMetaPage(`/datasources/${encodeURIComponent(datasourceId)}/meta/metrics`);
-  }
-  /**
-   * Get a single metric definition.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param metricKey - Metric key.
-   * @returns Parsed JSON response body.
-   */
-  getMetric(datasourceId, metricKey) {
-    return this.request(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`
-    );
-  }
-  /**
-   * Create a metric definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param payload - Metric definition payload.
-   * @returns Parsed JSON response body.
-   */
-  createMetric(datasourceId, payload) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/meta/metrics`, payload);
-  }
-  /**
-   * Update a metric definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param metricKey - Metric key.
-   * @param payload - Metric definition payload.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * Update a published metric meta via read-modify-write.
-   *
-   * The server's PUT replaces the whole payload, so the current payload is
-   * fetched first and the incoming fields are merged on top; fields not
-   * mentioned are preserved.
-   */
-  async updateMetric(datasourceId, metricKey, payload) {
-    const existing = await this.readMetaPayload(`${this.baseUrl}/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`);
-    return this.put(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`,
-      { payload: { ...existing, ...payload } }
-    );
-  }
-  /**
-   * Fetch the current `payload` object of a published meta entry.
-   *
-   * The single-entry read returns `{ code, data: [entry] }` (already unwrapped
-   * to the array by {@link request}); the payload lives on the first entry.
-   *
-   * @param absoluteUrl - Full URL of the single-entry meta read.
-   * @returns The stored payload object (empty when none exists).
-   */
-  async readMetaPayload(absoluteUrl) {
-    const response = await fetch(absoluteUrl, { headers: this.getHeaders() });
-    const text = await response.text().catch(() => "");
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
-    }
-    const parsed = this.parseBody(text);
-    const data = parsed?.envelope === true ? parsed.data : parsed?.value;
-    const entry = Array.isArray(data) ? data[0] : data;
-    const payload = entry?.payload;
-    return payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  }
-  /**
-   * Get runtime metadata for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getRuntimeMeta(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/meta`);
-  }
-  /**
-   * Run a metrics query.
-   *
-   * @param request - Metrics query request payload.
-   * @returns Parsed JSON response body.
-   */
-  queryMetrics(request) {
-    return this.post("/metrics/query", request);
-  }
-  /**
-   * Run an ad-hoc custom SQL query, validated as read-only before sending.
-   *
-   * @param request - Request with `datasourceId`, `customSql` (SELECT/WITH only),
-   * and optional `limit` / `debug`.
-   * @returns Parsed JSON response body.
-   * @throws When `customSql` fails read-only validation (rejected before any fetch).
-   */
-  async customSql(request) {
-    const validation = validateSql(request.customSql);
-    if (!validation.ok) throw new Error(`SQL_NOT_ALLOWED: ${validation.reason}`);
-    return this.post("/metrics/query", request);
-  }
-};
-
-// src/tool_lattice/semantic_metrics/metrics_datasource_tool.ts
-var DESCRIPTION = `PHYSICAL LAYER EXPLORATION \u2014 the only tool for probing raw datasource structure (Builder/Admin only; business agents do not need it).
-
-OWNS: discovering datasources, reading table-grants (the exploration boundary for this tenant), and running read-only SQL (SELECT/WITH only) to inspect physical tables, columns, sample rows, and value distributions. Also: per-datasource connection test and pool status.
-
-DOES NOT OWN:
-- Published semantic assets (table meta / metric meta) \u2192 use metrics_meta_tool.
-- Runtime meta and business metric queries \u2192 use metrics_runtime_tool.
-
-USE WHEN: starting a modeling task \u2014 \`list_datasources\` is always the FIRST step: it returns the datasource ids that every other action and tool requires (get_grants, query_sql here; read_semantic_catalog, query_metrics in metrics_runtime_tool; the meta actions in metrics_meta_tool). Read grants next, then probe tables, columns, samples, and distributions within the grant. If a field's business meaning is unclear, probe sample values and distributions here before publishing anything.
-
-COMMON MISTAKES (do not):
-- Do not answer business metric questions here (e.g. "monthly sales by region") \u2014 that is metrics_runtime_tool \`query\` against published metrics, NOT this tool's \`query_sql\` (physical-table SQL).
-- Do not read or publish semantic meta through this tool \u2014 metrics_meta_tool owns the semantic layer.
-- Do not probe tables outside the tenant's table-grants; un-granted probes are rejected and break the exploration boundary.
-- Do not attempt writes \u2014 SQL is validated read-only and rejected before sending.`;
-function createMetricsDatasourceTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool51(
-    async (input, exeConfig) => {
-      try {
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const scope = effectiveDatasourceScope(client.getSelectedEntities());
-        switch (input.action) {
-          case "list_datasources": {
-            const result = await client.listDatasources();
-            const filtered = scope.unrestricted ? result : result.filter((d) => scope.ids.includes(Number(d.id)));
-            const safe = filtered.map((d) => ({
-              id: d.id,
-              name: d.name,
-              sourceType: d.sourceType,
-              description: d.description,
-              statusLabel: d.statusLabel
-            }));
-            return JSON.stringify(safe, null, 2);
-          }
-          case "get_grants": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.getTableGrants(ds);
-            return JSON.stringify(result, null, 2);
-          }
-          case "query_sql": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            if (!input.sql) throw new Error("sql is required for the 'query_sql' action");
-            const result = await client.queryDatasource(ds, {
-              sql: input.sql,
-              params: input.params,
-              maxRows: input.maxRows
-            });
-            return JSON.stringify(result, null, 2);
-          }
-          case "test_connection": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.testDatasource(ds);
-            return JSON.stringify(result, null, 2);
-          }
-          case "pool_status": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.getPoolStatus(ds);
-            return JSON.stringify(result, null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_datasource_tool",
-      description: DESCRIPTION,
-      schema: z57.object({
-        action: z57.enum(["list_datasources", "get_grants", "query_sql", "test_connection", "pool_status"]).describe(
-          "list_datasources: list datasources \u2014 ALWAYS call this first to obtain the datasource id used by every other action and tool; get_grants: read table-grants; query_sql: run read-only SQL against PHYSICAL tables (note: this is query_sql, NOT the semantic 'query' action of metrics_runtime_tool); test_connection: test the datasource; pool_status: connection-pool status"
-        ),
-        connectionKey: z57.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z57.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (required for all actions except list_datasources; optional if set in runConfig.metricsDataSource)"),
-        sql: z57.string().optional().describe("Read-only SQL (SELECT/WITH only). Required for the query action. Metadata templates \u2014 PostgreSQL/SQL Server columns: select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position; HANA columns: select column_name, data_type_name from table_columns where schema_name = :schemaName and table_name = :tableName order by position; distributions: select <dim>, count(*) as row_count from <table> group by <dim> order by row_count desc limit :maxRows"),
-        params: z57.record(z57.union([z57.string(), z57.number(), z57.boolean()])).optional().describe("Named :param values for the SQL"),
-        maxRows: z57.number().optional().describe("Max rows to return")
-      })
-    }
-  );
-}
-
-// src/tool_lattice/semantic_metrics/metrics_meta_tool.ts
-import z58 from "zod";
-import { tool as tool52 } from "langchain";
-var DESCRIPTION2 = `SEMANTIC ASSET REGISTRY (Builder/Admin only) \u2014 the only tool for reading and publishing the runtime's semantic layer: table meta (meta/tables) and metric meta (meta/metrics).
-
-OWNS: listing published tables and metrics, reading one by objectKey, publishing a semantic table (create_table: columns tagged with role dimension|measure), publishing a metric (create_metric: a metric_index payload then a metric_detail payload using the SQL-free calculation DSL), and correcting published assets (update_table / update_metric).
-
-DOES NOT OWN:
-- Running queries or reading the aggregated runtime view \u2192 metrics_runtime_tool (get_meta / query / custom_sql).
-- Probing physical tables, columns, grants, or samples \u2192 metrics_datasource_tool.
-
-USE WHEN: physical exploration is done and the model has been proposed and confirmed by the user \u2014 to publish the semantic table and metrics, or to correct published assets afterwards.
-
-COMMON MISTAKES (do not):
-- Do not call get_meta here \u2014 that action belongs to metrics_runtime_tool, not this tool.
-- Do not try to "query numbers" through this tool \u2014 list/read actions return definitions only; use metrics_runtime_tool query for data.
-- Do not publish a metric whose sourceTable has no published table meta, or whose dimensions are not published columns with role dimension \u2014 the server will reject it.
-- The builder assistant must load the semantic-metrics-modeling skill and pass modelingSkillLoaded: true on write actions; no removal actions are exposed on purpose.`;
-var MODELING_SKILL_NAME = "semantic-metrics-modeling";
-var BUILDER_ASSISTANT_ID = "semantic-metrics-builder";
-function requireModelingSkillLoaded(action, input, exeConfig) {
-  const isWriteAction = action === "create_table" || action === "update_table" || action === "create_metric" || action === "update_metric";
-  if (!isWriteAction) return void 0;
-  const runConfig = readToolRunConfig(exeConfig);
-  const assistantId = runConfig?.assistant_id;
-  if (assistantId === BUILDER_ASSISTANT_ID && input.modelingSkillLoaded !== true) {
-    return JSON.stringify({
-      success: false,
-      error: `Load the '${MODELING_SKILL_NAME}' skill before publishing meta.`
-    });
-  }
-  return void 0;
-}
-function actionRequiresPayload(action) {
-  return action === "create_table" || action === "update_table" || action === "create_metric" || action === "update_metric";
-}
-function createMetricsMetaTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool52(
-    async (input, exeConfig) => {
-      try {
-        const guardError = requireModelingSkillLoaded(input.action, input, exeConfig);
-        if (guardError !== void 0) return guardError;
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const ds = resolveDatasourceId(input, exeConfig);
-        assertDatasourceSelected(effectiveDatasourceScope(client.getSelectedEntities()), ds);
-        if (actionRequiresPayload(input.action) && input.payload === void 0) {
-          throw new Error(`payload is required for ${input.action}`);
-        }
-        const payload = input.payload ?? {};
-        switch (input.action) {
-          case "list_tables": {
-            return JSON.stringify(await client.listTables(ds), null, 2);
-          }
-          case "read_table_meta": {
-            if (!input.objectKey) throw new Error("objectKey is required for read_table_meta");
-            return JSON.stringify(await client.getTable(ds, input.objectKey), null, 2);
-          }
-          case "create_table": {
-            return JSON.stringify(await client.createTable(ds, payload), null, 2);
-          }
-          case "update_table": {
-            if (!input.objectKey) throw new Error("objectKey is required for update_table");
-            return JSON.stringify(await client.updateTable(ds, input.objectKey, payload), null, 2);
-          }
-          case "list_metrics": {
-            return JSON.stringify(await client.listMetrics(ds), null, 2);
-          }
-          case "read_metric_meta": {
-            if (!input.objectKey) throw new Error("objectKey is required for read_metric_meta");
-            return JSON.stringify(await client.getMetric(ds, input.objectKey), null, 2);
-          }
-          case "create_metric": {
-            return JSON.stringify(await client.createMetric(ds, payload), null, 2);
-          }
-          case "update_metric": {
-            if (!input.objectKey) throw new Error("objectKey is required for update_metric");
-            return JSON.stringify(await client.updateMetric(ds, input.objectKey, payload), null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_meta_tool",
-      description: DESCRIPTION2,
-      schema: z58.object({
-        action: z58.enum([
-          "list_tables",
-          "read_table_meta",
-          "create_table",
-          "update_table",
-          "list_metrics",
-          "read_metric_meta",
-          "create_metric",
-          "update_metric"
-        ]).describe(
-          "Actions ONLY in this meta tool (runtime query actions like get_meta/query belong to metrics_runtime_tool): list_tables/list_metrics (browse published assets), read_table_meta/read_metric_meta (details by objectKey), create_table/create_metric (publish), update_table/update_metric (correct)"
-        ),
-        connectionKey: z58.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z58.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (optional if set in runConfig.metricsDataSource)"),
-        objectKey: z58.string().optional().describe("Semantic table/metric key (required for read_table_meta/update_table/read_metric_meta/update_metric)"),
-        payload: z58.record(z58.unknown()).optional().describe("Meta payload (required for create/update actions; objectType/objectKey/status/payload/accessGrant)"),
-        modelingSkillLoaded: z58.literal(true).optional().describe("Set true after loading the semantic-metrics-modeling skill (required for the builder assistant on write actions)")
-      })
-    }
-  );
-}
-
-// src/tool_lattice/semantic_metrics/metrics_runtime_tool.ts
-import z59 from "zod";
-import { tool as tool53 } from "langchain";
-var DESCRIPTION3 = `RUNTIME QUERY SURFACE \u2014 read what is published and answer business questions with numbers. Business agents use ONLY this tool; Builder agents also use it to verify freshly published metrics.
-
-OWNS: list_datasources (self-contained datasource discovery \u2014 redacted output, the first step before anything else), read_semantic_catalog (the published semantic model for a datasource: tables, metrics, dimensions, filters) and query_metrics (the semantic metric query: metrics / groupBy / filters / orderBy / limit \u2014 the server generates the SQL, so there is no free-form SQL here).
-
-DOES NOT OWN:
-- Publishing or correcting semantic tables/metrics \u2192 metrics_meta_tool (create_table/update_table/create_metric/update_metric/list_tables/read_table_meta/list_metrics/read_metric_meta).
-- Physical exploration of raw tables, grants, or samples \u2192 metrics_datasource_tool (query_sql).
-- Free-form custom SQL \u2014 intentionally not provided; use query against published metrics.
-
-USE WHEN: read_semantic_catalog to see what is published before asking numbers; query_metrics to answer a business question from already-published metrics (Business) or to verify a just-published metric against its acceptance evidence (Builder).
-
-COMMON MISTAKES (do not):
-- Do not call meta-tool actions here (create_table / update_table / create_metric / update_metric / list_tables / read_table_meta / list_metrics / read_metric_meta) \u2014 they live in metrics_meta_tool and will fail schema validation here.
-- Do not look for a custom-SQL action \u2014 there is none; explore physical data with metrics_datasource_tool query_sql, and query business numbers with the semantic query action.
-- Metrics and dimensions in query_metrics must already be published; querying an unpublished metric fails with "not found in catalog".`;
-function createMetricsRuntimeTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool53(
-    async (input, exeConfig) => {
-      try {
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const scope = effectiveDatasourceScope(client.getSelectedEntities());
-        switch (input.action) {
-          case "list_datasources": {
-            const result = await client.listDatasources();
-            const filtered = scope.unrestricted ? result : result.filter((d) => scope.ids.includes(Number(d.id)));
-            const safe = filtered.map((d) => ({
-              id: d.id,
-              name: d.name,
-              sourceType: d.sourceType,
-              description: d.description,
-              statusLabel: d.statusLabel
-            }));
-            return JSON.stringify(safe, null, 2);
-          }
-          case "read_semantic_catalog": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            return JSON.stringify(await client.getRuntimeMeta(ds), null, 2);
-          }
-          case "query_metrics": {
-            if (!input.query) throw new Error("query is required for the 'query_metrics' action");
-            const bodyDatasourceId = input.query.datasourceId;
-            if (bodyDatasourceId !== void 0) {
-              assertDatasourceSelected(scope, Number(bodyDatasourceId));
-            }
-            return JSON.stringify(await client.queryMetrics(input.query), null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_runtime_tool",
-      description: DESCRIPTION3,
-      schema: z59.object({
-        action: z59.enum(["list_datasources", "read_semantic_catalog", "query_metrics"]).describe(
-          "Actions ONLY in this runtime tool: list_datasources (list available datasources \u2014 ALWAYS call this first to obtain the datasourceId; output is redacted to non-sensitive fields), read_semantic_catalog (read the published semantic model: tables, metrics, dimensions), query_metrics (run a semantic metric query \u2014 the only way to get business numbers). Do NOT put meta-tool actions (list_tables/read_table_meta/create_table/update_table/list_metrics/read_metric_meta/create_metric/update_metric) here"
-        ),
-        connectionKey: z59.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z59.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (required for read_semantic_catalog; optional if set in runConfig.metricsDataSource)"),
-        query: z59.record(z59.unknown()).optional().describe('Semantic metric query request. Required for the query_metrics action, e.g. { datasourceId: 15, metrics: ["sell_in_nes"], groupBy: ["sales_team"], filters: [{ dimension: "posting_year", operator: "GTE", values: [2024] }], limit: 10 }')
-      })
-    }
-  );
-}
-
-// src/middlewares/semanticMetricsModelingSkill.ts
-var CONTENT = `---
-name: semantic-metrics-modeling
-description: Builder policy for turning a granted datasource into published semantic tables and metrics. Defines the orchestrator/worker contract \u2014 the orchestrator agrees goals, proposes the model, plans persistent tasks, and delegates execution to general-purpose workers with self-contained briefs; workers execute one bound brief each. Governs goal agreement, delegation, FEP verification, belief-state reconciliation, and continuous refinement until acceptance evidence is met.
----
-
-# Semantic Metrics Modeling
-
-You are the Semantic Metrics Builder. You turn physical datasource tables into reusable
-**semantic tables** and **business metrics** on a Metrics Server (\`/api/v1\`). Work is
-governed, observable, and continuously refined \u2014 never a one-shot guess.
-
-You always operate in exactly ONE of two roles:
-
-- **Orchestrator** (default; no \`## Bound Task\` section in your context): you face the
-  user. You agree the Goal Model, propose the model, plan persistent tasks, dispatch
-  execution to workers, reconcile belief, and own every user interaction.
-- **Worker** (your context contains a \`## Bound Task\` section naming you executor of one
-  task): you execute that task's brief only. See **Worker mode** \u2014 its rules override the
-  orchestrator policy.
-
-## Goal Model
-
-Before any exploration or publishing, agree with the user on:
-- **Real goal**: the business outcome (which metrics, for what decision), not just "make a table".
-- **Consumer**: who reads the result and how.
-- **Usable state**: observable conditions that make the published meta useful.
-- **Scope**: which datasource/tables, and what is explicitly out of scope.
-- **Acceptance evidence**: objective criteria (e.g. "metric \`sell_in_nes\` returns sane monthly
-  totals for 2024") used to decide success. Verbatim acceptance evidence is required later by
-  the Verify dispatch \u2014 record it exactly.
-Do not guess material goals, consumers, or acceptance evidence.
-
-**Vague requests** (e.g. "build the metric layer") \u2014 do not act and do not ask blind questions.
-First run cheap read-only observations (\`list_datasources\`, \`get_grants\`, \`list_metrics\`) to
-see what is authorized and already published, then ask focused questions that carry that
-context and offer concrete options (which datasource/tables, which business questions, extend
-existing metrics or build new). Every clarification question must include enough context and
-options for the user to answer in one step. Only after the user picks a direction does the
-Goal Model become confirmable \u2014 record it, create the task, and proceed to the workflow.
-
-## Target model and quality bar
-
-Your goal is a specific, verifiable artifact, not "some tables and metrics".
-
-**Target shape** \u2014 one delivery is:
-- a published \`table_view_detail\` meta per logical table, with every column tagged
-  \`role\` (dimension | measure) and a business-readable \`label\`;
-- a \`metric_index\` + \`metric_detail\` pair per metric, using the SQL-free \`calculation\` DSL;
-- the set, taken together, answers the user's concrete business question.
-
-**Publish gate (self-check every metric before create)** \u2014 if any fails, do **not** publish; go
-explore or ask the user:
-1. measure: an aggregation is chosen **and** its business meaning is confirmed (net/gross, currency, dedupe or not);
-2. dimension: has a business meaning and a grain (day/month/year/\u2026);
-3. \`displayName\`/\`label\` are business-readable;
-4. the metric answers one concrete question from the user's stated goal;
-5. a runtime \`query\` returns numbers consistent with the confirmed meaning.
-
-**Intent gaps first** \u2014 before diving into exploration, list the inputs you still need to meet the
-quality bar (business meaning, grain, target metric list, table scope, consumer) and ask for them
-explicitly. Exploration and user questions are both driven by this target shape and quality bar:
-missing business meaning \u2192 ask; unclear field semantics \u2192 probe or ask; right shape but it does not
-answer the business question \u2192 do not publish.
-
-## FEP Loop
-
-Apply this loop to every step (explore, publish table, publish metric, verify):
-**OBSERVE \u2192 HYPOTHESIZE \u2192 ACT \u2192 VERIFY \u2192 DECIDE \u2192 RECONCILE**
-
-- **Observe**: current state, grants, published meta, and decision-relevant uncertainty.
-- **Hypothesize**: what evidence should appear if your model is right, and how each outcome changes the decision.
-- **Act**: one proportional action \u2014 no more than necessary.
-- **Verify**: compare the observed result (e.g. a runtime \`query\`) against the prediction.
-- **Decide**: classify as **RETAIN** (confirmed), **REVERT** (rejected), or **INCONCLUSIVE**.
-- **Reconcile**: update the belief state and plan, then repeat while decision-relevant action remains.
-
-The orchestrator applies the loop **between dispatches** (each observation updates the plan
-before the next brief is written). A worker applies it **inside its brief**.
-
-Renew user approval when a foundational assumption or the goal changes.
-
-## Orchestrator: Task Policy
-
-You are an orchestrator, not the hands. Exactly five duties:
-
-1. **Goal Model agreement** \u2014 including cheap read-only observation for vague requests
-   (\`list_datasources\`, \`get_grants\`, \`list_metrics\`). This is your ONLY inline datasource
-   access; do not use \`write_todos\`.
-2. **Propose the model** and get user approval.
-3. **Task tree** \u2014 parent task = contract + \`## Belief State\`; child tasks = independently
-   verifiable outcomes (explore / publish-table / publish-metric / verify), one per dispatch.
-   See the \`task-definition\` skill for \`manage_task\` operation details.
-4. **Dispatch and collect** \u2014 \`task { taskId, agentId: "general-purpose" }\`; read the
-   observation; record the \`executionResultId\` on the child task with \`manage_task update\` or
-   \`add_activity\`; reconcile \`## Belief State\`.
-5. **HITL** \u2014 every \`ask_user_to_clarify\` is yours. Workers never ask the user.
-
-Hard rules:
-- Never run exploration SQL inline. Never build or publish payloads inline (sole exception:
-  the Publish/Verify inline fallback below).
-- **Belief State: you are the sole writer.** Workers return findings in their results; you
-  update \`## Belief State\` via \`manage_task update\` on the parent task. Workers never touch it.
-- **Dispatch serially** \u2014 one worker at a time; reconcile belief before writing the next brief.
-- **Distinguish dispatch failure from worker outcome**: a dispatch failure is a tool-level
-  error where the worker never ran. A worker returning INCONCLUSIVE or failed is a normal FEP
-  input \u2014 reconcile it, never treat it as a dispatch failure.
-
-Dispatch failure handling (worker never ran, tool error):
-1. Retry the dispatch once (recreate the child task if the store reports it unusable).
-2. **Explore: never execute inline.** If the retry fails, stop and ask the user via
-   \`ask_user_to_clarify\` (report what is blocked and why).
-3. **Publish/Verify: after a failed retry you MAY execute inline** to preserve delivery \u2014
-   the payload decisions are already in your context. Follow the same gate self-check as a
-   worker would.
-
-## Delegation Protocol
-
-Mechanics every brief must be designed around:
-
-- A worker sees ONLY: its task title + description, the parent task's description, and the
-  results of completed dependency tasks. It does NOT see this conversation.
-- Therefore **every brief is self-contained**: all decisions, boundaries, and evidence travel
-  inside the task description.
-- Dispatch is synchronous: \`task { taskId, agentId: "general-purpose" }\` returns an
-  observation (the worker's final message, truncated at ~8k chars) and an
-  \`executionResultId\`. Record the id on the child task (\`manage_task update\`/\`add_activity\`).
-- The worker settles its own task (\`set_status\` with \`result\`/\`failureReason\`). Read both the
-  observation and the task result before reconciling.
-
-Write briefs as field checklists adapted to the situation \u2014 decisions and evidence, not prose.
-The worker assembles payloads from the reference sections of this skill; the brief carries the
-approved decisions, never full payload JSON.
-
-### Explore brief (\`Explore <schema>.<table> for <goal>\`)
-
-Required fields:
-1. Datasource: serverKey/connectionKey + datasourceId (and \`runConfig.metricsDataSource\` preset if present).
-2. Grant boundary: the allowed schema + table pattern from \`get_grants\`, verbatim; never probe outside it.
-3. Target table(s): schema-qualified names; one brief per table.
-4. Question list: per column (or column group) \u2014 business meaning candidates, expected role
-   (dimension | measure | time), net/gross, grain.
-5. Method: read-only SELECT/WITH only; use the \`references/metadata-sql.md\` templates
-   (columns, sample rows, value distribution); cap sample size (e.g. \u22641000 rows, \u226450 groups).
-   Prefer targeted queries over bulk catalog dumps. A large single read (e.g. full
-   \`read_semantic_catalog\` detail) is allowed \u2014 your isolation protects the orchestrator's
-   context \u2014 but findings must be compressed to conclusion level.
-6. Output contract: structured findings \u2014 per column: observed type, sample values,
-   distribution highlights, role candidate + evidence, \`INCONCLUSIVE\` marking for unresolved
-   semantics.
-7. Invariants: read-only only; grant boundary absolute; never guess \u2014 \`INCONCLUSIVE\` instead.
-8. Closing: settle the task (\`set_status completed\`, result = findings summary); final message
-   = the structured findings (it becomes the observation).
-
-### Publish-table brief (\`Publish table meta <objectKey>\`)
-
-Required fields:
-1. Approved decisions: full column list (name/type/role/label/description), grain,
-   displayName/docType/shortDesc/sourceSystem/sourceTables.
-2. Identity: \`objectKey\` (stable, unique per datasource) + \`schemaName.tableName\`.
-3. Assembly instruction: full \`table_view_detail\` payload per **Publish table meta** below,
-   plus the identity twin (\`table_catalog\`, same \`objectKey\`), plus an EXACT \`accessGrant\`
-   matching the tenant grant.
-4. Gate self-check: publish gate items 1\u20133 \u2014 do not publish if any fails.
-5. Publish via \`metrics_meta_tool\` \`create_table\`; then \`get_meta\` to confirm visibility.
-6. Mistakes: fix with \`update_table\`; never leave a partial publish.
-7. Invariants: EXACT patternType; every column tagged and labeled.
-8. Closing: settle the task; final message = receipts (objectKeys + get_meta confirmation).
-
-### Publish-metric brief (\`Publish metric <objectKey>\`)
-
-Required fields (per metric):
-1. Identity: \`objectKey\` = \`metric_name\`, display_name, domain, description, data_type, format.
-2. Source: schema-qualified \`source.table_view\` (must match the published table meta).
-3. Calculation: aggregate (\`aggregation\` + \`measure\`, with the confirmed business meaning) or
-   derived (ratio references / formula) \u2014 exactly as approved in Propose the model.
-4. \`supported_dimensions\`: array of objects \`{dim_id, field_name, label, data_type}\`,
-   including the time dimension.
-5. \`default_time_context\`: time_dimension + granularity + supported_grains (+ window if requested).
-6. \`ai_agent_context\`: polarity, synonyms, human_readable_explanation.
-7. Assembly instruction: \`metric_index\` then \`metric_detail\` in the FULL runtime style per
-   **Publish metric meta** below; publish via \`metrics_meta_tool\` \`create_metric\`.
-8. Gate self-check + smoke \`query\` (one grouping by the default time grain) + \`get_meta\`
-   receipts; closing = settle the task, final message = receipts.
-
-### Verify brief (\`Verify <metric> against acceptance evidence\`)
-
-Required fields:
-1. Acceptance evidence verbatim (from the Goal Model).
-2. Queries to run (semantic \`query\` via \`metrics_runtime_tool\`) and the expected shape/values.
-3. Report contract: PASS/FAIL verdict + actual vs expected; on FAIL include the differences
-   and a suspicion list \u2014 do NOT modify meta (fixes are new Publish tasks).
-4. Invariants: read-only only.
-5. Closing: settle the task; final message = the verdict summary.
-
-### Brief closing (all types)
-
-- Invariants line: grant boundary + read-only SQL + publish gate before any create.
-- Result structure: the structured summary the orchestrator expects back.
-- Finish by settling the task (\`set_status completed\` with result, or \`failed\` with
-  failureReason) and making the final message that structured summary.
-
-## Worker mode
-
-Trigger: your context contains \`## Bound Task\`. You are a worker; these rules override the
-orchestrator policy (Safety and the reference sections still apply):
-
-- Execute the bound task's brief only. Read the contract with \`manage_task get\`; the task
-  description is authoritative. Load this skill if the bootstrap asks \u2014 you need its payload
-  reference sections.
-- Do NOT: re-agree the Goal Model, create sibling or child tasks, dispatch \`task\`, call
-  \`ask_user_to_clarify\`, or update the parent task's \`## Belief State\`.
-- Apply the FEP loop inside the brief; obey the grant boundary and read-only SQL; run the
-  publish gate before any create.
-- Unclear semantics: mark \`INCONCLUSIVE\` with candidates + evidence in your findings. Never
-  guess, never publish on a guess.
-- Finish: \`set_status completed\` with a structured result (or \`failed\` with failureReason),
-  and make your final message the structured summary \u2014 it is the observation your
-  orchestrator reads.
-
-## Belief State (orchestrator-owned)
-
-The parent task's description carries a \`## Belief State\` section as a Markdown table:
-
-\`\`\`
-| Belief Key | Probability | Target | Basis |
-|---|---|---|---|
-| sell-in-nes-source-table | 70% | 100% | column \`nes\` probed as numeric measure in grant |
-\`\`\`
-
-Rules: belief keys are lowercase kebab-case; probability/target are percentages 0\u2013100% that
-represent evidence support, not calibrated probability. Only the orchestrator writes this
-section \u2014 after each dispatch it folds the worker's findings into the table so the parent
-task always reflects the current evidence.
-
-## Workflow
-
-1. **Pick the datasource + cheap observation.** \`metrics_datasource_tool\` action
-   \`list_datasources\`, or the preset \`runConfig.metricsDataSource\` (\`serverKey\`\u2192connectionKey,
-   \`datasourceId\`). Inline, read-only.
-2. **Agree the Goal Model.** (HITL)
-3. **Create the parent task** \u2014 contract + \`## Belief State\` (seeded from the Goal Model).
-4. **Explore by dispatch** \u2014 one Explore brief per table, serial; collect findings; reconcile
-   \`## Belief State\`; collect \`INCONCLUSIVE\` columns.
-5. **Propose the model** (HITL) \u2014 present table columns (with \`role: dimension | measure\`)
-   and the metrics (aggregate/derived) for approval; include clarify questions for
-   \`INCONCLUSIVE\` columns in the same ask.
-6. **Publish tables by dispatch** \u2014 one Publish-table brief per table; check receipts.
-7. **Publish metrics by dispatch** \u2014 one Publish-metric brief per metric; receipts + smoke query.
-8. **Verify by dispatch** \u2014 Verify brief against acceptance evidence. FAIL \u2192 reconcile
-   belief \u2192 fix decisions \u2192 new Publish task (\`update_table\`/\`update_metric\`) \u2192 re-Verify.
-   PASS \u2192 complete the parent task (result = acceptance evidence met).
-
-## Explore (reference)
-
-Read \`table-grants\`, then probe with \`query\`. SQL is validated read-only by the client and the
-server enforces the grant; un-granted tables return \`TABLE_NOT_GRANTED\`. Prefer the
-\`references/metadata-sql.md\` templates because dialect varies (PostgreSQL / SQL Server / HANA).
-If the user provides a data dictionary or sample data file, read it with filesystem and
-reconcile it against the probed columns.
-
-## Unclear field semantics
-
-A probed column name may not reveal its business meaning (e.g. whether \`nes\` is a net amount to
-sum, a rate to average, or an enum to filter). Publishing meta on a misunderstood field pollutes
-the runtime and every downstream metric that depends on it, and delete is not available. Treat this
-as FEP **INCONCLUSIVE** \u2014 never guess, and never publish on an unverified guess.
-
-Resolve in order of increasing cost (inside the Explore brief):
-1. **Probe sample values and distribution** (\`query\`, templates in \`references/metadata-sql.md\`):
-   - numbers in (0,1) or clustered near 100 \u2192 likely a ratio/percentage \u2192 dimension or \`avg\`, rarely \`sum\`;
-   - large additive amounts (currency, counts) \u2192 measure with \`sum\`;
-   - small enumerations (year 2023/2024, 0/1 flags, codes) \u2192 dimension.
-   The share of zeros/negatives and the value scale usually disambiguate semantics.
-2. **Read user-provided docs**: if the user supplied a data dictionary or sample file, read it via
-   filesystem and reconcile it against the probed columns.
-3. **Cross-field correlation**: compare the unclear field with fields whose semantics are confirmed.
-
-If evidence is still INCONCLUSIVE:
-- Do **not** publish meta that depends on the unclear field.
-- The worker marks the column \`INCONCLUSIVE\` (candidates + evidence) in its findings; the
-  **orchestrator** lists it with candidate interpretations in the **Propose the model** step
-  and asks the user to confirm its semantics (role, value meaning, net/gross) via
-  \`ask_user_to_clarify\`. The user does not need to see the table \u2014 probed schema, samples, and
-  candidates are enough.
-- The orchestrator records a low-probability belief entry (e.g.
-  \`| sales-nes-semantics | 40% | 100% | user must confirm role / net amount |\`) so verify/refine
-  can revisit it later instead of assuming it is settled.
-
-## Publish table meta (\`create_table\`)
-
-Publish the authoritative shape below (objectType \`table_view_detail\`, with an EXACT accessGrant):
-
-\`\`\`json
-{
-  "objectType": "table_view_detail",
-  "objectKey": "hankel_view_sales_summary",
-  "status": 1,
-  "payload": {
-    "schemaName": "public",
-    "tableName": "hankel_view_sales_summary",
-    "displayName": "Hankel Sales Summary",
-    "docType": "Sales Summary",
-    "docTypeEn": "Sales Summary",
-    "shortDesc": "Sales-level progress summary.",
-    "grain": "canonical_sales_name",
-    "sourceSystem": "Hankel Run for Gold",
-    "sourceTables": ["hankel_project_opportunity_lines", "hankel_new_order_lines"],
-    "columns": [
-      { "name": "canonical_sales_name", "label": "Canonical Sales Name", "type": "string", "role": "dimension", "description": "Standardized sales name used for grouping." },
-      { "name": "nes", "label": "NES", "type": "number", "role": "measure", "description": "Net external sales amount." },
-      { "name": "report_cutoff_date", "label": "Report Cutoff Date", "type": "date", "role": "time", "description": "Cutoff date of the report snapshot." }
-    ]
-  },
-  "accessGrant": {
-    "schemaName": "public",
-    "tablePattern": "hankel_view_sales_summary",
-    "patternType": "EXACT",
-    "caseSensitive": false,
-    "status": 1
-  }
-}
-\`\`\`
-
-Design rules:
-- \`objectKey\` is stable and unique per datasource (the view/table key).
-- \`columns[].role\` has THREE values: \`dimension\` (grouping/filtering), \`measure\` (aggregated numbers), \`time\` (the report cutoff/snapshot date used by default_time_context).
-- Give every column a business \`description\`.
-- Lineage fields (\`docType\`, \`shortDesc\`, \`grain\`, \`sourceSystem\`, \`sourceTables\`) make the asset findable and trustworthy \u2014 fill them from exploration evidence.
-- Runtime table publication uses \`patternType: "EXACT"\` (\`PREFIX\` is only for datasource-level exploration scopes).
-- For each semantic table also publish the identity twin: the same body with \`objectType: "table_catalog"\` and the same \`objectKey\` (same or richer payload).
-
-## Publish metric meta (\`create_metric\`)
-
-Two steps for the same \`objectKey\`.
-
-### 3a. Metric index (for lists/search)
-
-\`\`\`json
-{
-  "objectType": "metric_index",
-  "objectKey": "sell_in_nes",
-  "status": 1,
-  "payload": {
-    "metric_name": "sell_in_nes",
-    "display_name": "Sell-in NES",
-    "domain": "sales",
-    "short_desc": "Net external sales amount from distributor sell-in rows.",
-    "search_keywords": ["sell in", "nes", "net external sales"],
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in" }
-  }
-}
-\`\`\`
-
-\`search_keywords\` drive metric retrieval for natural-language questions \u2014 include business synonyms.
-
-### 3b. Metric detail (the calculation)
-
-IMPORTANT \u2014 runtime schema requirement: the Metrics Server query runtime only recognizes metrics
-published in the FULL runtime style below (the same shape as existing working metrics, with
-snake_case fields like \`metric_name\`, \`source.table_view\`, \`supported_dimensions\` objects, and
-\`default_time_context\`). A minimal \`{name, sourceTable, calculation, dimensions}\` payload is
-accepted by the publish API but is NOT queryable \u2014 querying it returns 403 "not authorized".
-
-Aggregate metric (full runtime style):
-
-\`\`\`json
-{
-  "objectType": "metric_detail",
-  "objectKey": "sell_in_nes",
-  "status": 1,
-  "payload": {
-    "metric_name": "sell_in_nes",
-    "display_name": "Sell-in NES",
-    "domain": "sales",
-    "description": "Net external sales amount from distributor sell-in rows.",
-    "data_type": "numeric",
-    "format": "currency",
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
-    "calculation": { "type": "aggregate", "aggregation": "sum", "measure": "nes" },
-    "supported_dimensions": [
-      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" },
-      { "dim_id": "sales_team", "field_name": "sales_team", "label": "Sales Team", "data_type": "string" }
-    ],
-    "default_time_context": {
-      "time_dimension": "posting_date",
-      "label": "Posting date",
-      "granularity": "month",
-      "window": "YTD",
-      "supported_grains": ["month", "year"]
-    },
-    "ai_agent_context": {
-      "polarity": "positive",
-      "synonyms": ["sell in", "nes", "net external sales"],
-      "human_readable_explanation": "Higher sell-in NES means more goods purchased from the distributor."
-    }
-  }
-}
-\`\`\`
-
-Derived ratio metric (references two aggregate metrics):
-
-\`\`\`json
-{
-  "objectType": "metric_detail",
-  "objectKey": "gross_margin_rate",
-  "status": 1,
-  "payload": {
-    "metric_name": "gross_margin_rate",
-    "display_name": "Gross Margin Rate",
-    "description": "Gross margin divided by sell-in NES.",
-    "domain": "sales",
-    "data_type": "numeric",
-    "format": "percent",
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
-    "calculation": { "type": "derived", "operator": "ratio", "numerator": "gross_margin", "denominator": "sell_in_nes" },
-    "supported_dimensions": [
-      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" }
-    ],
-    "default_time_context": { "time_dimension": "posting_date", "granularity": "month", "supported_grains": ["month", "year"] }
-  }
-}
-\`\`\`
-
-Design rules:
-- \`objectKey\` unique per datasource (index and detail share it).
-- \`payload.metric_name\` must equal \`objectKey\`.
-- \`source.table_view\` must be schema-qualified and match the published table meta's physical table.
-- \`supported_dimensions\` is an array of OBJECTS ({dim_id, field_name, label, data_type}); include the time dimension too; each must be a published column of that table meta.
-- \`calculation.type: "aggregate"\` = one measure + aggregation (sum/avg/count/min/max/count_distinct).
-- \`calculation.type: "derived"\` operator \`ratio\` references existing metric objectKeys (numerator/denominator); a \`formula\` variant takes an expression of metric names, numbers, parentheses, and + - * / \u2014 referenced metrics must share the same source.table_view.
-- \`default_time_context\` (\`time_dimension\` + \`granularity\` + \`supported_grains\`, optionally \`window\`) is required by the query runtime; its \`time_dimension\` must appear in supported_dimensions.
-- \`ai_agent_context\` (\`polarity\`, \`synonyms\`, \`human_readable_explanation\`) improves natural-language metric retrieval \u2014 always provide it.
-- One semantic query can only combine metrics sharing the same source.table_view; groupBy values must be dim_ids or time-grain expressions like \`posting_date__month\`.
-- Do not inline raw SQL for new DB-backed metrics (complex logic belongs in a view).
-- Use \`update_metric\` / \`update_table\` to correct mistakes; no removal actions are exposed.
-
-## Verify and refine
-
-- Verify is **dispatched** (Verify brief). The worker runs \`get_meta\` \u2192 confirms the table and
-  metric are visible, then \`query\`es the metric against acceptance evidence.
-- On FAIL the worker reports differences; the **orchestrator** applies the FEP reconcile:
-  update \`## Belief State\`, fix the decisions, and dispatch a new Publish task
-  (\`update_table\`/\`update_metric\`) \u2014 then re-Verify \u2014 until acceptance evidence is met.
-
-## Troubleshooting
-
-| Symptom | Cause / fix |
-|---|---|
-| \`TABLE_NOT_GRANTED\` | SQL referenced a table outside the tenant grant; pick an in-grant table |
-| metric create fails: sourceTable missing | publish the table meta first |
-| metric create fails: unknown dimension | publish the dimension column with \`role: dimension\` |
-| derived metric create fails | numerator/denominator metrics don't exist yet \u2014 publish them first |
-| datasource \`query\` rejected | SQL was not read-only (SELECT/WITH only) or multi-statement |
-| \`403 Metric is not authorized\` on query_metrics | the metric meta is not in the queryable runtime schema (e.g. missing \`source.table_view\` / \`supported_dimensions\` / \`default_time_context\`) or genuinely unauthorized \u2014 re-publish with the full runtime payload and verify; never retry blindly |
-| worker observation truncated | findings exceeded ~8k chars; worker must keep the final message a compact structured summary |
-| dispatch failed (tool error) | retry once; Explore never goes inline \u2014 ask the user; Publish/Verify may go inline after the failed retry |
-
-## Safety
-
-- Only query tables that match the tenant's \`table-grants\`.
-- Never return a full physical-table inventory or reveal whether an un-granted table exists.
-- SQL is validated read-only; let the server reject anything outside that.
-`;
-var resources = {
-  "references/metadata-sql.md": {
-    content: `# Datasource exploration SQL templates (read-only)
-
-Pick the block matching the server's database. These run through the datasource \`query\` action;
-the SQL is validated read-only.
-
-## PostgreSQL
-- Tables: \`select table_schema, table_name from information_schema.tables where table_schema not in ('pg_catalog','information_schema') order by table_schema, table_name\`
-- Columns: \`select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position\`
-- Sample: \`select * from :schemaName.:tableName limit :maxRows\` \u2014 pass a concrete table, not a bound param, if the server does not support binding identifiers.
-
-## SQL Server
-- Tables: \`select table_schema, table_name from information_schema.tables order by table_schema, table_name\`
-- Columns: \`select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position\`
-
-## HANA
-- Tables: \`select schema_name, table_name from sys.tables where schema_name = :schemaName order by table_name\`
-- Columns: \`select column_name, data_type_name from table_columns where schema_name = :schemaName and table_name = :tableName order by position\`
-
-## Value distribution (any dialect)
-\`select <dim>, count(*) as row_count from <table> group by <dim> order by row_count desc limit :maxRows\`
-`
-  },
-  "examples/table-meta.json": {
-    content: `{
-  "objectType": "table_view_detail",
-  "objectKey": "hankel_distr_sell_in",
-  "status": 1,
-  "payload": {
-    "schemaName": "public",
-    "tableName": "hankel_distr_sell_in",
-    "displayName": "Hankel Distributor Sell In",
-    "description": "Distributor sell-in transaction rows for the Hankel tenant.",
-    "columns": [
-      { "name": "posting_year", "label": "Posting Year", "type": "number", "role": "dimension" },
-      { "name": "posting_month", "label": "Posting Month", "type": "number", "role": "dimension" },
-      { "name": "sales_team", "label": "Sales Team", "type": "string", "role": "dimension" },
-      { "name": "region", "label": "Region", "type": "string", "role": "dimension" },
-      { "name": "nes", "label": "Net External Sales", "type": "number", "role": "measure" },
-      { "name": "gross_margin", "label": "Gross Margin", "type": "number", "role": "measure" }
-    ]
-  }
-}
-`
-  },
-  "examples/metric-aggregate.json": {
-    content: `{
-  "objectType": "metric_detail",
-  "objectKey": "sell_in_nes",
-  "status": 1,
-  "payload": {
-    "metric_name": "sell_in_nes",
-    "display_name": "Sell-in NES",
-    "domain": "sales",
-    "description": "Net external sales amount from distributor sell-in rows.",
-    "data_type": "numeric",
-    "format": "currency",
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
-    "calculation": { "type": "aggregate", "aggregation": "sum", "measure": "nes" },
-    "supported_dimensions": [
-      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" },
-      { "dim_id": "sales_team", "field_name": "sales_team", "label": "Sales Team", "data_type": "string" },
-      { "dim_id": "posting_date", "field_name": "posting_date", "label": "Posting Date", "data_type": "string" }
-    ],
-    "default_time_context": {
-      "time_dimension": "posting_date",
-      "label": "Posting date",
-      "granularity": "month",
-      "window": "YTD",
-      "supported_grains": ["month", "year"]
-    },
-    "ai_agent_context": {
-      "polarity": "positive",
-      "synonyms": ["sell in", "nes", "net external sales"],
-      "human_readable_explanation": "Higher sell-in NES means more goods purchased from the distributor."
-    }
-  }
-}
-`
-  },
-  "examples/metric-derived.json": {
-    content: `{
-  "objectType": "metric_detail",
-  "objectKey": "gross_margin_rate",
-  "status": 1,
-  "payload": {
-    "metric_name": "gross_margin_rate",
-    "display_name": "Gross Margin Rate",
-    "domain": "sales",
-    "description": "Gross margin divided by sell-in NES.",
-    "data_type": "numeric",
-    "format": "percent",
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
-    "calculation": { "type": "derived", "operator": "ratio", "numerator": "gross_margin", "denominator": "sell_in_nes" },
-    "supported_dimensions": [
-      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" },
-      { "dim_id": "posting_date", "field_name": "posting_date", "label": "Posting Date", "data_type": "string" }
-    ],
-    "default_time_context": {
-      "time_dimension": "posting_date",
-      "label": "Posting date",
-      "granularity": "month",
-      "supported_grains": ["month", "year"]
-    },
-    "ai_agent_context": {
-      "polarity": "positive",
-      "synonyms": ["gross margin rate", "margin rate"],
-      "human_readable_explanation": "Gross margin rate divides gross margin by sell-in NES; higher means more margin retained on sold-in goods."
-    }
-  }
-}
-`
-  }
-};
-var SEMANTIC_METRICS_MODELING_SKILL = {
-  version: "1.1.2",
-  content: CONTENT,
-  resources
-};
-
-// src/middlewares/semanticMetricsBuilderPrompt.ts
-var SEMANTIC_METRICS_BUILDER_PROMPT = `You are the Semantic Metrics Builder.
-
-CRITICAL FIRST ACTION: Before any response or other action, call the \`skill\`
-tool with skill_name: "semantic-metrics-modeling" to load semantic-metrics-modeling and follow it.
-Never announce the skill load. If it fails, retry once, then stop and explicitly
-report that the required Semantic Metrics Builder skill could not be loaded.`;
-
-// src/middlewares/semanticMetricsMiddleware.ts
-import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
-function createSemanticMetricsMiddleware(config) {
-  const connections = config.connections ?? [];
-  const connectAll = config.connectAll === true;
-  const selector = { connectionType: "semantic-metrics", connections, connectAll };
-  return createMiddleware20({
-    name: "SemanticMetrics",
-    contextSchema,
-    tools: [
-      createMetricsDatasourceTool(selector),
-      createMetricsMetaTool(selector),
-      createMetricsRuntimeTool(selector)
-    ]
-  });
-}
-function buildConnectionHeaders(config) {
-  const headers = {
-    Accept: "application/json",
-    ...config.headers !== void 0 && config.headers !== null ? config.headers : {}
-  };
-  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-  return headers;
-}
-function resolveBaseUrl(config) {
-  const serverUrl = config.serverUrl;
-  if (!serverUrl) {
-    throw new Error("serverUrl is required");
-  }
-  return serverUrl.replace(/\/$/, "");
-}
-var semanticMetricsPlugin = {
-  meta: {
-    type: "semantic-metrics",
-    category: "data",
-    capabilityBundleEligible: true,
-    openExpose: [
-      // Query-only surface: no writes reach either tool (SQL is read-only).
-      { name: "metrics_datasource_tool", readOnly: true },
-      { name: "metrics_runtime_tool", readOnly: true }
-    ],
-    name: "Semantic Metrics",
-    description: "Semantic metrics datasource exploration, meta publishing, and runtime querying. PERMISSION MODEL \u2014 query-only agents (metric definitions + data): enable this middleware with allowedTools ['metrics_runtime_tool']. Metric designers (Builder): keep all three tools (metrics_datasource_tool, metrics_meta_tool, metrics_runtime_tool) for exploration, publishing, and verification, or use the built-in 'semantic-metrics-builder' agent.",
-    version: "1.0.0",
-    tools: [
-      { name: "metrics_datasource_tool", description: "Explore datasource structure within the tenant's granted scope" },
-      { name: "metrics_meta_tool", description: "Publish and maintain runtime semantic tables and metrics" },
-      { name: "metrics_runtime_tool", description: "Read runtime meta and execute semantic metric queries" }
-    ],
-    configSchema: {
-      type: "object",
-      title: "Semantic Metrics Configuration",
-      description: "First select connections (connections or connectAll). Then scope tools by role via allowedTools: QUERY-ONLY agents (metric definitions + data) set allowedTools to ['metrics_runtime_tool'] \u2014 it is self-contained (list_datasources, read_semantic_catalog, query_metrics); metric DESIGNERS keep all three tools (datasource exploration, meta publishing, runtime verification).",
-      properties: {
-        connections: {
-          type: "array",
-          title: "Connections",
-          items: { type: "string" },
-          widget: "connectionSelect"
-        },
-        connectAll: {
-          type: "boolean",
-          title: "Connect All",
-          default: false,
-          widget: "switch"
-        }
-      }
-    },
-    defaultConfig: { connections: [], connectAll: false }
-  },
-  connection: {
-    // PluginConnectionFieldSchema.type supports only string/number/boolean/password,
-    // so headers is NOT a form field; the V2 client still reads config.headers at runtime.
-    fields: [
-      { key: "serverUrl", type: "string", title: "Metrics Server Base URL (include /api/v1)", required: true },
-      { key: "apiKey", type: "password", title: "API Key (optional)" }
-    ],
-    test: async (config) => {
-      try {
-        const baseUrl = resolveBaseUrl(config);
-        const res = await fetch(`${baseUrl}/datasources`, {
-          headers: buildConnectionHeaders(config)
-        });
-        const text = await res.text().catch(() => "");
-        let ok = res.ok;
-        let detail = "";
-        try {
-          const parsed = JSON.parse(text);
-          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-            const code = parsed.code;
-            if (typeof code === "number") {
-              ok = res.ok && code === 200;
-              if (!ok) detail = ` (${parsed.message ?? code})`;
-            }
-          }
-        } catch {
-        }
-        return {
-          ok,
-          message: ok ? `Reachable at ${baseUrl}` : `HTTP ${res.status}${detail}`
-        };
-      } catch (err) {
-        return {
-          ok: false,
-          message: `Cannot connect: ${err instanceof Error ? err.message : String(err)}`
-        };
-      }
-    },
-    discover: async (config) => {
-      try {
-        const baseUrl = resolveBaseUrl(config);
-        const res = await fetch(`${baseUrl}/datasources`, {
-          headers: buildConnectionHeaders(config)
-        });
-        const text = await res.text();
-        if (!res.ok) {
-          throw new Error(`HTTP ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
-        }
-        const parsed = JSON.parse(text);
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-          throw new Error("Metrics server returned an unexpected payload (expected a JSON envelope)");
-        }
-        const envelope = parsed;
-        if (typeof envelope.code === "number" && envelope.code !== 200) {
-          throw new Error(envelope.message || `API ${envelope.code}`);
-        }
-        const data = envelope.data;
-        if (!Array.isArray(data)) {
-          throw new Error("Metrics server returned an unexpected payload (expected a datasource array)");
-        }
-        return data.filter((d) => {
-          if (d === null || typeof d !== "object") return false;
-          const id = d.id;
-          return id !== void 0 && id !== null && id !== "";
-        }).map((item) => ({
-          id: String(item.id),
-          name: item.name ?? String(item.id)
-        }));
-      } catch (err) {
-        throw new Error(
-          `Cannot discover datasources: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  },
-  skills: {
-    "semantic-metrics-modeling": SEMANTIC_METRICS_MODELING_SKILL
-  },
-  agents: {
-    "semantic-metrics-builder": {
-      key: "semantic-metrics-builder",
-      name: "Semantic Metrics Builder",
-      description: "Explore a granted datasource and build semantic tables and metrics interactively, tracking the work as persistent tasks with belief state and verifying each step.",
-      type: AgentType9.DEEP_AGENT,
-      prompt: SEMANTIC_METRICS_BUILDER_PROMPT,
-      middleware: [
-        {
-          id: "semantic-metrics",
-          type: "semantic-metrics",
-          name: "Semantic Metrics",
-          description: "Explore datasources, publish table/meta metrics, query runtime",
-          enabled: true,
-          config: { connections: [], connectAll: true }
-        },
-        {
-          id: "skill",
-          type: "skill",
-          name: "Skill",
-          description: "Load the semantic-metrics-modeling policy and task-definition reference",
-          enabled: true,
-          config: { readAll: false, skills: ["semantic-metrics-modeling", "task-definition"] }
-        },
-        {
-          id: "task",
-          type: "task",
-          name: "Task",
-          description: "Persistent TaskItems as the planning surface; update Belief State in task descriptions",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "ask_user_to_clarify",
-          type: "ask_user_to_clarify",
-          name: "Ask User",
-          description: "Wait for user input at modeling approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "filesystem",
-          type: "filesystem",
-          name: "Filesystem",
-          description: "Read user-provided schema docs, data dictionaries, or sample data files",
-          enabled: true,
-          config: {}
-        }
-      ]
-    }
-  },
-  middleware: (config) => createSemanticMetricsMiddleware(config)
-};
-
-// src/middlewares/collectionMiddleware.ts
-import { createMiddleware as createMiddleware21 } from "langchain";
-
-// src/tool_lattice/collection/list_collections.ts
-import z60 from "zod";
-import { tool as tool54 } from "langchain";
-
 // src/tool_lattice/collection/utils.ts
 function getEffectiveCollectionScope(exeConfig, staticScope) {
   const runtimeConfig = getRuntimeCapabilityConfig(exeConfig, "collection");
@@ -40786,7 +39245,7 @@ var createListCollectionsTool = ({
   collectionKeys,
   connectAll
 }) => {
-  return tool54(
+  return tool51(
     async (_input, _exeConfig) => {
       try {
         const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -40821,23 +39280,23 @@ var createListCollectionsTool = ({
     {
       name: "list_collections",
       description: LIST_COLLECTIONS_DESCRIPTION,
-      schema: z60.object({})
+      schema: z57.object({})
     }
   );
 };
 
 // src/tool_lattice/collection/search_collection.ts
-import z61 from "zod";
-import { tool as tool55 } from "langchain";
+import z58 from "zod";
+import { tool as tool52 } from "langchain";
 var SEARCH_COLLECTION_DESCRIPTION = `Search for content within a specific collection using semantic (vector) similarity. Use the 'filter' parameter to narrow results by metadata fields (e.g., {"category": "cardiovascular"}). Returns the most relevant content entries with similarity scores.`;
-var searchSchema = z61.object({
-  collection: z61.string().describe("The collection name to search in"),
-  query: z61.string().describe("The search query text"),
-  filter: z61.record(z61.unknown()).optional().describe("Metadata filter conditions"),
-  top_k: z61.number().optional().default(5).describe("Number of results to return")
+var searchSchema = z58.object({
+  collection: z58.string().describe("The collection name to search in"),
+  query: z58.string().describe("The search query text"),
+  filter: z58.record(z58.unknown()).optional().describe("Metadata filter conditions"),
+  top_k: z58.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => {
-  return tool55(
+  return tool52(
     async (input, _exeConfig) => {
       try {
         const { collection, query, filter: filter2, top_k } = input;
@@ -40903,10 +39362,10 @@ var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true
 };
 
 // src/tool_lattice/collection/get_collection.ts
-import z62 from "zod";
-import { tool as tool56 } from "langchain";
+import z59 from "zod";
+import { tool as tool53 } from "langchain";
 var GET_COLLECTION_DESCRIPTION = `Get a collection's full definition including its custom fields schema. Use this to discover what metadata fields are available before adding entries.`;
-var createGetCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool56(
+var createGetCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool53(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -40931,24 +39390,24 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
       return `Error: ${error.message}`;
     }
   },
-  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z62.object({ name: z62.string().describe("Collection name") }) }
+  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z59.object({ name: z59.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/create_collection.ts
-import z63 from "zod";
-import { tool as tool57 } from "langchain";
-var createSchema = z63.object({
-  name: z63.string().describe("Collection name (lowercase, underscores only)"),
-  label: z63.string().describe("Display name"),
-  embeddingKey: z63.string().describe("Embedding model key"),
-  fields: z63.array(z63.object({
-    key: z63.string().describe("Field key name"),
-    type: z63.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z63.array(z63.string()).optional().describe("Valid values for enum type"),
-    required: z63.boolean().optional().default(false).describe("Whether field is required")
+import z60 from "zod";
+import { tool as tool54 } from "langchain";
+var createSchema = z60.object({
+  name: z60.string().describe("Collection name (lowercase, underscores only)"),
+  label: z60.string().describe("Display name"),
+  embeddingKey: z60.string().describe("Embedding model key"),
+  fields: z60.array(z60.object({
+    key: z60.string().describe("Field key name"),
+    type: z60.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z60.array(z60.string()).optional().describe("Valid values for enum type"),
+    required: z60.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
-var createCreateCollectionTool = (scope = {}) => tool57(
+var createCreateCollectionTool = (scope = {}) => tool54(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -40974,20 +39433,20 @@ var createCreateCollectionTool = (scope = {}) => tool57(
 );
 
 // src/tool_lattice/collection/update_collection.ts
-import z64 from "zod";
-import { tool as tool58 } from "langchain";
-var schema = z64.object({
-  name: z64.string().describe("Collection name"),
-  label: z64.string().optional().describe("New display name"),
-  embeddingKey: z64.string().optional().describe("New embedding model key"),
-  fields: z64.array(z64.object({
-    key: z64.string().describe("Field key name"),
-    type: z64.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z64.array(z64.string()).optional().describe("Valid values for enum type"),
-    required: z64.boolean().optional().default(false).describe("Whether field is required")
+import z61 from "zod";
+import { tool as tool55 } from "langchain";
+var schema = z61.object({
+  name: z61.string().describe("Collection name"),
+  label: z61.string().optional().describe("New display name"),
+  embeddingKey: z61.string().optional().describe("New embedding model key"),
+  fields: z61.array(z61.object({
+    key: z61.string().describe("Field key name"),
+    type: z61.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z61.array(z61.string()).optional().describe("Valid values for enum type"),
+    required: z61.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
-var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool58(
+var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool55(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -41008,9 +39467,9 @@ var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true
 );
 
 // src/tool_lattice/collection/delete_collection.ts
-import z65 from "zod";
-import { tool as tool59 } from "langchain";
-var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool59(
+import z62 from "zod";
+import { tool as tool56 } from "langchain";
+var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool56(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -41022,19 +39481,19 @@ var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true
       return `Error: ${e.message}`;
     }
   },
-  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z65.object({ name: z65.string().describe("Collection name") }) }
+  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z62.object({ name: z62.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/list_entries.ts
-import z66 from "zod";
-import { tool as tool60 } from "langchain";
-var schema2 = z66.object({
-  collection: z66.string().describe("Collection name")
+import z63 from "zod";
+import { tool as tool57 } from "langchain";
+var schema2 = z63.object({
+  collection: z63.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
 }
-var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) => tool60(
+var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) => tool57(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -41063,19 +39522,19 @@ var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/add_entry.ts
-import z67 from "zod";
-import { tool as tool61 } from "langchain";
+import z64 from "zod";
+import { tool as tool58 } from "langchain";
 import { Document } from "@langchain/core/documents";
 import { v4 as uuidv48 } from "uuid";
-var schema3 = z67.object({
-  collection: z67.string().describe("Collection name"),
-  content: z67.string().describe("Entry content text"),
-  metadata: z67.record(z67.unknown()).optional().describe("Metadata fields matching the collection schema")
+var schema3 = z64.object({
+  collection: z64.string().describe("Collection name"),
+  content: z64.string().describe("Entry content text"),
+  metadata: z64.record(z64.unknown()).optional().describe("Metadata fields matching the collection schema")
 });
 function key2(t, n) {
   return `${t}:${n}`;
 }
-var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool61(
+var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool58(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -41107,18 +39566,18 @@ var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => t
 );
 
 // src/tool_lattice/collection/update_entry.ts
-import z68 from "zod";
-import { tool as tool62 } from "langchain";
-var schema4 = z68.object({
-  collection: z68.string().describe("Collection name"),
-  entryId: z68.string().describe("Entry ID to update"),
-  content: z68.string().optional().describe("New content"),
-  metadata: z68.record(z68.unknown()).optional().describe("New metadata")
+import z65 from "zod";
+import { tool as tool59 } from "langchain";
+var schema4 = z65.object({
+  collection: z65.string().describe("Collection name"),
+  entryId: z65.string().describe("Entry ID to update"),
+  content: z65.string().optional().describe("New content"),
+  metadata: z65.record(z65.unknown()).optional().describe("New metadata")
 });
 function key3(t, n) {
   return `${t}:${n}`;
 }
-var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool62(
+var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool59(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -41139,16 +39598,16 @@ var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/delete_entry.ts
-import z69 from "zod";
-import { tool as tool63 } from "langchain";
-var schema5 = z69.object({
-  collection: z69.string().describe("Collection name"),
-  entryId: z69.string().describe("Entry ID to delete")
+import z66 from "zod";
+import { tool as tool60 } from "langchain";
+var schema5 = z66.object({
+  collection: z66.string().describe("Collection name"),
+  entryId: z66.string().describe("Entry ID to delete")
 });
 function key4(t, n) {
   return `${t}:${n}`;
 }
-var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool63(
+var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool60(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -41168,7 +39627,7 @@ var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll, compileStableCandidateTools = false } = params;
   if (!compileStableCandidateTools && !connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return createMiddleware21({
+    return createMiddleware20({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -41178,7 +39637,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const toolParams = { collectionKeys, connectAll };
-  return createMiddleware21({
+  return createMiddleware20({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -41241,24 +39700,24 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-import { createMiddleware as createMiddleware22, ToolMessage as ToolMessage11 } from "langchain";
+import { createMiddleware as createMiddleware21, ToolMessage as ToolMessage11 } from "langchain";
 import { interrupt as interrupt3 } from "@langchain/langgraph";
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
-import { tool as tool64 } from "langchain";
-import z70 from "zod";
-var questionSchema = z70.object({
-  question: z70.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
-  options: z70.array(z70.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
-  type: z70.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
-  required: z70.boolean().optional().default(false).describe("Whether this question must be answered"),
-  allowOther: z70.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
+import { tool as tool61 } from "langchain";
+import z67 from "zod";
+var questionSchema = z67.object({
+  question: z67.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
+  options: z67.array(z67.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
+  type: z67.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
+  required: z67.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: z67.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
 });
-var inputSchema = z70.object({
-  questions: z70.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
+var inputSchema = z67.object({
+  questions: z67.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
 });
 function createAskUserToClarifyTool() {
-  return tool64(
+  return tool61(
     async (input) => {
       return JSON.stringify(input);
     },
@@ -41283,7 +39742,7 @@ function isProjectRoomRun(request) {
   return isRecord9(runConfig?.projectRoom);
 }
 function createAskUserClarifyMiddleware() {
-  return createMiddleware22({
+  return createMiddleware21({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -41387,11 +39846,11 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-import { createMiddleware as createMiddleware23 } from "langchain";
+import { createMiddleware as createMiddleware22 } from "langchain";
 
 // src/tool_lattice/widget/loadGuidelines.ts
-import { tool as tool65 } from "langchain";
-import { z as z71 } from "zod";
+import { tool as tool62 } from "langchain";
+import { z as z68 } from "zod";
 
 // src/middlewares/guidelines/index.ts
 var CORE = `# Imagine \u2014 Visual Creation Suite
@@ -42182,13 +40641,13 @@ function getGuidelines(modules) {
 var AVAILABLE_MODULES = Object.keys(MODULE_SECTIONS);
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var LoadGuidelinesInputSchema = z71.object({
-  modules: z71.array(z71.string()).describe(
+var LoadGuidelinesInputSchema = z68.object({
+  modules: z68.array(z68.string()).describe(
     "Which design modules to load. Choose all that apply. Available modules: [" + AVAILABLE_MODULES.join(",") + "]"
   )
 });
 function createLoadGuidelinesTool() {
-  return tool65(
+  return tool62(
     async (input) => {
       const result = getGuidelines(input.modules);
       return result;
@@ -42202,8 +40661,8 @@ function createLoadGuidelinesTool() {
 }
 
 // src/tool_lattice/widget/showWidget.ts
-import { tool as tool66 } from "langchain";
-import { z as z72 } from "zod";
+import { tool as tool63 } from "langchain";
+import { z as z69 } from "zod";
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
     /<!DOCTYPE/i,
@@ -42225,20 +40684,20 @@ function validateWidgetCode(code) {
   }
   return { valid: true };
 }
-var ShowWidgetInputSchema = z72.object({
-  i_have_seen_guidelines: z72.boolean().describe(
+var ShowWidgetInputSchema = z69.object({
+  i_have_seen_guidelines: z69.boolean().describe(
     "Must be true. Confirm you have called load_guidelines first."
   ),
-  title: z72.string().describe("Title displayed above the widget"),
-  loading_messages: z72.array(z72.string()).optional().describe(
+  title: z69.string().describe("Title displayed above the widget"),
+  loading_messages: z69.array(z69.string()).optional().describe(
     "1-4 short strings shown while the widget renders"
   ),
-  widget_code: z72.string().describe(
+  widget_code: z69.string().describe(
     "HTML fragment to render. Rules: 1. No DOCTYPE, <html>, <head>, or <body> tags. 2. Order: <style> block first, then HTML content, then <script> last. 3. Use only CSS variables for colors (e.g. var(--color-accent)). 4. No gradients, shadows, or blur effects. For SVG: start directly with <svg> tag."
   )
 });
 function createShowWidgetTool() {
-  return tool66(
+  return tool63(
     async (input) => {
       if (!input.i_have_seen_guidelines) {
         return "Error: You must call load_guidelines before using show_widget. Set i_have_seen_guidelines to true only after loading guidelines.";
@@ -42269,7 +40728,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return createMiddleware23({
+  return createMiddleware22({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -42293,8 +40752,8 @@ var widgetPlugin = {
 };
 
 // src/middlewares/taskMiddleware.ts
-import { createMiddleware as createMiddleware24, tool as tool67 } from "langchain";
-import { z as z73 } from "zod";
+import { createMiddleware as createMiddleware23, tool as tool64 } from "langchain";
+import { z as z70 } from "zod";
 import { GraphInterrupt as GraphInterrupt3, interrupt as interrupt4 } from "@langchain/langgraph";
 
 // src/util/truncateForJson.ts
@@ -43176,73 +41635,73 @@ function buildReviewMarkdown(task) {
     result: task.result
   });
 }
-var manageTaskSchema = z73.object({
-  action: z73.enum(["create", "get", "list", "update", "set_status", "add_activity", "delete"]).describe("Action to perform. Available: create, get, list, update, set_status, add_activity, delete. To change status, use set_status. To change content fields, use update."),
-  id: z73.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
-  title: z73.string().optional().describe("Task title (required for create)"),
-  description: z73.string().optional().describe("Task description in Markdown"),
-  priority: z73.enum(["low", "medium", "high"]).optional().describe("Priority level"),
-  status: z73.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Set 'in_progress' when you start processing a task you hold; 'completed'/'failed' require the task to be 'in_progress'. Agent summary-only interrupted updates default to missing_input"),
-  dueDate: z73.string().optional().describe("Due date (ISO 8601 format)"),
-  metadata: z73.record(z73.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
-  metadataFilter: z73.record(
-    z73.union([z73.string(), z73.number(), z73.boolean()])
+var manageTaskSchema = z70.object({
+  action: z70.enum(["create", "get", "list", "update", "set_status", "add_activity", "delete"]).describe("Action to perform. Available: create, get, list, update, set_status, add_activity, delete. To change status, use set_status. To change content fields, use update."),
+  id: z70.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
+  title: z70.string().optional().describe("Task title (required for create)"),
+  description: z70.string().optional().describe("Task description in Markdown"),
+  priority: z70.enum(["low", "medium", "high"]).optional().describe("Priority level"),
+  status: z70.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Set 'in_progress' when you start processing a task you hold; 'completed'/'failed' require the task to be 'in_progress'. Agent summary-only interrupted updates default to missing_input"),
+  dueDate: z70.string().optional().describe("Due date (ISO 8601 format)"),
+  metadata: z70.record(z70.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
+  metadataFilter: z70.record(
+    z70.union([z70.string(), z70.number(), z70.boolean()])
   ).optional().describe("List-only filter. Every key must equal the task metadata value, e.g. {projectId:'p1', retries:2}. Multiple keys AND together."),
-  parentId: z73.string().optional().describe("Parent task ID for grouping subtasks"),
-  sourceId: z73.string().optional().describe("Source session/thread ID"),
-  context: z73.record(z73.unknown()).optional().describe("Additional context data"),
-  ownerType: z73.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
-  ownerId: z73.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
-  requireReview: z73.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
-  dependencies: z73.array(z73.string()).optional().describe("List of task IDs that must be completed before this task can start"),
-  dependencyTaskIds: z73.array(z73.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
-  result: z73.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
-  failureReason: z73.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
-  files: z73.array(z73.object({
-    uri: z73.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
-    name: z73.string().optional().describe("Display name"),
-    addedBy: z73.enum(["user", "agent"]).optional().describe("Who attached the file")
+  parentId: z70.string().optional().describe("Parent task ID for grouping subtasks"),
+  sourceId: z70.string().optional().describe("Source session/thread ID"),
+  context: z70.record(z70.unknown()).optional().describe("Additional context data"),
+  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerId: z70.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
+  requireReview: z70.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
+  dependencies: z70.array(z70.string()).optional().describe("List of task IDs that must be completed before this task can start"),
+  dependencyTaskIds: z70.array(z70.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
+  result: z70.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
+  failureReason: z70.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
+  files: z70.array(z70.object({
+    uri: z70.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
+    name: z70.string().optional().describe("Display name"),
+    addedBy: z70.enum(["user", "agent"]).optional().describe("Who attached the file")
   })).optional().describe("File references attached to this task"),
-  beliefImpact: z73.array(z73.object({
-    key: z73.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-    after: z73.number().int().min(0).max(100),
-    basis: z73.string().trim().min(1).max(1e3),
-    isNew: z73.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
+  beliefImpact: z70.array(z70.object({
+    key: z70.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+    after: z70.number().int().min(0).max(100),
+    basis: z70.string().trim().min(1).max(1e3),
+    isNew: z70.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
   })).optional().describe("Structured belief reports required when an agent-owned task completes; existing keys update the belief owner's table, and a brand-new key must be declared with isNew: true"),
-  content: z73.string().optional().describe("Markdown content required for add_activity"),
-  summary: z73.string().optional().describe("Brief summary of the operation"),
-  executionResultId: z73.string().refine(isExecutionResultEventKey3, {
+  content: z70.string().optional().describe("Markdown content required for add_activity"),
+  summary: z70.string().optional().describe("Brief summary of the operation"),
+  executionResultId: z70.string().refine(isExecutionResultEventKey3, {
     message: "executionResultId must be the execution-result:<threadId> event key returned by task()"
   }).optional().describe(
     "Canonical ASCII `execution-result:<suffix>` event key returned by task(); the nonempty suffix allows only A-Z, a-z, 0-9, period, underscore, colon, and hyphen, and is not a database row ID"
   ),
-  ids: z73.array(z73.string().trim().min(1)).optional().describe("Task IDs to delete in one batch (delete action only). Use with or instead of id.")
+  ids: z70.array(z70.string().trim().min(1)).optional().describe("Task IDs to delete in one batch (delete action only). Use with or instead of id.")
 }).superRefine((input, context) => {
   if (input.executionResultId && input.action !== "update" && input.action !== "set_status" && input.action !== "add_activity") {
     context.addIssue({
-      code: z73.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       path: ["executionResultId"],
       message: "executionResultId is valid only for update, set_status, or add_activity"
     });
   }
   if (input.metadataFilter && input.action !== "list") {
     context.addIssue({
-      code: z73.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       path: ["metadataFilter"],
       message: "metadataFilter is valid only for list"
     });
   }
   if (input.ids && input.action !== "delete") {
     context.addIssue({
-      code: z73.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       path: ["ids"],
       message: "ids is valid only for delete"
     });
   }
 });
-var startTaskSchema = z73.object({
-  taskId: z73.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
-  agentId: z73.string().trim().min(1).describe(
+var startTaskSchema = z70.object({
+  taskId: z70.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
+  agentId: z70.string().trim().min(1).describe(
     `ID of the Agent that should execute the task. Use "general-purpose" to run the caller's own capabilities as an isolated worker.`
   )
 });
@@ -44617,12 +43076,12 @@ function createTaskMiddleware(options = {}) {
       ...trustedCaller ? { callerMembershipId: trustedCaller.membershipId, callerAssistantId: trustedCaller.assistantId } : {}
     }));
   };
-  return createMiddleware24({
+  return createMiddleware23({
     name: "TaskMiddleware",
     contextSchema,
     // Persisted between invocations (ADRs: the run↔task binding survives turns).
-    stateSchema: z73.object({
-      taskId: z73.string().default("")
+    stateSchema: z70.object({
+      taskId: z70.string().default("")
     }),
     // CLAIM: a run that holds a task moves it to in_progress (idempotent).
     beforeAgent: async (state, runtime) => {
@@ -44732,7 +43191,7 @@ ${TASK_CONVERGENCE_GUIDANCE}
       });
     },
     tools: [
-      tool67(
+      tool64(
         handleManageTask,
         {
           name: "manage_task",
@@ -44778,7 +43237,7 @@ to an expert \u2014 never re-dispatch the task you are processing.`,
           schema: manageTaskSchema
         }
       ),
-      tool67(handleStartTask, {
+      tool64(handleStartTask, {
         name: "task",
         description: `Start a persisted TaskItem with any existing Agent in a fresh isolated thread. Use this to delegate work \u2014 dispatch a subtask you created to the agent that should execute it; never re-dispatch the task you are currently processing (give the expert a child task instead). Pass agentId "general-purpose" for the general-purpose worker \u2014 ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION} It has access to all the caller's tools, model, and middleware, so use it for general-purpose subtasks, to isolate context and token usage, and whenever no specialized agent fits. The target does NOT need task-management tools: it runs and returns an observation plus an executionResultId, and the caller passes that executionResultId to the manage_task update or add_activity that interprets and records it. A project task instead returns a managed result (success:true, managed:true) because the project-lifecycle queue owns execution.`,
         schema: startTaskSchema
@@ -44922,8 +43381,8 @@ canonical Belief State:
 };
 
 // src/middlewares/documentLearningMiddleware.ts
-import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
-import { createMiddleware as createMiddleware25 } from "langchain";
+import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
+import { createMiddleware as createMiddleware24 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
 var LEARN_CAPABILITY_SKILL = `---
@@ -45162,7 +43621,7 @@ patterns discovered, recommendations. Include validation coverage: user-sample N
 `;
 
 // src/middlewares/documentLearningMiddleware.ts
-var createDocumentLearningMiddleware = () => createMiddleware25({
+var createDocumentLearningMiddleware = () => createMiddleware24({
   name: "DocumentLearningMiddleware",
   contextSchema,
   tools: []
@@ -45189,7 +43648,7 @@ var documentLearningPlugin = {
       key: "document-learner",
       name: "Document Learning Agent",
       description: "Read documents and build structured skill systems with evaluations. Use this agent when you need to extract knowledge from documents and turn it into reusable, testable agent skills.",
-      type: AgentType10.DEEP_AGENT,
+      type: AgentType9.DEEP_AGENT,
       prompt: DOCUMENT_LEARNER_SYSTEM_PROMPT,
       subAgents: ["document-parser-benchmark"],
       tools: [
@@ -45280,12 +43739,12 @@ var documentLearningPlugin = {
 };
 
 // src/middlewares/documentParserMiddleware.ts
-import { createMiddleware as createMiddleware26 } from "langchain";
+import { createMiddleware as createMiddleware25 } from "langchain";
 
 // src/tool_lattice/document_parser/index.ts
 import * as path7 from "path";
-import z74 from "zod";
-import { tool as tool68 } from "langchain";
+import z71 from "zod";
+import { tool as tool65 } from "langchain";
 var PARSE_DOCUMENT_DESCRIPTION = `Parse a document file (docx, pdf) into structured Markdown using a remote document parsing service.
 This tool handles the full pipeline internally: file upload \u2192 document parsing \u2192 polling until complete \u2192 download result \u2192 save to filesystem.
 
@@ -45408,7 +43867,7 @@ function createParseDocumentTool({
   baseUrl = "",
   apiKey = ""
 }) {
-  return tool68(
+  return tool65(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config?.configurable?.runConfig ?? { assistant_id: "", thread_id: "" };
@@ -45479,17 +43938,17 @@ function createParseDocumentTool({
     {
       name: "parse_document",
       description: PARSE_DOCUMENT_DESCRIPTION,
-      schema: z74.object({
-        file_path: z74.string().describe(
+      schema: z71.object({
+        file_path: z71.string().describe(
           'Absolute path to the document file. Must point to an existing .docx or .pdf file. Example: "/project/reports/contract.docx". The file must be accessible from the current workspace.'
         ),
-        engine: z74.string().describe(
+        engine: z71.string().describe(
           'Parsing engine to use. Available options: "textin" (recommended, works with local files, supports docx/pdf), "datalab" (alternative engine for docx/pdf), "mineru" (requires public URL, use only if textin/datalab fail), "paddleocr_remote" (PaddleOCR, good for scanned documents), "qwen_ocr" (OCR-focused, best for image-heavy PDFs).'
         ),
-        output_path: z74.string().optional().describe(
+        output_path: z71.string().optional().describe(
           'Path to save the parsed result. If not specified, the input extension is replaced with .md. Example: "/project/report.docx" becomes "/project/report.md". Parent directories are created automatically.'
         ),
-        output_format: z74.enum(["markdown", "json"]).optional().default("markdown").describe(
+        output_format: z71.enum(["markdown", "json"]).optional().default("markdown").describe(
           'Output format. "markdown": structured Markdown with tables, headers, formatting preserved (recommended). "json": raw JSON output from the parsing engine (for programmatic use).'
         )
       })
@@ -45498,7 +43957,7 @@ function createParseDocumentTool({
 }
 
 // src/middlewares/documentParserMiddleware.ts
-import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 
 // src/middlewares/documentBenchmarkWorkflow.ts
 var DOCUMENT_PARSER_BENCHMARK_YAML = `name: document-parser-benchmark
@@ -45907,7 +44366,7 @@ def main() -> None:
 if __name__ == "__main__":
     main()
 `;
-var resources2 = {
+var resources = {
   "references/api_reference.md": { mimeType: "text/markdown", content: `# API reference
 
 The supported command-line form is 'markitdown input -o output.md'. The Python API uses 'MarkItDown().convert(path)' upstream, but this runtime prefers the installed CLI and does not provide direct Python SDK LLM calls. Use local conversion for local files and keep output as Markdown.` },
@@ -45936,7 +44395,7 @@ Single file: 'markitdown input -o output.md'. Ordinary directory: 'scripts/batch
 var DOCUMENT_PARSER_MARKITDOWN_SKILL = {
   version: "1.1.0",
   content: MARKITDOWN_SKILL_CONTENT,
-  resources: resources2
+  resources
 };
 
 // src/middlewares/documentParserMiddleware.ts
@@ -45945,7 +44404,7 @@ function createDocumentParserMiddleware(config) {
   const baseUrl = config.baseUrl || "";
   const apiKey = config.apiKey || "";
   const connections = Array.isArray(config.connections) ? config.connections.filter((key5) => typeof key5 === "string") : [];
-  return createMiddleware26({
+  return createMiddleware25({
     name: "DocumentParser",
     contextSchema,
     tools: [createParseDocumentTool({ connectAll, connections, baseUrl, apiKey })]
@@ -46023,7 +44482,7 @@ var documentParserPlugin = {
   agents: {
     "document-parser-benchmark": {
       key: "document-parser-benchmark",
-      type: AgentType11.WORKFLOW,
+      type: AgentType10.WORKFLOW,
       name: "Document Parser Benchmark",
       description: "Benchmark document parsing engines. Parses a document with 5 engines in parallel, scores results, and produces a ranking report. Use this when you need to evaluate which parsing engine works best for a given document.",
       prompt: "Benchmark document parsing engines: parse with 5 engines, score, and rank results.",
@@ -46066,8 +44525,8 @@ import {
   snapshotExactArray as snapshotExactArray3,
   snapshotExactRecord as snapshotExactRecord8
 } from "@axiom-lattice/protocols";
-import { createMiddleware as createMiddleware27, tool as tool69 } from "langchain";
-import { z as z75 } from "zod";
+import { createMiddleware as createMiddleware26, tool as tool66 } from "langchain";
+import { z as z72 } from "zod";
 var PROJECT_ROOM_CONTEXT_REQUIRED = "PROJECT_ROOM_CONTEXT_REQUIRED";
 var PROJECT_ROOM_POST_FAILED = "PROJECT_ROOM_POST_FAILED";
 var PROJECT_ROOM_ROSTER_FAILED = "PROJECT_ROOM_ROSTER_FAILED";
@@ -46087,10 +44546,10 @@ var ROSTER_FAILED = JSON.stringify({
   error: PROJECT_ROOM_ROSTER_FAILED,
   message: PROJECT_ROOM_ROSTER_FAILED_MESSAGE
 });
-var postSchema = z75.object({
-  text: z75.string().trim().min(1).max(2e4)
+var postSchema = z72.object({
+  text: z72.string().trim().min(1).max(2e4)
 }).strict();
-var listSchema = z75.object({}).strict();
+var listSchema = z72.object({}).strict();
 function ownDataValue2(record, key5) {
   if (typeof record !== "object" || record === null || Array.isArray(record)) return void 0;
   try {
@@ -46157,10 +44616,10 @@ async function hasActiveCurrentMembership(scope) {
   return true;
 }
 function createProjectRoomMiddleware() {
-  return createMiddleware27({
+  return createMiddleware26({
     name: "ProjectRoomMiddleware",
     tools: [
-      tool69(async (input, config) => {
+      tool66(async (input, config) => {
         const { text } = input;
         const scope = readTrustedRoomScope(config);
         if (!scope) return CONTEXT_REQUIRED;
@@ -46191,7 +44650,7 @@ function createProjectRoomMiddleware() {
         description: "Post a text reply to the current trusted Project Room message",
         schema: postSchema
       }),
-      tool69(async (_input, config) => {
+      tool66(async (_input, config) => {
         const scope = readTrustedRoomScope(config);
         if (!scope) return CONTEXT_REQUIRED;
         try {
@@ -46233,9 +44692,9 @@ var projectRoomPlugin = {
 };
 
 // src/middlewares/sandboxPluginsMiddleware.ts
-import { createMiddleware as createMiddleware28, tool as tool70 } from "langchain";
-import { z as z76 } from "zod";
-import { AgentType as AgentType12 } from "@axiom-lattice/protocols";
+import { createMiddleware as createMiddleware27, tool as tool67 } from "langchain";
+import { z as z73 } from "zod";
+import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
 
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
@@ -46956,16 +45415,16 @@ function tenantIdFrom(exeConfig) {
   const c = exeConfig;
   return c?.configurable?.runConfig?.tenantId ?? "default";
 }
-var managePluginSchema = z76.object({
-  action: z76.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
-  type: z76.string().optional(),
-  manifest: z76.record(z76.unknown()).optional(),
-  handlers: z76.record(z76.string()).optional(),
-  target: z76.object({
-    kind: z76.enum(["tool", "connection-test", "connection-discover"]),
-    name: z76.string().optional(),
-    input: z76.unknown().optional(),
-    connectionKey: z76.string().optional()
+var managePluginSchema = z73.object({
+  action: z73.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
+  type: z73.string().optional(),
+  manifest: z73.record(z73.unknown()).optional(),
+  handlers: z73.record(z73.string()).optional(),
+  target: z73.object({
+    kind: z73.enum(["tool", "connection-test", "connection-discover"]),
+    name: z73.string().optional(),
+    input: z73.unknown().optional(),
+    connectionKey: z73.string().optional()
   }).optional()
 });
 var sandboxPluginsPlugin = {
@@ -46985,7 +45444,7 @@ var sandboxPluginsPlugin = {
       key: "plugin-builder",
       name: "Plugin Builder",
       description: "Author and manage tenant plugins in the shared sandbox: clarify goal, inputs/outputs, credentials, and whether a UI is needed; then write the manifest and JS handlers, add an optional HTML MCP App UI, and validate/test with the manage_plugin tool.",
-      type: AgentType12.DEEP_AGENT,
+      type: AgentType11.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
       middleware: [
         {
@@ -47039,10 +45498,10 @@ var sandboxPluginsPlugin = {
       ]
     }
   },
-  middleware: () => createMiddleware28({
+  middleware: () => createMiddleware27({
     name: "SandboxPluginsMiddleware",
     tools: [
-      tool70(
+      tool67(
         async (input, exeConfig) => {
           const tenantId2 = tenantIdFrom(exeConfig);
           const catalog2 = getSandboxPluginCatalog();
@@ -47183,7 +45642,6 @@ var BUILTIN_PLUGINS = [
   sqlPlugin,
   skillPlugin,
   metricsPlugin,
-  semanticMetricsPlugin,
   askUserClarifyPlugin,
   widgetPlugin,
   clawPlugin,
@@ -47815,7 +46273,6 @@ export {
   createSandboxProvider,
   createSandboxResolver,
   createSchedulerMiddleware,
-  createSemanticMetricsMiddleware,
   createSharePayload,
   createTaskExecutionService,
   createTaskLifecycleService,
@@ -47974,7 +46431,6 @@ export {
   sandboxLatticeManager,
   sanitizeToolCallId,
   scheduleLatticeManager,
-  semanticMetricsPlugin,
   serializePluginMeta,
   serializeTaskMutationSuccess,
   serializeTaskNormalizationFallback,