@baselineos/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3488 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaselineCommandSystem: () => BaselineCommandSystem,
+  MEGAGEMAutonomousAgent: () => MEGAGEMAutonomousAgent,
+  MEGAGEMCoreSystem: () => MEGAGEMCoreSystem
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands.ts
+var import_experience = require("@baselineos/experience");
+var import_govern = require("@baselineos/govern");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var BaselineCommandSystem = class {
+  state;
+  megagem;
+  contextEngine;
+  baselineLang;
+  constructor() {
+    this.state = {
+      customContextFolder: null,
+      baselineMode: false,
+      commandQueue: [],
+      executionHistory: [],
+      currentWorkflow: null
+    };
+    this.megagem = null;
+    this.contextEngine = null;
+    this.baselineLang = {
+      lexicon: this.initializeBaselineLexicon(),
+      syntax: this.initializeBaselineSyntax(),
+      commands: this.initializeBaselineCommands()
+    };
+  }
+  /**
+   * Initialize the Baseline lexicon with all recognized flags and their
+   * descriptions, usage patterns, categories, and examples.
+   */
+  initializeBaselineLexicon() {
+    return {
+      "--onboard": {
+        description: "Guided 20-minute onboarding flow to set up a team and run Baseline",
+        usage: "--onboard [--name <full-name>] [--role <role>] [--email <email>] [--company <name>] [--team <name>] [--project <name>] [--language <code>] [--learning-style <style>] [--pace <speed>] [--focus <focus>] [--learning-path <path>] [--context <path>] [--mode <mode>] [--skip-workflow] [--fresh] [--interactive]",
+        category: "onboarding",
+        examples: [
+          '--onboard --team "Acme Corp" --project "AI Governance"',
+          '--onboard --name "Amani" --role "Platform Lead" --team "GTCX Protocol"',
+          "--onboard --language en --learning-style visual --pace fast --focus practical --learning-path standard",
+          "--onboard --context ./my-project --mode production",
+          "--onboard --skip-workflow",
+          "--onboard --fresh",
+          "--onboard --interactive"
+        ]
+      },
+      "--experience": {
+        description: "Run an immersive experience sequence based on learning path",
+        usage: "--experience [--learning-path <path>] [--experiences <id,id>] [--context <path>] [--fresh]",
+        category: "onboarding",
+        examples: [
+          "--experience --learning-path standard",
+          "--experience --learning-path accelerated",
+          "--experience --experiences welcome-journey,ai-collaboration",
+          "--experience --fresh"
+        ]
+      },
+      "--config": {
+        description: "Configure Baseline preferences and settings",
+        usage: "--config <section> [--set <value>] [--region <value>] [--standards <csv>] [--enable <csv>] [--context <path>]",
+        category: "setup",
+        examples: [
+          "--config show",
+          "--config language --set en",
+          "--config culture --region latin-america --business-style relationship-focused",
+          "--config compliance --region eu --standards gdpr,iso27001",
+          "--config accessibility --screen-reader --high-contrast"
+        ]
+      },
+      "--index": {
+        description: "Index docs or context for retrieval",
+        usage: "--index [--paths <csv>] [--context <path>] [--max <n>]",
+        category: "setup",
+        examples: ["--index", "--index --paths docs,README.md", "--index --max 500"]
+      },
+      "--serve": {
+        description: "Start the Baseline MCP server (stdio) and optional API server",
+        usage: "--serve [--api] [--port <n>] [--context <path>] [--once]",
+        category: "setup",
+        examples: ["--serve", "--serve --api --port 3141", "--serve --once"]
+      },
+      "--agents": {
+        description: "Show agent registry status",
+        usage: "--agents [--context <path>]",
+        category: "info",
+        examples: ["--agents", "--agents --context ./project"]
+      },
+      "--doctor": {
+        description: "Run diagnostics for Baseline configuration and readiness",
+        usage: "--doctor [--context <path>]",
+        category: "diagnostics",
+        examples: ["--doctor", "--doctor --context ./project"]
+      },
+      "--baseline": {
+        description: "Execute the full Baseline Protocol workflow across all layers",
+        usage: "--baseline [options]",
+        category: "core",
+        examples: [
+          "--baseline",
+          "--baseline --context ./my-project",
+          "--baseline --mode production"
+        ]
+      },
+      "--run": {
+        description: "Run the full Baseline workflow (alias for --baseline)",
+        usage: "--run [--context <path>] [--mode <mode>]",
+        category: "core",
+        examples: ["--run", "--run --context ./project --mode development"]
+      },
+      "--init": {
+        description: "Initialize Baseline and optionally write config",
+        usage: "--init [--context <path>] [--mode <mode>] [--write-config]",
+        category: "setup",
+        examples: ["--init", "--init --write-config", "--init --context ./project"]
+      },
+      "--baseline-lang": {
+        description: "Execute the Baseline language processing layer",
+        usage: "--baseline-lang [options]",
+        category: "layer",
+        examples: [
+          "--baseline-lang",
+          "--baseline-lang --parse",
+          "--baseline-lang --validate"
+        ]
+      },
+      "--baseline-frame": {
+        description: "Execute the Baseline framework orchestration layer",
+        usage: "--baseline-frame [options]",
+        category: "layer",
+        examples: [
+          "--baseline-frame",
+          "--baseline-frame --scaffold",
+          "--baseline-frame --compose"
+        ]
+      },
+      "--baseline-studio": {
+        description: "Execute the Baseline studio design and rendering layer",
+        usage: "--baseline-studio [options]",
+        category: "layer",
+        examples: [
+          "--baseline-studio",
+          "--baseline-studio --render",
+          "--baseline-studio --preview"
+        ]
+      },
+      "--baseline-govern": {
+        description: "Execute the Baseline governance and compliance layer",
+        usage: "--baseline-govern [options]",
+        category: "layer",
+        examples: [
+          "--baseline-govern",
+          "--baseline-govern --audit",
+          "--baseline-govern --policy"
+        ]
+      }
+    };
+  }
+  /**
+   * Initialize syntax patterns for the command system, defining parameter
+   * schemas and usage examples for each pattern.
+   */
+  initializeBaselineSyntax() {
+    return {
+      onboarding: {
+        pattern: "--onboard [--name <full-name>] [--role <role>] [--email <email>] [--company <name>] [--team <name>] [--project <name>] [--language <code>] [--learning-style <style>] [--pace <speed>] [--focus <focus>] [--learning-path <path>] [--context <path>] [--mode <mode>] [--skip-workflow] [--fresh] [--interactive]",
+        parameters: {
+          name: "Your name for onboarding personalization",
+          role: "Your role (optional)",
+          email: "Your email (optional)",
+          company: "Company name for the onboarding profile",
+          team: "Team name to onboard (optional)",
+          project: "Project name to initialize (optional)",
+          language: "Preferred language (en, es, fr, de, ja, zh, ko, ar, hi, pt)",
+          "learning-style": "Learning style (visual, auditory, kinesthetic, reading)",
+          pace: "Learning pace (slow, moderate, fast, lightning)",
+          focus: "Learning focus (practical, theoretical, mixed)",
+          "learning-path": "Learning path (standard, accelerated, hands-on, theoretical)",
+          context: "Path to the project context folder",
+          mode: "Execution mode: development | staging | production",
+          "skip-workflow": "Skip running the Baseline workflow after onboarding",
+          fresh: "Start onboarding from scratch and overwrite any saved profile",
+          interactive: "Prompt for onboarding inputs"
+        },
+        examples: [
+          '--onboard --team "Acme" --project "AI Governance"',
+          '--onboard --name "Amani" --role "Engineering" --company "GTCX Dev"',
+          "--onboard --language en --learning-style visual --learning-path standard",
+          "--onboard --context ./project --mode development",
+          "--onboard --skip-workflow",
+          "--onboard --fresh",
+          "--onboard --interactive"
+        ]
+      },
+      experience: {
+        pattern: "--experience [--learning-path <path>] [--experiences <id,id>] [--context <path>] [--fresh]",
+        parameters: {
+          "learning-path": "Learning path (standard, accelerated, hands-on, theoretical)",
+          experiences: "Comma-separated experience ids to run",
+          context: "Path to the project context folder",
+          fresh: "Reset onboarding profile before running experiences"
+        },
+        examples: [
+          "--experience --learning-path standard",
+          "--experience --learning-path accelerated",
+          "--experience --experiences welcome-journey,ai-collaboration",
+          "--experience --fresh"
+        ]
+      },
+      config: {
+        pattern: "--config <section> [--set <value>] [--region <value>] [--standards <csv>] [--enable <csv>] [--context <path>]",
+        parameters: {
+          section: "Config section: show | language | culture | compliance | accessibility",
+          set: "Set a value for a given section",
+          region: "Set a region for culture/compliance",
+          standards: "Comma-separated standards list for compliance",
+          enable: "Comma-separated accessibility features to enable",
+          context: "Path to the project context folder"
+        },
+        examples: [
+          "--config show",
+          "--config language --set en",
+          "--config culture --region latin-america --business-style relationship-focused",
+          "--config compliance --region eu --standards gdpr,iso27001",
+          "--config accessibility --screen-reader --high-contrast"
+        ]
+      },
+      index: {
+        pattern: "--index [--paths <csv>] [--context <path>] [--max <n>]",
+        parameters: {
+          paths: "Comma-separated list of paths to index",
+          context: "Context path to resolve relative paths",
+          max: "Maximum number of entries to index"
+        },
+        examples: ["--index", "--index --paths docs,README.md", "--index --max 500"]
+      },
+      serve: {
+        pattern: "--serve [--api] [--port <n>] [--context <path>] [--once]",
+        parameters: {
+          api: "Start the HTTP/WebSocket API server alongside MCP",
+          port: "Port for the API server (default: 3141)",
+          context: "Path to the project context folder",
+          once: "Start then return immediately (for scripting)"
+        },
+        examples: ["--serve", "--serve --api --port 3141", "--serve --once"]
+      },
+      agents: {
+        pattern: "--agents [--context <path>]",
+        parameters: {
+          context: "Path to the project context folder"
+        },
+        examples: ["--agents", "--agents --context ./project"]
+      },
+      doctor: {
+        pattern: "--doctor [--context <path>]",
+        parameters: {
+          context: "Path to the project context folder"
+        },
+        examples: ["--doctor", "--doctor --context ./project"]
+      },
+      workflow: {
+        pattern: "--baseline [--context <path>] [--mode <mode>] [--verbose]",
+        parameters: {
+          context: "Path to the project context folder",
+          mode: "Execution mode: development | staging | production",
+          verbose: "Enable verbose logging output"
+        },
+        examples: [
+          "--baseline --context ./project --mode development",
+          "--baseline --mode production --verbose"
+        ]
+      },
+      run: {
+        pattern: "--run [--context <path>] [--mode <mode>]",
+        parameters: {
+          context: "Path to the project context folder",
+          mode: "Execution mode: development | staging | production"
+        },
+        examples: ["--run", "--run --context ./project --mode development"]
+      },
+      init: {
+        pattern: "--init [--context <path>] [--mode <mode>] [--write-config]",
+        parameters: {
+          context: "Path to the project context folder",
+          mode: "Execution mode: development | staging | production",
+          "write-config": "Persist baseline.config.json into .baseline/"
+        },
+        examples: ["--init --write-config", "--init --context ./project"]
+      },
+      layer: {
+        pattern: "--baseline-<layer> [--input <path>] [--output <path>] [--config <path>]",
+        parameters: {
+          layer: "Target layer: lang | frame | studio | govern",
+          input: "Input file or directory path",
+          output: "Output file or directory path",
+          config: "Layer-specific configuration file path"
+        },
+        examples: [
+          "--baseline-lang --input ./src --output ./dist",
+          "--baseline-frame --config ./baseline.config.json"
+        ]
+      },
+      chain: {
+        pattern: '--baseline-chain "<cmd1> | <cmd2> | <cmd3>"',
+        parameters: {
+          commands: "Pipe-delimited list of commands to execute sequentially"
+        },
+        examples: [
+          '--baseline-chain "--baseline-lang | --baseline-frame | --baseline-studio"',
+          '--baseline-chain "--init | --baseline"'
+        ]
+      },
+      queue: {
+        pattern: "--baseline-queue <add|run|clear|status>",
+        parameters: {
+          action: "Queue action to perform",
+          command: "Command to add (when using add)"
+        },
+        examples: [
+          "--baseline-queue add --baseline-lang",
+          "--baseline-queue run",
+          "--baseline-queue status"
+        ]
+      }
+    };
+  }
+  /**
+   * Initialize the built-in command registry with descriptions and action
+   * identifiers for each recognized command.
+   */
+  initializeBaselineCommands() {
+    return {
+      "--onboard": {
+        description: "Run a guided onboarding flow (team, project, system, workflow)",
+        action: "onboard",
+        category: "onboarding"
+      },
+      "--experience": {
+        description: "Run an immersive experience sequence based on learning path",
+        action: "experience",
+        category: "onboarding"
+      },
+      "--config": {
+        description: "Configure Baseline preferences and settings",
+        action: "config",
+        category: "setup"
+      },
+      "--index": {
+        description: "Index docs or context for retrieval",
+        action: "index",
+        category: "setup"
+      },
+      "--serve": {
+        description: "Start the Baseline server or MCP daemon (placeholder)",
+        action: "serve",
+        category: "setup"
+      },
+      "--persona": {
+        description: "Show persona status and available roles",
+        action: "persona",
+        category: "info"
+      },
+      "--agents": {
+        description: "Show agent registry status (placeholder)",
+        action: "agents",
+        category: "info"
+      },
+      "--doctor": {
+        description: "Run diagnostics for Baseline configuration and readiness",
+        action: "doctor",
+        category: "diagnostics"
+      },
+      "--init": {
+        description: "Initialize a new Baseline project in the current directory",
+        action: "initialize",
+        category: "setup"
+      },
+      "--run": {
+        description: "Run the full Baseline workflow with default settings",
+        action: "run",
+        category: "execution"
+      },
+      "--status": {
+        description: "Display the current status of the Baseline system and active workflows",
+        action: "status",
+        category: "info"
+      },
+      "--help": {
+        description: "Display help information for all available commands",
+        action: "help",
+        category: "info"
+      }
+    };
+  }
+  /**
+   * Execute the full Baseline Protocol workflow across all five layers:
+   * init -> lang -> frame -> studio -> govern
+   */
+  async executeBaselineWorkflow(options = {}) {
+    const workflowId = `wf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const workflow = {
+      id: workflowId,
+      startTime: /* @__PURE__ */ new Date(),
+      options,
+      status: "running"
+    };
+    this.state.currentWorkflow = workflow;
+    this.state.baselineMode = true;
+    console.log(`[Baseline] Starting workflow ${workflowId}`);
+    console.log(`[Baseline] Options: ${JSON.stringify(options)}`);
+    try {
+      console.log("[Baseline] Step 1/5: Initializing baseline environment...");
+      const initResult = await this.initializeBaseline(options);
+      if (!initResult.success) {
+        throw new Error(`Initialization failed: ${initResult.error || "unknown error"}`);
+      }
+      console.log("[Baseline] Step 1/5: Initialization complete.");
+      console.log("[Baseline] Step 2/5: Processing language layer...");
+      const langResult = await this.executeBaselineLang(options);
+      if (!langResult.success) {
+        throw new Error(`Language layer failed: ${langResult.error || "unknown error"}`);
+      }
+      console.log("[Baseline] Step 2/5: Language layer complete.");
+      console.log("[Baseline] Step 3/5: Processing frame layer...");
+      const frameResult = await this.executeBaselineFrame(options);
+      if (!frameResult.success) {
+        throw new Error(`Frame layer failed: ${frameResult.error || "unknown error"}`);
+      }
+      console.log("[Baseline] Step 3/5: Frame layer complete.");
+      console.log("[Baseline] Step 4/5: Processing studio layer...");
+      const studioResult = await this.executeBaselineStudio(options);
+      if (!studioResult.success) {
+        throw new Error(`Studio layer failed: ${studioResult.error || "unknown error"}`);
+      }
+      console.log("[Baseline] Step 4/5: Studio layer complete.");
+      console.log("[Baseline] Step 5/5: Processing governance layer...");
+      const governResult = await this.executeBaselineGovern(options);
+      if (!governResult.success) {
+        throw new Error(`Governance layer failed: ${governResult.error || "unknown error"}`);
+      }
+      console.log("[Baseline] Step 5/5: Governance layer complete.");
+      workflow.endTime = /* @__PURE__ */ new Date();
+      workflow.duration = workflow.endTime.getTime() - workflow.startTime.getTime();
+      workflow.status = "completed";
+      this.state.executionHistory.push(workflow);
+      this.state.currentWorkflow = null;
+      console.log(`[Baseline] Workflow ${workflowId} completed in ${workflow.duration}ms`);
+      return {
+        success: true,
+        workflow,
+        results: {
+          init: initResult,
+          lang: langResult,
+          frame: frameResult,
+          studio: studioResult,
+          govern: governResult
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      workflow.endTime = /* @__PURE__ */ new Date();
+      workflow.duration = workflow.endTime.getTime() - workflow.startTime.getTime();
+      workflow.status = "failed";
+      workflow.error = errorMessage;
+      this.state.executionHistory.push(workflow);
+      this.state.currentWorkflow = null;
+      console.log(`[Baseline] Workflow ${workflowId} failed: ${errorMessage}`);
+      return {
+        success: false,
+        error: errorMessage,
+        workflow
+      };
+    }
+  }
+  normalizeString(value) {
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length ? trimmed : void 0;
+    }
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    const text = String(value).trim();
+    return text.length ? text : void 0;
+  }
+  normalizeBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      return ["true", "1", "yes", "y"].includes(value.toLowerCase());
+    }
+    return false;
+  }
+  resolveContext(value, fallback) {
+    const resolved = this.normalizeString(value) || fallback || process.cwd();
+    return import_node_path.default.resolve(resolved);
+  }
+  async loadOnboardingProfile(context) {
+    const directory = import_node_path.default.join(context, ".baseline");
+    const filePath = import_node_path.default.join(directory, "onboarding.json");
+    try {
+      const raw = await (0, import_promises.readFile)(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return { path: filePath, profile: parsed, exists: true };
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") {
+        return { path: filePath, profile: null, exists: false };
+      }
+      return { path: filePath, profile: null, exists: false, error: error.message };
+    }
+  }
+  async saveOnboardingProfile(filePath, profile) {
+    await (0, import_promises.mkdir)(import_node_path.default.dirname(filePath), { recursive: true });
+    await (0, import_promises.writeFile)(filePath, JSON.stringify(profile, null, 2), "utf8");
+  }
+  async loadBaselineConfig(context) {
+    const directory = import_node_path.default.join(context, ".baseline");
+    const filePath = import_node_path.default.join(directory, "baseline.config.json");
+    try {
+      const raw = await (0, import_promises.readFile)(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return { path: filePath, config: parsed, exists: true };
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") {
+        return { path: filePath, config: null, exists: false };
+      }
+      return { path: filePath, config: null, exists: false, error: error.message };
+    }
+  }
+  async saveBaselineConfig(filePath, config) {
+    await (0, import_promises.mkdir)(import_node_path.default.dirname(filePath), { recursive: true });
+    await (0, import_promises.writeFile)(filePath, JSON.stringify(config, null, 2), "utf8");
+  }
+  async fileExists(filePath) {
+    try {
+      const result = await (0, import_promises.stat)(filePath);
+      return result.isFile() || result.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  buildDefaultConfig(context, profile) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      version: 1,
+      context,
+      createdAt: now,
+      updatedAt: now,
+      language: profile?.preferences?.language || "en",
+      preferences: {
+        learningStyle: profile?.preferences?.learningStyle,
+        pace: profile?.preferences?.pace,
+        focus: profile?.preferences?.focus,
+        learningPath: profile?.preferences?.learningPath
+      },
+      culture: {},
+      compliance: {},
+      accessibility: {}
+    };
+  }
+  getExperienceCatalog() {
+    return {
+      "welcome-journey": {
+        id: "welcome-journey",
+        name: "Welcome Journey",
+        description: "Interactive introduction to Baseline and AI-native development.",
+        duration: "5-10 minutes",
+        difficulty: "beginner",
+        type: "story",
+        tags: ["onboarding", "introduction", "story"]
+      },
+      "acceleration-discovery": {
+        id: "acceleration-discovery",
+        name: "Acceleration Discovery",
+        description: "Experience the jump from 300x to 1,000,000x acceleration.",
+        duration: "10-15 minutes",
+        difficulty: "beginner",
+        type: "interactive",
+        tags: ["acceleration", "demo", "interactive"]
+      },
+      "ai-collaboration": {
+        id: "ai-collaboration",
+        name: "AI Collaboration Workshop",
+        description: "Learn to coordinate with autonomous AI systems.",
+        duration: "15-20 minutes",
+        difficulty: "intermediate",
+        type: "workshop",
+        tags: ["workshop", "ai", "collaboration"]
+      },
+      "quantum-leap": {
+        id: "quantum-leap",
+        name: "Quantum Leap Challenge",
+        description: "Tackle advanced challenges with quantum-level acceleration.",
+        duration: "20-30 minutes",
+        difficulty: "advanced",
+        type: "challenge",
+        tags: ["challenge", "quantum", "advanced"]
+      },
+      "singularity-mastery": {
+        id: "singularity-mastery",
+        name: "Singularity Mastery",
+        description: "Master the highest tiers of AI-native execution.",
+        duration: "30-45 minutes",
+        difficulty: "expert",
+        type: "mastery",
+        tags: ["mastery", "singularity", "expert"]
+      },
+      "concept-exploration": {
+        id: "concept-exploration",
+        name: "Concept Exploration",
+        description: "Deep dive into AI-native development concepts.",
+        duration: "15-20 minutes",
+        difficulty: "intermediate",
+        type: "theoretical",
+        tags: ["theoretical", "concepts", "learning"]
+      },
+      "theory-workshop": {
+        id: "theory-workshop",
+        name: "Theory Workshop",
+        description: "Explore the principles behind Baseline OS.",
+        duration: "25-35 minutes",
+        difficulty: "advanced",
+        type: "workshop",
+        tags: ["workshop", "theory", "principles"]
+      },
+      "advanced-concepts": {
+        id: "advanced-concepts",
+        name: "Advanced Concepts",
+        description: "Master advanced AI-native concepts and patterns.",
+        duration: "30-40 minutes",
+        difficulty: "expert",
+        type: "theoretical",
+        tags: ["theoretical", "advanced", "mastery"]
+      },
+      "workshop-series": {
+        id: "workshop-series",
+        name: "Workshop Series",
+        description: "Hands-on applied learning series.",
+        duration: "45-60 minutes",
+        difficulty: "intermediate",
+        type: "workshop",
+        tags: ["workshop", "series", "hands-on"]
+      }
+    };
+  }
+  getLearningPaths() {
+    return {
+      standard: {
+        name: "Standard Path",
+        experiences: ["welcome-journey", "acceleration-discovery", "ai-collaboration"]
+      },
+      accelerated: {
+        name: "Accelerated Path",
+        experiences: ["acceleration-discovery", "quantum-leap", "singularity-mastery"]
+      },
+      "hands-on": {
+        name: "Hands-On Path",
+        experiences: ["ai-collaboration", "quantum-leap", "workshop-series"]
+      },
+      theoretical: {
+        name: "Theoretical Path",
+        experiences: ["concept-exploration", "theory-workshop", "advanced-concepts"]
+      }
+    };
+  }
+  /**
+   * Execute a guided onboarding flow (team, project, system) and optionally
+   * run the full Baseline workflow. Designed for a 20-minute quickstart.
+   */
+  async executeOnboarding(options = {}) {
+    const startedAt = Date.now();
+    const context = this.resolveContext(options.context, process.cwd());
+    const forceFresh = this.normalizeBoolean(options.fresh) || this.normalizeBoolean(options.reset);
+    const existingProfile = forceFresh ? null : await this.loadOnboardingProfile(context);
+    const prior = existingProfile?.profile ?? null;
+    const name = this.normalizeString(options.name) || prior?.user?.name || "User";
+    const role = this.normalizeString(options.role) || prior?.user?.role || "Operator";
+    const email = this.normalizeString(options.email) || prior?.user?.email;
+    const company = this.normalizeString(options.company) || prior?.company || "Acme Corp";
+    const team = this.normalizeString(options.team) || prior?.team;
+    const project = this.normalizeString(options.project) || prior?.project;
+    const mode = this.normalizeString(options.mode) || prior?.mode || "development";
+    const language = this.normalizeString(options.language) || prior?.preferences?.language || "en";
+    const learningStyle = this.normalizeString(options["learning-style"]) || prior?.preferences?.learningStyle || "visual";
+    const pace = this.normalizeString(options.pace) || prior?.preferences?.pace || "moderate";
+    const focus = this.normalizeString(options.focus) || prior?.preferences?.focus || "practical";
+    const learningPath = this.normalizeString(options["learning-path"]) || prior?.preferences?.learningPath || "standard";
+    const skipWorkflow = this.normalizeBoolean(options["skip-workflow"]);
+    console.log("[Baseline:Onboarding] Starting 20-minute onboarding flow");
+    console.log(`[Baseline:Onboarding] Welcome: ${name} (${role})`);
+    console.log(`[Baseline:Onboarding] Language: ${language}`);
+    console.log(
+      `[Baseline:Onboarding] Learning path: ${learningPath} (${learningStyle}, ${pace}, ${focus})`
+    );
+    if (team) {
+      console.log(`[Baseline:Onboarding] Team: ${team}`);
+    }
+    console.log(`[Baseline:Onboarding] Company: ${company}`);
+    if (project) {
+      console.log(`[Baseline:Onboarding] Project: ${project}`);
+    }
+    console.log(`[Baseline:Onboarding] Context: ${context}`);
+    console.log(`[Baseline:Onboarding] Mode: ${mode}`);
+    if (existingProfile?.exists && !forceFresh) {
+      console.log("[Baseline:Onboarding] Resuming from saved onboarding profile");
+    }
+    if (skipWorkflow) {
+      console.log("[Baseline:Onboarding] Workflow execution skipped by flag");
+    }
+    const experience = new import_experience.BaselineExperienceSystem();
+    const systemResult = await experience.onboarding.system.initialize();
+    const systemId = systemResult.systemId || `system-${Date.now()}`;
+    const systemConfig = await experience.onboarding.system.configure(systemId, {
+      user: { name, role, email },
+      company,
+      team,
+      project,
+      context,
+      mode,
+      preferences: { language, learningStyle, pace, focus, learningPath }
+    });
+    let teamResult;
+    let teamConfig;
+    let teamId;
+    if (team) {
+      teamResult = await experience.onboarding.team.start(company);
+      teamId = teamResult.teamId ?? `team-${Date.now()}`;
+      teamConfig = await experience.onboarding.team.configure(teamId, {
+        user: { name, role, email },
+        team,
+        company,
+        mode
+      });
+    } else {
+      teamResult = { success: true, skipped: true, reason: "team not provided" };
+      teamConfig = { success: true, skipped: true, reason: "team not provided" };
+    }
+    let projectResult;
+    let projectConfig;
+    let projectId;
+    if (project) {
+      projectResult = await experience.onboarding.project.setup(project);
+      projectId = projectResult.projectId ?? `project-${Date.now()}`;
+      projectConfig = await experience.onboarding.project.configure(projectId, {
+        teamId,
+        context
+      });
+    } else {
+      projectResult = { success: true, skipped: true, reason: "project not provided" };
+      projectConfig = { success: true, skipped: true, reason: "project not provided" };
+    }
+    let workflow = null;
+    if (!skipWorkflow) {
+      workflow = await this.executeBaselineWorkflow({ context, mode });
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const completedSteps = ["identity", "preferences", "workspace"];
+    if (!skipWorkflow) {
+      completedSteps.push("workflow");
+    }
+    const profile = {
+      version: 2,
+      createdAt: prior?.createdAt || now,
+      updatedAt: now,
+      user: { name, role, ...email ? { email } : {} },
+      company,
+      ...team ? { team } : {},
+      ...project ? { project } : {},
+      context,
+      mode,
+      preferences: { language, learningStyle, pace, focus, learningPath },
+      progress: {
+        completedSteps,
+        lastStep: completedSteps[completedSteps.length - 1],
+        lastCompletedAt: now
+      },
+      experiences: prior?.experiences ?? { completed: [] },
+      ...workflow?.workflow?.id ? { workflow: { lastRunAt: now, lastWorkflowId: workflow.workflow.id } } : {}
+    };
+    const storage = existingProfile ?? {
+      path: import_node_path.default.join(context, ".baseline", "onboarding.json"),
+      exists: false,
+      profile: null
+    };
+    let storageSaved = false;
+    let storageError;
+    try {
+      await this.saveOnboardingProfile(storage.path, profile);
+      storageSaved = true;
+    } catch (err) {
+      storageError = err instanceof Error ? err.message : String(err);
+      console.log(`[Baseline:Onboarding] Failed to save profile: ${storageError}`);
+    }
+    const success = systemResult.success && systemConfig.success && teamResult.success && teamConfig.success && projectResult.success && projectConfig.success && (workflow ? workflow.success : true);
+    return {
+      success,
+      onboarding: {
+        system: systemResult,
+        systemConfig,
+        user: { name, role, email },
+        preferences: { language, learningStyle, pace, focus, learningPath },
+        profile,
+        storage: {
+          path: storage.path,
+          saved: storageSaved,
+          error: storageError
+        },
+        team: teamResult,
+        teamConfig,
+        project: projectResult,
+        projectConfig
+      },
+      workflow,
+      nextSteps: [
+        "Run `baseline status` to verify layer status.",
+        "Run `baseline --baseline` to execute the full workflow.",
+        "Follow docs/experience/baseline-20-min-onboarding.md for mastery path."
+      ],
+      durationMs: Date.now() - startedAt
+    };
+  }
+  /**
+   * Execute an immersive experience sequence based on the selected learning path.
+   * Uses onboarding profile data and persists progress.
+   */
+  async executeExperience(options = {}) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const forceFresh = this.normalizeBoolean(options.fresh) || this.normalizeBoolean(options.reset);
+    const storage = forceFresh ? null : await this.loadOnboardingProfile(context);
+    let profile = storage?.profile ?? null;
+    if (!profile) {
+      console.log("[Baseline:Experience] No onboarding profile found. Bootstrapping profile...");
+      const onboardingResult = await this.executeOnboarding({
+        ...options,
+        context,
+        "skip-workflow": true,
+        fresh: forceFresh
+      });
+      profile = onboardingResult.onboarding?.profile ?? null;
+    }
+    if (!profile) {
+      return { success: false, error: "Unable to load or create onboarding profile." };
+    }
+    const catalog = this.getExperienceCatalog();
+    const paths = this.getLearningPaths();
+    const learningPath = this.normalizeString(options["learning-path"]) || profile.preferences.learningPath || "standard";
+    const explicitList = this.normalizeString(options.experiences);
+    const requested = explicitList ? explicitList.split(",").map((entry) => entry.trim()).filter((entry) => entry.length) : paths[learningPath]?.experiences || paths.standard.experiences;
+    const experiences = requested.filter((id) => !!catalog[id]);
+    if (experiences.length === 0) {
+      return {
+        success: false,
+        error: "No valid experiences found. Provide --learning-path or --experiences."
+      };
+    }
+    console.log("[Baseline:Experience] Starting experience sequence");
+    console.log(`[Baseline:Experience] Path: ${learningPath}`);
+    experiences.forEach((experienceId, index) => {
+      const experience = catalog[experienceId];
+      console.log(
+        `[Baseline:Experience] ${index + 1}/${experiences.length}: ${experience.name} (${experience.duration})`
+      );
+      console.log(`  ${experience.description}`);
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const completed = Array.from(
+      /* @__PURE__ */ new Set([...profile.experiences?.completed ?? [], ...experiences])
+    );
+    const updatedProfile = {
+      ...profile,
+      updatedAt: now,
+      preferences: {
+        ...profile.preferences,
+        learningPath
+      },
+      experiences: {
+        completed,
+        lastExperience: experiences[experiences.length - 1],
+        lastCompletedAt: now
+      }
+    };
+    const targetPath = storage?.path ?? import_node_path.default.join(context, ".baseline", "onboarding.json");
+    let storageSaved = false;
+    let storageError;
+    try {
+      await this.saveOnboardingProfile(targetPath, updatedProfile);
+      storageSaved = true;
+    } catch (err) {
+      storageError = err instanceof Error ? err.message : String(err);
+      console.log(`[Baseline:Experience] Failed to save profile: ${storageError}`);
+    }
+    return {
+      success: true,
+      experience: {
+        path: learningPath,
+        experiences: experiences.map((id) => catalog[id]),
+        completed
+      },
+      profile: updatedProfile,
+      storage: {
+        path: targetPath,
+        saved: storageSaved,
+        error: storageError
+      }
+    };
+  }
+  /**
+   * Initialize Baseline and optionally persist config to disk.
+   */
+  async executeInit(options = {}) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const mode = this.normalizeString(options.mode) || "development";
+    const writeConfig = this.normalizeBoolean(options["write-config"]) || this.normalizeBoolean(options.persist) || this.normalizeBoolean(options.write);
+    const initResult = await this.initializeBaseline({ context, mode });
+    if (!initResult.success) {
+      return initResult;
+    }
+    if (!writeConfig) {
+      return {
+        ...initResult,
+        message: "Initialization complete (config not written). Use --write-config to persist."
+      };
+    }
+    const profile = await this.loadOnboardingProfile(context);
+    const configRecord = await this.loadBaselineConfig(context);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const config = {
+      ...configRecord.config ?? this.buildDefaultConfig(context, profile.profile),
+      context,
+      updatedAt: now
+    };
+    await this.saveBaselineConfig(configRecord.path, config);
+    return {
+      ...initResult,
+      config,
+      configPath: configRecord.path,
+      message: "Initialization complete and config written."
+    };
+  }
+  /**
+   * Update or show Baseline configuration.
+   */
+  async executeConfig(options = {}) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const positional = Array.isArray(options._) && options._.length ? options._ : [];
+    const section = this.normalizeString(options.config) || this.normalizeString(options.section) || (positional.length ? this.normalizeString(positional[0]) : void 0) || "show";
+    const showOnly = this.normalizeBoolean(options.show) || section === "show" || !options.set && !options.region && !options.standards && !options.enable;
+    const onboarding = await this.loadOnboardingProfile(context);
+    const existing = await this.loadBaselineConfig(context);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const config = existing.config ?? this.buildDefaultConfig(context, onboarding.profile);
+    if (showOnly) {
+      return {
+        success: true,
+        config,
+        configPath: existing.path
+      };
+    }
+    if (section === "language") {
+      const value = this.normalizeString(options.set);
+      if (!value) {
+        return { success: false, error: "Missing --set <language-code>" };
+      }
+      config.language = value;
+      if (onboarding.profile) {
+        onboarding.profile.preferences.language = value;
+        onboarding.profile.updatedAt = now;
+        await this.saveOnboardingProfile(onboarding.path, onboarding.profile);
+      }
+    } else if (section === "culture") {
+      const region = this.normalizeString(options.region);
+      const businessStyle = this.normalizeString(options["business-style"]) || this.normalizeString(options.business);
+      config.culture = {
+        ...config.culture,
+        ...region ? { region } : {},
+        ...businessStyle ? { businessStyle } : {}
+      };
+    } else if (section === "compliance") {
+      const region = this.normalizeString(options.region);
+      const standardsRaw = this.normalizeString(options.standards);
+      const standards = standardsRaw ? standardsRaw.split(",").map((entry) => entry.trim()).filter(Boolean) : void 0;
+      config.compliance = {
+        ...config.compliance,
+        ...region ? { region } : {},
+        ...standards ? { standards } : {}
+      };
+    } else if (section === "accessibility") {
+      const enabledRaw = this.normalizeString(options.enable);
+      const enabled = enabledRaw ? enabledRaw.split(",").map((entry) => entry.trim()).filter(Boolean) : [];
+      config.accessibility = {
+        ...config.accessibility,
+        ...enabled.length ? { enabled } : {},
+        ...this.normalizeBoolean(options["screen-reader"]) ? { screenReader: true } : {},
+        ...this.normalizeBoolean(options["high-contrast"]) ? { highContrast: true } : {},
+        ...this.normalizeBoolean(options["voice-control"]) ? { voiceControl: true } : {}
+      };
+    } else {
+      return { success: false, error: `Unknown config section: ${section}` };
+    }
+    config.updatedAt = now;
+    await this.saveBaselineConfig(existing.path, config);
+    return {
+      success: true,
+      config,
+      configPath: existing.path
+    };
+  }
+  async collectIndexEntries(root, maxEntries) {
+    const entries = [];
+    const queue = [root];
+    const ignore = /* @__PURE__ */ new Set([".git", "node_modules", ".baseline", "dist", ".next", "build"]);
+    while (queue.length && entries.length < maxEntries) {
+      const current = queue.shift();
+      if (!current) continue;
+      let currentStat;
+      try {
+        currentStat = await (0, import_promises.stat)(current);
+      } catch {
+        continue;
+      }
+      if (currentStat.isFile()) {
+        entries.push(current);
+        continue;
+      }
+      if (!currentStat.isDirectory()) continue;
+      const name = import_node_path.default.basename(current);
+      if (ignore.has(name)) continue;
+      let children = [];
+      try {
+        children = await (0, import_promises.readdir)(current);
+      } catch {
+        continue;
+      }
+      for (const child of children) {
+        if (entries.length >= maxEntries) break;
+        queue.push(import_node_path.default.join(current, child));
+      }
+    }
+    return entries;
+  }
+  /**
+   * Index documentation/context files for retrieval.
+   */
+  async executeIndex(options = {}) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const positional = Array.isArray(options._) && options._.length ? options._ : [];
+    const pathsRaw = this.normalizeString(options.paths) || this.normalizeString(options.path) || (positional.length ? positional.join(",") : void 0);
+    const defaultCandidates = ["docs", "README.md"].map((entry) => import_node_path.default.join(context, entry)).filter((entry) => entry !== "");
+    const targets = pathsRaw ? pathsRaw.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => import_node_path.default.resolve(context, entry)) : defaultCandidates;
+    const maxEntries = Number(options.max) > 0 ? Number(options.max) : 2e3;
+    console.log(`[Baseline:Index] Scanning ${targets.length} target(s) in ${context}`);
+    const files = [];
+    for (const target of targets) {
+      const before = files.length;
+      const collected = await this.collectIndexEntries(target, maxEntries - files.length);
+      files.push(...collected);
+      const added = files.length - before;
+      if (added > 0) console.log(`[Baseline:Index]   ${import_node_path.default.relative(context, target) || target} \u2192 ${added} file(s)`);
+      if (files.length >= maxEntries) break;
+    }
+    console.log(`[Baseline:Index] Total: ${files.length} document(s) indexed`);
+    const index = files.map((filePath) => ({
+      path: filePath,
+      relativePath: import_node_path.default.relative(context, filePath)
+    }));
+    const indexPath = import_node_path.default.join(context, ".baseline", "index.json");
+    await (0, import_promises.mkdir)(import_node_path.default.dirname(indexPath), { recursive: true });
+    await (0, import_promises.writeFile)(
+      indexPath,
+      JSON.stringify(
+        {
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          context,
+          total: index.length,
+          entries: index
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    return {
+      success: true,
+      indexed: index.length,
+      indexPath,
+      targets
+    };
+  }
+  /**
+   * Placeholder for MCP server/daemon execution.
+   */
+  async executeServe(options = {}) {
+    return this.executeServeWithOptions(options);
+  }
+  /**
+   * Placeholder for agent status and management.
+   */
+  executePersona(_options = {}) {
+    const personas = [
+      { id: "developer", name: "Developer", focus: "Code governance, CI/CD integration, deployment validation" },
+      { id: "compliance-officer", name: "Compliance Officer", focus: "Policy enforcement, evidence export, regulatory alignment" },
+      { id: "platform-engineer", name: "Platform Engineer", focus: "System health, agent management, infrastructure monitoring" },
+      { id: "dfi-partner", name: "DFI Partner / Auditor", focus: "Evidence review, compliance verification, audit trails" },
+      { id: "trade-finance", name: "Trade Finance Officer", focus: "AfCFTA compliance, trade governance, DFI evidence" }
+    ];
+    console.log("[Baseline:Persona]");
+    console.log("  Available personas:");
+    console.log("");
+    for (const persona of personas) {
+      console.log(`    ${persona.id.padEnd(22)} ${persona.name}`);
+      console.log(`    ${"".padEnd(22)} ${persona.focus}`);
+      console.log("");
+    }
+    console.log("  Set persona in Settings or baseline.config.ts");
+    return { success: true, personas };
+  }
+  async executeAgents(options = {}) {
+    return this.executeAgentsWithOptions(options);
+  }
+  async buildBaselineOS(context) {
+    const { Baseline } = await import("baselineos");
+    const knowledge = [
+      import_node_path.default.join(context, "docs"),
+      import_node_path.default.join(context, "README.md")
+    ];
+    return new Baseline({
+      projectRoot: context,
+      knowledge,
+      paths: {
+        data: import_node_path.default.join(context, ".baseline"),
+        index: import_node_path.default.join(context, ".baseline", "index"),
+        checkpoints: import_node_path.default.join(context, ".baseline", "checkpoints")
+      }
+    });
+  }
+  async executeServeWithOptions(options) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const withApi = this.normalizeBoolean(options.api);
+    const portRaw = this.normalizeString(options.port);
+    const port = portRaw && Number(portRaw) > 0 ? Number(portRaw) : 3141;
+    const once = this.normalizeBoolean(options.once);
+    const baseline = await this.buildBaselineOS(context);
+    await baseline.init();
+    const mcpServer = await baseline.startMCPServer();
+    let apiServer = null;
+    if (withApi) {
+      apiServer = await baseline.startAPIServer(port);
+    }
+    console.error(
+      `[Baseline:Serve] MCP server started (stdio)${withApi ? ` + API:${port}` : ""}`
+    );
+    if (once) {
+      return {
+        success: true,
+        status: "running",
+        mode: "stdio",
+        api: withApi ? { port } : null,
+        message: "Server started (once mode)."
+      };
+    }
+    await new Promise((resolve) => {
+      const handle = async () => {
+        try {
+          await mcpServer.stop();
+        } catch {
+        }
+        if (apiServer && typeof apiServer === "object" && "stop" in apiServer) {
+          await apiServer.stop();
+        }
+        await baseline.shutdown();
+        resolve();
+      };
+      process.on("SIGINT", handle);
+      process.on("SIGTERM", handle);
+    });
+    return {
+      success: true,
+      status: "stopped"
+    };
+  }
+  async executeAgentsWithOptions(options) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const baseline = await this.buildBaselineOS(context);
+    await baseline.init();
+    const agents = baseline.listAgents();
+    return {
+      success: true,
+      context,
+      total: agents.length,
+      agents
+    };
+  }
+  /**
+   * Run diagnostics for configuration and readiness.
+   */
+  async executeDoctor(options = {}) {
+    const context = this.resolveContext(options.context, process.cwd());
+    const checks = [
+      {
+        id: "config",
+        description: "Baseline config exists",
+        path: import_node_path.default.join(context, ".baseline", "baseline.config.json")
+      },
+      {
+        id: "onboarding",
+        description: "Onboarding profile exists",
+        path: import_node_path.default.join(context, ".baseline", "onboarding.json")
+      },
+      {
+        id: "index",
+        description: "Index exists",
+        path: import_node_path.default.join(context, ".baseline", "index.json")
+      },
+      {
+        id: "roadmap",
+        description: "Roadmap exists",
+        path: import_node_path.default.join(context, "docs", "strategy", "roadmap.md")
+      },
+      {
+        id: "ga-release",
+        description: "GA release checklist exists",
+        path: import_node_path.default.join(context, "docs", "strategy", "ga-release.md")
+      },
+      {
+        id: "package-json",
+        description: "package.json exists",
+        path: import_node_path.default.join(context, "package.json")
+      }
+    ];
+    const results = await Promise.all(
+      checks.map(async (check) => ({
+        ...check,
+        ok: await this.fileExists(check.path)
+      }))
+    );
+    const total = results.length;
+    const passed = results.filter((check) => check.ok).length;
+    const score = Math.round(passed / total * 100);
+    const missing = results.filter((check) => !check.ok).map((check) => check.id);
+    return {
+      success: true,
+      context,
+      score,
+      passed,
+      total,
+      missing,
+      checks: results
+    };
+  }
+  /**
+   * Initialize the Baseline environment, setting up context folder,
+   * configuration, and mode.
+   */
+  async initializeBaseline(options = {}) {
+    try {
+      const contextPath = options.context || process.cwd();
+      const mode = options.mode || "development";
+      this.state.customContextFolder = contextPath;
+      this.state.baselineMode = true;
+      console.log(`[Baseline:Init] Context path: ${contextPath}`);
+      console.log(`[Baseline:Init] Mode: ${mode}`);
+      const contextValid = typeof contextPath === "string" && contextPath.length > 0;
+      if (!contextValid) {
+        return {
+          success: false,
+          error: "Invalid context path provided"
+        };
+      }
+      const config = {
+        contextPath,
+        mode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "0.1.0"
+      };
+      const detected = {};
+      try {
+        const { existsSync: existsSync2, readFileSync: readFileSync2 } = await import("fs");
+        const { join: join2 } = await import("path");
+        const pkgPath = join2(contextPath, "package.json");
+        if (existsSync2(pkgPath)) {
+          const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+          const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+          if (allDeps["@anthropic-ai/sdk"]) detected.provider = "anthropic";
+          else if (allDeps["openai"]) detected.provider = "openai";
+          if (allDeps["langchain"] || allDeps["@langchain/core"]) detected.framework = "langchain";
+          if (allDeps["@modelcontextprotocol/sdk"]) detected.mcp = true;
+          if (allDeps["bullmq"] || allDeps["@temporalio/client"]) detected.orchestration = true;
+          detected.runtime = "node";
+          detected.name = pkg.name;
+        }
+        const pyReq = join2(contextPath, "requirements.txt");
+        if (existsSync2(pyReq)) {
+          const reqs = readFileSync2(pyReq, "utf8");
+          if (reqs.includes("anthropic")) detected.provider = "anthropic";
+          else if (reqs.includes("openai")) detected.provider = "openai";
+          if (reqs.includes("langchain")) detected.framework = "langchain";
+          detected.runtime = "python";
+        }
+        if (Object.keys(detected).length > 0) {
+          console.log(`[Baseline:Init] Detected: ${JSON.stringify(detected)}`);
+        }
+      } catch {
+      }
+      console.log("[Baseline:Init] Environment initialized successfully");
+      return {
+        success: true,
+        config: { ...config, detected },
+        contextPath,
+        mode,
+        detected
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute the Baseline Language layer -- parsing, validation,
+   * and semantic analysis of the project context.
+   */
+  async executeBaselineLang(options = {}) {
+    try {
+      const inputPath = options.input || this.state.customContextFolder || process.cwd();
+      const outputPath = options.output || inputPath;
+      console.log(`[Baseline:Lang] Processing language layer...`);
+      console.log(`[Baseline:Lang] Input: ${inputPath}`);
+      console.log(`[Baseline:Lang] Output: ${outputPath}`);
+      const lexiconKeys = Object.keys(this.baselineLang.lexicon);
+      console.log(`[Baseline:Lang] Lexicon entries loaded: ${lexiconKeys.length}`);
+      const syntaxKeys = Object.keys(this.baselineLang.syntax);
+      console.log(`[Baseline:Lang] Syntax patterns loaded: ${syntaxKeys.length}`);
+      const analysisResult = {
+        lexiconEntries: lexiconKeys.length,
+        syntaxPatterns: syntaxKeys.length,
+        validationPassed: true,
+        semanticScore: 1,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      console.log("[Baseline:Lang] Language layer processing complete");
+      return {
+        success: true,
+        inputPath,
+        outputPath,
+        analysis: analysisResult
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute the Baseline Frame layer -- scaffolding, composition,
+   * and framework orchestration.
+   */
+  async executeBaselineFrame(options = {}) {
+    try {
+      const inputPath = options.input || this.state.customContextFolder || process.cwd();
+      const configPath = options.config || null;
+      console.log(`[Baseline:Frame] Processing frame layer...`);
+      console.log(`[Baseline:Frame] Input: ${inputPath}`);
+      if (configPath) {
+        console.log(`[Baseline:Frame] Config: ${configPath}`);
+      }
+      const scaffoldResult = {
+        components: [],
+        templates: [],
+        structure: "hierarchical"
+      };
+      const compositionResult = {
+        composed: true,
+        layers: ["lang", "frame", "studio", "govern"],
+        dependencies: []
+      };
+      const orchestrationResult = {
+        orchestrated: true,
+        pipelineStages: 4,
+        parallelism: 1
+      };
+      console.log("[Baseline:Frame] Frame layer processing complete");
+      return {
+        success: true,
+        scaffold: scaffoldResult,
+        composition: compositionResult,
+        orchestration: orchestrationResult
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute the Baseline Studio layer -- design rendering,
+   * preview generation, and visual asset processing.
+   */
+  async executeBaselineStudio(options = {}) {
+    try {
+      const inputPath = options.input || this.state.customContextFolder || process.cwd();
+      const renderMode = options.render || "standard";
+      console.log(`[Baseline:Studio] Processing studio layer...`);
+      console.log(`[Baseline:Studio] Input: ${inputPath}`);
+      console.log(`[Baseline:Studio] Render mode: ${renderMode}`);
+      const designResult = {
+        designSystem: "baseline-default",
+        components: 0,
+        tokens: {},
+        themes: ["light", "dark"]
+      };
+      const renderResult = {
+        rendered: true,
+        mode: renderMode,
+        outputFormat: "html",
+        assets: []
+      };
+      const previewResult = {
+        previewAvailable: false,
+        previewUrl: null
+      };
+      console.log("[Baseline:Studio] Studio layer processing complete");
+      return {
+        success: true,
+        design: designResult,
+        render: renderResult,
+        preview: previewResult
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute the Baseline Govern layer -- audit, policy enforcement,
+   * compliance checking, and governance controls.
+   */
+  async executeBaselineGovern(options = {}) {
+    try {
+      const inputPath = options.input || this.state.customContextFolder || process.cwd();
+      const policyPath = options.policy || null;
+      const auditPath = import_node_path.default.join(inputPath, ".baseline", "govern", "audit-trail.json");
+      console.log(`[Baseline:Govern] Processing governance layer...`);
+      console.log(`[Baseline:Govern] Input: ${inputPath}`);
+      if (policyPath) {
+        console.log(`[Baseline:Govern] Policy: ${policyPath}`);
+      }
+      let policyContent = "Default governance policy";
+      if (policyPath) {
+        try {
+          policyContent = await (0, import_promises.readFile)(policyPath, "utf8");
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.log(`[Baseline:Govern] Unable to read policy file, using default policy (${message})`);
+        }
+      }
+      const govern = new import_govern.BaselineGovernSystem({ persistPath: auditPath });
+      const createdPolicy = await govern.policies.create("baseline-default", policyContent, {
+        severity: "high",
+        enforcement: "block",
+        requireApproval: Boolean(options.requireApproval),
+        requiredApprovers: Array.isArray(options.requiredApprovers) ? options.requiredApprovers : ["govern-approver"],
+        rules: [
+          {
+            id: "restricted-sensitivity",
+            name: "Restricted sensitivity requires approval",
+            severity: "high",
+            enforcement: "block",
+            condition: { field: "sensitivity", equals: "restricted" },
+            message: "Restricted workloads must pass approval before enforcement."
+          }
+        ]
+      });
+      if (!createdPolicy.success || !createdPolicy.policy) {
+        throw new Error(createdPolicy.error || "Failed to create governance policy");
+      }
+      const policyId = createdPolicy.policy.id;
+      const approvedPolicy = await govern.policies.approve(policyId, String(options.approver || "baseline-cli"));
+      if (!approvedPolicy.success) {
+        throw new Error(approvedPolicy.error || "Failed to approve governance policy");
+      }
+      const enforcement = await govern.policies.enforce(policyId, {
+        resourceId: String(options.resourceId || inputPath),
+        requestedBy: String(options.requestedBy || "baseline-cli"),
+        sensitivity: String(options.sensitivity || "standard"),
+        mode: String(options.mode || this.state.customContextFolder || "development")
+      });
+      const compliance = await govern.compliance.check("ISO27001", {
+        documentation: options.documentation || "complete",
+        process: options.process || "complete"
+      });
+      const evidence = govern.getEvidenceBundle(policyId, String(options.resourceId || inputPath));
+      const violations = enforcement.evaluation?.violations ?? [];
+      const policyResult = {
+        policiesEvaluated: 1,
+        policiesPassed: enforcement.success ? 1 : 0,
+        policiesFailed: enforcement.success ? 0 : 1,
+        violations,
+        enforcementAction: enforcement.evaluation?.enforcementAction ?? "allow",
+        requiresApproval: enforcement.evaluation?.requiresApproval ?? false
+      };
+      const auditResult = {
+        auditId: `audit-${Date.now()}`,
+        passed: enforcement.success,
+        findings: violations.map((violation) => violation.message),
+        severity: violations.length > 0 ? "high" : "none",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        events: evidence.auditTrail.length
+      };
+      const complianceResult = {
+        compliant: compliance.compliance?.compliant ?? false,
+        standards: ["ISO27001"],
+        certifications: [],
+        gaps: compliance.compliance?.violations ?? []
+      };
+      console.log("[Baseline:Govern] Governance layer processing complete");
+      return {
+        success: enforcement.success,
+        audit: auditResult,
+        policy: policyResult,
+        compliance: complianceResult,
+        evaluation: enforcement.evaluation,
+        approval: enforcement.approval,
+        evidence
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute a chain of commands sequentially. Each command in the array
+   * is executed in order. If any command fails, the chain halts.
+   */
+  async executeChainedCommands(commands) {
+    console.log(`[Baseline:Chain] Executing ${commands.length} chained commands...`);
+    const results = {};
+    let overallSuccess = true;
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i].trim();
+      console.log(`[Baseline:Chain] Command ${i + 1}/${commands.length}: ${command}`);
+      try {
+        const result = await this.executeCommand(command);
+        results[`step_${i + 1}`] = result;
+        if (!result.success) {
+          overallSuccess = false;
+          console.log(`[Baseline:Chain] Command ${i + 1} failed: ${result.error || "unknown error"}`);
+          break;
+        }
+        console.log(`[Baseline:Chain] Command ${i + 1} completed successfully`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        overallSuccess = false;
+        results[`step_${i + 1}`] = { success: false, error: errorMessage };
+        console.log(`[Baseline:Chain] Command ${i + 1} threw error: ${errorMessage}`);
+        break;
+      }
+    }
+    console.log(`[Baseline:Chain] Chain execution ${overallSuccess ? "completed" : "failed"}`);
+    return {
+      success: overallSuccess,
+      results,
+      commandsExecuted: Object.keys(results).length,
+      totalCommands: commands.length
+    };
+  }
+  /**
+   * Add a command to the execution queue for deferred execution.
+   */
+  queueCommand(command) {
+    this.state.commandQueue.push(command);
+    console.log(`[Baseline:Queue] Command queued: ${command} (queue size: ${this.state.commandQueue.length})`);
+  }
+  /**
+   * Execute all commands currently in the queue, in FIFO order,
+   * then clear the queue.
+   */
+  async executeQueue() {
+    const queueLength = this.state.commandQueue.length;
+    if (queueLength === 0) {
+      console.log("[Baseline:Queue] Queue is empty, nothing to execute");
+      return { success: true, message: "Queue is empty" };
+    }
+    console.log(`[Baseline:Queue] Executing ${queueLength} queued commands...`);
+    const commands = [...this.state.commandQueue];
+    this.state.commandQueue = [];
+    const result = await this.executeChainedCommands(commands);
+    console.log(`[Baseline:Queue] Queue execution complete`);
+    return result;
+  }
+  /**
+   * Execute a single command string by dispatching to the appropriate
+   * handler based on the command flag.
+   */
+  async executeCommand(command) {
+    const trimmed = command.trim();
+    console.log(`[Baseline:Command] Executing: ${trimmed}`);
+    const parts = trimmed.split(/\s+/);
+    const mainCommand = parts[0];
+    const options = {};
+    const positionals = [];
+    for (let i = 1; i < parts.length; i++) {
+      if (parts[i].startsWith("--")) {
+        const key = parts[i].replace(/^--/, "");
+        const value = parts[i + 1] && !parts[i + 1].startsWith("--") ? parts[++i] : "true";
+        options[key] = value;
+      } else {
+        positionals.push(parts[i]);
+      }
+    }
+    options._ = positionals;
+    switch (mainCommand) {
+      case "--onboard":
+        return await this.executeOnboarding(options);
+      case "--experience":
+        return await this.executeExperience(options);
+      case "--config":
+        return await this.executeConfig(options);
+      case "--index":
+        return await this.executeIndex(options);
+      case "--serve":
+        return await this.executeServe(options);
+      case "--persona":
+        return this.executePersona(options);
+      case "--agents":
+        return await this.executeAgents(options);
+      case "--doctor":
+        return await this.executeDoctor(options);
+      case "--baseline":
+        return await this.executeBaselineWorkflow(options);
+      case "--baseline-lang":
+        return await this.executeBaselineLang(options);
+      case "--baseline-frame":
+        return await this.executeBaselineFrame(options);
+      case "--baseline-studio":
+        return await this.executeBaselineStudio(options);
+      case "--baseline-govern":
+        return await this.executeBaselineGovern(options);
+      case "--init":
+        return await this.executeInit(options);
+      case "--run":
+        return await this.executeBaselineWorkflow(options);
+      case "--status": {
+        const status = this.getStatus();
+        return { success: true, ...status };
+      }
+      case "--help":
+        this.showHelp();
+        return { success: true };
+      default:
+        console.log(`[Baseline:Command] Unknown command: ${mainCommand}`);
+        return {
+          success: false,
+          error: `Unknown command: ${mainCommand}. Use --help for available commands.`
+        };
+    }
+  }
+  /**
+   * Return the current status of the Baseline system, including
+   * state, execution history, and queue contents.
+   */
+  getStatus() {
+    const status = {
+      baselineMode: this.state.baselineMode,
+      customContextFolder: this.state.customContextFolder,
+      queueLength: this.state.commandQueue.length,
+      queuedCommands: [...this.state.commandQueue],
+      executionHistoryCount: this.state.executionHistory.length,
+      currentWorkflow: this.state.currentWorkflow ? {
+        id: this.state.currentWorkflow.id,
+        status: this.state.currentWorkflow.status,
+        startTime: this.state.currentWorkflow.startTime.toISOString()
+      } : null,
+      recentExecutions: this.state.executionHistory.slice(-5).map(
+        (execution) => ({
+          id: execution.id,
+          status: execution.status,
+          duration: execution.duration,
+          startTime: execution.startTime.toISOString(),
+          error: execution.error || null
+        })
+      ),
+      megagemConnected: this.megagem !== null,
+      contextEngineConnected: this.contextEngine !== null,
+      lexiconEntries: Object.keys(this.baselineLang.lexicon).length,
+      syntaxPatterns: Object.keys(this.baselineLang.syntax).length,
+      commands: Object.keys(this.baselineLang.commands).length
+    };
+    const layers = ["lang", "frame", "studio", "govern", "experience", "autonomy", "persona"];
+    const layerStatus = layers.map((id) => {
+      const lastExec = this.state.executionHistory.filter((e) => e.status === "completed").slice(-1)[0];
+      return { id, status: "armed", lastCheck: lastExec ? "passed" : "none" };
+    });
+    status.layers = layerStatus;
+    console.log("[Baseline:Status]");
+    console.log(`  Mode: ${status.baselineMode ? "active" : "inactive"}`);
+    console.log(`  Context: ${status.customContextFolder || "none"}`);
+    console.log(`  Queue: ${status.queueLength} commands`);
+    console.log(`  History: ${status.executionHistoryCount} executions`);
+    console.log(`  MEGAGEM: ${status.megagemConnected ? "connected" : "disconnected"}`);
+    console.log(`  Context Engine: ${status.contextEngineConnected ? "connected" : "disconnected"}`);
+    console.log("");
+    console.log("  Governance Layers:");
+    for (const layer of layerStatus) {
+      const dot = layer.lastCheck === "passed" ? "\u25CF" : layer.lastCheck === "failed" ? "\u25CB" : "\u25CC";
+      console.log(`    ${dot} ${layer.id.padEnd(12)} ${layer.status.padEnd(8)} last check: ${layer.lastCheck}`);
+    }
+    return status;
+  }
+  /**
+   * Display help information for all available commands, flags,
+   * and syntax patterns.
+   */
+  showHelp() {
+    console.log("");
+    console.log("=== Baseline Protocol CLI ===");
+    console.log("");
+    console.log("COMMANDS:");
+    console.log("");
+    for (const [flag, entry] of Object.entries(this.baselineLang.commands)) {
+      console.log(`  ${flag.padEnd(20)} ${entry.description}`);
+    }
+    console.log("");
+    console.log("LAYER FLAGS:");
+    console.log("");
+    for (const [flag, entry] of Object.entries(this.baselineLang.lexicon)) {
+      console.log(`  ${flag.padEnd(24)} ${entry.description}`);
+      console.log(`  ${"".padEnd(24)} Usage: ${entry.usage}`);
+      console.log(`  ${"".padEnd(24)} Category: ${entry.category}`);
+      if (entry.examples.length > 0) {
+        console.log(`  ${"".padEnd(24)} Examples:`);
+        for (const example of entry.examples) {
+          console.log(`  ${"".padEnd(28)} ${example}`);
+        }
+      }
+      console.log("");
+    }
+    console.log("SYNTAX PATTERNS:");
+    console.log("");
+    for (const [name, entry] of Object.entries(this.baselineLang.syntax)) {
+      console.log(`  ${name}:`);
+      console.log(`    Pattern: ${entry.pattern}`);
+      console.log("    Parameters:");
+      for (const [param, desc] of Object.entries(entry.parameters)) {
+        console.log(`      --${param.padEnd(16)} ${desc}`);
+      }
+      if (entry.examples.length > 0) {
+        console.log("    Examples:");
+        for (const example of entry.examples) {
+          console.log(`      ${example}`);
+        }
+      }
+      console.log("");
+    }
+    console.log("USAGE:");
+    console.log("  baseline --init                        Initialize a new project");
+    console.log("  baseline --run                         Run the full workflow");
+    console.log("  baseline --baseline --mode production   Run in production mode");
+    console.log("  baseline --status                      Check system status");
+    console.log("  baseline --help                        Show this help");
+    console.log("");
+  }
+  /**
+   * Set the MEGAGEM integration instance for autonomous operations.
+   */
+  setMegagem(megagem) {
+    this.megagem = megagem;
+    console.log("[Baseline] MEGAGEM integration connected");
+  }
+  /**
+   * Set the Context Engine integration instance for context management.
+   */
+  setContextEngine(contextEngine) {
+    this.contextEngine = contextEngine;
+    console.log("[Baseline] Context Engine integration connected");
+  }
+};
+
+// src/megagem.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/config/megagem-config.json
+var megagem_config_default = {
+  system: {
+    name: "MEGAGEM AI Autonomous Framework",
+    version: "1.0.0",
+    description: "The most advanced AI autonomy system ever built. Enables AI to truly OWN and EMPOWER projects autonomously.",
+    author: "GTCX Development Team",
+    license: "MIT",
+    created: "2025-08-12",
+    status: "active"
+  },
+  autonomy: {
+    defaultLevel: 0,
+    maxLevel: 100,
+    incrementStep: 25,
+    levels: {
+      "0": {
+        name: "Manual Control",
+        description: "AI waits for explicit commands",
+        capabilities: ["command_execution", "basic_assistance"],
+        safety: "maximum",
+        humanOversight: "required"
+      },
+      "25": {
+        name: "Assisted Autonomy",
+        description: "AI suggests actions, user approves",
+        capabilities: ["suggestion_generation", "plan_creation", "user_approval"],
+        safety: "high",
+        humanOversight: "required"
+      },
+      "50": {
+        name: "Collaborative Autonomy",
+        description: "AI executes approved plans autonomously",
+        capabilities: ["plan_execution", "resource_management", "progress_tracking"],
+        safety: "medium",
+        humanOversight: "periodic"
+      },
+      "75": {
+        name: "Strategic Autonomy",
+        description: "AI makes strategic decisions and executes",
+        capabilities: ["strategic_planning", "decision_making", "autonomous_execution"],
+        safety: "medium",
+        humanOversight: "minimal"
+      },
+      "100": {
+        name: "Full Autonomy",
+        description: "AI owns entire projects autonomously",
+        capabilities: ["project_ownership", "full_decision_making", "autonomous_evolution"],
+        safety: "monitored",
+        humanOversight: "audit_only"
+      }
+    },
+    safetyThresholds: {
+      riskTolerance: "medium",
+      humanOversight: "required",
+      decisionApproval: "automatic",
+      emergencyStop: true,
+      boundaryEnforcement: true
+    }
+  },
+  learning: {
+    continuousLearning: true,
+    selfImprovement: true,
+    knowledgeSharing: true,
+    learningMethods: {
+      supervised: true,
+      unsupervised: true,
+      reinforcement: true,
+      transfer: true,
+      meta: true
+    },
+    improvementAreas: {
+      decisionMaking: true,
+      efficiency: true,
+      creativity: true,
+      collaboration: true,
+      safety: true
+    },
+    learningRate: 0.1,
+    knowledgeRetention: 0.95,
+    adaptationSpeed: "adaptive"
+  },
+  safety: {
+    riskAssessment: true,
+    boundaryEnforcement: true,
+    humanOverride: true,
+    auditLogging: true,
+    emergencyStop: true,
+    riskCategories: {
+      operational: "high",
+      strategic: "medium",
+      ethical: "critical",
+      legal: "critical",
+      technical: "medium"
+    },
+    safetyProtocols: {
+      preAction: true,
+      duringAction: true,
+      postAction: true,
+      emergency: true
+    },
+    safetyLevels: {
+      low: "proceed_with_monitoring",
+      medium: "proceed_with_caution",
+      high: "require_approval",
+      critical: "immediate_stop"
+    }
+  },
+  collaboration: {
+    multiAgent: true,
+    teamFormation: true,
+    taskDistribution: true,
+    coordination: true,
+    communication: true,
+    conflictResolution: true,
+    agentTypes: {
+      strategist: true,
+      executor: true,
+      analyst: true,
+      coordinator: true,
+      innovator: true
+    },
+    collaborationModels: {
+      hierarchical: true,
+      collaborative: true,
+      adaptive: true,
+      emergent: true
+    }
+  },
+  decisionMaking: {
+    strategicThinking: true,
+    riskAssessment: true,
+    resourceOptimization: true,
+    goalOrientedPlanning: true,
+    adaptiveStrategy: true,
+    decisionTypes: {
+      tactical: true,
+      strategic: true,
+      operational: true,
+      innovative: true
+    },
+    decisionProcess: {
+      analysis: true,
+      evaluation: true,
+      selection: true,
+      execution: true,
+      monitoring: true
+    }
+  },
+  projectOwnership: {
+    projectInitiation: true,
+    resourceAllocation: true,
+    teamFormation: true,
+    executionManagement: true,
+    qualityControl: true,
+    deliveryManagement: true,
+    ownershipLevels: {
+      partial: true,
+      collaborative: true,
+      primary: true,
+      full: true
+    },
+    projectTypes: {
+      development: true,
+      research: true,
+      operations: true,
+      innovation: true
+    }
+  },
+  performance: {
+    metrics: {
+      efficiency: true,
+      accuracy: true,
+      speed: true,
+      quality: true,
+      innovation: true
+    },
+    monitoring: {
+      realTime: true,
+      historical: true,
+      predictive: true,
+      comparative: true
+    },
+    optimization: {
+      continuous: true,
+      adaptive: true,
+      goalOriented: true,
+      selfImproving: true
+    }
+  },
+  integration: {
+    mantraAI: {
+      enabled: true,
+      integrationLevel: "deep",
+      capabilities: ["strategic_thinking", "autonomous_planning"]
+    },
+    langChain: {
+      enabled: true,
+      integrationLevel: "deep",
+      capabilities: ["tool_orchestration", "workflow_management"]
+    },
+    autoGen: {
+      enabled: true,
+      integrationLevel: "medium",
+      capabilities: ["multi_agent_collaboration"]
+    },
+    crewAI: {
+      enabled: true,
+      integrationLevel: "medium",
+      capabilities: ["project_management", "team_orchestration"]
+    }
+  },
+  evolution: {
+    selfImprovement: true,
+    capabilityExpansion: true,
+    knowledgeEvolution: true,
+    strategyOptimization: true,
+    adaptationMechanisms: {
+      environmental: true,
+      performance: true,
+      user: true,
+      internal: true
+    },
+    evolutionSpeed: "adaptive",
+    improvementThreshold: 0.05
+  },
+  userInterface: {
+    autonomyControl: {
+      levelSlider: true,
+      safetySettings: true,
+      learningPreferences: true,
+      performanceMetrics: true
+    },
+    monitoring: {
+      realTimeStatus: true,
+      projectOverview: true,
+      safetyAlerts: true,
+      performanceDashboard: true
+    },
+    interaction: {
+      naturalLanguage: true,
+      visualInterface: true,
+      mobileAccess: true,
+      voiceControl: true
+    }
+  },
+  deployment: {
+    environment: "production",
+    scalability: "auto",
+    reliability: "99.9%",
+    security: "enterprise",
+    monitoring: "comprehensive",
+    backup: "automated",
+    recovery: "instant"
+  }
+};
+
+// src/megagem.ts
+var MEGAGEMCoreSystem = class {
+  systemName;
+  version;
+  autonomyLevel;
+  isActive;
+  learningMode;
+  safetyMode;
+  autonomyController;
+  decisionEngine;
+  projectOwner;
+  learningEngine;
+  safetyEngine;
+  collaborationEngine;
+  currentProjects;
+  performanceMetrics;
+  learningHistory;
+  safetyEvents;
+  config;
+  constructor() {
+    this.systemName = "MEGAGEM";
+    this.version = "1.0.0";
+    this.autonomyLevel = 1;
+    this.isActive = false;
+    this.learningMode = false;
+    this.safetyMode = true;
+    this.autonomyController = this.initializeAutonomyController();
+    this.decisionEngine = this.initializeDecisionEngine();
+    this.projectOwner = this.initializeProjectOwner();
+    this.learningEngine = this.initializeLearningEngine();
+    this.safetyEngine = this.initializeSafetyEngine();
+    this.collaborationEngine = this.initializeCollaborationEngine();
+    this.currentProjects = /* @__PURE__ */ new Map();
+    this.performanceMetrics = {
+      decisionsAccuracy: 0,
+      taskCompletionRate: 0,
+      learningRate: 0,
+      collaborationScore: 0,
+      safetyCompliance: 1,
+      totalDecisions: 0,
+      totalTasks: 0,
+      totalCollaborations: 0,
+      uptime: 0,
+      startTime: /* @__PURE__ */ new Date()
+    };
+    this.learningHistory = [];
+    this.safetyEvents = [];
+    this.config = this.getDefaultConfig();
+  }
+  /**
+   * Set up the autonomy controller with five operational levels
+   * and escalation rules.
+   */
+  initializeAutonomyController() {
+    return {
+      currentLevel: 1,
+      maxLevel: 5,
+      levels: {
+        1: { name: "Supervised", description: "All actions require human approval" },
+        2: { name: "Guided", description: "Routine actions auto-approved, complex actions require approval" },
+        3: { name: "Collaborative", description: "Most actions auto-approved, high-risk actions require approval" },
+        4: { name: "Autonomous", description: "Almost all actions auto-approved, critical actions require approval" },
+        5: { name: "Full Autonomy", description: "All actions auto-approved with safety constraints" }
+      },
+      escalationRules: [
+        { condition: "high_risk_detected", action: "reduce_autonomy", targetLevel: 1 },
+        { condition: "safety_violation", action: "emergency_stop", targetLevel: 0 },
+        { condition: "repeated_success", action: "increase_autonomy", targetLevel: -1 },
+        { condition: "human_override", action: "set_supervised", targetLevel: 1 }
+      ],
+      overrideActive: false
+    };
+  }
+  /**
+   * Set up the decision engine with thresholds and history tracking.
+   */
+  initializeDecisionEngine() {
+    return {
+      pendingDecisions: [],
+      decisionHistory: [],
+      decisionThresholds: {
+        lowRisk: 0.3,
+        mediumRisk: 0.6,
+        highRisk: 0.8,
+        criticalRisk: 0.95
+      },
+      autoApprove: false
+    };
+  }
+  /**
+   * Set up the project ownership engine with project stores and templates.
+   */
+  initializeProjectOwner() {
+    return {
+      activeProjects: /* @__PURE__ */ new Map(),
+      completedProjects: /* @__PURE__ */ new Map(),
+      projectTemplates: /* @__PURE__ */ new Map([
+        [
+          "standard",
+          {
+            phases: ["planning", "design", "implementation", "testing", "deployment"],
+            milestones: ["kickoff", "design-review", "alpha", "beta", "release"],
+            roles: ["lead", "developer", "designer", "tester", "reviewer"]
+          }
+        ],
+        [
+          "agile",
+          {
+            phases: ["backlog", "sprint-planning", "sprint", "review", "retrospective"],
+            milestones: ["sprint-start", "mid-sprint", "sprint-end", "demo"],
+            roles: ["product-owner", "scrum-master", "developer", "tester"]
+          }
+        ],
+        [
+          "research",
+          {
+            phases: ["exploration", "hypothesis", "experimentation", "analysis", "publication"],
+            milestones: ["proposal", "data-collection", "analysis-complete", "draft", "final"],
+            roles: ["principal-investigator", "researcher", "analyst", "reviewer"]
+          }
+        ]
+      ])
+    };
+  }
+  /**
+   * Set up the learning engine with knowledge base and adaptation rate.
+   */
+  initializeLearningEngine() {
+    return {
+      knowledgeBase: /* @__PURE__ */ new Map(),
+      learningHistory: [],
+      patterns: /* @__PURE__ */ new Map(),
+      adaptationRate: 0.1
+    };
+  }
+  /**
+   * Set up the safety engine with risk assessment stores and boundary
+   * configuration.
+   */
+  initializeSafetyEngine() {
+    return {
+      riskAssessments: /* @__PURE__ */ new Map(),
+      boundaries: /* @__PURE__ */ new Map([
+        ["max_file_operations", { limit: 1e3, current: 0 }],
+        ["max_network_requests", { limit: 100, current: 0 }],
+        ["max_memory_usage_mb", { limit: 512, current: 0 }],
+        ["max_execution_time_ms", { limit: 3e5, current: 0 }],
+        ["forbidden_operations", { list: ["delete_system_files", "modify_credentials", "disable_logging"] }]
+      ]),
+      safetyEvents: [],
+      overrideEnabled: true
+    };
+  }
+  /**
+   * Set up the collaboration engine with registries and communication log.
+   */
+  initializeCollaborationEngine() {
+    return {
+      activeCollaborations: /* @__PURE__ */ new Map(),
+      communicationLog: [],
+      teamRegistry: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * Perform full system initialization: activate learning, safety, and
+   * log startup information.
+   */
+  async initializeSystem() {
+    console.log(`[${this.systemName}] Initializing core system v${this.version}...`);
+    this.isActive = true;
+    this.learningMode = true;
+    this.safetyMode = true;
+    this.performanceMetrics.startTime = /* @__PURE__ */ new Date();
+    console.log(`[${this.systemName}] Autonomy controller ready (level ${this.autonomyController.currentLevel})`);
+    console.log(`[${this.systemName}] Decision engine ready`);
+    console.log(`[${this.systemName}] Project ownership engine ready`);
+    console.log(`[${this.systemName}] Learning engine ready (rate: ${this.learningEngine.adaptationRate})`);
+    console.log(`[${this.systemName}] Safety engine ready (override: ${this.safetyEngine.overrideEnabled})`);
+    console.log(`[${this.systemName}] Collaboration engine ready`);
+    console.log(`[${this.systemName}] System initialization complete`);
+    return {
+      success: true,
+      status: this.getSystemStatus()
+    };
+  }
+  /**
+   * Set the autonomy level (1-5) and update the system behavior accordingly.
+   */
+  setAutonomyLevel(level) {
+    if (level < 1 || level > this.autonomyController.maxLevel) {
+      console.log(
+        `[${this.systemName}] Invalid autonomy level: ${level}. Must be 1-${this.autonomyController.maxLevel}`
+      );
+      return {
+        success: false,
+        level: this.autonomyLevel,
+        name: this.autonomyController.levels[this.autonomyLevel].name,
+        error: `Level must be between 1 and ${this.autonomyController.maxLevel}`
+      };
+    }
+    const previousLevel = this.autonomyLevel;
+    this.autonomyLevel = level;
+    this.autonomyController.currentLevel = level;
+    this.updateSystemBehavior(level);
+    console.log(
+      `[${this.systemName}] Autonomy level changed: ${previousLevel} -> ${level} (${this.autonomyController.levels[level].name})`
+    );
+    return {
+      success: true,
+      level,
+      name: this.autonomyController.levels[level].name
+    };
+  }
+  /**
+   * Update internal system behavior based on the autonomy level.
+   */
+  updateSystemBehavior(level) {
+    switch (level) {
+      case 1:
+        this.decisionEngine.autoApprove = false;
+        this.safetyEngine.overrideEnabled = true;
+        break;
+      case 2:
+        this.decisionEngine.autoApprove = false;
+        this.safetyEngine.overrideEnabled = true;
+        break;
+      case 3:
+        this.decisionEngine.autoApprove = true;
+        this.safetyEngine.overrideEnabled = true;
+        break;
+      case 4:
+        this.decisionEngine.autoApprove = true;
+        this.safetyEngine.overrideEnabled = true;
+        break;
+      case 5:
+        this.decisionEngine.autoApprove = true;
+        this.safetyEngine.overrideEnabled = false;
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   * Return a comprehensive snapshot of the current system status.
+   */
+  getSystemStatus() {
+    const now = /* @__PURE__ */ new Date();
+    const uptimeMs = now.getTime() - this.performanceMetrics.startTime.getTime();
+    return {
+      systemName: this.systemName,
+      version: this.version,
+      isActive: this.isActive,
+      autonomyLevel: this.autonomyLevel,
+      autonomyName: this.autonomyController.levels[this.autonomyLevel]?.name || "unknown",
+      learningMode: this.learningMode,
+      safetyMode: this.safetyMode,
+      uptime: uptimeMs,
+      activeProjects: this.projectOwner.activeProjects.size,
+      completedProjects: this.projectOwner.completedProjects.size,
+      pendingDecisions: this.decisionEngine.pendingDecisions.length,
+      performanceMetrics: { ...this.performanceMetrics },
+      safetyEvents: this.safetyEvents.length,
+      learningHistory: this.learningHistory.length,
+      knowledgeBaseSize: this.learningEngine.knowledgeBase.size,
+      activeCollaborations: this.collaborationEngine.activeCollaborations.size
+    };
+  }
+  /**
+   * Attempt to load a configuration file from the given path.
+   * Falls back to defaults if the file does not exist.
+   */
+  loadConfiguration(configPath) {
+    try {
+      const fullPath = (0, import_path.join)(configPath, "megagem.config.json");
+      if ((0, import_fs.existsSync)(fullPath)) {
+        const raw = (0, import_fs.readFileSync)(fullPath, "utf-8");
+        const loaded = JSON.parse(raw);
+        this.config = loaded;
+        console.log(`[${this.systemName}] Configuration loaded from ${fullPath}`);
+        return loaded;
+      }
+      console.log(`[${this.systemName}] No config file found at ${fullPath}, using defaults`);
+      return this.config;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.log(`[${this.systemName}] Error loading configuration: ${msg}`);
+      return this.config;
+    }
+  }
+  /**
+   * Return the default MEGAGEM configuration object.
+   */
+  getDefaultConfig() {
+    const cfg = megagem_config_default;
+    const autonomy = cfg.autonomy ?? {};
+    const thresholds = autonomy.safetyThresholds ?? {};
+    return {
+      system: {
+        name: cfg.system?.name ?? "MEGAGEM",
+        version: cfg.system?.version ?? "1.0.0",
+        description: cfg.system?.description ?? "Multi-Environment General-purpose Autonomous Governance and Execution Manager"
+      },
+      autonomy: {
+        defaultLevel: autonomy.defaultLevel ?? 1,
+        maxLevel: autonomy.maxLevel ?? 5,
+        safetyThresholds: {
+          riskTolerance: thresholds.riskTolerance ?? "medium",
+          humanOversight: thresholds.humanOversight ?? "required"
+        }
+      },
+      learning: {
+        continuousLearning: cfg.learning?.continuousLearning ?? true,
+        selfImprovement: cfg.learning?.selfImprovement ?? true,
+        knowledgeSharing: cfg.learning?.knowledgeSharing ?? true
+      },
+      safety: {
+        riskAssessment: cfg.safety?.riskAssessment ?? true,
+        boundaryEnforcement: cfg.safety?.boundaryEnforcement ?? true,
+        humanOverride: cfg.safety?.humanOverride ?? true,
+        auditLogging: cfg.safety?.auditLogging ?? true
+      }
+    };
+  }
+  /**
+   * Activate autonomous operation mode: sets the system active, starts
+   * performance tracking, and returns the active capabilities.
+   */
+  async startAutonomousOperation() {
+    if (!this.isActive) {
+      await this.initializeSystem();
+    }
+    console.log(`[${this.systemName}] Starting autonomous operation at level ${this.autonomyLevel}...`);
+    const capabilities = this.activateAutonomousCapabilities();
+    console.log(`[${this.systemName}] Autonomous capabilities activated: ${capabilities.join(", ")}`);
+    return {
+      success: true,
+      capabilities
+    };
+  }
+  /**
+   * Determine which capabilities should be active given the current
+   * autonomy level and return them as a list.
+   */
+  activateAutonomousCapabilities() {
+    const capabilities = [
+      "monitoring",
+      "reporting",
+      "status_tracking"
+    ];
+    if (this.autonomyLevel >= 2) {
+      capabilities.push("routine_decisions", "task_scheduling", "resource_monitoring");
+    }
+    if (this.autonomyLevel >= 3) {
+      capabilities.push("project_planning", "team_coordination", "risk_assessment");
+    }
+    if (this.autonomyLevel >= 4) {
+      capabilities.push("autonomous_execution", "adaptive_planning", "self_optimization");
+    }
+    if (this.autonomyLevel >= 5) {
+      capabilities.push("full_project_ownership", "strategic_planning", "cross_project_optimization");
+    }
+    return capabilities;
+  }
+  /**
+   * Return the list of capabilities currently active.
+   */
+  getActiveCapabilities() {
+    return this.activateAutonomousCapabilities();
+  }
+};
+var MEGAGEMAutonomousAgent = class {
+  agentId;
+  agentType;
+  capabilities;
+  autonomyLevel;
+  isActive;
+  currentProjects;
+  performanceMetrics;
+  learningHistory;
+  collaborationHistory;
+  status;
+  currentTask;
+  teamMembers;
+  resources;
+  knowledgeBase;
+  skillLevels;
+  adaptationRate;
+  constructor(agentType = "general", autonomyLevel = 1) {
+    this.agentId = this.generateAgentId();
+    this.agentType = agentType;
+    this.capabilities = {};
+    this.autonomyLevel = autonomyLevel;
+    this.isActive = false;
+    this.currentProjects = /* @__PURE__ */ new Map();
+    this.performanceMetrics = {
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      successRate: 1,
+      averageCompletionTime: 0,
+      qualityScore: 1,
+      learningProgress: 0
+    };
+    this.learningHistory = [];
+    this.collaborationHistory = [];
+    this.status = "idle";
+    this.currentTask = null;
+    this.teamMembers = [];
+    this.resources = /* @__PURE__ */ new Map();
+    this.knowledgeBase = /* @__PURE__ */ new Map();
+    this.skillLevels = /* @__PURE__ */ new Map();
+    this.adaptationRate = 0.1;
+    this.initializeCapabilities(agentType);
+  }
+  /**
+   * Generate a unique agent identifier.
+   */
+  generateAgentId() {
+    return `agent-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Activate the agent for autonomous operation.
+   */
+  activate() {
+    this.isActive = true;
+    this.status = "active";
+    console.log(`[Agent:${this.agentId}] Activated as ${this.agentType} agent (autonomy level ${this.autonomyLevel})`);
+  }
+  /**
+   * Initialize capabilities based on the agent type. Supports five
+   * types: project-manager, developer, designer, analyst, general.
+   */
+  initializeCapabilities(agentType) {
+    switch (agentType) {
+      case "project-manager":
+        this.capabilities = {
+          planning: true,
+          scheduling: true,
+          resourceAllocation: true,
+          riskManagement: true,
+          teamCoordination: true,
+          reporting: true,
+          budgetManagement: true,
+          stakeholderCommunication: true,
+          qualityAssurance: true,
+          scope: "project",
+          specializations: ["waterfall", "agile", "hybrid"]
+        };
+        this.skillLevels.set("planning", 0.9);
+        this.skillLevels.set("communication", 0.85);
+        this.skillLevels.set("risk-assessment", 0.8);
+        this.skillLevels.set("resource-management", 0.85);
+        this.skillLevels.set("quality-control", 0.8);
+        break;
+      case "developer":
+        this.capabilities = {
+          coding: true,
+          testing: true,
+          debugging: true,
+          codeReview: true,
+          architecture: true,
+          documentation: true,
+          deployment: true,
+          optimization: true,
+          scope: "technical",
+          specializations: ["frontend", "backend", "fullstack", "devops"]
+        };
+        this.skillLevels.set("coding", 0.9);
+        this.skillLevels.set("testing", 0.85);
+        this.skillLevels.set("architecture", 0.8);
+        this.skillLevels.set("debugging", 0.85);
+        this.skillLevels.set("documentation", 0.7);
+        break;
+      case "designer":
+        this.capabilities = {
+          uiDesign: true,
+          uxResearch: true,
+          prototyping: true,
+          visualDesign: true,
+          designSystems: true,
+          accessibility: true,
+          userTesting: true,
+          scope: "design",
+          specializations: ["ui", "ux", "graphic", "interaction"]
+        };
+        this.skillLevels.set("visual-design", 0.9);
+        this.skillLevels.set("ux-research", 0.85);
+        this.skillLevels.set("prototyping", 0.8);
+        this.skillLevels.set("accessibility", 0.75);
+        this.skillLevels.set("design-systems", 0.8);
+        break;
+      case "analyst":
+        this.capabilities = {
+          dataAnalysis: true,
+          reporting: true,
+          forecasting: true,
+          visualization: true,
+          requirementsGathering: true,
+          processModeling: true,
+          scope: "analytical",
+          specializations: ["data", "business", "systems", "security"]
+        };
+        this.skillLevels.set("data-analysis", 0.9);
+        this.skillLevels.set("reporting", 0.85);
+        this.skillLevels.set("forecasting", 0.8);
+        this.skillLevels.set("visualization", 0.8);
+        this.skillLevels.set("requirements", 0.85);
+        break;
+      case "general":
+      default:
+        this.capabilities = {
+          planning: true,
+          execution: true,
+          monitoring: true,
+          reporting: true,
+          collaboration: true,
+          learning: true,
+          scope: "general",
+          specializations: ["general-purpose"]
+        };
+        this.skillLevels.set("planning", 0.7);
+        this.skillLevels.set("execution", 0.7);
+        this.skillLevels.set("monitoring", 0.7);
+        this.skillLevels.set("reporting", 0.7);
+        this.skillLevels.set("collaboration", 0.7);
+        break;
+    }
+  }
+  /**
+   * Take ownership of a project, creating the internal project record
+   * and setting status to planning.
+   */
+  async takeProjectOwnership(projectData) {
+    const projectId = this.generateProjectId();
+    const project = {
+      id: projectId,
+      name: projectData.name,
+      description: projectData.description,
+      type: projectData.type,
+      status: "planning",
+      ownershipLevel: "full",
+      startDate: /* @__PURE__ */ new Date(),
+      objectives: projectData.objectives || [],
+      constraints: projectData.constraints || [],
+      resources: projectData.resources || {},
+      timeline: projectData.timeline || {},
+      team: /* @__PURE__ */ new Set([this.agentId]),
+      tasks: /* @__PURE__ */ new Map(),
+      milestones: /* @__PURE__ */ new Map(),
+      risks: /* @__PURE__ */ new Map(),
+      progress: 0
+    };
+    this.currentProjects.set(projectId, project);
+    console.log(`[Agent:${this.agentId}] Took ownership of project: ${projectData.name} (${projectId})`);
+    return project;
+  }
+  /**
+   * Execute a project autonomously through all lifecycle phases:
+   * plan -> form team -> allocate resources -> execute -> monitor -> deliver.
+   */
+  async executeProjectAutonomously(projectId) {
+    const project = this.currentProjects.get(projectId);
+    if (!project) {
+      throw new Error(`Project ${projectId} not found`);
+    }
+    console.log(`[Agent:${this.agentId}] Starting autonomous execution of project: ${project.name}`);
+    try {
+      project.status = "planning";
+      console.log(`[Agent:${this.agentId}] Phase 1: Planning project...`);
+      await this.planProject(project);
+      project.status = "team-formation";
+      console.log(`[Agent:${this.agentId}] Phase 2: Forming project team...`);
+      await this.formProjectTeam(project);
+      project.status = "resource-allocation";
+      console.log(`[Agent:${this.agentId}] Phase 3: Allocating resources...`);
+      await this.allocateResources(project);
+      project.status = "in-progress";
+      console.log(`[Agent:${this.agentId}] Phase 4: Executing project plan...`);
+      await this.executeProjectPlan(project);
+      project.status = "monitoring";
+      console.log(`[Agent:${this.agentId}] Phase 5: Monitoring and controlling...`);
+      await this.monitorAndControl(project);
+      project.status = "delivering";
+      console.log(`[Agent:${this.agentId}] Phase 6: Delivering project...`);
+      await this.deliverProject(project);
+      project.status = "completed";
+      project.endDate = /* @__PURE__ */ new Date();
+      project.progress = 100;
+      console.log(`[Agent:${this.agentId}] Project ${project.name} completed successfully`);
+      return project;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      project.status = "failed";
+      project.error = errorMessage;
+      console.log(`[Agent:${this.agentId}] Project ${project.name} failed: ${errorMessage}`);
+      return project;
+    }
+  }
+  /**
+   * Create a strategic plan for the project including phases, milestones,
+   * task breakdown, timeline, resource plan, and risk assessment.
+   */
+  async planProject(project) {
+    const strategicPlan = this.createStrategicPlan(project);
+    project.plan = strategicPlan;
+    const phases = this.defineProjectPhases(project);
+    project.plan.phases = phases;
+    const milestones = this.defineMilestones(project);
+    for (const milestone of milestones) {
+      project.milestones.set(milestone.id, milestone);
+    }
+    const tasks = this.breakDownTasks(project);
+    for (const task of tasks) {
+      project.tasks.set(task.id, task);
+    }
+    const timeline = this.createTimeline(project);
+    project.timeline = timeline;
+    const resourcePlan = this.planResources(project);
+    project.plan.resources = resourcePlan;
+    const risks = this.assessRisks(project);
+    for (const risk of risks) {
+      project.risks.set(risk.id, risk);
+    }
+    project.strategy = strategicPlan;
+    console.log(
+      `[Agent:${this.agentId}] Project plan created: ${phases.length} phases, ${milestones.length} milestones, ${tasks.length} tasks, ${risks.length} risks`
+    );
+  }
+  /**
+   * Form a team for the project by analyzing requirements and assigning roles.
+   */
+  async formProjectTeam(project) {
+    const requirements = this.analyzeTeamRequirements(project);
+    const teamMembers = [];
+    for (const role of requirements.roles) {
+      const member = {
+        id: `member-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`,
+        role,
+        capabilities: this.getRoleCapabilities(role),
+        assignedDate: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "assigned"
+      };
+      teamMembers.push(member);
+      project.team.add(member.id);
+    }
+    project.teamMembers = teamMembers;
+    console.log(
+      `[Agent:${this.agentId}] Team formed: ${teamMembers.length} members for ${requirements.roles.length} roles`
+    );
+  }
+  /**
+   * Allocate resources to the project based on current plan and constraints.
+   */
+  async allocateResources(project) {
+    const resourceAllocation = {
+      compute: {
+        allocated: true,
+        type: "standard",
+        units: Math.max(1, project.tasks.size)
+      },
+      storage: {
+        allocated: true,
+        type: "standard",
+        sizeMB: 100
+      },
+      budget: {
+        allocated: true,
+        total: project.constraints.length > 0 ? 1e4 : 5e3,
+        spent: 0,
+        remaining: project.constraints.length > 0 ? 1e4 : 5e3
+      },
+      time: {
+        allocated: true,
+        totalHours: project.tasks.size * 8,
+        usedHours: 0,
+        remainingHours: project.tasks.size * 8
+      }
+    };
+    project.resources = resourceAllocation;
+    console.log(
+      `[Agent:${this.agentId}] Resources allocated: ${project.tasks.size} compute units, ${resourceAllocation.time.totalHours}h total`
+    );
+  }
+  /**
+   * Execute the project plan by iterating through all tasks.
+   */
+  async executeProjectPlan(project) {
+    const tasks = Array.from(project.tasks.entries());
+    let completedTasks = 0;
+    const totalTasks = tasks.length;
+    for (const [taskId, taskData] of tasks) {
+      const task = taskData;
+      console.log(`[Agent:${this.agentId}] Executing task: ${task.name} (${taskId})`);
+      const result = await this.executeTask(task);
+      if (result.success) {
+        task.status = "completed";
+        task.completedDate = (/* @__PURE__ */ new Date()).toISOString();
+        task.result = result.output;
+        completedTasks++;
+        this.performanceMetrics.tasksCompleted++;
+      } else {
+        task.status = "failed";
+        task.error = result.error;
+        this.performanceMetrics.tasksFailed++;
+        console.log(`[Agent:${this.agentId}] Task ${taskId} failed: ${result.error}`);
+      }
+      project.progress = Math.round(completedTasks / totalTasks * 80);
+    }
+    const totalAttempted = this.performanceMetrics.tasksCompleted + this.performanceMetrics.tasksFailed;
+    this.performanceMetrics.successRate = totalAttempted > 0 ? this.performanceMetrics.tasksCompleted / totalAttempted : 1;
+    console.log(
+      `[Agent:${this.agentId}] Plan execution complete: ${completedTasks}/${totalTasks} tasks completed`
+    );
+  }
+  /**
+   * Monitor project health and adjust the plan if deviations are detected.
+   */
+  async monitorAndControl(project) {
+    const health = this.assessProjectHealth(project);
+    project.healthMetrics = health;
+    console.log(
+      `[Agent:${this.agentId}] Project health: ${health.overall} (score: ${health.score})`
+    );
+    if (health.score < 0.7) {
+      console.log(`[Agent:${this.agentId}] Health below threshold, adjusting plan...`);
+      await this.adjustProjectPlan(project, health);
+    }
+    project.progress = 90;
+  }
+  /**
+   * Deliver project outputs, perform quality checks, and prepare deliverables.
+   */
+  async deliverProject(project) {
+    console.log(`[Agent:${this.agentId}] Performing final quality check...`);
+    const qualityResult = this.performQualityCheck(project);
+    project.qualityScore = qualityResult.score;
+    console.log(`[Agent:${this.agentId}] Preparing deliverables...`);
+    const deliverables = this.prepareDeliverables(project);
+    project.deliverables = deliverables;
+    project.progress = 100;
+    project.status = "delivered";
+    console.log(
+      `[Agent:${this.agentId}] Project ${project.name} delivered (quality: ${project.qualityScore})`
+    );
+  }
+  /**
+   * Build a strategic plan from the project's objectives and constraints.
+   */
+  createStrategicPlan(project) {
+    return {
+      projectId: project.id,
+      projectName: project.name,
+      vision: `Successfully deliver ${project.name}: ${project.description}`,
+      objectives: project.objectives.map((obj, index) => ({
+        id: `obj-${index + 1}`,
+        description: obj,
+        priority: index === 0 ? "high" : "medium",
+        status: "pending"
+      })),
+      constraints: project.constraints,
+      approach: project.type === "agile" ? "iterative" : "sequential",
+      riskStrategy: "proactive",
+      qualityStandard: "high",
+      communicationPlan: {
+        frequency: "daily",
+        channels: ["status-report", "milestone-review"],
+        stakeholders: ["team", "owner"]
+      },
+      createdDate: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Define project phases based on the project type.
+   */
+  defineProjectPhases(project) {
+    const phaseTemplates = {
+      standard: ["initiation", "planning", "execution", "monitoring", "closure"],
+      agile: ["backlog-refinement", "sprint-planning", "development", "review", "retrospective"],
+      research: ["exploration", "hypothesis", "experimentation", "analysis", "reporting"]
+    };
+    const phaseNames = phaseTemplates[project.type] || phaseTemplates["standard"];
+    return phaseNames.map((name, index) => ({
+      id: `phase-${index + 1}`,
+      name,
+      order: index + 1,
+      status: "pending",
+      startDate: null,
+      endDate: null,
+      dependencies: index > 0 ? [`phase-${index}`] : []
+    }));
+  }
+  /**
+   * Define milestones for the project plan.
+   */
+  defineMilestones(_project) {
+    const baseMilestones = [
+      "Project Kickoff",
+      "Requirements Complete",
+      "Design Approved",
+      "Development Complete",
+      "Testing Complete",
+      "Deployment Ready",
+      "Project Closure"
+    ];
+    return baseMilestones.map((name, index) => ({
+      id: `milestone-${index + 1}`,
+      name,
+      order: index + 1,
+      status: "pending",
+      dueDate: null,
+      criteria: [`${name} criteria met`],
+      deliverables: [`${name} artifacts`]
+    }));
+  }
+  /**
+   * Break project objectives down into concrete tasks.
+   */
+  breakDownTasks(project) {
+    const tasks = [];
+    let taskCounter = 0;
+    for (const objective of project.objectives) {
+      taskCounter++;
+      tasks.push({
+        id: `task-${taskCounter}`,
+        name: `Analyze: ${objective}`,
+        type: "analysis",
+        status: "pending",
+        priority: "high",
+        estimatedHours: 4,
+        assignee: null,
+        dependencies: []
+      });
+      taskCounter++;
+      tasks.push({
+        id: `task-${taskCounter}`,
+        name: `Implement: ${objective}`,
+        type: "implementation",
+        status: "pending",
+        priority: "high",
+        estimatedHours: 16,
+        assignee: null,
+        dependencies: [`task-${taskCounter - 1}`]
+      });
+      taskCounter++;
+      tasks.push({
+        id: `task-${taskCounter}`,
+        name: `Verify: ${objective}`,
+        type: "verification",
+        status: "pending",
+        priority: "medium",
+        estimatedHours: 4,
+        assignee: null,
+        dependencies: [`task-${taskCounter - 1}`]
+      });
+    }
+    if (tasks.length === 0) {
+      tasks.push(
+        {
+          id: "task-1",
+          name: "Setup project environment",
+          type: "setup",
+          status: "pending",
+          priority: "high",
+          estimatedHours: 4,
+          assignee: null,
+          dependencies: []
+        },
+        {
+          id: "task-2",
+          name: "Define project requirements",
+          type: "analysis",
+          status: "pending",
+          priority: "high",
+          estimatedHours: 8,
+          assignee: null,
+          dependencies: ["task-1"]
+        },
+        {
+          id: "task-3",
+          name: "Implement core functionality",
+          type: "implementation",
+          status: "pending",
+          priority: "high",
+          estimatedHours: 24,
+          assignee: null,
+          dependencies: ["task-2"]
+        },
+        {
+          id: "task-4",
+          name: "Test and validate",
+          type: "verification",
+          status: "pending",
+          priority: "medium",
+          estimatedHours: 8,
+          assignee: null,
+          dependencies: ["task-3"]
+        },
+        {
+          id: "task-5",
+          name: "Document and deliver",
+          type: "delivery",
+          status: "pending",
+          priority: "medium",
+          estimatedHours: 4,
+          assignee: null,
+          dependencies: ["task-4"]
+        }
+      );
+    }
+    return tasks;
+  }
+  /**
+   * Build a timeline for the project based on tasks and milestones.
+   */
+  createTimeline(project) {
+    const totalTasks = project.tasks.size;
+    const estimatedHours = totalTasks * 8;
+    const estimatedDays = Math.ceil(estimatedHours / 8);
+    const startDate = project.startDate;
+    const endDate = new Date(startDate);
+    endDate.setDate(endDate.getDate() + estimatedDays);
+    return {
+      startDate: startDate.toISOString(),
+      endDate: endDate.toISOString(),
+      totalDays: estimatedDays,
+      totalHours: estimatedHours,
+      workingHoursPerDay: 8,
+      phases: Array.from(project.milestones.entries()).map(
+        ([id, milestone]) => ({
+          milestoneId: id,
+          milestone
+        })
+      ),
+      criticalPath: Array.from(project.tasks.keys()),
+      bufferDays: Math.ceil(estimatedDays * 0.2)
+    };
+  }
+  /**
+   * Create a resource allocation plan for the project.
+   */
+  planResources(project) {
+    const teamSize = project.team.size;
+    const taskCount = project.tasks.size;
+    return {
+      team: {
+        current: teamSize,
+        required: Math.max(teamSize, Math.ceil(taskCount / 5)),
+        utilization: teamSize > 0 ? Math.min(1, taskCount / (teamSize * 5)) : 0
+      },
+      budget: {
+        estimated: taskCount * 500,
+        allocated: 0,
+        contingency: taskCount * 100
+      },
+      tools: {
+        required: ["version-control", "ci-cd", "monitoring", "communication"],
+        available: ["version-control", "communication"],
+        gaps: ["ci-cd", "monitoring"]
+      },
+      infrastructure: {
+        compute: "standard",
+        storage: "standard",
+        networking: "standard"
+      }
+    };
+  }
+  /**
+   * Assess potential risks for the project and return a list of risk records.
+   */
+  assessRisks(project) {
+    const risks = [
+      {
+        id: "risk-1",
+        name: "Scope creep",
+        category: "scope",
+        probability: 0.6,
+        impact: 0.7,
+        severity: 0.42,
+        mitigation: "Strict change control process and regular scope reviews",
+        status: "identified"
+      },
+      {
+        id: "risk-2",
+        name: "Resource unavailability",
+        category: "resource",
+        probability: 0.3,
+        impact: 0.8,
+        severity: 0.24,
+        mitigation: "Cross-training and backup resource identification",
+        status: "identified"
+      },
+      {
+        id: "risk-3",
+        name: "Technical complexity",
+        category: "technical",
+        probability: 0.5,
+        impact: 0.6,
+        severity: 0.3,
+        mitigation: "Proof of concept and incremental development approach",
+        status: "identified"
+      },
+      {
+        id: "risk-4",
+        name: "Timeline pressure",
+        category: "schedule",
+        probability: 0.4,
+        impact: 0.7,
+        severity: 0.28,
+        mitigation: "Buffer time allocation and milestone tracking",
+        status: "identified"
+      }
+    ];
+    if (project.constraints.length > 0) {
+      risks.push({
+        id: "risk-5",
+        name: "Constraint violations",
+        category: "compliance",
+        probability: 0.3,
+        impact: 0.9,
+        severity: 0.27,
+        mitigation: "Regular constraint validation and compliance checks",
+        status: "identified"
+      });
+    }
+    return risks;
+  }
+  /**
+   * Analyze the team requirements for a project based on its type and scope.
+   */
+  analyzeTeamRequirements(project) {
+    const roleMap = {
+      standard: ["project-lead", "developer", "tester", "reviewer"],
+      agile: ["product-owner", "scrum-master", "developer", "tester"],
+      research: ["principal-investigator", "researcher", "analyst"]
+    };
+    const roles = roleMap[project.type] || roleMap["standard"];
+    const skillMap = {
+      standard: ["planning", "development", "testing", "communication"],
+      agile: ["agile-methodology", "development", "testing", "collaboration"],
+      research: ["research-methodology", "data-analysis", "writing", "critical-thinking"]
+    };
+    const skills = skillMap[project.type] || skillMap["standard"];
+    return {
+      roles,
+      skills,
+      minSize: roles.length,
+      maxSize: roles.length * 2
+    };
+  }
+  /**
+   * Return the capabilities expected for a given team role.
+   */
+  getRoleCapabilities(role) {
+    const capabilityMap = {
+      "project-lead": ["planning", "coordination", "decision-making", "reporting"],
+      "product-owner": ["backlog-management", "prioritization", "stakeholder-communication"],
+      "scrum-master": ["facilitation", "impediment-removal", "process-improvement"],
+      developer: ["coding", "testing", "code-review", "documentation"],
+      designer: ["ui-design", "ux-research", "prototyping", "visual-design"],
+      tester: ["test-planning", "test-execution", "bug-reporting", "automation"],
+      reviewer: ["code-review", "quality-assessment", "feedback", "standards-enforcement"],
+      analyst: ["data-analysis", "reporting", "requirements-gathering", "modeling"],
+      "principal-investigator": ["research-design", "methodology", "publication", "mentoring"],
+      researcher: ["data-collection", "analysis", "literature-review", "experimentation"]
+    };
+    return capabilityMap[role] || ["general-support", "collaboration"];
+  }
+  /**
+   * Execute a single task and return the result.
+   */
+  async executeTask(task) {
+    const startTime = Date.now();
+    try {
+      this.currentTask = task.id;
+      this.status = "working";
+      const taskType = task.type || "general";
+      let output;
+      switch (taskType) {
+        case "analysis":
+          output = {
+            analyzed: true,
+            findings: [],
+            recommendations: []
+          };
+          break;
+        case "implementation":
+          output = {
+            implemented: true,
+            artifacts: [],
+            testsWritten: 0
+          };
+          break;
+        case "verification":
+          output = {
+            verified: true,
+            testsPassed: 0,
+            testsFailed: 0,
+            coverage: 0
+          };
+          break;
+        case "setup":
+          output = {
+            environmentReady: true,
+            toolsInstalled: [],
+            configurationComplete: true
+          };
+          break;
+        case "delivery":
+          output = {
+            delivered: true,
+            artifacts: [],
+            documentation: true
+          };
+          break;
+        default:
+          output = {
+            completed: true,
+            type: taskType
+          };
+          break;
+      }
+      const duration = Date.now() - startTime;
+      this.currentTask = null;
+      this.status = "active";
+      const totalCompleted = this.performanceMetrics.tasksCompleted + 1;
+      this.performanceMetrics.averageCompletionTime = (this.performanceMetrics.averageCompletionTime * this.performanceMetrics.tasksCompleted + duration) / totalCompleted;
+      return {
+        success: true,
+        output,
+        duration
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.currentTask = null;
+      this.status = "active";
+      return {
+        success: false,
+        error: errorMessage,
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Determine if a project phase is complete by checking task statuses.
+   */
+  isPhaseComplete(project, phaseIndex) {
+    const tasks = Array.from(project.tasks.entries());
+    const tasksPerPhase = Math.max(1, Math.ceil(tasks.length / 5));
+    const startIdx = phaseIndex * tasksPerPhase;
+    const endIdx = Math.min(startIdx + tasksPerPhase, tasks.length);
+    for (let i = startIdx; i < endIdx; i++) {
+      if (i < tasks.length) {
+        const task = tasks[i][1];
+        if (task.status !== "completed") {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Assess overall project health across timeline, quality, resources,
+   * and risks dimensions.
+   */
+  assessProjectHealth(project) {
+    const timelineHealth = this.assessTimelineHealth(project);
+    const qualityHealth = this.assessQualityHealth(project);
+    const resourceHealth = this.assessResourceHealth(project);
+    const riskHealth = this.assessRiskHealth(project);
+    const overallScore = timelineHealth * 0.3 + qualityHealth * 0.3 + resourceHealth * 0.2 + riskHealth * 0.2;
+    let overall;
+    if (overallScore >= 0.8) {
+      overall = "healthy";
+    } else if (overallScore >= 0.6) {
+      overall = "at-risk";
+    } else if (overallScore >= 0.4) {
+      overall = "critical";
+    } else {
+      overall = "failing";
+    }
+    return {
+      overall,
+      score: Math.round(overallScore * 100) / 100,
+      timeline: timelineHealth >= 0.7 ? "on-track" : "delayed",
+      quality: qualityHealth >= 0.7 ? "acceptable" : "below-standard",
+      resources: resourceHealth >= 0.7 ? "adequate" : "constrained",
+      risks: riskHealth >= 0.7 ? "managed" : "elevated",
+      details: {
+        timelineScore: timelineHealth,
+        qualityScore: qualityHealth,
+        resourceScore: resourceHealth,
+        riskScore: riskHealth
+      }
+    };
+  }
+  /**
+   * Assess the timeline health of the project (0.0 - 1.0).
+   */
+  assessTimelineHealth(project) {
+    const totalTasks = project.tasks.size;
+    if (totalTasks === 0) return 1;
+    let completedTasks = 0;
+    for (const [, task] of project.tasks) {
+      if (task.status === "completed") {
+        completedTasks++;
+      }
+    }
+    const completionRatio = completedTasks / totalTasks;
+    const expectedProgress = project.progress / 100;
+    const deviation = Math.abs(completionRatio - expectedProgress);
+    return Math.max(0, 1 - deviation);
+  }
+  /**
+   * Assess the quality health of the project (0.0 - 1.0).
+   */
+  assessQualityHealth(_project) {
+    if (this.performanceMetrics.tasksCompleted === 0) return 1;
+    return this.performanceMetrics.successRate;
+  }
+  /**
+   * Assess the resource health of the project (0.0 - 1.0).
+   */
+  assessResourceHealth(project) {
+    const resources = project.resources;
+    if (!resources || Object.keys(resources).length === 0) return 0.8;
+    const budget = resources.budget;
+    if (budget && typeof budget.total === "number" && typeof budget.spent === "number") {
+      const budgetRatio = budget.total > 0 ? 1 - budget.spent / budget.total : 1;
+      return Math.max(0, Math.min(1, budgetRatio));
+    }
+    return 0.8;
+  }
+  /**
+   * Assess the risk health of the project (0.0 - 1.0).
+   */
+  assessRiskHealth(project) {
+    const riskCount = project.risks.size;
+    if (riskCount === 0) return 1;
+    let totalSeverity = 0;
+    for (const [, risk] of project.risks) {
+      const r = risk;
+      totalSeverity += r.severity || 0;
+    }
+    const avgSeverity = totalSeverity / riskCount;
+    return Math.max(0, 1 - avgSeverity);
+  }
+  /**
+   * Adjust the project plan to address health assessment findings.
+   */
+  async adjustProjectPlan(project, health) {
+    console.log(`[Agent:${this.agentId}] Adjusting project plan based on health assessment...`);
+    if (health.timeline === "delayed") {
+      console.log(`[Agent:${this.agentId}] Addressing timeline delays...`);
+      this.accelerateProject(project);
+    }
+    if (health.quality === "below-standard") {
+      console.log(`[Agent:${this.agentId}] Addressing quality issues...`);
+      this.improveQuality(project);
+    }
+    if (health.resources === "constrained") {
+      console.log(`[Agent:${this.agentId}] Addressing resource constraints...`);
+      this.optimizeResources(project);
+    }
+    console.log(`[Agent:${this.agentId}] Project plan adjusted`);
+  }
+  /**
+   * Accelerate project execution by reprioritizing tasks.
+   */
+  accelerateProject(project) {
+    for (const [, task] of project.tasks) {
+      const t = task;
+      if (t.status === "pending" && t.priority === "medium") {
+        t.priority = "high";
+      }
+      if (t.status === "pending" && typeof t.estimatedHours === "number") {
+        t.estimatedHours = Math.ceil(t.estimatedHours * 0.8);
+      }
+    }
+    console.log(`[Agent:${this.agentId}] Tasks reprioritized and estimates reduced for acceleration`);
+  }
+  /**
+   * Improve quality by adding quality gates to the project.
+   */
+  improveQuality(project) {
+    project.qualityGates = [
+      "code-review-required",
+      "testing-threshold-80",
+      "documentation-required",
+      "peer-approval-required"
+    ];
+    console.log(`[Agent:${this.agentId}] Quality gates added: ${project.qualityGates.length} gates`);
+  }
+  /**
+   * Optimize resource usage by consolidating and redistributing.
+   */
+  optimizeResources(project) {
+    const resources = project.resources;
+    if (resources && resources.budget) {
+      const budget = resources.budget;
+      if (typeof budget.contingency === "number") {
+        const released = Math.ceil(budget.contingency * 0.5);
+        budget.contingency = budget.contingency - released;
+        budget.remaining = (budget.remaining || 0) + released;
+      }
+    }
+    console.log(`[Agent:${this.agentId}] Resources optimized with contingency reallocation`);
+  }
+  /**
+   * Perform a quality check on the project deliverables.
+   */
+  performQualityCheck(project) {
+    const totalTasks = project.tasks.size;
+    let completedTasks = 0;
+    let failedTasks = 0;
+    for (const [, task] of project.tasks) {
+      const t = task;
+      if (t.status === "completed") completedTasks++;
+      if (t.status === "failed") failedTasks++;
+    }
+    const completionRate = totalTasks > 0 ? completedTasks / totalTasks : 0;
+    const failureRate = totalTasks > 0 ? failedTasks / totalTasks : 0;
+    const qualityScore = Math.max(0, completionRate - failureRate * 0.5);
+    return {
+      score: Math.round(qualityScore * 100) / 100,
+      completionRate: Math.round(completionRate * 100) / 100,
+      failureRate: Math.round(failureRate * 100) / 100,
+      totalTasks,
+      completedTasks,
+      failedTasks,
+      qualityGatesPassed: project.qualityGates ? project.qualityGates.length : 0,
+      recommendation: qualityScore >= 0.8 ? "Ready for delivery" : qualityScore >= 0.6 ? "Needs minor improvements" : "Requires significant rework"
+    };
+  }
+  /**
+   * Prepare the final deliverables summary for the project.
+   */
+  prepareDeliverables(project) {
+    const artifacts = [];
+    for (const [taskId, task] of project.tasks) {
+      const t = task;
+      if (t.status === "completed" && t.result) {
+        artifacts.push({
+          taskId,
+          taskName: t.name,
+          type: t.type,
+          result: t.result
+        });
+      }
+    }
+    return {
+      projectId: project.id,
+      projectName: project.name,
+      deliveryDate: (/* @__PURE__ */ new Date()).toISOString(),
+      artifacts,
+      documentation: {
+        readme: true,
+        changelog: true,
+        apiDocs: false
+      },
+      summary: {
+        totalArtifacts: artifacts.length,
+        totalTasks: project.tasks.size,
+        completedTasks: artifacts.length,
+        qualityScore: project.qualityScore || 0,
+        duration: project.endDate ? project.endDate.getTime() - project.startDate.getTime() : Date.now() - project.startDate.getTime()
+      }
+    };
+  }
+  /**
+   * Return a status snapshot for this agent.
+   */
+  getAgentStatus() {
+    return {
+      agentId: this.agentId,
+      agentType: this.agentType,
+      isActive: this.isActive,
+      status: this.status,
+      autonomyLevel: this.autonomyLevel,
+      currentTask: this.currentTask,
+      activeProjects: this.currentProjects.size,
+      performanceMetrics: { ...this.performanceMetrics },
+      teamSize: this.teamMembers.length,
+      knowledgeBaseSize: this.knowledgeBase.size,
+      skillLevels: Object.fromEntries(this.skillLevels),
+      adaptationRate: this.adaptationRate,
+      capabilities: { ...this.capabilities }
+    };
+  }
+  /**
+   * Generate a unique project identifier.
+   */
+  generateProjectId() {
+    return `proj-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaselineCommandSystem,
+  MEGAGEMAutonomousAgent,
+  MEGAGEMCoreSystem
+});