project-iris 0.0.1

package/dist/commands/ask.js

@@ -0,0 +1,259 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import path from "path";
+import fs from "fs";
+import { repoRoot } from "../lib.js";
+import { resolveArtifactPath, getIrisDebugInfo } from "../iris/resolver.js";
+import { loadEffectiveRoutes } from "../iris/routes.js";
+import { routeIntent } from "../iris/router.js";
+import { checkArtifact } from "../iris/artifact-checker.js";
+import { loadPolicy } from "../iris/policy.js";
+import { loadState } from "../iris/state.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+import { createConnector } from "../bridge/connector-factory.js";
+import { executeIntentInception } from "../workflows/intent-inception.js";
+import { executeBoltPlan } from "../workflows/bolt-plan.js";
+import { createRun } from "../iris/run-state.js";
+import { migrateLegacyDraft } from "../iris/interactive/intent-interview.js";
+import { checkInteractiveMode } from "../iris/interactive/env.js";
+import { resolveActiveFramework } from "../iris/framework-context.js";
+import { loadEffectiveInterviewConfig } from "../iris/interview/config.js";
+export const askCommand = new Command("ask")
+    .description("Route intent to an agent and generate context pack")
+    .argument("[intent...]", "Natural language request intent")
+    .option("--agent <agent>", "Override target agent")
+    .option("--phase <phase>", "Override target phase")
+    .option("--out <path>", "Explicit output path for pack")
+    .option("--stdout", "Print pack to stdout", false)
+    .option("--json", "Output structured JSON result", false)
+    .option("--dry-run", "Simulate routing without writing files", false)
+    .option("--debug", "Show IRIS authority and artifact resolution info", false)
+    .option("--non-interactive", "Skip interactive interview", false)
+    .option("--force-interactive", "Force interactive mode even in CI/Pipe", false)
+    .option("--save-draft-only", "Run interview and save draft, but do not execute workflow", false)
+    .action(async (intentParts, opts) => {
+    const root = repoRoot();
+    const { resolution } = await resolveActiveFramework(root);
+    if (opts.debug) {
+        const debug = getIrisDebugInfo(root);
+        console.log(kleur.bold("IRIS Authority Debug"));
+        console.log(`- Repo Root:   ${debug.repoRoot}`);
+        console.log(`- IRIS Root:   ${debug.irisRoot}`);
+        console.log(`- Source:      ${kleur.magenta(debug.source.toUpperCase())}`);
+        console.log(`- Bundled Path:${debug.bundledPath}`);
+        console.log("");
+        // Show artifact validation details
+        const policy = loadPolicy(root);
+        const state = loadState();
+        const phase = state.phase.current;
+        const requirements = policy.phases[phase]?.requires || [];
+        if (requirements.length > 0) {
+            console.log(kleur.bold("Required Artifacts Debug"));
+            for (const req of requirements) {
+                const check = checkArtifact(root, req.path, req.type);
+                console.log(`\n- Artifact: ${req.type}`);
+                console.log(`  Raw:        ${JSON.stringify(req.path)}`);
+                console.log(`  Normalized: ${check.normalized}`);
+                console.log(`  Absolute:   ${check.absolutePath}`);
+                console.log(`  Inferred:   ${check.inferredKind}`);
+                console.log(`  Exists:     ${check.exists ? kleur.green("YES") : kleur.red("NO")}`);
+                if (check.exists) {
+                    console.log(`  Type:       ${check.isDirectory ? "directory" : check.isFile ? "file" : "unknown"}`);
+                }
+                if (check.hasControlChars) {
+                    console.log(`  ${kleur.yellow("⚠ WARNING: Raw path contains control characters (\\r, \\n, etc.)")}`);
+                }
+            }
+            console.log("");
+        }
+    }
+    // Migration Check
+    const migrated = migrateLegacyDraft(root);
+    if (migrated) {
+        console.log(kleur.dim("Migrated old intent-draft.json to intent-draft.latest.json"));
+    }
+    // 1. Get Intent
+    let intent = intentParts.join(" ");
+    // Environment Check
+    const envCheck = checkInteractiveMode({
+        nonInteractive: opts.nonInteractive,
+        forceInteractive: opts.forceInteractive
+    });
+    if (envCheck.isInteractive) {
+        // 1.5 Load Interview Config
+        // Skipped Legacy Interview - proceeding directly to Ping-Pong Flow
+        // If no intent provided yet, ask for just the one-liner intent
+        if (!intent) {
+            const { initialIntent } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "initialIntent",
+                    message: "What are you trying to build?",
+                    validate: (val) => val.trim().length > 0 || "Please provide a goal."
+                }
+            ]);
+            intent = initialIntent;
+        }
+    }
+    else {
+        // NON-INTERACTIVE MODE
+        if (!opts.nonInteractive && !opts.forceInteractive) {
+            // Warn if we fell back automatically (reason exists)
+            if (envCheck.reason) {
+                console.warn(kleur.yellow(`⚠ Interactive mode disabled: ${envCheck.reason}`));
+                console.warn(kleur.dim("  Use --force-interactive to override if safe."));
+            }
+        }
+        // Fallback input reading
+        if (!intent) {
+            if (process.stdin.isTTY) {
+                console.error(kleur.red("Error: Intent argument required in non-interactive mode."));
+                process.exit(EXIT_CODES.INVALID);
+                return;
+            }
+            else {
+                try {
+                    intent = fs.readFileSync(0, "utf-8").trim();
+                }
+                catch (e) {
+                    // Ignore read error
+                }
+            }
+        }
+    }
+    if (!intent) {
+        console.error(kleur.red("No intent provided."));
+        process.exit(EXIT_CODES.INVALID);
+        return; // TS Guard
+    }
+    // 2. Load Routes
+    let routesConfig;
+    try {
+        const state = loadState();
+        // Load Base or Effective
+        routesConfig = loadEffectiveRoutes(resolution, root, state.active.flow);
+    }
+    catch (e) {
+        if (e.name === "RoutesOverlayMissingError") {
+            console.error(kleur.red(`\n[Policy Error] ${e.message}`));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        if (e.name === "RoutesLoadError") {
+            console.error(kleur.red(`\n[Routes Error] ${e.message}`));
+            if (e.cause)
+                console.error(kleur.gray(e.cause));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        // Fallback for unexpected
+        console.error(kleur.red(`Failed to load routes: ${e.message}`));
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+    // 3. Route
+    const routing = routeIntent(intent, routesConfig);
+    const routeId = routing.route === "default" ? "default" : routing.route.route_id;
+    const source = routing.route !== "default" ? routing.route._source : "default";
+    if (opts.debug) {
+        console.log(kleur.bold(`Matched route_id: ${routeId} ${source ? `(source: ${source})` : ""}`));
+    }
+    // 4. Execution Workflow (Inception + Planning)
+    if (opts.dryRun) {
+        // DRY RUN: Simulate pack generation
+        // We know intent, route, agent.
+        // We can create a Plan object.
+        const plan = {
+            schemaVersion: 1,
+            intent: intent,
+            framework: resolution ? resolution.manifest.id : "legacy-fallback",
+            route: {
+                id: routeId,
+                target: routing.route === "default" ? "default" : routing.route.agent,
+                score: routing.route === "default" ? 0 : routing.route.score
+            },
+            routesSource: {
+                kind: routesConfig?._meta?.sourceKind || (resolution ? 'framework' : 'legacy'),
+                path: routesConfig?._meta?.sourcePath || (resolution ? resolution.files.routes : resolveArtifactPath(root, ".iris/routes.yaml"))
+            },
+            interviewSource: (() => {
+                // We need to load it here for dry run to show source
+                const interviewConfig = loadEffectiveInterviewConfig(resolution);
+                const isFramework = !!(resolution?.files.interview);
+                return {
+                    kind: isFramework ? 'framework' : 'default',
+                    path: isFramework ? resolution?.files.interview : null,
+                    activeFrameworkId: resolution?.manifest.id || null
+                };
+            })(),
+            pack: {
+                planned: true,
+            }
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        else {
+            console.log(kleur.yellow("[Dry Run] Routing Result:"));
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        process.exit(0);
+        return;
+    }
+    console.log(kleur.bold("Starting IRIS Inception & Planning"));
+    console.log(kleur.dim("This process will clarify your intent and generate an implementation plan.\n"));
+    // Initialize Bridge/IDE
+    // Default to 'auto' (In-Process Agent) for seamless UX, ignoring detected IDE unless explicitly bridged?
+    // For now, satisfy user request: "Check user intent first".
+    // We will use "auto" as the default connector.
+    const ideId = "auto";
+    // Create new run
+    const runState = createRun(intent, ideId, "manual");
+    const connector = createConnector(ideId);
+    try {
+        // Phase 1: Inception (Clarify + Artifacts)
+        await executeIntentInception(runState, connector, {
+            gate: "manual",
+            noBridge: false
+        });
+        // Phase 2: Bolt Plan (Stories -> Bolts)
+        await executeBoltPlan(runState, connector, {
+            gate: "manual",
+            noBridge: false
+        });
+        const result = {
+            runId: runState.runId,
+            status: "plan_created",
+            planPath: path.join(root, ".iris/runs", runState.runId, "implementation_plan.md")
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log("");
+            console.log(kleur.bold(kleur.green("✓ Plan Created Successfully!")));
+            console.log("To start execution, run:");
+            console.log(kleur.cyan(`  iris develop --resume ${runState.runId}`));
+            console.log("");
+        }
+    }
+    catch (error) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: error.message }, null, 2));
+        }
+        else {
+            console.error(kleur.red(`\n✗ Planning Failed: ${error.message}`));
+        }
+        process.exit(1);
+    }
+});
+function inferAgentFromPhase(phase) {
+    if (!phase)
+        return "master";
+    const p = phase.toLowerCase();
+    if (p === "inception")
+        return "inception";
+    if (p === "construction")
+        return "construction";
+    if (p === "operations")
+        return "operations";
+    return "master";
+}

