0xray 4.0.36 → 4.0.37

package/dist/analytics/simple-pattern-analyzer.js

@@ -50,16 +50,22 @@ export class SimplePatternAnalyzer {
         // Fall back to activity log parsing if no outcomes
         if (entries.length === 0 && fs.existsSync(this.logPath)) {
             const content = fs.readFileSync(this.logPath, "utf-8");
-            const lines = content.split("\n").filter((l) => l.trim());
-            // Filter to task completion entries
-            const completionLines = lines.filter((line) => line.includes("complex-task-completed") ||
-                line.includes("job-completed") ||
-                line.includes("task-completed"));
+            const completionLines = [];
+            for (const line of content.split("\n")) {
+                if (!line.trim())
+                    continue;
+                if (line.includes("complex-task-completed") ||
+                    line.includes("job-completed") ||
+                    line.includes("task-completed")) {
+                    completionLines.push(line);
+                }
+            }
             const entriesToAnalyze = limit ? completionLines.slice(-limit) : completionLines;
-            const parsedEntries = entriesToAnalyze
-                .map((line) => this.parseLine(line))
-                .filter((e) => e !== null);
-            entries.push(...parsedEntries);
+            for (const line of entriesToAnalyze) {
+                const parsed = this.parseLine(line);
+                if (parsed)
+                    entries.push(parsed);
+            }
         }
         if (entries.length === 0) {
             return this.emptyInsights();
@@ -189,32 +195,64 @@ export class SimplePatternAnalyzer {
                 }
             }
         }
-        // Calculate success rates
-        for (const [agent, stats] of agentStats) {
-            if (stats.attempts > 0) {
-                // We'll calculate in the output
-            }
+        let attempts = 0;
+        let successes = 0;
+        for (const stats of agentStats.values()) {
+            attempts += stats.attempts;
+            successes += stats.successes;
         }
-        for (const [taskType, stats] of taskTypeStats) {
-            const agentStatsForTask = Array.from(agentStats.values()).reduce((acc, s) => ({
-                attempts: acc.attempts + s.attempts,
-                successes: acc.successes + s.successes,
-            }), { attempts: 0, successes: 0 });
-            stats.successRate =
-                agentStatsForTask.attempts > 0
-                    ? (agentStatsForTask.successes / agentStatsForTask.attempts) * 100
-                    : 0;
+        const successRate = attempts > 0 ? (successes / attempts) * 100 : 0;
+        for (const stats of taskTypeStats.values()) {
+            stats.successRate = successRate;
         }
-        const sortedEntries = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         return {
             agentStats,
             taskTypeStats,
             complexityStats,
             totalEntries: entries.length,
-            dateRange: {
-                start: sortedEntries[0]?.timestamp || "",
-                end: sortedEntries[sortedEntries.length - 1]?.timestamp || "",
-            },
+            dateRange: this.entryDateRange(entries),
+        };
+    }
+    /**
+     * Earliest and latest timestamp. Matches a stable sort on finite times.
+     */
+    entryDateRange(entries) {
+        if (entries.length === 0)
+            return { start: "", end: "" };
+        const first = entries[0];
+        if (!first)
+            return { start: "", end: "" };
+        let start = first.timestamp;
+        let end = start;
+        let startTime = new Date(start).getTime();
+        let endTime = startTime;
+        if (!Number.isNaN(startTime)) {
+            let finite = true;
+            for (let i = 1; i < entries.length; i++) {
+                const entry = entries[i];
+                if (!entry)
+                    continue;
+                const time = new Date(entry.timestamp).getTime();
+                if (Number.isNaN(time)) {
+                    finite = false;
+                    break;
+                }
+                if (time < startTime) {
+                    startTime = time;
+                    start = entry.timestamp;
+                }
+                if (time >= endTime) {
+                    endTime = time;
+                    end = entry.timestamp;
+                }
+            }
+            if (finite)
+                return { start, end };
+        }
+        const sortedEntries = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        return {
+            start: sortedEntries[0]?.timestamp || "",
+            end: sortedEntries[sortedEntries.length - 1]?.timestamp || "",
         };
     }
     /**

package/dist/architect/architect-tools.d.ts

@@ -62,6 +62,9 @@ export declare function dependencyAnalysis(projectRoot: string, focusAreas?: str
  * Architecture Assessment Tool - Overall architectural health evaluation
  */
 export declare function architectureAssessment(projectRoot: string, assessmentType?: "quick" | "comprehensive"): Promise<ArchitectureAssessment>;
+/** Confer text follows the assessment. A critical coupling issue is FAIL. */
+export declare function conferVerdictFromAssessment(assessment: ArchitectureAssessment): "PASS" | "CONDITIONAL" | "FAIL";
+export declare function formatConferArchitectureText(conferPrompt: string, assessment: ArchitectureAssessment): string;
 export declare const architectTools: {
     contextAnalysis: typeof contextAnalysis;
     codebaseStructure: typeof codebaseStructure;

package/dist/architect/architect-tools.js

@@ -189,6 +189,28 @@ export async function architectureAssessment(projectRoot, assessmentType = "comp
     });
     return result;
 }
