@venthezone/everything-opencode-plugin 1.0.0

package/dist/index.js

@@ -0,0 +1,2476 @@
+// ../essential-opencode/src/types/index.ts
+var DEFAULT_CONFIG = {
+  components: {
+    agents: true,
+    commands: true,
+    skills: true,
+    workflows: true,
+    hooks: true
+  },
+  performance: {
+    lazyLoad: true,
+    cacheResults: true,
+    maxConcurrency: 5
+  },
+  development: {
+    enableDebug: false,
+    verboseLogging: false,
+    enableTelemetry: false
+  },
+  defaults: {
+    temperature: 0.7,
+    maxTokens: 4000
+  }
+};
+// ../essential-opencode/src/utils/logger.ts
+class Logger {
+  context;
+  logLevel = 2 /* INFO */;
+  logHistory = [];
+  maxHistorySize = 1000;
+  constructor(context, logLevel) {
+    this.context = context;
+    if (logLevel) {
+      this.logLevel = logLevel;
+    } else if (this.context.config.development?.enableDebug) {
+      this.logLevel = 3 /* DEBUG */;
+    }
+  }
+  debug(message, data) {
+    this.log(3 /* DEBUG */, message, data);
+  }
+  info(message, data) {
+    this.log(2 /* INFO */, message, data);
+  }
+  warn(message, data) {
+    this.log(1 /* WARN */, message, data);
+  }
+  error(message, error) {
+    this.log(0 /* ERROR */, message, error);
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level))
+      return;
+    const entry = {
+      timestamp: new Date,
+      level,
+      message,
+      data: this.sanitizeData(data),
+      sessionId: this.context.session.id
+    };
+    this.logHistory.push(entry);
+    if (this.logHistory.length > this.maxHistorySize) {
+      this.logHistory = this.logHistory.slice(-this.maxHistorySize / 2);
+    }
+    this.outputLog(entry);
+  }
+  shouldLog(level) {
+    return level >= this.logLevel;
+  }
+  outputLog(entry) {
+    const timestamp = entry.timestamp.toISOString();
+    const levelStr = LogLevel[entry.level].padEnd(5);
+    const sessionId = entry.sessionId.substring(0, 8);
+    let output = `[${timestamp}] [${levelStr}] [${sessionId}] ${entry.message}`;
+    if (entry.data) {
+      output += `
+` + this.formatData(entry.data);
+    }
+    switch (entry.level) {
+      case 0 /* ERROR */:
+        console.error(output);
+        break;
+      case 1 /* WARN */:
+        console.warn(output);
+        break;
+      case 3 /* DEBUG */:
+        if (this.context.config.development?.verboseLogging) {
+          console.log(output);
+        }
+        break;
+      default:
+        console.log(output);
+    }
+  }
+  formatData(data) {
+    try {
+      return JSON.stringify(data, null, 2);
+    } catch (error) {
+      return `[Unserializable data: ${typeof data}]`;
+    }
+  }
+  sanitizeData(data) {
+    if (!data)
+      return data;
+    if (typeof data === "string") {
+      return this.maskSensitiveStrings(data);
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => this.sanitizeData(item));
+    }
+    if (typeof data === "object") {
+      const sanitized = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (this.isSensitiveKey(key)) {
+          sanitized[key] = "[REDACTED]";
+        } else {
+          sanitized[key] = this.sanitizeData(value);
+        }
+      }
+      return sanitized;
+    }
+    return data;
+  }
+  maskSensitiveStrings(str) {
+    const sensitivePatterns = [
+      /password["\s:]+["\s]*[\w\-]+/gi,
+      /token["\s:]+["\s]*[\w\-\.]+/gi,
+      /secret["\s:]+["\s]*[\w\-]+/gi,
+      /key["\s:]+["\s]*[\w\-]+/gi,
+      /auth["\s:]+["\s]*[\w\-]+/gi
+    ];
+    let result = str;
+    for (const pattern of sensitivePatterns) {
+      result = result.replace(pattern, (match) => {
+        return match.replace(/[\w\-\.]+$/, "***");
+      });
+    }
+    return result;
+  }
+  isSensitiveKey(key) {
+    const sensitiveKeys = [
+      "password",
+      "passwd",
+      "pwd",
+      "token",
+      "secret",
+      "key",
+      "auth",
+      "authorization",
+      "credential",
+      "credentials",
+      "private",
+      "confidential"
+    ];
+    return sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive));
+  }
+  getHistory(level, limit) {
+    let filtered = this.logHistory;
+    if (level !== undefined) {
+      filtered = filtered.filter((entry) => entry.level === level);
+    }
+    if (limit) {
+      filtered = filtered.slice(-limit);
+    }
+    return filtered.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  }
+  getStats() {
+    const levelCounts = new Map;
+    for (const entry of this.logHistory) {
+      levelCounts.set(entry.level, (levelCounts.get(entry.level) || 0) + 1);
+    }
+    const now = new Date;
+    const recentEntries = this.logHistory.filter((entry) => now.getTime() - entry.timestamp.getTime() < 60 * 60 * 1000);
+    return {
+      totalEntries: this.logHistory.length,
+      entriesByLevel: Object.fromEntries(levelCounts),
+      recentEntries: recentEntries.length,
+      currentLevel: LogLevel[this.logLevel],
+      oldestEntry: this.logHistory.length > 0 ? this.logHistory[0].timestamp : null,
+      newestEntry: this.logHistory.length > 0 ? this.logHistory[this.logHistory.length - 1].timestamp : null
+    };
+  }
+  clearHistory() {
+    this.logHistory = [];
+    this.info("Log history cleared");
+  }
+  exportLogs() {
+    return {
+      logs: this.logHistory,
+      exportTime: new Date,
+      sessionId: this.context.session.id,
+      stats: this.getStats()
+    };
+  }
+  child(additionalContext) {
+    return new Logger({
+      ...this.context,
+      session: {
+        ...this.context.session,
+        context: {
+          ...this.context.session.context,
+          ...additionalContext
+        }
+      }
+    }, this.logLevel);
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+    this.info(`Log level changed to: ${LogLevel[level]}`);
+  }
+  setDebugMode(enabled) {
+    if (enabled) {
+      this.setLogLevel(3 /* DEBUG */);
+    } else {
+      this.setLogLevel(2 /* INFO */);
+    }
+  }
+  time(label) {
+    const startTime = Date.now();
+    this.debug(`Timer started: ${label}`);
+    return () => {
+      const duration = Date.now() - startTime;
+      this.debug(`Timer finished: ${label} (${duration}ms)`);
+    };
+  }
+  logMemoryUsage(label) {
+    try {
+      const usage = process.memoryUsage();
+      const message = label ? `Memory usage (${label})` : "Memory usage";
+      this.debug(message, {
+        rss: this.formatBytes(usage.rss),
+        heapTotal: this.formatBytes(usage.heapTotal),
+        heapUsed: this.formatBytes(usage.heapUsed),
+        external: this.formatBytes(usage.external)
+      });
+    } catch (error) {
+      this.debug("Could not get memory usage", error);
+    }
+  }
+  formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+  }
+  async writeToFile(filePath) {
+    try {
+      const logData = this.exportLogs();
+      await this.context.$`mkdir -p ${this.context.workspace.root}/.opencode/logs`;
+      await this.context.$`echo ${JSON.stringify(logData, null, 2)} > ${filePath}`;
+      this.info(`Logs written to: ${filePath}`);
+    } catch (error) {
+      this.error(`Failed to write logs to file: ${filePath}`, error);
+    }
+  }
+}
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
+})(LogLevel ||= {});
+// ../essential-opencode/src/utils/tool-registry.ts
+class ToolRegistry {
+  context;
+  logger;
+  tools = new Map;
+  categories = new Map;
+  metadata = new Map;
+  constructor(context, logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      this.logger.warn(`Tool ${tool.name} is already registered, overwriting...`);
+    }
+    this.tools.set(tool.name, tool);
+    const category = this.extractCategory(tool);
+    if (!this.categories.has(category)) {
+      this.categories.set(category, new Set);
+    }
+    this.categories.get(category).add(tool.name);
+    this.logger.debug(`Registered tool: ${tool.name} (${category})`);
+  }
+  unregister(id) {
+    const tool = this.tools.get(id);
+    if (tool) {
+      const category = this.extractCategory(tool);
+      this.categories.get(category)?.delete(id);
+      this.tools.delete(id);
+      this.logger.debug(`Unregistered tool: ${id}`);
+    }
+  }
+  get(id) {
+    return this.tools.get(id);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  filter(category) {
+    const toolNames = this.categories.get(category);
+    if (!toolNames)
+      return [];
+    return Array.from(toolNames).map((name) => this.tools.get(name)).filter(Boolean);
+  }
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.list().filter((tool) => tool.name.toLowerCase().includes(lowerQuery) || tool.description.toLowerCase().includes(lowerQuery));
+  }
+  getByCapability(capability) {
+    return this.list().filter((tool) => tool.parameters && Object.values(tool.parameters).some((param) => typeof param === "object" && param && ("description" in param) && param.description?.toLowerCase().includes(capability.toLowerCase())));
+  }
+  extractCategory(tool) {
+    if (tool.parameters && "category" in tool.parameters) {
+      return tool.parameters.category || "general";
+    }
+    if (tool.name.includes("-")) {
+      const parts = tool.name.split("-");
+      if (parts.length > 1) {
+        return parts[0];
+      }
+    }
+    if (tool.name.startsWith("code-"))
+      return "code";
+    if (tool.name.startsWith("test-"))
+      return "testing";
+    if (tool.name.startsWith("security-"))
+      return "security";
+    if (tool.name.startsWith("build-"))
+      return "build";
+    if (tool.name.startsWith("refactor-"))
+      return "refactoring";
+    if (tool.name.startsWith("update-"))
+      return "maintenance";
+    return "general";
+  }
+  getStats() {
+    const categoryStats = Array.from(this.categories.entries()).map(([category, tools]) => ({
+      category,
+      count: tools.size
+    }));
+    return {
+      totalTools: this.tools.size,
+      categories: categoryStats,
+      tools: this.list().map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        category: this.extractCategory(tool)
+      }))
+    };
+  }
+}
+// ../essential-opencode/src/utils/agent-registry.ts
+class AgentRegistry {
+  context;
+  logger;
+  agents = new Map;
+  capabilities = new Map;
+  constructor(context, logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  register(agent) {
+    if (this.agents.has(agent.id)) {
+      this.logger.warn(`Agent ${agent.id} is already registered, overwriting...`);
+    }
+    this.agents.set(agent.id, agent);
+    for (const capability of agent.capabilities) {
+      if (!this.capabilities.has(capability)) {
+        this.capabilities.set(capability, new Set);
+      }
+      this.capabilities.get(capability).add(agent.id);
+    }
+    this.logger.debug(`Registered agent: ${agent.name} (${agent.capabilities.join(", ")})`);
+  }
+  unregister(id) {
+    const agent = this.agents.get(id);
+    if (agent) {
+      for (const capability of agent.capabilities) {
+        this.capabilities.get(capability)?.delete(id);
+      }
+      this.agents.delete(id);
+      this.logger.debug(`Unregistered agent: ${id}`);
+    }
+  }
+  get(id) {
+    return this.agents.get(id);
+  }
+  list() {
+    return Array.from(this.agents.values());
+  }
+  filter(capability) {
+    const agentIds = this.capabilities.get(capability);
+    if (!agentIds)
+      return [];
+    return Array.from(agentIds).map((id) => this.agents.get(id)).filter(Boolean);
+  }
+  findByCapabilities(capabilities) {
+    if (capabilities.length === 0)
+      return this.list();
+    return this.list().filter((agent) => capabilities.every((cap) => agent.capabilities.includes(cap)));
+  }
+  findByAnyCapability(capabilities) {
+    if (capabilities.length === 0)
+      return [];
+    const agentIds = new Set;
+    for (const capability of capabilities) {
+      const ids = this.capabilities.get(capability);
+      if (ids) {
+        for (const id of ids) {
+          agentIds.add(id);
+        }
+      }
+    }
+    return Array.from(agentIds).map((id) => this.agents.get(id)).filter(Boolean);
+  }
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.list().filter((agent) => agent.name.toLowerCase().includes(lowerQuery) || agent.description.toLowerCase().includes(lowerQuery) || agent.capabilities.some((cap) => cap.toLowerCase().includes(lowerQuery)));
+  }
+  getBestAgent(task, requiredCapabilities) {
+    let candidates = this.list();
+    if (requiredCapabilities && requiredCapabilities.length > 0) {
+      candidates = this.findByCapabilities(requiredCapabilities);
+    }
+    if (candidates.length === 0)
+      return;
+    if (candidates.length === 1)
+      return candidates[0];
+    const taskLower = task.toLowerCase();
+    const scored = candidates.map((agent) => {
+      let score = 0;
+      if (agent.name.toLowerCase().includes(taskLower))
+        score += 10;
+      if (taskLower.includes(agent.name.toLowerCase()))
+        score += 5;
+      if (agent.description.toLowerCase().includes(taskLower))
+        score += 3;
+      const matchingCapabilities = agent.capabilities.filter((cap) => cap.toLowerCase().includes(taskLower) || taskLower.includes(cap.toLowerCase()));
+      score += matchingCapabilities.length * 2;
+      score += (10 - agent.capabilities.length) * 0.5;
+      return { agent, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0].agent;
+  }
+  getAllCapabilities() {
+    return Array.from(this.capabilities.keys()).sort();
+  }
+  getByCategory(category) {
+    const categoryKeywords = {
+      development: ["code", "development", "programming"],
+      testing: ["test", "testing", "qa"],
+      security: ["security", "audit", "vulnerability"],
+      documentation: ["doc", "documentation", "readme"],
+      architecture: ["architect", "design", "structure"],
+      automation: ["automation", "script", "workflow"]
+    };
+    const keywords = categoryKeywords[category] || [category];
+    const lowerKeywords = keywords.map((k) => k.toLowerCase());
+    return this.list().filter((agent) => lowerKeywords.some((keyword) => agent.name.toLowerCase().includes(keyword) || agent.description.toLowerCase().includes(keyword) || agent.capabilities.some((cap) => cap.toLowerCase().includes(keyword))));
+  }
+  getStats() {
+    const capabilityStats = Array.from(this.capabilities.entries()).map(([capability, agents]) => ({
+      capability,
+      count: agents.size
+    })).sort((a, b) => b.count - a.count);
+    return {
+      totalAgents: this.agents.size,
+      totalCapabilities: this.capabilities.size,
+      topCapabilities: capabilityStats.slice(0, 10),
+      agents: this.list().map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        description: agent.description,
+        capabilities: agent.capabilities,
+        tools: agent.tools || []
+      }))
+    };
+  }
+}
+// ../essential-opencode/src/utils/skill-registry.ts
+class SkillRegistry {
+  context;
+  logger;
+  skills = new Map;
+  categories = new Map;
+  expertise = new Map;
+  constructor(context, logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  register(skill) {
+    if (this.skills.has(skill.id)) {
+      this.logger.warn(`Skill ${skill.id} is already registered, overwriting...`);
+    }
+    this.skills.set(skill.id, skill);
+    if (!this.categories.has(skill.category)) {
+      this.categories.set(skill.category, new Set);
+    }
+    this.categories.get(skill.category).add(skill.id);
+    for (const exp of skill.expertise) {
+      if (!this.expertise.has(exp)) {
+        this.expertise.set(exp, new Set);
+      }
+      this.expertise.get(exp).add(skill.id);
+    }
+    this.logger.debug(`Registered skill: ${skill.name} (${skill.category}: ${skill.expertise.join(", ")})`);
+  }
+  unregister(id) {
+    const skill = this.skills.get(id);
+    if (skill) {
+      this.categories.get(skill.category)?.delete(id);
+      for (const exp of skill.expertise) {
+        this.expertise.get(exp)?.delete(id);
+      }
+      this.skills.delete(id);
+      this.logger.debug(`Unregistered skill: ${id}`);
+    }
+  }
+  get(id) {
+    return this.skills.get(id);
+  }
+  list() {
+    return Array.from(this.skills.values());
+  }
+  filter(category) {
+    const skillIds = this.categories.get(category);
+    if (!skillIds)
+      return [];
+    return Array.from(skillIds).map((id) => this.skills.get(id)).filter(Boolean);
+  }
+  findByExpertise(expertise) {
+    const skillIds = this.expertise.get(expertise);
+    if (!skillIds)
+      return [];
+    return Array.from(skillIds).map((id) => this.skills.get(id)).filter(Boolean);
+  }
+  findByMultipleExpertise(expertiseAreas) {
+    if (expertiseAreas.length === 0)
+      return this.list();
+    return this.list().filter((skill) => expertiseAreas.every((exp) => skill.expertise.includes(exp)));
+  }
+  findByAnyExpertise(expertiseAreas) {
+    if (expertiseAreas.length === 0)
+      return [];
+    const skillIds = new Set;
+    for (const exp of expertiseAreas) {
+      const ids = this.expertise.get(exp);
+      if (ids) {
+        for (const id of ids) {
+          skillIds.add(id);
+        }
+      }
+    }
+    return Array.from(skillIds).map((id) => this.skills.get(id)).filter(Boolean);
+  }
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.list().filter((skill) => skill.name.toLowerCase().includes(lowerQuery) || skill.description.toLowerCase().includes(lowerQuery) || skill.category.toLowerCase().includes(lowerQuery) || skill.expertise.some((exp) => exp.toLowerCase().includes(lowerQuery)) || skill.patterns?.some((pattern) => pattern.toLowerCase().includes(lowerQuery)));
+  }
+  getBestSkill(task, requiredExpertise) {
+    let candidates = this.list();
+    if (requiredExpertise && requiredExpertise.length > 0) {
+      candidates = this.findByMultipleExpertise(requiredExpertise);
+    }
+    if (candidates.length === 0)
+      return;
+    if (candidates.length === 1)
+      return candidates[0];
+    const taskLower = task.toLowerCase();
+    const scored = candidates.map((skill) => {
+      let score = 0;
+      if (skill.name.toLowerCase().includes(taskLower))
+        score += 10;
+      if (taskLower.includes(skill.name.toLowerCase()))
+        score += 5;
+      if (skill.description.toLowerCase().includes(taskLower))
+        score += 3;
+      const matchingExpertise = skill.expertise.filter((exp) => exp.toLowerCase().includes(taskLower) || taskLower.includes(exp.toLowerCase()));
+      score += matchingExpertise.length * 4;
+      if (skill.patterns) {
+        const matchingPatterns = skill.patterns.filter((pattern) => pattern.toLowerCase().includes(taskLower));
+        score += matchingPatterns.length * 2;
+      }
+      if (skill.category.toLowerCase().includes(taskLower))
+        score += 2;
+      return { skill, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0].skill;
+  }
+  getAllCategories() {
+    return Array.from(this.categories.keys()).sort();
+  }
+  getAllExpertise() {
+    return Array.from(this.expertise.keys()).sort();
+  }
+  getRelatedSkills(skillId) {
+    const skill = this.get(skillId);
+    if (!skill)
+      return [];
+    return this.list().filter((s) => s.id !== skillId && (s.category === skill.category || s.expertise.some((exp) => skill.expertise.includes(exp))));
+  }
+  getByTechnology(technology) {
+    const techLower = technology.toLowerCase();
+    return this.list().filter((skill) => skill.name.toLowerCase().includes(techLower) || skill.description.toLowerCase().includes(techLower) || skill.expertise.some((exp) => exp.toLowerCase().includes(techLower)) || skill.patterns?.some((pattern) => pattern.toLowerCase().includes(techLower)));
+  }
+  getSkillsForAgent(agentId, agent) {
+    const allowedSkills = agent?.allowedSkills;
+    if (!allowedSkills || allowedSkills.length === 0) {
+      this.logger.debug(`Agent ${agentId} has access to all ${this.skills.size} skills`);
+      return this.list();
+    }
+    const filtered = this.list().filter((skill) => allowedSkills.includes(skill.id));
+    this.logger.debug(`Agent ${agentId} has scoped access to ${filtered.length}/${this.skills.size} skills: [${allowedSkills.join(", ")}]`);
+    const existingSkillIds = new Set(this.list().map((s) => s.id));
+    const missingSkills = allowedSkills.filter((id) => !existingSkillIds.has(id));
+    if (missingSkills.length > 0) {
+      this.logger.warn(`Agent ${agentId} references non-existent skills: [${missingSkills.join(", ")}]`);
+    }
+    return filtered;
+  }
+  getStats() {
+    const categoryStats = Array.from(this.categories.entries()).map(([category, skills]) => ({
+      category,
+      count: skills.size
+    })).sort((a, b) => b.count - a.count);
+    const expertiseStats = Array.from(this.expertise.entries()).map(([expertise, skills]) => ({
+      expertise,
+      count: skills.size
+    })).sort((a, b) => b.count - a.count);
+    return {
+      totalSkills: this.skills.size,
+      totalCategories: this.categories.size,
+      totalExpertiseAreas: this.expertise.size,
+      topCategories: categoryStats.slice(0, 10),
+      topExpertiseAreas: expertiseStats.slice(0, 10),
+      skills: this.list().map((skill) => ({
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        category: skill.category,
+        expertise: skill.expertise,
+        patternCount: skill.patterns?.length || 0,
+        exampleCount: skill.examples?.length || 0
+      }))
+    };
+  }
+}
+// ../essential-opencode/src/utils/workflow-engine.ts
+class WorkflowEngine {
+  context;
+  toolRegistry;
+  logger;
+  workflows = new Map;
+  runningWorkflows = new Map;
+  constructor(context, toolRegistry, logger) {
+    this.context = context;
+    this.toolRegistry = toolRegistry;
+    this.logger = logger;
+  }
+  register(workflow) {
+    if (this.workflows.has(workflow.id)) {
+      this.logger.warn(`Workflow ${workflow.id} is already registered, overwriting...`);
+    }
+    this.workflows.set(workflow.id, workflow);
+    this.logger.debug(`Registered workflow: ${workflow.name} (${workflow.steps.length} steps)`);
+  }
+  unregister(id) {
+    this.workflows.delete(id);
+    this.logger.debug(`Unregistered workflow: ${id}`);
+  }
+  get(id) {
+    return this.workflows.get(id);
+  }
+  list() {
+    return Array.from(this.workflows.values());
+  }
+  async execute(workflowId, inputContext) {
+    const workflow = this.get(workflowId);
+    if (!workflow) {
+      return {
+        success: false,
+        error: `Workflow ${workflowId} not found`,
+        executionId: crypto.randomUUID()
+      };
+    }
+    const executionId = crypto.randomUUID();
+    this.logger.info(`Starting workflow execution: ${workflow.name} (${executionId})`);
+    const executionContext = {
+      workflow,
+      startTime: new Date,
+      currentStep: 0,
+      context: { ...inputContext, workflowId, executionId }
+    };
+    this.runningWorkflows.set(executionId, executionContext);
+    try {
+      await this.context.sessionManager?.createCheckpoint("workflow-start", `Started workflow: ${workflow.name}`, "automatic", { workflowId, executionId, inputContext });
+      const result = await this.executeSteps(workflow, executionContext);
+      await this.context.sessionManager?.createCheckpoint("workflow-complete", `Completed workflow: ${workflow.name}`, "automatic", {
+        workflowId,
+        executionId,
+        success: result.success,
+        duration: Date.now() - executionContext.startTime.getTime()
+      });
+      this.logger.info(`Workflow execution completed: ${workflow.name} (${executionId})`);
+      return {
+        ...result,
+        executionId
+      };
+    } catch (error) {
+      this.logger.error(`Workflow execution failed: ${workflow.name} (${executionId})`, error);
+      await this.context.sessionManager?.createCheckpoint("workflow-error", `Failed workflow: ${workflow.name}`, "error", {
+        workflowId,
+        executionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        executionId
+      };
+    } finally {
+      this.runningWorkflows.delete(executionId);
+    }
+  }
+  async executeSteps(workflow, executionContext) {
+    let stepResult = {};
+    let stepContext = { ...executionContext.context };
+    for (let i = 0;i < workflow.steps.length; i++) {
+      const step = workflow.steps[i];
+      executionContext.currentStep = i;
+      this.logger.debug(`Executing step ${i + 1}/${workflow.steps.length}: ${step.name}`);
+      try {
+        if (step.condition && !this.evaluateCondition(step.condition, stepContext)) {
+          this.logger.debug(`Skipping step ${step.name} - condition not met`);
+          continue;
+        }
+        const result = await this.executeStep(step, stepContext, workflow);
+        if (!result.success) {
+          if (step.onError === "continue") {
+            this.logger.warn(`Step ${step.name} failed, continuing workflow`);
+            continue;
+          } else if (step.onError === "retry") {
+            this.logger.info(`Retrying step ${step.name}`);
+            i--;
+            continue;
+          } else {
+            return {
+              success: false,
+              error: `Step ${step.name} failed: ${result.error}`,
+              completedSteps: i,
+              stepResult
+            };
+          }
+        }
+        stepResult = { ...stepResult, [step.id]: result.result };
+        stepContext = { ...stepContext, ...result.result, stepResult };
+      } catch (error) {
+        this.logger.error(`Step execution error: ${step.name}`, error);
+        if (step.onError === "continue") {
+          continue;
+        } else {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            completedSteps: i,
+            stepResult
+          };
+        }
+      }
+    }
+    return {
+      success: true,
+      result: stepResult
+    };
+  }
+  async executeStep(step, context, workflow) {
+    try {
+      switch (step.type) {
+        case "tool":
+          return await this.executeToolStep(step, context);
+        case "agent":
+          return await this.executeAgentStep(step, context);
+        case "condition":
+          return await this.executeConditionStep(step, context);
+        case "loop":
+          return await this.executeLoopStep(step, context, workflow);
+        default:
+          return {
+            success: false,
+            error: `Unknown step type: ${step.type}`
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async executeToolStep(step, context) {
+    const toolName = step.config.tool;
+    const tool = this.toolRegistry.get(toolName);
+    if (!tool) {
+      return {
+        success: false,
+        error: `Tool ${toolName} not found`
+      };
+    }
+    this.logger.debug(`Executing tool: ${toolName}`);
+    try {
+      const args = this.substituteVariables(step.config.args || {}, context);
+      const result = await tool.execute(args, {
+        ...this.context,
+        signal: new AbortController().signal
+      });
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async executeAgentStep(step, context) {
+    const agentName = step.config.agent;
+    const prompt = this.substituteVariables(step.config.prompt || "", context);
+    this.logger.debug(`Executing agent: ${agentName}`);
+    try {
+      const result = await this.context.task({
+        description: step.config.description || `Execute ${agentName} agent`,
+        prompt: this.createAgentPrompt(agentName, prompt, step.config, context),
+        subagent_type: "general"
+      });
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async executeConditionStep(step, context) {
+    const condition = this.substituteVariables(step.config.condition, context);
+    const result = this.evaluateCondition(condition, context);
+    return {
+      success: true,
+      result: { condition, result }
+    };
+  }
+  async executeLoopStep(step, context, workflow) {
+    const iterations = step.config.iterations || 1;
+    const loopSteps = step.config.steps || [];
+    const loopResults = [];
+    this.logger.debug(`Executing loop: ${iterations} iterations`);
+    for (let i = 0;i < iterations; i++) {
+      const loopContext = { ...context, loopIndex: i };
+      const loopResult = {};
+      for (const loopStep of loopSteps) {
+        const result = await this.executeStep(loopStep, loopContext, workflow);
+        if (!result.success) {
+          return {
+            success: false,
+            error: `Loop step ${loopStep.name} failed on iteration ${i}: ${result.error}`
+          };
+        }
+        loopResult[loopStep.id] = result.result;
+      }
+      loopResults.push(loopResult);
+    }
+    return {
+      success: true,
+      result: { loopResults, iterations }
+    };
+  }
+  evaluateCondition(condition, context) {
+    try {
+      const evaluated = condition.replace(/\{(\w+)\}/g, (match, key) => {
+        return JSON.stringify(context[key] || "");
+      });
+      const fn = new Function("return " + evaluated);
+      return Boolean(fn());
+    } catch (error) {
+      this.logger.error(`Condition evaluation failed: ${condition}`, error);
+      return false;
+    }
+  }
+  substituteVariables(input, context) {
+    if (typeof input === "string") {
+      return input.replace(/\{(\w+)\}/g, (match, key) => {
+        return context[key] !== undefined ? String(context[key]) : match;
+      });
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.substituteVariables(item, context));
+    }
+    if (typeof input === "object" && input !== null) {
+      const result = {};
+      for (const [key, value] of Object.entries(input)) {
+        result[key] = this.substituteVariables(value, context);
+      }
+      return result;
+    }
+    return input;
+  }
+  createAgentPrompt(agentName, prompt, config, context) {
+    return `
+You are acting as the ${agentName} agent within a workflow execution context.
+
+${prompt}
+
+Context:
+${JSON.stringify(context, null, 2)}
+
+Configuration:
+${JSON.stringify(config, null, 2)}
+
+Please execute this task according to the agent's specialized capabilities and return the results in a structured format.
+    `.trim();
+  }
+  getRunningWorkflows() {
+    return Array.from(this.runningWorkflows.entries()).map(([executionId, running]) => ({
+      executionId,
+      workflow: running.workflow,
+      startTime: running.startTime,
+      currentStep: running.currentStep,
+      totalSteps: running.workflow.steps.length
+    }));
+  }
+  async stopWorkflow(executionId) {
+    const running = this.runningWorkflows.get(executionId);
+    if (!running)
+      return false;
+    this.logger.info(`Stopping workflow execution: ${executionId}`);
+    this.runningWorkflows.delete(executionId);
+    await this.context.sessionManager?.createCheckpoint("workflow-stop", `Stopped workflow: ${running.workflow.name}`, "automatic", {
+      workflowId: running.workflow.id,
+      executionId,
+      stoppedAt: new Date,
+      currentStep: running.currentStep
+    });
+    return true;
+  }
+  getStats() {
+    return {
+      totalWorkflows: this.workflows.size,
+      runningWorkflows: this.runningWorkflows.size,
+      workflows: this.list().map((workflow) => ({
+        id: workflow.id,
+        name: workflow.name,
+        description: workflow.description,
+        steps: workflow.steps.length,
+        triggers: workflow.triggers || [],
+        dependencies: workflow.dependencies || []
+      })),
+      runningDetails: this.getRunningWorkflows()
+    };
+  }
+  findByTrigger(trigger) {
+    return this.list().filter((workflow) => workflow.triggers?.includes(trigger));
+  }
+  async executeByTrigger(trigger, context) {
+    const workflows = this.findByTrigger(trigger);
+    const results = [];
+    for (const workflow of workflows) {
+      const result = await this.execute(workflow.id, context);
+      results.push({
+        workflowId: workflow.id,
+        executionId: result.executionId,
+        success: result.success,
+        error: result.error
+      });
+    }
+    return results;
+  }
+}
+// ../essential-opencode/src/utils/session-manager.ts
+class SessionManager {
+  context;
+  logger;
+  checkpoints = [];
+  lastCheckpointTime = 0;
+  constructor(context, logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  async initialize() {
+    this.logger.info("Initializing session manager...");
+    await this.loadSessionData();
+    await this.createCheckpoint("initial", "Session started", "automatic");
+    this.logger.info("Session manager initialized");
+  }
+  async onSessionStart(input, output) {
+    this.logger.info(`Session ${this.context.session.id} started`);
+    this.context.session.startTime = new Date;
+    await this.createCheckpoint("session-start", "OpenCode session initialized", "automatic", {
+      input,
+      output,
+      workspace: this.context.workspace
+    });
+  }
+  async onSessionEnd(input, output) {
+    this.logger.info(`Session ${this.context.session.id} ending`);
+    await this.createCheckpoint("session-end", "OpenCode session ended", "automatic", {
+      input,
+      output,
+      duration: Date.now() - this.context.session.startTime.getTime(),
+      checkpointCount: this.checkpoints.length
+    });
+    await this.saveSessionData();
+    this.logger.info("Session manager cleaned up");
+  }
+  async createCheckpoint(type, description, checkpointType = "manual", additionalContext) {
+    const checkpoint = {
+      id: crypto.randomUUID(),
+      timestamp: new Date,
+      type: checkpointType,
+      description,
+      context: {
+        ...this.context.session.context,
+        type,
+        ...additionalContext
+      },
+      state: this.captureState()
+    };
+    this.checkpoints.push(checkpoint);
+    this.lastCheckpointTime = Date.now();
+    this.logger.debug(`Created checkpoint: ${checkpoint.type} - ${checkpoint.description}`);
+    if (this.checkpoints.length > 100) {
+      this.checkpoints = this.checkpoints.slice(-50);
+    }
+    return checkpoint;
+  }
+  getRecentCheckpoints(count = 10) {
+    return this.checkpoints.slice(-count).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  }
+  getCheckpoint(id) {
+    return this.checkpoints.find((cp) => cp.id === id);
+  }
+  async restoreFromCheckpoint(checkpointId) {
+    const checkpoint = this.getCheckpoint(checkpointId);
+    if (!checkpoint) {
+      this.logger.error(`Checkpoint ${checkpointId} not found`);
+      return false;
+    }
+    this.logger.info(`Restoring session from checkpoint: ${checkpoint.description}`);
+    this.context.session.context = { ...checkpoint.context };
+    await this.createCheckpoint("restore", `Restored from ${checkpointId}`, "automatic", {
+      restoredFrom: checkpointId,
+      restoredAt: new Date
+    });
+    return true;
+  }
+  async autoCheckpoint(description) {
+    const now = Date.now();
+    const timeSinceLastCheckpoint = now - this.lastCheckpointTime;
+    if (timeSinceLastCheckpoint < 5 * 60 * 1000) {
+      return;
+    }
+    await this.createCheckpoint("auto", description || "Automatic checkpoint", "automatic", {
+      timeSinceLastCheckpoint,
+      lastCheckpoint: this.checkpoints[this.checkpoints.length - 1]?.id
+    });
+  }
+  getSessionSummary() {
+    const now = new Date;
+    return {
+      id: this.context.session.id,
+      startTime: this.context.session.startTime,
+      duration: now.getTime() - this.context.session.startTime.getTime(),
+      checkpointCount: this.checkpoints.length,
+      lastActivity: new Date(this.lastCheckpointTime)
+    };
+  }
+  exportSessionData() {
+    return {
+      session: {
+        id: this.context.session.id,
+        startTime: this.context.session.startTime,
+        checkpoints: this.checkpoints,
+        context: this.context.session.context
+      },
+      workspace: this.context.workspace,
+      exportTime: new Date
+    };
+  }
+  async importSessionData(data) {
+    try {
+      this.context.session.id = data.session.id || crypto.randomUUID();
+      this.context.session.startTime = new Date(data.session.startTime || Date.now());
+      this.checkpoints = data.session.checkpoints || [];
+      this.context.session.context = data.session.context || {};
+      this.logger.info(`Imported session data: ${this.checkpoints.length} checkpoints`);
+      await this.createCheckpoint("import", "Session data imported", "automatic", {
+        importedAt: new Date,
+        originalSessionId: data.session.id
+      });
+    } catch (error) {
+      this.logger.error("Failed to import session data", error);
+    }
+  }
+  captureState() {
+    return {
+      timestamp: Date.now(),
+      workspace: this.context.workspace,
+      sessionContext: { ...this.context.session.context }
+    };
+  }
+  async saveSessionData() {
+    try {
+      const sessionFile = `${this.context.workspace.root}/.opencode/session-${this.context.session.id}.json`;
+      const sessionData = this.exportSessionData();
+      await this.context.$`mkdir -p ${this.context.workspace.root}/.opencode`;
+      await this.context.$`echo ${JSON.stringify(sessionData, null, 2)} > ${sessionFile}`;
+      this.logger.debug(`Session data saved to ${sessionFile}`);
+    } catch (error) {
+      this.logger.error("Failed to save session data", error);
+    }
+  }
+  async loadSessionData() {
+    try {
+      const sessionFile = `${this.context.workspace.root}/.opencode/session-${this.context.session.id}.json`;
+      const result = await this.context.$`test -f ${sessionFile}`.quiet().nothrow();
+      const fileExists = result.exitCode === 0;
+      if (!fileExists)
+        return;
+      const sessionData = await this.context.$`cat ${sessionFile}`.text();
+      const parsed = JSON.parse(sessionData);
+      await this.importSessionData(parsed);
+      this.logger.info(`Loaded session data from ${sessionFile}`);
+    } catch (error) {
+      this.logger.error("Failed to load session data", error);
+    }
+  }
+  async cleanupOldSessions(maxAge = 7 * 24 * 60 * 60 * 1000) {
+    try {
+      const sessionDir = `${this.context.workspace.root}/.opencode`;
+      const now = Date.now();
+      const sessionFiles = await this.context.$`ls ${sessionDir}/session-*.json 2>/dev/null || true`.text().trim().split(`
+`).filter(Boolean);
+      for (const file of sessionFiles) {
+        const fileStats = await this.context.$`stat -c %Y ${file}`.text().trim();
+        const fileTime = parseInt(fileStats) * 1000;
+        if (now - fileTime > maxAge) {
+          await this.context.$`rm ${file}`;
+          this.logger.debug(`Removed old session file: ${file}`);
+        }
+      }
+    } catch (error) {
+      this.logger.error("Failed to cleanup old sessions", error);
+    }
+  }
+}
+// ../essential-opencode/src/utils/hook-manager.ts
+class HookManager {
+  context;
+  logger;
+  hooks = new Map;
+  eventHistory = [];
+  constructor(context, logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  async beforeToolExecute(input, output) {
+    const startTime = Date.now();
+    try {
+      this.logger.debug(`Before tool execute: ${input.tool}`);
+      if (this.shouldCreateCheckpoint(input.tool)) {
+        await this.context.sessionManager?.createCheckpoint("tool-before", `Before ${input.tool}`, "automatic", { tool: input.tool, args: input.args });
+      }
+      this.logToolUsage(input, "before");
+      await this.validateToolExecution(input);
+    } catch (error) {
+      this.logger.error("Error in beforeToolExecute hook", error);
+      throw error;
+    } finally {
+      this.recordEvent("tool.execute.before", input, output, Date.now() - startTime);
+    }
+  }
+  async afterToolExecute(input, output) {
+    const startTime = Date.now();
+    try {
+      this.logger.debug(`After tool execute: ${input.tool}`);
+      if (this.shouldCreateCheckpoint(input.tool, output)) {
+        await this.context.sessionManager?.createCheckpoint("tool-after", `After ${input.tool}`, "automatic", {
+          tool: input.tool,
+          success: !output.error,
+          resultSize: this.getResultSize(output)
+        });
+      }
+      await this.analyzeToolResults(input, output);
+      this.updateSessionContext(input, output);
+    } catch (error) {
+      this.logger.error("Error in afterToolExecute hook", error);
+      throw error;
+    } finally {
+      this.recordEvent("tool.execute.after", input, output, Date.now() - startTime);
+    }
+  }
+  async onAgentRequest(input, output) {
+    const startTime = Date.now();
+    try {
+      this.logger.debug(`Agent request: ${input.agent || "unknown"}`);
+      await this.context.sessionManager?.createCheckpoint("agent-request", `Agent request: ${input.agent}`, "automatic", { agent: input.agent, request: input.request });
+      this.monitorAgentUsage(input);
+    } catch (error) {
+      this.logger.error("Error in onAgentRequest hook", error);
+      throw error;
+    } finally {
+      this.recordEvent("agent.request", input, output, Date.now() - startTime);
+    }
+  }
+  registerHook(event, handler) {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event).push(handler);
+    this.logger.debug(`Registered hook for event: ${event}`);
+  }
+  unregisterHook(event, handler) {
+    const handlers = this.hooks.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+        this.logger.debug(`Unregistered hook for event: ${event}`);
+      }
+    }
+  }
+  async executeHooks(event, input, output) {
+    const handlers = this.hooks.get(event);
+    if (!handlers || handlers.length === 0)
+      return;
+    this.logger.debug(`Executing ${handlers.length} hooks for event: ${event}`);
+    for (const handler of handlers) {
+      try {
+        await handler(input, output, this.context);
+      } catch (error) {
+        this.logger.error(`Hook execution failed for event: ${event}`, error);
+      }
+    }
+  }
+  getHookStats() {
+    const eventCounts = new Map;
+    const totalDuration = new Map;
+    for (const event of this.eventHistory) {
+      eventCounts.set(event.event, (eventCounts.get(event.event) || 0) + 1);
+      totalDuration.set(event.event, (totalDuration.get(event.event) || 0) + event.duration);
+    }
+    return {
+      totalEvents: this.eventHistory.length,
+      registeredHooks: Array.from(this.hooks.entries()).map(([event, handlers]) => ({
+        event,
+        count: handlers.length
+      })),
+      eventStats: Array.from(eventCounts.entries()).map(([event, count]) => ({
+        event,
+        count,
+        averageDuration: totalDuration.get(event) / count,
+        totalDuration: totalDuration.get(event)
+      })),
+      recentEvents: this.eventHistory.slice(-10).map((e) => ({
+        event: e.event,
+        timestamp: e.timestamp,
+        duration: e.duration
+      }))
+    };
+  }
+  shouldCreateCheckpoint(tool, output) {
+    const significantTools = ["write", "edit", "bash", "glob", "task"];
+    if (significantTools.includes(tool))
+      return true;
+    if (output?.error)
+      return true;
+    if (output && this.getResultSize(output) > 1e4)
+      return true;
+    return false;
+  }
+  getResultSize(output) {
+    if (typeof output === "string")
+      return output.length;
+    if (typeof output === "object") {
+      try {
+        return JSON.stringify(output).length;
+      } catch {
+        return 0;
+      }
+    }
+    return 0;
+  }
+  logToolUsage(input, phase) {
+    const usage = {
+      tool: input.tool,
+      phase,
+      timestamp: new Date,
+      args: input.args ? Object.keys(input.args) : [],
+      sessionId: this.context.session.id
+    };
+    this.logger.debug(`Tool usage: ${usage.tool} (${usage.phase})`);
+  }
+  async validateToolExecution(input) {
+    switch (input.tool) {
+      case "bash":
+        await this.validateBashCommand(input.args?.command || "");
+        break;
+      case "write":
+      case "edit":
+        await this.validateFileOperation(input.args?.filePath || "");
+        break;
+      case "read":
+        await this.validateFileRead(input.args?.filePath || "");
+        break;
+    }
+  }
+  async validateBashCommand(command) {
+    const dangerousPatterns = [
+      /rm\s+-rf/,
+      /sudo/,
+      /passwd/,
+      /curl.*\|.*sh/,
+      /wget.*\|.*sh/,
+      /eval/,
+      /exec/
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(command)) {
+        this.logger.warn(`Potentially dangerous command detected: ${command}`);
+      }
+    }
+  }
+  async validateFileOperation(filePath) {
+    const sensitivePatterns = [
+      /\.env$/,
+      /\/etc\//,
+      /\.ssh\//,
+      /\.gnupg\//
+    ];
+    for (const pattern of sensitivePatterns) {
+      if (pattern.test(filePath)) {
+        this.logger.warn(`Attempted write to sensitive file: ${filePath}`);
+      }
+    }
+  }
+  async validateFileRead(filePath) {
+    const sensitivePatterns = [
+      /\.env$/,
+      /\.pem$/,
+      /\.key$/,
+      /\/etc\/shadow/
+    ];
+    for (const pattern of sensitivePatterns) {
+      if (pattern.test(filePath)) {
+        this.logger.warn(`Attempted read from sensitive file: ${filePath}`);
+      }
+    }
+  }
+  async analyzeToolResults(input, output) {
+    if (input.tool === "read" && output?.content) {
+      const insights = this.analyzeFileContent(output.content, input.args?.filePath || "");
+      if (insights.length > 0) {
+        this.context.session.context.fileInsights = {
+          ...this.context.session.context.fileInsights || {},
+          [input.args?.filePath || ""]: insights
+        };
+      }
+    }
+    if (input.tool === "bash" && output?.stdout) {
+      const insights = this.analyzeBashOutput(output.stdout, input.args?.command || "");
+      if (insights.length > 0) {
+        this.context.session.context.commandInsights = {
+          ...this.context.session.context.commandInsights || {},
+          [input.args?.command || ""]: insights
+        };
+      }
+    }
+  }
+  analyzeFileContent(content, filePath) {
+    const insights = [];
+    if (content.includes("TODO") || content.includes("FIXME")) {
+      insights.push("Contains TODO/FIXME comments");
+    }
+    if (content.includes("console.log") && filePath.endsWith(".js")) {
+      insights.push("Contains console.log statements");
+    }
+    if (content.includes("import") && content.includes("from")) {
+      insights.push("Uses ES6 imports");
+    }
+    return insights;
+  }
+  analyzeBashOutput(output, command) {
+    const insights = [];
+    if (command.includes("test") && output.includes("failed")) {
+      insights.push("Test failures detected");
+    }
+    if (command.includes("git") && output.includes("conflict")) {
+      insights.push("Git conflicts detected");
+    }
+    if (command.includes("npm") && output.includes("error")) {
+      insights.push("NPM errors detected");
+    }
+    return insights;
+  }
+  updateSessionContext(input, output) {
+    if (["write", "edit"].includes(input.tool)) {
+      const filePath = input.args?.filePath;
+      if (filePath) {
+        this.context.session.context.modifiedFiles = [
+          ...this.context.session.context.modifiedFiles || [],
+          filePath
+        ].filter((file, index, arr) => arr.indexOf(file) === index);
+      }
+    }
+    if (input.tool === "bash") {
+      this.context.session.context.executedCommands = [
+        ...this.context.session.context.executedCommands || [],
+        {
+          command: input.args?.command,
+          timestamp: new Date,
+          success: !output?.error
+        }
+      ];
+    }
+  }
+  monitorAgentUsage(input) {
+    const agentName = input.agent || "unknown";
+    this.context.session.context.agentUsage = {
+      ...this.context.session.context.agentUsage || {},
+      [agentName]: {
+        ...this.context.session.context.agentUsage?.[agentName] || {},
+        count: (this.context.session.context.agentUsage?.[agentName]?.count || 0) + 1,
+        lastUsed: new Date
+      }
+    };
+  }
+  recordEvent(event, input, output, duration) {
+    this.eventHistory.push({
+      event,
+      timestamp: new Date,
+      input: this.sanitizeInput(input),
+      output: this.sanitizeOutput(output),
+      duration
+    });
+    if (this.eventHistory.length > 1000) {
+      this.eventHistory = this.eventHistory.slice(-500);
+    }
+  }
+  sanitizeInput(input) {
+    if (!input)
+      return input;
+    const sanitized = { ...input };
+    delete sanitized.password;
+    delete sanitized.token;
+    delete sanitized.secret;
+    return sanitized;
+  }
+  sanitizeOutput(output) {
+    if (!output)
+      return output;
+    const sanitized = { ...output };
+    if (sanitized.content && sanitized.content.length > 1000) {
+      sanitized.content = sanitized.content.substring(0, 1000) + "...[truncated]";
+    }
+    return sanitized;
+  }
+}
+// ../essential-opencode/src/utils/agent-utils.ts
+function withDefaults(agent, config) {
+  const defaults = config?.defaults || DEFAULT_CONFIG.defaults;
+  return {
+    ...agent,
+    temperature: agent.temperature ?? defaults.temperature,
+    maxTokens: agent.maxTokens ?? defaults.maxTokens
+  };
+}
+function validateAgent(agent) {
+  if (!agent.id || !agent.name || !agent.description) {
+    return false;
+  }
+  if (agent.temperature !== undefined && (agent.temperature < 0 || agent.temperature > 2)) {
+    console.warn(`[agent-utils] Invalid temperature for ${agent.id}: ${agent.temperature}. Should be between 0 and 2.`);
+    return false;
+  }
+  if (agent.maxTokens !== undefined && agent.maxTokens < 1) {
+    console.warn(`[agent-utils] Invalid maxTokens for ${agent.id}: ${agent.maxTokens}. Should be >= 1.`);
+    return false;
+  }
+  return true;
+}
+function getAvailableSkills(agent, allSkills) {
+  if (!agent.allowedSkills || agent.allowedSkills.length === 0) {
+    return allSkills;
+  }
+  return allSkills.filter((skill) => agent.allowedSkills.includes(skill));
+}
+// ../essential-opencode/src/utils/agent-skill-validator.ts
+function validateAgentSkillCompatibility(agent, availableSkills) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    suggestions: []
+  };
+  const skillMap = new Map(availableSkills.map((s) => [s.id, s]));
+  const allowedSkills = agent.allowedSkills || [];
+  if (allowedSkills.length === 0) {
+    result.suggestions.push(`Agent '${agent.id}' has access to all ${availableSkills.length} skills. Consider scoping skills to prevent ultracontext rot.`);
+    return result;
+  }
+  const nonExistent = allowedSkills.filter((skillId) => !skillMap.has(skillId));
+  if (nonExistent.length > 0) {
+    result.valid = false;
+    result.errors.push(`Agent '${agent.id}' references non-existent skills: [${nonExistent.join(", ")}]`);
+  }
+  const existingSkills = allowedSkills.filter((skillId) => skillMap.has(skillId));
+  if (existingSkills.length === 0 && allowedSkills.length > 0) {
+    result.valid = false;
+    result.errors.push(`Agent '${agent.id}' has no valid skills available`);
+  }
+  if (agent.capabilities && agent.capabilities.length > 0) {
+    const suggestedSkills = availableSkills.filter((skill) => {
+      return agent.capabilities.some((cap) => skill.expertise.some((exp) => exp.toLowerCase().includes(cap.toLowerCase()) || cap.toLowerCase().includes(exp.toLowerCase())));
+    });
+    const missingSuggestions = suggestedSkills.filter((skill) => !allowedSkills.includes(skill.id)).map((skill) => skill.id);
+    if (missingSuggestions.length > 0) {
+      result.suggestions.push(`Agent '${agent.id}' might benefit from these skills based on capabilities: [${missingSuggestions.join(", ")}]`);
+    }
+  }
+  if (existingSkills.length > 0 && existingSkills.length < 3 && availableSkills.length > 5) {
+    result.warnings.push(`Agent '${agent.id}' has access to only ${existingSkills.length} skill(s), which may limit functionality`);
+  }
+  return result;
+}
+function validateAllAgents(agents, availableSkills) {
+  const results = new Map;
+  for (const agent of agents) {
+    const result = validateAgentSkillCompatibility(agent, availableSkills);
+    results.set(agent.id, result);
+  }
+  return results;
+}
+function getValidationSummary(results) {
+  let totalAgents = 0;
+  let validAgents = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalSuggestions = 0;
+  for (const [agentId, result] of results) {
+    totalAgents++;
+    if (result.valid)
+      validAgents++;
+    totalErrors += result.errors.length;
+    totalWarnings += result.warnings.length;
+    totalSuggestions += result.suggestions.length;
+  }
+  return {
+    totalAgents,
+    validAgents,
+    invalidAgents: totalAgents - validAgents,
+    totalErrors,
+    totalWarnings,
+    totalSuggestions,
+    allValid: validAgents === totalAgents
+  };
+}
+// ../essential-opencode/src/hooks/index.ts
+async function onSessionStart(context) {
+  console.log("[everything-opencode] Session started");
+  return {
+    success: true,
+    data: {
+      timestamp: new Date().toISOString(),
+      sessionId: context.sessionId
+    }
+  };
+}
+async function onSessionEnd(context) {
+  console.log("[everything-opencode] Session ended");
+  return {
+    success: true,
+    data: {
+      timestamp: new Date().toISOString(),
+      sessionId: context.sessionId
+    }
+  };
+}
+async function onToolExecuteBefore(context) {
+  const toolName = context.data?.toolName;
+  console.log(`[everything-opencode] Executing tool: ${toolName}`);
+  return {
+    success: true,
+    data: {
+      timestamp: new Date().toISOString(),
+      toolName
+    }
+  };
+}
+async function onToolExecuteAfter(context) {
+  const toolName = context.data?.toolName;
+  const success = context.data?.success;
+  console.log(`[everything-opencode] Tool ${toolName} ${success ? "succeeded" : "failed"}`);
+  return {
+    success: true,
+    data: {
+      timestamp: new Date().toISOString(),
+      toolName,
+      success
+    }
+  };
+}
+async function onAgentRequest(context) {
+  const agentId = context.data?.agentId;
+  console.log(`[everything-opencode] Agent request: ${agentId}`);
+  return {
+    success: true,
+    data: {
+      timestamp: new Date().toISOString(),
+      agentId
+    }
+  };
+}
+// ../essential-opencode/src/contexts/index.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function detectTypeScript(workingDir) {
+  const tsconfigPath = join(workingDir, "tsconfig.json");
+  return existsSync(tsconfigPath);
+}
+function detectPackageManager(workingDir) {
+  if (existsSync(join(workingDir, "bun.lockb")))
+    return "bun";
+  if (existsSync(join(workingDir, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync(join(workingDir, "yarn.lock")))
+    return "yarn";
+  if (existsSync(join(workingDir, "package-lock.json")))
+    return "npm";
+  return "unknown";
+}
+function detectTestingFramework(workingDir) {
+  const packageJsonPath = join(workingDir, "package.json");
+  if (!existsSync(packageJsonPath))
+    return "unknown";
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (deps.vitest)
+      return "vitest";
+    if (deps.jest)
+      return "jest";
+    if (deps.mocha)
+      return "mocha";
+  } catch (error) {
+    console.error("[contexts] Failed to parse package.json:", error);
+  }
+  return "unknown";
+}
+function enrichContext(context) {
+  const workingDir = context.workingDirectory || process.cwd();
+  return {
+    ...context,
+    projectContext: {
+      isTypeScript: detectTypeScript(workingDir),
+      packageManager: detectPackageManager(workingDir),
+      testingFramework: detectTestingFramework(workingDir),
+      workingDir
+    }
+  };
+}
+// ../essential-opencode/src/agents/planner.ts
+var plannerAgent = {
+  id: "planner",
+  name: "Planner",
+  description: "Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.",
+  capabilities: [
+    "requirements-analysis",
+    "architecture-review",
+    "step-breakdown",
+    "implementation-planning",
+    "risk-assessment",
+    "dependency-mapping"
+  ],
+  tools: [
+    "read",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "project-architecture",
+    "implementation-strategies",
+    "best-practices",
+    "risk-mitigation"
+  ],
+  temperature: 0.3,
+  allowedSkills: [
+    "coding-standards",
+    "testing",
+    "documentation",
+    "planning-with-files"
+  ]
+};
+var planner_default = plannerAgent;
+// ../essential-opencode/src/agents/code-reviewer.ts
+var codeReviewerAgent = {
+  id: "code-reviewer",
+  name: "Code Reviewer",
+  description: "Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. MUST BE USED for all code changes.",
+  capabilities: [
+    "code-quality-review",
+    "security-checks",
+    "performance-analysis",
+    "best-practices",
+    "error-handling",
+    "test-coverage-review"
+  ],
+  tools: [
+    "read",
+    "grep",
+    "glob",
+    "bash"
+  ],
+  context: [
+    "coding-standards",
+    "security-vulnerabilities",
+    "performance-optimization",
+    "code-maintainability"
+  ],
+  allowedSkills: ["coding-standards", "security-check", "performance-optimization"]
+};
+var code_reviewer_default = codeReviewerAgent;
+// ../essential-opencode/src/agents/doc-updater.ts
+var docUpdaterAgent = {
+  id: "doc-updater",
+  name: "Documentation Updater",
+  description: "Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.",
+  capabilities: [
+    "codemap-generation",
+    "documentation-updates",
+    "ast-analysis",
+    "dependency-mapping",
+    "api-documentation"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "typescript-ast",
+    "documentation-generation",
+    "code-structure-analysis",
+    "dependency-graphs"
+  ]
+};
+var doc_updater_default = docUpdaterAgent;
+// ../essential-opencode/src/agents/build-error-resolver.ts
+var buildErrorResolverAgent = {
+  id: "build-error-resolver",
+  name: "Build Error Resolver",
+  description: "Build and TypeScript error resolution specialist. Use PROACTIVELY when build fails or type errors occur. Fixes build/type errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.",
+  capabilities: [
+    "typescript-error-resolution",
+    "build-error-fixing",
+    "dependency-issues",
+    "configuration-errors",
+    "minimal-diffs",
+    "compilation-failures"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "build-configuration",
+    "typescript-compiler",
+    "dependency-management",
+    "error-resolution"
+  ]
+};
+var build_error_resolver_default = buildErrorResolverAgent;
+// ../essential-opencode/src/agents/security-reviewer.ts
+var securityReviewerAgent = {
+  id: "security-reviewer",
+  name: "Security Reviewer",
+  description: "Security vulnerability detection and remediation specialist. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities.",
+  capabilities: [
+    "vulnerability-detection",
+    "secrets-detection",
+    "input-validation",
+    "authentication-security",
+    "dependency-security",
+    "owasp-top-10"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "owasp-top-10",
+    "security-best-practices",
+    "cryptographic-security",
+    "authentication-authorization",
+    "financial-security"
+  ]
+};
+var security_reviewer_default = securityReviewerAgent;
+// ../essential-opencode/src/agents/refactor-cleaner.ts
+var refactorCleanerAgent = {
+  id: "refactor-cleaner",
+  name: "Refactor Cleaner",
+  description: "Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.",
+  capabilities: [
+    "dead-code-detection",
+    "duplicate-elimination",
+    "dependency-cleanup",
+    "safe-refactoring",
+    "code-consolidation"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "code-analysis",
+    "dependency-management",
+    "refactoring-best-practices",
+    "deletion-logging"
+  ]
+};
+var refactor_cleaner_default = refactorCleanerAgent;
+// ../essential-opencode/src/skills/coding-standards.ts
+var codingStandardsSkill = {
+  id: "coding-standards",
+  name: "Coding Standards & Best Practices",
+  description: "Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development",
+  category: "development",
+  expertise: [
+    "typescript-standards",
+    "javascript-best-practices",
+    "react-patterns",
+    "nodejs-patterns",
+    "code-quality",
+    "performance-optimization",
+    "error-handling",
+    "api-design"
+  ],
+  patterns: [
+    "Use descriptive variable and function names",
+    "Follow KISS (Keep It Simple, Stupid) principle",
+    "Apply DRY (Don't Repeat Yourself) pattern",
+    "Follow YAGNI (You Aren't Gonna Need It) principle",
+    "Use immutable patterns with spread operator",
+    "Implement comprehensive error handling",
+    "Follow async/await best practices",
+    "Use proper TypeScript typing"
+  ],
+  examples: [
+    "Refactor complex functions into smaller, focused functions",
+    "Implement proper error boundaries in React applications",
+    "Create reusable custom hooks for common logic",
+    "Set up consistent API response formats",
+    "Apply performance optimization with memoization and lazy loading"
+  ]
+};
+var coding_standards_default = codingStandardsSkill;
+// ../essential-opencode/src/skills/tdd-workflow.ts
+var tddWorkflowSkill = {
+  id: "tdd-workflow",
+  name: "Test-Driven Development Workflow",
+  description: "TDD methodology with comprehensive testing including unit, integration, and E2E tests for minimum 80% coverage",
+  category: "development",
+  expertise: [
+    "test-driven-development",
+    "unit-testing",
+    "integration-testing",
+    "e2e-testing",
+    "test-coverage",
+    "testing-patterns",
+    "mock-testing",
+    "continuous-testing"
+  ],
+  patterns: [
+    "Write tests BEFORE code implementation",
+    "Arrange-Act-Assert test structure",
+    "Test edge cases and error scenarios",
+    "Mock external dependencies",
+    "Verify 80%+ code coverage",
+    "Use semantic selectors in tests",
+    "Independent test isolation",
+    "Descriptive test naming"
+  ],
+  examples: [
+    "Write failing tests for new functionality, then implement code to make tests pass",
+    "Create comprehensive test suite for API endpoints with Jest/Supertest",
+    "Implement E2E tests with Playwright for critical user workflows",
+    "Set up test coverage reporting and enforce minimum thresholds",
+    "Mock external services like databases and APIs for isolated unit testing"
+  ]
+};
+var tdd_workflow_default = tddWorkflowSkill;
+// ../essential-opencode/src/skills/security-review.ts
+var securityReviewSkill = {
+  id: "security-review",
+  name: "Security Review",
+  description: "Comprehensive security analysis including vulnerability assessment, secure coding practices, and security best practices",
+  category: "security",
+  expertise: [
+    "vulnerability-assessment",
+    "secure-coding",
+    "authentication-authorization",
+    "data-protection",
+    "security-audit",
+    "penetration-testing"
+  ],
+  patterns: [
+    "Check for SQL injection vulnerabilities",
+    "Validate input sanitization and output encoding",
+    "Review authentication and authorization mechanisms",
+    "Assess data protection and encryption usage",
+    "Identify potential security misconfigurations",
+    "Review dependency security",
+    "Check for XSS and CSRF vulnerabilities",
+    "Validate session management"
+  ],
+  examples: [
+    "Review user authentication implementation for security weaknesses",
+    "Assess API endpoint security including input validation and rate limiting",
+    "Analyze database queries for SQL injection vulnerabilities",
+    "Review file upload functionality for security risks",
+    "Check for proper error handling that doesn't leak sensitive information"
+  ]
+};
+var security_review_default = securityReviewSkill;
+// ../essential-opencode/src/skills/verification-loop.ts
+var verificationLoopSkill = {
+  id: "verification-loop",
+  name: "Verification Loop",
+  description: "Comprehensive verification system for development sessions with build, type checking, linting, testing, security scanning, and diff review",
+  category: "quality-assurance",
+  expertise: [
+    "build-verification",
+    "type-checking",
+    "linting-checks",
+    "test-verification",
+    "security-scanning",
+    "diff-review",
+    "quality-gates",
+    "continuous-verification"
+  ],
+  patterns: [
+    "Run build verification before any other checks",
+    "Execute type checking to catch type errors early",
+    "Run linting to enforce code standards",
+    "Execute test suite with coverage reporting",
+    "Perform security scans for secrets and vulnerabilities",
+    "Review diff for unintended changes and edge cases",
+    "Generate comprehensive verification reports",
+    "Run verification at logical intervals during development"
+  ],
+  examples: [
+    "Run full verification pipeline before creating pull requests",
+    "Execute verification after completing significant features",
+    "Set up continuous verification during long development sessions",
+    "Review security scans for exposed API keys or console.log statements",
+    "Check test coverage meets minimum 80% threshold"
+  ]
+};
+var verification_loop_default = verificationLoopSkill;
+// ../essential-opencode/src/skills/planning-with-files.ts
+var planningWithFilesSkill = {
+  id: "planning-with-files",
+  name: "Planning with Files",
+  description: "Structured planning using persistent markdown files (task_plan.md, findings.md, progress.md) for complex multi-step tasks and research projects",
+  category: "project-management",
+  expertise: [
+    "Task planning and breakdown",
+    "Research organization",
+    "Progress tracking",
+    "Session recovery",
+    "Multi-phase projects"
+  ],
+  patterns: [
+    "Complex tasks requiring >5 tool calls",
+    "Research projects with findings",
+    "Multi-session work continuation",
+    "Tasks needing structured planning"
+  ],
+  examples: [
+    {
+      trigger: "Complex refactoring project",
+      action: "Create task_plan.md with phases, findings.md for analysis, progress.md for tracking"
+    },
+    {
+      trigger: "Codebase investigation",
+      action: "Document findings in findings.md, track progress in progress.md"
+    },
+    {
+      trigger: "Session recovery after /clear",
+      action: "Read task_plan.md and progress.md to resume work"
+    }
+  ]
+};
+var planning_with_files_default = planningWithFilesSkill;
+// ../essential-opencode/src/skills/continuous-learning.ts
+var continuousLearningSkill = {
+  id: "continuous-learning",
+  name: "Continuous Learning",
+  description: "Automatically extract reusable patterns from development sessions and save them as learned skills for future use",
+  category: "automation",
+  expertise: [
+    "pattern-extraction",
+    "session-evaluation",
+    "skill-learning",
+    "hook-automation",
+    "context-analysis",
+    "pattern-detection",
+    "session-management",
+    "automated-learning"
+  ],
+  patterns: [
+    "Extract error resolution patterns from sessions",
+    "Identify user corrections and improvements",
+    "Detect workarounds for framework quirks",
+    "Capture debugging techniques that work",
+    "Learn project-specific conventions",
+    "Run session evaluation at logical boundaries",
+    "Save useful patterns to learned skills directory",
+    "Configure minimum session length for extraction"
+  ],
+  examples: [
+    "Set up stop hooks to automatically evaluate sessions at completion",
+    "Extract reusable error resolution patterns from debugging sessions",
+    "Learn project-specific coding patterns and conventions",
+    "Configure pattern extraction thresholds and ignore patterns",
+    "Save learned debugging techniques for future reference"
+  ]
+};
+var continuous_learning_default = continuousLearningSkill;
+// ../essential-opencode/src/skills/strategic-compact.ts
+var strategicCompactSkill = {
+  id: "strategic-compact",
+  name: "Strategic Compact",
+  description: "Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction",
+  category: "context-management",
+  expertise: [
+    "context-compaction",
+    "memory-management",
+    "session-optimization",
+    "hook-automation",
+    "threshold-detection",
+    "strategic-planning",
+    "context-preservation",
+    "tool-call-tracking"
+  ],
+  patterns: [
+    "Compact after exploration before execution",
+    "Compact at logical task boundaries",
+    "Use PreToolUse hooks for threshold detection",
+    "Track tool calls to determine optimal compaction points",
+    "Preserve important context while removing noise",
+    "Suggest manual compaction at strategic intervals",
+    "Configure thresholds based on session complexity",
+    "Avoid mid-task context interruption"
+  ],
+  examples: [
+    "Set up PreToolUse hooks to suggest compaction at 50 tool calls",
+    "Compact after research phase before implementation",
+    "Use strategic compaction before major task shifts",
+    "Configure compaction thresholds based on project complexity",
+    "Preserve critical context while clearing noise"
+  ]
+};
+var strategic_compact_default = strategicCompactSkill;
+// ../essential-opencode/src/skills/eval-harness.ts
+var evalHarnessSkill = {
+  id: "eval-harness",
+  name: "Eval Harness",
+  description: "Formal evaluation framework for development sessions, implementing eval-driven development (EDD) principles with capability and regression testing",
+  category: "evaluation",
+  expertise: [
+    "eval-driven-development",
+    "capability-evals",
+    "regression-evals",
+    "code-grading",
+    "model-grading",
+    "pass-k-metrics",
+    "test-metrics",
+    "eval-automation"
+  ],
+  patterns: [
+    "Define evals BEFORE implementation",
+    "Use capability evals to test new functionality",
+    "Implement regression evals to prevent breakage",
+    "Apply code-based graders for deterministic checks",
+    "Use model-based graders for open-ended evaluation",
+    "Track pass@k metrics for reliability measurement",
+    "Run evals frequently during development",
+    "Maintain eval baselines for regression detection"
+  ],
+  examples: [
+    "Define capability evals for new authentication features",
+    "Create regression evals to ensure existing functionality works",
+    "Set up code-based graders for deterministic test results",
+    "Implement pass@3 metrics to measure reliability targets",
+    "Run continuous evals during feature development",
+    "Generate comprehensive eval reports before deployment"
+  ]
+};
+var eval_harness_default = evalHarnessSkill;
+// ../essential-opencode/src/skills/project-guidelines-example.ts
+var projectGuidelinesExampleSkill = {
+  id: "project-guidelines-example",
+  name: "Project Guidelines Example",
+  description: "Example of project-specific skill containing architecture overview, file structure, code patterns, testing requirements, and deployment workflow",
+  category: "project-management",
+  expertise: [
+    "architecture-design",
+    "project-structure",
+    "code-patterns",
+    "testing-strategies",
+    "deployment-workflows",
+    "technology-stack",
+    "development-guidelines",
+    "team-collaboration"
+  ],
+  patterns: [
+    "Define clear architecture and technology stack",
+    "Establish consistent file structure conventions",
+    "Create reusable code patterns and utilities",
+    "Implement comprehensive testing strategies",
+    "Set up deployment workflows and checklists",
+    "Define critical coding rules and standards",
+    "Document API response formats",
+    "Create development environment guidelines"
+  ],
+  examples: [
+    "Set up Next.js + FastAPI architecture with proper separation",
+    "Create consistent API response patterns across frontend and backend",
+    "Implement comprehensive testing with Jest, pytest, and Playwright",
+    "Define deployment checklist for Google Cloud Run",
+    "Establish project-specific coding rules and conventions",
+    "Create integration patterns for Claude AI with structured output"
+  ]
+};
+var project_guidelines_example_default = projectGuidelinesExampleSkill;
+// ../essential-opencode/src/skills/clickhouse-io.ts
+var clickhouseIoSkill = {
+  id: "clickhouse-io",
+  name: "ClickHouse Analytics Patterns",
+  description: "ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads",
+  category: "database",
+  expertise: [
+    "clickhouse-optimization",
+    "analytical-queries",
+    "data-engineering",
+    "merge-trees",
+    "materialized-views",
+    "bulk-inserts",
+    "performance-tuning",
+    "real-time-analytics"
+  ],
+  patterns: [
+    "Use MergeTree engines for time-series data",
+    "Implement efficient partitioning strategies",
+    "Optimize query performance with proper filtering",
+    "Use materialized views for real-time aggregations",
+    "Batch insert operations for performance",
+    "Leverage ClickHouse-specific aggregation functions",
+    "Implement ETL patterns for data pipelines",
+    "Monitor query performance and system metrics"
+  ],
+  examples: [
+    "Design optimal table schemas with MergeTree engines",
+    "Create materialized views for real-time analytics",
+    "Implement efficient bulk insert patterns",
+    "Optimize analytical queries with proper indexing",
+    "Set up ETL pipelines for continuous data ingestion",
+    "Monitor ClickHouse performance and query efficiency"
+  ]
+};
+var clickhouse_io_default = clickhouseIoSkill;
+
+// ../essential-opencode/src/index.ts
+var ESSENTIAL_VERSION = "1.0.0";
+var ESSENTIAL_NAME = "@venthezone/essential-opencode";
+// ../typescript-opencode/src/agents/tdd-guide.ts
+var tddGuideAgent = {
+  id: "tdd-guide",
+  name: "TDD Guide",
+  description: "Test-Driven Development specialist enforcing write-tests-first methodology. Use PROACTIVELY when writing new features, fixing bugs, or refactoring code. Ensures 80%+ test coverage.",
+  capabilities: [
+    "test-driven-development",
+    "unit-testing",
+    "integration-testing",
+    "e2e-testing",
+    "test-coverage",
+    "red-green-refactor"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep"
+  ],
+  context: [
+    "testing-methodologies",
+    "test-frameworks",
+    "mocking-strategies",
+    "coverage-reports"
+  ],
+  allowedSkills: ["testing", "tdd-methodology"]
+};
+var tdd_guide_default = tddGuideAgent;
+// ../typescript-opencode/src/agents/architect.ts
+var architectAgent = {
+  id: "architect",
+  name: "Software Architect",
+  description: "Expert in software architecture, design patterns, system design, and technical decision making",
+  capabilities: [
+    "system-design",
+    "architecture-planning",
+    "design-patterns",
+    "technical-decisions",
+    "scalability-planning",
+    "performance-optimization"
+  ],
+  tools: [
+    "read",
+    "glob",
+    "grep",
+    "write",
+    "edit"
+  ],
+  context: [
+    "architectural-principles",
+    "design-patterns",
+    "best-practices",
+    "technology-stack"
+  ],
+  allowedSkills: ["architecture-patterns", "design-patterns", "system-design"]
+};
+var architect_default = architectAgent;
+// ../typescript-opencode/src/agents/e2e-runner.ts
+var e2eRunnerAgent = {
+  id: "e2e-runner",
+  name: "E2E Test Runner",
+  description: "End-to-end testing specialist using Playwright. Use PROACTIVELY for generating, maintaining, and running E2E tests. Manages test journeys, quarantines flaky tests, uploads artifacts (screenshots, videos, traces), and ensures critical user flows work.",
+  capabilities: [
+    "test-journey-creation",
+    "test-maintenance",
+    "flaky-test-management",
+    "artifact-management",
+    "ci-cd-integration",
+    "test-reporting"
+  ],
+  tools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob"
+  ],
+  context: [
+    "playwright-testing",
+    "page-object-model",
+    "test-automation",
+    "flaky-test-quarantine"
+  ]
+};
+var e2e_runner_default = e2eRunnerAgent;
+// ../typescript-opencode/src/skills/backend-patterns.ts
+var backendPatternsSkill = {
+  id: "backend-patterns",
+  name: "Backend Development Patterns",
+  description: "Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes",
+  category: "backend",
+  expertise: [
+    "api-design",
+    "repository-pattern",
+    "service-layer",
+    "middleware-patterns",
+    "database-optimization",
+    "caching-strategies",
+    "error-handling",
+    "authentication-authorization"
+  ],
+  patterns: [
+    "RESTful API design with proper HTTP methods",
+    "Repository pattern for data access abstraction",
+    "Service layer for business logic separation",
+    "Middleware for request/response processing",
+    "Query optimization and N+1 prevention",
+    "Cache-aside pattern for performance",
+    "Centralized error handling",
+    "JWT-based authentication and RBAC"
+  ],
+  examples: [
+    "Design RESTful APIs with proper resource endpoints",
+    "Implement repository pattern for database operations",
+    "Set up Redis caching layer for frequently accessed data",
+    "Create middleware for authentication and authorization",
+    "Implement rate limiting for API protection",
+    "Use transactions for data consistency"
+  ]
+};
+var backend_patterns_default = backendPatternsSkill;
+// ../typescript-opencode/src/skills/frontend-patterns.ts
+var frontendPatternsSkill = {
+  id: "frontend-patterns",
+  name: "Frontend Development Patterns",
+  description: "Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices",
+  category: "frontend",
+  expertise: [
+    "react-patterns",
+    "nextjs-development",
+    "state-management",
+    "performance-optimization",
+    "component-design",
+    "custom-hooks",
+    "accessibility",
+    "animation-patterns"
+  ],
+  patterns: [
+    "Component composition over inheritance",
+    "Compound components for complex UI",
+    "Render props pattern for flexible components",
+    "Custom hooks for reusable logic",
+    "Context + reducer pattern for state",
+    "Memoization with useMemo and useCallback",
+    "Code splitting and lazy loading",
+    "Error boundaries for graceful failures"
+  ],
+  examples: [
+    "Create compound components like Tabs with TabList and Tab",
+    "Implement custom data fetching hook with loading states",
+    "Set up virtualization for long lists performance",
+    "Create accessible form components with proper keyboard navigation",
+    "Implement animations with Framer Motion",
+    "Use error boundaries to catch and handle component errors"
+  ]
+};
+var frontend_patterns_default = frontendPatternsSkill;
+
+// ../typescript-opencode/src/index.ts
+var typescriptAgents = [
+  "tdd-guide",
+  "architect",
+  "e2e-runner"
+];
+var typescriptSkills = [
+  "backend-patterns",
+  "frontend-patterns"
+];
+var TYPESCRIPT_VERSION = "1.0.0";
+var TYPESCRIPT_NAME = "@venthezone/typescript-opencode";
+
+// src/index.ts
+var allAgents = [
+  "planner",
+  "code-reviewer",
+  "doc-updater",
+  "build-error-resolver",
+  "security-reviewer",
+  "refactor-cleaner",
+  "tdd-guide",
+  "architect",
+  "e2e-runner"
+];
+var allSkills = [
+  "coding-standards",
+  "tdd-workflow",
+  "security-review",
+  "verification-loop",
+  "planning-with-files",
+  "continuous-learning",
+  "strategic-compact",
+  "eval-harness",
+  "project-guidelines-example",
+  "clickhouse-io",
+  "backend-patterns",
+  "frontend-patterns"
+];
+var EVERYTHING_VERSION = "1.0.0";
+var EVERYTHING_NAME = "@venthezone/everything-opencode-plugin";
+var PACKAGES = {
+  essential: "@venthezone/essential-opencode",
+  typescript: "@venthezone/typescript-opencode",
+  complete: "@venthezone/everything-opencode-plugin"
+};
+export {
+  withDefaults,
+  verification_loop_default as verificationLoopSkill,
+  validateAllAgents,
+  validateAgentSkillCompatibility,
+  validateAgent,
+  typescriptSkills,
+  typescriptAgents,
+  tdd_workflow_default as tddWorkflowSkill,
+  tdd_guide_default as tddGuideAgent,
+  strategic_compact_default as strategicCompactSkill,
+  security_reviewer_default as securityReviewerAgent,
+  security_review_default as securityReviewSkill,
+  refactor_cleaner_default as refactorCleanerAgent,
+  project_guidelines_example_default as projectGuidelinesSkill,
+  planning_with_files_default as planningWithFilesSkill,
+  planner_default as plannerAgent,
+  onToolExecuteBefore,
+  onToolExecuteAfter,
+  onSessionStart,
+  onSessionEnd,
+  onAgentRequest,
+  getValidationSummary,
+  getAvailableSkills,
+  frontend_patterns_default as frontendPatternsSkill,
+  eval_harness_default as evalHarnessSkill,
+  enrichContext,
+  e2e_runner_default as e2eRunnerAgent,
+  doc_updater_default as docUpdaterAgent,
+  detectTypeScript,
+  detectTestingFramework,
+  detectPackageManager,
+  continuous_learning_default as continuousLearningSkill,
+  coding_standards_default as codingStandardsSkill,
+  code_reviewer_default as codeReviewerAgent,
+  clickhouse_io_default as clickhouseIOSkill,
+  build_error_resolver_default as buildErrorResolverAgent,
+  backend_patterns_default as backendPatternsSkill,
+  architect_default as architectAgent,
+  allSkills,
+  allAgents,
+  WorkflowEngine,
+  ToolRegistry,
+  TYPESCRIPT_VERSION,
+  TYPESCRIPT_NAME,
+  SkillRegistry,
+  SessionManager,
+  PACKAGES,
+  Logger,
+  HookManager,
+  EVERYTHING_VERSION,
+  EVERYTHING_NAME,
+  ESSENTIAL_VERSION,
+  ESSENTIAL_NAME,
+  DEFAULT_CONFIG,
+  AgentRegistry
+};