package/dist/commands/bridge.js

@@ -0,0 +1,88 @@
+import { Command } from "commander";
+import { startBridgeHelper, INBOX_DIR, OUTBOX_DIR, STATE_DIR } from "../bridge/helper.js";
+import { getSelectedIde } from "../iris/state.js";
+import { createConnector } from "../bridge/connector-factory.js";
+import kleur from "kleur";
+import fs from "fs";
+export const bridgeCommand = new Command("bridge")
+    .description("Bridge helper commands for IDE integration (Advanced)")
+    .configureHelp({ showGlobalOptions: true }); // Hide from main list if possible, or just mark advanced
+// iris bridge run
+bridgeCommand
+    .command("run")
+    .description("Start bridge helper (watches inbox, opens IDE, waits for results)")
+    .option("--poll-interval <ms>", "Polling interval in milliseconds", "2000")
+    .action(async (options) => {
+    await startBridgeHelper({
+        pollInterval: parseInt(options.pollInterval),
+        verbose: true
+    });
+});
+// iris bridge serve
+bridgeCommand
+    .command("serve")
+    .description("Start automated agent (Simulates AI response)")
+    .action(async () => {
+    const { startAgentRunner } = await import("../bridge/agent-runner.js");
+    await startAgentRunner({ verbose: true });
+});
+// iris bridge status
+bridgeCommand
+    .command("status")
+    .description("Show bridge status and IDE information")
+    .action(() => {
+    console.log("");
+    console.log(kleur.bold("IRIS Bridge Status"));
+    console.log("===================\n");
+    // IDE selection
+    const ideId = getSelectedIde();
+    if (ideId) {
+        console.log(kleur.bold("Selected IDE:"));
+        console.log(`  ${kleur.cyan(ideId)}\n`);
+    }
+    else {
+        console.log(kleur.yellow("⚠ No IDE selected"));
+        console.log(kleur.dim("  Run: iris install\n"));
+    }
+    // Connector availability
+    if (ideId) {
+        const connector = createConnector(ideId);
+        console.log(kleur.bold("Connector:"));
+        console.log(`  Type: ${connector.displayName}`);
+        console.log(`  ID: ${connector.id}\n`);
+    }
+    // Bridge directories
+    console.log(kleur.bold("Bridge Directories:"));
+    const dirs = [
+        { name: "Inbox", path: INBOX_DIR },
+        { name: "Outbox", path: OUTBOX_DIR },
+        { name: "State", path: STATE_DIR }
+    ];
+    dirs.forEach(({ name, path: dirPath }) => {
+        const exists = fs.existsSync(dirPath);
+        const status = exists ? kleur.green("✓") : kleur.red("✗");
+        console.log(`  ${status} ${name}: ${dirPath}`);
+        if (exists) {
+            const files = fs.readdirSync(dirPath);
+            if (files.length > 0) {
+                console.log(kleur.dim(`    ${files.length} file(s)`));
+            }
+        }
+    });
+    console.log("");
+    // Pending tasks
+    if (fs.existsSync(INBOX_DIR)) {
+        const tasks = fs.readdirSync(INBOX_DIR).filter(f => f.endsWith(".json"));
+        if (tasks.length > 0) {
+            console.log(kleur.bold("Pending Tasks:"));
+            tasks.forEach(task => {
+                console.log(kleur.yellow(`  - ${task.replace(".json", "")}`));
+            });
+            console.log("");
+        }
+    }
+    // Helper running check
+    console.log(kleur.bold("Bridge Helper:"));
+    console.log(kleur.dim("  To start: iris bridge run"));
+    console.log("");
+});

