@baselineos/cli 0.1.0

package/dist/chunk-CCIHFLKI.js

@@ -0,0 +1,1792 @@
+// src/commands.ts
+import { BaselineExperienceSystem } from "@baselineos/experience";
+import { BaselineGovernSystem } from "@baselineos/govern";
+import { mkdir, readFile, writeFile, readdir, stat } from "fs/promises";
+import path from "path";
+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 path.resolve(resolved);
+  }
+  async loadOnboardingProfile(context) {
+    const directory = path.join(context, ".baseline");
+    const filePath = path.join(directory, "onboarding.json");
+    try {
+      const raw = await 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 mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(profile, null, 2), "utf8");
+  }
+  async loadBaselineConfig(context) {
+    const directory = path.join(context, ".baseline");
+    const filePath = path.join(directory, "baseline.config.json");
+    try {
+      const raw = await 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 mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(config, null, 2), "utf8");
+  }
+  async fileExists(filePath) {
+    try {
+      const result = await 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 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: path.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 ?? path.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 stat(current);
+      } catch {
+        continue;
+      }
+      if (currentStat.isFile()) {
+        entries.push(current);
+        continue;
+      }
+      if (!currentStat.isDirectory()) continue;
+      const name = path.basename(current);
+      if (ignore.has(name)) continue;
+      let children = [];
+      try {
+        children = await readdir(current);
+      } catch {
+        continue;
+      }
+      for (const child of children) {
+        if (entries.length >= maxEntries) break;
+        queue.push(path.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) => path.join(context, entry)).filter((entry) => entry !== "");
+    const targets = pathsRaw ? pathsRaw.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => path.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]   ${path.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: path.relative(context, filePath)
+    }));
+    const indexPath = path.join(context, ".baseline", "index.json");
+    await mkdir(path.dirname(indexPath), { recursive: true });
+    await 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 = [
+      path.join(context, "docs"),
+      path.join(context, "README.md")
+    ];
+    return new Baseline({
+      projectRoot: context,
+      knowledge,
+      paths: {
+        data: path.join(context, ".baseline"),
+        index: path.join(context, ".baseline", "index"),
+        checkpoints: path.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: path.join(context, ".baseline", "baseline.config.json")
+      },
+      {
+        id: "onboarding",
+        description: "Onboarding profile exists",
+        path: path.join(context, ".baseline", "onboarding.json")
+      },
+      {
+        id: "index",
+        description: "Index exists",
+        path: path.join(context, ".baseline", "index.json")
+      },
+      {
+        id: "roadmap",
+        description: "Roadmap exists",
+        path: path.join(context, "docs", "strategy", "roadmap.md")
+      },
+      {
+        id: "ga-release",
+        description: "GA release checklist exists",
+        path: path.join(context, "docs", "strategy", "ga-release.md")
+      },
+      {
+        id: "package-json",
+        description: "package.json exists",
+        path: path.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, readFileSync } = await import("fs");
+        const { join } = await import("path");
+        const pkgPath = join(contextPath, "package.json");
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(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 = join(contextPath, "requirements.txt");
+        if (existsSync(pyReq)) {
+          const reqs = readFileSync(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 = path.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 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 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");
+  }
+};
+
+export {
+  BaselineCommandSystem
+};