@10et/cli 1.0.0

package/dist/commands/setup.js

@@ -0,0 +1,727 @@
+/**
+ * @purpose CLI command for auto-creating RL agents from project context — analyzes journals, recommends agents, generates configs
+ */
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { analyzeContext } from "../lib/setup/context-analyzer.js";
+import { recommendAgents, writeAgentConfigs } from "../lib/setup/agent-generator.js";
+import { generateDomain, writeDomain } from "../lib/setup/domain-generator.js";
+import { extractSystemModel, writeSpec } from "../lib/setup/spec-generator.js";
+import { writeViolationAgents } from "../lib/setup/violation-agent-generator.js";
+import { generateRuntimeRules, generateRulesFromViolations, generateViolationTrainingTuples, writeRuntimeRules, writeViolationTuples } from "../lib/setup/invariant-bridge.js";
+import { extractJournalInsights, getSmartRecommendations, formatInsightsSummary } from "../lib/setup/smart-recommender.js";
+import { auditDocs } from "../lib/setup/doc-auditor.js";
+import { AdvancedSetup } from "../lib/advanced-setup.js";
+import { isStarterIntelligenceNeeded, applyStarterIntelligence } from "../lib/setup/starter-intelligence.js";
+function findProjectRoot() {
+    let dir = process.cwd();
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, ".jfl", "config.json")))
+            return dir;
+        if (existsSync(join(dir, ".jfl")))
+            return dir;
+        dir = dirname(dir);
+    }
+    return process.cwd();
+}
+/**
+ * Check if user is ready for advanced setup based on progressive disclosure criteria
+ */
+async function checkProgressiveDisclosureReadiness(tenentDir) {
+    try {
+        const engagementPath = join(tenentDir, 'engagement.json');
+        if (!existsSync(engagementPath))
+            return false;
+        const engagement = JSON.parse(readFileSync(engagementPath, 'utf8'));
+        const daysSinceInstall = Math.floor((Date.now() - new Date(engagement.installDate).getTime()) / (1000 * 60 * 60 * 24));
+        const isEngaged = engagement.positiveSignals.length > engagement.confusionSignals.length;
+        // Ready for advanced setup if:
+        // - At least 7 days since install AND engaged
+        // - OR at least 14 days regardless (give them the option)
+        // - OR they have significant usage (many sessions)
+        return (daysSinceInstall >= 7 && isEngaged) ||
+            daysSinceInstall >= 14 ||
+            engagement.sessionsCount >= 10;
+    }
+    catch (error) {
+        // If we can't read engagement data, assume not ready
+        return false;
+    }
+}
+export async function setupCommand(options) {
+    const projectRoot = findProjectRoot();
+    // Progressive disclosure: .tenet dir with engagement data enables advanced features
+    // But NEVER gate the basic setup — agents should work from day 1
+    const tenentDir = join(projectRoot, '.tenet');
+    const hasAdvancedFeatures = existsSync(tenentDir) && await checkProgressiveDisclosureReadiness(tenentDir);
+    if (hasAdvancedFeatures && !options.force) {
+        console.log();
+        console.log(chalk.bold.cyan('🚀 Enhanced Setup - Personalized RL Agents'));
+        console.log(chalk.gray('   Based on your development patterns and usage history'));
+        console.log();
+        // Run the advanced personalized setup, then fall through to validation
+        const advancedSetup = new AdvancedSetup(projectRoot);
+        await advancedSetup.run({
+            includeVerification: options.smart,
+            includeRLAgents: true,
+            includeCIPipeline: options.smart,
+            includeMonitoring: true
+        });
+        // Fall through to eval validation below instead of returning
+    }
+    // No .jfl directory — create it. Don't tell user to go away and come back.
+    if (!existsSync(join(projectRoot, '.jfl'))) {
+        const { mkdirSync } = await import("fs");
+        mkdirSync(join(projectRoot, '.jfl'), { recursive: true });
+        mkdirSync(join(projectRoot, '.jfl', 'journal'), { recursive: true });
+        mkdirSync(join(projectRoot, '.jfl', 'agents'), { recursive: true });
+        console.log(chalk.gray("\n  Created .jfl directory"));
+    }
+    // Fast path: generate agents from violations JSON (piped from `jfl verify --json`)
+    if (options.fromViolations) {
+        console.log(chalk.bold("\n  JFL Setup — Generate Agents from Violations"));
+        console.log(chalk.gray("  ─".repeat(30)));
+        // Read violations from stdin or last verify run
+        const violationsPath = join(projectRoot, ".jfl", "specs", "violations.json");
+        let violations = [];
+        if (existsSync(violationsPath)) {
+            const data = JSON.parse(readFileSync(violationsPath, "utf-8"));
+            violations = data.specs?.flatMap((s) => s.violations || []) || [];
+        }
+        else {
+            console.log(chalk.yellow("\n  No violations file found."));
+            console.log(chalk.gray("  Run: jfl verify --json"));
+            console.log(chalk.gray("  Then: jfl setup --from-violations\n"));
+            return;
+        }
+        if (violations.length === 0) {
+            console.log(chalk.green("\n  No violations found — system design is formally correct. ✨\n"));
+            return;
+        }
+        console.log(chalk.yellow(`\n  Found ${violations.length} violation(s):`));
+        for (const v of violations) {
+            console.log(chalk.yellow(`    - ${v.invariant} (${v.trace?.length || 0} step trace)`));
+        }
+        if (options.dryRun) {
+            console.log(chalk.yellow("\n  Dry run — no agents written.\n"));
+            return;
+        }
+        const written = writeViolationAgents(projectRoot, violations);
+        console.log(chalk.green(`\n  Created ${written.length} agent(s): ${written.join(", ")}`));
+        console.log(chalk.gray("  Each agent has a TOML config + eval script.\n"));
+        console.log(chalk.bold("  Next: jfl peter daily  (agents will target these violations)\n"));
+        return;
+    }
+    console.log(chalk.bold("\n  JFL Setup — Auto-configure RL Agents"));
+    console.log(chalk.gray("  ─".repeat(30)));
+    // Analyze context
+    console.log(chalk.gray("\n  Analyzing project context..."));
+    const ctx = analyzeContext(projectRoot);
+    console.log(`    Journal entries:  ${ctx.journalCount}`);
+    console.log(`    Sessions:         ${ctx.sessionCount}`);
+    console.log(`    Knowledge docs:   ${ctx.hasKnowledge ? chalk.green("found") : chalk.yellow("missing")}`);
+    console.log(`    Product repo:     ${ctx.hasProductRepo ? chalk.green("found") : chalk.yellow("missing")}`);
+    console.log(`    Existing agents:  ${ctx.agents.length > 0 ? ctx.agents.join(", ") : "none"}`);
+    console.log(`    Metric categories:${ctx.metricCategories.length > 0 ? " " + ctx.metricCategories.join(", ") : " none detected"}`);
+    console.log(`    File hotspots:    ${ctx.topFilePatterns.length > 0 ? ctx.topFilePatterns.join(", ") : "none"}`);
+    console.log(`    Readiness:        ${ctx.readinessScore}%`);
+    // Check readiness — apply starter intelligence if cold start
+    if (ctx.readinessScore < 50) {
+        if (isStarterIntelligenceNeeded(projectRoot)) {
+            const configPath = join(projectRoot, ".jfl", "config.json");
+            let projectName = "my-project";
+            if (existsSync(configPath)) {
+                try {
+                    projectName = JSON.parse(readFileSync(configPath, "utf-8")).name || projectName;
+                }
+                catch { }
+            }
+            console.log(chalk.cyan("\n  🧠 Cold start detected — applying starter intelligence..."));
+            const starterResult = applyStarterIntelligence(projectRoot, projectName);
+            console.log(chalk.green(`    Seed journal:   ${starterResult.journalEntries} entries`));
+            console.log(chalk.green(`    Eval scripts:   ${starterResult.evalScripts} created`));
+            console.log(chalk.green(`    Default agents: ${starterResult.agents} configured`));
+            console.log(chalk.green(`    Flows:          ${starterResult.flows ? "ready" : "will generate"}`));
+            console.log(chalk.green(`    PolicyHead:     ${starterResult.checkpoint ? "checkpoint found" : "metadata created (download later)"}`));
+            console.log(chalk.gray("    Your project now has baseline intelligence. It gets smarter as you work."));
+            // Re-analyze with starter content
+            const updatedCtx = analyzeContext(projectRoot);
+            Object.assign(ctx, updatedCtx);
+            console.log(chalk.gray(`    Updated readiness: ${ctx.readinessScore}%`));
+        }
+        else if (!options.force) {
+            console.log(chalk.yellow("\n  Low readiness but some content exists. Issues:"));
+            for (const issue of ctx.issues) {
+                console.log(chalk.yellow(`    - ${issue}`));
+            }
+            console.log(chalk.gray("\n  Use --force to proceed anyway, or keep working to build context.\n"));
+            return;
+        }
+    }
+    // Phase 1: System Model — extract and verify with TLA+
+    console.log(chalk.bold("\n  Phase 1: System Model"));
+    const model = extractSystemModel(projectRoot);
+    console.log(`    Services:      ${model.services.length} detected`);
+    console.log(`    State vars:    ${model.stateVariables.length}`);
+    console.log(`    Actions:       ${model.actions.length}`);
+    console.log(`    Invariants:    ${model.invariants.length}`);
+    console.log(`    Concurrency:   ${model.concurrencyPatterns.length} pattern(s)`);
+    if (model.concurrencyPatterns.length > 0) {
+        console.log(chalk.yellow("\n  ⚠ Concurrency patterns detected:"));
+        for (const p of model.concurrencyPatterns) {
+            console.log(chalk.yellow(`    - ${p.type}: ${p.description}`));
+        }
+    }
+    if (!options.dryRun && (model.services.length > 0 || model.stateVariables.length > 0)) {
+        const { specPath, cfgPath, planningSpecPath, planningCfgPath } = writeSpec(projectRoot, model);
+        console.log(chalk.green(`    TLA+ spec:     ${specPath}`));
+        console.log(chalk.green(`    TLC config:    ${cfgPath}`));
+        if (planningSpecPath) {
+            console.log(chalk.green(`    Planning spec: ${planningSpecPath}`));
+            console.log(chalk.gray(`    Models: PH → DM → IM → Execute (${model.planningLoop?.tools.length || 12} tools, ${model.planningLoop?.invariantGates.length || 0} gates)`));
+        }
+        console.log(chalk.gray(`    Run: jfl verify  (to check invariants with TLC)`));
+        // Generate runtime invariant rules from TLA+ model + TLC violations
+        const modelRules = generateRuntimeRules(model);
+        const violationRules = generateRulesFromViolations(projectRoot);
+        const allRules = [...modelRules, ...violationRules];
+        const rulesPath = writeRuntimeRules(projectRoot, allRules);
+        console.log(chalk.green(`    IM rules:      ${rulesPath} (${allRules.length} rules: ${modelRules.length} from model, ${violationRules.length} from violations)`));
+        // Mine negative training tuples from TLC violations
+        const tuples = generateViolationTrainingTuples(projectRoot);
+        if (tuples.length > 0) {
+            const written = writeViolationTuples(projectRoot, tuples);
+            console.log(chalk.green(`    Training:      ${written} negative tuples from TLC violations → training buffer`));
+        }
+    }
+    // Phase 2: Deep Journal Analysis
+    console.log(chalk.bold("\n  Phase 2: Journal Analysis"));
+    const insight = extractJournalInsights(projectRoot);
+    console.log(formatInsightsSummary(insight));
+    // Phase 3: Agent Recommendations
+    console.log(chalk.bold("\n  Phase 3: Agent Recommendations"));
+    if (options.smart || process.env.STRATUS_API_KEY) {
+        // Smart mode: use Stratus reasoning
+        console.log(chalk.gray("    Using Stratus reasoning model..."));
+        const smartRecs = await getSmartRecommendations(projectRoot, ctx.agents);
+        // Auto-import recommendations as GitHub Issues
+        if (smartRecs.length > 0) {
+            try {
+                const { GitHubKanban } = await import("../lib/kanban-github.js");
+                const kb = new GitHubKanban(projectRoot);
+                const existing = (await kb.getCards()).map(c => c.title);
+                const newRecs = smartRecs.filter(r => !existing.includes(r.name));
+                let created = 0;
+                for (const r of newRecs) {
+                    kb.create({
+                        title: r.name,
+                        description: `${r.rationale}\n\nConfidence: ${r.confidence}\nAuthored-by: stratus (jfl-setup)`,
+                        source: "setup",
+                        priority: r.confidence > 0.7 ? 6 : 3,
+                    });
+                    created++;
+                }
+                if (created > 0)
+                    console.log(chalk.gray(`    📋 Issues: created ${created} recommendations`));
+            }
+            catch { }
+        }
+        if (smartRecs.length === 0) {
+            console.log(chalk.green("\n  No new agents recommended.\n"));
+        }
+        else {
+            console.log(chalk.bold("\n  Recommended Agents (AI-powered):"));
+            for (const rec of smartRecs) {
+                const conf = chalk.gray(`[${(rec.confidence * 100).toFixed(0)}%]`);
+                console.log(`    ${chalk.cyan(rec.name)} ${conf} ${chalk.gray(`P${rec.priority}`)}`);
+                console.log(`      Metric:    ${rec.metric} (${rec.direction})`);
+                console.log(`      Scope:     ${rec.scope}`);
+                console.log(`      Rationale: ${chalk.italic(rec.rationale)}`);
+                console.log(`      Files:     ${rec.filePatterns.join(", ")}`);
+                console.log(`      Eval:      ${chalk.gray(rec.evalHint)}`);
+            }
+        }
+        if (!options.dryRun) {
+            // Write smart recommendations as agent TOMLs
+            const { generateAgentToml } = await import("../lib/setup/agent-generator.js");
+            const { writeFileSync, mkdirSync } = await import("fs");
+            const agentsDir = join(projectRoot, ".jfl", "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            const written = [];
+            for (const rec of smartRecs) {
+                const tomlPath = join(agentsDir, `${rec.name}.toml`);
+                if (!existsSync(tomlPath)) {
+                    const toml = `# ${rec.name} — AI-recommended agent
+# ${rec.rationale}
+
+[agent]
+name = "${rec.name}"
+scope = "${rec.scope}"
+metric = "${rec.metric}"
+direction = "${rec.direction}"
+time_budget_seconds = 600
+rounds = 10
+
+[eval]
+script = "eval/${rec.name}.sh"
+# Eval hint: ${rec.evalHint}
+
+[constraints]
+files_in_scope = [${rec.filePatterns.map(p => `"${p}"`).join(", ")}]
+max_file_changes = 5
+
+[training]
+version = 2
+checkpoint_path = ".jfl/checkpoints/best_policy_head.pt"
+metadata_path = ".jfl/checkpoints/policy-head-v2.json"
+num_tools = 12
+
+[policy]
+embedding_model = "stratus-x1ac-base"
+exploration_rate = 0.15
+decay_per_round = 0.01
+min_exploration = 0.05
+
+[context_scope]
+produces = ["${rec.scope}:improved"]
+consumes = ["eval:scored"]
+
+[meta]
+source = "stratus_recommendation"
+confidence = ${rec.confidence}
+priority = ${rec.priority}
+generated_at = "${new Date().toISOString()}"
+`;
+                    writeFileSync(tomlPath, toml);
+                    written.push(rec.name);
+                }
+                // Generate eval script for this agent
+                const { generateEvalScript } = await import("../lib/setup/agent-generator.js");
+                const evalDir = join(projectRoot, ".jfl", "eval");
+                const fixturesDir = join(evalDir, "fixtures");
+                mkdirSync(evalDir, { recursive: true });
+                mkdirSync(fixturesDir, { recursive: true });
+                const evalPath = join(evalDir, `${rec.name}.sh`);
+                if (!existsSync(evalPath)) {
+                    const agentRec = { name: rec.name, scope: rec.scope, metric: rec.metric, direction: rec.direction, description: rec.rationale, filePatterns: rec.filePatterns, evalScript: `eval/${rec.name}.sh` };
+                    const script = generateEvalScript(agentRec, projectRoot);
+                    writeFileSync(evalPath, script, { mode: 0o755 });
+                }
+                const fixturePath = join(fixturesDir, `${rec.name}.jsonl`);
+                if (!existsSync(fixturePath)) {
+                    writeFileSync(fixturePath, "{}\n");
+                }
+            }
+            // Always create world-model agent — core RL agent for v2 pipeline
+            const { generateWorldModelToml, generateEvalScript: genEvalScript } = await import("../lib/setup/agent-generator.js");
+            const wmPath = join(agentsDir, "world-model.toml");
+            if (!existsSync(wmPath)) {
+                writeFileSync(wmPath, generateWorldModelToml());
+                written.push("world-model");
+                // world-model eval script
+                const smartEvalDir = join(projectRoot, ".jfl", "eval");
+                mkdirSync(smartEvalDir, { recursive: true });
+                const wmEvalPath = join(smartEvalDir, "world-model.sh");
+                if (!existsSync(wmEvalPath)) {
+                    const agentRec = { name: "world-model", scope: "dynamics", metric: "prediction_accuracy", direction: "maximize", description: "Core RL agent", filePatterns: ["src/**"], evalScript: "eval/world-model.sh" };
+                    const script = genEvalScript(agentRec, projectRoot);
+                    writeFileSync(wmEvalPath, script, { mode: 0o755 });
+                }
+            }
+            // Create checkpoints directory for v2 pipeline
+            const checkpointsDir = join(projectRoot, ".jfl", "checkpoints");
+            mkdirSync(checkpointsDir, { recursive: true });
+            if (written.length > 0) {
+                console.log(chalk.green(`\n  Created ${written.length} agent config(s) with eval scripts: ${written.join(", ")}`));
+            }
+        } // end if (!options.dryRun)
+    }
+    else {
+        // Fallback: template-based recommendations
+        console.log(chalk.gray("    Using template matching (set STRATUS_API_KEY for AI-powered recommendations)"));
+        const recommendations = recommendAgents(ctx);
+        if (recommendations.length === 0) {
+            console.log(chalk.green("\n  All recommended agents already configured.\n"));
+        }
+        else {
+            console.log(chalk.bold("\n  Recommended Agents:"));
+            for (const rec of recommendations) {
+                console.log(`    ${chalk.cyan(rec.name)}`);
+                console.log(`      Metric:   ${rec.metric} (${rec.direction})`);
+                console.log(`      Scope:    ${rec.scope}`);
+                console.log(`      Files:    ${rec.filePatterns.join(", ")}`);
+            }
+            // Auto-import template recommendations as GitHub Issues
+            try {
+                const { GitHubKanban } = await import("../lib/kanban-github.js");
+                const kb = new GitHubKanban(projectRoot);
+                const existing = (await kb.getCards()).map(c => c.title);
+                const newRecs = recommendations.filter(r => !existing.includes(r.name));
+                let created = 0;
+                for (const r of newRecs) {
+                    kb.create({
+                        title: r.name,
+                        description: `${r.metric} (${r.direction}) — scope: ${r.scope}\n\nAuthored-by: template (jfl-setup)`,
+                        source: "setup",
+                        priority: 5,
+                    });
+                    created++;
+                }
+                if (created > 0)
+                    console.log(chalk.gray(`    📋 Issues: created ${created} recommendations`));
+            }
+            catch { }
+            if (!options.dryRun) {
+                const written = writeAgentConfigs(projectRoot, recommendations);
+                if (written.length > 0) {
+                    console.log(chalk.green(`\n  Created ${written.length} agent config(s): ${written.join(", ")}`));
+                }
+            }
+        }
+        if (options.dryRun) {
+            console.log(chalk.yellow("\n  Dry run — no files written.\n"));
+            return;
+        }
+    }
+    // Generate domain.json
+    const domain = generateDomain(projectRoot, ctx);
+    const domainPath = writeDomain(projectRoot, domain);
+    console.log(chalk.green(`  Generated domain.json: ${domainPath}`));
+    // Phase 3b: Validate evals have gradient (Karpathy requirement)
+    // Run each agent's eval script and check score < 0.90. If ceiling'd, warn.
+    try {
+        console.log(chalk.bold("\n  Phase 3b: Eval Validation"));
+        console.log(chalk.gray("    Running each eval to verify gradient exists...\n"));
+        const { loadAllAgentConfigs: loadConfigs } = await import("../lib/agent-config.js");
+        const { spawnSync: spawnEval } = await import("child_process");
+        const agentConfigs = loadConfigs(projectRoot);
+        const CEILING_THRESHOLD = 0.90;
+        let ceilingCount = 0;
+        for (const agent of agentConfigs) {
+            const evalScriptPath = join(projectRoot, agent.eval.script);
+            if (!existsSync(evalScriptPath)) {
+                console.log(chalk.yellow(`    ${agent.name}: ⚠ eval not found (${agent.eval.script})`));
+                continue;
+            }
+            try {
+                const isShell = evalScriptPath.endsWith(".sh");
+                const result = isShell
+                    ? spawnEval("bash", [evalScriptPath], {
+                        cwd: projectRoot,
+                        timeout: 120000,
+                        stdio: ["ignore", "pipe", "pipe"],
+                        env: { ...process.env, JFL_PROJECT_ROOT: projectRoot },
+                    })
+                    : spawnEval("npx", ["tsx", "-e", `
+            import('${evalScriptPath}').then(m => {
+              const r = m.evaluate ? m.evaluate() : m.default?.();
+              console.log(JSON.stringify({ metric: r }));
+            });
+          `], {
+                        cwd: projectRoot,
+                        timeout: 120000,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                const stdout = result.stdout?.toString().trim() || "";
+                const lastLine = stdout.split("\n").pop() || "";
+                // Parse score from JSON output or raw number
+                let score = 0;
+                try {
+                    const parsed = JSON.parse(lastLine);
+                    // Find the metric field matching agent.metric, or take first numeric value
+                    score = parsed[agent.metric] ?? parsed.metric ?? Object.values(parsed).find(v => typeof v === "number") ?? 0;
+                }
+                catch {
+                    score = parseFloat(lastLine) || 0;
+                }
+                const scoreStr = score.toFixed(4);
+                // For "minimize" agents (e.g. p90_ms), any positive score means there's room.
+                // For "maximize" agents, score < 0.90 means gradient exists.
+                // Handle non-normalized scores (ms, percentages) — ceiling only applies to 0-1 scores.
+                const isMinimize = agent.direction === "minimize";
+                const isNormalized = score >= 0 && score <= 1.0;
+                const isCeiling = !isMinimize && isNormalized && score >= CEILING_THRESHOLD;
+                if (isCeiling) {
+                    ceilingCount++;
+                    console.log(chalk.yellow(`    ${agent.name}: ${scoreStr} ⚠ CEILING — score ≥ ${CEILING_THRESHOLD}, agent can't improve this`));
+                    console.log(chalk.gray(`      Consider: harder eval dimensions, or archive this agent`));
+                }
+                else if (score <= 0 && !isMinimize) {
+                    console.log(chalk.red(`    ${agent.name}: ${scoreStr} ✗ BROKEN — eval returned 0 or error`));
+                    console.log(chalk.gray(`      Check: ${agent.eval.script} — does it run? does it find the right directory?`));
+                }
+                else if (isMinimize) {
+                    console.log(chalk.green(`    ${agent.name}: ${scoreStr} ✓ has gradient (${agent.direction}: lower is better)`));
+                }
+                else {
+                    console.log(chalk.green(`    ${agent.name}: ${scoreStr} ✓ has gradient (room to improve)`));
+                }
+            }
+            catch (err) {
+                console.log(chalk.red(`    ${agent.name}: ✗ eval failed — ${err.message?.slice(0, 80)}`));
+            }
+        }
+        if (ceilingCount > 0 && ceilingCount === agentConfigs.length) {
+            console.log(chalk.yellow(`\n    ⚠ ALL agents are at ceiling. The RL loop cannot improve anything.`));
+            console.log(chalk.gray(`    Add harder eval dimensions or create new agents targeting lower-scoring metrics.`));
+        }
+        else if (agentConfigs.length === 0) {
+            console.log(chalk.yellow(`    No agents configured. Starter intelligence should have created defaults.`));
+        }
+        else {
+            const gradientCount = agentConfigs.length - ceilingCount;
+            console.log(chalk.green(`\n    ${gradientCount}/${agentConfigs.length} agents have gradient — RL loop can improve these.`));
+        }
+    }
+    catch (evalErr) {
+        console.log(chalk.yellow(`\n  Phase 3b skipped: ${evalErr.message}`));
+    }
+    // Phase 4: Doc Audit
+    console.log(chalk.bold("\n  Phase 4: Doc Health"));
+    const audit = auditDocs(projectRoot, insight);
+    console.log(`    Total:         ${audit.totalDocs} docs (${audit.totalLines} lines, ${audit.totalTokens} tokens, ${(audit.totalBytes / 1024).toFixed(0)}KB)`);
+    console.log(`    Framework:     ${audit.frameworkDocs.length} docs (${audit.frameworkDocs.reduce((s, d) => s + d.tokenEstimate, 0)} tokens)`);
+    console.log(`    Customer:      ${audit.customerDocs.length} docs (${audit.customerDocs.reduce((s, d) => s + d.tokenEstimate, 0)} tokens)`);
+    console.log(`    Unreferenced:  ${audit.unreferencedDocs.length} docs (${audit.unreferencedDocs.reduce((s, d) => s + d.tokenEstimate, 0)} tokens wasted)`);
+    console.log(`    Bloated:       ${audit.bloatedDocs.length}`);
+    if (audit.unreferencedDocs.length > 0) {
+        const wastedTokens = audit.unreferencedDocs.reduce((s, d) => s + d.tokenEstimate, 0);
+        console.log(chalk.yellow(`\n    ⚠ ${wastedTokens} tokens/session on docs with 0 journal references`));
+        for (const doc of audit.unreferencedDocs.slice(0, 5)) {
+            const origin = doc.origin === "framework" ? chalk.blue("[framework]") : chalk.magenta("[customer]");
+            console.log(chalk.yellow(`      ${origin} ${doc.relativePath} — ${doc.tokenEstimate} tokens, 0 refs`));
+        }
+    }
+    if (audit.bloatedDocs.length > 0) {
+        console.log(chalk.yellow("\n    Bloated docs:"));
+        for (const doc of audit.bloatedDocs.slice(0, 5)) {
+            const origin = doc.origin === "framework" ? chalk.blue("[framework]") : chalk.magenta("[customer]");
+            console.log(chalk.yellow(`      ${origin} ${doc.relativePath} — ${doc.lines} lines, ${doc.sections.length} sections`));
+        }
+    }
+    if (audit.missingDocs.length > 0) {
+        console.log(chalk.yellow("\n    Missing:"));
+        for (const missing of audit.missingDocs) {
+            console.log(chalk.yellow(`      ${missing}`));
+        }
+    }
+    const recIcons = { trim: "✂️", update: "📝", create: "📄", archive: "📦", split: "🔀", merge: "🔗", refresh: "🔄", dedupe: "🔍" };
+    if (audit.recommendations.length > 0) {
+        console.log(chalk.bold("\n    Doc Recommendations:"));
+        for (const rec of audit.recommendations.slice(0, 10)) {
+            const icon = recIcons[rec.type] || "📋";
+            const originTag = rec.origin === "framework" ? chalk.blue("[F]") : rec.origin === "customer" ? chalk.magenta("[C]") : "";
+            console.log(`      ${icon} ${originTag} ${chalk.cyan(rec.type.toUpperCase())} ${rec.target}`);
+            console.log(chalk.gray(`         ${rec.rationale}`));
+            if (rec.estimatedSavings)
+                console.log(chalk.green(`         💰 ${rec.estimatedSavings}`));
+            if (rec.action)
+                console.log(chalk.gray(`         → ${rec.action}`));
+        }
+    }
+    // Save setup report for hub/dashboard consumption
+    const setupReport = {
+        timestamp: new Date().toISOString(),
+        project: projectRoot,
+        context: {
+            journalEntries: ctx.journalCount,
+            sessions: ctx.sessionCount,
+            readiness: ctx.readinessScore,
+            existingAgents: ctx.agents,
+        },
+        systemModel: {
+            services: model.services.length,
+            stateVariables: model.stateVariables.length,
+            actions: model.actions.length,
+            invariants: model.invariants.length,
+            concurrencyPatterns: model.concurrencyPatterns.length,
+        },
+        journalInsights: {
+            revertRate: insight.revertRate,
+            hotspots: insight.fileHotspots.slice(0, 10),
+            evalTrends: insight.evalHistory,
+            topReverts: insight.topReverts,
+        },
+        docHealth: {
+            totalDocs: audit.totalDocs,
+            totalLines: audit.totalLines,
+            totalBytes: audit.totalBytes,
+            totalTokens: audit.totalTokens,
+            frameworkDocs: audit.frameworkDocs.length,
+            frameworkTokens: audit.frameworkDocs.reduce((s, d) => s + d.tokenEstimate, 0),
+            customerDocs: audit.customerDocs.length,
+            customerTokens: audit.customerDocs.reduce((s, d) => s + d.tokenEstimate, 0),
+            unreferencedDocs: audit.unreferencedDocs.map(d => ({
+                path: d.relativePath, tokens: d.tokenEstimate, origin: d.origin, refs: d.referenceCount,
+            })),
+            staleDocs: audit.staleDocs.map(d => ({ path: d.relativePath, lines: d.lines, staleScore: d.staleScore, origin: d.origin })),
+            bloatedDocs: audit.bloatedDocs.map(d => ({ path: d.relativePath, lines: d.lines, origin: d.origin, sections: d.sections })),
+            missingDocs: audit.missingDocs,
+            recommendations: audit.recommendations,
+        },
+    };
+    const { writeFileSync: writeReport, mkdirSync: mkReport } = await import("fs");
+    const reportDir = join(projectRoot, ".jfl");
+    mkReport(reportDir, { recursive: true });
+    writeReport(join(reportDir, "setup-report.json"), JSON.stringify(setupReport, null, 2));
+    console.log(chalk.green(`\n  Setup report saved: .jfl/setup-report.json`));
+    console.log(chalk.gray("  Hub serves this to the platform dashboard for exec visibility."));
+    // Auto-bootstrap kanban labels on the repo
+    try {
+        const { GitHubKanban } = await import("../lib/kanban-github.js");
+        const kb = new GitHubKanban(projectRoot);
+        const info = kb.getWorkspaceInfo();
+        GitHubKanban.bootstrap(info.repo);
+        // Create scope labels for registered services
+        const services = kb.getRegisteredServices();
+        for (const s of services) {
+            try {
+                const { execSync } = await import("child_process");
+                execSync(`gh label create "scope:${s.name}" --repo ${info.repo} --color 1971C2 --description "Scope: ${s.name}" --force`, {
+                    encoding: "utf-8", timeout: 10000, stdio: "pipe",
+                });
+            }
+            catch { }
+        }
+        console.log(chalk.green(`  Kanban labels bootstrapped on ${info.repo}`));
+    }
+    catch { }
+    // Phase 4b: Self-driving flows
+    const flowsDir = join(projectRoot, ".jfl", "flows");
+    const selfDrivingPath = join(flowsDir, "self-driving.yaml");
+    if (!existsSync(selfDrivingPath)) {
+        const fs = await import("fs");
+        if (!existsSync(flowsDir)) {
+            fs.mkdirSync(flowsDir, { recursive: true });
+        }
+        const { generateSelfDrivingFlows } = await import("../lib/setup/flow-generator.js");
+        const flowContent = generateSelfDrivingFlows();
+        fs.writeFileSync(selfDrivingPath, flowContent);
+        console.log(chalk.green(`    Self-driving flows: ${selfDrivingPath}`));
+        console.log(chalk.gray(`    Issue pickup (30min) + auto-merge + training capture + nightly retrain`));
+    }
+    else {
+        console.log(chalk.gray(`    Self-driving flows: already exists`));
+    }
+    // Phase 5: v2 Training Pipeline Status
+    console.log(chalk.bold("\n  Phase 5: v2 Training Pipeline"));
+    const v2CheckpointPath = join(projectRoot, ".jfl", "checkpoints", "best_policy_head.pt");
+    const v2MetaPath = join(projectRoot, ".jfl", "checkpoints", "policy-head-v2.json");
+    const v1WeightsPath = join(projectRoot, ".jfl", "policy-weights.json");
+    const bufferPath = join(projectRoot, ".jfl", "training-buffer.jsonl");
+    const v2DataDir = join(projectRoot, ".jfl", "v2-data");
+    const benchmarkPath = join(projectRoot, ".jfl", "checkpoints", "benchmark-results.json");
+    const hasV2 = existsSync(v2CheckpointPath) && existsSync(v2MetaPath);
+    const hasV1 = existsSync(v1WeightsPath);
+    const hasBuffer = existsSync(bufferPath);
+    if (hasV2) {
+        try {
+            const v2Meta = JSON.parse(readFileSync(v2MetaPath, "utf-8"));
+            console.log(chalk.green(`    PolicyHead v2:  ✅ loaded`));
+            console.log(chalk.gray(`      Architecture: ${v2Meta.architecture} (${(v2Meta.parameters / 1e6).toFixed(1)}M params)`));
+            console.log(chalk.gray(`      Trained on:   ${v2Meta.trained_on} examples`));
+            console.log(chalk.gray(`      Val accuracy: ${(v2Meta.val_accuracy * 100).toFixed(1)}%`));
+            console.log(chalk.gray(`      Tools:        ${v2Meta.num_tools} (${Object.keys(v2Meta.tool_to_index || {}).join(", ")})`));
+            console.log(chalk.gray(`      Trained at:   ${v2Meta.trained_at}`));
+            if (existsSync(benchmarkPath)) {
+                try {
+                    const bench = JSON.parse(readFileSync(benchmarkPath, "utf-8"));
+                    console.log(chalk.gray(`      Benchmark:    ${(bench.top1_accuracy * 100).toFixed(1)}% top-1, ${(bench.top3_accuracy * 100).toFixed(1)}% top-3`));
+                }
+                catch { }
+            }
+        }
+        catch {
+            console.log(chalk.yellow(`    PolicyHead v2:  ⚠️ metadata unreadable`));
+        }
+    }
+    else if (hasV1) {
+        try {
+            const v1 = JSON.parse(readFileSync(v1WeightsPath, "utf-8"));
+            console.log(chalk.yellow(`    PolicyHead v1:  ⚠️ legacy MLP (trained on ${v1.trained_on} entries)`));
+            console.log(chalk.gray(`      Upgrade: jfl train transform && jfl train policy-head`));
+        }
+        catch {
+            console.log(chalk.yellow(`    PolicyHead v1:  ⚠️ weights unreadable`));
+        }
+    }
+    else {
+        console.log(chalk.red(`    PolicyHead:     ❌ not trained yet`));
+    }
+    if (hasBuffer) {
+        try {
+            const bufferContent = readFileSync(bufferPath, "utf-8");
+            const lineCount = bufferContent.split("\n").filter(l => l.trim()).length;
+            console.log(chalk.gray(`    Training buffer: ${lineCount} entries`));
+        }
+        catch { }
+    }
+    else {
+        console.log(chalk.yellow(`    Training buffer: empty — run experiments to generate data`));
+    }
+    if (existsSync(v2DataDir)) {
+        const splits = ["train", "val", "test", "benchmark"].filter(s => existsSync(join(v2DataDir, `${s}.jsonl`)));
+        console.log(chalk.gray(`    v2 data splits:  ${splits.join(", ") || "none"}`));
+        if (existsSync(join(v2DataDir, "embeddings_cache.npz"))) {
+            console.log(chalk.gray(`    Embedding cache: ✅ precomputed`));
+        }
+    }
+    // Summary — give correct v2 pipeline steps
+    console.log(chalk.bold("\n  Next steps:"));
+    if (!hasBuffer || !hasV2) {
+        // Fresh project or no v2 yet
+        if (!hasBuffer) {
+            console.log(chalk.gray("    1. Run experiments to generate training data:"));
+            console.log(chalk.gray("       jfl peter experiment           (generate training tuples)"));
+        }
+        console.log(chalk.gray(`    ${!hasBuffer ? "2" : "1"}. Run the v2 training pipeline:`));
+        console.log(chalk.gray("       jfl train transform            (buffer → v2 JSONL splits)"));
+        console.log(chalk.gray("       jfl train policy-head --force  (precompute embeddings + train transformer)"));
+        console.log(chalk.gray("       jfl train eval                 (per-tool accuracy report)"));
+        console.log(chalk.gray("       jfl train benchmark            (33 scenario synthetic eval)"));
+    }
+    else {
+        // v2 exists — show improvement steps
+        console.log(chalk.gray("    RL pipeline is active. To retrain:"));
+        console.log(chalk.gray("       jfl train transform && jfl train policy-head --force"));
+        console.log(chalk.gray("       jfl train eval && jfl train benchmark"));
+        console.log(chalk.gray("    To run autonomous experiments:"));
+        console.log(chalk.gray("       jfl peter experiment           (single experiment)"));
+        console.log(chalk.gray("       jfl peter autoresearch -n 5    (5-round autonomous loop)"));
+    }
+    if (model.services.length > 0) {
+        console.log(chalk.gray("    Formal verification:"));
+        console.log(chalk.gray("       jfl verify                     (check TLA+ invariants)"));
+    }
+    // ResourceOptimizer telemetry stats
+    try {
+        const { getResourceOptimizerStats } = await import("../lib/resource-optimizer-middleware.js");
+        const roStats = getResourceOptimizerStats(projectRoot);
+        console.log(chalk.bold("  ResourceOptimizer"));
+        console.log(chalk.gray(`    Transitions: ${roStats.transitions} collected`));
+        if (roStats.trainingReady) {
+            console.log(chalk.green(`    Training:    Ready (≥5K tuples) — run GRU training`));
+        }
+        else {
+            console.log(chalk.gray(`    Training:    ${roStats.transitions}/5000 tuples for GRU training`));
+        }
+    }
+    catch {
+        // RO middleware not available
+    }
+    console.log();
+}
+export function registerSetupCommand(parent) {
+    parent
+        .command("setup")
+        .description("Auto-configure RL agents from project context")
+        .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) => {
+        await setupCommand(options);
+    });
+}
+//# sourceMappingURL=setup.js.map