@deimoscloud/coreai 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,4037 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { join as join11, dirname as dirname4 } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// 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 validate2 = ajv.compile(configSchema);
+  const valid = validate2(config);
+  if (!valid) {
+    const errors = validate2.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;
+}
+
+// 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 validate2 = ajv.compile(agentSchema);
+  const valid = validate2(agent);
+  if (!valid) {
+    const errors = validate2.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 agents2 = /* @__PURE__ */ new Map();
+  const files = listYamlFiles(dir);
+  for (const filePath of files) {
+    try {
+      const definition = loadAgentFromFile(filePath);
+      agents2.set(definition.role, {
+        definition,
+        source,
+        filePath
+      });
+    } catch (error) {
+      const fileName = basename(filePath);
+      console.warn(`Warning: Failed to load agent from ${fileName}: ${error.message}`);
+    }
+  }
+  return agents2;
+}
+
+// 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 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 agents2 = /* @__PURE__ */ new Map();
+  if (options.coreAgentsDir && existsSync3(options.coreAgentsDir)) {
+    const coreAgents = loadAgentsFromDirectory(options.coreAgentsDir, "core");
+    for (const [role, metadata] of coreAgents) {
+      agents2.set(role, metadata);
+    }
+  }
+  if (options.customAgentsDir && existsSync3(options.customAgentsDir)) {
+    const customAgents = loadAgentsFromDirectory(options.customAgentsDir, "custom");
+    for (const [role, metadata] of customAgents) {
+      if (agents2.has(role)) {
+        metadata.source = "override";
+      }
+      agents2.set(role, metadata);
+    }
+  }
+  return agents2;
+}
+function filterAgentsByTeam(agents2, config) {
+  if (!config?.team?.agents || config.team.agents.length === 0) {
+    return agents2;
+  }
+  const filtered = /* @__PURE__ */ new Map();
+  for (const role of config.team.agents) {
+    const metadata = agents2.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 agents2 = filterAgentsByTeam(allAgents, config);
+  if (!existsSync3(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  for (const [role, metadata] of agents2) {
+    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;
+}
+
+// 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 status2 = this.getEntryStatus(indexEntry);
+      if (status2 === "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 status2 = this.getEntryStatus(entry);
+      if (status2 === "valid") validEntries++;
+      else if (status2 === "stale") staleEntries++;
+      else if (status2 === "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");
+  }
+};
+
+// 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 status2 = await this.cache.getStatus(key);
+        if (status2 === "valid") {
+          return cached;
+        }
+        if (status2 === "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;
+  }
+};
+
+// 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 join5, basename as basename2 } 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 = join5(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 = basename2(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 ?? join5(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 = join5(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 join6, basename as basename3 } 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 = join6(basePath, agentName);
+  return {
+    root,
+    inbox: join6(root, "inbox"),
+    inboxProcessed: join6(root, "inbox", "processed"),
+    outbox: join6(root, "outbox"),
+    context: join6(root, "context"),
+    control: join6(root, "control"),
+    history: join6(root, "history"),
+    tech: join6(root, "tech")
+  };
+}
+function initKnowledgeLibrary(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join6(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 = join6(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 = join6(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 = join6(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 = join6(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 = join6(dirs.root, dir);
+      if (!existsSync5(dirPath)) {
+        mkdirSync3(dirPath, { recursive: true });
+        createdDirs.push(dirPath);
+      }
+    }
+    if (createDefaults) {
+      const currentContextPath = join6(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 = join6(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 = join6(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 = join6(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 = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const agentRoot = join6(basePath, agentName);
+  return existsSync5(agentRoot) && existsSync5(join6(agentRoot, "inbox"));
+}
+function getAgentKnowledgeState(agentName, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join6(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 = join6(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 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 = join6(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(join6(dirs.inbox, f)).isFile()
+    );
+    for (const file of files) {
+      const filePath = join6(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(join6(dirs.inboxProcessed, f)).isFile()
+    );
+    for (const file of files) {
+      const filePath = join6(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 getKnowledgeLibraryState(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  if (!existsSync5(basePath)) {
+    return null;
+  }
+  const agents2 = [];
+  const entries = readdirSync3(basePath);
+  for (const entry of entries) {
+    const entryPath = join6(basePath, entry);
+    if (statSync2(entryPath).isDirectory() && existsSync5(join6(entryPath, "inbox"))) {
+      agents2.push(entry);
+    }
+  }
+  return {
+    basePath,
+    contextPath: join6(basePath, STANDARD_FILES.context),
+    architecturePath: join6(basePath, STANDARD_FILES.architecture),
+    prdPath: join6(basePath, STANDARD_FILES.prd),
+    agents: agents2
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+// src/cli/commands/cache.ts
+import { join as join7 } from "path";
+function getCachePath(options) {
+  if (options.cachePath) {
+    return options.cachePath;
+  }
+  const root = options.projectRoot ?? process.cwd();
+  return join7(root, CACHE_PATHS.base);
+}
+async function cacheStatus(options = {}) {
+  const cachePath = getCachePath(options);
+  const provider = new FileCacheProvider({ basePath: cachePath });
+  try {
+    await provider.initialize();
+  } catch {
+    return {
+      initialized: false,
+      path: cachePath,
+      stats: null,
+      entries: []
+    };
+  }
+  const stats = await provider.getStats();
+  const metadataList = await provider.list();
+  const entries = await Promise.all(
+    metadataList.map(async (metadata) => {
+      const status2 = await provider.getStatus(metadata.key);
+      return {
+        key: metadata.key,
+        source: metadata.source,
+        status: status2 ?? "unknown",
+        size: metadata.size,
+        cachedAt: metadata.cachedAt,
+        expiresAt: metadata.expiresAt
+      };
+    })
+  );
+  return {
+    initialized: true,
+    path: cachePath,
+    stats,
+    entries
+  };
+}
+async function cacheClear(options = {}) {
+  const cachePath = getCachePath(options);
+  const provider = new FileCacheProvider({ basePath: cachePath });
+  try {
+    await provider.initialize();
+    const cleared = await provider.clear();
+    return { cleared, success: true };
+  } catch (error) {
+    return {
+      cleared: 0,
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function cacheClearExpired(options = {}) {
+  const cachePath = getCachePath(options);
+  const provider = new FileCacheProvider({ basePath: cachePath });
+  try {
+    await provider.initialize();
+    const cleared = await provider.clearExpired();
+    return { cleared, success: true };
+  } catch (error) {
+    return {
+      cleared: 0,
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function formatCacheStatus(result) {
+  const lines = [];
+  lines.push("Cache Status");
+  lines.push("============");
+  lines.push("");
+  if (!result.initialized) {
+    lines.push(`Path: ${result.path}`);
+    lines.push("Status: Not initialized (no cache found)");
+    return lines.join("\n");
+  }
+  lines.push(`Path: ${result.path}`);
+  lines.push("Status: Initialized");
+  lines.push("");
+  if (result.stats) {
+    lines.push("Statistics:");
+    lines.push(`  Entries: ${result.stats.totalEntries}`);
+    lines.push(`  Total size: ${formatBytes(result.stats.totalSize)}`);
+    lines.push(
+      `  Valid: ${result.stats.validEntries}, Stale: ${result.stats.staleEntries}, Expired: ${result.stats.expiredEntries}`
+    );
+    if (result.stats.newestEntry) {
+      lines.push(`  Last updated: ${result.stats.newestEntry}`);
+    }
+  }
+  if (result.entries.length > 0) {
+    lines.push("");
+    lines.push("Entries:");
+    lines.push("");
+    const bySource = /* @__PURE__ */ new Map();
+    for (const entry of result.entries) {
+      const source = entry.source;
+      if (!bySource.has(source)) {
+        bySource.set(source, []);
+      }
+      const entries = bySource.get(source);
+      if (entries) {
+        entries.push(entry);
+      }
+    }
+    for (const [source, entries] of bySource) {
+      lines.push(`  ${source}:`);
+      for (const entry of entries) {
+        const statusIcon = entry.status === "valid" ? "\u2713" : entry.status === "stale" ? "\u25CB" : "\u2717";
+        lines.push(`    ${statusIcon} ${entry.key} (${formatBytes(entry.size)})`);
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("No entries in cache.");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/sync.ts
+import { join as join8 } from "path";
+function createPlaceholderFetcher(source) {
+  return {
+    async fetch(url) {
+      throw new Error(
+        `No fetcher implementation for source "${source}". URL: ${url}. Configure a documentation provider in coreai.config.yaml.`
+      );
+    },
+    async hasChanged(_url, _etag) {
+      return true;
+    }
+  };
+}
+function getCachePath2(options) {
+  if (options.cachePath) {
+    return options.cachePath;
+  }
+  const root = options.projectRoot ?? process.cwd();
+  return join8(root, CACHE_PATHS.base);
+}
+async function sync(options = {}) {
+  const cachePath = getCachePath2(options);
+  const provider = new FileCacheProvider({ basePath: cachePath });
+  try {
+    await provider.initialize();
+  } catch (error) {
+    return {
+      success: false,
+      result: null,
+      error: `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
+      sources: []
+    };
+  }
+  const entries = await provider.list({ source: options.source });
+  if (entries.length === 0) {
+    return {
+      success: true,
+      result: {
+        added: 0,
+        updated: 0,
+        removed: 0,
+        failed: 0,
+        errors: [],
+        duration: 0
+      },
+      sources: []
+    };
+  }
+  const manager = new CacheManager({
+    cache: provider,
+    defaultTtl: 3600
+  });
+  const sources = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    sources.add(entry.source);
+  }
+  for (const source of sources) {
+    if (!manager.hasFetcher(source)) {
+      manager.registerFetcher(source, createPlaceholderFetcher(source));
+    }
+  }
+  const keys = entries.map((e) => e.key);
+  if (options.onProgress) {
+    options.onProgress(0, keys.length, "Starting sync...");
+  }
+  try {
+    const result = await manager.syncEntries(keys, {
+      force: options.force,
+      continueOnError: options.continueOnError ?? true,
+      concurrency: options.concurrency ?? 5,
+      onProgress: (completed, total) => {
+        if (options.onProgress) {
+          options.onProgress(completed, total, `Syncing ${completed}/${total} entries...`);
+        }
+      }
+    });
+    return {
+      success: result.failed === 0 || options.continueOnError === true,
+      result,
+      sources: Array.from(sources)
+    };
+  } catch (error) {
+    return {
+      success: false,
+      result: null,
+      error: error instanceof Error ? error.message : String(error),
+      sources: Array.from(sources)
+    };
+  }
+}
+function formatSyncResult(result) {
+  const lines = [];
+  lines.push("Sync Results");
+  lines.push("============");
+  lines.push("");
+  if (!result.success && result.error) {
+    lines.push(`Error: ${result.error}`);
+    return lines.join("\n");
+  }
+  if (!result.result) {
+    lines.push("No sync operation performed.");
+    return lines.join("\n");
+  }
+  const r = result.result;
+  if (r.added === 0 && r.updated === 0 && r.removed === 0 && r.failed === 0) {
+    lines.push("Cache is empty. Nothing to sync.");
+    lines.push("");
+    lines.push("Tip: Add context sources to your coreai.config.yaml to fetch remote content.");
+    return lines.join("\n");
+  }
+  lines.push(`Duration: ${r.duration}ms`);
+  lines.push("");
+  if (result.sources.length > 0) {
+    lines.push(`Sources: ${result.sources.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("Summary:");
+  if (r.added > 0) lines.push(`  \u2713 Added: ${r.added}`);
+  if (r.updated > 0) lines.push(`  \u2713 Updated: ${r.updated}`);
+  if (r.removed > 0) lines.push(`  \u25CB Removed: ${r.removed}`);
+  if (r.failed > 0) lines.push(`  \u2717 Failed: ${r.failed}`);
+  if (r.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const err of r.errors.slice(0, 10)) {
+      lines.push(`  - ${err.key}: ${err.error}`);
+    }
+    if (r.errors.length > 10) {
+      lines.push(`  ... and ${r.errors.length - 10} more errors`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/init.ts
+import { existsSync as existsSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join9, basename as basename4 } from "path";
+import { execSync } from "child_process";
+function detectGitInfo() {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+    const httpsMatch = remoteUrl.match(/https:\/\/github\.com\/([^/]+)\/([^/.]+)/);
+    if (httpsMatch) {
+      return { provider: "github", owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^/.]+)/);
+    if (sshMatch) {
+      return { provider: "github", owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    const gitlabHttps = remoteUrl.match(/https:\/\/gitlab\.com\/([^/]+)\/([^/.]+)/);
+    if (gitlabHttps) {
+      return { provider: "gitlab", owner: gitlabHttps[1], repo: gitlabHttps[2] };
+    }
+    const gitlabSsh = remoteUrl.match(/git@gitlab\.com:([^/]+)\/([^/.]+)/);
+    if (gitlabSsh) {
+      return { provider: "gitlab", owner: gitlabSsh[1], repo: gitlabSsh[2] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function detectProjectName(projectRoot) {
+  const packageJsonPath = join9(projectRoot, "package.json");
+  if (existsSync6(packageJsonPath)) {
+    try {
+      const content = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+      if (content.name) {
+        return content.name;
+      }
+    } catch {
+    }
+  }
+  return basename4(projectRoot);
+}
+function generateConfigYaml(options) {
+  let yaml = `# CoreAI Configuration
+# See https://coreai.dev/docs/config for full schema
+
+version: "1.0"
+
+project:
+  name: "${options.name}"
+  type: ${options.type}
+
+team:
+  agents:
+    - backend-engineer
+    - frontend-engineer
+    - devops-engineer
+    - engineering-manager
+`;
+  if (options.gitInfo?.provider) {
+    yaml += `
+integrations:
+  git:
+    provider: ${options.gitInfo.provider}
+    config:
+      owner: "${options.gitInfo.owner}"
+      repo: "${options.gitInfo.repo}"
+`;
+  }
+  yaml += `
+# quality_gates:
+#   lint:
+#     command: npm run lint
+#     required: true
+#   test:
+#     command: npm test
+#     required: true
+#   build:
+#     command: npm run build
+#     required: true
+
+# tech_stack:
+#   primary_language: typescript
+#   frameworks:
+#     - node.js
+#     - express
+`;
+  return yaml;
+}
+function createDirectories(projectRoot) {
+  const dirs = [
+    join9(projectRoot, "coreai", "agents"),
+    join9(projectRoot, "coreai", "commands"),
+    join9(projectRoot, ".coreai", "cache")
+  ];
+  const created = [];
+  for (const dir of dirs) {
+    if (!existsSync6(dir)) {
+      mkdirSync4(dir, { recursive: true });
+      created.push(dir);
+    }
+  }
+  return created;
+}
+function init(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  if (configExists(projectRoot) && !options.force) {
+    return {
+      success: false,
+      error: "CoreAI configuration already exists. Use --force to overwrite."
+    };
+  }
+  const gitInfo = detectGitInfo();
+  const name = options.name ?? detectProjectName(projectRoot);
+  const type = options.type ?? "software";
+  const configContent = generateConfigYaml({ name, type, gitInfo });
+  const configPath = join9(projectRoot, "coreai.config.yaml");
+  try {
+    writeFileSync4(configPath, configContent, "utf-8");
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to write config file: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let createdDirs = [];
+  if (!options.skipDirs) {
+    try {
+      createdDirs = createDirectories(projectRoot);
+    } catch (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to create directories: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  return {
+    success: true,
+    configPath,
+    createdDirs,
+    gitInfo: gitInfo ?? void 0
+  };
+}
+function formatInitResult(result) {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+  const lines = [];
+  lines.push("CoreAI project initialized successfully!\n");
+  if (result.configPath) {
+    lines.push(`Created: ${result.configPath}`);
+  }
+  if (result.createdDirs && result.createdDirs.length > 0) {
+    lines.push("\nCreated directories:");
+    for (const dir of result.createdDirs) {
+      lines.push(`  - ${dir}`);
+    }
+  }
+  if (result.gitInfo?.provider) {
+    lines.push(
+      `
+Detected ${result.gitInfo.provider} repository: ${result.gitInfo.owner}/${result.gitInfo.repo}`
+    );
+  }
+  lines.push("\nNext steps:");
+  lines.push("  1. Edit coreai.config.yaml to configure your project");
+  lines.push("  2. Run `coreai build` to compile agents");
+  lines.push("  3. Run `coreai validate` to check your setup");
+  return lines.join("\n");
+}
+
+// src/cli/commands/build.ts
+function build(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings = [];
+  let config;
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        return {
+          success: false,
+          error: `Configuration error: ${error.message}`
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  } else {
+    warnings.push("No configuration file found. Building with defaults.");
+  }
+  const compileOptions = {
+    projectRoot
+  };
+  if (options.coreAgentsDir) {
+    compileOptions.coreAgentsDir = options.coreAgentsDir;
+  }
+  if (options.outputDir) {
+    compileOptions.outputDir = options.outputDir;
+  }
+  if (options.agents && options.agents.length > 0) {
+    const agentsList = options.agents;
+    compileOptions.filter = (agent) => agentsList.includes(agent.role);
+  }
+  try {
+    const result = compileAgents(config, compileOptions);
+    if (result.errors.length > 0) {
+      return {
+        success: false,
+        result,
+        config,
+        error: `Failed to compile ${result.errors.length} agent(s)`,
+        warnings
+      };
+    }
+    let knowledgeLibraryInitialized;
+    if (options.initKnowledgeLibrary) {
+      knowledgeLibraryInitialized = [];
+      for (const compiled of result.compiled) {
+        const initResult = initAgentKnowledgeLibrary(compiled.role, {
+          projectRoot,
+          createDefaults: true
+        });
+        if (initResult.success && initResult.createdDirs.length > 0) {
+          knowledgeLibraryInitialized.push(compiled.role);
+        }
+      }
+    }
+    return {
+      success: true,
+      result,
+      config,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      knowledgeLibraryInitialized
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Build failed: ${error instanceof Error ? error.message : String(error)}`,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+}
+function formatBuildResult(result) {
+  const lines = [];
+  if (result.warnings && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      lines.push(`\u26A0 ${warning}`);
+    }
+    lines.push("");
+  }
+  if (!result.success) {
+    lines.push(`Build failed: ${result.error}`);
+    if (result.result?.errors && result.result.errors.length > 0) {
+      lines.push("");
+      for (const error of result.result.errors) {
+        lines.push(`  \u2717 ${error.role}: ${error.error}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  const compileResult = result.result;
+  if (!compileResult) {
+    lines.push("No agents to compile.");
+    return lines.join("\n");
+  }
+  if (compileResult.compiled.length === 0) {
+    lines.push("No agents to compile.");
+    return lines.join("\n");
+  }
+  lines.push(`Compiled ${compileResult.compiled.length} agent(s):
+`);
+  const coreAgents = compileResult.compiled.filter((a) => a.source === "core");
+  const customAgents = compileResult.compiled.filter((a) => a.source === "custom");
+  const overrideAgents = compileResult.compiled.filter((a) => a.source === "override");
+  if (coreAgents.length > 0) {
+    lines.push("Core agents:");
+    for (const agent of coreAgents) {
+      lines.push(`  \u2713 ${agent.role}`);
+      lines.push(`    \u2192 ${agent.outputPath}`);
+    }
+    lines.push("");
+  }
+  if (customAgents.length > 0) {
+    lines.push("Custom agents:");
+    for (const agent of customAgents) {
+      lines.push(`  \u2713 ${agent.role}`);
+      lines.push(`    \u2192 ${agent.outputPath}`);
+    }
+    lines.push("");
+  }
+  if (overrideAgents.length > 0) {
+    lines.push("Override agents:");
+    for (const agent of overrideAgents) {
+      lines.push(`  \u2713 ${agent.role} (overrides core)`);
+      lines.push(`    \u2192 ${agent.outputPath}`);
+    }
+    lines.push("");
+  }
+  if (result.knowledgeLibraryInitialized && result.knowledgeLibraryInitialized.length > 0) {
+    lines.push(
+      `KnowledgeLibrary initialized for ${result.knowledgeLibraryInitialized.length} agent(s):`
+    );
+    for (const agent of result.knowledgeLibraryInitialized) {
+      lines.push(`  \u2713 ${agent}`);
+    }
+    lines.push("");
+  }
+  lines.push("Build complete!");
+  return lines.join("\n");
+}
+
+// src/cli/commands/validate.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
+function validateConfig2(projectRoot) {
+  const issues = [];
+  if (!configExists(projectRoot)) {
+    issues.push({
+      level: "error",
+      category: "config",
+      message: "No CoreAI configuration file found",
+      fix: "Run `coreai init` to create a configuration file"
+    });
+    return { issues };
+  }
+  try {
+    const config = loadConfig(projectRoot);
+    return { config, issues };
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      issues.push({
+        level: "error",
+        category: "config",
+        message: `Configuration error: ${error.message}`,
+        fix: "Check coreai.config.yaml for syntax errors"
+      });
+    } else {
+      issues.push({
+        level: "error",
+        category: "config",
+        message: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+    return { issues };
+  }
+}
+function validateAgents(config, coreAgentsDir, projectRoot) {
+  const issues = [];
+  const customAgentsDir = join10(projectRoot, "coreai", "agents");
+  let availableAgents;
+  try {
+    availableAgents = loadAllAgents({
+      coreAgentsDir,
+      customAgentsDir
+    });
+  } catch (error) {
+    issues.push({
+      level: "warning",
+      category: "agents",
+      message: `Could not load agents: ${error instanceof Error ? error.message : String(error)}`
+    });
+    return issues;
+  }
+  const configuredAgents = config.team.agents;
+  for (const agentRole of configuredAgents) {
+    if (!availableAgents.has(agentRole)) {
+      issues.push({
+        level: "error",
+        category: "agents",
+        message: `Configured agent '${agentRole}' not found`,
+        fix: `Add agent definition to coreai/agents/${agentRole}.yaml or remove from config`
+      });
+    }
+  }
+  const unconfigured = Array.from(availableAgents.keys()).filter(
+    (role) => !configuredAgents.includes(role)
+  );
+  if (unconfigured.length > 0) {
+    issues.push({
+      level: "info",
+      category: "agents",
+      message: `${unconfigured.length} available agent(s) not configured: ${unconfigured.join(", ")}`
+    });
+  }
+  return issues;
+}
+function validateDirectories(projectRoot) {
+  const issues = [];
+  const requiredDirs = [{ path: "coreai", description: "CoreAI configuration directory" }];
+  const optionalDirs = [
+    { path: "coreai/agents", description: "Custom agent definitions" },
+    { path: "coreai/commands", description: "Custom command definitions" },
+    { path: ".coreai", description: "CoreAI runtime directory" },
+    { path: ".coreai/cache", description: "Cache directory" },
+    { path: ".claude/agents", description: "Compiled agents output" }
+  ];
+  for (const dir of requiredDirs) {
+    const fullPath = join10(projectRoot, dir.path);
+    if (!existsSync7(fullPath)) {
+      issues.push({
+        level: "warning",
+        category: "directories",
+        message: `Missing directory: ${dir.path} (${dir.description})`,
+        fix: `Run mkdir -p ${dir.path}`
+      });
+    }
+  }
+  for (const dir of optionalDirs) {
+    const fullPath = join10(projectRoot, dir.path);
+    if (!existsSync7(fullPath)) {
+      issues.push({
+        level: "info",
+        category: "directories",
+        message: `Optional directory not found: ${dir.path} (${dir.description})`
+      });
+    }
+  }
+  return issues;
+}
+function validateIntegrations(config) {
+  const issues = [];
+  if (!config.integrations) {
+    issues.push({
+      level: "info",
+      category: "integrations",
+      message: "No integrations configured"
+    });
+    return issues;
+  }
+  if (config.integrations.git) {
+    const git = config.integrations.git;
+    if (!git.config?.owner || !git.config?.repo) {
+      issues.push({
+        level: "warning",
+        category: "integrations",
+        message: "Git integration configured but owner/repo not specified",
+        fix: "Add integrations.git.config.owner and integrations.git.config.repo to config"
+      });
+    }
+  }
+  if (config.integrations.issue_tracker) {
+    const tracker = config.integrations.issue_tracker;
+    if (tracker.provider === "jira" && !tracker.config?.base_url) {
+      issues.push({
+        level: "warning",
+        category: "integrations",
+        message: "Jira integration configured but base_url not specified",
+        fix: "Add integrations.issue_tracker.config.base_url to config"
+      });
+    }
+  }
+  return issues;
+}
+function validate(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const coreAgentsDir = options.coreAgentsDir ?? join10(projectRoot, "node_modules", "@coreai", "cli", "agents");
+  const checkAgents = options.checkAgents ?? true;
+  const checkDirs = options.checkDirs ?? true;
+  const allIssues = [];
+  const { config, issues: configIssues } = validateConfig2(projectRoot);
+  allIssues.push(...configIssues);
+  if (config) {
+    if (checkAgents) {
+      allIssues.push(...validateAgents(config, coreAgentsDir, projectRoot));
+    }
+    allIssues.push(...validateIntegrations(config));
+  }
+  if (checkDirs) {
+    allIssues.push(...validateDirectories(projectRoot));
+  }
+  const summary = {
+    errors: allIssues.filter((i) => i.level === "error").length,
+    warnings: allIssues.filter((i) => i.level === "warning").length,
+    info: allIssues.filter((i) => i.level === "info").length
+  };
+  return {
+    success: true,
+    valid: summary.errors === 0,
+    config,
+    issues: allIssues,
+    summary
+  };
+}
+function formatValidateResult(result) {
+  const lines = [];
+  if (result.valid) {
+    lines.push("\u2713 Configuration is valid\n");
+  } else {
+    lines.push("\u2717 Configuration has errors\n");
+  }
+  const categories = ["config", "agents", "integrations", "directories", "quality_gates"];
+  for (const category of categories) {
+    const categoryIssues = result.issues.filter((i) => i.category === category);
+    if (categoryIssues.length === 0) continue;
+    const categoryLabel = category.charAt(0).toUpperCase() + category.slice(1).replace("_", " ");
+    lines.push(`${categoryLabel}:`);
+    for (const issue of categoryIssues) {
+      const prefix = issue.level === "error" ? "  \u2717" : issue.level === "warning" ? "  \u26A0" : "  \u2139";
+      lines.push(`${prefix} ${issue.message}`);
+      if (issue.fix) {
+        lines.push(`    \u2192 ${issue.fix}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("Summary:");
+  lines.push(`  Errors: ${result.summary.errors}`);
+  lines.push(`  Warnings: ${result.summary.warnings}`);
+  lines.push(`  Info: ${result.summary.info}`);
+  return lines.join("\n");
+}
+
+// src/cli/commands/skills.ts
+function skillsGenerate(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings = [];
+  let config;
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        return {
+          success: false,
+          error: `Configuration error: ${error.message}`
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  } else {
+    warnings.push("No configuration file found. Generating skills with defaults.");
+  }
+  const generateOptions = {
+    projectRoot,
+    includeCoreSkills: options.includeCoreSkills ?? true,
+    includeOptionalSkills: options.includeOptionalSkills ?? true,
+    overwrite: options.overwrite ?? false
+  };
+  if (options.outputDir) {
+    generateOptions.outputDir = options.outputDir;
+  }
+  if (options.customTemplatesDir) {
+    generateOptions.customTemplatesDir = options.customTemplatesDir;
+  }
+  if (options.skills && options.skills.length > 0) {
+    generateOptions.skills = options.skills;
+  }
+  if (options.variables) {
+    generateOptions.variables = options.variables;
+  }
+  try {
+    const result = generateSkills(config, generateOptions);
+    if (result.errors.length > 0) {
+      return {
+        success: false,
+        result,
+        config,
+        error: `Failed to generate ${result.errors.length} skill(s)`,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+    return {
+      success: true,
+      result,
+      config,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Skill generation failed: ${error instanceof Error ? error.message : String(error)}`,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+}
+function formatSkillsGenerateResult(result) {
+  const lines = [];
+  if (result.warnings && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      lines.push(`\u26A0 ${warning}`);
+    }
+    lines.push("");
+  }
+  if (!result.success) {
+    lines.push(`Skill generation failed: ${result.error}`);
+    if (result.result?.errors && result.result.errors.length > 0) {
+      lines.push("");
+      for (const error of result.result.errors) {
+        lines.push(`  \u2717 ${error.name}: ${error.error}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  if (result.result) {
+    return formatGenerateResult(result.result);
+  }
+  lines.push("No skills to generate.");
+  return lines.join("\n");
+}
+function skillsList(options = {}) {
+  try {
+    const skills = [];
+    const includeCoreSkills = options.includeCoreSkills ?? true;
+    const includeOptionalSkills = options.includeOptionalSkills ?? true;
+    for (const skill of builtInSkills) {
+      if (skill.category === "core" && !includeCoreSkills) continue;
+      if (skill.category === "optional" && !includeOptionalSkills) continue;
+      skills.push({
+        name: skill.name,
+        description: skill.description,
+        category: skill.category,
+        dependencies: skill.dependencies?.filter((d) => d.required).map((d) => d.type),
+        argumentHint: skill.argumentHint
+      });
+    }
+    if (options.customTemplatesDir) {
+      const customSkills = loadCustomTemplates(options.customTemplatesDir);
+      for (const skill of customSkills) {
+        skills.push({
+          name: skill.name,
+          description: skill.description,
+          category: skill.category,
+          dependencies: skill.dependencies?.filter((d) => d.required).map((d) => d.type),
+          argumentHint: skill.argumentHint
+        });
+      }
+    }
+    return {
+      success: true,
+      skills
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to list skills: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function formatSkillsListResult(result) {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+  if (!result.skills || result.skills.length === 0) {
+    return "No skills available.";
+  }
+  const lines = [];
+  lines.push("Available skills:\n");
+  const coreSkills = result.skills.filter((s) => s.category === "core");
+  const optionalSkills = result.skills.filter((s) => s.category === "optional");
+  const customSkills = result.skills.filter((s) => s.category === "custom");
+  if (coreSkills.length > 0) {
+    lines.push("Core skills:");
+    for (const skill of coreSkills) {
+      lines.push(`  ${skill.name}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push("");
+  }
+  if (optionalSkills.length > 0) {
+    lines.push("Optional skills:");
+    for (const skill of optionalSkills) {
+      const deps = skill.dependencies?.length ? ` (requires: ${skill.dependencies.join(", ")})` : "";
+      lines.push(`  ${skill.name}${deps}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push("");
+  }
+  if (customSkills.length > 0) {
+    lines.push("Custom skills:");
+    for (const skill of customSkills) {
+      lines.push(`  ${skill.name}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/status.ts
+function status(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings = [];
+  let config;
+  let configuredAgents = [];
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+      if (config.team?.agents) {
+        configuredAgents = config.team.agents;
+      }
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        warnings.push(`Configuration error: ${error.message}`);
+      } else {
+        warnings.push(
+          `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  } else {
+    warnings.push("No configuration file found.");
+  }
+  let klState = getKnowledgeLibraryState({ projectRoot });
+  if (!klState && options.init) {
+    const initResult = initKnowledgeLibrary({ projectRoot, createDefaults: true });
+    if (initResult.success) {
+      klState = getKnowledgeLibraryState({ projectRoot });
+    } else {
+      return {
+        success: false,
+        agents: [],
+        error: `Failed to initialize KnowledgeLibrary: ${initResult.error}`,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+  }
+  if (!klState) {
+    return {
+      success: true,
+      agents: [],
+      warnings: [
+        ...warnings,
+        "KnowledgeLibrary not initialized. Run `coreai status --init` to create it."
+      ]
+    };
+  }
+  let agentsToCheck;
+  if (options.agent) {
+    agentsToCheck = [options.agent];
+  } else {
+    agentsToCheck = [.../* @__PURE__ */ new Set([...configuredAgents, ...klState.agents])];
+  }
+  const agentStatuses = [];
+  for (const agentName of agentsToCheck) {
+    const agentState = getAgentKnowledgeState(agentName, { projectRoot });
+    const agentStatus = {
+      name: agentName,
+      initialized: agentState.initialized,
+      pendingMessages: agentState.pendingMessages.length
+    };
+    if (agentState.context) {
+      agentStatus.status = agentState.context.status;
+      agentStatus.currentTask = agentState.context.currentTask;
+      agentStatus.currentTicket = agentState.context.currentTicket;
+      agentStatus.lastActivity = agentState.context.lastUpdated;
+    }
+    if (options.detailed && agentState.pendingMessages.length > 0) {
+      agentStatus.messageDetails = agentState.pendingMessages.map((msg) => ({
+        type: msg.metadata.type ?? "unknown",
+        from: msg.metadata.from ?? "unknown",
+        subject: msg.metadata.subject ?? msg.filename,
+        date: msg.metadata.date
+      }));
+    }
+    agentStatuses.push(agentStatus);
+  }
+  agentStatuses.sort((a, b) => {
+    if (b.pendingMessages !== a.pendingMessages) {
+      return b.pendingMessages - a.pendingMessages;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return {
+    success: true,
+    knowledgeLibrary: klState,
+    agents: agentStatuses,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function formatStatusResult(result) {
+  const lines = [];
+  if (result.warnings && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      lines.push(`\u26A0 ${warning}`);
+    }
+    lines.push("");
+  }
+  if (!result.success) {
+    lines.push(`Error: ${result.error}`);
+    return lines.join("\n");
+  }
+  if (result.agents.length === 0) {
+    lines.push("No agents found.");
+    return lines.join("\n");
+  }
+  lines.push("Agent Status\n");
+  const activeAgents = result.agents.filter((a) => a.status === "working");
+  const idleAgents = result.agents.filter(
+    (a) => a.initialized && (!a.status || a.status === "idle")
+  );
+  const uninitializedAgents = result.agents.filter((a) => !a.initialized);
+  const totalPending = result.agents.reduce((sum, a) => sum + a.pendingMessages, 0);
+  lines.push(`Total agents: ${result.agents.length}`);
+  if (activeAgents.length > 0) {
+    lines.push(`  Active: ${activeAgents.length}`);
+  }
+  if (idleAgents.length > 0) {
+    lines.push(`  Idle: ${idleAgents.length}`);
+  }
+  if (uninitializedAgents.length > 0) {
+    lines.push(`  Not initialized: ${uninitializedAgents.length}`);
+  }
+  if (totalPending > 0) {
+    lines.push(`  Total pending messages: ${totalPending}`);
+  }
+  lines.push("");
+  for (const agent of result.agents) {
+    const statusIcon = !agent.initialized ? "\u25CB" : agent.pendingMessages > 0 ? "\u25CF" : "\u25CE";
+    const statusText = !agent.initialized ? "not initialized" : agent.status ?? "idle";
+    lines.push(`${statusIcon} ${agent.name}`);
+    lines.push(`    Status: ${statusText}`);
+    if (agent.currentTask) {
+      lines.push(`    Task: ${agent.currentTask}`);
+    }
+    if (agent.currentTicket) {
+      lines.push(`    Ticket: ${agent.currentTicket}`);
+    }
+    if (agent.pendingMessages > 0) {
+      lines.push(`    Pending messages: ${agent.pendingMessages}`);
+      if (agent.messageDetails && agent.messageDetails.length > 0) {
+        for (const msg of agent.messageDetails) {
+          const dateStr = msg.date ? msg.date.toISOString().slice(0, 16).replace("T", " ") : "";
+          lines.push(`      - [${msg.type}] from ${msg.from}: ${msg.subject}`);
+          if (dateStr) {
+            lines.push(`        ${dateStr}`);
+          }
+        }
+      }
+    }
+    if (agent.lastActivity) {
+      const activityStr = agent.lastActivity.toISOString().slice(0, 16).replace("T", " ");
+      lines.push(`    Last activity: ${activityStr}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname4(__filename);
+function getCoreAgentsPath() {
+  return join11(__dirname, "..", "..", "agents");
+}
+var program = new Command();
+program.name("coreai").description("A configurable, team-ready AI agent orchestration platform").version(VERSION, "-v, --version", "output the current version");
+program.command("init").description("Initialize a new CoreAI project").option("-f, --force", "overwrite existing configuration").option("-n, --name <name>", "project name").option("-t, --type <type>", "project type (software, infrastructure, data, mobile)").option("--skip-dirs", "skip creating directory structure").action((options) => {
+  const result = init({
+    projectRoot: process.cwd(),
+    force: options.force,
+    name: options.name,
+    type: options.type,
+    skipDirs: options.skipDirs
+  });
+  console.log(formatInitResult(result));
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+program.command("build").description("Compile agent definitions to Claude-compatible markdown").option("-w, --watch", "watch for changes and rebuild").option("-o, --output <dir>", "output directory (default: .claude/agents)").option("--agents <agents>", "comma-separated list of agents to build").option("--init-knowledge-library", "initialize KnowledgeLibrary directories for agents").action(
+  (options) => {
+    if (options.watch) {
+      console.log("Watch mode is not yet implemented");
+      process.exit(1);
+    }
+    console.log("Building agents...\n");
+    const result = build({
+      projectRoot: process.cwd(),
+      coreAgentsDir: getCoreAgentsPath(),
+      outputDir: options.output,
+      agents: options.agents?.split(",").map((a) => a.trim()),
+      initKnowledgeLibrary: options.initKnowledgeLibrary
+    });
+    console.log(formatBuildResult(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+  }
+);
+program.command("sync").description("Sync shared context from remote sources").option("--force", "force refresh all cached content").option("--source <source>", "filter by source (github, confluence, notion)").option("--concurrency <n>", "max concurrent fetches", "5").action(async (options) => {
+  try {
+    console.log("Syncing shared context...\n");
+    const result = await sync({
+      projectRoot: process.cwd(),
+      force: options.force,
+      source: options.source,
+      concurrency: parseInt(options.concurrency ?? "5", 10),
+      continueOnError: true,
+      onProgress: (completed, total, message) => {
+        process.stdout.write(`\r${message}`);
+      }
+    });
+    process.stdout.write("\r" + " ".repeat(60) + "\r");
+    console.log(formatSyncResult(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Sync failed: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate configuration and project setup").option("--skip-agents", "skip agent validation").option("--skip-dirs", "skip directory validation").option("--json", "output as JSON").action((options) => {
+  const result = validate({
+    projectRoot: process.cwd(),
+    coreAgentsDir: getCoreAgentsPath(),
+    checkAgents: !options.skipAgents,
+    checkDirs: !options.skipDirs
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatValidateResult(result));
+  }
+  if (!result.valid) {
+    process.exit(1);
+  }
+});
+var agents = program.command("agents").description("Manage agent definitions");
+agents.command("list").description("List available agents").option("--core", "show only core agents").option("--custom", "show only custom agents").action((options) => {
+  try {
+    const customAgentsDir = join11(process.cwd(), "coreai", "agents");
+    const allAgents = loadAllAgents({
+      coreAgentsDir: getCoreAgentsPath(),
+      customAgentsDir
+    });
+    if (allAgents.size === 0) {
+      console.log("No agents found.");
+      return;
+    }
+    const agents2 = Array.from(allAgents.entries()).filter(([, meta]) => {
+      if (options.core && meta.source !== "core") return false;
+      if (options.custom && meta.source !== "custom" && meta.source !== "override") return false;
+      return true;
+    });
+    if (agents2.length === 0) {
+      console.log("No matching agents found.");
+      return;
+    }
+    console.log("Available agents:\n");
+    const coreAgents = agents2.filter(([, m]) => m.source === "core");
+    const customAgents = agents2.filter(([, m]) => m.source === "custom");
+    const overrideAgents = agents2.filter(([, m]) => m.source === "override");
+    if (coreAgents.length > 0 && !options.custom) {
+      console.log("Core agents:");
+      for (const [role, meta] of coreAgents) {
+        console.log(`  ${role} (${meta.definition.type})`);
+        console.log(`    ${meta.definition.display_name}`);
+      }
+      console.log();
+    }
+    if (customAgents.length > 0 && !options.core) {
+      console.log("Custom agents:");
+      for (const [role, meta] of customAgents) {
+        console.log(`  ${role} (${meta.definition.type})`);
+        console.log(`    ${meta.definition.display_name}`);
+      }
+      console.log();
+    }
+    if (overrideAgents.length > 0 && !options.core) {
+      console.log("Override agents:");
+      for (const [role, meta] of overrideAgents) {
+        console.log(`  ${role} (${meta.definition.type})`);
+        console.log(`    ${meta.definition.display_name} [overrides core]`);
+      }
+      console.log();
+    }
+    console.log(`Total: ${agents2.length} agent(s)`);
+  } catch (error) {
+    console.error(`Failed to list agents: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+});
+agents.command("show <name>").description("Show details for a specific agent").option("--markdown", "output as compiled markdown").option("--json", "output as JSON").action((name, options) => {
+  try {
+    const customAgentsDir = join11(process.cwd(), "coreai", "agents");
+    const allAgents = loadAllAgents({
+      coreAgentsDir: getCoreAgentsPath(),
+      customAgentsDir
+    });
+    const agentMeta = allAgents.get(name);
+    if (!agentMeta) {
+      console.error(`Agent not found: ${name}`);
+      console.log("\nAvailable agents:");
+      for (const role of allAgents.keys()) {
+        console.log(`  - ${role}`);
+      }
+      process.exit(1);
+    }
+    const agent = agentMeta.definition;
+    if (options.json) {
+      console.log(JSON.stringify(agent, null, 2));
+      return;
+    }
+    if (options.markdown) {
+      console.log(generateAgentMarkdown(agent));
+      return;
+    }
+    console.log(`
+${agent.display_name}`);
+    console.log("=".repeat(agent.display_name.length));
+    console.log();
+    console.log(`Role: ${agent.role}`);
+    console.log(`Type: ${agent.type}`);
+    console.log(`Source: ${agentMeta.source}`);
+    console.log();
+    console.log("Description:");
+    console.log(`  ${agent.description}`);
+    if (agent.responsibilities && agent.responsibilities.length > 0) {
+      console.log();
+      console.log("Responsibilities:");
+      for (const r of agent.responsibilities) {
+        console.log(`  - ${r}`);
+      }
+    }
+    if (agent.expertise?.primary && agent.expertise.primary.length > 0) {
+      console.log();
+      console.log("Expertise:");
+      for (const e of agent.expertise.primary) {
+        console.log(`  - ${e}`);
+      }
+    }
+    if (agent.skills && agent.skills.length > 0) {
+      console.log();
+      console.log("Skills:");
+      for (const s of agent.skills) {
+        console.log(`  - ${s}`);
+      }
+    }
+    if (agent.behaviors?.workflow) {
+      console.log();
+      console.log(`Workflow: ${agent.behaviors.workflow}`);
+    }
+    console.log();
+    console.log(`File: ${agentMeta.filePath}`);
+  } catch (error) {
+    console.error(`Failed to show agent: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+});
+var cacheCmd = program.command("cache").description("Manage local cache");
+cacheCmd.command("clear").description("Clear the local cache").option("--expired", "only clear expired entries").option("--json", "output as JSON").action(async (options) => {
+  try {
+    const result = options.expired ? await cacheClearExpired({ projectRoot: process.cwd() }) : await cacheClear({ projectRoot: process.cwd() });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.success) {
+      console.error(`Failed to clear cache: ${result.error}`);
+      process.exit(1);
+    }
+    if (result.cleared === 0) {
+      console.log("Cache is already empty.");
+    } else {
+      const word = result.cleared === 1 ? "entry" : "entries";
+      console.log(`Cleared ${result.cleared} cache ${word}.`);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : error;
+    console.error(`Failed to clear cache: ${msg}`);
+    process.exit(1);
+  }
+});
+cacheCmd.command("status").description("Show cache status").option("--json", "output as JSON").action(async (options) => {
+  try {
+    const result = await cacheStatus({ projectRoot: process.cwd() });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(formatCacheStatus(result));
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : error;
+    console.error(`Failed to get cache status: ${msg}`);
+    process.exit(1);
+  }
+});
+program.command("status").description("Show agent states and pending messages").option("-a, --agent <name>", "show status for a specific agent").option("-d, --detailed", "show detailed message information").option("--init", "initialize KnowledgeLibrary if not exists").option("--json", "output as JSON").action((options) => {
+  const result = status({
+    projectRoot: process.cwd(),
+    agent: options.agent,
+    detailed: options.detailed,
+    init: options.init
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatStatusResult(result));
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+var skillsCmd = program.command("skills").description("Manage Claude skills");
+skillsCmd.command("generate").description("Generate Claude skills from templates").option("-o, --output <dir>", "output directory (default: .claude/commands)").option("--skills <skills>", "comma-separated list of skills to generate").option("--no-core", "exclude core skills").option("--no-optional", "exclude optional skills").option("--overwrite", "overwrite existing skill files").option("--json", "output as JSON").action(
+  (options) => {
+    console.log("Generating skills...\n");
+    const result = skillsGenerate({
+      projectRoot: process.cwd(),
+      outputDir: options.output,
+      skills: options.skills?.split(",").map((s) => s.trim()),
+      includeCoreSkills: options.core !== false,
+      includeOptionalSkills: options.optional !== false,
+      overwrite: options.overwrite
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(formatSkillsGenerateResult(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+  }
+);
+skillsCmd.command("list").description("List available skills").option("--no-core", "exclude core skills").option("--no-optional", "exclude optional skills").option("--json", "output as JSON").action((options) => {
+  const result = skillsList({
+    projectRoot: process.cwd(),
+    includeCoreSkills: options.core !== false,
+    includeOptionalSkills: options.optional !== false
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatSkillsListResult(result));
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map