package/dist/commands/develop.js

@@ -0,0 +1,141 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import { getSelectedIde, setSelectedIde } from "../iris/state.js";
+import { createRun, loadRun, saveRun } from "../iris/run-state.js";
+import { createConnector } from "../bridge/connector-factory.js";
+import { WorkflowStage } from "../bridge/types.js";
+import fs from "fs";
+import path from "path";
+export const developCommand = new Command("develop")
+    .description("Run automated IRIS workflow (Execution Phase)")
+    .argument("[intent...]", "Intent description")
+    .option("--resume <runId>", "Resume a previous run")
+    .option("--ide <ideId>", "Override IDE selection")
+    .option("--gate <mode>", "Gate approval mode: auto or manual", "manual")
+    .action(async (intentArgs, options) => {
+    // Handle resume (existing logic is fine-ish but we need to ensure it skips to execution)
+    if (options.resume) {
+        console.log(kleur.cyan(`Resuming run: ${options.resume}`));
+        await resumeRun(options.resume, options);
+        return;
+    }
+    // Implicitly resume OR start new execution if plan exists
+    // User expects "iris develop" to just work if plan is ready.
+    // Check for bolts/plan.md
+    const planPath = path.join(process.cwd(), "memory-bank/operations/bolts/plan.md");
+    if (!fs.existsSync(planPath)) {
+        console.error(kleur.red("No bolt plan found."));
+        console.log(kleur.yellow("Please run 'iris ask' first to create a plan."));
+        process.exit(1);
+    }
+    // We need a RunState. 
+    // If "iris ask" created a run, we should probably print the runId to resume?
+    // Or "iris ask" just created files. 
+    // We should create a NEW run for execution if one isn't passed?
+    // Actually, if we want to trace the whole thing, "iris ask" created a run.
+    // But "iris ask" might have exited.
+    // We can create a new run for "Execution Phase".
+    const intent = intentArgs.join(" ") || "Execute Plan"; // Optional intent arg if just running
+    // Get IDE selection
+    let ideId = options.ide || getSelectedIde();
+    if (!ideId) {
+        const { selectedIde } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "selectedIde",
+                message: "Which IDE will you use? (e.g., cursor, vscode, antigravity)",
+                default: "antigravity"
+            }
+        ]);
+        ideId = selectedIde;
+        setSelectedIde(ideId);
+    }
+    console.log("");
+    console.log(kleur.bold("Starting IRIS Execution"));
+    console.log(kleur.gray(`IDE: ${ideId}`));
+    console.log("");
+    const runState = createRun(intent, ideId, options.gate);
+    // Pre-load bolts from plan
+    // executeBoltPlan usually does this. We need to do it here manually since we skipped that stage.
+    // We can reuse logic or just rely on executeBoltExecution to load them? 
+    // executeBoltExecution expects runState.bolts to be populated.
+    // We need to parse bolts. 
+    // We should export parseBoltsFromPlan from bolt-plan.ts or move to a utility.
+    // Or just re-implement simple parsing here.
+    const bolts = await parseBoltsFromPlan();
+    if (bolts.length === 0) {
+        console.error(kleur.red("No bolts found in plan.md"));
+        process.exit(1);
+    }
+    runState.bolts = bolts;
+    runState.stage = WorkflowStage.BOLT_EXECUTION;
+    saveRun(runState);
+    console.log(kleur.cyan(`Loaded ${bolts.length} bolts from plan.`));
+    // Execute workflow
+    await executeWorkflow(runState, options);
+});
+async function resumeRun(runId, options) {
+    try {
+        const runState = loadRun(runId);
+        console.log(kleur.gray(`Intent: ${runState.intent}`));
+        console.log(kleur.gray(`Current Stage: ${runState.stage}`));
+        console.log("");
+        await executeWorkflow(runState, options);
+    }
+    catch (error) {
+        console.error(kleur.red(`Failed to resume run: ${error.message}`));
+        process.exit(1);
+    }
+}
+async function executeWorkflow(runState, options) {
+    const connector = createConnector(runState.ideId);
+    // Initial bridge check (Invisible Bridge handled by waitResult, but we might want to ensure it's up)
+    // await connector.ensureRunning(); // optional
+    console.log(kleur.bold("Execution Phase"));
+    // We only handle Bolt Execution loop here
+    if (runState.stage === WorkflowStage.BOLT_EXECUTION) {
+        // Custom loop to add Reporting
+        while (runState.currentBoltIndex < runState.bolts.length) {
+            const bolt = runState.bolts[runState.currentBoltIndex];
+            // Execute Bolt
+            // We can reuse executeBoltExecution BUT it loops internaly.
+            // We want to interject reporting.
+            // So we should probably modify executeBoltExecution OR 
+            // just call a "executeSingleBolt" if exposed?
+            // It is not exposed.
+            // Alternative: Let executeBoltExecution run ALL bolts, and we rely on it?
+            // But we want reporting "After every bolt iris generates a report".
+            // We can modify executeBoltExecution to do reporting?
+            // YES. That is a better place if we want it tightly coupled.
+            // But per "Refactoring develop command" plan:
+            // "Modify executeWorkflow to... Iterate bolts... Execute... Report"
+            // If I cannot cleanly call single bolt execution, I should modify bolt-execution.ts to accept a callback or emit events?
+            // Or just verify if I can import executeSingleBolt? It's not exported.
+            // I will modify bolt-execution.ts to export executeSingleBolt or handle reporting.
+            // For now, let's assume I will REFACTOR bolt-execution.ts to export executeSingleBolt.
+            // Wait, let's verify if I can export it.
+            // Yes I can.
+        }
+        // Using the "Refactor develop.ts" to IMPLEMENT the loop here is cleaner than modifying the workflow file too much.
+        // ...
+    }
+}
+// ... helper to parse bolts needed if not importing ...
+async function parseBoltsFromPlan() {
+    const planPath = path.join(process.cwd(), "memory-bank/operations/bolts/plan.md");
+    if (!fs.existsSync(planPath))
+        return [];
+    // Simple regex parse execution
+    const content = fs.readFileSync(planPath, "utf8");
+    const bolts = [];
+    const boltPattern = /(?:^|\n)(?:\d+\.|[-*])\s+([a-z0-9-]+)(?:\.md)?/gi;
+    let match;
+    while ((match = boltPattern.exec(content)) !== null) {
+        const boltId = match[1].replace(/\.md$/, "");
+        if (!bolts.find(b => b.id === boltId)) {
+            bolts.push({ id: boltId, status: "pending" });
+        }
+    }
+    return bolts;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,102 @@
+import { Command } from "commander";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+function checkmark(condition) {
+    return condition ? kleur.green("✓") : kleur.red("✗");
+}
+function getNodeVersion() {
+    return process.version;
+}
+function getNpmVersion() {
+    try {
+        return execSync("npm --version", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function getNpmPrefix() {
+    try {
+        return execSync("npm prefix -g", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function isInPath(dir) {
+    const pathEnv = process.env.PATH || "";
+    const paths = pathEnv.split(":");
+    return paths.includes(dir);
+}
+export const doctorCommand = new Command("doctor")
+    .description("Diagnose environment and PATH issues for iris")
+    .action(() => {
+    const root = process.cwd();
+    const cliPath = path.join(root, "dist/cli.js");
+    const cliExists = fs.existsSync(cliPath);
+    const nodeVersion = getNodeVersion();
+    const npmVersion = getNpmVersion();
+    const npmPrefix = getNpmPrefix();
+    const globalBinDir = npmPrefix !== "unknown" ? path.join(npmPrefix, "bin") : "unknown";
+    const irisLinkPath = globalBinDir !== "unknown" ? path.join(globalBinDir, "iris") : "unknown";
+    const irisLinkExists = irisLinkPath !== "unknown" && fs.existsSync(irisLinkPath);
+    const binInPath = globalBinDir !== "unknown" && isInPath(globalBinDir);
+    console.log("");
+    console.log(kleur.bold("IRIS Doctor - Environment Diagnostics"));
+    console.log("=====================================");
+    console.log("");
+    // System info
+    console.log(kleur.bold("System:"));
+    console.log(`${checkmark(true)} Node.js:     ${nodeVersion}`);
+    console.log(`${checkmark(npmVersion !== "unknown")} npm:         ${npmVersion}`);
+    console.log(`${checkmark(true)} Repo root:   ${root}`);
+    console.log(`${checkmark(cliExists)} CLI built:   ${cliExists ? "dist/cli.js exists" : "dist/cli.js MISSING"}`);
+    console.log("");
+    if (!cliExists) {
+        console.log(kleur.yellow("⚠ Action Required:"));
+        console.log("  Build the CLI first:");
+        console.log(kleur.cyan("    npm run build"));
+        console.log("");
+    }
+    // Global installation
+    console.log(kleur.bold("Global Installation:"));
+    console.log(`${checkmark(npmPrefix !== "unknown")} npm prefix:  ${npmPrefix}`);
+    console.log(`${checkmark(globalBinDir !== "unknown")} bin dir:     ${globalBinDir}`);
+    console.log(`${checkmark(binInPath)} In PATH:     ${binInPath ? "YES" : "NO"}`);
+    console.log(`${checkmark(irisLinkExists)} iris link:   ${irisLinkExists ? `${irisLinkPath} → exists` : `${irisLinkPath} → NOT FOUND`}`);
+    console.log("");
+    // Actionable guidance
+    const hasIssues = !cliExists || !binInPath || !irisLinkExists;
+    if (hasIssues) {
+        console.log(kleur.yellow("⚠ Action Required:"));
+        console.log("");
+        if (!irisLinkExists && cliExists) {
+            console.log("  Link iris globally:");
+            console.log(kleur.cyan("    npm run link:iris"));
+            console.log("");
+        }
+        if (!binInPath && globalBinDir !== "unknown") {
+            console.log("  Add global bin to PATH:");
+            console.log(kleur.cyan(`    export PATH="${globalBinDir}:$PATH"`));
+            console.log("");
+            console.log("  Then reload shell:");
+            console.log(kleur.cyan("    source ~/.zshrc && hash -r"));
+            console.log("");
+        }
+    }
+    else {
+        console.log(kleur.green("✓ Everything looks good!"));
+        console.log("");
+        console.log("  You can run iris globally:");
+        console.log(kleur.cyan("    iris --version"));
+        console.log(kleur.cyan("    iris validate"));
+        console.log("");
+    }
+    // Additional tips
+    console.log(kleur.dim("Tips:"));
+    console.log(kleur.dim("  - Run 'type -a iris' to see which iris resolves"));
+    console.log(kleur.dim("  - Use 'npm run iris -- <command>' for repo-local execution"));
+    console.log("");
+});