@ekkos/cli 1.3.7 → 1.3.8

package/dist/commands/scan.d.ts

@@ -12,10 +12,78 @@
  *
  * Reuses discovery logic from apps/memory/workers/context-compiler/registry-seed.ts
  */
+export interface SystemEntry {
+    system_id: string;
+    name: string;
+    description: string;
+    directory_path: string;
+    domain: string;
+    status: 'active';
+    parent_system_id: string | null;
+    metadata: Record<string, unknown>;
+    tags: string[];
+    aliases: string[];
+}
 interface ScanOptions {
     compile?: boolean;
     dryRun?: boolean;
     path?: string;
 }
+export interface SeedResponse {
+    ok: boolean;
+    inserted: number;
+    updated: number;
+    errors: string[];
+    total: number;
+    duration_ms: number;
+    compile?: {
+        triggered: boolean;
+        error?: string;
+        reason?: string;
+    } | null;
+    error?: string;
+}
+export declare function loadApiKey(): string | null;
+export declare function findGitRoot(startPath: string): string | null;
+export declare function discoverSystems(targetPath: string, options?: {
+    scopeToTarget?: boolean;
+}): {
+    gitRoot: string | null;
+    repoRoot: string;
+    targetRoot: string;
+    scopePath: string;
+    systems: SystemEntry[];
+    ekkosYml: EkkosYmlConfig | null;
+};
+export interface EkkosYmlSystem {
+    path: string;
+    name?: string;
+    description?: string;
+}
+export interface EkkosYmlConfig {
+    version?: number;
+    project?: string;
+    description?: string;
+    stack?: {
+        language?: string;
+        framework?: string;
+        version?: string;
+        package_manager?: string;
+    };
+    systems?: EkkosYmlSystem[];
+    key_files?: string[];
+    ans?: {
+        tier?: string;
+        build?: string;
+        test?: string;
+        lint?: string;
+    };
+}
+export declare function seedSystems(options: {
+    systems: SystemEntry[];
+    apiUrl: string;
+    apiKey: string;
+    compile?: boolean;
+}): Promise<SeedResponse>;
 export declare function scan(options: ScanOptions): Promise<void>;
 export {};

package/dist/commands/scan.js

@@ -13,13 +13,51 @@
  *
  * Reuses discovery logic from apps/memory/workers/context-compiler/registry-seed.ts
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadApiKey = loadApiKey;
+exports.findGitRoot = findGitRoot;
+exports.discoverSystems = discoverSystems;
+exports.seedSystems = seedSystems;
 exports.scan = scan;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const os_1 = require("os");
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const platform_js_1 = require("../utils/platform.js");
@@ -58,6 +96,27 @@ function detectDomain(dirPath) {
     const topLevel = dirPath.split('/')[0];
     return DOMAIN_MAP[topLevel] || 'other';
 }
