@ekkos/cli 1.3.6 → 1.3.8

package/dist/commands/run.js

@@ -49,6 +49,7 @@ const doctor_1 = require("./doctor");
 const stream_tailer_1 = require("../capture/stream-tailer");
 const jsonl_rewriter_1 = require("../capture/jsonl-rewriter");
 const transcript_repair_1 = require("../capture/transcript-repair");
+const living_docs_manager_js_1 = require("../local/living-docs-manager.js");
 // Try to load node-pty (may fail on Node 24+)
 // IMPORTANT: This must be awaited in run() to avoid racey false fallbacks.
 let pty = null;
@@ -291,10 +292,12 @@ const isWindows = os.platform() === 'win32';
 // Cosmetic patches may fail on newer versions but don't affect functionality
 const PINNED_CLAUDE_VERSION = 'latest';
 // Max output tokens for Claude responses
-// Default: 16384 (safe for Sonnet 4.5)
-// Opus 4.5 supports up to 64k - set EKKOS_MAX_OUTPUT_TOKENS=32768 or =65536 to use higher limits
-// Configurable via environment variable
-const EKKOS_MAX_OUTPUT_TOKENS = process.env.EKKOS_MAX_OUTPUT_TOKENS || '16384';
+// Default: 128000 (Opus 4.6 / Sonnet 4.6 max output)
+// Override via EKKOS_MAX_OUTPUT_TOKENS env var if needed
+// Note: Claude Code has a known bug where CLAUDE_CODE_MAX_OUTPUT_TOKENS is ignored on Opus 4.6
+// (see github.com/anthropics/claude-code/issues/24159). We set it anyway + the proxy also
+// enforces this via max_tokens override on the API request.
+const EKKOS_MAX_OUTPUT_TOKENS = process.env.EKKOS_MAX_OUTPUT_TOKENS || '128000';
 const proxy_url_1 = require("../utils/proxy-url");
 // Track proxy mode for getEkkosEnv (set by run() based on options)
 let proxyModeEnabled = true;
@@ -315,7 +318,7 @@ let cliSessionName = null;
 let cliSessionId = null;
 /**
  * Get environment with ekkOS enhancements
- * - Sets CLAUDE_CODE_MAX_OUTPUT_TOKENS to 32k for longer responses
+ * - Sets CLAUDE_CODE_MAX_OUTPUT_TOKENS to 128K (API max for Opus/Sonnet 4.6)
  * - Routes API through ekkOS proxy for seamless context eviction (when enabled)
  * - Sets EKKOS_PROXY_MODE to signal JSONL rewriter to disable eviction
  * - Passes session headers for eviction/retrieval context tracking
@@ -332,6 +335,11 @@ function getEkkosEnv() {
         // Native autocompact would compact without ekkOS saving state first, causing knowledge loss.
         // Only ekkOS-wrapped sessions get this; vanilla `claude` keeps autocompact on.
         DISABLE_AUTO_COMPACT: 'true',
+        // Set max output tokens to 128K (Opus 4.6 / Sonnet 4.6 API max).
+        // Note: Claude Code has a known bug where this env var is ignored on Opus 4.6
+        // (github.com/anthropics/claude-code/issues/24159). The proxy also enforces
+        // this by overriding max_tokens on the API request as a fallback.
+        CLAUDE_CODE_MAX_OUTPUT_TOKENS: EKKOS_MAX_OUTPUT_TOKENS,
     };
     /* eslint-enable no-restricted-syntax */
     // Check if proxy is disabled via env var or options
@@ -504,7 +512,9 @@ function resolveClaudePath() {
         // No system Claude found — fall through to ekkOS-managed install
     }
     // ekkOS-managed installation (for pinned versions or no system Claude)