+/** Confer text follows the assessment. A critical coupling issue is FAIL. */
+export function conferVerdictFromAssessment(assessment) {
+    const criticalIssue = assessment.issues.some((issue) => issue.type === "critical");
+    if (criticalIssue ||
+        assessment.overallHealth === "critical" ||
+        assessment.overallHealth === "poor") {
+        return "FAIL";
+    }
+    if (assessment.overallHealth === "fair" ||
+        assessment.issues.some((issue) => issue.type === "major")) {
+        return "CONDITIONAL";
+    }
+    return "PASS";
+}
+export function formatConferArchitectureText(conferPrompt, assessment) {
+    const assessmentJson = JSON.stringify(assessment, null, 2);
+    const prompt = conferPrompt.trim();
+    if (!prompt)
+        return assessmentJson;
+    const verdict = conferVerdictFromAssessment(assessment);
+    return `${prompt}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: ${verdict}\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`;
+}
 // Helper functions
 function identifyArchitecturalPatterns(codebaseAnalysis, dependencyAnalysis) {
     const patterns = [];

package/dist/cli/commands/grok-install.js

@@ -3,7 +3,6 @@
  *
  * Helps users register 0xRay MCP servers with the Grok CLI.
  */
-import { installForGrokCLI } from '../../integrations/grok/grok-cli.js';
 export function registerGrokCommands(grokCmd) {
     grokCmd
         .command('install')
@@ -11,6 +10,7 @@ export function registerGrokCommands(grokCmd) {
         .option('--dry-run', 'Show what would be done without making changes')
         .option('--force', 'Force reinstall even if already present')
         .action(async (options) => {
+        const { installForGrokCLI } = await import('../../integrations/grok/grok-cli.js');
         await installForGrokCLI({ dryRun: options.dryRun, force: options.force });
     });
 }

package/dist/cli/commands/hermes-install.js

@@ -2,14 +2,15 @@ import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'node:url';
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { syncBuiltinSkills } from './skill-install.js';
-import { mintAfterWear } from './foundry-mint-wear.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const packageRoot = path.join(__dirname, '..', '..', '..');
-const millSuit = require(path.join(packageRoot, 'scripts', 'foundry', 'mint-suit.cjs'));
-const wiring = require(path.join(packageRoot, 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+function loadMillSuit() {
+    return require(path.join(packageRoot, 'scripts', 'foundry', 'mint-suit.cjs'));
+}
+function loadWiring() {
+    return require(path.join(packageRoot, 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+}
 export function registerHermesCommands(hermesCmd) {
     hermesCmd
         .command('install')
@@ -21,6 +22,11 @@ export function registerHermesCommands(hermesCmd) {
     });
 }
 async function installForHermes(options = {}) {
+    const { frameworkLogger } = await import('../../core/framework-logger.js');
+    const { syncBuiltinSkills } = await import('./skill-install.js');
+    const { mintAfterWear } = await import('./foundry-mint-wear.js');
+    const millSuit = loadMillSuit();
+    const wiring = loadWiring();
     frameworkLogger.log('hermes-integration', 'install-start', 'info', { options });
     const isolated = millSuit.isIsolatedHome();
     const targetPluginDir = isolated

package/dist/cli/commands/openclaw-install.js

@@ -2,15 +2,14 @@ import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'node:url';
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { syncBuiltinSkills } from './skill-install.js';
-import { mintAfterWear } from './foundry-mint-wear.js';
-import { OpenClawConfigLoader } from '../../integrations/openclaw/config.js';
-import { writeSuitSessionBoot } from '../../nucleus/suit-temperament.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-const millSuit = require(path.join(__dirname, '..', '..', '..', 'scripts', 'foundry', 'mint-suit.cjs'));
-const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+function loadMillSuit() {
+    return require(path.join(__dirname, '..', '..', '..', 'scripts', 'foundry', 'mint-suit.cjs'));
+}
+function loadWiring() {
+    return require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+}
 export function registerOpenClawCommands(openclawCmd) {
     openclawCmd
         .command('install')
@@ -22,6 +21,13 @@ export function registerOpenClawCommands(openclawCmd) {
     });
 }
 async function installForOpenClaw(options = {}) {
+    const { frameworkLogger } = await import('../../core/framework-logger.js');
+    const { syncBuiltinSkills } = await import('./skill-install.js');
+    const { mintAfterWear } = await import('./foundry-mint-wear.js');
+    const { OpenClawConfigLoader } = await import('../../integrations/openclaw/config.js');
+    const { writeSuitSessionBoot } = await import('../../nucleus/suit-temperament.js');
+    const millSuit = loadMillSuit();
+    const wiring = loadWiring();
     frameworkLogger.log('openclaw-integration', 'install-start', 'info', { options });
     const configPath = path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
     if (options.dryRun) {

package/dist/cli/commands/opencode-install.js

@@ -2,12 +2,11 @@ import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'node:url';
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { syncBuiltinSkills } from './skill-install.js';
-import { mintAfterWear, wantsCostume } from './foundry-mint-wear.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+function loadWiring() {
+    return require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+}
 export function registerOpencodeCommands(opencodeCmd) {
     opencodeCmd
         .command('install')
@@ -74,6 +73,10 @@ function copyDir(src, dest, relPath = "") {
     }
 }
 async function installForOpencode(options = {}) {
+    const { frameworkLogger } = await import('../../core/framework-logger.js');
+    const { syncBuiltinSkills } = await import('./skill-install.js');
+    const { mintAfterWear, wantsCostume } = await import('./foundry-mint-wear.js');
+    const wiring = loadWiring();
     frameworkLogger.log('opencode-integration', 'install-start', 'info', { options });
     const opencodeSource = path.join(__dirname, '..', '..', '..', '.opencode');
     const opencodeDest = path.join(process.cwd(), '.opencode');

package/dist/cli/commands/suit-monitor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Current picture of the worn suit.
+ *
+ * Inventory, already on disk, not a second store:
+ * - logs/framework/activity.log — activity-logger.ts and grok-hook-activity appendHookActivity
+ * - inference state — InferenceStateManager.load() from vendored @0xray/repertoire
+ *   (.xray/state/repertoire/inference-state.json)
+ * - repertoire version — that organ's package.json
+ * - worn 0xray version — package.json beside this CLI
+ * - 0xray report stays the health report; scripts/mjs/goggles-observer.mjs stays the lens check
+ */
+export type SuitSources = {
+    activityLogPath: string;
+    inferenceStatePath: string;
+    repertoirePackageJson: string | null;
+    xrayPackageJson: string;
+    tail?: number;
+};
+export type SuitPicture = {
+    activityLines: string[];
+    inferenceStatePresent: boolean;
+    inferenceLastRun: string | null;
+    repertoireVersion: string | null;
+    xrayVersion: string | null;
+};
+export declare function resolveRepertoirePackageJson(cwd: string): string | null;
+export declare function defaultSuitSources(cwd: string, xrayPackageJson: string): SuitSources;
+export declare function readSuitPicture(sources: SuitSources): Promise<SuitPicture>;
+export declare function formatSuitPicture(picture: SuitPicture): string;
+export declare function printSuitMonitor(cwd: string, packageRoot: string, lines?: number): Promise<void>;

package/dist/cli/commands/suit-monitor.js

@@ -0,0 +1,128 @@
+/**
+ * Current picture of the worn suit.
+ *
+ * Inventory, already on disk, not a second store:
+ * - logs/framework/activity.log — activity-logger.ts and grok-hook-activity appendHookActivity
+ * - inference state — InferenceStateManager.load() from vendored @0xray/repertoire
+ *   (.xray/state/repertoire/inference-state.json)
+ * - repertoire version — that organ's package.json
+ * - worn 0xray version — package.json beside this CLI
+ * - 0xray report stays the health report; scripts/mjs/goggles-observer.mjs stays the lens check
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { dirname, join, resolve } from "node:path";
+const REPERTOIRE_PACKAGE_CANDIDATES = [
+    "node_modules/@0xray/repertoire/package.json",
+    "vendor/@0xray/repertoire/package.json",
+    "node_modules/0xray/vendor/@0xray/repertoire/package.json",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isConstructor(value) {
+    return typeof value === "function";
+}
+export function resolveRepertoirePackageJson(cwd) {
+    for (const rel of REPERTOIRE_PACKAGE_CANDIDATES) {
+        const abs = resolve(cwd, rel);
+        if (existsSync(abs))
+            return abs;
+    }
+    return null;
+}
+export function defaultSuitSources(cwd, xrayPackageJson) {
+    return {
+        activityLogPath: join(cwd, "logs", "framework", "activity.log"),
+        inferenceStatePath: join(cwd, ".xray", "state", "repertoire", "inference-state.json"),
+        repertoirePackageJson: resolveRepertoirePackageJson(cwd),
+        xrayPackageJson,
+    };
+}
+function readPackageVersion(packageJsonPath) {
+    try {
+        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (!isRecord(raw) || typeof raw.version !== "string")
+            return null;
+        return raw.version;
+    }
+    catch {
+        return null;
+    }
+}
+function readLastActivityLines(logPath, tail) {
+    if (!existsSync(logPath) || tail <= 0)
+        return [];
+    try {
+        const lines = readFileSync(logPath, "utf8")
+            .split(/\r?\n/)
+            .filter((line) => line.length > 0);
+        return lines.slice(-tail);
+    }
+    catch {
+        return [];
+    }
+}
+function inferenceModuleFromPackage(packageJsonPath) {
+    const modulePath = join(dirname(packageJsonPath), "dist", "registry", "InferenceStateManager.js");
+    return existsSync(modulePath) ? modulePath : null;
+}
+/** Reuse the organ's read. A missing file stays absent; load() is not a second parser. */
+async function loadLastRun(modulePath, filePath) {
+    try {
+        const loaded = await import(pathToFileURL(modulePath).href);
+        if (!isRecord(loaded) || !isConstructor(loaded.InferenceStateManager))
+            return null;
+        const instance = new loaded.InferenceStateManager(filePath);
+        if (!isRecord(instance) || typeof instance.load !== "function")
+            return null;
+        const state = instance.load();
+        if (!isRecord(state) || typeof state.lastRun !== "string")
+            return null;
+        return state.lastRun;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readSuitPicture(sources) {
+    const tail = sources.tail ?? 8;
+    const modulePath = sources.repertoirePackageJson
+        ? inferenceModuleFromPackage(sources.repertoirePackageJson)
+        : null;
+    const inferenceStatePresent = existsSync(sources.inferenceStatePath);
+    const inferenceLastRun = inferenceStatePresent && modulePath
+        ? await loadLastRun(modulePath, sources.inferenceStatePath)
+        : null;
+    return {
+        activityLines: readLastActivityLines(sources.activityLogPath, tail),
+        inferenceStatePresent,
+        inferenceLastRun,
+        repertoireVersion: sources.repertoirePackageJson
+            ? readPackageVersion(sources.repertoirePackageJson)
+            : null,
+        xrayVersion: readPackageVersion(sources.xrayPackageJson),
+    };
+}
+export function formatSuitPicture(picture) {
+    const inference = picture.inferenceStatePresent
+        ? `present${picture.inferenceLastRun ? ` lastRun ${picture.inferenceLastRun}` : ""}`
+        : "absent";
+    const activity = picture.activityLines.length > 0
+        ? picture.activityLines.map((line) => `  ${line}`).join("\n")
+        : "  (none)";
+    return [
+        "suit monitor",
+        `xray: ${picture.xrayVersion ?? "missing"}`,
+        `repertoire: ${picture.repertoireVersion ?? "missing"}`,
+        `inference state: ${inference}`,
+        "activity:",
+        activity,
+    ].join("\n");
+}
+export async function printSuitMonitor(cwd, packageRoot, lines = 8) {
+    const sources = defaultSuitSources(cwd, join(packageRoot, "package.json"));
+    sources.tail = lines;
+    const picture = await readSuitPicture(sources);
+    process.stdout.write(`${formatSuitPicture(picture)}\n`);
+}

package/dist/cli/index.js

@@ -9,9 +9,10 @@ import { execSync, spawn, spawnSync } from "child_process";
 import { join, resolve } from "path";
 import { fileURLToPath } from "node:url";
 import { readFileSync, existsSync } from "fs";
-import { getConfigDir } from "../core/config-paths.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { inferenceRunMayEnter } from "../inference/inference-run-gate.js";
+async function loadFrameworkLogger() {
+    const { frameworkLogger } = await import("../core/framework-logger.js");
+    return frameworkLogger;
+}
 // Get package root relative to this script location
 const packageRoot = resolve(fileURLToPath(new URL("../..", import.meta.url)));
 // Read version dynamically from package.json
@@ -54,7 +55,8 @@ function runNodeScript(scriptName, args = []) {
 program
     .command("install")
     .description("Install xray framework in the current project")
-    .action(() => {
+    .action(async () => {
+    const frameworkLogger = await loadFrameworkLogger();
     frameworkLogger.log('cli', 'install', 'info', { message: 'nothing written' });
     process.stdout.write("nothing written\n");
 });
@@ -62,7 +64,7 @@ program
     .command("setup")
     .description("Set up .mcp.json and the OpenCode, Grok, Hermes, and OpenClaw bridges")
     .option("--git-hooks", "also install git hooks")
-    .action((opts) => {
+    .action(async (opts) => {
     const args = ["setup"];
     if (opts.gitHooks)
         args.push("--git-hooks");
@@ -70,6 +72,7 @@ program
         runNodeScript("install-bridges.cjs", args);
     }
     catch (error) {
+        const frameworkLogger = await loadFrameworkLogger();
         frameworkLogger.log("cli", "setup-error", "error", {
             error: error instanceof Error ? error.message : String(error),
         });
@@ -116,11 +119,12 @@ program
 program
     .command("wear")
     .description("Wear the 0xray suit in this git checkout")
-    .action(() => {
+    .action(async () => {
     try {
         runNodeScript("wear-cursor-hooks.cjs");
     }
     catch (error) {
+        const frameworkLogger = await loadFrameworkLogger();
         frameworkLogger.log('cli', 'wear-error', 'error', {
             error: error instanceof Error ? error.message : String(error),
         });
@@ -130,11 +134,12 @@ program
 program
     .command("unwear")
     .description("Remove the 0xray suit and restore the pre-wear hooks file")
-    .action(() => {
+    .action(async () => {
     try {
         runNodeScript("unwear-cursor-hooks.cjs");
     }
     catch (error) {
+        const frameworkLogger = await loadFrameworkLogger();
         frameworkLogger.log('cli', 'unwear-error', 'error', {
             error: error instanceof Error ? error.message : String(error),
         });
@@ -154,6 +159,16 @@ program
     const { statusCommand } = await import("./commands/status.js");
     await statusCommand(packageRoot);
 });
+program
+    .command("monitor")
+    .description("Current picture of the worn suit (activity, inference state, repertoire, version)")
+    .option("-n, --lines <count>", "Activity lines to show", "8")
+    .action(async (options) => {
+    const { printSuitMonitor } = await import("./commands/suit-monitor.js");
+    const parsed = Number(options.lines);
+    const lines = Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 8;
+    await printSuitMonitor(process.cwd(), packageRoot, lines);
+});
 program
     .command("validate")
     .description("Validate consumer wear (pack paths, Cursor hooks, mill plant) — not leftover init.sh")
@@ -391,6 +406,13 @@ program
         process.exit(1);
     }
 });
+program
+    .command("pulse")
+    .description("Print one line: worn CLI, repertoire, inference age, activity, lens, plant")
+    .action(async () => {
+    const { readSuitPulse } = await import("./suit-pulse.js");
+    process.stdout.write(`${readSuitPulse(process.cwd()).line}\n`);
+});
 program
     .command("fix")
     .description("Automatically fix common framework issues by running the postinstall setup")
@@ -496,6 +518,7 @@ program
             process.stdout.write("not worn\n");
         }
         const opencodeConfigPath = path.join(cwd, "opencode.json");
+        const { getConfigDir } = await import("../core/config-paths.js");
         const xrayDir = getConfigDir(cwd);
         const opencodeExists = fs.existsSync(opencodeConfigPath);
         const configDirExists = fs.existsSync(xrayDir);
@@ -727,6 +750,7 @@ program
             return;
         }
         const features = featuresConfigLoader.loadConfig();
+        const { inferenceRunMayEnter } = await import('../inference/inference-run-gate.js');
         if (!inferenceRunMayEnter(features.inference, options.force === true)) {
             if (options.json) {
                 console.log(JSON.stringify({ triggered: false, reason: 'Inference feature disabled in features.json' }));
@@ -957,22 +981,33 @@ program
     const child = spawn(process.execPath, [serverPath], { stdio: 'inherit', env });
     child.on('exit', (code) => process.exit(code ?? 0));
 });
+function argvSelects(name) {
+    return process.argv.slice(2).includes(name);
+}
 // Grok CLI integration
 const grokCmd = program.command('grok').description('Grok CLI integration commands');
-const { registerGrokCommands } = await import('./commands/grok-install.js');
-registerGrokCommands(grokCmd);
+if (argvSelects('grok')) {
+    const { registerGrokCommands } = await import('./commands/grok-install.js');
+    registerGrokCommands(grokCmd);
+}
 // Hermes Agent integration
 const hermesCmd = program.command('hermes').description('Hermes Agent integration commands');
-const { registerHermesCommands } = await import('./commands/hermes-install.js');
-registerHermesCommands(hermesCmd);
+if (argvSelects('hermes')) {
+    const { registerHermesCommands } = await import('./commands/hermes-install.js');
+    registerHermesCommands(hermesCmd);
+}
 // OpenClaw integration
 const openclawCmd = program.command('openclaw').description('OpenClaw integration commands');
-const { registerOpenClawCommands } = await import('./commands/openclaw-install.js');
-registerOpenClawCommands(openclawCmd);
+if (argvSelects('openclaw')) {
+    const { registerOpenClawCommands } = await import('./commands/openclaw-install.js');
+    registerOpenClawCommands(openclawCmd);
+}
 // OpenCode integration
 const opencodeCmd = program.command('opencode').description('OpenCode integration commands');
-const { registerOpencodeCommands } = await import('./commands/opencode-install.js');
-registerOpencodeCommands(opencodeCmd);
+if (argvSelects('opencode')) {
+    const { registerOpencodeCommands } = await import('./commands/opencode-install.js');
+    registerOpencodeCommands(opencodeCmd);
+}
 // Analytics enable command
 // Plugin subcommands
 const pluginCmd = program.command('plugin').description('Manage plugins');
@@ -1029,6 +1064,8 @@ Examples:
     $ npx 0xray capabilities  # Show all available capabilities
     $ npx 0xray health        # Check framework health and status
     $ npx 0xray report        # Generate activity and health reports
+    $ npx 0xray monitor       # Current picture of the worn suit
+    $ npx 0xray pulse         # One line: worn, repertoire, inference, activity, lens, plant
     $ npx 0xray fix           # Automatically restore missing config files
     $ npx 0xray doctor        # Diagnose issues (does not fix them)
     $ npx 0xray analytics     # Pattern analytics and insights

package/dist/cli/suit-pulse.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One line from streams the suit already writes.
+ * Not a doctor, not a second memory.
+ */
+export type SuitLens = "none" | "armed" | "spent";
+export interface SuitPulseActivity {
+    gate: string | null;
+    decision: string;
+    tool: string | null;
+}
+export interface SuitPulse {
+    worn: {
+        version: string;
+        directory: string;
+    } | null;
+    repertoire: string | null;
+    inferenceSeconds: number | null;
+    activity: SuitPulseActivity | null;
+    lens: SuitLens;
+    plant: boolean;
+    line: string;
+}
+export interface SuitPulseOptions {
+    /** Epoch ms. Tests pin this so inference age stays exact. */
+    now?: number;
+    /** Override the CLI directory. Hooks and node_modules/0xray are the default. */
+    wornDir?: string;
+}
+export declare function readSuitPulse(root: string, opts?: SuitPulseOptions): SuitPulse;