archbyte 0.4.0 → 0.4.1

package/dist/cli/patrol.js

@@ -3,8 +3,57 @@ import * as fs from "fs";
 import { execSync } from "child_process";
 import chalk from "chalk";
 import { runValidation } from "./validate.js";
-import { loadMetadata } from "./yaml-io.js";
+import { loadPatrolIgnore } from "./shared.js";
+import { loadArchitectureJSON, diffArchitectures, hasStructuralChanges } from "./arch-diff.js";
 const PATROL_DIR = ".archbyte/patrols";
+/**
+ * Convert a gitignore-style pattern to chokidar glob(s).
+ */
+function toChokidarGlobs(line) {
+    // Directory pattern: "dist/" → "**/dist/**"
+    if (line.endsWith("/")) {
+        return [`**/${line.slice(0, -1)}/**`];
+    }
+    // Glob with extension: "*.pyc" → "**/*.pyc"
+    if (line.startsWith("*.")) {
+        return [`**/${line}`];
+    }
+    // Already a glob — pass through
+    if (line.includes("*") || line.includes("?")) {
+        return [line];
+    }
+    // Plain name: treat as both file and directory
+    return [`**/${line}`, `**/${line}/**`];
+}
+/**
+ * Build chokidar ignored list from three layers:
+ *   1. Baseline: hidden dirs + node_modules (always)
+ *   2. .gitignore patterns (if present)
+ *   3. archbyte.yaml patrol.ignore patterns (if configured)
+ */
+function buildWatchIgnored(configPath) {
+    const ignored = [
+        /(^|[/\\])\./, // hidden files/dirs (.git, .archbyte, .venv, .next, etc.)
+        "**/node_modules/**",
+    ];
+    // Layer 2: .gitignore
+    const gitignorePath = path.join(process.cwd(), ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        const lines = fs.readFileSync(gitignorePath, "utf-8").split("\n");
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith("#") || line.startsWith("!"))
+                continue;
+            ignored.push(...toChokidarGlobs(line));
+        }
+    }
+    // Layer 3: archbyte.yaml patrol.ignore
+    const userPatterns = loadPatrolIgnore(configPath);
+    for (const pattern of userPatterns) {
+        ignored.push(...toChokidarGlobs(pattern));
+    }
+    return ignored;
+}
 const HISTORY_FILE = "history.jsonl";
 const LATEST_FILE = "latest.json";
 function parseInterval(str) {
@@ -41,63 +90,240 @@ function saveRecord(patrolDir, record) {
     // Append to history
     fs.appendFileSync(path.join(patrolDir, HISTORY_FILE), JSON.stringify(record) + "\n", "utf-8");
 }
-function diffViolations(previous, current) {
-    const key = (v) => `${v.rule}:${v.message}`;
+function diffIssues(previous, current) {
+    const key = (i) => `${i.type}:${i.rule || i.metric}:${i.message}`;
     const prevKeys = new Set(previous.map(key));
     const currKeys = new Set(current.map(key));
     return {
-        newViolations: current.filter((v) => !prevKeys.has(key(v))),
-        resolvedViolations: previous.filter((v) => !currKeys.has(key(v))),
+        newIssues: current.filter((i) => !prevKeys.has(key(i))),
+        resolvedIssues: previous.filter((i) => !currKeys.has(key(i))),
     };
 }
-function getCurrentCommit() {
+/**
+ * Load token usage from analysis.json metadata
+ */
+function loadTokenUsage() {
     try {
-        return execSync("git rev-parse HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        const analysisPath = path.join(process.cwd(), ".archbyte", "analysis.json");
+        if (!fs.existsSync(analysisPath))
+            return null;
+        const analysis = JSON.parse(fs.readFileSync(analysisPath, "utf-8"));
+        const tokenUsage = analysis.metadata?.tokenUsage;
+        if (tokenUsage?.input && tokenUsage?.output) {
+            return { input: tokenUsage.input, output: tokenUsage.output };
+        }
+        return null;
     }
     catch {
         return null;
     }
 }
-async function maybeRescan(options) {
-    if (!options.rescan)
-        return false;
-    const rootDir = process.cwd();
-    const meta = loadMetadata(rootDir);
-    const currentCommit = getCurrentCommit();
-    if (!currentCommit || !meta?.lastCommit || currentCommit === meta.lastCommit) {
-        return false;
+// ─── Git change tracking ───
+function gitExec(cmd, rootDir) {
+    try {
+        return execSync(cmd, {
+            cwd: rootDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function captureGitState(rootDir, patrolDir) {
+    const commitHash = gitExec("git rev-parse HEAD", rootDir);
+    if (!commitHash)
+        return undefined;
+    const previous = loadLatestRecord(patrolDir);
+    const previousCommitHash = previous?.git?.commitHash;
+    let changedFiles = [];
+    let commitCount = 0;
+    if (previousCommitHash && previousCommitHash !== commitHash) {
+        const countStr = gitExec(`git rev-list --count ${previousCommitHash}..HEAD`, rootDir);
+        if (countStr)
+            commitCount = parseInt(countStr, 10) || 0;
+        const diff = gitExec(`git diff --name-only ${previousCommitHash}..HEAD`, rootDir);
+        if (diff)
+            changedFiles = diff.split("\n").filter(Boolean);
     }
-    // Commit changed — run incremental analyze
-    console.log(chalk.gray(`  Rescan: commit changed (${meta.lastCommit.slice(0, 7)} → ${currentCommit.slice(0, 7)})`));
+    // Include uncommitted changes (staged + unstaged + untracked)
+    const unstaged = gitExec("git diff --name-only", rootDir);
+    if (unstaged) {
+        for (const f of unstaged.split("\n").filter(Boolean)) {
+            if (!changedFiles.includes(f))
+                changedFiles.push(f);
+        }
+    }
+    const staged = gitExec("git diff --name-only --cached", rootDir);
+    if (staged) {
+        for (const f of staged.split("\n").filter(Boolean)) {
+            if (!changedFiles.includes(f))
+                changedFiles.push(f);
+        }
+    }
+    const untracked = gitExec("git ls-files --others --exclude-standard", rootDir);
+    if (untracked) {
+        for (const f of untracked.split("\n").filter(Boolean)) {
+            if (!changedFiles.includes(f))
+                changedFiles.push(f);
+        }
+    }
+    return {
+        commitHash,
+        previousCommitHash,
+        commitCount,
+        changedFiles: changedFiles.slice(0, 100),
+        changedFileCount: changedFiles.length,
+    };
+}
+// ─── Structural diff → issues ───
+function structuralDiffToIssues(diff) {
+    const issues = [];
+    for (const node of diff.addedNodes) {
+        issues.push({
+            type: 'structural',
+            metric: 'component-added',
+            level: 'warn',
+            message: `New component: "${node.label}" (${node.type}, ${node.layer})`,
+            nodeIds: [node.id],
+        });
+    }
+    for (const node of diff.removedNodes) {
+        issues.push({
+            type: 'structural',
+            metric: 'component-removed',
+            level: 'warn',
+            message: `Removed component: "${node.label}" (${node.type}, ${node.layer})`,
+            nodeIds: [node.id],
+        });
+    }
+    for (const mod of diff.modifiedNodes) {
+        issues.push({
+            type: 'structural',
+            metric: 'component-modified',
+            level: 'warn',
+            message: `"${mod.id}" ${mod.field}: "${mod.from}" -> "${mod.to}"`,
+            nodeIds: [mod.id],
+        });
+    }
+    if (diff.addedEdges.length > 0 || diff.removedEdges.length > 0) {
+        issues.push({
+            type: 'structural',
+            metric: 'connections-changed',
+            level: 'warn',
+            message: `Connections: +${diff.addedEdges.length} added, -${diff.removedEdges.length} removed`,
+        });
+    }
+    return issues;
+}
+// ─── Metrics from validation ───
+function computeMetrics(result) {
+    return {
+        circularDependencies: result.violations.filter((v) => v.rule === "no-circular-deps").length,
+        highDegreeHubCount: result.violations.filter((v) => v.rule === "max-connections").length,
+        disconnectedComponentCount: result.violations.filter((v) => v.rule === "no-orphans").length,
+    };
+}
+/**
+ * Run a full patrol cycle: snapshot → analyze → generate → validate → diff.
+ */
+async function runPatrolCycle(options, patrolDir) {
+    const cycleStart = Date.now();
+    const rootDir = process.cwd();
+    // 0. Snapshot architecture before cycle for structural diff
+    const prevArch = loadArchitectureJSON(rootDir);
+    // 0b. Capture git state
+    const git = captureGitState(rootDir, patrolDir);
+    // 1. Run full analyze (static context → LLM pipeline, incremental)
     try {
         const { handleAnalyze } = await import("./analyze.js");
-        await handleAnalyze({ verbose: false });
-        return true;
+        await handleAnalyze({ verbose: false, skipServeHint: true });
     }
     catch (err) {
-        console.error(chalk.yellow(`  Rescan failed: ${err instanceof Error ? err.message : String(err)}`));
-        return false;
+        console.error(chalk.yellow(`  Analyze failed: ${err instanceof Error ? err.message : String(err)}`));
     }
-}
-function runPatrolCycle(options, patrolDir) {
+    // 2. Generate diagram from updated analysis
+    try {
+        const { handleGenerate } = await import("./generate.js");
+        await handleGenerate({ verbose: false });
+    }
+    catch (err) {
+        console.error(chalk.yellow(`  Generate failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    // 3. Compute structural diff
+    const currArch = loadArchitectureJSON(rootDir);
+    let structuralDiff;
+    if (prevArch && currArch) {
+        const diff = diffArchitectures(prevArch, currArch);
+        if (hasStructuralChanges(diff)) {
+            structuralDiff = diff;
+        }
+    }
+    // 4. Validate (get rule violations)
     const previous = loadLatestRecord(patrolDir);
     const result = runValidation({
         diagram: options.diagram,
         config: options.config,
     });
-    const { newViolations, resolvedViolations } = previous
-        ? diffViolations(previous.violations, result.violations)
-        : { newViolations: result.violations, resolvedViolations: [] };
+    // Convert rule violations to audit issues
+    const ruleIssues = result.violations.map((v) => ({
+        type: 'rule-violation',
+        rule: v.rule,
+        level: v.level,
+        message: v.message,
+        ruleType: 'builtin',
+    }));
+    // Convert structural diff to audit issues
+    const structuralIssues = structuralDiff ? structuralDiffToIssues(structuralDiff) : [];
+    // Merge all issues
+    const allIssues = [...ruleIssues, ...structuralIssues];
+    // Diff against previous cycle
+    const prevIssues = previous?.issues ?? [];
+    const { newIssues, resolvedIssues } = diffIssues(prevIssues, allIssues);
+    // 5. Extract token usage
+    const tokenData = loadTokenUsage();
+    // 6. Build record with all fields (structured + flattened for UI)
     const record = {
         timestamp: new Date().toISOString(),
-        passed: result.errors === 0,
+        passed: result.errors === 0 && structuralIssues.length === 0,
+        issues: allIssues,
+        summary: {
+            ruleViolations: ruleIssues.length,
+            structuralIssues: structuralIssues.length,
+            totalIssues: allIssues.length,
+        },
+        newIssues,
+        resolvedIssues,
+        metrics: computeMetrics(result),
+        durationMs: Date.now() - cycleStart,
+        tokenUsage: tokenData
+            ? {
+                inputTokens: tokenData.input,
+                outputTokens: tokenData.output,
+                totalTokens: tokenData.input + tokenData.output,
+            }
+            : undefined,
+        // Structural diff
+        structuralDiff,
+        // Git context
+        git,
+        // Architecture counts
+        totalNodes: currArch?.nodes.length ?? 0,
+        totalEdges: currArch?.edges.length ?? 0,
+        // Flattened for UI (backward compat)
         errors: result.errors,
         warnings: result.warnings,
-        violations: result.violations,
-        newViolations,
-        resolvedViolations,
-        totalNodes: result.totalNodes,
-        totalEdges: result.totalEdges,
+        newViolations: newIssues.map((i) => ({
+            rule: i.rule || i.metric || "",
+            level: i.level,
+            message: i.message,
+        })),
+        resolvedViolations: resolvedIssues.map((i) => ({
+            rule: i.rule || i.metric || "",
+            level: i.level,
+            message: i.message,
+        })),
     };
     saveRecord(patrolDir, record);
     return record;
@@ -105,23 +331,66 @@ function runPatrolCycle(options, patrolDir) {
 function printPatrolResult(record, cycleNum) {
     const time = new Date(record.timestamp).toLocaleTimeString();
     const status = record.passed ? chalk.green("HEALTHY") : chalk.red("VIOLATION");
+    const duration = record.durationMs ? `${(record.durationMs / 1000).toFixed(1)}s` : "?";
     console.log();
-    console.log(chalk.bold.cyan(`  Patrol #${cycleNum} | ${time} | ${status}`));
-    if (record.newViolations.length > 0) {
-        console.log(chalk.red(`  ${record.newViolations.length} new violation(s):`));
-        for (const v of record.newViolations) {
-            const icon = v.level === "error" ? chalk.red("!!") : chalk.yellow("!!");
-            console.log(chalk.gray(`    ${icon} [${v.rule}] ${v.message}`));
+    console.log(chalk.bold.cyan(`  Patrol #${cycleNum} | ${time} | ${status} | ${duration}`));
+    console.log(chalk.gray(`  Architecture: ${record.totalNodes} nodes, ${record.totalEdges} edges`));
+    // Token usage
+    if (record.tokenUsage) {
+        const tokens = record.tokenUsage;
+        console.log(chalk.gray(`  Tokens: ${tokens.inputTokens.toLocaleString()} in + ${tokens.outputTokens.toLocaleString()} out = ${tokens.totalTokens.toLocaleString()} total`));
+    }
+    // Git changes
+    if (record.git && (record.git.commitCount > 0 || record.git.changedFileCount > 0)) {
+        const parts = [];
+        if (record.git.commitCount > 0)
+            parts.push(`${record.git.commitCount} commit(s)`);
+        parts.push(`${record.git.changedFileCount} file(s) changed`);
+        console.log(chalk.gray(`  Git: ${parts.join(", ")}`));
+    }
+    // Structural changes
+    if (record.structuralDiff && hasStructuralChanges(record.structuralDiff)) {
+        const d = record.structuralDiff;
+        console.log(chalk.bold.yellow(`  Architecture drift detected:`));
+        for (const n of d.addedNodes) {
+            console.log(chalk.green(`    + ${n.label} (${n.type})`));
+        }
+        for (const n of d.removedNodes) {
+            console.log(chalk.red(`    - ${n.label} (${n.type})`));
+        }
+        for (const m of d.modifiedNodes) {
+            console.log(chalk.yellow(`    ~ ${m.id}: ${m.field} "${m.from}" -> "${m.to}"`));
+        }
+        if (d.addedEdges.length > 0) {
+            console.log(chalk.green(`    + ${d.addedEdges.length} new connection(s)`));
+        }
+        if (d.removedEdges.length > 0) {
+            console.log(chalk.red(`    - ${d.removedEdges.length} removed connection(s)`));
         }
     }
-    if (record.resolvedViolations.length > 0) {
-        console.log(chalk.green(`  ${record.resolvedViolations.length} resolved:`));
-        for (const v of record.resolvedViolations) {
-            console.log(chalk.green(`    -- [${v.rule}] ${v.message}`));
+    // New rule violations
+    const newRuleIssues = record.newIssues.filter((i) => i.type === "rule-violation");
+    if (newRuleIssues.length > 0) {
+        console.log(chalk.red(`  ${newRuleIssues.length} new rule violation(s):`));
+        for (const issue of newRuleIssues) {
+            const icon = issue.level === "error" ? chalk.red("!!") : chalk.yellow("!!");
+            const label = issue.rule || issue.metric || "unknown";
+            console.log(chalk.gray(`    ${icon} [${label}] ${issue.message}`));
         }
     }
-    if (record.newViolations.length === 0 && record.resolvedViolations.length === 0) {
-        console.log(chalk.gray(`  No changes. ${record.errors} errors, ${record.warnings} warnings`));
+    // Resolved issues
+    if (record.resolvedIssues.length > 0) {
+        console.log(chalk.green(`  ${record.resolvedIssues.length} resolved:`));
+        for (const issue of record.resolvedIssues) {
+            const label = issue.rule || issue.metric || "unknown";
+            console.log(chalk.green(`    -- [${label}] ${issue.message}`));
+        }
+    }
+    // No changes at all
+    if (record.newIssues.length === 0 &&
+        record.resolvedIssues.length === 0 &&
+        (!record.structuralDiff || !hasStructuralChanges(record.structuralDiff))) {
+        console.log(chalk.gray(`  No changes. ${record.summary.ruleViolations} rules, ${record.summary.structuralIssues} structural`));
     }
 }
 function printHistory(patrolDir) {
@@ -155,34 +424,43 @@ function printHistory(patrolDir) {
     console.log(`  Health: ${sparkline}  (last ${records.length} patrols)`);
     console.log();
     // Table
-    console.log(chalk.gray("  Time                 Status    Errors  Warnings  New  Resolved"));
-    console.log(chalk.gray("  " + "-".repeat(68)));
+    console.log(chalk.gray("  Time                 Status    Nodes  Edges  Rules  Struct  New  Resolved  Git"));
+    console.log(chalk.gray("  " + "-".repeat(100)));
     for (const r of records) {
         const time = new Date(r.timestamp).toLocaleString().padEnd(20);
         const status = r.passed ? chalk.green("PASS  ") : chalk.red("FAIL  ");
-        const errors = String(r.errors).padEnd(8);
-        const warnings = String(r.warnings).padEnd(10);
-        const newV = String(r.newViolations.length).padEnd(5);
-        const resolved = String(r.resolvedViolations.length);
-        console.log(`  ${time} ${status} ${errors}${warnings}${newV}${resolved}`);
+        const nodes = String(r.totalNodes ?? "?").padEnd(6);
+        const edges = String(r.totalEdges ?? "?").padEnd(6);
+        const rules = String(r.summary?.ruleViolations ?? 0).padEnd(6);
+        const structural = String(r.summary?.structuralIssues ?? 0).padEnd(8);
+        const newV = String(r.newIssues?.length ?? 0).padEnd(5);
+        const resolved = String(r.resolvedIssues?.length ?? 0).padEnd(10);
+        const gitInfo = r.git
+            ? `${r.git.commitCount}c/${r.git.changedFileCount}f`
+            : "-";
+        console.log(`  ${time} ${status} ${nodes}${edges}${rules}${structural}${newV}${resolved}${gitInfo}`);
     }
     console.log();
     // Summary
     const totalPatrols = lines.length;
-    const failedPatrols = lines.filter((l) => !JSON.parse(l).passed).length;
-    const healthPct = Math.round(((totalPatrols - failedPatrols) / totalPatrols) * 100);
+    const failedPatrols = records.filter((r) => !r.passed).length;
+    const healthPct = totalPatrols > 0
+        ? Math.round(((totalPatrols - failedPatrols) / totalPatrols) * 100)
+        : 100;
     console.log(`  Total patrols: ${totalPatrols} | Health rate: ${healthPct}% | Failed: ${failedPatrols}`);
     console.log();
 }
 function handleViolationAction(record, action) {
-    if (record.newViolations.length === 0)
+    if (record.newIssues.length === 0 && (!record.structuralDiff || !hasStructuralChanges(record.structuralDiff)))
         return;
     switch (action) {
         case "json":
             console.log(JSON.stringify({
-                event: "patrol-violation",
+                event: "patrol-issue",
                 timestamp: record.timestamp,
-                newViolations: record.newViolations,
+                newIssues: record.newIssues,
+                structuralDiff: record.structuralDiff,
+                git: record.git,
             }));
             break;
         case "log":
@@ -193,8 +471,9 @@ function handleViolationAction(record, action) {
 }
 /**
  * Run the architecture patrol daemon.
- * Inspired by Gastown's patrol loop pattern — cyclic monitoring
- * that detects drift and reports violations.
+ * Each cycle: snapshot → analyze (incremental) → generate → validate → diff
+ *
+ * --once: run a single cycle then exit (used by UI "Run Now")
  */
 export async function handlePatrol(options) {
     const projectName = process.cwd().split("/").pop() || "project";
@@ -204,25 +483,98 @@ export async function handlePatrol(options) {
         printHistory(patrolDir);
         return;
     }
+    const action = options.onViolation || "log";
+    // Run initial cycle immediately
+    let cycleNum = 1;
+    // Watch mode: trigger patrol cycle on source file changes
+    if (options.watch) {
+        const chokidar = await import("chokidar");
+        const userPatterns = loadPatrolIgnore(options.config);
+        console.log();
+        console.log(chalk.bold.cyan(`  ArchByte Patrol: ${projectName}`));
+        console.log(chalk.gray(`  Mode: watch | On violation: ${action}`));
+        console.log(chalk.gray(`  Detects: rule violations, architecture drift, git changes`));
+        console.log(chalk.gray(`  History: archbyte patrol --history`));
+        if (userPatterns.length > 0) {
+            console.log(chalk.gray(`  Ignoring: ${userPatterns.join(", ")} (from archbyte.yaml)`));
+        }
+        else {
+            console.log(chalk.gray(`  Tip: Add patrol.ignore in archbyte.yaml to exclude paths from watching`));
+        }
+        console.log(chalk.gray("  Press Ctrl+C to stop."));
+        // Set up watcher FIRST — its file handles keep the event loop alive
+        // so the process can't exit during the initial cycle.
+        let debounceTimer = null;
+        let running = false;
+        const triggerCycle = () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                if (running)
+                    return;
+                running = true;
+                cycleNum++;
+                try {
+                    const record = await runPatrolCycle(options, patrolDir);
+                    printPatrolResult(record, cycleNum);
+                    handleViolationAction(record, action);
+                }
+                catch (err) {
+                    console.error(chalk.red(`  Patrol cycle #${cycleNum} failed: ${err}`));
+                }
+                finally {
+                    running = false;
+                }
+            }, 500);
+        };
+        const watcher = chokidar.watch(".", {
+            cwd: process.cwd(),
+            ignoreInitial: true,
+            ignored: buildWatchIgnored(options.config),
+        });
+        watcher.on("change", triggerCycle);
+        watcher.on("add", triggerCycle);
+        watcher.on("unlink", triggerCycle);
+        const shutdown = () => {
+            watcher.close();
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            console.log();
+            console.log(chalk.gray(`  Patrol stopped after ${cycleNum} cycles.`));
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        // Now run initial cycle — watcher is already anchoring the event loop
+        try {
+            const record = await runPatrolCycle(options, patrolDir);
+            printPatrolResult(record, cycleNum);
+            handleViolationAction(record, action);
+        }
+        catch (err) {
+            console.error(chalk.red(`  Initial patrol cycle failed: ${err}`));
+        }
+        console.log(chalk.gray("  Watching for changes..."));
+        await new Promise(() => { });
+        return;
+    }
+    // Timer mode (default): poll on interval
     const intervalMs = parseInterval(options.interval || "5m");
     const intervalStr = options.interval || "5m";
-    const action = options.onViolation || "log";
     console.log();
     console.log(chalk.bold.cyan(`  ArchByte Patrol: ${projectName}`));
     console.log(chalk.gray(`  Interval: ${intervalStr} | On violation: ${action}`));
-    console.log(chalk.gray(`  History: ${path.join(PATROL_DIR, HISTORY_FILE)}`));
+    console.log(chalk.gray(`  Detects: rule violations, architecture drift, git changes`));
+    console.log(chalk.gray(`  History: archbyte patrol --history`));
     console.log(chalk.gray("  Press Ctrl+C to stop."));
-    // Run initial cycle immediately
-    let cycleNum = 1;
-    const record = runPatrolCycle(options, patrolDir);
+    const record = await runPatrolCycle(options, patrolDir);
     printPatrolResult(record, cycleNum);
     handleViolationAction(record, action);
     // Patrol loop
     const timer = setInterval(async () => {
         cycleNum++;
         try {
-            await maybeRescan(options);
-            const record = runPatrolCycle(options, patrolDir);
+            const record = await runPatrolCycle(options, patrolDir);
             printPatrolResult(record, cycleNum);
             handleViolationAction(record, action);
         }

package/dist/cli/setup.js

@@ -211,7 +211,7 @@ export async function handleSetup() {
     console.log();
     console.log(chalk.bold.cyan("ArchByte Setup"));
     console.log(chalk.gray("Configure your model provider and API key.\n"));
-    // Detect AI coding tools — suggest MCP instead of BYOK
+    // Detect AI coding tools
     const hasClaude = isInPath("claude");
     const codexDir = path.join(CONFIG_DIR, "../.codex");
     const hasCodex = fs.existsSync(codexDir);
@@ -303,9 +303,6 @@ export async function handleSetup() {
             console.log("  " + chalk.bold("Next steps"));
             console.log();
             console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
-            if (hasCodex) {
-                console.log("  " + chalk.cyan("archbyte mcp install") + "    Use from Codex CLI");
-            }
             console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
             console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");
             console.log();
@@ -313,8 +310,7 @@ export async function handleSetup() {
         }
         if (choice === "codex") {
             // TODO: Add Codex SDK provider when available
-            console.log(chalk.yellow("\n  Codex SDK provider coming soon. Setting up with API key for now."));
-            console.log(chalk.gray("  In the meantime, use archbyte mcp install to run ArchByte from Codex.\n"));
+            console.log(chalk.yellow("\n  Codex SDK provider coming soon. Setting up with API key for now.\n"));
         }
         // User chose BYOK — continue to normal provider selection below
         if (choice === "byok")
@@ -596,7 +592,6 @@ export async function handleSetup() {
     console.log();
     console.log("  " + chalk.cyan("archbyte run") + "            Analyze your codebase");
     if (hasClaude || hasCodex) {
-        console.log("  " + chalk.cyan("archbyte mcp install") + "    Use from your AI tool");
     }
     console.log("  " + chalk.cyan("archbyte status") + "         Check account and usage");
     console.log("  " + chalk.cyan("archbyte --help") + "         See all commands");

package/dist/cli/shared.d.ts

@@ -64,5 +64,16 @@ export declare function parseRulesFromYaml(content: string): RuleConfig;
  *         level: error
  */
 export declare function parseCustomRulesFromYaml(content: string): CustomRule[];
+/**
+ * Parse the patrol.ignore list from archbyte.yaml.
+ * Returns user-defined glob patterns for watch mode to ignore.
+ *
+ *   patrol:
+ *     ignore:
+ *       - "docs/"
+ *       - "*.md"
+ *       - "build/"
+ */
+export declare function loadPatrolIgnore(configPath?: string): string[];
 export declare function getRuleLevel(config: RuleConfig, rule: keyof RuleConfig, defaultLevel: RuleLevel): RuleLevel;
 export declare function getThreshold(config: RuleConfig, rule: "max-connections", defaultVal: number): number;