+function normalizeSystemPath(dirPath) {
+    return dirPath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+function resolveTargetDirectory(targetPath) {
+    const resolved = (0, path_1.resolve)(targetPath);
+    try {
+        return (0, fs_1.statSync)(resolved).isDirectory() ? resolved : (0, path_1.dirname)(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function intersectsScope(systemPath, scopePath) {
+    const normalizedSystem = normalizeSystemPath(systemPath);
+    const normalizedScope = normalizeSystemPath(scopePath);
+    if (!normalizedScope || normalizedScope === '.')
+        return true;
+    return normalizedSystem === normalizedScope ||
+        normalizedSystem.startsWith(`${normalizedScope}/`) ||
+        normalizedScope.startsWith(`${normalizedSystem}/`);
+}
 // ── System ID generation ─────────────────────────────────────────────────
 function toSystemId(dirPath) {
     return dirPath
@@ -249,6 +308,208 @@ function findGitRoot(startPath) {
     }
     return null;
 }
+function discoverSystems(targetPath, options) {
+    const targetRoot = resolveTargetDirectory(targetPath);
+    const gitRoot = findGitRoot(targetRoot);
+    const repoRoot = gitRoot || targetRoot;
+    const scopePath = normalizeSystemPath((0, path_1.relative)(repoRoot, targetRoot) || '.');
+    // Read ekkos.yml for system overrides and stack config
+    const ekkosYml = readEkkosYml(repoRoot);
+    let systems;
+    // If ekkos.yml has explicit systems[], use those as overrides
+    if (ekkosYml?.systems && ekkosYml.systems.length > 0) {
+        const overrideSystems = ekkosYml.systems.map(s => ({
+            system_id: toSystemId(s.path),
+            name: s.name || (0, path_1.basename)(s.path),
+            description: s.description || '',
+            directory_path: normalizeSystemPath(s.path),
+            domain: detectDomain(s.path),
+            status: 'active',
+            parent_system_id: null,
+            metadata: {},
+            tags: [],
+            aliases: [],
+        }));
+        // Also discover auto-detected systems and merge (overrides take precedence)
+        const autoSystems = assignParentSystems(scanDirectory(repoRoot, repoRoot, 0, 4, null));
+        const overridePaths = new Set(overrideSystems.map(s => s.directory_path));
+        systems = [
+            ...overrideSystems,
+            ...autoSystems.filter(s => !overridePaths.has(s.directory_path)),
+        ];
+        systems = assignParentSystems(systems);
+    }
+    else {
+        const rawSystems = scanDirectory(repoRoot, repoRoot, 0, 4, null);
+        systems = assignParentSystems(rawSystems);
+    }
+    if (options?.scopeToTarget && scopePath !== '.') {
+        systems = assignParentSystems(systems
+            .filter(system => intersectsScope(system.directory_path, scopePath))
+            .map(system => ({
+            ...system,
+            parent_system_id: null,
+        })));
+    }
+    return {
+        gitRoot,
+        repoRoot,
+        targetRoot,
+        scopePath,
+        systems,
+        ekkosYml,
+    };
+}
+function readEkkosYml(repoRoot) {
+    const names = ['ekkos.yml', 'ekkos.yaml', '.ekkos.yml', '.ekkos.yaml'];
+    for (const name of names) {
+        const filePath = (0, path_1.join)(repoRoot, name);
+        if ((0, fs_1.existsSync)(filePath)) {
+            try {
+                const raw = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                // Simple YAML parser for the flat structure we need (avoid adding js-yaml dep)
+                return parseSimpleYaml(raw);
+            }
+            catch { /* malformed — skip */ }
+        }
+    }
+    return null;
+}
+/**
+ * Minimal YAML parser for ekkos.yml — handles the flat/nested structure we need.
+ * Does NOT support full YAML spec. For production, consider js-yaml.
+ */
+function parseSimpleYaml(raw) {
+    const result = {};
+    const lines = raw.split('\n');
+    let currentSection = null;
+    let currentItem = null;
+    const systems = [];
+    for (const line of lines) {
+        const stripped = line.replace(/#.*$/, '').trimEnd();
+        if (!stripped || stripped.trim() === '')
+            continue;
+        // Top-level key
+        const topMatch = stripped.match(/^(\w+):\s*"?([^"]*)"?\s*$/);
+        if (topMatch && !stripped.startsWith(' ') && !stripped.startsWith('\t')) {
+            const [, key, value] = topMatch;
+            if (key === 'version')
+                result.version = parseInt(value, 10);
+            else if (key === 'project')
+                result.project = value;
+            else if (key === 'description')
+                result.description = value;
+            currentSection = key;
+            continue;
+        }
+        // Section header (no value)
+        const sectionMatch = stripped.match(/^(\w+):\s*$/);
+        if (sectionMatch && !stripped.startsWith(' ')) {
+            currentSection = sectionMatch[1];
+            continue;
+        }
+        // Nested key under a section
+        const nestedMatch = stripped.match(/^\s{2}(\w+):\s*"?([^"]*)"?\s*$/);
+        if (nestedMatch && currentSection) {
+            const [, key, value] = nestedMatch;
+            if (currentSection === 'stack') {
+                if (!result.stack)
+                    result.stack = {};
+                result.stack[key] = value;
+            }
+            else if (currentSection === 'ans') {
+                if (!result.ans)
+                    result.ans = {};
+                result.ans[key] = value;
+            }
+            continue;
+        }
+        // Array item (systems or key_files)
+        const arrayItemMatch = stripped.match(/^\s{2}-\s+(?:path:\s*)?"?([^"]+)"?\s*$/);
+        if (arrayItemMatch && currentSection === 'systems') {
+            currentItem = { path: arrayItemMatch[1].trim() };
+            systems.push(currentItem);
+            continue;
+        }
+        if (arrayItemMatch && currentSection === 'key_files') {
+            if (!result.key_files)
+                result.key_files = [];
+            result.key_files.push(arrayItemMatch[1].trim());
+            continue;
+        }
+        // Nested under array item
+        const itemFieldMatch = stripped.match(/^\s{4,}(\w+):\s*"?([^"]*)"?\s*$/);
+        if (itemFieldMatch && currentItem) {
+            currentItem[itemFieldMatch[1]] = itemFieldMatch[2];
+        }
+    }
+    if (systems.length > 0)
+        result.systems = systems;
+    return result;
+}
+async function seedSystems(options) {
+    const response = await fetch(`${options.apiUrl}/api/v1/living-docs/seed`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${options.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            systems: options.systems,
+            compile: !!options.compile,
+        }),
+    });
+    if (!response.ok) {
+        const errBody = await response.text();
+        throw new Error(`API returned ${response.status}: ${errBody}`);
+    }
+    return response.json();
+}
+// ── ekkos.yml scaffolding ────────────────────────────────────────────────
+function scaffoldEkkosYml(project, hasPackageJson, hasCargo) {
+    const lines = [
+        '# ekkos.yml — Project contract for the ekkOS Autonomic Nervous System',
+        '# This file activates self-healing, evolution, and living documentation.',
+        '#',
+        '# Docs: https://docs.ekkos.dev/ekkos-yml',
+        '',
+        'version: 1',
+        `project: "${project}"`,
+        '',
+    ];
+    // Stack detection for scaffold
+    if (hasPackageJson) {
+        lines.push('# Stack — tells ekkOS what language/framework you use (auto-detected if omitted)');
+        lines.push('# stack:');
+        lines.push('#   language: typescript');
+        lines.push('#   framework: next  # or express, react, etc.');
+        lines.push('');
+    }
+    else if (hasCargo) {
+        lines.push('stack:');
+        lines.push('  language: rust');
+        lines.push('');
+    }
+    else {
+        lines.push('# Stack — uncomment and set your language for better docs');
+        lines.push('# stack:');
+        lines.push('#   language: python  # or rust, go, ruby, java, etc.');
+        lines.push('#   framework: django  # optional');
+        lines.push('');
+    }
+    lines.push('# Systems — custom system boundaries (auto-detected if omitted)', '# systems:', '#   - path: "apps/api"', '#     name: "API Service"', '#     description: "REST API for the platform"', '#   - path: "apps/web"', '#     name: "Web Frontend"', '', '# Key files — files the compiler should always read', '# key_files:', '#   - "settings/production.py"', '#   - "config/routes.rb"', '', '# Vitals — connect observability providers to feel pain', '# vitals:', '#   - type: sentry', '#     project_id: "your-sentry-project-id"', '', '# ANS — autonomic nervous system configuration', 'ans:', '  tier: "R1"  # R0=observe, R1=memory mutation, R2=source mutation (PRs), R3=reflex rollbacks');
+    if (hasPackageJson) {
+        lines.push('  build: "npm run build"', '  test: "npm test"', '  lint: "npm run lint"');
+    }
+    else if (hasCargo) {
+        lines.push('  build: "cargo build"', '  test: "cargo test"', '  lint: "cargo clippy"');
+    }
+    else {
+        lines.push('  # build: "your build command"', '  # test: "your test command"');
+    }
+    lines.push('', '# Invariants — architectural rules the ANS must never break', '# invariants:', '#   - "no-circular-dependencies"', '#   - "auth-is-isolated"', '');
+    return lines.join('\n');
+}
 // ── Main scan command ────────────────────────────────────────────────────
 async function scan(options) {
     const startTime = Date.now();
@@ -260,21 +521,42 @@ async function scan(options) {
     console.log(chalk_1.default.gray('  ─'.repeat(25)));
     console.log('');
     // Check if in a git repo
-    const gitRoot = findGitRoot(targetPath);
-    const repoRoot = gitRoot || targetPath;
+    const { gitRoot, targetRoot, scopePath } = discoverSystems(targetPath, { scopeToTarget: true });
     if (gitRoot) {
         console.log(chalk_1.default.gray(`  Git root: ${gitRoot}`));
     }
     else {
         console.log(chalk_1.default.yellow(`  No git repo found — scanning ${targetPath}`));
     }
+    if (scopePath !== '.') {
+        console.log(chalk_1.default.gray(`  Workspace scope: ${targetRoot}`));
+    }
     console.log('');
+    // Phase 0: Check for ekkos.yml — scaffold if missing
+    const repoRoot = gitRoot || targetRoot;
+    const ekkosYmlPath = (0, path_1.join)(repoRoot, 'ekkos.yml');
+    if (!(0, fs_1.existsSync)(ekkosYmlPath) && !isDryRun) {
+        const projectName = (0, path_1.basename)(repoRoot);
+        const hasPackageJson = (0, fs_1.existsSync)((0, path_1.join)(repoRoot, 'package.json'));
+        const hasCargo = (0, fs_1.existsSync)((0, path_1.join)(repoRoot, 'Cargo.toml'));
+        const content = scaffoldEkkosYml(projectName, hasPackageJson, hasCargo);
+        (0, fs_1.writeFileSync)(ekkosYmlPath, content, 'utf-8');
+        console.log(chalk_1.default.green(`  Created ${chalk_1.default.bold('ekkos.yml')} — the seed of your project's nervous system`));
+        console.log('');
+        console.log(chalk_1.default.white(`  Two ways to configure it:`));
+        console.log(chalk_1.default.gray(`    1. Edit ${chalk_1.default.white('ekkos.yml')} directly (build commands, vitals, tier)`));
+        console.log(chalk_1.default.gray(`    2. Use the guided wizard: ${chalk_1.default.cyan('https://platform.ekkos.dev/dashboard/settings/project')}`));
+        console.log('');
+    }
+    else if ((0, fs_1.existsSync)(ekkosYmlPath)) {
+        console.log(chalk_1.default.gray(`  ekkos.yml: ${ekkosYmlPath}`));
+        console.log('');
+    }
     // Phase 1: Scan repo structure
     const scanSpinner = (0, ora_1.default)('Scanning repo structure...').start();
     let systems;
     try {
-        const rawSystems = scanDirectory(repoRoot, repoRoot, 0, 4, null);
-        systems = assignParentSystems(rawSystems);
+        systems = discoverSystems(targetRoot, { scopeToTarget: true }).systems;
         scanSpinner.succeed(`Found ${chalk_1.default.bold(systems.length.toString())} systems`);
     }
     catch (err) {
@@ -322,24 +604,12 @@ async function scan(options) {
     const seedSpinner = (0, ora_1.default)('Seeding registry...').start();
     try {
         const apiUrl = process.env.EKKOS_API_URL || platform_js_1.MCP_API_URL;
-        const response = await fetch(`${apiUrl}/api/v1/living-docs/seed`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                systems,
-                compile: shouldCompile,
-            }),
+        const result = await seedSystems({
+            systems,
+            apiUrl,
+            apiKey,
+            compile: shouldCompile,
         });
-        if (!response.ok) {
-            const errBody = await response.text();
-            seedSpinner.fail('Seed failed');
-            console.error(chalk_1.default.red(`  API returned ${response.status}: ${errBody}`));
-            process.exit(1);
-        }
-        const result = await response.json();
         if (!result.ok) {
             seedSpinner.fail('Seed failed');
             console.error(chalk_1.default.red(`  ${result.error || 'Unknown error'}`));
@@ -378,9 +648,35 @@ async function scan(options) {
         }
         process.exit(1);
     }
+    // Phase 4: Register workspace for daemon living-docs watcher
+    try {
+        const workspacePath = gitRoot || targetRoot;
+        // Write workspace path to synk settings so the daemon can pick it up
+        const synkSettingsPath = (0, path_1.join)((0, os_1.homedir)(), '.ekkos', 'synk', 'settings.json');
+        if ((0, fs_1.existsSync)(synkSettingsPath)) {
+            const settings = JSON.parse((0, fs_1.readFileSync)(synkSettingsPath, 'utf-8'));
+            const existing = settings.watchedWorkspaces || [];
+            if (!existing.some((w) => w.path === workspacePath)) {
+                settings.watchedWorkspaces = [...existing, { path: workspacePath, addedAt: new Date().toISOString() }];
+                const { writeFileSync: writeSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                writeSync(synkSettingsPath, JSON.stringify(settings, null, 2));
+                console.log(chalk_1.default.gray(`  Workspace registered for daemon watcher: ${workspacePath}`));
+            }
+        }
+    }
+    catch {
+        // Daemon settings may not exist yet — that's fine
+    }
     // Summary
     const duration = ((Date.now() - startTime) / 1000).toFixed(1);
     console.log('');
-    console.log(chalk_1.default.green(`  Done in ${duration}s`));
+    console.log(chalk_1.default.green(`  ✓ Done in ${duration}s`));
+    console.log('');
+    console.log(chalk_1.default.white.bold('  What happens now:'));
+    console.log(chalk_1.default.gray(`    • Living docs watcher keeps your ${chalk_1.default.white('ekkOS_CONTEXT.md')} files current`));
+    console.log(chalk_1.default.gray(`    • ANS monitors your systems for anomalies`));
+    console.log(chalk_1.default.gray(`    • Dream Forge runs nightly to evolve patterns`));
+    console.log('');
+    console.log(chalk_1.default.gray(`  Configure vitals & autonomy: ${chalk_1.default.cyan('https://platform.ekkos.dev/dashboard/settings/project')}`));
     console.log('');
 }

package/dist/commands/setup.js

@@ -359,12 +359,8 @@ Use \`ekkOS_Forge\` when you:
 
 ## Pattern Application
 
-When you use a pattern from memory:
-\`\`\`
-[ekkOS_APPLY] Using: "Pattern Name"
-\`\`\`
-
-This is how ekkOS learns and improves over time.
+Apply relevant patterns silently in the answer.
+Do not emit control markers such as \`[ekkOS_APPLY]\` or \`[ekkOS_SKIP]\` unless the runtime explicitly asks for them.
 `;
 }
 function generateCascadeRules() {

package/dist/deploy/index.d.ts

@@ -2,4 +2,5 @@ export * from './mcp';
 export * from './settings';
 export * from './hooks';
 export * from './skills';
+export * from './agents';
 export * from './instructions';

package/dist/deploy/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./mcp"), exports);
 __exportStar(require("./settings"), exports);
 __exportStar(require("./hooks"), exports);
 __exportStar(require("./skills"), exports);
+__exportStar(require("./agents"), exports);
 __exportStar(require("./instructions"), exports);

package/dist/deploy/instructions.d.ts

@@ -1,12 +1,19 @@
 /**
- * Deploy CLAUDE.md to ~/.claude/CLAUDE.md
+ * Deploy ekkOS block into ~/.claude/CLAUDE.md.
+ *
+ * Strategy:
+ *  - If file doesn't exist → create it with just the ekkOS block.
+ *  - If file exists and already has markers → replace the block between markers.
+ *  - If file exists with no markers → prepend ekkOS block above existing content.
+ *
+ * Never destroys user content outside the markers.
  */
 export declare function deployInstructions(): void;
 /**
- * Check if CLAUDE.md is deployed
+ * Check if CLAUDE.md has the ekkOS block
  */
 export declare function isInstructionsDeployed(): boolean;
 /**
- * Get the CLAUDE.md content (for preview)
+ * Get the ekkOS CLAUDE.md template content
  */
 export declare function getInstructionsContent(): string;

package/dist/deploy/instructions.js

@@ -6,25 +6,52 @@ exports.getInstructionsContent = getInstructionsContent;
 const fs_1 = require("fs");
 const platform_1 = require("../utils/platform");
 const templates_1 = require("../utils/templates");
+const BEGIN_MARKER = '<!-- ekkOS:begin — managed by ekkos init, do not remove this marker -->';
+const END_MARKER = '<!-- ekkOS:end -->';
 /**
- * Deploy CLAUDE.md to ~/.claude/CLAUDE.md
+ * Deploy ekkOS block into ~/.claude/CLAUDE.md.
+ *
+ * Strategy:
+ *  - If file doesn't exist → create it with just the ekkOS block.
+ *  - If file exists and already has markers → replace the block between markers.
+ *  - If file exists with no markers → prepend ekkOS block above existing content.
+ *
+ * Never destroys user content outside the markers.
  */
 function deployInstructions() {
-    // Ensure .claude directory exists
     if (!(0, fs_1.existsSync)(platform_1.CLAUDE_DIR)) {
         (0, fs_1.mkdirSync)(platform_1.CLAUDE_DIR, { recursive: true });
     }
-    // Copy CLAUDE.md template
-    (0, templates_1.copyTemplateFile)('CLAUDE.md', platform_1.CLAUDE_MD);
+    const ekkosBlock = (0, templates_1.readTemplate)('CLAUDE.md');
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_MD)) {
+        // No file — create fresh
+        (0, fs_1.writeFileSync)(platform_1.CLAUDE_MD, ekkosBlock);
+        return;
+    }
+    const existing = (0, fs_1.readFileSync)(platform_1.CLAUDE_MD, 'utf-8');
+    const beginIdx = existing.indexOf(BEGIN_MARKER);
+    const endIdx = existing.indexOf(END_MARKER);
+    if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+        // Markers found — replace in-place
+        const before = existing.slice(0, beginIdx);
+        const after = existing.slice(endIdx + END_MARKER.length);
+        (0, fs_1.writeFileSync)(platform_1.CLAUDE_MD, before + ekkosBlock + after);
+        return;
+    }
+    // No markers — prepend ekkOS block, preserve everything below
+    (0, fs_1.writeFileSync)(platform_1.CLAUDE_MD, ekkosBlock + '\n\n' + existing);
 }
 /**
- * Check if CLAUDE.md is deployed
+ * Check if CLAUDE.md has the ekkOS block
  */
 function isInstructionsDeployed() {
-    return (0, fs_1.existsSync)(platform_1.CLAUDE_MD);
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_MD))
+        return false;
+    const content = (0, fs_1.readFileSync)(platform_1.CLAUDE_MD, 'utf-8');
+    return content.includes(BEGIN_MARKER) && content.includes(END_MARKER);
 }
 /**
- * Get the CLAUDE.md content (for preview)
+ * Get the ekkOS CLAUDE.md template content
  */
 function getInstructionsContent() {
     try {