@deimoscloud/coreai 0.1.0

package/dist/index.js

@@ -0,0 +1,3867 @@
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { parse as parseYaml } from "yaml";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var configSchema = require2("../../schemas/coreai.config.schema.json");
+var CONFIG_FILE_NAME = "coreai.config.yaml";
+var CONFIG_FILE_NAMES = [CONFIG_FILE_NAME, "coreai.config.yml"];
+var ConfigError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ConfigError";
+  }
+};
+var DEFAULT_AGENTS = [
+  "backend-engineer",
+  "frontend-engineer",
+  "devops-engineer",
+  "engineering-manager"
+];
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+  const root = dirname(currentDir);
+  while (currentDir !== root) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = join(currentDir, fileName);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = join(currentDir, fileName);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function parseConfig(content, filePath) {
+  try {
+    return parseYaml(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parse error";
+    throw new ConfigError(
+      `Failed to parse YAML${filePath ? ` in ${filePath}` : ""}: ${message}`,
+      "PARSE_ERROR",
+      error
+    );
+  }
+}
+function validateConfig(config) {
+  const ajv = new Ajv.default({ allErrors: true, strict: false });
+  addFormats.default(ajv);
+  const validate = ajv.compile(configSchema);
+  const valid = validate(config);
+  if (!valid) {
+    const errors = validate.errors ?? [];
+    const errorMessages = errors.map((err) => {
+      const path = err.instancePath || "root";
+      return `${path}: ${err.message ?? "unknown error"}`;
+    });
+    throw new ConfigError(
+      `Configuration validation failed:
+  - ${errorMessages.join("\n  - ")}`,
+      "VALIDATION_ERROR",
+      errors
+    );
+  }
+  return config;
+}
+function applyDefaults(config) {
+  return {
+    ...config,
+    project: {
+      name: config.project?.name ?? "unnamed",
+      type: config.project?.type ?? "software",
+      root: config.project?.root ?? process.cwd()
+    },
+    team: {
+      agents: config.team?.agents ?? DEFAULT_AGENTS
+    }
+  };
+}
+function loadConfigFromFile(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown read error";
+    throw new ConfigError(
+      `Failed to read config file ${filePath}: ${message}`,
+      "READ_ERROR",
+      error
+    );
+  }
+  const parsed = parseConfig(content, filePath);
+  const validated = validateConfig(parsed);
+  return applyDefaults(validated);
+}
+function loadConfig(startDir) {
+  const configPath = findConfigFile(startDir);
+  if (!configPath) {
+    throw new ConfigError(
+      `Configuration file not found. Create a ${CONFIG_FILE_NAME} file or run 'coreai init'.`,
+      "NOT_FOUND"
+    );
+  }
+  return loadConfigFromFile(configPath);
+}
+function configExists(startDir) {
+  return findConfigFile(startDir) !== null;
+}
+function getConfigPath(startDir) {
+  return findConfigFile(startDir);
+}
+
+// src/agents/loader.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { basename, extname, join as join2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+import Ajv2 from "ajv";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var agentSchema = require3("../../schemas/agent.schema.json");
+var AgentError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AgentError";
+  }
+};
+function parseAgentYaml(content, filePath) {
+  try {
+    return parseYaml2(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parse error";
+    throw new AgentError(
+      `Failed to parse agent YAML${filePath ? ` in ${filePath}` : ""}: ${message}`,
+      "PARSE_ERROR",
+      error
+    );
+  }
+}
+function validateAgentDefinition(agent) {
+  const ajv = new Ajv2.default({ allErrors: true, strict: false });
+  const validate = ajv.compile(agentSchema);
+  const valid = validate(agent);
+  if (!valid) {
+    const errors = validate.errors ?? [];
+    const errorMessages = errors.map((err) => {
+      const path = err.instancePath || "root";
+      return `${path}: ${err.message ?? "unknown error"}`;
+    });
+    throw new AgentError(
+      `Agent validation failed:
+  - ${errorMessages.join("\n  - ")}`,
+      "VALIDATION_ERROR",
+      errors
+    );
+  }
+  return agent;
+}
+function loadAgentFromFile(filePath) {
+  if (!existsSync2(filePath)) {
+    throw new AgentError(`Agent file not found: ${filePath}`, "NOT_FOUND");
+  }
+  let content;
+  try {
+    content = readFileSync2(filePath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown read error";
+    throw new AgentError(`Failed to read agent file ${filePath}: ${message}`, "READ_ERROR", error);
+  }
+  const parsed = parseAgentYaml(content, filePath);
+  return validateAgentDefinition(parsed);
+}
+function listYamlFiles(dir) {
+  if (!existsSync2(dir)) {
+    return [];
+  }
+  return readdirSync(dir).filter((file) => {
+    const ext = extname(file).toLowerCase();
+    return ext === ".yaml" || ext === ".yml";
+  }).map((file) => join2(dir, file));
+}
+function loadAgentsFromDirectory(dir, source) {
+  const agents = /* @__PURE__ */ new Map();
+  const files = listYamlFiles(dir);
+  for (const filePath of files) {
+    try {
+      const definition = loadAgentFromFile(filePath);
+      agents.set(definition.role, {
+        definition,
+        source,
+        filePath
+      });
+    } catch (error) {
+      const fileName = basename(filePath);
+      console.warn(`Warning: Failed to load agent from ${fileName}: ${error.message}`);
+    }
+  }
+  return agents;
+}
+function getRoleFromFilename(filePath) {
+  const fileName = basename(filePath);
+  const ext = extname(fileName);
+  return fileName.slice(0, -ext.length);
+}
+
+// src/agents/resolver.ts
+var ResolutionError = class extends Error {
+  constructor(message, variable, path) {
+    super(message);
+    this.variable = variable;
+    this.path = path;
+    this.name = "ResolutionError";
+  }
+};
+var VARIABLE_PATTERN = /\$\{([a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)*)\}/gi;
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function resolveVariable(variable, context, options) {
+  const parts = variable.split(".");
+  const namespace = parts[0];
+  const path = parts.slice(1).join(".");
+  let value;
+  switch (namespace) {
+    case "config":
+      if (!context.config) {
+        if (options.strict) {
+          throw new ResolutionError(
+            `Cannot resolve \${${variable}}: no config context provided`,
+            variable
+          );
+        }
+        return void 0;
+      }
+      value = getNestedValue(context.config, path);
+      break;
+    case "agent":
+      if (!context.agent) {
+        if (options.strict) {
+          throw new ResolutionError(
+            `Cannot resolve \${${variable}}: no agent context provided`,
+            variable
+          );
+        }
+        return void 0;
+      }
+      value = getNestedValue(context.agent, path);
+      break;
+    case "remote":
+      value = resolveRemoteVariable(path, context, options);
+      break;
+    default:
+      if (options.strict) {
+        throw new ResolutionError(`Unknown variable namespace: ${namespace}`, variable);
+      }
+      return void 0;
+  }
+  if (value === void 0) {
+    if (options.strict) {
+      throw new ResolutionError(`Cannot resolve \${${variable}}: path not found`, variable, path);
+    }
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function resolveRemoteVariable(path, context, options) {
+  if (!context.config?.integrations) {
+    if (options.strict) {
+      throw new ResolutionError(
+        `Cannot resolve \${remote.${path}}: no integrations configured`,
+        `remote.${path}`
+      );
+    }
+    return void 0;
+  }
+  const integrations = context.config.integrations;
+  switch (path) {
+    case "documentation":
+      return integrations.documentation?.config?.base_url ?? integrations.documentation?.config?.base_path;
+    case "issues":
+      return integrations.issue_tracker?.config?.base_url;
+    case "git":
+      return integrations.git?.config?.repo;
+    case "state":
+      return integrations.state?.config?.base_path ?? integrations.state?.config?.bucket;
+    default:
+      return getNestedValue(integrations, path);
+  }
+}
+function resolveString(input, context, options = {}) {
+  return input.replace(VARIABLE_PATTERN, (match, variable) => {
+    const resolved = resolveVariable(variable, context, options);
+    return resolved !== void 0 ? resolved : match;
+  });
+}
+function hasVariables(input) {
+  const pattern = /\$\{([a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)*)\}/i;
+  return pattern.test(input);
+}
+function extractVariables(input) {
+  const matches = input.matchAll(VARIABLE_PATTERN);
+  return Array.from(matches, (m) => m[1]).filter((v) => v !== void 0);
+}
+function resolveObject(obj, context, options = {}) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    return resolveString(obj, context, options);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveObject(item, context, options));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolveObject(value, context, options);
+    }
+    return result;
+  }
+  return obj;
+}
+function resolveAgentDefinition(agent, config, options = {}) {
+  const context = {
+    agent
+  };
+  if (config) {
+    context.config = config;
+  }
+  return resolveObject(agent, context, options);
+}
+
+// src/agents/compiler.ts
+import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function generateAgentMarkdown(agent) {
+  const lines = [];
+  lines.push(`# ${agent.display_name}`);
+  lines.push("");
+  lines.push(`**Role:** ${agent.role}`);
+  lines.push(`**Type:** ${agent.type}`);
+  lines.push("");
+  lines.push("## Description");
+  lines.push("");
+  lines.push(agent.description.trim());
+  lines.push("");
+  if (agent.responsibilities && agent.responsibilities.length > 0) {
+    lines.push("## Responsibilities");
+    lines.push("");
+    for (const responsibility of agent.responsibilities) {
+      lines.push(`- ${responsibility}`);
+    }
+    lines.push("");
+  }
+  if (agent.expertise) {
+    lines.push("## Expertise");
+    lines.push("");
+    if (agent.expertise.primary && agent.expertise.primary.length > 0) {
+      lines.push("### Primary Areas");
+      lines.push("");
+      for (const area of agent.expertise.primary) {
+        lines.push(`- ${area}`);
+      }
+      lines.push("");
+    }
+    if (agent.expertise.tech_stack) {
+      lines.push("### Tech Stack");
+      lines.push("");
+      const techStack = agent.expertise.tech_stack;
+      if (typeof techStack === "string") {
+        lines.push(techStack);
+      } else if (typeof techStack === "object") {
+        lines.push("```json");
+        lines.push(JSON.stringify(techStack, null, 2));
+        lines.push("```");
+      }
+      lines.push("");
+    }
+  }
+  if (agent.skills && agent.skills.length > 0) {
+    lines.push("## Skills");
+    lines.push("");
+    for (const skill of agent.skills) {
+      lines.push(`- ${skill}`);
+    }
+    lines.push("");
+  }
+  if (agent.principles) {
+    lines.push("## Principles");
+    lines.push("");
+    for (const [category, items] of Object.entries(agent.principles)) {
+      if (items && Array.isArray(items) && items.length > 0) {
+        const title = formatTitle(category);
+        lines.push(`### ${title}`);
+        lines.push("");
+        for (const item of items) {
+          lines.push(`- ${item}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  if (agent.behaviors) {
+    lines.push("## Behaviors");
+    lines.push("");
+    if (agent.behaviors.workflow) {
+      lines.push(`**Workflow:** ${agent.behaviors.workflow}`);
+      lines.push("");
+    }
+    if (agent.behaviors.quality_gates) {
+      lines.push("### Quality Gates");
+      lines.push("");
+      const gates = agent.behaviors.quality_gates;
+      if (typeof gates === "string") {
+        lines.push(gates);
+      } else if (typeof gates === "object") {
+        lines.push("```json");
+        lines.push(JSON.stringify(gates, null, 2));
+        lines.push("```");
+      }
+      lines.push("");
+    }
+  }
+  if (agent.context_sources) {
+    lines.push("## Context Sources");
+    lines.push("");
+    if (agent.context_sources.shared && agent.context_sources.shared.length > 0) {
+      lines.push("### Shared");
+      lines.push("");
+      for (const source of agent.context_sources.shared) {
+        lines.push(`- ${source}`);
+      }
+      lines.push("");
+    }
+    if (agent.context_sources.personal && agent.context_sources.personal.length > 0) {
+      lines.push("### Personal");
+      lines.push("");
+      for (const source of agent.context_sources.personal) {
+        lines.push(`- ${source}`);
+      }
+      lines.push("");
+    }
+  }
+  if (agent.communication) {
+    lines.push("## Communication");
+    lines.push("");
+    if (agent.communication.inbox) {
+      lines.push(`**Inbox:** ${agent.communication.inbox}`);
+    }
+    if (agent.communication.outbox) {
+      lines.push(`**Outbox:** ${agent.communication.outbox}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by CoreAI*");
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTitle(str) {
+  return str.replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function compileAgent(agent, config) {
+  const resolved = resolveAgentDefinition(agent, config);
+  return generateAgentMarkdown(resolved);
+}
+function loadAllAgents(options = {}) {
+  const agents = /* @__PURE__ */ new Map();
+  if (options.coreAgentsDir && existsSync3(options.coreAgentsDir)) {
+    const coreAgents = loadAgentsFromDirectory(options.coreAgentsDir, "core");
+    for (const [role, metadata] of coreAgents) {
+      agents.set(role, metadata);
+    }
+  }
+  if (options.customAgentsDir && existsSync3(options.customAgentsDir)) {
+    const customAgents = loadAgentsFromDirectory(options.customAgentsDir, "custom");
+    for (const [role, metadata] of customAgents) {
+      if (agents.has(role)) {
+        metadata.source = "override";
+      }
+      agents.set(role, metadata);
+    }
+  }
+  return agents;
+}
+function filterAgentsByTeam(agents, config) {
+  if (!config?.team?.agents || config.team.agents.length === 0) {
+    return agents;
+  }
+  const filtered = /* @__PURE__ */ new Map();
+  for (const role of config.team.agents) {
+    const metadata = agents.get(role);
+    if (metadata) {
+      filtered.set(role, metadata);
+    }
+  }
+  return filtered;
+}
+function compileAgents(config, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const outputDir = options.outputDir ?? join3(projectRoot, ".claude", "agents");
+  const customAgentsDir = options.customAgentsDir ?? join3(projectRoot, "coreai", "agents");
+  const result = {
+    compiled: [],
+    errors: []
+  };
+  const allAgents = loadAllAgents({
+    ...options,
+    customAgentsDir
+  });
+  const agents = filterAgentsByTeam(allAgents, config);
+  if (!existsSync3(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  for (const [role, metadata] of agents) {
+    if (options.filter && !options.filter(metadata.definition)) {
+      continue;
+    }
+    try {
+      const markdown = compileAgent(metadata.definition, config);
+      const outputPath = join3(outputDir, `${role}.md`);
+      writeFileSync(outputPath, markdown, "utf-8");
+      result.compiled.push({
+        role,
+        source: metadata.source,
+        outputPath
+      });
+    } catch (error) {
+      result.errors.push({
+        role,
+        source: metadata.source,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+function getCoreAgentsDir() {
+  return join3(dirname2(dirname2(dirname2(import.meta.url.replace("file://", "")))), "agents");
+}
+
+// src/adapters/types.ts
+var AdapterError = class extends Error {
+  code;
+  adapter;
+  constructor(message, code, adapter, cause) {
+    super(message, { cause });
+    this.name = "AdapterError";
+    this.code = code;
+    if (adapter) {
+      this.adapter = adapter;
+    }
+  }
+};
+
+// src/adapters/factory.ts
+var AdapterFactory = class {
+  config;
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * Registry of adapter creators by type
+   */
+  creators = {
+    issue_tracker: {},
+    git: {},
+    documentation: {},
+    state: {}
+  };
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Register an adapter creator
+   */
+  registerCreator(type, implementation, creator) {
+    const typeCreators = this.creators[type];
+    typeCreators[implementation] = creator;
+  }
+  /**
+   * Get an issue tracker adapter
+   */
+  async getIssueTracker(options) {
+    return this.getAdapter("issue_tracker", options);
+  }
+  /**
+   * Get a git provider adapter
+   */
+  async getGitProvider(options) {
+    return this.getAdapter("git", options);
+  }
+  /**
+   * Get a documentation provider adapter
+   */
+  async getDocumentationProvider(options) {
+    return this.getAdapter("documentation", options);
+  }
+  /**
+   * Get a state provider adapter
+   */
+  async getStateProvider(options) {
+    return this.getAdapter("state", options);
+  }
+  /**
+   * Get an adapter by type
+   */
+  async getAdapter(type, options) {
+    const cached = this.adapters.get(type);
+    if (cached && cached.isConnected()) {
+      return cached;
+    }
+    const strategy = this.getStrategy(type, options);
+    const implementation = options?.implementation ?? this.selectImplementation(type, strategy);
+    const adapter = await this.createAdapter(type, implementation);
+    this.adapters.set(type, adapter);
+    return adapter;
+  }
+  /**
+   * Check if an adapter type is configured
+   */
+  hasIntegration(type) {
+    const integrations = this.config.integrations;
+    if (!integrations) return false;
+    switch (type) {
+      case "issue_tracker":
+        return !!integrations.issue_tracker?.provider;
+      case "git":
+        return !!integrations.git?.provider;
+      case "documentation":
+        return !!integrations.documentation?.provider;
+      case "state":
+        return !!integrations.state?.provider;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Get information about a configured integration
+   */
+  getIntegrationInfo(type) {
+    const integrations = this.config.integrations;
+    if (!integrations) return null;
+    let integration;
+    switch (type) {
+      case "issue_tracker":
+        integration = integrations.issue_tracker;
+        break;
+      case "git":
+        integration = integrations.git;
+        break;
+      case "documentation":
+        integration = integrations.documentation;
+        break;
+      case "state":
+        integration = integrations.state;
+        break;
+    }
+    if (!integration?.provider) return null;
+    return {
+      provider: integration.provider,
+      strategy: integration.strategy ?? "auto"
+    };
+  }
+  /**
+   * Disconnect and clear all cached adapters
+   */
+  async disconnectAll() {
+    const disconnects = [];
+    for (const adapter of this.adapters.values()) {
+      if (adapter.isConnected()) {
+        disconnects.push(adapter.disconnect());
+      }
+    }
+    await Promise.all(disconnects);
+    this.adapters.clear();
+  }
+  /**
+   * Get the strategy for an adapter type
+   */
+  getStrategy(type, options) {
+    if (options?.strategy) {
+      return options.strategy;
+    }
+    const info = this.getIntegrationInfo(type);
+    return info?.strategy ?? "auto";
+  }
+  /**
+   * Select the implementation based on strategy and availability
+   */
+  selectImplementation(type, strategy) {
+    const creators = this.creators[type];
+    switch (strategy) {
+      case "mcp":
+        if (creators.mcp) return "mcp";
+        throw new AdapterError(
+          `MCP adapter not available for ${type}`,
+          "not_implemented",
+          void 0
+        );
+      case "native":
+        if (creators.native) return "native";
+        throw new AdapterError(
+          `Native adapter not available for ${type}`,
+          "not_implemented",
+          void 0
+        );
+      case "auto":
+      default:
+        if (creators.mcp) return "mcp";
+        if (creators.native) return "native";
+        if (creators.mock) return "mock";
+        throw new AdapterError(
+          `No adapter implementation available for ${type}`,
+          "not_implemented",
+          void 0
+        );
+    }
+  }
+  /**
+   * Create an adapter instance
+   */
+  async createAdapter(type, implementation) {
+    const creators = this.creators[type];
+    const creator = creators[implementation];
+    if (!creator) {
+      throw new AdapterError(
+        `No ${implementation} adapter creator registered for ${type}`,
+        "not_implemented",
+        void 0
+      );
+    }
+    const adapter = await creator(this.config);
+    await adapter.connect();
+    return adapter;
+  }
+};
+function createAdapterFactory(config) {
+  return new AdapterFactory(config);
+}
+function createAdapterInfo(type, provider, implementation, connected = false) {
+  return {
+    type,
+    provider,
+    implementation,
+    connected
+  };
+}
+
+// src/adapters/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+// src/adapters/native/github.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+
+// src/cache/types.ts
+var CacheError = class extends Error {
+  constructor(message, code, key, cause) {
+    super(message);
+    this.code = code;
+    this.key = key;
+    this.cause = cause;
+    this.name = "CacheError";
+  }
+};
+var CACHE_PATHS = {
+  /**
+   * Root cache directory (relative to project root)
+   */
+  ROOT: ".coreai/cache",
+  /**
+   * Content storage directory
+   */
+  CONTENT: ".coreai/cache/content",
+  /**
+   * Metadata storage directory
+   */
+  METADATA: ".coreai/cache/metadata",
+  /**
+   * Index file for fast lookups
+   */
+  INDEX: ".coreai/cache/index.json",
+  /**
+   * Lock file for concurrent access
+   */
+  LOCK: ".coreai/cache/.lock"
+};
+var DEFAULT_CACHE_CONFIG = {
+  /**
+   * Default TTL in seconds (1 hour)
+   */
+  ttl: 3600,
+  /**
+   * Maximum cache size in bytes (100MB)
+   */
+  maxSize: 100 * 1024 * 1024,
+  /**
+   * Maximum number of entries
+   */
+  maxEntries: 1e3,
+  /**
+   * Enable automatic cleanup of expired entries
+   */
+  autoCleanup: true,
+  /**
+   * Cleanup interval in seconds (1 hour)
+   */
+  cleanupInterval: 3600
+};
+
+// src/cache/provider.ts
+import { promises as fs } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
+import { createHash } from "crypto";
+function noop() {
+}
+var INDEX_VERSION = 1;
+var FileCacheProvider = class {
+  basePath;
+  cachePath;
+  contentPath;
+  metadataPath;
+  indexPath;
+  ttl;
+  maxSize;
+  maxEntries;
+  initialized = false;
+  index = null;
+  constructor(options) {
+    this.basePath = options.basePath;
+    this.cachePath = join4(this.basePath, CACHE_PATHS.ROOT);
+    this.contentPath = join4(this.basePath, CACHE_PATHS.CONTENT);
+    this.metadataPath = join4(this.basePath, CACHE_PATHS.METADATA);
+    this.indexPath = join4(this.basePath, CACHE_PATHS.INDEX);
+    this.ttl = options.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
+    this.maxSize = options.maxSize ?? DEFAULT_CACHE_CONFIG.maxSize;
+    this.maxEntries = options.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
+  }
+  /**
+   * Initialize the cache (create directories, load index)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await fs.mkdir(this.contentPath, { recursive: true });
+      await fs.mkdir(this.metadataPath, { recursive: true });
+      this.index = await this.loadIndex();
+      await this.saveIndex();
+      this.initialized = true;
+    } catch (error) {
+      throw new CacheError(
+        `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        void 0,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Check if the cache is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get a cached entry by key
+   */
+  async get(key, options) {
+    this.ensureInitialized();
+    if (options?.skipCache) {
+      return null;
+    }
+    const indexEntry = this.index?.entries[key];
+    if (!indexEntry) {
+      return null;
+    }
+    if (!options?.forceRefresh) {
+      const status = this.getEntryStatus(indexEntry);
+      if (status === "expired") {
+        return null;
+      }
+    }
+    try {
+      const metadataContent = await fs.readFile(indexEntry.metadataFile, "utf-8");
+      const metadata = JSON.parse(metadataContent);
+      const contentRaw = await fs.readFile(indexEntry.contentFile, "utf-8");
+      let content;
+      if (metadata.contentType.includes("json")) {
+        content = JSON.parse(contentRaw);
+      } else {
+        content = contentRaw;
+      }
+      return { metadata, content };
+    } catch {
+      await this.delete(key);
+      return null;
+    }
+  }
+  /**
+   * Get the content only (convenience method)
+   */
+  async getContent(key, options) {
+    const entry = await this.get(key, options);
+    return entry?.content ?? null;
+  }
+  /**
+   * Set a cache entry
+   */
+  async set(key, content, metadata, options) {
+    this.ensureInitialized();
+    const now = /* @__PURE__ */ new Date();
+    const ttl = options?.ttl ?? this.ttl;
+    const expiresAt = new Date(now.getTime() + ttl * 1e3);
+    const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+    const contentHash = this.hashContent(contentStr);
+    const size = Buffer.byteLength(contentStr, "utf-8");
+    const safeKey = this.sanitizeKey(key);
+    const contentFile = join4(this.contentPath, `${safeKey}.cache`);
+    const metadataFile = join4(this.metadataPath, `${safeKey}.json`);
+    const fullMetadata = {
+      key,
+      source: metadata.source ?? "custom",
+      sourceUrl: metadata.sourceUrl ?? "",
+      cachedAt: now.toISOString(),
+      expiresAt: expiresAt.toISOString(),
+      contentHash,
+      size,
+      contentType: metadata.contentType ?? (typeof content === "string" ? "text/plain" : "application/json")
+    };
+    if (metadata.etag) {
+      fullMetadata.etag = metadata.etag;
+    }
+    if (metadata.title) {
+      fullMetadata.title = metadata.title;
+    }
+    if (metadata.lastModified) {
+      fullMetadata.lastModified = metadata.lastModified;
+    }
+    const tags = options?.tags ?? metadata.tags;
+    if (tags) {
+      fullMetadata.tags = tags;
+    }
+    try {
+      await fs.mkdir(dirname3(contentFile), { recursive: true });
+      await fs.mkdir(dirname3(metadataFile), { recursive: true });
+      await fs.writeFile(contentFile, contentStr, "utf-8");
+      await fs.writeFile(metadataFile, JSON.stringify(fullMetadata, null, 2), "utf-8");
+      if (this.index) {
+        const oldEntry = this.index.entries[key];
+        if (oldEntry) {
+          this.index.stats.totalSize -= oldEntry.size;
+        } else {
+          this.index.stats.entryCount++;
+        }
+        this.index.entries[key] = {
+          key,
+          source: fullMetadata.source,
+          cachedAt: fullMetadata.cachedAt,
+          expiresAt: fullMetadata.expiresAt,
+          size,
+          contentFile,
+          metadataFile
+        };
+        this.index.stats.totalSize += size;
+        await this.saveIndex();
+      }
+    } catch (error) {
+      throw new CacheError(
+        `Failed to write cache entry: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        key,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Check if a key exists in the cache
+   */
+  async has(key) {
+    this.ensureInitialized();
+    return key in (this.index?.entries ?? {});
+  }
+  /**
+   * Delete a cache entry
+   */
+  async delete(key) {
+    this.ensureInitialized();
+    const indexEntry = this.index?.entries[key];
+    if (!indexEntry) {
+      return false;
+    }
+    try {
+      await fs.unlink(indexEntry.contentFile).catch(noop);
+      await fs.unlink(indexEntry.metadataFile).catch(noop);
+      if (this.index) {
+        this.index.stats.totalSize -= indexEntry.size;
+        this.index.stats.entryCount--;
+        const { [key]: _removed, ...remaining } = this.index.entries;
+        this.index.entries = remaining;
+        await this.saveIndex();
+      }
+      return true;
+    } catch (error) {
+      throw new CacheError(
+        `Failed to delete cache entry: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        key,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Get the status of a cache entry
+   */
+  async getStatus(key) {
+    this.ensureInitialized();
+    const indexEntry = this.index?.entries[key];
+    if (!indexEntry) {
+      return null;
+    }
+    return this.getEntryStatus(indexEntry);
+  }
+  /**
+   * Get metadata for a cache entry
+   */
+  async getMetadata(key) {
+    this.ensureInitialized();
+    const indexEntry = this.index?.entries[key];
+    if (!indexEntry) {
+      return null;
+    }
+    try {
+      const content = await fs.readFile(indexEntry.metadataFile, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update metadata for a cache entry
+   */
+  async updateMetadata(key, metadata) {
+    this.ensureInitialized();
+    const existing = await this.getMetadata(key);
+    if (!existing) {
+      throw new CacheError(`Cache entry not found: ${key}`, "not_found", key);
+    }
+    const indexEntry = this.index?.entries[key];
+    if (!indexEntry) {
+      throw new CacheError(`Cache entry not found: ${key}`, "not_found", key);
+    }
+    const updated = {
+      ...existing,
+      ...metadata,
+      key: existing.key
+      // Can't change key
+    };
+    try {
+      await fs.writeFile(indexEntry.metadataFile, JSON.stringify(updated, null, 2), "utf-8");
+      if (this.index && indexEntry) {
+        if (metadata.source) indexEntry.source = metadata.source;
+        if (metadata.expiresAt) indexEntry.expiresAt = metadata.expiresAt;
+        await this.saveIndex();
+      }
+    } catch (error) {
+      throw new CacheError(
+        `Failed to update metadata: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        key,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * List cache entries
+   */
+  async list(options) {
+    this.ensureInitialized();
+    if (!this.index) return [];
+    let entries = Object.values(this.index.entries);
+    if (options?.source) {
+      entries = entries.filter((e) => e.source === options.source);
+    }
+    if (options?.status) {
+      entries = entries.filter((e) => this.getEntryStatus(e) === options.status);
+    }
+    const metadataPromises = entries.map(async (e) => {
+      const metadata = await this.getMetadata(e.key);
+      return metadata;
+    });
+    let results = (await Promise.all(metadataPromises)).filter(
+      (m) => m !== null
+    );
+    if (options?.tag) {
+      const tag = options.tag;
+      results = results.filter((m) => m.tags?.includes(tag));
+    }
+    if (options?.limit && results.length > options.limit) {
+      results = results.slice(0, options.limit);
+    }
+    return results;
+  }
+  /**
+   * Get cache statistics
+   */
+  async getStats() {
+    this.ensureInitialized();
+    if (!this.index) {
+      return {
+        totalEntries: 0,
+        totalSize: 0,
+        validEntries: 0,
+        staleEntries: 0,
+        expiredEntries: 0,
+        bySource: {
+          confluence: 0,
+          github: 0,
+          notion: 0,
+          local: 0,
+          custom: 0
+        }
+      };
+    }
+    const entries = Object.values(this.index.entries);
+    const bySource = {
+      confluence: 0,
+      github: 0,
+      notion: 0,
+      local: 0,
+      custom: 0
+    };
+    let validEntries = 0;
+    let staleEntries = 0;
+    let expiredEntries = 0;
+    let oldestEntry;
+    let newestEntry;
+    for (const entry of entries) {
+      bySource[entry.source]++;
+      const status = this.getEntryStatus(entry);
+      if (status === "valid") validEntries++;
+      else if (status === "stale") staleEntries++;
+      else if (status === "expired") expiredEntries++;
+      if (!oldestEntry || entry.cachedAt < oldestEntry) {
+        oldestEntry = entry.cachedAt;
+      }
+      if (!newestEntry || entry.cachedAt > newestEntry) {
+        newestEntry = entry.cachedAt;
+      }
+    }
+    const stats = {
+      totalEntries: this.index.stats.entryCount,
+      totalSize: this.index.stats.totalSize,
+      validEntries,
+      staleEntries,
+      expiredEntries,
+      bySource
+    };
+    if (oldestEntry) stats.oldestEntry = oldestEntry;
+    if (newestEntry) stats.newestEntry = newestEntry;
+    return stats;
+  }
+  /**
+   * Clear all cache entries
+   */
+  async clear() {
+    this.ensureInitialized();
+    if (!this.index) return 0;
+    const count = this.index.stats.entryCount;
+    try {
+      await fs.rm(this.contentPath, { recursive: true, force: true });
+      await fs.rm(this.metadataPath, { recursive: true, force: true });
+      await fs.mkdir(this.contentPath, { recursive: true });
+      await fs.mkdir(this.metadataPath, { recursive: true });
+      this.index = this.createEmptyIndex();
+      await this.saveIndex();
+      return count;
+    } catch (error) {
+      throw new CacheError(
+        `Failed to clear cache: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        void 0,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Clear expired entries only
+   */
+  async clearExpired() {
+    this.ensureInitialized();
+    if (!this.index) return 0;
+    const expiredKeys = Object.entries(this.index.entries).filter(([, entry]) => this.getEntryStatus(entry) === "expired").map(([key]) => key);
+    for (const key of expiredKeys) {
+      await this.delete(key);
+    }
+    if (this.index) {
+      this.index.stats.lastCleanup = (/* @__PURE__ */ new Date()).toISOString();
+      await this.saveIndex();
+    }
+    return expiredKeys.length;
+  }
+  /**
+   * Clear entries by source
+   */
+  async clearBySource(source) {
+    this.ensureInitialized();
+    if (!this.index) return 0;
+    const keys = Object.entries(this.index.entries).filter(([, entry]) => entry.source === source).map(([key]) => key);
+    for (const key of keys) {
+      await this.delete(key);
+    }
+    return keys.length;
+  }
+  /**
+   * Clear entries by tag
+   */
+  async clearByTag(tag) {
+    this.ensureInitialized();
+    const entries = await this.list({ tag });
+    for (const entry of entries) {
+      await this.delete(entry.key);
+    }
+    return entries.length;
+  }
+  // Private helpers
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new CacheError("Cache not initialized. Call initialize() first.", "invalid_config");
+    }
+  }
+  async loadIndex() {
+    try {
+      const content = await fs.readFile(this.indexPath, "utf-8");
+      const index = JSON.parse(content);
+      if (index.version !== INDEX_VERSION) {
+        return this.rebuildIndex();
+      }
+      return index;
+    } catch {
+      return this.createEmptyIndex();
+    }
+  }
+  async saveIndex() {
+    if (!this.index) return;
+    try {
+      await fs.writeFile(this.indexPath, JSON.stringify(this.index, null, 2), "utf-8");
+    } catch (error) {
+      throw new CacheError(
+        `Failed to save cache index: ${error instanceof Error ? error.message : String(error)}`,
+        "write_failed",
+        void 0,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  createEmptyIndex() {
+    return {
+      version: INDEX_VERSION,
+      entries: {},
+      stats: {
+        totalSize: 0,
+        entryCount: 0,
+        lastCleanup: null
+      }
+    };
+  }
+  async rebuildIndex() {
+    const index = this.createEmptyIndex();
+    try {
+      const metadataFiles = await fs.readdir(this.metadataPath);
+      for (const file of metadataFiles) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const metadataPath = join4(this.metadataPath, file);
+          const content = await fs.readFile(metadataPath, "utf-8");
+          const metadata = JSON.parse(content);
+          const safeKey = this.sanitizeKey(metadata.key);
+          const contentFile = join4(this.contentPath, `${safeKey}.cache`);
+          await fs.access(contentFile);
+          index.entries[metadata.key] = {
+            key: metadata.key,
+            source: metadata.source,
+            cachedAt: metadata.cachedAt,
+            expiresAt: metadata.expiresAt,
+            size: metadata.size,
+            contentFile,
+            metadataFile: metadataPath
+          };
+          index.stats.totalSize += metadata.size;
+          index.stats.entryCount++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return index;
+  }
+  getEntryStatus(entry) {
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(entry.expiresAt);
+    const cachedAt = new Date(entry.cachedAt);
+    if (now > expiresAt) {
+      return "expired";
+    }
+    const totalTtl = expiresAt.getTime() - cachedAt.getTime();
+    const elapsed = now.getTime() - cachedAt.getTime();
+    if (elapsed > totalTtl * 0.8) {
+      return "stale";
+    }
+    return "valid";
+  }
+  sanitizeKey(key) {
+    return createHash("sha256").update(key).digest("hex").substring(0, 32);
+  }
+  hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+  }
+};
+function createFileCacheProvider(options) {
+  return new FileCacheProvider(options);
+}
+
+// src/cache/manager.ts
+var CacheManager = class {
+  cache;
+  fetchers = /* @__PURE__ */ new Map();
+  defaultTtl;
+  defaultSource;
+  constructor(options) {
+    this.cache = options.cache;
+    this.defaultTtl = options.defaultTtl ?? 3600;
+    this.defaultSource = options.defaultSource ?? "custom";
+  }
+  /**
+   * Get content with cache-first strategy
+   */
+  async getWithFallback(key, url, options) {
+    if (!options?.skipCache && !options?.forceRefresh) {
+      const cached = await this.cache.get(key);
+      if (cached) {
+        const status = await this.cache.getStatus(key);
+        if (status === "valid") {
+          return cached;
+        }
+        if (status === "stale") {
+          try {
+            return await this.fetchAndCache(key, url, options);
+          } catch {
+            return cached;
+          }
+        }
+      }
+    }
+    return this.fetchAndCache(key, url, options);
+  }
+  /**
+   * Sync all entries from a source
+   */
+  async syncSource(source, options) {
+    const startTime = Date.now();
+    const result = {
+      added: 0,
+      updated: 0,
+      removed: 0,
+      failed: 0,
+      errors: [],
+      duration: 0
+    };
+    const entries = await this.cache.list({ source });
+    const concurrency = options?.concurrency ?? 5;
+    const chunks = this.chunkArray(entries, concurrency);
+    for (const chunk of chunks) {
+      const promises = chunk.map(async (entry) => {
+        try {
+          const fetcher = this.fetchers.get(source);
+          if (!fetcher) {
+            throw new Error(`No fetcher registered for source: ${source}`);
+          }
+          const hasChanged = await fetcher.hasChanged(entry.sourceUrl, entry.etag);
+          if (hasChanged || options?.force) {
+            const fetchOptions = {};
+            if (entry.etag) {
+              fetchOptions.etag = entry.etag;
+            }
+            const { content, metadata } = await fetcher.fetch(entry.sourceUrl, fetchOptions);
+            await this.cache.set(entry.key, content, {
+              ...entry,
+              ...metadata
+            });
+            result.updated++;
+          }
+        } catch (error) {
+          result.failed++;
+          result.errors.push({
+            key: entry.key,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (!options?.continueOnError) {
+            throw error;
+          }
+        }
+      });
+      await Promise.all(promises);
+    }
+    if (options?.onProgress) {
+      options.onProgress(entries.length, entries.length);
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Sync specific entries
+   */
+  async syncEntries(keys, options) {
+    const startTime = Date.now();
+    const result = {
+      added: 0,
+      updated: 0,
+      removed: 0,
+      failed: 0,
+      errors: [],
+      duration: 0
+    };
+    const concurrency = options?.concurrency ?? 5;
+    const chunks = this.chunkArray(keys, concurrency);
+    for (const chunk of chunks) {
+      const promises = chunk.map(async (key) => {
+        try {
+          const metadata = await this.cache.getMetadata(key);
+          if (!metadata) {
+            result.failed++;
+            result.errors.push({ key, error: "Entry not found in cache" });
+            return;
+          }
+          const fetcher = this.fetchers.get(metadata.source);
+          if (!fetcher) {
+            result.failed++;
+            result.errors.push({ key, error: `No fetcher for source: ${metadata.source}` });
+            return;
+          }
+          const hasChanged = await fetcher.hasChanged(metadata.sourceUrl, metadata.etag);
+          if (hasChanged || options?.force) {
+            const fetchOpts = {};
+            if (metadata.etag) {
+              fetchOpts.etag = metadata.etag;
+            }
+            const { content, metadata: newMeta } = await fetcher.fetch(
+              metadata.sourceUrl,
+              fetchOpts
+            );
+            await this.cache.set(key, content, {
+              ...metadata,
+              ...newMeta
+            });
+            result.updated++;
+          }
+        } catch (error) {
+          result.failed++;
+          result.errors.push({
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (!options?.continueOnError) {
+            throw error;
+          }
+        }
+      });
+      await Promise.all(promises);
+    }
+    if (options?.onProgress) {
+      options.onProgress(keys.length, keys.length);
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Register a fetcher for a source
+   */
+  registerFetcher(source, fetcher) {
+    this.fetchers.set(source, fetcher);
+  }
+  /**
+   * Get the underlying cache provider
+   */
+  getCache() {
+    return this.cache;
+  }
+  /**
+   * Check if a fetcher is registered for a source
+   */
+  hasFetcher(source) {
+    return this.fetchers.has(source);
+  }
+  /**
+   * Get all registered sources
+   */
+  getRegisteredSources() {
+    return Array.from(this.fetchers.keys());
+  }
+  // Private helpers
+  async fetchAndCache(key, url, options) {
+    const source = this.getSourceFromUrl(url);
+    const fetcher = this.fetchers.get(source);
+    if (!fetcher) {
+      throw new CacheError(
+        `No fetcher registered for source: ${source}. Register one with registerFetcher().`,
+        "fetch_failed",
+        key
+      );
+    }
+    try {
+      const fetchOpts = {};
+      if (options?.timeout) {
+        fetchOpts.timeout = options.timeout;
+      }
+      if (options?.headers) {
+        fetchOpts.headers = options.headers;
+      }
+      const { content, metadata } = await fetcher.fetch(url, fetchOpts);
+      const fullMetadata = {
+        source,
+        sourceUrl: url,
+        contentType: metadata.contentType ?? "text/plain"
+      };
+      if (metadata.etag) {
+        fullMetadata.etag = metadata.etag;
+      }
+      if (metadata.title) {
+        fullMetadata.title = metadata.title;
+      }
+      if (metadata.lastModified) {
+        fullMetadata.lastModified = metadata.lastModified;
+      }
+      if (options?.tags) {
+        fullMetadata.tags = options.tags;
+      }
+      const cacheOpts = {
+        ttl: options?.ttl ?? this.defaultTtl
+      };
+      if (options?.tags) {
+        cacheOpts.tags = options.tags;
+      }
+      await this.cache.set(key, content, fullMetadata, cacheOpts);
+      const entry = await this.cache.get(key);
+      if (!entry) {
+        throw new CacheError("Failed to retrieve cached entry after write", "read_failed", key);
+      }
+      return entry;
+    } catch (error) {
+      if (error instanceof CacheError) {
+        throw error;
+      }
+      throw new CacheError(
+        `Failed to fetch content: ${error instanceof Error ? error.message : String(error)}`,
+        "fetch_failed",
+        key,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  getSourceFromUrl(url) {
+    try {
+      const parsed = new URL(url);
+      const hostname = parsed.hostname.toLowerCase();
+      if (hostname.includes("confluence") || hostname.includes("atlassian.net")) {
+        return "confluence";
+      }
+      if (hostname.includes("github.com") || hostname.includes("github")) {
+        return "github";
+      }
+      if (hostname.includes("notion.so") || hostname.includes("notion")) {
+        return "notion";
+      }
+      return this.defaultSource;
+    } catch {
+      return "local";
+    }
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+function createCacheManager(options) {
+  return new CacheManager(options);
+}
+
+// src/context/loader.ts
+var ContextLoader = class {
+  cacheManager;
+  defaultTtl;
+  failOnRequired;
+  concurrency;
+  constructor(options) {
+    this.cacheManager = options.cacheManager;
+    this.defaultTtl = options.defaultTtl ?? 3600;
+    this.failOnRequired = options.failOnRequired ?? true;
+    this.concurrency = options.concurrency ?? 5;
+  }
+  /**
+   * Load a single context
+   */
+  async load(source, options) {
+    try {
+      const cacheOptions = {
+        ...options,
+        ttl: options?.ttl ?? this.defaultTtl
+      };
+      if (source.tags) {
+        cacheOptions.tags = source.tags;
+      }
+      const entry = await this.cacheManager.getWithFallback(
+        source.key,
+        source.url,
+        cacheOptions
+      );
+      return entry;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (source.required && this.failOnRequired) {
+        throw new Error(`Failed to load required context "${source.key}": ${message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Load multiple contexts
+   */
+  async loadMany(sources, options) {
+    const startTime = Date.now();
+    const result = {
+      loaded: [],
+      failed: [],
+      duration: 0
+    };
+    const cacheStatuses = /* @__PURE__ */ new Map();
+    for (const source of sources) {
+      const status = await this.cacheManager.getCache().getStatus(source.key);
+      cacheStatuses.set(source.key, status === "valid");
+    }
+    const chunks = this.chunkArray(sources, this.concurrency);
+    let completed = 0;
+    for (const chunk of chunks) {
+      const promises = chunk.map(async (source) => {
+        try {
+          const itemCacheOptions = {
+            ...options,
+            ttl: options?.ttl ?? this.defaultTtl
+          };
+          if (source.tags) {
+            itemCacheOptions.tags = source.tags;
+          }
+          const entry = await this.cacheManager.getWithFallback(
+            source.key,
+            source.url,
+            itemCacheOptions
+          );
+          result.loaded.push({
+            key: source.key,
+            content: entry.content,
+            fromCache: cacheStatuses.get(source.key) ?? false,
+            metadata: entry.metadata
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          result.failed.push({
+            key: source.key,
+            error: message,
+            required: source.required ?? false
+          });
+          if (source.required && this.failOnRequired && !options?.continueOnError) {
+            throw new Error(`Failed to load required context "${source.key}": ${message}`);
+          }
+        }
+      });
+      await Promise.all(promises);
+      completed += chunk.length;
+      if (options?.onProgress) {
+        const currentKey = chunk[chunk.length - 1]?.key ?? "";
+        options.onProgress(completed, sources.length, currentKey);
+      }
+    }
+    result.duration = Date.now() - startTime;
+    if (this.failOnRequired && !options?.continueOnError) {
+      const requiredFailures = result.failed.filter((f) => f.required);
+      if (requiredFailures.length > 0) {
+        throw new Error(
+          `Failed to load ${requiredFailures.length} required context(s): ${requiredFailures.map((f) => f.key).join(", ")}`
+        );
+      }
+    }
+    return result;
+  }
+  /**
+   * Load contexts by tag
+   */
+  async loadByTag(tag, _options) {
+    const startTime = Date.now();
+    const result = {
+      loaded: [],
+      failed: [],
+      duration: 0
+    };
+    const entries = await this.cacheManager.getCache().list({ tag });
+    for (const entry of entries) {
+      try {
+        const cached = await this.cacheManager.getCache().get(entry.key);
+        if (cached) {
+          result.loaded.push({
+            key: entry.key,
+            content: cached.content,
+            fromCache: true,
+            metadata: cached.metadata
+          });
+        }
+      } catch (error) {
+        result.failed.push({
+          key: entry.key,
+          error: error instanceof Error ? error.message : String(error),
+          required: false
+        });
+      }
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Refresh all contexts (sync from remote)
+   */
+  async refresh(sources, options) {
+    return this.loadMany(sources, {
+      ...options,
+      forceRefresh: true
+    });
+  }
+  /**
+   * Check if all required contexts are available (cached or fetchable)
+   */
+  async checkAvailability(sources) {
+    const available = [];
+    const missing = [];
+    const errors = [];
+    for (const source of sources) {
+      try {
+        const hasCached = await this.cacheManager.getCache().has(source.key);
+        if (hasCached) {
+          available.push(source.key);
+          continue;
+        }
+        const url = new URL(source.url);
+        const source_type = this.getSourceFromHostname(url.hostname);
+        if (this.cacheManager.hasFetcher(source_type)) {
+          missing.push(source.key);
+        } else {
+          errors.push(`${source.key}: No fetcher for ${source_type}`);
+        }
+      } catch (error) {
+        errors.push(`${source.key}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return { available, missing, errors };
+  }
+  /**
+   * Get the cache manager
+   */
+  getCacheManager() {
+    return this.cacheManager;
+  }
+  // Private helpers
+  getSourceFromHostname(hostname) {
+    const lower = hostname.toLowerCase();
+    if (lower.includes("confluence") || lower.includes("atlassian.net")) return "confluence";
+    if (lower.includes("github.com") || lower.includes("github")) return "github";
+    if (lower.includes("notion.so") || lower.includes("notion")) return "notion";
+    return "custom";
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+function createContextLoader(options) {
+  return new ContextLoader(options);
+}
+
+// src/commands/context.ts
+function createCommandContext(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  let config = options.config ?? null;
+  if (!config && configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+    } catch {
+      config = null;
+    }
+  }
+  let adapterFactory = options.adapterFactory ?? null;
+  if (!adapterFactory && config) {
+    try {
+      adapterFactory = createAdapterFactory(config);
+    } catch {
+      adapterFactory = null;
+    }
+  }
+  return {
+    config,
+    adapterFactory,
+    projectRoot,
+    hasIntegration(type) {
+      if (!adapterFactory) return false;
+      return adapterFactory.hasIntegration(type);
+    },
+    async getAdapterSafe(type) {
+      if (!adapterFactory) return null;
+      if (!adapterFactory.hasIntegration(type)) return null;
+      try {
+        const adapter = await adapterFactory.getAdapter(type);
+        return adapter;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+async function cleanupContext(context) {
+  if (context.adapterFactory) {
+    await context.adapterFactory.disconnectAll();
+  }
+}
+async function withContext(options, fn) {
+  const context = createCommandContext(options);
+  try {
+    return await fn(context);
+  } finally {
+    await cleanupContext(context);
+  }
+}
+
+// src/commands/registry.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  adapterFactory = null;
+  /**
+   * Set the adapter factory for dependency checking
+   */
+  setAdapterFactory(factory) {
+    this.adapterFactory = factory;
+    this.updateAvailability();
+  }
+  /**
+   * Register a programmatic command
+   */
+  register(definition) {
+    const metadata = {
+      name: definition.name,
+      description: definition.description,
+      category: definition.category,
+      dependencies: definition.dependencies ?? [],
+      sourcePath: "<programmatic>",
+      available: true
+    };
+    this.checkAvailability(metadata);
+    this.commands.set(definition.name, {
+      metadata,
+      definition,
+      source: "programmatic"
+    });
+  }
+  /**
+   * Register a markdown command
+   */
+  registerMarkdown(command) {
+    this.checkAvailability(command.metadata);
+    this.commands.set(command.metadata.name, {
+      metadata: command.metadata,
+      markdownCommand: command,
+      source: "markdown"
+    });
+  }
+  /**
+   * Register multiple commands
+   */
+  registerAll(definitions) {
+    for (const def of definitions) {
+      this.register(def);
+    }
+  }
+  /**
+   * Register multiple markdown commands
+   */
+  registerAllMarkdown(commands) {
+    for (const cmd of commands) {
+      this.registerMarkdown(cmd);
+    }
+  }
+  /**
+   * Unregister a command
+   */
+  unregister(name) {
+    return this.commands.delete(name);
+  }
+  /**
+   * Get a command by name
+   */
+  get(name) {
+    return this.commands.get(name);
+  }
+  /**
+   * Check if a command exists
+   */
+  has(name) {
+    return this.commands.has(name);
+  }
+  /**
+   * Get all registered commands
+   */
+  getAll() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get available commands (dependencies satisfied)
+   */
+  getAvailable() {
+    return this.getAll().filter((entry) => entry.metadata.available);
+  }
+  /**
+   * Get unavailable commands
+   */
+  getUnavailable() {
+    return this.getAll().filter((entry) => !entry.metadata.available);
+  }
+  /**
+   * Get commands by category
+   */
+  getByCategory(category) {
+    return this.getAll().filter((entry) => entry.metadata.category === category);
+  }
+  /**
+   * Get command names
+   */
+  getNames() {
+    return Array.from(this.commands.keys());
+  }
+  /**
+   * Clear all registered commands
+   */
+  clear() {
+    this.commands.clear();
+  }
+  /**
+   * Get the number of registered commands
+   */
+  get size() {
+    return this.commands.size;
+  }
+  /**
+   * Check and update availability for a command metadata
+   */
+  checkAvailability(metadata) {
+    const missingDeps = this.getMissingDependencies(metadata.dependencies);
+    if (missingDeps.length > 0) {
+      const requiredMissing = missingDeps.filter((d) => d.required);
+      if (requiredMissing.length > 0) {
+        metadata.available = false;
+        metadata.unavailableReason = `Missing required integrations: ${requiredMissing.map((d) => d.type).join(", ")}`;
+      } else {
+        metadata.available = true;
+      }
+    } else {
+      metadata.available = true;
+      delete metadata.unavailableReason;
+    }
+  }
+  /**
+   * Get missing dependencies
+   */
+  getMissingDependencies(dependencies) {
+    const factory = this.adapterFactory;
+    if (!factory) {
+      return dependencies.filter((d) => d.required);
+    }
+    return dependencies.filter((dep) => !factory.hasIntegration(dep.type));
+  }
+  /**
+   * Update availability for all commands
+   */
+  updateAvailability() {
+    for (const entry of this.commands.values()) {
+      this.checkAvailability(entry.metadata);
+    }
+  }
+  /**
+   * Get dependency status for a command
+   */
+  getDependencyStatus(name) {
+    const entry = this.commands.get(name);
+    if (!entry) return null;
+    const deps = entry.metadata.dependencies;
+    const missing = this.getMissingDependencies(deps);
+    const satisfied = deps.filter((d) => !missing.includes(d));
+    return { satisfied, missing };
+  }
+};
+function createCommandRegistry() {
+  return new CommandRegistry();
+}
+var globalRegistry = null;
+function getGlobalRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new CommandRegistry();
+  }
+  return globalRegistry;
+}
+function resetGlobalRegistry() {
+  globalRegistry = null;
+}
+
+// src/commands/loader.ts
+import { promises as fs2 } from "fs";
+import { join as join5, basename as basename2, dirname as dirname4, relative } from "path";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterText = match[1] ?? "";
+  const body = match[2] ?? "";
+  const frontmatter = {};
+  const lines = frontmatterText.split(/\r?\n/);
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      const arrayContent = value.slice(1, -1);
+      const items = arrayContent.split(",").map((s) => s.trim().replace(/['"]/g, ""));
+      frontmatter[key] = items;
+    } else {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function parseSections(body) {
+  const sections = {};
+  const titleMatch = body.match(/^#\s+(.+)$/m);
+  if (titleMatch?.[1]) {
+    sections.title = titleMatch[1].trim();
+  }
+  const instructionsMatch = body.match(/##\s*Instructions?\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (instructionsMatch?.[1]) {
+    sections.instructions = instructionsMatch[1].trim();
+  }
+  const fallbacksMatch = body.match(/##\s*Fallbacks?\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (fallbacksMatch?.[1]) {
+    sections.fallbacks = fallbacksMatch[1].trim();
+  }
+  const outputMatch = body.match(/##\s*Output\s*(Format)?\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (outputMatch?.[2]) {
+    sections.outputFormat = outputMatch[2].trim();
+  }
+  return sections;
+}
+function mapIntegrationToAdapterType(integration) {
+  const mapping = {
+    // Issue tracker mappings
+    jira: "issue_tracker",
+    issue_tracker: "issue_tracker",
+    issues: "issue_tracker",
+    linear: "issue_tracker",
+    github_issues: "issue_tracker",
+    // Git provider mappings
+    git: "git",
+    github: "git",
+    gitlab: "git",
+    bitbucket: "git",
+    // Documentation mappings
+    docs: "documentation",
+    documentation: "documentation",
+    confluence: "documentation",
+    notion: "documentation",
+    wiki: "documentation",
+    // State mappings
+    state: "state",
+    filesystem: "state"
+  };
+  return mapping[integration.toLowerCase()] ?? null;
+}
+function parseDependencies(frontmatter) {
+  const dependencies = [];
+  if (frontmatter.requires && Array.isArray(frontmatter.requires)) {
+    for (const req of frontmatter.requires) {
+      const type = mapIntegrationToAdapterType(req);
+      if (type) {
+        dependencies.push({
+          type,
+          required: true,
+          description: `Requires ${req} integration`
+        });
+      }
+    }
+  }
+  if (frontmatter.optional && Array.isArray(frontmatter.optional)) {
+    for (const opt of frontmatter.optional) {
+      const type = mapIntegrationToAdapterType(opt);
+      if (type) {
+        dependencies.push({
+          type,
+          required: false,
+          description: `Optionally uses ${opt} integration`
+        });
+      }
+    }
+  }
+  return dependencies;
+}
+function deriveCommandName(filePath, baseDir) {
+  const relativePath = relative(baseDir, filePath);
+  const name = basename2(filePath, ".md");
+  const dir = dirname4(relativePath);
+  if (dir === "." || dir === "core" || dir === "optional") {
+    return name;
+  }
+  return name;
+}
+function deriveCategoryFromPath(filePath, baseDir) {
+  const relativePath = relative(baseDir, filePath);
+  const parts = relativePath.split("/");
+  if (parts.includes("optional")) {
+    return "optional";
+  }
+  if (parts.includes("core")) {
+    return "core";
+  }
+  return "custom";
+}
+async function loadCommandFromFile(filePath, baseDir, categoryOverride) {
+  const content = await fs2.readFile(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  const sections = parseSections(body);
+  const name = deriveCommandName(filePath, baseDir);
+  const category = categoryOverride ?? deriveCategoryFromPath(filePath, baseDir);
+  const dependencies = parseDependencies(frontmatter);
+  const metadata = {
+    name,
+    description: frontmatter.description ?? sections.title ?? name,
+    category,
+    dependencies,
+    sourcePath: filePath,
+    available: true
+    // Will be updated by registry
+  };
+  if (frontmatter["argument-hint"]) {
+    metadata.argumentHint = frontmatter["argument-hint"];
+  }
+  return {
+    metadata,
+    content: body,
+    sections
+  };
+}
+async function findMarkdownFiles(dir, recursive) {
+  const files = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join5(dir, entry.name);
+      if (entry.isDirectory() && recursive) {
+        const subFiles = await findMarkdownFiles(fullPath, recursive);
+        files.push(...subFiles);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return files;
+}
+async function loadCommandsFromDirectory(options) {
+  const result = {
+    loaded: [],
+    errors: []
+  };
+  const files = await findMarkdownFiles(options.directory, options.recursive ?? true);
+  for (const filePath of files) {
+    try {
+      const command = await loadCommandFromFile(filePath, options.directory, options.category);
+      if (options.filter && !options.filter(command.metadata)) {
+        continue;
+      }
+      result.loaded.push(command);
+    } catch (error) {
+      result.errors.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+async function loadCoreAICommands(projectRoot) {
+  const commandsDir = join5(projectRoot, "coreai", "commands");
+  return loadCommandsFromDirectory({
+    directory: commandsDir,
+    category: "core",
+    // Will be overridden by path derivation
+    recursive: true
+  });
+}
+async function loadAllCommands(coreCommandsDir, customCommandsDir) {
+  const result = {
+    loaded: [],
+    errors: []
+  };
+  const coreResult = await loadCommandsFromDirectory({
+    directory: coreCommandsDir,
+    category: "core",
+    recursive: true
+  });
+  result.loaded.push(...coreResult.loaded);
+  result.errors.push(...coreResult.errors);
+  if (customCommandsDir) {
+    const customResult = await loadCommandsFromDirectory({
+      directory: customCommandsDir,
+      category: "custom",
+      recursive: true
+    });
+    result.loaded.push(...customResult.loaded);
+    result.errors.push(...customResult.errors);
+  }
+  return result;
+}
+
+// src/commands/runner.ts
+async function runCommand(registry, name, args, options = {}) {
+  const entry = registry.get(name);
+  if (!entry) {
+    return {
+      success: false,
+      error: `Command not found: ${name}`
+    };
+  }
+  if (!entry.metadata.available) {
+    return {
+      success: false,
+      error: entry.metadata.unavailableReason ?? "Command is unavailable"
+    };
+  }
+  if (!entry.definition) {
+    return {
+      success: false,
+      error: `Command ${name} is a markdown command and cannot be executed programmatically`
+    };
+  }
+  const contextOptions = {};
+  if (options.projectRoot) {
+    contextOptions.projectRoot = options.projectRoot;
+  }
+  const context = options.context ?? createCommandContext(contextOptions);
+  try {
+    const result = await entry.definition.handler(
+      args,
+      options,
+      context
+    );
+    if (entry.metadata.dependencies) {
+      const optionalDeps = entry.metadata.dependencies.filter((d) => !d.required);
+      const optionalUnavailable = optionalDeps.filter((d) => !context.hasIntegration(d.type));
+      if (optionalUnavailable.length > 0) {
+        result.skippedSteps = result.skippedSteps ?? [];
+        for (const dep of optionalUnavailable) {
+          result.skippedSteps.push({
+            step: `${dep.type} integration`,
+            reason: dep.description ?? `${dep.type} not configured`
+          });
+        }
+      }
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (options.cleanupAfter !== false && !options.context) {
+      await cleanupContext(context);
+    }
+  }
+}
+async function executeWithDegradation(context, dependency, step, fallback) {
+  if (!context.hasIntegration(dependency.type)) {
+    if (dependency.required) {
+      throw new Error(`Required integration missing: ${dependency.type}`);
+    }
+    if (fallback) {
+      try {
+        const result2 = await fallback();
+        return { result: result2, skipped: false };
+      } catch {
+        return {
+          result: null,
+          skipped: true,
+          reason: dependency.description ?? `${dependency.type} not available`
+        };
+      }
+    }
+    return {
+      result: null,
+      skipped: true,
+      reason: dependency.description ?? `${dependency.type} not available`
+    };
+  }
+  const result = await step();
+  return { result, skipped: false };
+}
+function createDegradingHandler(handler) {
+  return async (args, options, context) => {
+    const tracker = new StepTracker();
+    try {
+      const data = await handler(args, options, context, tracker);
+      return {
+        success: true,
+        data,
+        warnings: tracker.warnings,
+        skippedSteps: tracker.skippedSteps
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        warnings: tracker.warnings,
+        skippedSteps: tracker.skippedSteps
+      };
+    }
+  };
+}
+var StepTracker = class {
+  skippedSteps = [];
+  warnings = [];
+  /**
+   * Record a skipped step
+   */
+  skip(step, reason) {
+    this.skippedSteps.push({ step, reason });
+  }
+  /**
+   * Record a warning
+   */
+  warn(message) {
+    this.warnings.push(message);
+  }
+  /**
+   * Execute a step with optional fallback
+   */
+  async tryStep(stepName, context, dependency, step, fallback) {
+    const result = await executeWithDegradation(context, dependency, step, fallback);
+    if (result.skipped) {
+      this.skip(stepName, result.reason ?? "Integration not available");
+    }
+    return result.result;
+  }
+};
+
+// src/skills/generator.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join6, basename as basename3 } from "path";
+
+// src/skills/templates.ts
+var checkInboxSkill = {
+  name: "check-inbox",
+  description: "Check your inbox for pending tasks and messages",
+  category: "core",
+  content: `---
+description: Check your inbox for pending tasks and messages
+---
+
+# Check Inbox
+
+Check the inbox at \`KnowledgeLibrary/{{AGENT_NAME}}/inbox/\` for new messages.
+
+## Instructions
+
+1. Read all unprocessed messages in the inbox directory
+2. For each message:
+   - Parse the frontmatter (type, from, date, priority)
+   - Understand the request or task
+   - Take appropriate action based on message type
+3. After processing, move message to \`inbox/processed/\`
+4. Update your context file at \`KnowledgeLibrary/{{AGENT_NAME}}/context/current.txt\`
+
+## Message Types
+
+- **task-assignment**: New work assigned to you
+- **completion-report**: Another agent completed work
+- **review-request**: Code review needed
+- **feedback**: Response to your previous work
+
+## Output Format
+
+Report what messages were processed and actions taken.
+`
+};
+var delegateSkill = {
+  name: "delegate",
+  description: "Delegate a task to another agent via inbox messaging",
+  argumentHint: "<task-description> to <agent-name>",
+  category: "core",
+  content: `---
+description: Delegate a task to another agent via inbox messaging
+argument-hint: <task-description> to <agent-name>
+---
+
+# Delegate Task
+
+Delegate work to another agent using the inbox-based messaging system.
+
+## CRITICAL: Do NOT use the Task tool
+
+Agent-to-agent delegation MUST use file-based messaging, not the Task tool.
+The Task tool spawns subagents that lose MCP access.
+
+## Instructions
+
+1. Parse the delegation request to identify:
+   - The task to delegate
+   - The target agent
+
+2. Create a message file in the target agent's inbox:
+   - Path: \`KnowledgeLibrary/<target-agent>/inbox/\`
+   - Filename: \`YYYYMMDD_HHMM-{{AGENT_NAME}}-<subject>.md\`
+
+3. Use this message format:
+\`\`\`markdown
+---
+type: task-assignment
+from: {{AGENT_NAME}}
+to: <target-agent>
+date: YYYY-MM-DD HH:MM
+priority: P2
+---
+
+## Task Assignment
+
+### Description
+<Clear description of what needs to be done>
+
+### Context
+<Any relevant context or background>
+
+### Expected Deliverables
+1. <Deliverable 1>
+2. <Deliverable 2>
+
+### Success Criteria
+- <Criterion 1>
+- <Criterion 2>
+\`\`\`
+
+4. Tell the user to invoke the target agent:
+   "Please invoke @<target-agent> to process this task."
+
+## Output
+
+Confirm the delegation message was created and instruct user to invoke the agent.
+`
+};
+var gitCommitSkill = {
+  name: "git-commit",
+  description: "Create a quality-gated git commit",
+  argumentHint: "<commit-message>",
+  category: "core",
+  dependencies: [{ type: "git", required: false, description: "For commit operations" }],
+  content: `---
+description: Create a quality-gated git commit
+argument-hint: <commit-message>
+optional: [git]
+---
+
+# Git Commit
+
+Create a git commit after passing all quality gates.
+
+## Quality Gates
+
+Run these checks before committing:
+
+1. **Lint**: \`{{LINT_CMD}}\`
+2. **Tests**: \`{{TEST_CMD}}\`
+3. **Build**: \`{{BUILD_CMD}}\`
+
+## Instructions
+
+1. Stage the relevant files with \`git add\`
+2. Run all quality gate commands
+3. If any gate fails:
+   - Fix the issues
+   - Re-run the failed gate
+   - Continue only when all pass
+4. Create the commit with the provided message
+5. Format: Include ticket reference if applicable
+
+## Commit Message Format
+
+\`\`\`
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+\`\`\`
+
+Types: feat, fix, docs, style, refactor, test, chore
+
+## Fallbacks
+
+If quality gate commands are not configured:
+- Ask the user what commands to run
+- Or skip gates with user confirmation
+`
+};
+var prCreateSkill = {
+  name: "pr-create",
+  description: "Create a pull request with proper format",
+  argumentHint: "[branch-name]",
+  category: "core",
+  dependencies: [{ type: "git", required: true, description: "For PR creation" }],
+  content: `---
+description: Create a pull request with proper format
+argument-hint: [branch-name]
+requires: [git]
+---
+
+# Create Pull Request
+
+Create a well-formatted pull request for the current branch.
+
+## Instructions
+
+1. Ensure all changes are committed
+2. Push the branch to remote
+3. Create PR with proper format:
+
+\`\`\`markdown
+## Summary
+<Brief description of changes>
+
+## Changes
+- <Change 1>
+- <Change 2>
+
+## Test Plan
+- [ ] <Test case 1>
+- [ ] <Test case 2>
+
+## Related Issues
+Closes {{JIRA_PROJECT}}-XXX
+\`\`\`
+
+4. Request reviewers if specified
+
+## Using GitHub CLI
+
+\`\`\`bash
+gh pr create --title "<title>" --body "<body>"
+\`\`\`
+
+## Output
+
+Provide the PR URL and summary of what was created.
+`
+};
+var reviewSkill = {
+  name: "review",
+  description: "Request or perform a code review",
+  argumentHint: "<pr-number-or-url>",
+  category: "core",
+  dependencies: [{ type: "git", required: true, description: "For PR review" }],
+  content: `---
+description: Request or perform a code review
+argument-hint: <pr-number-or-url>
+requires: [git]
+---
+
+# Code Review
+
+Review a pull request or delegate review to a specialist.
+
+## Instructions
+
+### If you are reviewing:
+
+1. Fetch the PR details and diff
+2. Review for:
+   - Code quality and style
+   - Logic errors or bugs
+   - Security concerns
+   - Test coverage
+   - Documentation
+3. Provide feedback with specific line references
+4. Approve, request changes, or comment
+
+### If delegating to a reviewer:
+
+1. Identify the appropriate reviewer based on the changes
+2. Create a review request message in their inbox
+3. Include PR link and context
+
+## Review Checklist
+
+- [ ] Code follows project conventions
+- [ ] No obvious bugs or edge cases
+- [ ] Tests cover the changes
+- [ ] Documentation updated if needed
+- [ ] No security vulnerabilities
+
+## Output
+
+Provide review summary with actionable feedback.
+`
+};
+var sprintStatusSkill = {
+  name: "sprint-status",
+  description: "Get current sprint status and progress",
+  category: "optional",
+  dependencies: [{ type: "issue_tracker", required: true, description: "For sprint data" }],
+  content: `---
+description: Get current sprint status and progress
+requires: [issue_tracker]
+---
+
+# Sprint Status
+
+Get the current sprint status and team progress.
+
+## Instructions
+
+1. Query the active sprint for project {{JIRA_PROJECT}}
+2. Gather metrics:
+   - Total story points committed
+   - Points completed
+   - Points in progress
+   - Points remaining
+3. List tickets by status
+4. Identify blockers or at-risk items
+
+## Output Format
+
+\`\`\`
+Sprint: <sprint-name>
+Progress: XX/YY points (ZZ%)
+
+## Completed
+- [{{JIRA_PROJECT}}-123] Task name (3 pts)
+
+## In Progress
+- [{{JIRA_PROJECT}}-124] Task name (5 pts) - @assignee
+
+## To Do
+- [{{JIRA_PROJECT}}-125] Task name (2 pts)
+
+## Blocked
+- [{{JIRA_PROJECT}}-126] Task name - Reason
+\`\`\`
+
+## Fallbacks
+
+If issue tracker is unavailable:
+- Report that sprint data cannot be fetched
+- Suggest checking the issue tracker directly at {{JIRA_URL}}
+`
+};
+var jiraCreateSkill = {
+  name: "jira-create",
+  description: "Create a new Jira ticket",
+  argumentHint: "<ticket-type> <summary>",
+  category: "optional",
+  dependencies: [{ type: "issue_tracker", required: true, description: "For ticket creation" }],
+  content: `---
+description: Create a new Jira ticket
+argument-hint: <ticket-type> <summary>
+requires: [issue_tracker]
+---
+
+# Create Jira Ticket
+
+Create a new ticket in project {{JIRA_PROJECT}}.
+
+## Instructions
+
+1. Parse the ticket type and summary from arguments
+2. Gather additional details:
+   - Description
+   - Priority
+   - Labels
+   - Components (if applicable)
+3. Create the ticket via the issue tracker integration
+4. Return the ticket key and URL
+
+## Ticket Types
+
+- **Story**: User-facing feature
+- **Bug**: Defect to fix
+- **Task**: Technical work
+- **Spike**: Research/investigation
+
+## Output
+
+\`\`\`
+Created: {{JIRA_PROJECT}}-XXX
+URL: {{JIRA_URL}}/browse/{{JIRA_PROJECT}}-XXX
+Summary: <summary>
+Type: <type>
+\`\`\`
+
+## Fallbacks
+
+If issue tracker is unavailable:
+- Provide the user with manual creation instructions
+- Include all details they should enter
+`
+};
+var jiraTransitionSkill = {
+  name: "jira-transition",
+  description: "Transition a Jira ticket to a new status",
+  argumentHint: "<ticket-key> to <status>",
+  category: "optional",
+  dependencies: [{ type: "issue_tracker", required: true, description: "For ticket transitions" }],
+  content: `---
+description: Transition a Jira ticket to a new status
+argument-hint: <ticket-key> to <status>
+requires: [issue_tracker]
+---
+
+# Transition Jira Ticket
+
+Update the status of a ticket in {{JIRA_PROJECT}}.
+
+## Status Mapping
+
+| Workflow Status | Jira Status |
+|-----------------|-------------|
+| BACKLOG | Backlog |
+| IN_PROGRESS | In Progress |
+| PR_CREATED | In Review |
+| IN_REVIEW | In Review |
+| APPROVED | Ready to Merge |
+| MERGED | Done |
+| DONE | Done |
+
+## Instructions
+
+1. Parse ticket key and target status
+2. Validate the transition is allowed
+3. Add a comment explaining the transition
+4. Execute the transition
+
+## Transition Comment Format
+
+\`\`\`
+Status updated to <status>.
+<optional context about why>
+\`\`\`
+
+## Fallbacks
+
+If issue tracker is unavailable:
+- Instruct user to manually transition at {{JIRA_URL}}
+- Provide the target status name
+`
+};
+var docsUpdateSkill = {
+  name: "docs-update",
+  description: "Update project documentation",
+  argumentHint: "<doc-path-or-topic>",
+  category: "optional",
+  dependencies: [{ type: "documentation", required: false, description: "For remote docs" }],
+  content: `---
+description: Update project documentation
+argument-hint: <doc-path-or-topic>
+optional: [documentation]
+---
+
+# Update Documentation
+
+Update project documentation for a specific topic or file.
+
+## Instructions
+
+1. Identify the documentation to update:
+   - Local: \`{{DOCS_PATH}}/\`
+   - Remote: {{CONFLUENCE_SPACE}} (if configured)
+
+2. Make the necessary updates:
+   - Keep formatting consistent
+   - Update examples if code changed
+   - Add/update version information
+
+3. For remote documentation:
+   - Use the documentation integration
+   - Or provide content for manual update
+
+## Documentation Types
+
+- **README**: Project overview and setup
+- **API Docs**: Endpoint documentation
+- **Architecture**: Design decisions
+- **Runbooks**: Operational procedures
+
+## Fallbacks
+
+If documentation integration is unavailable:
+- Create/update local markdown files
+- Provide instructions for manual remote update
+`
+};
+var builtInSkills = [
+  checkInboxSkill,
+  delegateSkill,
+  gitCommitSkill,
+  prCreateSkill,
+  reviewSkill,
+  sprintStatusSkill,
+  jiraCreateSkill,
+  jiraTransitionSkill,
+  docsUpdateSkill
+];
+
+// src/skills/generator.ts
+function extractVariables2(config) {
+  const vars = {};
+  if (!config) {
+    return vars;
+  }
+  vars.PROJECT_NAME = config.project.name;
+  vars.PROJECT_ROOT = config.project.root;
+  if (config.project.type) {
+    vars.PROJECT_TYPE = config.project.type;
+  }
+  if (config.integrations?.issue_tracker) {
+    const tracker = config.integrations.issue_tracker;
+    if (tracker.config?.project_key) {
+      vars.JIRA_PROJECT = tracker.config.project_key;
+    }
+    if (tracker.config?.base_url) {
+      vars.JIRA_URL = tracker.config.base_url;
+    }
+  }
+  if (config.integrations?.git) {
+    const git = config.integrations.git;
+    if (git.config?.repo) {
+      vars.GITHUB_REPO = git.config.repo;
+    }
+    if (git.config?.owner) {
+      vars.GITHUB_OWNER = git.config.owner;
+    }
+    if (git.config?.default_branch) {
+      vars.DEFAULT_BRANCH = git.config.default_branch;
+    }
+  }
+  if (config.integrations?.documentation) {
+    const docs = config.integrations.documentation;
+    if (docs.config?.space_key) {
+      vars.CONFLUENCE_SPACE = docs.config.space_key;
+    }
+    if (docs.config?.base_url) {
+      vars.CONFLUENCE_URL = docs.config.base_url;
+    }
+    if (docs.config?.base_path) {
+      vars.DOCS_PATH = docs.config.base_path;
+    }
+  }
+  if (config.quality_gates) {
+    const gates = config.quality_gates;
+    const gateMappings = {
+      lint: "LINT_CMD",
+      test: "TEST_CMD",
+      build: "BUILD_CMD",
+      static_analysis: "STATIC_ANALYSIS_CMD",
+      staticAnalysis: "STATIC_ANALYSIS_CMD"
+    };
+    for (const [gateName, gate] of Object.entries(gates)) {
+      const varName = gateMappings[gateName];
+      if (varName) {
+        vars[varName] = gate.command;
+      }
+    }
+  }
+  if (config.tech_stack?.primary_language) {
+    vars.PRIMARY_LANGUAGE = config.tech_stack.primary_language;
+  }
+  return vars;
+}
+function substituteVariables(content, variables) {
+  let result = content;
+  for (const [key, value] of Object.entries(variables)) {
+    if (value !== void 0) {
+      const pattern = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+      result = result.replace(pattern, value);
+    }
+  }
+  return result;
+}
+function checkDependencies(skill, config) {
+  if (!skill.dependencies || skill.dependencies.length === 0) {
+    return { satisfied: true, missing: [] };
+  }
+  const missing = [];
+  for (const dep of skill.dependencies) {
+    if (!dep.required) {
+      continue;
+    }
+    let hasIntegration = false;
+    if (config?.integrations) {
+      switch (dep.type) {
+        case "issue_tracker":
+          hasIntegration = !!config.integrations.issue_tracker;
+          break;
+        case "git":
+          hasIntegration = !!config.integrations.git;
+          break;
+        case "documentation":
+          hasIntegration = !!config.integrations.documentation;
+          break;
+        case "state":
+          hasIntegration = !!config.integrations.state;
+          break;
+      }
+    }
+    if (!hasIntegration) {
+      missing.push(dep);
+    }
+  }
+  return {
+    satisfied: missing.length === 0,
+    missing
+  };
+}
+function loadCustomTemplates(templatesDir) {
+  const templates = [];
+  if (!existsSync4(templatesDir)) {
+    return templates;
+  }
+  const files = readdirSync2(templatesDir);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = join6(templatesDir, file);
+    const stat = statSync(filePath);
+    if (!stat.isFile()) continue;
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      const template = parseSkillTemplate(file, content);
+      templates.push(template);
+    } catch {
+    }
+  }
+  return templates;
+}
+function parseSkillTemplate(filename, content) {
+  const name = basename3(filename, ".md");
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  let description = name;
+  let argumentHint;
+  const dependencies = [];
+  if (frontmatterMatch) {
+    const frontmatter = frontmatterMatch[1] ?? "";
+    const lines = frontmatter.split(/\r?\n/);
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) continue;
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      switch (key) {
+        case "description":
+          description = value;
+          break;
+        case "argument-hint":
+          argumentHint = value;
+          break;
+        case "requires":
+          if (value.startsWith("[") && value.endsWith("]")) {
+            const items = value.slice(1, -1).split(",").map((s) => s.trim().replace(/['"]/g, ""));
+            for (const item of items) {
+              if (item) {
+                dependencies.push({
+                  type: mapIntegrationName(item),
+                  required: true
+                });
+              }
+            }
+          }
+          break;
+        case "optional":
+          if (value.startsWith("[") && value.endsWith("]")) {
+            const items = value.slice(1, -1).split(",").map((s) => s.trim().replace(/['"]/g, ""));
+            for (const item of items) {
+              if (item) {
+                dependencies.push({
+                  type: mapIntegrationName(item),
+                  required: false
+                });
+              }
+            }
+          }
+          break;
+      }
+    }
+  }
+  const template = {
+    name,
+    description,
+    category: "custom",
+    content
+  };
+  if (argumentHint) {
+    template.argumentHint = argumentHint;
+  }
+  if (dependencies.length > 0) {
+    template.dependencies = dependencies;
+  }
+  return template;
+}
+function mapIntegrationName(name) {
+  const lower = name.toLowerCase();
+  if (["jira", "linear", "issue_tracker", "issues", "github-issues"].includes(lower)) {
+    return "issue_tracker";
+  }
+  if (["git", "github", "gitlab", "bitbucket"].includes(lower)) {
+    return "git";
+  }
+  if (["docs", "documentation", "confluence", "notion", "wiki"].includes(lower)) {
+    return "documentation";
+  }
+  return "state";
+}
+function generateSkills(config, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const outputDir = options.outputDir ?? join6(projectRoot, ".claude", "commands");
+  const includeCoreSkills = options.includeCoreSkills ?? true;
+  const includeOptionalSkills = options.includeOptionalSkills ?? true;
+  const overwrite = options.overwrite ?? false;
+  const result = {
+    generated: [],
+    errors: [],
+    variables: {}
+  };
+  const variables = extractVariables2(config);
+  if (options.variables) {
+    Object.assign(variables, options.variables);
+  }
+  result.variables = variables;
+  let templates = [];
+  if (includeCoreSkills) {
+    templates.push(...builtInSkills.filter((s) => s.category === "core"));
+  }
+  if (includeOptionalSkills) {
+    templates.push(...builtInSkills.filter((s) => s.category === "optional"));
+  }
+  if (options.customTemplatesDir && existsSync4(options.customTemplatesDir)) {
+    templates.push(...loadCustomTemplates(options.customTemplatesDir));
+  }
+  if (options.skills && options.skills.length > 0) {
+    const skillsToInclude = options.skills;
+    templates = templates.filter((t) => skillsToInclude.includes(t.name));
+  }
+  if (!existsSync4(outputDir)) {
+    mkdirSync2(outputDir, { recursive: true });
+  }
+  for (const template of templates) {
+    try {
+      const generated = generateSkill(template, variables, config, outputDir, overwrite);
+      result.generated.push(generated);
+    } catch (error) {
+      result.errors.push({
+        name: template.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+function generateSkill(template, variables, config, outputDir, overwrite) {
+  const outputPath = join6(outputDir, `${template.name}.md`);
+  if (existsSync4(outputPath) && !overwrite) {
+    return {
+      name: template.name,
+      category: template.category,
+      outputPath,
+      action: "skipped",
+      skipReason: "File already exists"
+    };
+  }
+  const { satisfied, missing } = checkDependencies(template, config);
+  if (!satisfied) {
+    const missingTypes = missing.map((d) => d.type).join(", ");
+    return {
+      name: template.name,
+      category: template.category,
+      outputPath,
+      action: "skipped",
+      skipReason: `Missing required integrations: ${missingTypes}`
+    };
+  }
+  const content = substituteVariables(template.content, variables);
+  const isUpdate = existsSync4(outputPath);
+  writeFileSync2(outputPath, content, "utf-8");
+  return {
+    name: template.name,
+    category: template.category,
+    outputPath,
+    action: isUpdate ? "updated" : "created"
+  };
+}
+function formatGenerateResult(result) {
+  const lines = [];
+  const created = result.generated.filter((g) => g.action === "created");
+  const updated = result.generated.filter((g) => g.action === "updated");
+  const skipped = result.generated.filter((g) => g.action === "skipped");
+  if (created.length > 0) {
+    lines.push(`Created ${created.length} skill(s):`);
+    for (const skill of created) {
+      lines.push(`  \u2713 ${skill.name}`);
+    }
+    lines.push("");
+  }
+  if (updated.length > 0) {
+    lines.push(`Updated ${updated.length} skill(s):`);
+    for (const skill of updated) {
+      lines.push(`  \u2713 ${skill.name}`);
+    }
+    lines.push("");
+  }
+  if (skipped.length > 0) {
+    lines.push(`Skipped ${skipped.length} skill(s):`);
+    for (const skill of skipped) {
+      lines.push(`  - ${skill.name}: ${skill.skipReason}`);
+    }
+    lines.push("");
+  }
+  if (result.errors.length > 0) {
+    lines.push(`Failed to generate ${result.errors.length} skill(s):`);
+    for (const error of result.errors) {
+      lines.push(`  \u2717 ${error.name}: ${error.error}`);
+    }
+    lines.push("");
+  }
+  const total = created.length + updated.length;
+  if (total > 0) {
+    lines.push(`Generated ${total} skill(s) to .claude/commands/`);
+  } else if (result.generated.length === 0 && result.errors.length === 0) {
+    lines.push("No skills to generate.");
+  }
+  return lines.join("\n");
+}
+
+// src/knowledge-library/manager.ts
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  renameSync,
+  statSync as statSync2
+} from "fs";
+import { join as join7, basename as basename4 } from "path";
+var DEFAULT_KNOWLEDGE_LIBRARY_PATH = "KnowledgeLibrary";
+var STANDARD_FILES = {
+  context: "context.txt",
+  architecture: "architecture.txt",
+  prd: "prd.txt"
+};
+var AGENT_DIRECTORIES = [
+  "inbox",
+  "inbox/processed",
+  "outbox",
+  "context",
+  "control",
+  "history",
+  "tech"
+];
+var CONTROL_FILES = {
+  objectives: "objectives.txt",
+  decisions: "decisions.txt",
+  dependencies: "dependencies.txt"
+};
+function getAgentDirectories(basePath, agentName) {
+  const root = join7(basePath, agentName);
+  return {
+    root,
+    inbox: join7(root, "inbox"),
+    inboxProcessed: join7(root, "inbox", "processed"),
+    outbox: join7(root, "outbox"),
+    context: join7(root, "context"),
+    control: join7(root, "control"),
+    history: join7(root, "history"),
+    tech: join7(root, "tech")
+  };
+}
+function initKnowledgeLibrary(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const createDefaults = options.createDefaults ?? true;
+  const createdDirs = [];
+  const createdFiles = [];
+  try {
+    if (!existsSync5(basePath)) {
+      mkdirSync3(basePath, { recursive: true });
+      createdDirs.push(basePath);
+    }
+    if (createDefaults) {
+      const contextPath = join7(basePath, STANDARD_FILES.context);
+      if (!existsSync5(contextPath)) {
+        writeFileSync3(
+          contextPath,
+          `# Project Context
+
+## Current Sprint
+- Sprint: [Sprint name/number]
+- Goals: [Sprint goals]
+- Deadline: [Sprint deadline]
+
+## Priorities
+1. [Priority 1]
+2. [Priority 2]
+3. [Priority 3]
+
+## Notes
+[Project-wide notes and context]
+`,
+          "utf-8"
+        );
+        createdFiles.push(contextPath);
+      }
+      const architecturePath = join7(basePath, STANDARD_FILES.architecture);
+      if (!existsSync5(architecturePath)) {
+        writeFileSync3(
+          architecturePath,
+          `# Architecture Notes
+
+## Technical Decisions
+[Record major technical decisions here]
+
+## System Overview
+[High-level system architecture]
+
+## Key Components
+[Important system components]
+`,
+          "utf-8"
+        );
+        createdFiles.push(architecturePath);
+      }
+      const prdPath = join7(basePath, STANDARD_FILES.prd);
+      if (!existsSync5(prdPath)) {
+        writeFileSync3(
+          prdPath,
+          `# Product Requirements Document
+
+## Overview
+[Product overview]
+
+## Goals
+[Product goals]
+
+## Features
+[Feature list]
+
+## Requirements
+[Detailed requirements]
+`,
+          "utf-8"
+        );
+        createdFiles.push(prdPath);
+      }
+    }
+    return {
+      success: true,
+      createdDirs,
+      createdFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      createdDirs,
+      createdFiles,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function initAgentKnowledgeLibrary(agentName, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const createDefaults = options.createDefaults ?? true;
+  const createdDirs = [];
+  const createdFiles = [];
+  try {
+    if (!existsSync5(basePath)) {
+      const baseResult = initKnowledgeLibrary(options);
+      if (!baseResult.success) {
+        return baseResult;
+      }
+      createdDirs.push(...baseResult.createdDirs);
+      createdFiles.push(...baseResult.createdFiles);
+    }
+    const dirs = getAgentDirectories(basePath, agentName);
+    for (const dir of AGENT_DIRECTORIES) {
+      const dirPath = join7(dirs.root, dir);
+      if (!existsSync5(dirPath)) {
+        mkdirSync3(dirPath, { recursive: true });
+        createdDirs.push(dirPath);
+      }
+    }
+    if (createDefaults) {
+      const currentContextPath = join7(dirs.context, "current.txt");
+      if (!existsSync5(currentContextPath)) {
+        writeFileSync3(
+          currentContextPath,
+          `# ${agentName} Current Context
+
+## Status
+- State: idle
+- Current Task: None
+- Last Updated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Notes
+[Agent-specific context notes]
+`,
+          "utf-8"
+        );
+        createdFiles.push(currentContextPath);
+      }
+      const objectivesPath = join7(dirs.control, CONTROL_FILES.objectives);
+      if (!existsSync5(objectivesPath)) {
+        writeFileSync3(
+          objectivesPath,
+          `# ${agentName} Objectives
+
+## Current Objectives
+[None]
+
+## Success Criteria
+[Define success criteria for objectives]
+`,
+          "utf-8"
+        );
+        createdFiles.push(objectivesPath);
+      }
+      const decisionsPath = join7(dirs.control, CONTROL_FILES.decisions);
+      if (!existsSync5(decisionsPath)) {
+        writeFileSync3(
+          decisionsPath,
+          `# ${agentName} Decision Log
+
+## Decisions
+[Record important decisions here]
+
+Format:
+- Date: YYYY-MM-DD
+- Decision: [What was decided]
+- Reasoning: [Why]
+- Related: [Ticket or task reference]
+`,
+          "utf-8"
+        );
+        createdFiles.push(decisionsPath);
+      }
+      const dependenciesPath = join7(dirs.control, CONTROL_FILES.dependencies);
+      if (!existsSync5(dependenciesPath)) {
+        writeFileSync3(
+          dependenciesPath,
+          `# ${agentName} Dependencies
+
+## Blocked By
+[Tasks/agents blocking this agent]
+
+## Blocking
+[Tasks/agents this agent is blocking]
+
+Last Updated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+          "utf-8"
+        );
+        createdFiles.push(dependenciesPath);
+      }
+    }
+    return {
+      success: true,
+      createdDirs,
+      createdFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      createdDirs,
+      createdFiles,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function agentKnowledgeLibraryExists(agentName, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const agentRoot = join7(basePath, agentName);
+  return existsSync5(agentRoot) && existsSync5(join7(agentRoot, "inbox"));
+}
+function getAgentKnowledgeState(agentName, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const dirs = getAgentDirectories(basePath, agentName);
+  const initialized = agentKnowledgeLibraryExists(agentName, options);
+  const pendingMessages = initialized ? readInboxMessages(agentName, options) : [];
+  let context;
+  const currentContextPath = join7(dirs.context, "current.txt");
+  if (existsSync5(currentContextPath)) {
+    const content = readFileSync4(currentContextPath, "utf-8");
+    context = parseContextFile(content);
+  }
+  const state = {
+    agentName,
+    directories: dirs,
+    pendingMessages,
+    initialized
+  };
+  if (context) {
+    state.context = context;
+  }
+  return state;
+}
+function parseContextFile(content) {
+  const context = {
+    lastUpdated: /* @__PURE__ */ new Date()
+  };
+  const statusMatch = content.match(/State:\s*(.+)/i);
+  if (statusMatch && statusMatch[1]) {
+    context.status = statusMatch[1].trim();
+  }
+  const taskMatch = content.match(/Current Task:\s*(.+)/i);
+  if (taskMatch && taskMatch[1] && taskMatch[1].trim() !== "None") {
+    context.currentTask = taskMatch[1].trim();
+  }
+  const ticketMatch = content.match(/Current Ticket:\s*([A-Z]+-\d+)/i);
+  if (ticketMatch && ticketMatch[1]) {
+    context.currentTicket = ticketMatch[1];
+  }
+  const updatedMatch = content.match(/Last Updated:\s*(.+)/i);
+  if (updatedMatch) {
+    const dateStr = updatedMatch[1]?.trim();
+    if (dateStr) {
+      const parsed = new Date(dateStr);
+      if (!isNaN(parsed.getTime())) {
+        context.lastUpdated = parsed;
+      }
+    }
+  }
+  return context;
+}
+function generateMessageFilename(from, subject) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace(/[-:T]/g, "").slice(0, 12);
+  const sanitizedSubject = subject.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 30);
+  return `${timestamp}-${from}-${sanitizedSubject}.md`;
+}
+function parseMessageFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) {
+    return { metadata: {}, body: content };
+  }
+  const frontmatter = match[1] ?? "";
+  const body = match[2] ?? "";
+  const metadata = {};
+  for (const line of frontmatter.split(/\r?\n/)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "type":
+        metadata.type = value;
+        break;
+      case "from":
+        metadata.from = value;
+        break;
+      case "to":
+        metadata.to = value;
+        break;
+      case "date":
+        metadata.date = new Date(value);
+        break;
+      case "ticket":
+        metadata.ticket = value;
+        break;
+      case "priority":
+        if (value === "P0" || value === "P1" || value === "P2" || value === "P3") {
+          metadata.priority = value;
+        }
+        break;
+      case "subject":
+        metadata.subject = value;
+        break;
+    }
+  }
+  return { metadata, body };
+}
+function readInboxMessages(agentName, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const dirs = getAgentDirectories(basePath, agentName);
+  const messages = [];
+  if (existsSync5(dirs.inbox)) {
+    const files = readdirSync3(dirs.inbox).filter(
+      (f) => f.endsWith(".md") && statSync2(join7(dirs.inbox, f)).isFile()
+    );
+    for (const file of files) {
+      const filePath = join7(dirs.inbox, file);
+      const rawContent = readFileSync4(filePath, "utf-8");
+      const { metadata, body } = parseMessageFrontmatter(rawContent);
+      if (options.type && metadata.type !== options.type) continue;
+      if (options.from && metadata.from !== options.from) continue;
+      if (options.priority && metadata.priority !== options.priority) continue;
+      messages.push({
+        filename: file,
+        path: filePath,
+        metadata,
+        rawContent,
+        body
+      });
+    }
+  }
+  if (options.includeProcessed && existsSync5(dirs.inboxProcessed)) {
+    const files = readdirSync3(dirs.inboxProcessed).filter(
+      (f) => f.endsWith(".md") && statSync2(join7(dirs.inboxProcessed, f)).isFile()
+    );
+    for (const file of files) {
+      const filePath = join7(dirs.inboxProcessed, file);
+      const rawContent = readFileSync4(filePath, "utf-8");
+      const { metadata, body } = parseMessageFrontmatter(rawContent);
+      if (options.type && metadata.type !== options.type) continue;
+      if (options.from && metadata.from !== options.from) continue;
+      if (options.priority && metadata.priority !== options.priority) continue;
+      messages.push({
+        filename: file,
+        path: filePath,
+        metadata,
+        rawContent,
+        body
+      });
+    }
+  }
+  messages.sort((a, b) => {
+    const dateA = a.metadata.date?.getTime() ?? 0;
+    const dateB = b.metadata.date?.getTime() ?? 0;
+    return dateB - dateA;
+  });
+  if (options.limit && messages.length > options.limit) {
+    return messages.slice(0, options.limit);
+  }
+  return messages;
+}
+function writeInboxMessage(options) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const dirs = getAgentDirectories(basePath, options.to);
+  try {
+    if (!existsSync5(dirs.inbox)) {
+      mkdirSync3(dirs.inbox, { recursive: true });
+    }
+    const filename = generateMessageFilename(options.from, options.subject);
+    const filePath = join7(dirs.inbox, filename);
+    const now = /* @__PURE__ */ new Date();
+    const content = formatMessage(options, now);
+    writeFileSync3(filePath, content, "utf-8");
+    const senderDirs = getAgentDirectories(basePath, options.from);
+    if (existsSync5(senderDirs.outbox)) {
+      writeFileSync3(join7(senderDirs.outbox, filename), content, "utf-8");
+    }
+    return { success: true, path: filePath };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatMessage(options, date) {
+  let frontmatter = `---
+type: ${options.type}
+from: ${options.from}
+to: ${options.to}
+date: ${date.toISOString().slice(0, 16).replace("T", " ")}`;
+  if (options.ticket) {
+    frontmatter += `
+ticket: ${options.ticket}`;
+  }
+  if (options.priority) {
+    frontmatter += `
+priority: ${options.priority}`;
+  }
+  frontmatter += `
+subject: ${options.subject}`;
+  frontmatter += `
+---
+
+## ${options.subject}
+
+${options.body}`;
+  return frontmatter;
+}
+function markMessageProcessed(agentName, messageFilename, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const dirs = getAgentDirectories(basePath, agentName);
+  const sourcePath = join7(dirs.inbox, messageFilename);
+  const destPath = join7(dirs.inboxProcessed, messageFilename);
+  try {
+    if (!existsSync5(sourcePath)) {
+      return { success: false, error: `Message not found: ${messageFilename}` };
+    }
+    if (!existsSync5(dirs.inboxProcessed)) {
+      mkdirSync3(dirs.inboxProcessed, { recursive: true });
+    }
+    renameSync(sourcePath, destPath);
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function getKnowledgeLibraryState(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  if (!existsSync5(basePath)) {
+    return null;
+  }
+  const agents = [];
+  const entries = readdirSync3(basePath);
+  for (const entry of entries) {
+    const entryPath = join7(basePath, entry);
+    if (statSync2(entryPath).isDirectory() && existsSync5(join7(entryPath, "inbox"))) {
+      agents.push(entry);
+    }
+  }
+  return {
+    basePath,
+    contextPath: join7(basePath, STANDARD_FILES.context),
+    architecturePath: join7(basePath, STANDARD_FILES.architecture),
+    prdPath: join7(basePath, STANDARD_FILES.prd),
+    agents
+  };
+}
+function updateAgentContext(agentName, context, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const dirs = getAgentDirectories(basePath, agentName);
+  const contextPath = join7(dirs.context, "current.txt");
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const content = `# ${agentName} Current Context
+
+## Status
+- State: ${context.status ?? "idle"}
+- Current Task: ${context.currentTask ?? "None"}
+${context.currentTicket ? `- Current Ticket: ${context.currentTicket}` : ""}- Last Updated: ${now.toISOString()}
+
+## Notes
+${context.notes ?? "[Agent-specific context notes]"}
+`;
+    if (!existsSync5(dirs.context)) {
+      mkdirSync3(dirs.context, { recursive: true });
+    }
+    writeFileSync3(contextPath, content, "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatKnowledgeLibraryState(state) {
+  if (!state) {
+    return "KnowledgeLibrary not initialized.";
+  }
+  const lines = [];
+  lines.push(`KnowledgeLibrary: ${state.basePath}
+`);
+  lines.push("Global files:");
+  lines.push(`  - ${basename4(state.contextPath)}`);
+  lines.push(`  - ${basename4(state.architecturePath)}`);
+  lines.push(`  - ${basename4(state.prdPath)}`);
+  lines.push("");
+  if (state.agents.length > 0) {
+    lines.push(`Agents (${state.agents.length}):`);
+    for (const agent of state.agents) {
+      lines.push(`  - ${agent}`);
+    }
+  } else {
+    lines.push("No agents initialized.");
+  }
+  return lines.join("\n");
+}
+function formatAgentKnowledgeState(state) {
+  const lines = [];
+  lines.push(`Agent: ${state.agentName}`);
+  lines.push(`Status: ${state.initialized ? "Initialized" : "Not initialized"}`);
+  lines.push("");
+  if (state.context) {
+    lines.push("Context:");
+    lines.push(`  State: ${state.context.status ?? "unknown"}`);
+    if (state.context.currentTask) {
+      lines.push(`  Current Task: ${state.context.currentTask}`);
+    }
+    if (state.context.currentTicket) {
+      lines.push(`  Current Ticket: ${state.context.currentTicket}`);
+    }
+    lines.push(`  Last Updated: ${state.context.lastUpdated.toISOString()}`);
+    lines.push("");
+  }
+  if (state.pendingMessages.length > 0) {
+    lines.push(`Pending Messages (${state.pendingMessages.length}):`);
+    for (const msg of state.pendingMessages) {
+      const type = msg.metadata.type ?? "unknown";
+      const from = msg.metadata.from ?? "unknown";
+      const subject = msg.metadata.subject ?? msg.filename;
+      lines.push(`  - [${type}] from ${from}: ${subject}`);
+    }
+  } else {
+    lines.push("No pending messages.");
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  AGENT_DIRECTORIES,
+  AdapterError,
+  AdapterFactory,
+  AgentError,
+  CACHE_PATHS,
+  CONTROL_FILES,
+  CacheError,
+  CommandRegistry,
+  ConfigError,
+  ContextLoader,
+  DEFAULT_CACHE_CONFIG,
+  DEFAULT_KNOWLEDGE_LIBRARY_PATH,
+  CacheManager as FileCacheManager,
+  FileCacheProvider,
+  ResolutionError,
+  STANDARD_FILES,
+  StepTracker,
+  VERSION,
+  agentKnowledgeLibraryExists,
+  builtInSkills,
+  checkDependencies,
+  cleanupContext,
+  compileAgent,
+  compileAgents,
+  configExists,
+  createAdapterFactory,
+  createAdapterInfo,
+  createCacheManager,
+  createCommandContext,
+  createCommandRegistry,
+  createContextLoader,
+  createDegradingHandler,
+  createFileCacheProvider,
+  executeWithDegradation,
+  extractVariables2 as extractSkillVariables,
+  extractVariables,
+  filterAgentsByTeam,
+  findConfigFile,
+  formatAgentKnowledgeState,
+  formatGenerateResult,
+  formatKnowledgeLibraryState,
+  generateAgentMarkdown,
+  generateMessageFilename,
+  generateSkills,
+  getAgentDirectories,
+  getAgentKnowledgeState,
+  getConfigPath,
+  getCoreAgentsDir,
+  getGlobalRegistry,
+  getKnowledgeLibraryState,
+  getRoleFromFilename,
+  hasVariables,
+  initAgentKnowledgeLibrary,
+  initKnowledgeLibrary,
+  loadAgentFromFile,
+  loadAgentsFromDirectory,
+  loadAllAgents,
+  loadAllCommands,
+  loadCommandFromFile,
+  loadCommandsFromDirectory,
+  loadConfig,
+  loadConfigFromFile,
+  loadCoreAICommands,
+  loadCustomTemplates,
+  markMessageProcessed,
+  parseAgentYaml,
+  readInboxMessages,
+  resetGlobalRegistry,
+  resolveAgentDefinition,
+  resolveObject,
+  resolveString,
+  runCommand,
+  substituteVariables,
+  updateAgentContext,
+  validateAgentDefinition,
+  withContext,
+  writeInboxMessage
+};
+//# sourceMappingURL=index.js.map