@axiom-lattice/core 2.1.14 → 2.1.16

package/dist/index.mjs

@@ -1120,14 +1120,884 @@ ${trimmedQuery}
   }
 );
 
+// src/tool_lattice/load_skills/index.ts
+import z7 from "zod";
+
+// src/store_lattice/InMemoryThreadStore.ts
+var InMemoryThreadStore = class {
+  constructor() {
+    // Map<assistantId, Map<threadId, Thread>>
+    this.threads = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all threads for a specific assistant
+   */
+  async getThreadsByAssistantId(assistantId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return [];
+    }
+    return Array.from(assistantThreads.values());
+  }
+  /**
+   * Get a thread by ID for a specific assistant
+   */
+  async getThreadById(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return void 0;
+    }
+    return assistantThreads.get(threadId);
+  }
+  /**
+   * Create a new thread for an assistant
+   */
+  async createThread(assistantId, threadId, data) {
+    const now = /* @__PURE__ */ new Date();
+    const thread = {
+      id: threadId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+    if (!this.threads.has(assistantId)) {
+      this.threads.set(assistantId, /* @__PURE__ */ new Map());
+    }
+    const assistantThreads = this.threads.get(assistantId);
+    assistantThreads.set(threadId, thread);
+    return thread;
+  }
+  /**
+   * Update an existing thread
+   */
+  async updateThread(assistantId, threadId, updates) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return null;
+    }
+    const existing = assistantThreads.get(threadId);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata || {}
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    assistantThreads.set(threadId, updated);
+    return updated;
+  }
+  /**
+   * Delete a thread by ID
+   */
+  async deleteThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.delete(threadId);
+  }
+  /**
+   * Check if thread exists
+   */
+  async hasThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.has(threadId);
+  }
+  /**
+   * Clear all threads (useful for testing)
+   */
+  clear() {
+    this.threads.clear();
+  }
+  /**
+   * Get all threads for all assistants (useful for debugging)
+   */
+  getAllThreads() {
+    const allThreads = [];
+    for (const assistantThreads of this.threads.values()) {
+      allThreads.push(...Array.from(assistantThreads.values()));
+    }
+    return allThreads;
+  }
+};
+
+// src/store_lattice/InMemoryAssistantStore.ts
+var InMemoryAssistantStore = class {
+  constructor() {
+    this.assistants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all assistants
+   */
+  async getAllAssistants() {
+    return Array.from(this.assistants.values());
+  }
+  /**
+   * Get assistant by ID
+   */
+  async getAssistantById(id) {
+    return this.assistants.get(id) || null;
+  }
+  /**
+   * Create a new assistant
+   */
+  async createAssistant(id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const assistant = {
+      id,
+      name: data.name,
+      description: data.description,
+      graphDefinition: data.graphDefinition,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.assistants.set(id, assistant);
+    return assistant;
+  }
+  /**
+   * Update an existing assistant
+   */
+  async updateAssistant(id, updates) {
+    const existing = this.assistants.get(id);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.assistants.set(id, updated);
+    return updated;
+  }
+  /**
+   * Delete an assistant by ID
+   */
+  async deleteAssistant(id) {
+    return this.assistants.delete(id);
+  }
+  /**
+   * Check if assistant exists
+   */
+  async hasAssistant(id) {
+    return this.assistants.has(id);
+  }
+  /**
+   * Clear all assistants (useful for testing)
+   */
+  clear() {
+    this.assistants.clear();
+  }
+};
+
+// src/store_lattice/FileSystemSkillStore.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/skill_lattice/skillNameValidator.ts
+var SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var MIN_LENGTH = 1;
+var MAX_LENGTH = 64;
+function isValidSkillName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.length < MIN_LENGTH || name.length > MAX_LENGTH) {
+    return false;
+  }
+  return SKILL_NAME_REGEX.test(name);
+}
+function validateSkillName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Skill name is required and must be a string");
+  }
+  if (name.length < MIN_LENGTH || name.length > MAX_LENGTH) {
+    throw new Error(
+      `Skill name must be between ${MIN_LENGTH} and ${MAX_LENGTH} characters`
+    );
+  }
+  if (!SKILL_NAME_REGEX.test(name)) {
+    throw new Error(
+      "Skill name must be lowercase alphanumeric with single hyphen separators, not start or end with -, and not contain consecutive --. Pattern: ^[a-z0-9]+(-[a-z0-9]+)*$"
+    );
+  }
+}
+
+// src/store_lattice/FileSystemSkillStore.ts
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    console.warn("[parseFrontmatter] No frontmatter match found in content");
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterText = match[1];
+  const body = match[2] || "";
+  const frontmatter = {};
+  const lines = frontmatterText.split("\n");
+  let currentKey = null;
+  let metadataIndent = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+    if (currentKey === "metadata" && indent > metadataIndent) {
+      const colonIndex2 = trimmed.indexOf(":");
+      if (colonIndex2 !== -1) {
+        const key2 = trimmed.substring(0, colonIndex2).trim();
+        let value2 = trimmed.substring(colonIndex2 + 1).trim();
+        if (value2.startsWith('"') && value2.endsWith('"') || value2.startsWith("'") && value2.endsWith("'")) {
+          value2 = value2.slice(1, -1);
+        }
+        if (!frontmatter.metadata) {
+          frontmatter.metadata = {};
+        }
+        frontmatter.metadata[key2] = value2;
+      }
+      continue;
+    }
+    if (currentKey === "subSkills" && indent > metadataIndent) {
+      if (trimmed.startsWith("-")) {
+        let value2 = trimmed.substring(1).trim();
+        if (value2.startsWith('"') && value2.endsWith('"') || value2.startsWith("'") && value2.endsWith("'")) {
+          value2 = value2.slice(1, -1);
+        }
+        if (!frontmatter.subSkills) {
+          frontmatter.subSkills = [];
+        }
+        frontmatter.subSkills.push(value2);
+      }
+      continue;
+    }
+    if ((currentKey === "metadata" || currentKey === "subSkills") && indent <= metadataIndent) {
+      currentKey = null;
+      metadataIndent = 0;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmed.substring(0, colonIndex).trim();
+    let value = trimmed.substring(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "metadata") {
+      if (value === "" || value === "{}") {
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1];
+          const nextIndent = nextLine.match(/^(\s*)/)?.[1].length || 0;
+          if (nextIndent > indent) {
+            currentKey = "metadata";
+            metadataIndent = indent;
+            frontmatter.metadata = {};
+            continue;
+          }
+        }
+        frontmatter[key] = {};
+      } else if (value.startsWith("{")) {
+        try {
+          frontmatter[key] = JSON.parse(value);
+        } catch {
+          frontmatter[key] = {};
+        }
+      } else {
+        frontmatter[key] = {};
+      }
+    } else if (key === "subSkills") {
+      if (value === "" || value === "[]") {
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1];
+          const nextIndent = nextLine.match(/^(\s*)/)?.[1].length || 0;
+          if (nextIndent > indent && nextLine.trim().startsWith("-")) {
+            currentKey = "subSkills";
+            metadataIndent = indent;
+            frontmatter.subSkills = [];
+            continue;
+          }
+        }
+        frontmatter[key] = [];
+      } else if (value.startsWith("[")) {
+        try {
+          frontmatter[key] = JSON.parse(value);
+        } catch {
+          frontmatter[key] = [];
+        }
+      } else {
+        frontmatter[key] = [];
+      }
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function generateFrontmatter(data) {
+  const lines = ["---"];
+  lines.push(`name: ${data.name}`);
+  lines.push(`description: ${data.description}`);
+  if (data.license) {
+    lines.push(`license: ${data.license}`);
+  }
+  if (data.compatibility) {
+    lines.push(`compatibility: ${data.compatibility}`);
+  }
+  if (data.metadata && Object.keys(data.metadata).length > 0) {
+    lines.push("metadata:");
+    for (const [key, value] of Object.entries(data.metadata)) {
+      lines.push(`  ${key}: ${value}`);
+    }
+  }
+  if (data.subSkills && data.subSkills.length > 0) {
+    lines.push("subSkills:");
+    for (const subSkill of data.subSkills) {
+      lines.push(`  - ${subSkill}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+var FileSystemSkillStore = class {
+  constructor(options = {}) {
+    const defaultPath = "lattice_store/skills";
+    const providedPath = options.rootDir || defaultPath;
+    if (path.isAbsolute(providedPath)) {
+      this.rootDir = providedPath;
+    } else {
+      this.rootDir = path.resolve(process.cwd(), providedPath);
+    }
+    this.ensureDirectoryExists().catch((error) => {
+      console.error("Failed to initialize FileSystemSkillStore:", error);
+    });
+  }
+  /**
+   * Ensure the root directory exists
+   */
+  async ensureDirectoryExists() {
+    try {
+      await fs.access(this.rootDir);
+    } catch {
+      await fs.mkdir(this.rootDir, { recursive: true });
+    }
+  }
+  /**
+   * Get directory path for a skill name
+   * Name is used as the directory name, and SKILL.md is the fixed filename
+   */
+  getSkillDirectoryPath(name) {
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      throw new Error(`Invalid skill name: ${name} (contains invalid characters)`);
+    }
+    return path.join(this.rootDir, name);
+  }
+  /**
+   * Get file path for a skill name
+   * File is always named SKILL.md inside the name directory
+   */
+  getSkillFilePath(name) {
+    return path.join(this.getSkillDirectoryPath(name), "SKILL.md");
+  }
+  /**
+   * Read skill from file
+   * Uses name as the directory name and reads SKILL.md from it
+   */
+  async readSkillFile(name) {
+    await this.ensureDirectoryExists();
+    const filePath = this.getSkillFilePath(name);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const { frontmatter, body } = parseFrontmatter(content);
+      if (!frontmatter.name || !frontmatter.description) {
+        console.warn(
+          `Skill file ${name} parsed frontmatter:`,
+          JSON.stringify(frontmatter, null, 2)
+        );
+        console.warn(`Raw frontmatter text (first 200 chars):`, content.substring(0, 200));
+      }
+      const stats = await fs.stat(filePath);
+      if (!frontmatter.name || !frontmatter.description) {
+        throw new Error(
+          `Invalid skill file ${name}: missing required fields (name or description). Frontmatter: ${JSON.stringify(frontmatter)}`
+        );
+      }
+      if (frontmatter.name !== name) {
+        throw new Error(
+          `Skill name mismatch: directory name is "${name}" but frontmatter name is "${frontmatter.name}"`
+        );
+      }
+      return {
+        id: name,
+        // id equals name (name is used for path addressing)
+        name: frontmatter.name,
+        description: frontmatter.description,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata || {},
+        content: body.trim() || void 0,
+        subSkills: Array.isArray(frontmatter.subSkills) ? frontmatter.subSkills : void 0,
+        createdAt: stats.birthtime,
+        updatedAt: stats.mtime
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.warn(`Skill file not found: ${filePath}`);
+        return null;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to read skill file ${filePath}: ${errorMessage}`);
+    }
+  }
+  /**
+   * Write skill to file
+   * Creates directory with name and writes SKILL.md inside it
+   */
+  async writeSkillFile(skill) {
+    await this.ensureDirectoryExists();
+    const skillName = skill.name;
+    const skillDir = this.getSkillDirectoryPath(skillName);
+    const filePath = this.getSkillFilePath(skillName);
+    try {
+      await fs.mkdir(skillDir, { recursive: true });
+    } catch (error) {
+    }
+    const frontmatter = generateFrontmatter({
+      name: skillName,
+      description: skill.description,
+      license: skill.license,
+      compatibility: skill.compatibility,
+      metadata: skill.metadata,
+      subSkills: skill.subSkills
+    });
+    const body = skill.content || "";
+    const content = body ? `${frontmatter}
+${body}` : `${frontmatter}
+`;
+    await fs.writeFile(filePath, content, "utf-8");
+  }
+  /**
+   * Get all skills
+   */
+  async getAllSkills() {
+    await this.ensureDirectoryExists();
+    try {
+      const entries = await fs.readdir(this.rootDir, { withFileTypes: true });
+      const skills = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillName = entry.name;
+          try {
+            const skill = await this.readSkillFile(skillName);
+            if (skill) {
+              skills.push(skill);
+            } else {
+              console.warn(
+                `Failed to load skill "${skillName}": readSkillFile returned null`
+              );
+            }
+          } catch (error) {
+            console.error(
+              `Error loading skill "${skillName}" from ${this.getSkillFilePath(skillName)}:`,
+              error instanceof Error ? error.message : String(error)
+            );
+          }
+        }
+      }
+      return skills.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.warn(
+          `Skills directory not found: ${this.rootDir}`
+        );
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get skill by ID
+   * ID should equal name (name is used for path addressing)
+   */
+  async getSkillById(id) {
+    return this.readSkillFile(id);
+  }
+  /**
+   * Create a new skill
+   * id should equal name (name is used for path addressing)
+   */
+  async createSkill(id, data) {
+    await this.ensureDirectoryExists();
+    validateSkillName(data.name);
+    if (id !== data.name) {
+      throw new Error(
+        `Skill id "${id}" must equal name "${data.name}" (name is used for path addressing)`
+      );
+    }
+    const existing = await this.getSkillById(id);
+    if (existing) {
+      return this.updateSkill(id, data);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const skill = {
+      id: data.name,
+      // id equals name
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata || {},
+      content: data.content,
+      subSkills: data.subSkills,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.writeSkillFile(skill);
+    return skill;
+  }
+  /**
+   * Update an existing skill
+   */
+  async updateSkill(id, updates) {
+    const skill = await this.readSkillFile(id);
+    if (!skill) {
+      return null;
+    }
+    if (updates.name !== void 0) {
+      validateSkillName(updates.name);
+      if (updates.name !== skill.name) {
+        const oldDir = this.getSkillDirectoryPath(skill.name);
+        const newDir = this.getSkillDirectoryPath(updates.name);
+        try {
+          await fs.rename(oldDir, newDir);
+        } catch (error) {
+          throw new Error(
+            `Failed to rename skill directory from "${skill.name}" to "${updates.name}": ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    const updatedSkill = {
+      ...skill,
+      name: updates.name ?? skill.name,
+      id: updates.name ?? skill.id,
+      // id equals name
+      description: updates.description ?? skill.description,
+      license: updates.license ?? skill.license,
+      compatibility: updates.compatibility ?? skill.compatibility,
+      metadata: updates.metadata ?? skill.metadata,
+      content: updates.content !== void 0 ? updates.content : skill.content,
+      subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.writeSkillFile(updatedSkill);
+    return updatedSkill;
+  }
+  /**
+   * Delete a skill by ID
+   * Deletes the entire directory (name is the directory name)
+   */
+  async deleteSkill(id) {
+    await this.ensureDirectoryExists();
+    const skillDir = this.getSkillDirectoryPath(id);
+    try {
+      await fs.rm(skillDir, { recursive: true, force: true });
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Check if skill exists
+   */
+  async hasSkill(id) {
+    const skill = await this.getSkillById(id);
+    return skill !== null;
+  }
+  /**
+   * Search skills by metadata
+   */
+  async searchByMetadata(metadataKey, metadataValue) {
+    const allSkills = await this.getAllSkills();
+    return allSkills.filter((skill) => {
+      return skill.metadata && skill.metadata[metadataKey] === metadataValue;
+    });
+  }
+  /**
+   * Filter skills by compatibility
+   */
+  async filterByCompatibility(compatibility) {
+    const allSkills = await this.getAllSkills();
+    return allSkills.filter((skill) => {
+      return skill.compatibility === compatibility;
+    });
+  }
+  /**
+   * Filter skills by license
+   */
+  async filterByLicense(license) {
+    const allSkills = await this.getAllSkills();
+    return allSkills.filter((skill) => {
+      return skill.license === license;
+    });
+  }
+  /**
+   * Get sub-skills of a parent skill
+   */
+  async getSubSkills(parentSkillName) {
+    const parentSkill = await this.getSkillById(parentSkillName);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+    const subSkills = [];
+    for (const subSkillName of parentSkill.subSkills) {
+      const subSkill = await this.getSkillById(subSkillName);
+      if (subSkill) {
+        subSkills.push(subSkill);
+      }
+    }
+    return subSkills;
+  }
+};
+
+// src/store_lattice/StoreLatticeManager.ts
+var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
+  /**
+   * Get StoreLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_StoreLatticeManager._instance) {
+      _StoreLatticeManager._instance = new _StoreLatticeManager();
+    }
+    return _StoreLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "stores";
+  }
+  /**
+   * Generate composite key from key and type
+   * @param key Lattice key name
+   * @param type Store type
+   * @returns Composite key string
+   */
+  getCompositeKey(key, type) {
+    return `${key}:${type}`;
+  }
+  /**
+   * Register store Lattice with type safety
+   * Uses composite key (key + type) as unique identifier
+   * @param key Lattice key name
+   * @param type Store type (e.g., "thread")
+   * @param store Store implementation instance matching the type
+   */
+  registerLattice(key, type, store) {
+    const storeLattice = {
+      key,
+      type,
+      store
+    };
+    const compositeKey = this.getCompositeKey(key, type);
+    this.register(compositeKey, storeLattice);
+  }
+  /**
+   * Get StoreLattice with type safety
+   * Uses composite key (key + type) to retrieve the store
+   * @param key Lattice key name
+   * @param type Expected store type for type checking
+   * @returns StoreLattice with typed store
+   */
+  getStoreLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    const storeLattice = this.get(compositeKey);
+    if (!storeLattice) {
+      throw new Error(`StoreLattice ${key}:${type} not found`);
+    }
+    if (storeLattice.type !== type) {
+      throw new Error(
+        `StoreLattice ${key}:${type} has type "${storeLattice.type}", expected "${type}"`
+      );
+    }
+    return storeLattice;
+  }
+  /**
+   * Get StoreLattice without type checking (for backward compatibility)
+   * @param key Lattice key name
+   * @param type Store type
+   * @returns StoreLattice (type may be unknown)
+   */
+  getStoreLatticeUnsafe(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    const storeLattice = this.get(compositeKey);
+    if (!storeLattice) {
+      throw new Error(`StoreLattice ${key}:${type} not found`);
+    }
+    return storeLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * Uses composite key (key + type) to check existence
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  hasLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.has(compositeKey);
+  }
+  /**
+   * Remove Lattice
+   * Uses composite key (key + type) to remove the store
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  removeLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.remove(compositeKey);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var storeLatticeManager = StoreLatticeManager.getInstance();
+var registerStoreLattice = (key, type, store) => storeLatticeManager.registerLattice(key, type, store);
+var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, type);
+var defaultThreadStore = new InMemoryThreadStore();
+var defaultAssistantStore = new InMemoryAssistantStore();
+var defaultSkillStore = new FileSystemSkillStore();
+storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
+storeLatticeManager.registerLattice(
+  "default",
+  "assistant",
+  defaultAssistantStore
+);
+storeLatticeManager.registerLattice("default", "skill", defaultSkillStore);
+
+// src/tool_lattice/load_skills/index.ts
+var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure. Skills can have sub-skills, creating a tree structure for organizing capabilities.`;
+registerToolLattice(
+  "load_skills",
+  {
+    name: "load_skills",
+    description: LOAD_SKILLS_DESCRIPTION,
+    needUserApprove: false,
+    schema: z7.object({})
+  },
+  async () => {
+    try {
+      const storeLattice = getStoreLattice("default", "skill");
+      const skillStore = storeLattice.store;
+      const skills = await skillStore.getAllSkills();
+      const skillsMeta = skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+        license: skill.license,
+        compatibility: skill.compatibility,
+        metadata: skill.metadata,
+        subSkills: skill.subSkills
+      }));
+      return JSON.stringify(skillsMeta, null, 2);
+    } catch (error) {
+      return `Error loading skills: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/load_skill_content/index.ts
+import z8 from "zod";
+var LOAD_SKILL_CONTENT_DESCRIPTION = `Load a specific skill's content by name and return its full content including markdown body. This tool returns the complete skill content including frontmatter and markdown body. If the skill has sub-skills defined, they will be listed in the frontmatter. Use this tool to get the complete skill content for a skill that you want to use.`;
+registerToolLattice(
+  "load_skill_content",
+  {
+    name: "load_skill_content",
+    description: LOAD_SKILL_CONTENT_DESCRIPTION,
+    needUserApprove: false,
+    schema: z8.object({
+      skill_name: z8.string().describe("The name of the skill to load")
+    })
+  },
+  async (input) => {
+    try {
+      const storeLattice = getStoreLattice("default", "skill");
+      const skillStore = storeLattice.store;
+      const skill = await skillStore.getSkillById(input.skill_name);
+      if (!skill) {
+        const allSkills = await skillStore.getAllSkills();
+        const availableSkills = allSkills.map((s) => s.name).join(", ");
+        return `Skill "${input.skill_name}" not found. Available skills: ${availableSkills}`;
+      }
+      const frontmatter = ["---"];
+      frontmatter.push(`name: ${skill.name}`);
+      frontmatter.push(`description: ${skill.description}`);
+      if (skill.license) {
+        frontmatter.push(`license: ${skill.license}`);
+      }
+      if (skill.compatibility) {
+        frontmatter.push(`compatibility: ${skill.compatibility}`);
+      }
+      if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+        frontmatter.push("metadata:");
+        for (const [key, value] of Object.entries(skill.metadata)) {
+          frontmatter.push(`  ${key}: ${value}`);
+        }
+      }
+      if (skill.subSkills && skill.subSkills.length > 0) {
+        frontmatter.push("subSkills:");
+        for (const subSkill of skill.subSkills) {
+          frontmatter.push(`  - ${subSkill}`);
+        }
+      }
+      frontmatter.push("---");
+      const content = skill.content || "";
+      return `${frontmatter.join("\n")}
+${content}`;
+    } catch (error) {
+      return `Error loading skill content: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
 // src/agent_lattice/types.ts
 import {
   AgentType,
   AgentConfig,
   ReactAgentConfig,
   DeepAgentConfig,
-  PlanExecuteAgentConfig,
-  SequentialAgentConfig,
   AgentConfigWithTools,
   GraphBuildOptions,
   hasTools,
@@ -1365,8 +2235,8 @@ function performStringReplacement(content, oldString, newString, replaceAll) {
   const newContent = content.split(oldString).join(newString);
   return [newContent, occurrences];
 }
-function validatePath(path) {
-  const pathStr = path || "/";
+function validatePath(path2) {
+  const pathStr = path2 || "/";
   if (!pathStr || pathStr.trim() === "") {
     throw new Error("Path cannot be empty");
   }
@@ -1376,10 +2246,10 @@ function validatePath(path) {
   }
   return normalized;
 }
-function globSearchFiles(files, pattern, path = "/") {
+function globSearchFiles(files, pattern, path2 = "/") {
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path);
+    normalizedPath = validatePath(path2);
   } catch {
     return "No files found";
   }
@@ -1410,7 +2280,7 @@ function globSearchFiles(files, pattern, path = "/") {
   }
   return matches.map(([fp]) => fp).join("\n");
 }
-function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
+function grepMatchesFromFiles(files, pattern, path2 = null, glob = null) {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -1419,7 +2289,7 @@ function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path);
+    normalizedPath = validatePath(path2);
   } catch {
     return [];
   }
@@ -1464,11 +2334,11 @@ var StateBackend = class {
    * @returns List of FileInfo objects for files and directories directly in the directory.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  lsInfo(path) {
+  lsInfo(path2) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path.endsWith("/") ? path : path + "/";
+    const normalizedPath = path2.endsWith("/") ? path2 : path2 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
@@ -1574,16 +2444,16 @@ var StateBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  grepRaw(pattern, path = "/", glob = null) {
+  grepRaw(pattern, path2 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path, glob);
+    return grepMatchesFromFiles(files, pattern, path2, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern, path = "/") {
+  globInfo(pattern, path2 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path);
+    const result = globSearchFiles(files, pattern, path2);
     if (result === "No files found") {
       return [];
     }
@@ -1669,10 +2539,10 @@ function createLsTool(backend, options) {
         store: config.store
       };
       const resolvedBackend = getBackend(backend, stateAndStore);
-      const path = input.path || "/";
-      const infos = await resolvedBackend.lsInfo(path);
+      const path2 = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path2);
       if (infos.length === 0) {
-        return `No files found in ${path}`;
+        return `No files found in ${path2}`;
       }
       const lines = [];
       for (const info of infos) {
@@ -1807,8 +2677,8 @@ function createGlobTool(backend, options) {
         store: config.store
       };
       const resolvedBackend = getBackend(backend, stateAndStore);
-      const { pattern, path = "/" } = input;
-      const infos = await resolvedBackend.globInfo(pattern, path);
+      const { pattern, path: path2 = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path2);
       if (infos.length === 0) {
         return `No files found matching pattern '${pattern}'`;
       }
@@ -1833,8 +2703,8 @@ function createGrepTool(backend, options) {
         store: config.store
       };
       const resolvedBackend = getBackend(backend, stateAndStore);
-      const { pattern, path = "/", glob = null } = input;
-      const result = await resolvedBackend.grepRaw(pattern, path, glob);
+      const { pattern, path: path2 = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path2, glob);
       if (typeof result === "string") {
         return result;
       }
@@ -1987,7 +2857,7 @@ ${systemPrompt}` : systemPrompt;
 }
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z7 } from "zod/v3";
+import { z as z9 } from "zod/v3";
 import {
   createMiddleware as createMiddleware2,
   createAgent as createAgent2,
@@ -2262,12 +3132,12 @@ var AgentManager = class _AgentManager {
     return _AgentManager.instance;
   }
   callAgentInQueue(queue, return_agent_state) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
       if (return_agent_state) {
         event_bus_default.subscribeOnce(callback_event, (data) => {
           if (data.success) {
-            resolve(data.state);
+            resolve2(data.state);
           } else {
             reject(data.error);
           }
@@ -2282,7 +3152,7 @@ var AgentManager = class _AgentManager {
           },
           true
         );
-        !return_agent_state && resolve({ callback_event_id: callback_event, success: true });
+        !return_agent_state && resolve2({ callback_event_id: callback_event, success: true });
       } catch (error) {
         !return_agent_state && reject({
           callback_event_id: callback_event,
@@ -2664,9 +3534,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z7.object({
-        description: z7.string().describe("The task to execute with the selected agent"),
-        subagent_type: z7.string().describe(
+      schema: z9.object({
+        description: z9.string().describe("The task to execute with the selected agent"),
+        subagent_type: z9.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -2770,7 +3640,7 @@ var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 import { createMiddleware as createMiddleware4, tool as tool4, ToolMessage as ToolMessage4 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
@@ -2998,12 +3868,12 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z8.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z8.object({
-  content: z8.string().describe("Content of the todo item"),
+var TodoStatus = z10.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z10.object({
+  content: z10.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z8.object({ todos: z8.array(TodoSchema).default([]) });
+var stateSchema = z10.object({ todos: z10.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
   const writeTodos = tool4(
     ({ todos }, config) => {
@@ -3022,8 +3892,8 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z8.object({
-        todos: z8.array(TodoSchema).describe("List of todo items to update")
+      schema: z10.object({
+        todos: z10.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
@@ -3040,6 +3910,56 @@ function todoListMiddleware(options) {
   });
 }
 
+// src/middlewares/skillMiddleware.ts
+import { createMiddleware as createMiddleware5 } from "langchain";
+var DEFAULT_HEADING = "## Available Skills";
+var DEFAULT_EXTRA_NOTE = "Use the load_skill tool when you need detailed information about handling a specific type of request.";
+function createSkillMiddleware(params = {}) {
+  const {
+    skillCategories,
+    loadSkillTool = getToolClient("load_skill_content"),
+    heading = DEFAULT_HEADING,
+    extraNote = DEFAULT_EXTRA_NOTE
+  } = params;
+  let latestSkills = [];
+  return createMiddleware5({
+    name: "skillMiddleware",
+    tools: [loadSkillTool],
+    // Fetch the latest skills from the Skill Lattice before the agent runs
+    beforeAgent: async () => {
+      try {
+        if (skillCategories && skillCategories.length > 0) {
+          const storeLattice = getStoreLattice("default", "skill");
+          const skillStore = storeLattice?.store;
+          const skillLatticePromises = skillCategories.map(
+            (category) => skillStore.searchByMetadata("category", category)
+          );
+          const skillLatticesArrays = await Promise.all(skillLatticePromises);
+          latestSkills = skillLatticesArrays.flat().filter((skill) => skill !== void 0);
+        }
+      } catch (error) {
+        console.error("Error fetching skills:", error);
+      }
+    },
+    wrapModelCall: (request, handler) => {
+      const skillsPrompt = latestSkills.map((skill) => `- **${skill.name}**: ${skill.description}`).join("\n");
+      const skillsAddendum = `
+
+${heading}
+
+${skillsPrompt}
+
+${extraNote}`;
+      const existingSystemPrompt = request.systemPrompt ?? "";
+      const newSystemPrompt = existingSystemPrompt.length > 0 ? `${existingSystemPrompt}${skillsAddendum}` : skillsAddendum.trimStart();
+      return handler({
+        ...request,
+        systemPrompt: newSystemPrompt
+      });
+    }
+  });
+}
+
 // src/deep_agent_new/agent.ts
 var BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
 function createDeepAgent(params = {}) {
@@ -3055,7 +3975,8 @@ function createDeepAgent(params = {}) {
     store,
     backend,
     interruptOn,
-    name
+    name,
+    skillCategories
   } = params;
   const finalSystemPrompt = systemPrompt ? `${systemPrompt}
 
@@ -3105,7 +4026,8 @@ ${BASE_PROMPT}` : BASE_PROMPT;
       unsupportedModelBehavior: "ignore"
     }),
     // Patches tool calls to ensure compatibility across different model providers
-    createPatchToolCallsMiddleware()
+    createPatchToolCallsMiddleware(),
+    createSkillMiddleware({ skillCategories })
   ];
   if (interruptOn) {
     middleware.push(humanInTheLoopMiddleware2({ interruptOn }));
@@ -3162,7 +4084,8 @@ var DeepAgentGraphBuilder = class {
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
-      checkpointer: getCheckpointSaver("default")
+      checkpointer: getCheckpointSaver("default"),
+      skillCategories: params.skillCategories
     });
     return deepAgent;
   }
@@ -3237,6 +4160,7 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   buildParams(agentLattice, options) {
+    const skillCategories = isDeepAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
     const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
@@ -3278,7 +4202,8 @@ var AgentParamsBuilder = class {
       model,
       subAgents: [...subAgents, ...internalSubAgents],
       prompt: agentLattice.config.prompt,
-      stateSchema: agentLattice.config.schema
+      stateSchema: agentLattice.config.schema,
+      skillCategories
     };
   }
 };
@@ -3633,9 +4558,9 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       next: (chunk) => {
         queue.push(chunk);
         if (resolveNext) {
-          const resolve = resolveNext;
+          const resolve2 = resolveNext;
           resolveNext = null;
-          resolve();
+          resolve2();
         }
       },
       error: (err) => {
@@ -3645,17 +4570,17 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
           errorNext = null;
           reject(err);
         } else if (resolveNext) {
-          const resolve = resolveNext;
+          const resolve2 = resolveNext;
           resolveNext = null;
-          resolve();
+          resolve2();
         }
       },
       complete: () => {
         isCompleted = true;
         if (resolveNext) {
-          const resolve = resolveNext;
+          const resolve2 = resolveNext;
           resolveNext = null;
-          resolve();
+          resolve2();
         }
       }
     });
@@ -3667,8 +4592,8 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
         }
         if (queue.length === 0) {
           if (isCompleted) break;
-          await new Promise((resolve, reject) => {
-            resolveNext = resolve;
+          await new Promise((resolve2, reject) => {
+            resolveNext = resolve2;
             errorNext = reject;
           });
         }
@@ -4700,7 +5625,90 @@ var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeMa
     if (!scheduleLattice) {
       throw new Error(`ScheduleLattice ${key} not found`);
     }
-    return scheduleLattice;
+    return scheduleLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var scheduleLatticeManager = ScheduleLatticeManager.getInstance();
+var registerScheduleLattice = (key, config, client) => scheduleLatticeManager.registerLattice(key, config, client);
+var getScheduleLattice = (key) => scheduleLatticeManager.getScheduleLattice(key);
+
+// src/embeddings_lattice/EmbeddingsLatticeManager.ts
+var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatticeManager {
+  /**
+   * Get EmbeddingsLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_EmbeddingsLatticeManager._instance) {
+      _EmbeddingsLatticeManager._instance = new _EmbeddingsLatticeManager();
+    }
+    return _EmbeddingsLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "embeddings";
+  }
+  /**
+   * Register embeddings Lattice
+   * @param key Lattice key name
+   * @param embeddings Embeddings instance
+   */
+  registerLattice(key, embeddings) {
+    const embeddingsLattice = {
+      key,
+      client: embeddings
+    };
+    this.register(key, embeddingsLattice);
+  }
+  /**
+   * Get EmbeddingsLattice
+   * @param key Lattice key name
+   */
+  getEmbeddingsLattice(key) {
+    const embeddingsLattice = this.get(key);
+    if (!embeddingsLattice) {
+      throw new Error(`EmbeddingsLattice ${key} not found`);
+    }
+    return embeddingsLattice;
   }
   /**
    * Get all Lattices
@@ -4740,261 +5748,385 @@ var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeMa
   getLatticeKeys() {
     return this.keys();
   }
-};
-var scheduleLatticeManager = ScheduleLatticeManager.getInstance();
-var registerScheduleLattice = (key, config, client) => scheduleLatticeManager.registerLattice(key, config, client);
-var getScheduleLattice = (key) => scheduleLatticeManager.getScheduleLattice(key);
-
-// src/store_lattice/InMemoryThreadStore.ts
-var InMemoryThreadStore = class {
-  constructor() {
-    // Map<assistantId, Map<threadId, Thread>>
-    this.threads = /* @__PURE__ */ new Map();
-  }
   /**
-   * Get all threads for a specific assistant
+   * Get embeddings client
+   * @param key Lattice key name
    */
-  async getThreadsByAssistantId(assistantId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
-      return [];
-    }
-    return Array.from(assistantThreads.values());
+  getEmbeddingsClient(key) {
+    const embeddingsLattice = this.getEmbeddingsLattice(key);
+    return embeddingsLattice.client;
   }
+};
+var embeddingsLatticeManager = EmbeddingsLatticeManager.getInstance();
+var registerEmbeddingsLattice = (key, embeddings) => embeddingsLatticeManager.registerLattice(key, embeddings);
+var getEmbeddingsLattice = (key) => embeddingsLatticeManager.getEmbeddingsLattice(key);
+var getEmbeddingsClient = (key) => embeddingsLatticeManager.getEmbeddingsClient(key);
+
+// src/vectorstore_lattice/VectorStoreLatticeManager.ts
+var VectorStoreLatticeManager = class _VectorStoreLatticeManager extends BaseLatticeManager {
   /**
-   * Get a thread by ID for a specific assistant
+   * Get VectorStoreLatticeManager singleton instance
    */
-  async getThreadById(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
-      return void 0;
+  static getInstance() {
+    if (!_VectorStoreLatticeManager._instance) {
+      _VectorStoreLatticeManager._instance = new _VectorStoreLatticeManager();
     }
-    return assistantThreads.get(threadId);
+    return _VectorStoreLatticeManager._instance;
   }
   /**
-   * Create a new thread for an assistant
+   * Get Lattice type prefix
    */
-  async createThread(assistantId, threadId, data) {
-    const now = /* @__PURE__ */ new Date();
-    const thread = {
-      id: threadId,
-      assistantId,
-      metadata: data.metadata || {},
-      createdAt: now,
-      updatedAt: now
-    };
-    if (!this.threads.has(assistantId)) {
-      this.threads.set(assistantId, /* @__PURE__ */ new Map());
-    }
-    const assistantThreads = this.threads.get(assistantId);
-    assistantThreads.set(threadId, thread);
-    return thread;
+  getLatticeType() {
+    return "vectorstores";
   }
   /**
-   * Update an existing thread
+   * Register vector store Lattice
+   * @param key Lattice key name
+   * @param vectorStore VectorStore instance
    */
-  async updateThread(assistantId, threadId, updates) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
-      return null;
-    }
-    const existing = assistantThreads.get(threadId);
-    if (!existing) {
-      return null;
-    }
-    const updated = {
-      ...existing,
-      metadata: {
-        ...existing.metadata,
-        ...updates.metadata || {}
-      },
-      updatedAt: /* @__PURE__ */ new Date()
+  registerLattice(key, vectorStore) {
+    const vectorStoreLattice = {
+      key,
+      client: vectorStore
     };
-    assistantThreads.set(threadId, updated);
-    return updated;
+    this.register(key, vectorStoreLattice);
   }
   /**
-   * Delete a thread by ID
+   * Get VectorStoreLattice
+   * @param key Lattice key name
    */
-  async deleteThread(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
-      return false;
+  getVectorStoreLattice(key) {
+    const vectorStoreLattice = this.get(key);
+    if (!vectorStoreLattice) {
+      throw new Error(`VectorStoreLattice ${key} not found`);
     }
-    return assistantThreads.delete(threadId);
+    return vectorStoreLattice;
   }
   /**
-   * Check if thread exists
+   * Get all Lattices
    */
-  async hasThread(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
-      return false;
-    }
-    return assistantThreads.has(threadId);
+  getAllLattices() {
+    return this.getAll();
   }
   /**
-   * Clear all threads (useful for testing)
+   * Check if Lattice exists
+   * @param key Lattice key name
    */
-  clear() {
-    this.threads.clear();
+  hasLattice(key) {
+    return this.has(key);
   }
   /**
-   * Get all threads for all assistants (useful for debugging)
+   * Remove Lattice
+   * @param key Lattice key name
    */
-  getAllThreads() {
-    const allThreads = [];
-    for (const assistantThreads of this.threads.values()) {
-      allThreads.push(...Array.from(assistantThreads.values()));
-    }
-    return allThreads;
-  }
-};
-
-// src/store_lattice/InMemoryAssistantStore.ts
-var InMemoryAssistantStore = class {
-  constructor() {
-    this.assistants = /* @__PURE__ */ new Map();
+  removeLattice(key) {
+    return this.remove(key);
   }
   /**
-   * Get all assistants
+   * Clear all Lattices
    */
-  async getAllAssistants() {
-    return Array.from(this.assistants.values());
+  clearLattices() {
+    this.clear();
   }
   /**
-   * Get assistant by ID
+   * Get Lattice count
    */
-  async getAssistantById(id) {
-    return this.assistants.get(id) || null;
+  getLatticeCount() {
+    return this.count();
   }
   /**
-   * Create a new assistant
+   * Get Lattice key list
    */
-  async createAssistant(id, data) {
-    const now = /* @__PURE__ */ new Date();
-    const assistant = {
-      id,
-      name: data.name,
-      description: data.description,
-      graphDefinition: data.graphDefinition,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.assistants.set(id, assistant);
-    return assistant;
+  getLatticeKeys() {
+    return this.keys();
   }
   /**
-   * Update an existing assistant
+   * Get vector store client
+   * @param key Lattice key name
    */
-  async updateAssistant(id, updates) {
-    const existing = this.assistants.get(id);
-    if (!existing) {
-      return null;
-    }
-    const updated = {
-      ...existing,
-      ...updates,
-      updatedAt: /* @__PURE__ */ new Date()
+  getVectorStoreClient(key) {
+    const vectorStoreLattice = this.getVectorStoreLattice(key);
+    return vectorStoreLattice.client;
+  }
+};
+var vectorStoreLatticeManager = VectorStoreLatticeManager.getInstance();
+var registerVectorStoreLattice = (key, vectorStore) => vectorStoreLatticeManager.registerLattice(key, vectorStore);
+var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLattice(key);
+var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
+
+// src/logger_lattice/LoggerLatticeManager.ts
+import {
+  LoggerType
+} from "@axiom-lattice/protocols";
+
+// src/logger_lattice/PinoLoggerClient.ts
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+var PinoLoggerClient = class _PinoLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+    const loggerConfig = {
+      // Custom timestamp format
+      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      // Base metadata
+      base: {
+        "@version": "1",
+        app_name: "lattice",
+        service_name: config.serviceName || "lattice-service",
+        thread_name: "main",
+        logger_name: config.loggerName || config.name || "lattice-logger"
+      },
+      formatters: {
+        level: (label, number) => {
+          return {
+            level: label.toUpperCase(),
+            level_value: number * 1e3
+          };
+        }
+      }
     };
-    this.assistants.set(id, updated);
-    return updated;
+    const useFileLogging = this.shouldUseFileLogging(config);
+    const fileOptions = this.getFileOptions(config);
+    if (useFileLogging && fileOptions) {
+      try {
+        this.pinoLogger = pino(
+          loggerConfig,
+          pino.transport({
+            target: "pino-roll",
+            options: {
+              file: fileOptions.file || "./logs/app",
+              frequency: fileOptions.frequency || "daily",
+              mkdir: fileOptions.mkdir !== false,
+              // Default to true
+              size: fileOptions.size,
+              maxFiles: fileOptions.maxFiles
+            }
+          })
+        );
+      } catch (error) {
+        console.error(
+          "Failed to initialize pino-roll logger, falling back to console",
+          error
+        );
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true
+            }
+          }
+        });
+      }
+    } else {
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        }
+      });
+    }
   }
   /**
-   * Delete an assistant by ID
+   * Determine if file logging should be used
    */
-  async deleteAssistant(id) {
-    return this.assistants.delete(id);
+  shouldUseFileLogging(config) {
+    const hasFileConfig = config.file !== void 0;
+    const isProduction = process.env.NODE_ENV === "production";
+    return hasFileConfig || isProduction;
   }
   /**
-   * Check if assistant exists
+   * Get file options from config
    */
-  async hasAssistant(id) {
-    return this.assistants.has(id);
+  getFileOptions(config) {
+    if (!config.file) {
+      if (process.env.NODE_ENV === "production") {
+        return {
+          file: "./logs/app",
+          frequency: "daily",
+          mkdir: true
+        };
+      }
+      return null;
+    }
+    if (typeof config.file === "string") {
+      return {
+        file: config.file,
+        frequency: "daily",
+        mkdir: true
+      };
+    }
+    return config.file;
   }
   /**
-   * Clear all assistants (useful for testing)
+   * Get contextual logger with merged context
    */
-  clear() {
-    this.assistants.clear();
+  getContextualLogger(additionalContext) {
+    const contextObj = {
+      "x-user-id": this.context["x-user-id"] || "",
+      "x-tenant-id": this.context["x-tenant-id"] || "",
+      "x-request-id": this.context["x-request-id"] || "",
+      "x-thread-id": this.context["x-thread-id"] || "",
+      service_name: this.config.serviceName || "lattice-service",
+      logger_name: this.config.loggerName || this.config.name || "lattice-logger",
+      ...additionalContext
+    };
+    return this.pinoLogger.child(contextObj);
+  }
+  info(msg, obj) {
+    this.getContextualLogger(obj).info(msg);
+  }
+  error(msg, obj) {
+    this.getContextualLogger(obj).error(msg);
+  }
+  warn(msg, obj) {
+    this.getContextualLogger(obj).warn(msg);
+  }
+  debug(msg, obj) {
+    this.getContextualLogger(obj).debug(msg);
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    return new _PinoLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+  }
+};
+
+// src/logger_lattice/ConsoleLoggerClient.ts
+var ConsoleLoggerClient = class _ConsoleLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+  }
+  formatMessage(level, msg, obj) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const contextStr = Object.keys(this.context).length > 0 ? ` [${JSON.stringify(this.context)}]` : "";
+    const objStr = obj ? ` ${JSON.stringify(obj)}` : "";
+    return `[${timestamp}] [${level}]${contextStr} ${msg}${objStr}`;
+  }
+  info(msg, obj) {
+    console.log(this.formatMessage("INFO", msg, obj));
+  }
+  error(msg, obj) {
+    console.error(this.formatMessage("ERROR", msg, obj));
+  }
+  warn(msg, obj) {
+    console.warn(this.formatMessage("WARN", msg, obj));
+  }
+  debug(msg, obj) {
+    console.debug(this.formatMessage("DEBUG", msg, obj));
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    const childClient = new _ConsoleLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+    return childClient;
   }
 };
 
-// src/store_lattice/StoreLatticeManager.ts
-var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
+// src/logger_lattice/LoggerLatticeManager.ts
+var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManager {
   /**
-   * Get StoreLatticeManager singleton instance
+   * Get LoggerLatticeManager singleton instance
    */
   static getInstance() {
-    if (!_StoreLatticeManager._instance) {
-      _StoreLatticeManager._instance = new _StoreLatticeManager();
+    if (!_LoggerLatticeManager._instance) {
+      _LoggerLatticeManager._instance = new _LoggerLatticeManager();
     }
-    return _StoreLatticeManager._instance;
+    return _LoggerLatticeManager._instance;
   }
   /**
    * Get Lattice type prefix
    */
   getLatticeType() {
-    return "stores";
-  }
-  /**
-   * Generate composite key from key and type
-   * @param key Lattice key name
-   * @param type Store type
-   * @returns Composite key string
-   */
-  getCompositeKey(key, type) {
-    return `${key}:${type}`;
+    return "loggers";
   }
   /**
-   * Register store Lattice with type safety
-   * Uses composite key (key + type) as unique identifier
+   * Register logger Lattice
    * @param key Lattice key name
-   * @param type Store type (e.g., "thread")
-   * @param store Store implementation instance matching the type
+   * @param config Logger configuration
+   * @param client Optional logger client. If not provided, will create based on config type.
    */
-  registerLattice(key, type, store) {
-    const storeLattice = {
+  registerLattice(key, config, client) {
+    let loggerClient;
+    if (client) {
+      loggerClient = client;
+    } else {
+      if (config.type === LoggerType.PINO) {
+        loggerClient = new PinoLoggerClient(config);
+      } else if (config.type === LoggerType.CONSOLE) {
+        loggerClient = new ConsoleLoggerClient(config);
+      } else if (config.type === LoggerType.CUSTOM) {
+        throw new Error(
+          `Custom logger client must be provided. Please pass the client to registerLattice.`
+        );
+      } else {
+        loggerClient = new PinoLoggerClient(config);
+      }
+    }
+    const loggerLattice = {
       key,
-      type,
-      store
+      config,
+      client: loggerClient,
+      // Logger operations
+      info: (msg, obj) => {
+        loggerClient.info(msg, obj);
+      },
+      error: (msg, obj) => {
+        loggerClient.error(msg, obj);
+      },
+      warn: (msg, obj) => {
+        loggerClient.warn(msg, obj);
+      },
+      debug: (msg, obj) => {
+        loggerClient.debug(msg, obj);
+      },
+      updateContext: loggerClient.updateContext ? (context) => {
+        loggerClient.updateContext(context);
+      } : void 0,
+      child: loggerClient.child ? (options) => {
+        return loggerClient.child(options);
+      } : void 0
     };
-    const compositeKey = this.getCompositeKey(key, type);
-    this.register(compositeKey, storeLattice);
-  }
-  /**
-   * Get StoreLattice with type safety
-   * Uses composite key (key + type) to retrieve the store
-   * @param key Lattice key name
-   * @param type Expected store type for type checking
-   * @returns StoreLattice with typed store
-   */
-  getStoreLattice(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    const storeLattice = this.get(compositeKey);
-    if (!storeLattice) {
-      throw new Error(`StoreLattice ${key}:${type} not found`);
-    }
-    if (storeLattice.type !== type) {
-      throw new Error(
-        `StoreLattice ${key}:${type} has type "${storeLattice.type}", expected "${type}"`
-      );
-    }
-    return storeLattice;
+    this.register(key, loggerLattice);
   }
   /**
-   * Get StoreLattice without type checking (for backward compatibility)
+   * Get LoggerLattice
    * @param key Lattice key name
-   * @param type Store type
-   * @returns StoreLattice (type may be unknown)
    */
-  getStoreLatticeUnsafe(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    const storeLattice = this.get(compositeKey);
-    if (!storeLattice) {
-      throw new Error(`StoreLattice ${key}:${type} not found`);
+  getLoggerLattice(key) {
+    const loggerLattice = this.get(key);
+    if (!loggerLattice) {
+      throw new Error(`LoggerLattice ${key} not found`);
     }
-    return storeLattice;
+    return loggerLattice;
   }
   /**
    * Get all Lattices
@@ -5004,23 +6136,17 @@ var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager
   }
   /**
    * Check if Lattice exists
-   * Uses composite key (key + type) to check existence
    * @param key Lattice key name
-   * @param type Store type
    */
-  hasLattice(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    return this.has(compositeKey);
+  hasLattice(key) {
+    return this.has(key);
   }
   /**
    * Remove Lattice
-   * Uses composite key (key + type) to remove the store
    * @param key Lattice key name
-   * @param type Store type
    */
-  removeLattice(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    return this.remove(compositeKey);
+  removeLattice(key) {
+    return this.remove(key);
   }
   /**
    * Clear all Lattices
@@ -5041,63 +6167,151 @@ var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager
     return this.keys();
   }
 };
-var storeLatticeManager = StoreLatticeManager.getInstance();
-var registerStoreLattice = (key, type, store) => storeLatticeManager.registerLattice(key, type, store);
-var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, type);
-var defaultThreadStore = new InMemoryThreadStore();
-var defaultAssistantStore = new InMemoryAssistantStore();
-storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
-storeLatticeManager.registerLattice(
-  "default",
-  "assistant",
-  defaultAssistantStore
-);
+var loggerLatticeManager = LoggerLatticeManager.getInstance();
+var registerLoggerLattice = (key, config, client) => loggerLatticeManager.registerLattice(key, config, client);
+var getLoggerLattice = (key) => loggerLatticeManager.getLoggerLattice(key);
 
-// src/embeddings_lattice/EmbeddingsLatticeManager.ts
-var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatticeManager {
+// src/skill_lattice/SkillLatticeManager.ts
+var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager {
   /**
-   * Get EmbeddingsLatticeManager singleton instance
+   * Get SkillLatticeManager singleton instance
    */
   static getInstance() {
-    if (!_EmbeddingsLatticeManager._instance) {
-      _EmbeddingsLatticeManager._instance = new _EmbeddingsLatticeManager();
+    if (!_SkillLatticeManager._instance) {
+      _SkillLatticeManager._instance = new _SkillLatticeManager();
     }
-    return _EmbeddingsLatticeManager._instance;
+    return _SkillLatticeManager._instance;
   }
   /**
    * Get Lattice type prefix
    */
   getLatticeType() {
-    return "embeddings";
+    return "skills";
   }
   /**
-   * Register embeddings Lattice
+   * Configure store for persistence
+   * @param storeKey Store key name registered in StoreLatticeManager
+   */
+  configureStore(storeKey) {
+    this.storeKey = storeKey;
+  }
+  /**
+   * Get configured store
+   * @returns SkillStore instance if configured, null otherwise
+   */
+  getStore() {
+    if (!this.storeKey) {
+      return null;
+    }
+    try {
+      const storeLattice = storeLatticeManager.getStoreLattice(
+        this.storeKey,
+        "skill"
+      );
+      return storeLattice.store;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Inject store into client if client supports it
+   * @param client Skill client instance
+   * @param store Store instance to inject
+   */
+  injectStoreIntoClient(client, store) {
+    if (!client || typeof client !== "object") {
+      return;
+    }
+    if (typeof client.setStore === "function") {
+      client.setStore(store);
+    }
+    client.store = store;
+  }
+  /**
+   * Register a skill Lattice
    * @param key Lattice key name
-   * @param embeddings Embeddings instance
+   * @param config Skill configuration
+   * @param client Optional skill client implementation
    */
-  registerLattice(key, embeddings) {
-    const embeddingsLattice = {
+  async registerLattice(key, config, client) {
+    if (!config.name) {
+      throw new Error("Skill name is required");
+    }
+    if (!config.description) {
+      throw new Error("Skill description is required");
+    }
+    validateSkillName(config.name);
+    if (key !== config.name) {
+      throw new Error(
+        `Skill key "${key}" must equal name "${config.name}" (name is used for path addressing)`
+      );
+    }
+    const store = this.getStore();
+    if (client && store) {
+      this.injectStoreIntoClient(client, store);
+    }
+    const skillLattice = {
       key,
-      client: embeddings
+      config,
+      client: client ?? null
     };
-    this.register(key, embeddingsLattice);
+    this.register(key, skillLattice);
+    if (store) {
+      try {
+        await store.createSkill(key, {
+          name: config.name,
+          description: config.description,
+          license: config.license,
+          compatibility: config.compatibility,
+          metadata: config.metadata,
+          content: config.content,
+          subSkills: config.subSkills
+        });
+      } catch (error) {
+        console.warn(
+          `Failed to persist skill ${key} to store:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
   }
   /**
-   * Get EmbeddingsLattice
+   * Get skill Lattice by key
    * @param key Lattice key name
    */
-  getEmbeddingsLattice(key) {
-    const embeddingsLattice = this.get(key);
-    if (!embeddingsLattice) {
-      throw new Error(`EmbeddingsLattice ${key} not found`);
-    }
-    return embeddingsLattice;
+  getSkillLattice(key) {
+    return this.get(key);
   }
   /**
-   * Get all Lattices
+   * Get all skill Lattices from store
+   * Always reads from the configured store and merges with in-memory clients
    */
-  getAllLattices() {
-    return this.getAll();
+  async getAllLattices() {
+    const store = this.getStore();
+    if (!store) {
+      return this.getAll();
+    }
+    const skills = await store.getAllSkills();
+    return skills.map((skill) => {
+      const memoryLattice = this.get(skill.id);
+      const client = memoryLattice?.client || null;
+      if (client && store) {
+        this.injectStoreIntoClient(client, store);
+      }
+      return {
+        key: skill.id,
+        config: {
+          name: skill.name,
+          description: skill.description,
+          license: skill.license,
+          compatibility: skill.compatibility,
+          metadata: skill.metadata,
+          content: skill.content,
+          subSkills: skill.subSkills
+        },
+        client
+      };
+    });
   }
   /**
    * Check if Lattice exists
@@ -5110,8 +6324,22 @@ var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatti
    * Remove Lattice
    * @param key Lattice key name
    */
-  removeLattice(key) {
-    return this.remove(key);
+  async removeLattice(key) {
+    const removed = this.remove(key);
+    if (removed) {
+      const store = this.getStore();
+      if (store) {
+        try {
+          await store.deleteSkill(key);
+        } catch (error) {
+          console.warn(
+            `Failed to remove skill ${key} from store:`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    }
+    return removed;
   }
   /**
    * Clear all Lattices
@@ -5126,116 +6354,139 @@ var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatti
     return this.count();
   }
   /**
-   * Get Lattice key list
+   * Get Lattice key name list
    */
   getLatticeKeys() {
     return this.keys();
   }
   /**
-   * Get embeddings client
+   * Get skill configuration
    * @param key Lattice key name
    */
-  getEmbeddingsClient(key) {
-    const embeddingsLattice = this.getEmbeddingsLattice(key);
-    return embeddingsLattice.client;
-  }
-};
-var embeddingsLatticeManager = EmbeddingsLatticeManager.getInstance();
-var registerEmbeddingsLattice = (key, embeddings) => embeddingsLatticeManager.registerLattice(key, embeddings);
-var getEmbeddingsLattice = (key) => embeddingsLatticeManager.getEmbeddingsLattice(key);
-var getEmbeddingsClient = (key) => embeddingsLatticeManager.getEmbeddingsClient(key);
-
-// src/vectorstore_lattice/VectorStoreLatticeManager.ts
-var VectorStoreLatticeManager = class _VectorStoreLatticeManager extends BaseLatticeManager {
-  /**
-   * Get VectorStoreLatticeManager singleton instance
-   */
-  static getInstance() {
-    if (!_VectorStoreLatticeManager._instance) {
-      _VectorStoreLatticeManager._instance = new _VectorStoreLatticeManager();
+  getSkillConfig(key) {
+    const skillLattice = this.getSkillLattice(key);
+    if (!skillLattice) {
+      throw new Error(`SkillLattice ${key} not found`);
     }
-    return _VectorStoreLatticeManager._instance;
-  }
-  /**
-   * Get Lattice type prefix
-   */
-  getLatticeType() {
-    return "vectorstores";
+    return skillLattice.config;
   }
   /**
-   * Register vector store Lattice
-   * @param key Lattice key name
-   * @param vectorStore VectorStore instance
-   */
-  registerLattice(key, vectorStore) {
-    const vectorStoreLattice = {
-      key,
-      client: vectorStore
-    };
-    this.register(key, vectorStoreLattice);
-  }
-  /**
-   * Get VectorStoreLattice
+   * Get skill client
+   * Ensures client has store access if store is configured
    * @param key Lattice key name
    */
-  getVectorStoreLattice(key) {
-    const vectorStoreLattice = this.get(key);
-    if (!vectorStoreLattice) {
-      throw new Error(`VectorStoreLattice ${key} not found`);
+  getSkillClient(key) {
+    const skillLattice = this.getSkillLattice(key);
+    if (!skillLattice) {
+      throw new Error(`SkillLattice ${key} not found`);
     }
-    return vectorStoreLattice;
-  }
-  /**
-   * Get all Lattices
-   */
-  getAllLattices() {
-    return this.getAll();
+    const client = skillLattice.client;
+    if (!client) {
+      return null;
+    }
+    const store = this.getStore();
+    if (store && client) {
+      this.injectStoreIntoClient(client, store);
+    }
+    return client;
   }
   /**
-   * Check if Lattice exists
-   * @param key Lattice key name
+   * Get all skill configurations from store
+   * Always reads from the configured store, not from memory
    */
-  hasLattice(key) {
-    return this.has(key);
+  async getAllSkillConfigs() {
+    const lattices = await this.getAllLattices();
+    return lattices.map((lattice) => lattice.config);
   }
   /**
-   * Remove Lattice
-   * @param key Lattice key name
+   * Search skills by metadata
+   * @param metadataKey Metadata key to search for
+   * @param metadataValue Metadata value to match
    */
-  removeLattice(key) {
-    return this.remove(key);
+  async searchByMetadata(metadataKey, metadataValue) {
+    const lattices = await this.getAllLattices();
+    return lattices.filter((lattice) => {
+      return lattice.config.metadata && lattice.config.metadata[metadataKey] === metadataValue;
+    });
   }
   /**
-   * Clear all Lattices
+   * Filter skills by compatibility
+   * @param compatibility Compatibility string to filter by
    */
-  clearLattices() {
-    this.clear();
+  async filterByCompatibility(compatibility) {
+    const lattices = await this.getAllLattices();
+    return lattices.filter((lattice) => {
+      return lattice.config.compatibility === compatibility;
+    });
   }
   /**
-   * Get Lattice count
+   * Filter skills by license
+   * @param license License string to filter by
    */
-  getLatticeCount() {
-    return this.count();
+  async filterByLicense(license) {
+    const lattices = await this.getAllLattices();
+    return lattices.filter((lattice) => {
+      return lattice.config.license === license;
+    });
   }
   /**
-   * Get Lattice key list
-   */
-  getLatticeKeys() {
-    return this.keys();
+   * Load skills from configured store
+   * This method loads all skills from the store and registers them in memory
+   */
+  async loadFromStore() {
+    const store = this.getStore();
+    if (!store) {
+      throw new Error("No store configured. Call configureStore() first.");
+    }
+    const skills = await store.getAllSkills();
+    for (const skill of skills) {
+      const skillLattice = {
+        key: skill.id,
+        config: {
+          name: skill.name,
+          description: skill.description,
+          license: skill.license,
+          compatibility: skill.compatibility,
+          metadata: skill.metadata,
+          content: skill.content,
+          subSkills: skill.subSkills
+        },
+        client: null
+      };
+      this.register(skill.id, skillLattice);
+    }
   }
   /**
-   * Get vector store client
-   * @param key Lattice key name
+   * Update skill in store
+   * @param key Skill key
+   * @param updates Partial skill data to update
    */
-  getVectorStoreClient(key) {
-    const vectorStoreLattice = this.getVectorStoreLattice(key);
-    return vectorStoreLattice.client;
+  async updateSkillInStore(key, updates) {
+    const store = this.getStore();
+    if (!store) {
+      throw new Error("No store configured. Call configureStore() first.");
+    }
+    const skillLattice = this.getSkillLattice(key);
+    if (!skillLattice) {
+      throw new Error(`SkillLattice ${key} not found`);
+    }
+    const updatedConfig = {
+      ...skillLattice.config,
+      ...updates
+    };
+    skillLattice.config = updatedConfig;
+    await store.updateSkill(key, {
+      name: updatedConfig.name,
+      description: updatedConfig.description,
+      license: updatedConfig.license,
+      compatibility: updatedConfig.compatibility,
+      metadata: updatedConfig.metadata,
+      content: updatedConfig.content,
+      subSkills: updatedConfig.subSkills
+    });
   }
 };
-var vectorStoreLatticeManager = VectorStoreLatticeManager.getInstance();
-var registerVectorStoreLattice = (key, vectorStore) => vectorStoreLatticeManager.registerLattice(key, vectorStore);
-var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLattice(key);
-var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
+var skillLatticeManager = SkillLatticeManager.getInstance();
 
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
@@ -5247,21 +6498,26 @@ export {
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  ConsoleLoggerClient,
   DefaultScheduleClient,
   EmbeddingsLatticeManager,
+  FileSystemSkillStore,
   GraphBuildOptions,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
   InMemoryThreadStore,
+  LoggerLatticeManager,
   MemoryLatticeManager,
   MemoryQueueClient,
   MemoryScheduleStorage,
   MemoryType,
   ModelLatticeManager,
+  PinoLoggerClient,
   PostgresDatabase,
   Protocols,
   QueueLatticeManager,
   ScheduleLatticeManager,
+  SkillLatticeManager,
   SqlDatabaseManager,
   StoreLatticeManager,
   ThreadStatus,
@@ -5281,6 +6537,7 @@ export {
   getChunkBuffer,
   getEmbeddingsClient,
   getEmbeddingsLattice,
+  getLoggerLattice,
   getModelLattice,
   getNextCronTime,
   getQueueLattice,
@@ -5293,6 +6550,8 @@ export {
   getVectorStoreLattice,
   hasChunkBuffer,
   isValidCronExpression,
+  isValidSkillName,
+  loggerLatticeManager,
   modelLatticeManager,
   parseCronExpression,
   queueLatticeManager,
@@ -5301,6 +6560,7 @@ export {
   registerCheckpointSaver,
   registerChunkBuffer,
   registerEmbeddingsLattice,
+  registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
   registerScheduleLattice,
@@ -5308,10 +6568,12 @@ export {
   registerToolLattice,
   registerVectorStoreLattice,
   scheduleLatticeManager,
+  skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
   toolLatticeManager,
   validateAgentInput,
+  validateSkillName,
   validateToolInput,
   vectorStoreLatticeManager
 };