@10et/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1707 @@
+#!/usr/bin/env node
+;
+globalThis.__jfl_start = Date.now();
+/**
+ * JFL CLI - Just Fucking Launch
+ *
+ * Free tier: Works standalone with BYOAI
+ * Paid tier: Connects to platform for dashboard, integrations, hosted agents
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import { join } from "path";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { TENET_DEBUG } from "./utils/tenet-env.js";
+// Lazy imports - only load when needed to reduce startup latency
+// All commands use dynamic import() to defer loading until invoked
+import { JFL_PATHS } from "./utils/jfl-paths.js";
+// Telemetry loaded lazily on first track() call
+let _telemetry;
+async function getTelemetry() {
+    if (!_telemetry) {
+        const mod = await import("./lib/telemetry.js");
+        _telemetry = mod.telemetry;
+    }
+    return _telemetry;
+}
+// Migration check runs in background, doesn't block startup
+import("./utils/jfl-migration.js").then(mod => mod.checkAndMigrate({ silent: true })).catch(() => { });
+const program = new Command();
+// Telemetry hooks — auto-track all commands (lazy load telemetry)
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+    ;
+    actionCommand.__telemetryStart = Date.now();
+    if (TENET_DEBUG) {
+        console.error(`[timing] preAction start: ${Date.now() - globalThis.__jfl_start}ms`);
+    }
+    // ResourceOptimizer: decide() before every command (<5ms)
+    try {
+        const { resourceOptimizerPreAction, applyGuidance } = await import("./lib/resource-optimizer-middleware.js");
+        const guidance = await resourceOptimizerPreAction(actionCommand.name());
+        actionCommand.__roGuidance = guidance;
+        // Apply guidance (delay if thermal/CPU issue)
+        if (guidance.action !== "passthrough" && guidance.action !== "monitor") {
+            await applyGuidance(guidance);
+            if (guidance.delay_ms > 0) {
+                const chalk = (await import("chalk")).default;
+                console.log(chalk.yellow(`  ⚡ ${guidance.reason}`));
+            }
+        }
+    }
+    catch {
+        // Never block commands for RO failures
+    }
+    if (TENET_DEBUG) {
+        console.error(`[timing] preAction end: ${Date.now() - globalThis.__jfl_start}ms`);
+    }
+});
+program.hook('postAction', async (_thisCommand, actionCommand) => {
+    if (TENET_DEBUG) {
+        console.error(`[timing] postAction start: ${Date.now() - globalThis.__jfl_start}ms`);
+    }
+    const start = actionCommand.__telemetryStart;
+    const commandName = actionCommand.name();
+    const durationMs = start ? Date.now() - start : undefined;
+    // Fire-and-forget: don't block CLI exit for telemetry/RO
+    // These run in background; process.on('beforeExit') flushes telemetry
+    Promise.all([
+        // ResourceOptimizer: record transition
+        import("./lib/resource-optimizer-middleware.js")
+            .then(m => m.resourceOptimizerPostAction(commandName, process.cwd()))
+            .catch(() => { }),
+        // Telemetry: track command
+        getTelemetry()
+            .then(t => t.track({
+            category: 'command',
+            event: `command:${commandName}`,
+            command: commandName,
+            duration_ms: durationMs,
+            success: true,
+        }))
+            .catch(() => { }),
+    ]).catch(() => { });
+    if (TENET_DEBUG) {
+        console.error(`[timing] postAction end: ${Date.now() - globalThis.__jfl_start}ms`);
+    }
+});
+const HELP_GROUPS = {
+    "Getting Started": ["init", "status", "whoami", "hud", "ide", "doctor"],
+    "Daily Use": ["synopsis", "ask", "improve", "organize", "events", "voice", "kanban"],
+    "Management": ["services", "portfolio", "flows", "hooks", "scope", "memory", "eval", "findings", "viz", "telemetry", "context-hub", "skills", "ci"],
+    "Platform": ["login", "deploy", "wallet", "preferences"],
+    "Advanced": ["peter", "orchestrate", "openclaw", "ralph", "agent", "train", "setup"],
+};
+const HIDDEN_COMMANDS = new Set([
+    "repair", "validate-settings", "test", "brand", "content", "feedback",
+    "migrate-services", "onboard", "service-agent", "dashboard", "profile",
+    "gtm", "clawdbot", "update", "service-manager", "logout", "agents", "help",
+]);
+program.configureHelp({
+    formatHelp(cmd, helper) {
+        // For sub-commands, render standard Commander help so arguments/options are visible
+        if (cmd.parent !== null) {
+            const lines = [];
+            const pad = 22;
+            lines.push("");
+            lines.push(`  Usage: ${helper.commandUsage(cmd)}`);
+            const desc = helper.commandDescription(cmd);
+            if (desc) {
+                lines.push("");
+                lines.push(`  ${desc}`);
+            }
+            const args = helper.visibleArguments(cmd);
+            if (args.length > 0) {
+                lines.push("");
+                lines.push("  Arguments:");
+                for (const arg of args) {
+                    lines.push(`    ${helper.argumentTerm(arg).padEnd(pad)}${helper.argumentDescription(arg)}`);
+                }
+            }
+            const opts = helper.visibleOptions(cmd);
+            if (opts.length > 0) {
+                lines.push("");
+                lines.push("  Options:");
+                for (const opt of opts) {
+                    lines.push(`    ${helper.optionTerm(opt).padEnd(pad)}${helper.optionDescription(opt)}`);
+                }
+            }
+            const cmds = helper.visibleCommands(cmd);
+            if (cmds.length > 0) {
+                lines.push("");
+                lines.push("  Commands:");
+                for (const c of cmds) {
+                    lines.push(`    ${helper.subcommandTerm(c).padEnd(pad)}${helper.subcommandDescription(c)}`);
+                }
+            }
+            lines.push("");
+            return lines.join("\n");
+        }
+        // Root command: custom grouped format
+        const lines = [];
+        lines.push("");
+        lines.push(chalk.bold("  JFL - Just Fucking Launch"));
+        lines.push("");
+        lines.push(chalk.gray("  Your context layer. Any project. Any AI."));
+        lines.push("");
+        const allCommands = cmd.commands;
+        const commandMap = new Map();
+        for (const sub of allCommands) {
+            commandMap.set(sub.name(), sub.description());
+        }
+        for (const [group, names] of Object.entries(HELP_GROUPS)) {
+            lines.push(chalk.cyan(`  ${group}`));
+            for (const name of names) {
+                const desc = commandMap.get(name);
+                if (desc) {
+                    lines.push(`    ${name.padEnd(18)}${desc}`);
+                }
+            }
+            lines.push("");
+        }
+        lines.push(chalk.gray("  Run jfl <command> --help for details"));
+        lines.push("");
+        return lines.join("\n");
+    },
+});
+function getVersion() {
+    try {
+        const pkgPath = new URL("../package.json", import.meta.url);
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+program
+    .name("tenet")
+    .description("TENET — The operating system for AI agent teams")
+    .version(getVersion())
+    .option("--no-update", "Skip automatic update check")
+    .action(async (options) => {
+    // Always update on session start (unless --no-update flag)
+    if (options.update !== false) {
+        const { updateCommand } = await import("./commands/update.js");
+        await updateCommand({ autoUpdate: true });
+        console.log(); // Add spacing before session starts
+    }
+    const { sessionCommand } = await import("./commands/session.js");
+    await sessionCommand({});
+});
+// ============================================================================
+// FREE TIER COMMANDS (work offline/standalone)
+// ============================================================================
+program
+    .command("start")
+    .description("One-command activation: init → setup → launch (zero to intelligence in <2 min)")
+    .argument("[name]", "Project name or path")
+    .option("--repo <path>", "Analyze existing repo and create GTM workspace")
+    .option("--pi", "Launch Pi instead of Claude Code")
+    .option("--ci", "Deploy CI workflows (eval + review)")
+    .option("-s, --service <path...>", "Service repo paths/URLs to onboard (repeatable)")
+    .option("--no-launch", "Don't launch editor after setup")
+    .action(async (name, options) => {
+    const { startCommand } = await import("./commands/start.js");
+    await startCommand(name, options);
+});
+program
+    .command("init")
+    .description("Initialize a new JFL project")
+    .option("-n, --name <name>", "Project name")
+    .option("-t, --type <type>", "Workspace type: gtm, portfolio, service", "gtm")
+    .option("-d, --description <desc>", "Project description")
+    .option("-s, --service <path...>", "Service repo paths/URLs to onboard (repeatable)")
+    .option("--from-service", "Deep-analyze current directory and create GTM in sibling directory")
+    .option("--ci", "Deploy eval + review CI workflows after init")
+    .option("--no-interactive", "Skip all prompts, use defaults")
+    .option("--no-search", "Skip search setup")
+    .option("--no-services", "Skip service onboarding")
+    .option("--no-launch", "Skip launching Claude Code after init")
+    .action(async (options) => {
+    const { initCommand } = await import("./commands/init.js");
+    await initCommand(options);
+});
+program
+    .command("migrate")
+    .description("Migrate project from JFL to Tenet naming (.jfl/ → .tenet/, configs, scripts)")
+    .option("--dry-run", "Show what would change without making changes")
+    .option("--force", "Overwrite existing .tenet/ directory")
+    .option("--rollback", "Reverse: migrate from Tenet back to JFL")
+    .action(async (options) => {
+    const { migrateTenetCommand } = await import("./commands/migrate-tenet.js");
+    await migrateTenetCommand(options);
+});
+program
+    .command("repair")
+    .description("Repair a JFL project missing .jfl directory")
+    .action(async () => {
+    const { repairCommand } = await import("./commands/repair.js");
+    await repairCommand();
+});
+program
+    .command("validate-settings")
+    .description("Validate and repair .claude/settings.json")
+    .option("--fix", "Attempt to auto-repair common issues")
+    .option("--json", "Output in JSON format")
+    .action(async (options) => {
+    const { validateSettingsCommand } = await import("./commands/validate-settings.js");
+    await validateSettingsCommand(options);
+});
+program
+    .command("hud")
+    .description("Show campaign dashboard")
+    .option("-c, --compact", "Show compact one-line status")
+    .action(async (options) => {
+    const { hudCommand } = await import("./commands/hud.js");
+    await hudCommand(options);
+});
+program
+    .command("status")
+    .description("Show project status")
+    .action(async () => {
+    if (TENET_DEBUG) {
+        const _t = Date.now();
+        const { statusCommand } = await import("./commands/status.js");
+        console.error(`[timing] import status.js: ${Date.now() - _t}ms`);
+        const _t2 = Date.now();
+        await statusCommand();
+        console.error(`[timing] statusCommand exec: ${Date.now() - _t2}ms`);
+    }
+    else {
+        const { statusCommand } = await import("./commands/status.js");
+        await statusCommand();
+    }
+});
+program
+    .command("whoami")
+    .description("Print current user and project info")
+    .action(async () => {
+    const { whoamiCommand } = await import("./commands/whoami.js");
+    whoamiCommand();
+});
+// RL learning agents now accessible via: jfl agents rl <action>
+// (integrated into existing agents command)
+// IDE workspace command — uses dynamic imports to avoid linter stripping  
+const ide = program.command("ide").description("Launch smart development environment (jfl ide) or manage workspace (jfl ide <command>)");
+ide.command("launch", { isDefault: true }).description("Launch workspace (same as 'jfl ide')").option("--json", "Output as JSON").option("--sidebar", "Include sidebar pane (20% width)").action(async (options) => { const m = await import("./commands/ide.js"); await m.ideLaunchCommand(options); });
+ide.command("add").description("Add a surface to the workspace").argument("[name]", "Surface name (agent, built-in type, or service)").option("--row <n>", "Row index (0-based)").option("--position <n>", "Position within row (0-based)").option("--title <title>", "Custom surface title").option("--cmd <command>", "Custom surface command").action(async (name, options) => { const m = await import("./commands/ide.js"); await m.ideAddCommand(name, options); });
+ide.command("remove").description("Remove a surface from the workspace").argument("<name>", "Surface name or title to remove").action(async (name) => { const m = await import("./commands/ide.js"); await m.ideRemoveCommand(name); });
+ide.command("available").description("List available surface types, agents, and services").action(async () => { const m = await import("./commands/ide.js"); await m.ideAvailableCommand(); });
+ide.command("status").description("Show current workspace layout and session state").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/ide.js"); await m.ideStatusCommand(options); });
+ide.command("surfaces").description("List active surfaces with live sidebar data").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/ide.js"); await m.ideSurfacesCommand(options); });
+ide.command("stop").description("Stop the running workspace session").action(async () => { const m = await import("./commands/ide.js"); await m.ideStopCommand(); });
+ide.command("restart").description("Restart the workspace session").action(async () => { const m = await import("./commands/ide.js"); await m.ideRestartCommand(); });
+ide.command("reset").description("Reset workspace to welcome state").action(async () => { const m = await import("./commands/ide.js"); await m.ideResetCommand(); });
+ide.command("open").description("Open a child project/service in the workspace").argument("<name>", "Service or product name to open").action(async (name) => { const m = await import("./commands/ide.js"); await m.ideOpenCommand(name); });
+ide.command("up").description("Navigate to parent project (portfolio or GTM)").action(async () => { const m = await import("./commands/ide.js"); await m.ideUpCommand(); });
+ide.command("config").description("View or set IDE configuration").argument("[key]", "Config key (e.g., primary, backend)").argument("[value]", "Config value").action(async (key, value) => { const m = await import("./commands/ide.js"); await m.ideConfigCommand(key, value); });
+program
+    .command("context-hub")
+    .description("Manage Context Hub daemon (unified context for AI agents)")
+    .argument("[action]", "start, stop, restart, status, ensure, ensure-all, doctor, dashboard, install-daemon, uninstall-daemon, query, serve")
+    .option("-p, --port <port>", "Port to run on (default: per-project)")
+    .option("-g, --global", "Run in global mode (serve all GTM projects)")
+    .option("-q, --quiet", "Suppress output (for daemon use)")
+    .option("--clean", "Remove stale entries (for doctor)")
+    .option("--purge", "Also delete token file (for stop)")
+    .option("--project-root <path>", "Override project root directory")
+    .allowUnknownOption()
+    .action(async (action, options) => {
+    const { contextHubCommand } = await import("./commands/context-hub.js");
+    await contextHubCommand(action, {
+        port: options.port ? parseInt(options.port, 10) : undefined,
+        global: options.global || false,
+        quiet: options.quiet || false,
+        projectRoot: options.projectRoot,
+    });
+});
+program
+    .command("hooks")
+    .description("Manage Claude Code HTTP hooks for Context Hub")
+    .argument("[action]", "init, status, remove")
+    .action(async (action) => {
+    const { hooksCommand } = await import("./commands/hooks.js");
+    await hooksCommand(action);
+});
+program
+    .command("flows")
+    .description("Manage declarative event flows")
+    .argument("[action]", "list, add, test, enable, disable, approve")
+    .argument("[name]", "Flow name (for test/enable/disable)")
+    .option("--flow <name>", "Filter approvals to a specific flow")
+    .option("--all", "Approve all pending gated executions")
+    .action(async (action, name, options) => {
+    const { flowsCommand } = await import("./commands/flows.js");
+    await flowsCommand(action, name, options);
+});
+program
+    .command("scope")
+    .description("View and manage service context scopes")
+    .argument("[action]", "list, set, test, viz")
+    .argument("[args...]", "Arguments for the action")
+    .action(async (action, args) => {
+    const { scopeCommand } = await import("./commands/scope.js");
+    await scopeCommand(action, ...args);
+});
+program
+    .command("synopsis")
+    .description("Show work summary (journal + commits + code)")
+    .argument("[hours]", "Hours to look back (default: 24)", "24")
+    .argument("[author]", "Filter by author name")
+    .action(async (hours, author) => {
+    const { synopsisCommand } = await import("./commands/synopsis.js");
+    await synopsisCommand(hours, author);
+});
+program
+    .command("service-manager")
+    .description("Manage Service Manager API daemon")
+    .argument("[action]", "start, stop, restart, status, serve")
+    .option("-p, --port <port>", "Port to run on (default: from config or 3402)")
+    .action(async (action, options) => {
+    const { serviceManagerCommand } = await import("./commands/service-manager.js");
+    await serviceManagerCommand(action, {
+        port: options.port ? parseInt(options.port, 10) : undefined
+    });
+});
+program
+    .command("services")
+    .description("Manage services across all GTM projects (interactive TUI or CLI)")
+    .argument("[action]", "create, scan, list, status, start, stop, deps, validate, sync-agents, or leave empty for TUI")
+    .argument("[service]", "Service name")
+    .option("--dry-run", "Preview what would be discovered (for scan) or preview sync changes (for sync-agents)")
+    .option("--current", "Sync only current service (for sync-agents)")
+    .option("--path <path>", "Path to scan (default: current directory)")
+    .option("--force", "Force operation (for stop with dependents)")
+    .option("--verbose", "Verbose output")
+    .option("--fix", "Auto-repair issues (for validate)")
+    .option("--json", "Output JSON (for validate)")
+    .option("--skip-ai", "Skip AI tool, just scaffold (for create)")
+    .action(async (action, service, options) => {
+    // Handle scan action
+    if (action === "scan") {
+        const { scanServices } = await import("./commands/services-scan.js");
+        await scanServices({
+            path: options.path,
+            dryRun: options.dryRun
+        });
+        return;
+    }
+    // Handle dependency actions
+    if (action === "deps" || action === "dependencies") {
+        const { buildDependencyGraph, visualizeDependencies, validateDependencies } = await import("./lib/service-dependencies.js");
+        const fs = await import("fs");
+        const servicesConfigPath = path.join(JFL_PATHS.data, "services.json");
+        const servicesConfig = JSON.parse(fs.readFileSync(servicesConfigPath, "utf-8"));
+        if (service === "validate") {
+            const result = validateDependencies(servicesConfig.services);
+            if (result.valid) {
+                console.log(chalk.green("\n✓ All dependencies valid\n"));
+            }
+            else {
+                console.log(chalk.red("\n✗ Dependency validation failed:\n"));
+                result.errors.forEach(err => console.log(chalk.red(`  - ${err}`)));
+                console.log();
+            }
+        }
+        else {
+            console.log(visualizeDependencies(servicesConfig.services));
+        }
+        return;
+    }
+    // If no action, launch interactive TUI
+    if (!action) {
+        const { spawn } = await import("child_process");
+        const { fileURLToPath } = await import("url");
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const tui = spawn(process.execPath, [
+            path.join(__dirname, "../dist/ui/services-manager.js")
+        ], {
+            stdio: "inherit"
+        });
+        tui.on("exit", (code) => {
+            process.exit(code || 0);
+        });
+    }
+    else {
+        // CLI mode
+        const { servicesCommand } = await import("./commands/services.js");
+        await servicesCommand(action, service, {
+            fix: options.fix,
+            json: options.json,
+            dryRun: options.dryRun,
+            current: options.current,
+            skipAI: options.skipAi
+        });
+    }
+});
+program
+    .command("onboard")
+    .description("Onboard a service repo as a service agent")
+    .argument("<path-or-url>", "Local path to service directory, or git URL to clone")
+    .option("-n, --name <name>", "Override service name")
+    .option("-t, --type <type>", "Override service type (web, api, container, worker, cli, infrastructure, library)")
+    .option("-d, --description <desc>", "Override service description")
+    .option("--skip-git", "Skip git clone (treat URL as local path)")
+    .action(async (pathOrUrl, options) => {
+    const { onboardCommand } = await import("./commands/onboard.js");
+    await onboardCommand(pathOrUrl, options);
+});
+program
+    .command("orchestrate")
+    .description("Execute multi-service orchestration workflows")
+    .argument("[name]", "Orchestration name to run (omit to list available)")
+    .option("--dry-run", "Preview orchestration steps without executing")
+    .option("--list", "List available orchestrations")
+    .option("--create <name>", "Create new orchestration template")
+    .action(async (name, options) => {
+    const { orchestrate, listOrchestrations, createOrchestration } = await import("./commands/orchestrate.js");
+    if (options.list) {
+        await listOrchestrations();
+    }
+    else if (options.create) {
+        await createOrchestration(options.create);
+    }
+    else if (name) {
+        await orchestrate(name, { dryRun: options.dryRun });
+    }
+    else {
+        await listOrchestrations();
+    }
+});
+program
+    .command("dashboard")
+    .description("Launch interactive service monitoring dashboard")
+    .action(async () => {
+    const { startDashboard } = await import("./ui/service-dashboard.js");
+    await startDashboard();
+});
+program
+    .command("service-agent")
+    .description("Manage service MCP agents")
+    .argument("<action>", "init | generate | generate-all | register | unregister | list | clean")
+    .argument("[name]", "Service name (required for generate, unregister)")
+    .action(async (action, name) => {
+    const { init, generate, generateAll, register, unregister, list, clean } = await import("./commands/service-agent.js");
+    switch (action) {
+        case "init":
+            await init(name); // name is optional path
+            break;
+        case "generate":
+            if (!name) {
+                console.log(chalk.red("Error: service name required"));
+                console.log(chalk.gray("Usage: jfl service-agent generate <service-name>"));
+                process.exit(1);
+            }
+            await generate(name);
+            break;
+        case "generate-all":
+            await generateAll();
+            break;
+        case "register":
+            await register(name);
+            break;
+        case "unregister":
+            if (!name) {
+                console.log(chalk.red("Error: service name required"));
+                console.log(chalk.gray("Usage: jfl service-agent unregister <service-name>"));
+                process.exit(1);
+            }
+            await unregister(name);
+            break;
+        case "list":
+            await list();
+            break;
+        case "clean":
+            await clean();
+            break;
+        default:
+            console.log(chalk.red(`Unknown action: ${action}`));
+            console.log(chalk.gray("Available actions: init, generate, generate-all, register, unregister, list, clean"));
+            process.exit(1);
+    }
+});
+program
+    .command("profile [action]")
+    .description("Manage your JFL profile (stored in config)")
+    .argument("[action]", "show, edit, export, import, generate")
+    .option("-f, --file <path>", "File path for export/import/generate output")
+    .action(async (action, options) => {
+    const { profileCommand } = await import("./commands/profile.js");
+    await profileCommand(action, options);
+});
+program
+    .command("migrate-services")
+    .description("Migrate services from references/ to service manager")
+    .argument("[gtm-path]", "Path to GTM project (default: current directory)")
+    .action(async (gtmPath) => {
+    const { migrateServices } = await import("./commands/migrate-services.js");
+    await migrateServices(gtmPath);
+});
+// ============================================================================
+// PLATFORM COMMANDS (require login for full features)
+// ============================================================================
+program
+    .command("login")
+    .description("Login to JFL platform")
+    .option("--platform", "Use Platform Account (recommended)")
+    .option("--x402", "Use x402 Day Pass ($5/day, crypto)")
+    .option("--solo", "Use Solo plan ($49/mo)")
+    .option("--team", "Use Team plan ($199/mo)")
+    .option("--free", "Stay on trial")
+    .option("--force", "Force re-authentication")
+    .action(async (options) => {
+    const { loginCommand } = await import("./commands/login.js");
+    await loginCommand(options);
+});
+program
+    .command("logout")
+    .description("Logout from JFL platform")
+    .action(async () => {
+    const { logout } = await import("./commands/login.js");
+    logout();
+    console.log(chalk.green("Logged out successfully."));
+});
+program
+    .command("preferences")
+    .description("Manage JFL preferences")
+    .option("--clear-ai", "Clear saved AI CLI preference")
+    .option("--no-telemetry", "Disable anonymous telemetry")
+    .option("--telemetry", "Enable anonymous telemetry")
+    .option("--show", "Show current preferences")
+    .action(async (options) => {
+    const { getConfigValue, deleteConfigKey } = await import("./utils/jfl-config.js");
+    if (options.clearAi) {
+        deleteConfigKey("aiCLI");
+        console.log(chalk.green("\n✓ Cleared AI CLI preference"));
+        console.log(chalk.gray("  Next 'jfl' will show selection menu\n"));
+        return;
+    }
+    if (options.telemetry === false) {
+        const telemetry = await getTelemetry();
+        telemetry.disable();
+        console.log(chalk.green("\n✓ Telemetry disabled"));
+        console.log(chalk.gray("  No data will be collected\n"));
+        return;
+    }
+    if (options.telemetry === true) {
+        const telemetry = await getTelemetry();
+        telemetry.enable();
+        console.log(chalk.green("\n✓ Telemetry enabled"));
+        console.log(chalk.gray("  Anonymous usage data helps improve JFL\n"));
+        return;
+    }
+    if (options.show || (!options.clearAi && options.telemetry === undefined)) {
+        const telemetry = await getTelemetry();
+        console.log(chalk.bold("\n  JFL Preferences\n"));
+        console.log(chalk.gray("  AI CLI:") + " " + (getConfigValue("aiCLI") || chalk.gray("none")));
+        console.log(chalk.gray("  Projects tracked:") + " " + ((getConfigValue("projects") || []).length));
+        console.log(chalk.gray("  Telemetry:") + " " + (telemetry.isEnabled() ? chalk.green("enabled") : chalk.red("disabled")));
+        console.log();
+        console.log(chalk.gray("  To clear AI preference:   jfl preferences --clear-ai"));
+        console.log(chalk.gray("  To disable telemetry:     jfl preferences --no-telemetry"));
+        console.log();
+    }
+});
+program
+    .command("wallet")
+    .description("Show wallet and day pass status")
+    .action(async () => {
+    const { showDayPassStatus, hasWallet, getWalletAddress } = await import("./utils/auth-guard.js");
+    const address = getWalletAddress();
+    if (!address) {
+        console.log(chalk.yellow("\n⚠️  No wallet configured"));
+        console.log(chalk.gray("   Run: jfl login\n"));
+        return;
+    }
+    console.log(chalk.bold("\n💰 Wallet Status\n"));
+    console.log(chalk.gray("Address: ") + chalk.cyan(address));
+    if (!hasWallet()) {
+        console.log(chalk.yellow("Mode: View-only (cannot sign payments)"));
+        console.log(chalk.gray("Run 'jfl login' to import signing key"));
+    }
+    else {
+        console.log(chalk.green("Mode: Full (can sign payments)"));
+    }
+    console.log();
+    showDayPassStatus();
+    console.log();
+});
+program
+    .command("deploy")
+    .description("Deploy project to JFL platform")
+    .option("-f, --force", "Force deploy even if no changes")
+    .action(async (options) => {
+    const { deployCommand } = await import("./commands/deploy.js");
+    await deployCommand(options);
+});
+program
+    .command("agents")
+    .description("Manage parallel agents and RL learning agents")
+    .argument("[action]", "Action: list, create, start, stop, destroy, rl")
+    .argument("[subaction]", "For 'rl': status, dashboard, train, tune, feedback, explain")
+    .option("-n, --name <name>", "Agent name")
+    .option("-t, --task <task>", "Task for agent")
+    .option("--agent <name>", "Target specific RL agent")
+    .option("--insight-id <id>", "Insight ID for RL agent feedback")
+    .option("--feedback <type>", "RL agent feedback: helpful, not_helpful, needs_adjustment")
+    .action(async (action, subaction, options) => {
+    if (action === 'rl') {
+        const { tenentAgentsCommand } = await import("./commands/tenet-agents.js");
+        await tenentAgentsCommand(subaction, options);
+    }
+    else {
+        const { agentsCommand } = await import("./commands/agents.js");
+        await agentsCommand(action, options);
+    }
+});
+program
+    .command("feedback")
+    .description("Rate your JFL session")
+    .argument("[action]", "view or sync")
+    .action(async (action) => {
+    const { feedbackCommand } = await import("./commands/feedback.js");
+    await feedbackCommand(action);
+});
+program
+    .command("update")
+    .description("Pull latest JFL product updates")
+    .option("--dry", "Show what would be updated without making changes")
+    .option("--auto", "Auto mode: check once per 24h, skip if recently updated")
+    .action(async (options) => {
+    const { updateCommand } = await import("./commands/update.js");
+    await updateCommand({ dry: options.dry, autoUpdate: options.auto });
+});
+// ============================================================================
+// SKILL MANAGEMENT (work offline)
+// ============================================================================
+const skills = program.command("skills").description("Manage JFL skills");
+skills
+    .command("list")
+    .description("List installed or available skills")
+    .option("-a, --available", "Show all available skills")
+    .option("-c, --category <category>", "Filter by category (core or catalog)")
+    .option("-t, --tag <tag>", "Filter by tag")
+    .action(async (options) => {
+    const { listSkillsCommand } = await import("./commands/skills.js");
+    await listSkillsCommand(options);
+});
+skills
+    .command("install")
+    .description("Install skill(s)")
+    .argument("<skills...>", "Skill name(s) to install")
+    .action(async (skills) => {
+    const { installSkillCommand } = await import("./commands/skills.js");
+    await installSkillCommand(skills);
+});
+skills
+    .command("remove")
+    .description("Remove skill(s)")
+    .argument("<skills...>", "Skill name(s) to remove")
+    .action(async (skills) => {
+    const { removeSkillCommand } = await import("./commands/skills.js");
+    await removeSkillCommand(skills);
+});
+skills
+    .command("update")
+    .description("Update installed skill(s)")
+    .argument("[skill]", "Skill name to update (omit to update all)")
+    .option("--dry", "Show what would be updated without making changes")
+    .action(async (skill, options) => {
+    const { updateSkillsCommand } = await import("./commands/skills.js");
+    await updateSkillsCommand({ ...options, skillName: skill });
+});
+skills
+    .command("search")
+    .description("Search for skills")
+    .argument("<query>", "Search query")
+    .action(async (query) => {
+    const { searchSkillsCommand } = await import("./commands/skills.js");
+    await searchSkillsCommand(query);
+});
+// ============================================================================
+// VOICE INPUT (work offline)
+// ============================================================================
+const voice = program.command("voice").description("Voice input for JFL");
+voice
+    .command("model")
+    .description("Manage whisper models")
+    .argument("[action]", "list, download, or default")
+    .argument("[name]", "Model name (tiny, base, small, etc.)")
+    .option("-f, --force", "Force re-download")
+    .action(async (action, name, options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("model", action, name, options);
+});
+voice
+    .command("devices")
+    .description("List audio input devices")
+    .action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("devices");
+});
+voice
+    .command("test")
+    .description("Test voice input (record 3s and transcribe)")
+    .option("-d, --device <id>", "Device ID to use")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("test", undefined, undefined, {
+        device: options.device,
+    });
+});
+voice
+    .command("recording")
+    .description("Test recording only (no transcription)")
+    .option("-d, --device <id>", "Device ID to use")
+    .option("-t, --duration <seconds>", "Recording duration in seconds", "5")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("recording", undefined, undefined, {
+        device: options.device,
+        duration: parseInt(options.duration, 10),
+    });
+});
+voice
+    .command("setup")
+    .description("First-time setup wizard for voice input")
+    .action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("setup");
+});
+voice
+    .command("record")
+    .description("Record voice with VAD (same as running jfl voice)")
+    .option("-d, --device <id>", "Device ID to use")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("record", undefined, undefined, {
+        device: options.device,
+    });
+});
+voice
+    .command("help")
+    .description("Show voice command help")
+    .action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("help");
+});
+voice
+    .command("hotkey")
+    .description("Start global hotkey listener (macOS only)")
+    .option("-d, --device <id>", "Device ID to use")
+    .option("-m, --mode <mode>", "Hotkey mode: auto, tap, or hold (default: auto)")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("hotkey", undefined, undefined, {
+        device: options.device,
+        mode: options.mode,
+    });
+});
+// VS-013: Daemon commands for background hotkey listening
+const daemon = voice
+    .command("daemon")
+    .description("Background hotkey listener daemon (macOS only)");
+daemon
+    .command("start")
+    .description("Start hotkey listener in background")
+    .option("-m, --mode <mode>", "Hotkey mode: auto, tap, or hold (default: auto)")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("daemon", "start", undefined, {
+        mode: options.mode,
+    });
+});
+daemon
+    .command("stop")
+    .description("Stop the background daemon")
+    .action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("daemon", "stop");
+});
+daemon
+    .command("status")
+    .description("Show daemon status and uptime")
+    .action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("daemon", "status");
+});
+// Default daemon action (show status)
+daemon.action(async () => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand("daemon", "status");
+});
+// Running `jfl voice` without subcommand starts recording with VAD
+voice
+    .option("-d, --device <id>", "Device ID to use")
+    .action(async (options) => {
+    const { voiceCommand } = await import("./commands/voice.js");
+    await voiceCommand(undefined, undefined, undefined, {
+        device: options.device,
+    });
+});
+// ============================================================================
+// MEMORY SYSTEM (work offline)
+// ============================================================================
+const memory = program.command("memory").description("Memory system management");
+memory
+    .command("init")
+    .description("Initialize memory database")
+    .action(async () => {
+    const { memoryInitCommand } = await import("./commands/memory.js");
+    await memoryInitCommand();
+});
+memory
+    .command("status")
+    .description("Show memory statistics")
+    .action(async () => {
+    const { memoryStatusCommand } = await import("./commands/memory.js");
+    await memoryStatusCommand();
+});
+memory
+    .command("search")
+    .description("Search memories")
+    .argument("<query>", "Search query")
+    .option("-t, --type <type>", "Filter by type (feature, fix, decision, etc.)")
+    .option("-n, --max <n>", "Maximum results", "10")
+    .action(async (query, options) => {
+    const { memorySearchCommand } = await import("./commands/memory.js");
+    await memorySearchCommand(query, options);
+});
+memory
+    .command("index")
+    .description("Reindex journal entries")
+    .option("-f, --force", "Force full reindex")
+    .action(async (options) => {
+    const { memoryIndexCommand } = await import("./commands/memory.js");
+    await memoryIndexCommand(options);
+});
+// Alias: jfl ask <question> → jfl memory search <question>
+program
+    .command("ask")
+    .description("Ask a question - searches memory system")
+    .argument("<question>", "Question to search for in memory")
+    .option("-t, --type <type>", "Filter by type (feature, fix, decision, etc.)")
+    .option("-n, --max <n>", "Maximum results", "5")
+    .action(async (question, options) => {
+    const { memorySearchCommand } = await import("./commands/memory.js");
+    await memorySearchCommand(question, options);
+});
+// ============================================================================
+// SKILL SHORTCUTS (work offline)
+// ============================================================================
+program
+    .command("brand")
+    .description("Run brand architect skill")
+    .argument("[subcommand]", "marks, colors, typography, or full")
+    .action(async (subcommand) => {
+    console.log(chalk.cyan("Running /brand-architect..."));
+    console.log(chalk.gray("This skill runs in your Claude Code session."));
+    console.log(chalk.yellow("\nRun in Claude Code:"), "/brand-architect", subcommand || "");
+});
+program
+    .command("content")
+    .description("Run content creator skill")
+    .argument("<type>", "thread, post, article, or one-pager")
+    .argument("[topic]", "Topic for content")
+    .action(async (type, topic) => {
+    console.log(chalk.cyan("Running /content..."));
+    console.log(chalk.gray("This skill runs in your Claude Code session."));
+    console.log(chalk.yellow("\nRun in Claude Code:"), "/content", type, topic || "");
+});
+// ============================================================================
+// RALPH TUI (autonomous task execution)
+// ============================================================================
+program
+    .command("ralph")
+    .description("AI agent loop orchestrator (ralph-tui)")
+    .argument("[command...]", "ralph-tui command and args")
+    .option("-h, --help", "Show ralph-tui help")
+    .allowUnknownOption()
+    .action(async (args, options) => {
+    const { ralphCommand, showRalphHelp } = await import("./commands/ralph.js");
+    if (options.help || args.length === 0) {
+        showRalphHelp();
+        return;
+    }
+    await ralphCommand(args);
+});
+program
+    .command("events")
+    .description("Live MAP event bus dashboard")
+    .option("-p, --pattern <pattern>", "Filter pattern (default: *)")
+    .action(async (options) => {
+    const { startEventDashboard } = await import("./ui/event-dashboard.js");
+    await startEventDashboard({ pattern: options.pattern });
+});
+program
+    .command("peter")
+    .description("Peter Parker - model-routed agent orchestrator")
+    .argument("[action]", "setup, run, pr, experiment, autoresearch, status, agent, or dashboard")
+    .argument("[name]", "Agent name (for agent subcommand)")
+    .option("--cost", "Cost-optimized model routing (haiku-heavy)")
+    .option("--balanced", "Balanced model routing (default)")
+    .option("--quality", "Quality-first model routing (opus-heavy)")
+    .option("-t, --task <task>", "Task to run (for run action)")
+    .option("-r, --rounds <n>", "Number of autoresearch rounds (default: 5)")
+    .option("--mode <mode>", "Experiment mode: default or autoresearch")
+    .option("--budget <amount>", "Cost budget in USD (Pi runtime: auto-downgrades model when exceeded)")
+    .option("--pi", "Force Pi runtime (default: auto-detect based on 'pi' command availability)")
+    .action(async (action, name, options) => {
+    const { peterCommand } = await import("./commands/peter.js");
+    if (name)
+        options.name = name;
+    await peterCommand(action, options);
+});
+// ============================================================================
+// TEST MODE (for development)
+// ============================================================================
+program
+    .command("test")
+    .description("Test onboarding flow (isolated environment)")
+    .action(() => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = join(__filename, "..");
+    const scriptPath = join(__dirname, "../scripts/test-onboarding.sh");
+    const test = spawn("bash", [scriptPath], {
+        stdio: "inherit",
+    });
+    test.on("error", (err) => {
+        console.log(chalk.red("\n❌ Failed to launch test mode"));
+        console.log(chalk.gray("  Make sure the test script exists at: scripts/test-onboarding.sh"));
+    });
+});
+// ============================================================================
+// CLAWDBOT INTEGRATION
+// ============================================================================
+const clawdbot = program.command("clawdbot").description("Manage JFL plugin for Clawdbot gateway");
+clawdbot
+    .command("setup")
+    .description("Install JFL plugin into Clawdbot and configure it")
+    .action(async () => {
+    const { clawdbotSetupCommand } = await import("./commands/clawdbot.js");
+    await clawdbotSetupCommand();
+});
+clawdbot
+    .command("status")
+    .description("Show JFL Clawdbot plugin installation status")
+    .action(async () => {
+    const { clawdbotStatusCommand } = await import("./commands/clawdbot.js");
+    await clawdbotStatusCommand();
+});
+// Default action: show status
+clawdbot.action(async () => {
+    const { clawdbotStatusCommand } = await import("./commands/clawdbot.js");
+    await clawdbotStatusCommand();
+});
+// ============================================================================
+// PIVOT (checkpoint + context reset)
+// ============================================================================
+program
+    .command("pivot")
+    .description("Checkpoint current work to journals/memory and signal context reset — same branch, no restart hooks")
+    .option("-s, --summary <text>", "Summary of what you were working on")
+    .option("--push", "Push to remote after pivot")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+    const { pivotCommand } = await import("./commands/pivot.js");
+    await pivotCommand(options);
+});
+// ============================================================================
+// OPENCLAW (runtime-agnostic agent protocol)
+// ============================================================================
+const openclaw = program.command("openclaw").description("OpenClaw agent protocol - runtime-agnostic JFL integration");
+openclaw
+    .command("session-start")
+    .description("Start an agent session (branch, auto-commit, Context Hub)")
+    .requiredOption("-a, --agent <name>", "Agent name/ID")
+    .option("-g, --gtm <path>", "GTM workspace path")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { sessionStartCommand } = await import("./commands/openclaw.js");
+    await sessionStartCommand(options);
+});
+openclaw
+    .command("session-end")
+    .description("End session (commit, merge, cleanup)")
+    .option("-s, --sync", "Sync to GTM parent (for services)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { sessionEndCommand } = await import("./commands/openclaw.js");
+    await sessionEndCommand(options);
+});
+openclaw
+    .command("heartbeat")
+    .description("Health pulse (auto-commit, check Context Hub)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { heartbeatCommand: openclawHeartbeat } = await import("./commands/openclaw.js");
+    await openclawHeartbeat(options);
+});
+openclaw
+    .command("context")
+    .description("Get unified context from Context Hub")
+    .option("-q, --query <query>", "Search query")
+    .option("-t, --task-type <type>", "Task type (code, spec, content, strategy, general)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { contextCommand } = await import("./commands/openclaw.js");
+    await contextCommand(options);
+});
+openclaw
+    .command("journal")
+    .description("Write a journal entry")
+    .requiredOption("--type <type>", "Entry type (feature, fix, decision, milestone, spec, discovery)")
+    .requiredOption("--title <title>", "Entry title")
+    .requiredOption("--summary <summary>", "Entry summary")
+    .option("--detail <detail>", "Full detail")
+    .option("--files <files>", "Comma-separated file paths")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { journalCommand } = await import("./commands/openclaw.js");
+    await journalCommand(options);
+});
+openclaw
+    .command("status")
+    .description("Show agent session state and health")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { statusCommand: openclawStatus } = await import("./commands/openclaw.js");
+    await openclawStatus(options);
+});
+openclaw
+    .command("gtm-list")
+    .description("List registered GTM workspaces")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { gtmListCommand } = await import("./commands/openclaw.js");
+    await gtmListCommand(options);
+});
+openclaw
+    .command("gtm-switch")
+    .description("Switch active GTM workspace")
+    .argument("<gtm-id>", "GTM ID to switch to")
+    .option("--json", "Output JSON")
+    .action(async (gtmId, options) => {
+    const { gtmSwitchCommand } = await import("./commands/openclaw.js");
+    await gtmSwitchCommand(gtmId, options);
+});
+openclaw
+    .command("gtm-create")
+    .description("Create and register a new GTM workspace")
+    .argument("<name>", "GTM workspace name")
+    .option("-p, --path <dir>", "Target directory")
+    .option("--json", "Output JSON")
+    .action(async (name, options) => {
+    const { gtmCreateCommand } = await import("./commands/openclaw.js");
+    await gtmCreateCommand(name, options);
+});
+openclaw
+    .command("register")
+    .description("Register agent with a GTM workspace")
+    .requiredOption("-g, --gtm <path>", "GTM workspace path")
+    .option("-a, --agent <name>", "Agent name (auto-detected from manifest)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    const { registerCommand } = await import("./commands/openclaw.js");
+    await registerCommand(options);
+});
+openclaw
+    .command("tag")
+    .description("Send message to a service agent")
+    .argument("<service>", "Service name")
+    .argument("<message>", "Message to send")
+    .option("--json", "Output JSON")
+    .action(async (service, message, options) => {
+    const { tagCommand } = await import("./commands/openclaw.js");
+    await tagCommand(service, message, options);
+});
+openclaw
+    .command("install-skill")
+    .description("Install jfl-gtm skill into OpenClaw (~/.openclaw/skills/)")
+    .option("--dir <path>", "Custom install directory")
+    .action(async (options) => {
+    const { installSkillCommand } = await import("./commands/openclaw.js");
+    await installSkillCommand(options);
+});
+// ============================================================================
+// CI WORKFLOWS
+// ============================================================================
+const ci = program.command("ci").description("CI/CD workflow management");
+ci
+    .command("setup")
+    .description("Deploy eval + review CI workflows to .github/workflows/")
+    .action(async () => {
+    const { ciSetupCommand } = await import("./commands/ci-setup.js");
+    await ciSetupCommand();
+});
+ci.action(() => {
+    ci.outputHelp();
+});
+// ============================================================================
+// EVAL FRAMEWORK
+// ============================================================================
+// Lazy command registration — modules loaded only when command is invoked
+// (was: registerXxxCommand eager imports adding ~200ms to startup)
+// --- eval ---
+const evalCmd = program.command("eval").description("Eval framework — track agent metrics over time");
+evalCmd.command("list").description("List recent eval entries").option("--agent <name>", "Filter by agent name").option("--limit <n>", "Max entries to show", "20").action(async (options) => { const m = await import("./commands/eval.js"); await m.listCommand(options); });
+evalCmd.command("trajectory").description("Show metric trajectory over time").requiredOption("--agent <name>", "Agent name").option("--metric <name>", "Metric to plot (default: composite)").action(async (options) => { const m = await import("./commands/eval.js"); await m.trajectoryCommand(options); });
+evalCmd.command("log").description("Log an eval entry").requiredOption("--agent <name>", "Agent name").requiredOption("--metrics <json>", "Metrics as JSON object").option("--composite <n>", "Composite score").option("--model-version <v>", "Model version").option("--dataset <ds>", "Dataset name").option("--run-id <id>", "Run ID").option("--notes <text>", "Notes").action(async (options) => { const m = await import("./commands/eval.js"); await m.logCommand(options); });
+evalCmd.command("compare").description("Compare agents side-by-side").requiredOption("--agents <list>", "Comma-separated agent names").option("--metric <name>", "Metric to compare (default: composite)").action(async (options) => { const m = await import("./commands/eval.js"); await m.compareCommand(options); });
+evalCmd.command("tuples").description("Extract training tuples from journals").option("--team <name>", "Filter by team").option("--since <date>", "Only tuples after this date").option("--report", "Full markdown report").action(async (options) => { const m = await import("./commands/eval.js"); await m.tuplesCommand(options); });
+evalCmd.command("buffer").description("View or export RL training buffer (.jfl/training-buffer.jsonl)").option("--export", "Export as JSONL for policy head training").option("--limit <n>", "Max entries to show", "10").action(async (options) => { const m = await import("./commands/eval.js"); await m.bufferCommand(options); });
+evalCmd.command("mine").description("Mine training tuples from journals, events, telemetry, and eval history").option("--all", "Scan all JFL projects (from ~/.config/jfl/config.json)").option("--telemetry", "Include global telemetry archive (58k+ events)").option("--dry-run", "Show what would be mined without writing").option("--dir <path>", "Specific directory to mine").action(async (options) => { const m = await import("./commands/eval.js"); await m.mineCommand(options); });
+evalCmd.command("train").description("Train policy head from training buffer (requires STRATUS_API_KEY)").option("--epochs <n>", "Training epochs", "50").option("--lr <rate>", "Learning rate", "0.0001").action(async (options) => { const m = await import("./commands/eval.js"); await m.trainCommand(options); });
+evalCmd.action(async () => { const m = await import("./commands/eval.js"); await m.listCommand({}); });
+// --- predict ---
+const predictCmd = program.command("predict").description("Predict eval score delta before executing changes (Stratus world model)");
+predictCmd.command("run").description("Generate a prediction for a proposed change").requiredOption("--proposal <text>", "Description of the proposed change").requiredOption("--goal <text>", "Goal expression (e.g. 'test_pass_rate > 0.9')").option("--score <n>", "Current composite score", "0").option("--type <type>", "Change type: fix, refactor, feature, config", "fix").option("--scope <scope>", "Change scope: small, medium, large", "medium").option("--files <list>", "Comma-separated affected files").option("--failing-evals <list>", "Comma-separated failing eval names").action(async (options) => { const m = await import("./commands/predict.js"); await m.predictCommand(options); });
+predictCmd.command("resolve").description("Resolve a prediction with actual results").requiredOption("--id <prediction_id>", "Prediction ID to resolve").requiredOption("--actual-delta <n>", "Actual score delta").requiredOption("--actual-score <n>", "Actual final score").requiredOption("--eval-run <id>", "Eval run ID").action(async (options) => { const m = await import("./commands/predict.js"); await m.resolveCommand({ resolve: options.id, actualDelta: options.actualDelta, actualScore: options.actualScore, evalRun: options.evalRun }); });
+predictCmd.command("accuracy").description("Show prediction accuracy statistics").action(async () => { const m = await import("./commands/predict.js"); await m.accuracyCommand(); });
+predictCmd.command("history").description("Show recent predictions").option("--limit <n>", "Max entries to show", "20").action(async (options) => { const m = await import("./commands/predict.js"); await m.historyCommand(options); });
+predictCmd.action(async () => { console.log(chalk.bold("\n  Stratus Prediction Engine\n")); console.log(chalk.gray("  Commands:")); console.log(chalk.gray('    jfl predict run --proposal "..." --goal "..."  Generate prediction')); console.log(chalk.gray("    jfl predict resolve --id <id> ...              Resolve with actuals")); console.log(chalk.gray("    jfl predict accuracy                           Show accuracy stats")); console.log(chalk.gray("    jfl predict history                            Recent predictions")); console.log(); });
+// --- portfolio ---
+const portfolioCmd = program.command("portfolio").description("Manage portfolio of GTM workspaces");
+portfolioCmd.command("register <path>").description("Register a GTM workspace in this portfolio").action(async (gtmPath) => { const m = await import("./commands/portfolio.js"); await m.portfolioRegisterCommand(gtmPath); });
+portfolioCmd.command("list").description("List registered GTM workspaces").action(async () => { const m = await import("./commands/portfolio.js"); await m.portfolioListCommand(); });
+portfolioCmd.command("unregister <name>").description("Remove a GTM workspace from this portfolio").action(async (name) => { const m = await import("./commands/portfolio.js"); await m.portfolioUnregisterCommand(name); });
+portfolioCmd.command("status").description("Portfolio health and eval summary").action(async () => { const m = await import("./commands/portfolio.js"); await m.portfolioStatusCommand(); });
+portfolioCmd.command("phone-home").description("Sync this GTM's journals and activity to its portfolio parent").action(async () => { const m = await import("./commands/portfolio.js"); await m.portfolioPhoneHomeCommand(); });
+// --- viz ---
+const vizCmd = program.command("viz").description("Terminal visualizations — headless dashboard data via Context Hub");
+vizCmd.command("experiments").description("Show experiment runs with dot plot, sparklines, and score table").option("--agent <name>", "Filter to a specific agent").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.experimentsCommand(options); });
+vizCmd.command("leaderboard").description("Ranked agent leaderboard with sparklines and bar chart").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.leaderboardCommand(options); });
+vizCmd.command("flows").description("Flow definitions and pending executions").option("--pending", "Show only pending approval executions").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.flowsVizCommand(options); });
+vizCmd.command("events").description("Recent event stream with type coloring").option("--pattern <pattern>", "Filter events by type pattern").option("--limit <n>", "Max events to show", "20").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.eventsCommand(options); });
+vizCmd.command("status").description("Hub health, children, sources, item count").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.statusCommand(options); });
+vizCmd.command("dash").description("Composite dashboard — leaderboard, pending flows, events, status").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.dashCommand(options); });
+vizCmd.command("loop").description("Self-driving loop pipeline — detect, propose, eval, merge, learn").option("--days <n>", "Lookback period in days", "7").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.loopCommand(options); });
+vizCmd.command("learning").description("Policy head learning curve — tuples, accuracy, action rewards").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.learningCommand(options); });
+vizCmd.command("fleet").description("VM fleet status — parallel agent waves and tuple collection").option("--wave <id>", "Filter to a specific wave ID").option("--json", "Output as JSON").action(async (options) => { const m = await import("./commands/viz.js"); await m.fleetCommand(options); });
+vizCmd.action(async () => { const m = await import("./commands/viz.js"); await m.dashCommand({}); });
+// --- findings ---
+const findingsCmd = program.command("findings").description("Surface and fix problems automatically");
+findingsCmd.command("list", { isDefault: true }).description("List current findings").option("--refresh", "Re-analyze before listing").option("--all", "Include dismissed findings").action(async (options) => { const m = await import("./commands/findings.js"); await m.listCommand(options); });
+findingsCmd.command("fix <n>").description("Spawn an agent to fix finding #n").action(async (n) => { const m = await import("./commands/findings.js"); await m.fixCommand(n); });
+findingsCmd.command("dismiss <n>").description("Dismiss finding #n").action(async (n) => { const m = await import("./commands/findings.js"); await m.dismissCommand(n); });
+findingsCmd.command("analyze").description("Force re-analyze the project").action(async () => { const m = await import("./commands/findings.js"); await m.analyzeCommand(); });
+findingsCmd.action(async () => { const m = await import("./commands/findings.js"); await m.listCommand({}); });
+// --- verify ---
+program.command("verify").description("Run TLA+ model checking on system specs")
+    .option("-s, --spec <name>", "Check a specific spec (default: all)")
+    .option("-t, --timeout <seconds>", "TLC timeout in seconds", "120")
+    .option("--apalache", "Use Apalache (symbolic bounded) instead of TLC")
+    .option("-v, --verbose", "Show full TLC output")
+    .option("--json", "Output results as JSON (pipe-friendly)")
+    .action(async (options) => { const m = await import("./commands/verify.js"); await m.verifyCommand({ ...options, timeout: parseInt(options.timeout) }); });
+// ============================================================================
+// TELEMETRY
+// ============================================================================
+const telemetryCmd = program.command("telemetry").description("Manage anonymous usage telemetry");
+// Digest command registered lazily (was: registerDigestCommand)
+telemetryCmd
+    .command('digest')
+    .description('Analyze telemetry events: costs, stats, and suggestions')
+    .option('--hours <hours>', 'Analysis period in hours', '24')
+    .option('--format <format>', 'Output format: text or json', 'text')
+    .option('--plots', 'Render terminal charts for key metrics')
+    .option('--platform', 'Include platform-side data (requires network)')
+    .action(async (options) => { const m = await import("./commands/digest.js"); await m.digestCommand(options); });
+telemetryCmd
+    .command("status")
+    .description("Show telemetry status")
+    .action(async () => {
+    const telemetry = await getTelemetry();
+    const enabled = telemetry.isEnabled();
+    const installId = telemetry.getInstallId();
+    const queueSize = telemetry.getQueueSize();
+    const spillover = telemetry.getSpilloverEvents();
+    console.log(chalk.bold("\n  Telemetry Status\n"));
+    console.log(chalk.gray("  Enabled:    ") + (enabled ? chalk.green("yes") : chalk.red("no")));
+    if (enabled) {
+        console.log(chalk.gray("  Install ID: ") + chalk.cyan(installId));
+        console.log(chalk.gray("  Queue:      ") + `${queueSize} events pending`);
+        console.log(chalk.gray("  Spillover:  ") + `${spillover.length} events on disk`);
+    }
+    console.log(chalk.gray("\n  Disable: jfl preferences --no-telemetry"));
+    console.log(chalk.gray("  Or set:  JFL_TELEMETRY=0\n"));
+});
+telemetryCmd
+    .command("show")
+    .description("Show recent telemetry events from spillover queue")
+    .action(async () => {
+    const telemetry = await getTelemetry();
+    const spillover = telemetry.getSpilloverEvents();
+    if (spillover.length === 0) {
+        console.log(chalk.gray("\n  No events in spillover queue.\n"));
+        return;
+    }
+    console.log(chalk.bold(`\n  Last ${Math.min(spillover.length, 20)} events:\n`));
+    for (const event of spillover.slice(-20)) {
+        const time = event.ts.replace('T', ' ').slice(0, 19);
+        console.log(chalk.gray(`  [${time}]`) + ` ${chalk.cyan(event.event)}` + (event.duration_ms ? chalk.gray(` ${event.duration_ms}ms`) : ''));
+    }
+    console.log();
+});
+telemetryCmd
+    .command("reset")
+    .description("Reset install ID (generates new anonymous ID)")
+    .action(async () => {
+    const telemetry = await getTelemetry();
+    telemetry.resetInstallId();
+    console.log(chalk.green("\n  Install ID reset. New ID: ") + chalk.cyan(telemetry.getInstallId()) + "\n");
+});
+telemetryCmd
+    .command("track")
+    .description("Emit a telemetry event (for shell scripts/hooks)")
+    .requiredOption("--category <category>", "Event category (command, error, context_hub, session, performance)")
+    .requiredOption("--event <event>", "Event name (e.g., hook:session_init)")
+    .option("--duration <ms>", "Duration in milliseconds")
+    .option("--success <bool>", "Whether the operation succeeded")
+    .option("--endpoint <endpoint>", "HTTP endpoint")
+    .option("--error-type <type>", "Error type")
+    .option("--error-code <code>", "Error code")
+    .allowUnknownOption()
+    .action(async (options) => {
+    const telemetry = await getTelemetry();
+    telemetry.track({
+        category: options.category,
+        event: options.event,
+        duration_ms: options.duration ? parseInt(options.duration, 10) : undefined,
+        success: options.success !== undefined ? options.success === 'true' : undefined,
+        endpoint: options.endpoint,
+        error_type: options.errorType,
+        error_code: options.errorCode,
+    });
+    await telemetry.flush();
+});
+telemetryCmd
+    .command("monitor")
+    .description("Monitor physical-world telemetry data in real-time")
+    .option("--live", "Live monitoring with auto-refresh")
+    .option("--compact", "Compact display mode")
+    .option("--interval <seconds>", "Update interval in seconds (default: 5)", "5")
+    .option("--filter <pattern>", "Filter events by category, event name, or content")
+    .action(async (options) => {
+    const { telemetryMonitorCommand } = await import("./commands/telemetry-monitor.js");
+    await telemetryMonitorCommand(options);
+});
+telemetryCmd
+    .command("test")
+    .description("Generate test physical-world telemetry data (for testing)")
+    .option("--count <n>", "Number of events to generate (default: 10)", "10")
+    .option("--interval <ms>", "Interval between events in ms (default: 1000)", "1000")
+    .option("--categories <list>", "Comma-separated event categories (default: command,performance,session)")
+    .action(async (options) => {
+    const { telemetryTestCommand } = await import("./commands/telemetry-test.js");
+    await telemetryTestCommand(options);
+});
+// Default telemetry action
+telemetryCmd.action(async () => {
+    // Show status by default
+    const telemetry = await getTelemetry();
+    const enabled = telemetry.isEnabled();
+    const installId = telemetry.getInstallId();
+    console.log(chalk.bold("\n  Telemetry Status\n"));
+    console.log(chalk.gray("  Enabled:    ") + (enabled ? chalk.green("yes") : chalk.red("no")));
+    if (enabled) {
+        console.log(chalk.gray("  Install ID: ") + chalk.cyan(installId));
+    }
+    console.log(chalk.gray("\n  Commands:"));
+    console.log("    jfl telemetry status    Show detailed status");
+    console.log("    jfl telemetry show      Show queued events");
+    console.log("    jfl telemetry digest    Cost and health analysis");
+    console.log("    jfl telemetry monitor   Monitor physical-world data");
+    console.log("    jfl telemetry reset     Reset install ID");
+    console.log();
+});
+// ============================================================================
+// IMPROVE
+// ============================================================================
+program
+    .command("organize")
+    .description("Audit knowledge docs for staleness, propose updates, manage lifecycle")
+    .option("--fix", "Generate PENDING.md with proposed updates and open questions")
+    .option("--apply", "Apply reviewed changes from PENDING.md")
+    .option("--archive", "Move archive-candidate docs to knowledge/archive/")
+    .option("--days <days>", "Journal lookback period in days", "30")
+    .action(async (options) => {
+    const { organizeCommand } = await import("./commands/organize.js");
+    await organizeCommand({ ...options, days: parseInt(options.days || "30") });
+});
+program
+    .command("improve")
+    .description("Analyze telemetry and suggest improvements")
+    .option("--dry-run", "Preview suggestions without creating issues")
+    .option("--auto", "Create GitHub issues for actionable suggestions")
+    .option("--hours <hours>", "Analysis period in hours", "24")
+    .action(async (options) => {
+    const { improveCommand } = await import("./commands/improve.js");
+    await improveCommand(options);
+});
+// ============================================================================
+// DOCTOR (unified health check)
+// ============================================================================
+program
+    .command("doctor")
+    .description("Check project health and auto-repair")
+    .option("--fix", "Auto-repair fixable issues")
+    .option("--json", "Output structured JSON (machine-readable)")
+    .action(async (options) => {
+    const { doctorCommand } = await import("./commands/doctor.js");
+    await doctorCommand({ fix: options.fix, json: options.json });
+});
+// ============================================================================
+// TRAIN (policy head training pipeline)
+// ============================================================================
+const train = program.command("train").description("Policy head training pipeline");
+train
+    .command("policy-head")
+    .description("Train policy head (v2 transformer by default, --v1 for legacy MLP)")
+    .option("-f, --force", "Train even if threshold not met")
+    .option("--v1", "Use v1 MLP trainer instead of v2 transformer")
+    .option("--epochs <n>", "Max training epochs")
+    .option("--lr <rate>", "Learning rate")
+    .option("--batch-size <n>", "Batch size")
+    .option("--min-entries <n>", "Minimum entries required")
+    .option("-o, --output <path>", "Output path for weights (v1 only)")
+    .option("-a, --agent <name>", "Filter training data to specific agent")
+    .action(async (options) => {
+    const { trainPolicyHead } = await import("./commands/train.js");
+    await trainPolicyHead(options);
+});
+train
+    .command("transform")
+    .description("Transform training buffer to v2 format (current_state, goal, correct_tool)")
+    .option("--all", "Include entries where improved=false")
+    .action(async (options) => {
+    const { trainTransform } = await import("./commands/train.js");
+    await trainTransform(options);
+});
+train
+    .command("generate")
+    .description("Generate synthetic training data for v2 policy head")
+    .option("--goals-per-tool <n>", "Goals to generate per tool (default: 50)")
+    .option("--states-per-goal <n>", "States to generate per goal (default: 2)")
+    .action(async (options) => {
+    const { trainGenerate } = await import("./commands/train.js");
+    await trainGenerate(options);
+});
+train
+    .command("eval")
+    .description("Evaluate v2 policy head — per-tool accuracy report")
+    .option("--split <name>", "Which split to evaluate: train/val/test (default: test)")
+    .action(async (options) => {
+    const { trainEval } = await import("./commands/train.js");
+    await trainEval(options);
+});
+train
+    .command("status")
+    .description("Show training data stats, model info, and threshold")
+    .action(async () => {
+    const { trainStatus } = await import("./commands/train.js");
+    await trainStatus();
+});
+train
+    .command("export")
+    .description("Export training data for external tools")
+    .option("--format <fmt>", "Export format: jsonl or csv (default: jsonl)")
+    .action(async (options) => {
+    const { trainExport } = await import("./commands/train.js");
+    await trainExport(options);
+});
+train
+    .command("check")
+    .description("Check if training threshold is met")
+    .option("-q, --quiet", "Quiet mode — exit code only")
+    .action(async (options) => {
+    const { trainThresholdCheck } = await import("./commands/train.js");
+    const ready = await trainThresholdCheck(options);
+    if (!ready)
+        process.exitCode = 1;
+});
+train.action(async () => {
+    const { trainStatus } = await import("./commands/train.js");
+    await trainStatus();
+});
+// ============================================================================
+// AGENT (narrowly-scoped agent scaffolding)
+// ============================================================================
+const agent = program.command("agent").description("Manage narrowly-scoped agents");
+agent
+    .command("init")
+    .description("Scaffold a new agent (manifest + policy + flows)")
+    .argument("<name>", "Agent name (lowercase, hyphens allowed)")
+    .option("-d, --description <desc>", "Agent description")
+    .action(async (name, options) => {
+    const { agentCommand } = await import("./commands/agent.js");
+    await agentCommand("init", name, { description: options.description });
+});
+agent
+    .command("list")
+    .description("List registered agents")
+    .action(async () => {
+    const { agentCommand } = await import("./commands/agent.js");
+    await agentCommand("list");
+});
+agent
+    .command("status")
+    .description("Show agent health and config")
+    .argument("<name>", "Agent name")
+    .action(async (name) => {
+    const { agentCommand } = await import("./commands/agent.js");
+    await agentCommand("status", name);
+});
+agent.action(async () => {
+    const { agentCommand } = await import("./commands/agent.js");
+    await agentCommand();
+});
+// ============================================================================
+// SETUP (auto-configure RL agents from project context)
+// ============================================================================
+program
+    .command("setup")
+    .description("Progressive intelligent setup - personalized RL agents based on your development patterns")
+    .option("--dry-run", "Show recommendations without writing files")
+    .option("-f, --force", "Proceed even if readiness check fails")
+    .option("--from-violations", "Generate agents from TLC invariant violations")
+    .option("--smart", "Use Stratus reasoning for agent recommendations")
+    .action(async (options) => {
+    const { setupCommand } = await import("./commands/setup.js");
+    await setupCommand(options);
+});
+// ============================================================================
+// GTM COMMANDS
+// ============================================================================
+const gtm = program.command("gtm").description("GTM workspace management");
+gtm
+    .command("process-service-update")
+    .description("Process service sync notification (called by hooks)")
+    .argument("[event-file]", "Path to service sync event JSON file")
+    .action(async (eventFile) => {
+    const { gtmProcessUpdate } = await import("./commands/gtm-process-update.js");
+    await gtmProcessUpdate(eventFile);
+});
+// ============================================================================
+// PI INTEGRATION
+// ============================================================================
+const piCmd = program
+    .command("pi")
+    .description("Pi AI agent runtime — launch JFL with Pi extensions, multi-provider LLM, agent grid")
+    .option("--provider <name>", "AI provider (anthropic, google, openai, openrouter)")
+    .option("--model <id>", "Model ID or pattern (e.g. claude-opus-4-6, *sonnet*, gpt-4o)")
+    .option("--thinking <level>", "Thinking level: off, low, medium, high, xhigh")
+    .option("--yolo", "Skip all permission prompts (pass-through to Pi)")
+    .option("--mode <mode>", "Pi mode: interactive (default), rpc, headless")
+    .option("--task <task>", "Task for RPC/headless mode")
+    .option("--onboarding <v1|v2|v3>", "Onboarding variant: v1 (minimal), v2 (cinematic), v3 (mission control)")
+    .allowUnknownOption(true)
+    .action(async (options, cmd) => {
+    const { piCommand } = await import("./commands/pi.js");
+    await piCommand(options, cmd.args);
+});
+const piAgents = piCmd.command("agents").description("Manage Pi agent team sessions");
+piAgents
+    .command("run")
+    .description("Spawn agent team as Pi RPC subprocesses")
+    .option("--team <yaml>", "Team configuration YAML", "teams/gtm-team.yaml")
+    .option("--dry-run", "Show what would be spawned without spawning")
+    .action(async (options) => {
+    const { piAgentsRunCommand } = await import("./commands/pi.js");
+    await piAgentsRunCommand(options);
+});
+// ============================================================================
+const piFleet = piCmd.command("fleet").description("VM agent fleet — spawn, collect, destroy waves of autonomous agents");
+piFleet
+    .command("setup")
+    .description("Install VM backend, check boot arg, create base image")
+    .option("--backend <name>", "VM backend: lume (default)", "lume")
+    .option("--cpus <n>", "CPUs per VM", "4")
+    .option("--memory <mb>", "Memory per VM in MB", "4096")
+    .option("--skip-boot-arg", "Skip VM quota boot arg check")
+    .action(async (options) => {
+    const { fleetSetup } = await import("./commands/pi-fleet.js");
+    await fleetSetup({ ...options, cpus: parseInt(options.cpus), memory: parseInt(options.memory) });
+});
+piFleet
+    .command("spawn <count>")
+    .description("Spawn N agent VMs for parallel autoresearch")
+    .option("--rounds <n>", "Autoresearch rounds per agent", "5")
+    .option("--repo <url>", "Target repo (defaults to git remote origin)")
+    .action(async (count, options) => {
+    const { fleetSpawn } = await import("./commands/pi-fleet.js");
+    await fleetSpawn(parseInt(count), { ...options, rounds: parseInt(options.rounds) });
+});
+piFleet
+    .command("status")
+    .description("Show running agents, tuple counts, health")
+    .action(async () => {
+    const { fleetStatus } = await import("./commands/pi-fleet.js");
+    await fleetStatus();
+});
+piFleet
+    .command("collect [waveId]")
+    .description("Pull tuples from agents, dedup, append to training buffer")
+    .action(async (waveId) => {
+    const { fleetCollect } = await import("./commands/pi-fleet.js");
+    await fleetCollect(waveId);
+});
+piFleet
+    .command("destroy [waveId]")
+    .description("Tear down a wave of agent VMs")
+    .action(async (waveId) => {
+    const { fleetDestroy } = await import("./commands/pi-fleet.js");
+    await fleetDestroy(waveId);
+});
+piFleet
+    .command("logs <agent>")
+    .description("Tail an agent's autoresearch log")
+    .action(async (agent) => {
+    const { fleetLogs } = await import("./commands/pi-fleet.js");
+    await fleetLogs(agent);
+});
+// ============================================================================
+// Kanban
+// ============================================================================
+const kanban = program
+    .command("kanban")
+    .description("Task board — cards flow backlog → in_progress → eval → done");
+kanban
+    .command("ls")
+    .description("Show the board")
+    .option("--json", "JSON output")
+    .option("--column <col>", "Filter by column")
+    .option("--scope <name>", "Filter by service scope")
+    .option("--label <tag>", "Filter by label")
+    .option("--compact", "Compact view")
+    .action(async (options) => {
+    const { kanbanLs } = await import("./commands/kanban.js");
+    await kanbanLs(process.cwd(), options);
+});
+kanban
+    .command("add <title>")
+    .description("Add a card to backlog")
+    .option("--description <desc>", "Card description")
+    .option("--priority <n>", "Priority (higher = first)")
+    .option("--source <src>", "Source: human, agent, setup, verify, findings")
+    .option("--scope <name>", "Service scope (auto-detected from config)")
+    .option("--label <tag...>", "Labels (repeatable)")
+    .action(async (title, options) => {
+    const { kanbanAdd } = await import("./commands/kanban.js");
+    await kanbanAdd(process.cwd(), title, options);
+});
+kanban
+    .command("move <id> <column>")
+    .description("Move card to column (backlog, in_progress, eval, done)")
+    .option("--agent <name>", "Agent performing the move")
+    .action(async (id, column, options) => {
+    const { kanbanMove } = await import("./commands/kanban.js");
+    await kanbanMove(process.cwd(), id, column, options);
+});
+kanban
+    .command("pick")
+    .description("Pick top card from backlog (outputs title for piping)")
+    .option("--agent <name>", "Agent picking the card")
+    .action(async (options) => {
+    const { kanbanPick } = await import("./commands/kanban.js");
+    await kanbanPick(process.cwd(), options);
+});
+kanban
+    .command("done <id>")
+    .description("Mark card done")
+    .option("--agent <name>", "Agent that completed it")
+    .action(async (id, options) => {
+    const { kanbanDone } = await import("./commands/kanban.js");
+    await kanbanDone(process.cwd(), id, options);
+});
+kanban
+    .command("bootstrap")
+    .description("Create kanban labels + optional GitHub Action on the repo")
+    .option("--workflow", "Also install the kanban GitHub Action")
+    .action(async (options) => {
+    const { kanbanBootstrap } = await import("./commands/kanban.js");
+    await kanbanBootstrap(process.cwd(), options);
+});
+// ============================================================================
+// Linear
+// ============================================================================
+const linear = program
+    .command("linear")
+    .description("Sync with Linear — bidirectional issue sync (GitHub ↔ Linear)");
+linear
+    .command("link")
+    .description("Link a Linear project to this workspace")
+    .action(async () => {
+    const { findProjectRoot: fpr } = await import("./utils/jfl-config.js");
+    const root = fpr(process.cwd());
+    if (!root) {
+        console.error(chalk.red("Not in a JFL project. Run jfl init first."));
+        process.exit(1);
+    }
+    const { linearLink } = await import("./commands/linear.js");
+    await linearLink(root);
+});
+linear
+    .command("unlink")
+    .description("Unlink the Linear project")
+    .action(async () => {
+    const { findProjectRoot: fpr } = await import("./utils/jfl-config.js");
+    const root = fpr(process.cwd());
+    if (!root) {
+        console.error(chalk.red("Not in a JFL project."));
+        process.exit(1);
+    }
+    const { linearUnlink } = await import("./commands/linear.js");
+    await linearUnlink(root);
+});
+linear
+    .command("status")
+    .description("Show Linear sync state and mapped issues")
+    .action(async () => {
+    const { findProjectRoot: fpr } = await import("./utils/jfl-config.js");
+    const root = fpr(process.cwd()) ?? process.cwd();
+    const { linearStatus } = await import("./commands/linear.js");
+    await linearStatus(root);
+});
+linear
+    .command("sync")
+    .description("Bidirectional sync: GitHub Issues ↔ Linear")
+    .option("--direction <dir>", "Sync direction: github, linear, or both (default: both)", "both")
+    .option("--dry-run", "Preview changes without applying them")
+    .option("--json", "Output structured JSON (for CI and agents)")
+    .action(async (options) => {
+    const { findProjectRoot: fpr } = await import("./utils/jfl-config.js");
+    const root = fpr(process.cwd());
+    if (!root) {
+        console.error(chalk.red("Not in a JFL project."));
+        process.exit(1);
+    }
+    const { linearSync } = await import("./commands/linear.js");
+    await linearSync(root, { direction: options.direction, dryRun: options.dryRun, json: options.json });
+});
+linear
+    .command("bootstrap")
+    .description("Deploy GitHub Actions sync workflow + set secrets (one-time setup)")
+    .action(async () => {
+    const { findProjectRoot: fpr } = await import("./utils/jfl-config.js");
+    const root = fpr(process.cwd());
+    if (!root) {
+        console.error(chalk.red("Not in a JFL project."));
+        process.exit(1);
+    }
+    const { linearBootstrap } = await import("./commands/linear.js");
+    await linearBootstrap(root);
+});
+// Parse and run
+if (TENET_DEBUG) {
+    console.error(`[timing] before parse: ${Date.now() - globalThis.__jfl_start}ms`);
+}
+program.parse();
+// Library exports
+export * from "./lib/domain/index.js";
+export * from "./lib/connectors/index.js";
+//# sourceMappingURL=index.js.map