-    if (fs.existsSync(EKKOS_CLAUDE_BIN) && checkClaudeVersion(EKKOS_CLAUDE_BIN)) {
+    // When 'latest', skip the slow `claude --version` subprocess — any version is fine.
+    const ekkosClaudeExists = fs.existsSync(EKKOS_CLAUDE_BIN);
+    if (ekkosClaudeExists && (PINNED_CLAUDE_VERSION === 'latest' || checkClaudeVersion(EKKOS_CLAUDE_BIN))) {
         return EKKOS_CLAUDE_BIN;
     }
     // Auto-install to ekkOS-managed directory
@@ -811,6 +821,9 @@ function writeSessionFiles(sessionId, sessionName) {
  * Launch ekkos run + dashboard in isolated tmux panes (60/40 split)
  */
 function launchWithDashboard(options) {
+    // Prune dead-PID entries from active-sessions.json so the dashboard
+    // (and resolveSessionName) never cross-bind to stale sessions after restart.
+    (0, state_1.getActiveSessions)();
     const tmuxSession = `ekkos-${Date.now().toString(36)}`;
     const launchTime = Date.now();
     // Pre-generate session name so dashboard can start immediately (no polling).
@@ -1043,6 +1056,24 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     (0, state_1.ensureEkkosDir)();
     (0, state_1.clearAutoClearFlag)();
+    // Construct manager early but defer .start() until Claude's first idle prompt
+    // (filesystem scans run only after Claude is fully loaded and waiting for input)
+    let localLivingDocsManager = null;
+    if (process.env.EKKOS_LOCAL_LIVING_DOCS !== '0') {
+        try {
+            localLivingDocsManager = new living_docs_manager_js_1.LocalLivingDocsManager({
+                targetPath: process.cwd(),
+                apiUrl: process.env.EKKOS_API_URL || MEMORY_API_URL,
+                apiKey: (0, state_1.getAuthToken)(),
+                timeZone: process.env.EKKOS_USER_TIMEZONE || Intl.DateTimeFormat().resolvedOptions().timeZone,
+                onLog: message => dlog(message),
+            });
+            // .start() deferred to first idle prompt — see idle detection below (~line 2685)
+        }
+        catch (err) {
+            dlog(`[LivingDocs:Local] Failed to start: ${err.message}`);
+        }
+    }
     // Resolve Claude path
     const rawClaudePath = resolveClaudePath();
     const isNpxMode = rawClaudePath.startsWith('npx:');
@@ -1321,6 +1352,7 @@ async function run(options) {
     // Clear terminal to prevent startup banner artifacts bleeding into Claude Code's Ink TUI
     process.stdout.write('\x1B[2J\x1B[H');
     dlog(`Animation complete. shellReady=${shellReady}, buffered=${bufferedOutput.length} chunks`);
+    // Living docs .start() is deferred further — triggers on first idle prompt (Claude fully loaded)
     // Show loading indicator if Claude is still initializing
     if (shellReady && bufferedOutput.length === 0) {
         process.stdout.write(chalk_1.default.gray('  Connecting to Claude...'));
@@ -1367,6 +1399,7 @@ async function run(options) {
     // Tracks idle→active transitions to print the session banner once per turn
     // ══════════════════════════════════════════════════════════════════════════
     let wasIdle = false; // Start as NOT idle — first idle→active fires after startup
+    let livingDocsStarted = false; // Deferred until Claude's first idle prompt
     let turnCount = 0; // Incremented each time a new turn banner prints
     let lastBannerTime = Date.now(); // Grace period so startup output doesn't trigger banner
     // Stream tailer for mid-turn context capture (must be declared before polling code)
@@ -2324,6 +2357,20 @@ async function run(options) {
         // We check the raw outputBuffer (stripped) so the idle regex fires reliably.
         if (IDLE_PROMPT_REGEX.test(stripAnsi(outputBuffer))) {
             wasIdle = true;
+            // Start living docs on first idle prompt — Claude is fully loaded, won't compete for I/O
+            if (!livingDocsStarted && localLivingDocsManager) {
+                livingDocsStarted = true;
+                // Use setImmediate so the current data handler returns first
+                setImmediate(() => {
+                    try {
+                        localLivingDocsManager.start();
+                        dlog('[LivingDocs:Local] Manager started (first idle prompt)');
+                    }
+                    catch (err) {
+                        dlog(`[LivingDocs:Local] Failed to start: ${err.message}`);
+                    }
+                });
+            }
         }
         // ══════════════════════════════════════════════════════════════════════════
         // ORPHAN TOOL_RESULT DETECTION (LOCAL MODE ONLY)
@@ -2711,6 +2758,7 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
     // Handle PTY exit
     shell.onExit(async ({ exitCode }) => {
         (0, state_1.clearAutoClearFlag)();
+        localLivingDocsManager?.stop();
         stopStreamTailer(); // Stop stream capture
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file
@@ -2730,6 +2778,7 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
     // Cleanup on exit signals
     const cleanup = () => {
         (0, state_1.clearAutoClearFlag)();
+        localLivingDocsManager?.stop();
         stopStreamTailer(); // Stop stream capture
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file

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;