0xray 4.0.38 → 4.0.40

package/vendor/@0xray/repertoire/dist/provider/memory-routing-provider.d.ts

@@ -4,6 +4,7 @@
  * Loaded dynamically by 0xRay via features.json memory_routing.module_path.
  * Other providers can follow the same createMemoryRoutingProvider() export pattern.
  */
+import { type MetaInferenceFailureReason, type MetaInferenceModel } from '../synthesis/meta-inference-engine.js';
 /** Mirrors 0xRay memory-routing/types.ts — kept local to avoid compile-time coupling */
 export interface MemoryAgentCapability {
     capabilities: string[];
@@ -80,6 +81,14 @@ export interface OrchestratorFeedbackEntry {
     dynamoResult?: Record<string, unknown>;
     lesson?: string;
 }
+export type MetaInferenceRefreshReason = 'synthesized' | 'nothing_to_process' | MetaInferenceFailureReason;
+export interface MetaInferenceRefreshResult {
+    refreshed: boolean;
+    /** Machine-readable outcome. A failed model is never `synthesized`. */
+    reason: MetaInferenceRefreshReason;
+    /** Present when the model was missing or the call failed. */
+    error?: string;
+}
 export interface MemoryRoutingProviderConfig {
     dataDir?: string;
     signalsPath?: string;
@@ -87,6 +96,11 @@ export interface MemoryRoutingProviderConfig {
     statePath?: string;
     feedbackDir?: string;
     projectRoot?: string;
+    /**
+     * Meta-inference model. `null` means none is configured (refresh fails closed).
+     * Omit to keep the engine's hermes CLI default.
+     */
+    hermesCommand?: MetaInferenceModel | null;
 }
 export interface MemoryRoutingProvider {
     readonly id: string;
@@ -104,9 +118,7 @@ export interface MemoryRoutingProvider {
         projectRoot: string;
         dueReason?: string | null;
     }): Record<string, unknown> | null;
-    refreshMetaInference?(): Promise<{
-        refreshed: boolean;
-    }>;
+    refreshMetaInference?(): Promise<MetaInferenceRefreshResult>;
 }
 export type ProviderAvailabilityReason = 'ok' | 'empty_registry' | 'signals_unreadable' | 'signals_missing';
 export interface ProviderAvailabilityStatus {
@@ -143,9 +155,7 @@ export declare class RepertoireMemoryRoutingProvider implements MemoryRoutingPro
         projectRoot: string;
         dueReason?: string | null;
     }): Record<string, unknown> | null;
-    refreshMetaInference(): Promise<{
-        refreshed: boolean;
-    }>;
+    refreshMetaInference(): Promise<MetaInferenceRefreshResult>;
 }
 /** Factory export — 0xRay provider-loader calls this by name */
 export declare function createMemoryRoutingProvider(config?: MemoryRoutingProviderConfig): MemoryRoutingProvider;

package/vendor/@0xray/repertoire/dist/provider/memory-routing-provider.js

@@ -7,6 +7,7 @@
 import { existsSync } from 'node:fs';
 import { DEFAULT_SIGNALS_PATH, defaultWritablePaths, hydrateWritableSignals, resolveReadableConfigPath, resolveWritableConfigPath, } from '../paths.js';
 import { RepertoireService } from '../RepertoireService.js';
+import { MetaInferenceModelError, } from '../synthesis/meta-inference-engine.js';
 function toRepertoireCaps(caps) {
     return {
         capabilities: caps.capabilities,
@@ -71,6 +72,9 @@ export class RepertoireMemoryRoutingProvider {
             logDir: resolveWritableConfigPath(config.logDir, cwd, writable.logDir),
             feedbackDir: resolveWritableConfigPath(config.feedbackDir, cwd, writable.feedbackDir),
         });
+        if (config.hermesCommand !== undefined) {
+            this.service.metaInference.configureModel(config.hermesCommand);
+        }
     }
     getAvailabilityStatus() {
         try {
@@ -199,8 +203,21 @@ export class RepertoireMemoryRoutingProvider {
         return this.service.buildSynthesisContext(opts.projectRoot, opts.dueReason ?? null);
     }
     async refreshMetaInference() {
-        const report = await this.service.runMetaInference();
-        return { refreshed: report !== null };
+        try {
+            const report = await this.service.runMetaInference();
+            if (report === null) {
+                return { refreshed: false, reason: 'nothing_to_process' };
+            }
+            return { refreshed: true, reason: 'synthesized' };
+        }
+        catch (error) {
+            if (error instanceof MetaInferenceModelError) {
+                return { refreshed: false, reason: error.reason, error: error.message };
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[meta-inference] state_error: ${message}\n`);
+            return { refreshed: false, reason: 'state_error', error: message };
+        }
     }
 }
 /** Factory export — 0xRay provider-loader calls this by name */

package/vendor/@0xray/repertoire/dist/registry/CuratedSignalsManager.js

@@ -150,6 +150,38 @@ function isSpeechMint(signal) {
     return signal.status === 'proposed' && signal.tags.includes('learned');
 }
 const FIELD_PRIMITIVE_NAME = /^[A-Za-z][A-Za-z0-9_-]{2,119}$/;
+/** A content word after a spaced law extends the id. A function word is the sentence. */
+const PROSE_TAIL = new Set([
+    'a', 'an', 'the', 'as', 'and', 'or', 'but', 'if', 'of', 'to', 'for', 'in', 'on', 'at', 'by',
+    'with', 'from', 'into', 'over', 'after', 'before', 'about', 'than', 'then', 'that', 'this',
+    'these', 'those', 'it', 'its', 'is', 'are', 'was', 'were', 'be', 'been', 'not', 'no', 'so',
+    'when', 'while', 'where', 'which', 'who', 'what', 'how', 'also', 'only', 'just', 'still',
+    'never', 'today',
+]);
+/** A longer id does not count. Spaced prose may continue after a hyphenated id. */
+function boundedId(text, id, spaced) {
+    if (!id)
+        return false;
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`(?:^|[^a-z0-9-])${escaped}`, 'g');
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        const after = text.slice(match.index + match[0].length);
+        if (spaced ? spacedTailIsProse(after) : !/^[a-z0-9-]/.test(after))
+            return true;
+        if (match.index === re.lastIndex)
+            re.lastIndex += 1;
+    }
+    return false;
+}
+function spacedTailIsProse(after) {
+    if (/^-[a-z0-9]/.test(after) || /^[a-z0-9]/.test(after))
+        return false;
+    const word = /^\s*([a-z0-9]+)/.exec(after);
+    if (!word || !/^\s/.test(after))
+        return true;
+    return PROSE_TAIL.has(word[1]);
+}
 /**
  * The diary names a law only when it contains the signal id, or the id with
  * hyphens read as spaces. A repo tail, leftover tokens, and two definition
@@ -160,10 +192,10 @@ export function signalNameInText(text, name) {
     const id = name.toLowerCase();
     if (!id)
         return false;
-    if (normalized.includes(id))
+    if (boundedId(normalized, id, false))
         return true;
     const spaced = id.replace(/-/g, ' ');
-    return spaced !== id && normalized.includes(spaced);
+    return spaced !== id && boundedId(normalized, spaced, true);
 }
 const GROOVER_EXPERIMENT_NAMES = new Set([
     'criteria_selection_gap',

package/vendor/@0xray/repertoire/dist/registry/InferenceStateManager.d.ts

@@ -3,6 +3,9 @@ export declare class InferenceStateManager {
     private readonly filePath;
     constructor(filePath?: string);
     load(): InferenceState;
+    /** Remember a failed model attempt without marking entries processed or touching lastRun. */
+    recordModelFailure(failedAt: string): void;
+    clearModelBackoff(): void;
     save(state: InferenceState): void;
     isProcessed(id: string): boolean;
     markProcessed(ids: string[], kind?: 'comment' | 'session' | 'post'): void;

package/vendor/@0xray/repertoire/dist/registry/InferenceStateManager.js

@@ -10,12 +10,30 @@ export class InferenceStateManager {
             return this.createEmpty();
         }
         const raw = JSON.parse(readFileSync(this.filePath, 'utf8'));
-        return {
+        const state = {
             processedCommentIds: raw.processedCommentIds ?? [],
             processedSessionIds: raw.processedSessionIds ?? [],
             processedPostIds: raw.processedPostIds ?? [],
             lastRun: raw.lastRun ?? null,
         };
+        const backoff = readBackoff(raw.modelBackoff);
+        if (backoff)
+            state.modelBackoff = backoff;
+        return state;
+    }
+    /** Remember a failed model attempt without marking entries processed or touching lastRun. */
+    recordModelFailure(failedAt) {
+        const state = this.load();
+        const failures = (state.modelBackoff?.failures ?? 0) + 1;
+        state.modelBackoff = { failedAt, failures };
+        this.save(state);
+    }
+    clearModelBackoff() {
+        const state = this.load();
+        if (!state.modelBackoff)
+            return;
+        delete state.modelBackoff;
+        this.save(state);
     }
     save(state) {
         const dir = dirname(this.filePath);
@@ -58,4 +76,10 @@ export class InferenceStateManager {
         };
     }
 }
+function readBackoff(value) {
+    if (!value || typeof value.failedAt !== 'string')
+        return null;
+    const failures = typeof value.failures === 'number' && value.failures > 0 ? value.failures : 1;
+    return { failedAt: value.failedAt, failures };
+}
 //# sourceMappingURL=InferenceStateManager.js.map

package/vendor/@0xray/repertoire/dist/synthesis/meta-inference-engine.d.ts

@@ -1,11 +1,32 @@
 import type { SynthesisReport } from '../types.js';
+export type MetaInferenceModel = (prompt: string) => unknown;
+export type MetaInferenceFailureReason = 'model_unavailable' | 'model_call_failed' | 'model_output_invalid' | 'model_backoff' | 'state_error';
+/** First wait after a failed model attempt. Doubles until MODEL_BACKOFF_CAP_MS. */
+export declare const MODEL_BACKOFF_BASE_MS: number;
+/** Upper bound so a dead hermes CLI cannot push the wait without limit. */
+export declare const MODEL_BACKOFF_CAP_MS: number;
+export declare function modelBackoffDelayMs(failures: number): number;
+export declare function formatMetaInferenceFailure(error: unknown): string;
+/** Raised when synthesis cannot be produced by a model. Callers must not treat it as a report. */
+export declare class MetaInferenceModelError extends Error {
+    readonly reason: MetaInferenceFailureReason;
+    constructor(reason: MetaInferenceFailureReason, message: string, options?: {
+        cause?: unknown;
+    });
+}
 export interface MetaInferenceEngineOptions {
     logDir?: string;
     statePath?: string;
     reportPath?: string;
     batchSize?: number;
     maxEntries?: number;
-    hermesCommand?: (prompt: string) => string;
+    /**
+     * Model call. Omit to use the hermes CLI.
+     * `null` means no model is configured — the run fails closed and does not call out.
+     */
+    hermesCommand?: MetaInferenceModel | null;
+    /** Pinned in tests. Defaults to the system clock. */
+    now?: () => Date;
 }
 export declare class MetaInferenceEngine {
     private readonly logDir;
@@ -14,10 +35,24 @@ export declare class MetaInferenceEngine {
     private readonly batchSize;
     private readonly maxEntries;
     private readonly promptBuilder;
-    private readonly runHermes;
+    private readonly now;
+    private model;
     constructor(options?: MetaInferenceEngineOptions);
+    /** `null` configures no model. The next run fails closed instead of calling the hermes CLI. */
+    configureModel(command: MetaInferenceModel | null): void;
     run(): Promise<SynthesisReport | null>;
     private loadUnprocessedEntries;
+    private loadState;
+    private throwIfBackingOff;
+    /**
+     * A missing, failed, or junk model result must not produce a synthesis report.
+     * Entries stay unprocessed so a later run can retry them.
+     */
+    private callModelOrRecord;
+    private callModel;
+    private noteModelFailure;
+    private fail;
+    private logFailure;
     private appendReport;
     private defaultHermesCommand;
 }

package/vendor/@0xray/repertoire/dist/synthesis/meta-inference-engine.js

@@ -3,6 +3,31 @@ import { join, dirname } from 'node:path';
 import { execSync } from 'node:child_process';
 import { SynthesisPromptBuilder } from './synthesis-prompt-builder.js';
 import { InferenceStateManager } from '../registry/InferenceStateManager.js';
+/** First wait after a failed model attempt. Doubles until MODEL_BACKOFF_CAP_MS. */
+export const MODEL_BACKOFF_BASE_MS = 15 * 60 * 1000;
+/** Upper bound so a dead hermes CLI cannot push the wait without limit. */
+export const MODEL_BACKOFF_CAP_MS = 4 * 60 * 60 * 1000;
+export function modelBackoffDelayMs(failures) {
+    const exponent = Math.max(0, Math.min(failures, 16) - 1);
+    const doubled = MODEL_BACKOFF_BASE_MS * 2 ** exponent;
+    return Math.min(doubled, MODEL_BACKOFF_CAP_MS);
+}
+export function formatMetaInferenceFailure(error) {
+    if (error instanceof MetaInferenceModelError) {
+        return oneLine(`meta-inference failed: ${error.reason}: ${error.message}`);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return oneLine(`meta-inference failed: state_error: ${message}`);
+}
+/** Raised when synthesis cannot be produced by a model. Callers must not treat it as a report. */
+export class MetaInferenceModelError extends Error {
+    reason;
+    constructor(reason, message, options) {
+        super(message, options);
+        this.name = 'MetaInferenceModelError';
+        this.reason = reason;
+    }
+}
 const DEFAULT_BATCH_SIZE = 1;
 const DEFAULT_MAX_ENTRIES = 8;
 export class MetaInferenceEngine {
@@ -12,17 +37,26 @@ export class MetaInferenceEngine {
     batchSize;
     maxEntries;
     promptBuilder = new SynthesisPromptBuilder();
-    runHermes;
+    now;
+    model;
     constructor(options = {}) {
         this.logDir = options.logDir ?? 'logs/groover-inference';
         this.stateManager = new InferenceStateManager(options.statePath ?? 'data/inference-state.json');
         this.reportPath = options.reportPath ?? 'logs/meta-inference/synthesis.md';
         this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
         this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-        this.runHermes = options.hermesCommand ?? this.defaultHermesCommand;
+        this.now = options.now ?? (() => new Date());
+        this.model =
+            options.hermesCommand === null
+                ? null
+                : (options.hermesCommand ?? ((prompt) => this.defaultHermesCommand(prompt)));
+    }
+    /** `null` configures no model. The next run fails closed instead of calling the hermes CLI. */
+    configureModel(command) {
+        this.model = command;
     }
     async run() {
-        const state = this.stateManager.load();
+        const state = this.loadState();
         const processed = new Set([
             ...state.processedCommentIds,
             ...state.processedSessionIds,
@@ -36,6 +70,7 @@ export class MetaInferenceEngine {
             return null;
         }
         const entries = newEntries.slice(0, this.maxEntries);
+        this.throwIfBackingOff(state);
         const batchResults = [];
         let totalPass = 0;
         let totalReject = 0;
@@ -68,23 +103,13 @@ export class MetaInferenceEngine {
                     analyzedSoFar: i + batch.length,
                 },
             });
-            try {
-                batchResults.push(this.runHermes(prompt));
-            }
-            catch {
-                // Continue with remaining batches
-            }
+            batchResults.push(this.callModelOrRecord(prompt));
         }
         const avgResonance = resonanceCount > 0 ? (resonanceSum / resonanceCount).toFixed(3) : 'N/A';
         const finalPrompt = this.promptBuilder.buildFinalSynthesisPrompt(entries.length, { pass: totalPass, reject: totalReject, avgResonance }, batchResults, entries);
-        let finalReport = '';
-        try {
-            finalReport = this.runHermes(finalPrompt);
-            this.appendReport(entries.length, totalPass, resonanceCount > 0 ? resonanceSum / resonanceCount : null, finalReport);
-        }
-        catch {
-            finalReport = batchResults.join('\n\n---\n\n');
-        }
+        const finalReport = this.callModelOrRecord(finalPrompt);
+        this.stateManager.clearModelBackoff();
+        this.appendReport(entries.length, totalPass, resonanceCount > 0 ? resonanceSum / resonanceCount : null, finalReport);
         const ids = entries.map((e) => e.comment_id ?? e.post_id ?? e.session_id).filter(Boolean);
         const hasSession = entries.some((e) => e.session_id);
         this.stateManager.markProcessed(ids, hasSession ? 'session' : 'comment');
@@ -118,13 +143,96 @@ export class MetaInferenceEngine {
                         processed.add(id);
                     }
                 }
-                catch {
-                    // skip malformed
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.logFailure('malformed_log_line', `skipped malformed log line in ${file}: ${message}`);
                 }
             }
         }
         return entries;
     }
+    loadState() {
+        try {
+            return this.stateManager.load();
+        }
+        catch (error) {
+            throw this.fail('state_error', `meta-inference state could not be read: ${errorText(error)}`, error);
+        }
+    }
+    throwIfBackingOff(state) {
+        const backoff = state.modelBackoff;
+        if (!backoff)
+            return;
+        const failedAt = Date.parse(backoff.failedAt);
+        if (Number.isNaN(failedAt))
+            return;
+        const wait = modelBackoffDelayMs(backoff.failures);
+        if (this.now().getTime() - failedAt < wait) {
+            throw this.fail('model_backoff', `meta-inference model call skipped until backoff ends (${wait}ms)`);
+        }
+    }
+    /**
+     * A missing, failed, or junk model result must not produce a synthesis report.
+     * Entries stay unprocessed so a later run can retry them.
+     */
+    callModelOrRecord(prompt) {
+        try {
+            return this.callModel(prompt);
+        }
+        catch (error) {
+            this.noteModelFailure(error);
+            throw error;
+        }
+    }
+    callModel(prompt) {
+        if (this.model === null) {
+            throw this.fail('model_unavailable', 'meta-inference model is not configured');
+        }
+        let output;
+        try {
+            output = this.model(prompt);
+        }
+        catch (error) {
+            if (error instanceof MetaInferenceModelError) {
+                this.logFailure(error.reason, error.message);
+                throw error;
+            }
+            if (isMissingHermes(error)) {
+                throw this.fail('model_unavailable', 'meta-inference model is not available: hermes CLI not found', error);
+            }
+            throw this.fail('model_call_failed', `meta-inference model call failed: ${errorText(error)}`, error);
+        }
+        try {
+            return acceptModelOutput(output);
+        }
+        catch (error) {
+            if (error instanceof MetaInferenceModelError) {
+                this.logFailure(error.reason, error.message);
+                throw error;
+            }
+            throw error;
+        }
+    }
+    noteModelFailure(error) {
+        if (!(error instanceof MetaInferenceModelError))
+            return;
+        if (error.reason === 'model_backoff' || error.reason === 'state_error')
+            return;
+        try {
+            this.stateManager.recordModelFailure(this.now().toISOString());
+        }
+        catch (recordError) {
+            this.logFailure('state_error', `could not record model backoff: ${errorText(recordError)}`);
+        }
+    }
+    fail(reason, message, cause) {
+        const error = new MetaInferenceModelError(reason, message, cause === undefined ? undefined : { cause });
+        this.logFailure(reason, message);
+        return error;
+    }
+    logFailure(reason, message) {
+        process.stderr.write(`[meta-inference] ${reason}: ${message}\n`);
+    }
     appendReport(entryCount, passCount, avgResonance, report) {
         const dir = dirname(this.reportPath);
         if (!existsSync(dir))
@@ -146,4 +254,53 @@ export class MetaInferenceEngine {
         }).trim();
     }
 }
+function oneLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function errorText(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function isMissingHermes(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const record = error;
+    if (record.code === 'ENOENT')
+        return true;
+    return typeof record.message === 'string' && record.message.includes('ENOENT');
+}
+function isThenable(value) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function'))
+        return false;
+    return typeof value.then === 'function';
+}
+/**
+ * Synthesis text is a non-empty string. A value shaped like JSON must parse.
+ * Anything else is not a model result.
+ */
+function acceptModelOutput(value) {
+    if (isThenable(value)) {
+        throw new MetaInferenceModelError('model_output_invalid', 'meta-inference model returned a Promise');
+    }
+    if (value === undefined || value === null) {
+        throw new MetaInferenceModelError('model_output_invalid', 'meta-inference model returned empty output');
+    }
+    if (typeof value !== 'string') {
+        throw new MetaInferenceModelError('model_output_invalid', 'meta-inference model returned a non-string');
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new MetaInferenceModelError('model_output_invalid', 'meta-inference model returned empty output');
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            JSON.parse(trimmed);
+        }
+        catch (error) {
+            throw new MetaInferenceModelError('model_output_invalid', `meta-inference model returned invalid JSON: ${errorText(error)}`, { cause: error });
+        }
+    }
+    return trimmed;
+}
 //# sourceMappingURL=meta-inference-engine.js.map

package/vendor/@0xray/repertoire/dist/types.d.ts

@@ -100,11 +100,17 @@ export interface CuratedSignalsFile {
     };
     signals: CuratedSignal[];
 }
+/** Clock for skipping another hermes call after a failed meta-inference run. */
+export interface ModelBackoffState {
+    failedAt: string;
+    failures: number;
+}
 export interface InferenceState {
     processedCommentIds: string[];
     processedSessionIds: string[];
     processedPostIds: string[];
     lastRun: string | null;
+    modelBackoff?: ModelBackoffState;
 }
 export interface SynthesisReport {
     entriesProcessed: number;

package/vendor/@0xray/repertoire/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xray/repertoire",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Factory memory organ for 0xRay — seed primitives, memory routing, extra MCP",
   "type": "module",
   "license": "MIT",
@@ -117,7 +117,7 @@
     }
   },
   "devDependencies": {
-    "0xray": "^4.0.7",
+    "0xray": "^4.0.28",
     "@types/node": "^22.15.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",

package/vendor/@0xray/repertoire/scripts/verify-grok-suit.mjs

@@ -114,10 +114,13 @@ try {
   fail('.mcp.json', e.message);
 }
 
-// 5. Grok plugin + UserPromptSubmit boot hook
-const grokPlugin = join(homedir(), '.grok/plugins/0xray');
-const grokHooks = join(grokPlugin, 'hooks/hooks.json');
-existsSync(grokPlugin) ? pass('Grok plugin', grokPlugin) : fail('Grok plugin', 'run: npx 0xray grok install --force');
+// 5. Grok plugin + UserPromptSubmit boot hook.
+// 0xray 4.0.28 installs the plugin into the project, not ~/.grok.
+const grokPlugin = join(root, '.grok', 'plugins', '0xray');
+const grokHooks = join(grokPlugin, 'hooks', 'hooks.json');
+existsSync(grokPlugin)
+  ? pass('Grok plugin', grokPlugin)
+  : fail('Grok plugin', `missing ${grokPlugin} — run: npx 0xray grok install --force`);
 if (existsSync(grokHooks)) {
   const hooksRaw = readFileSync(grokHooks, 'utf8');
   hooksRaw.includes('session-start.js')
@@ -130,7 +133,7 @@ if (existsSync(grokHooks)) {
     ? pass('UserPromptSubmit boot hook')
     : fail('UserPromptSubmit boot hook', 'add session-start.js — npx 0xray grok install --force');
 } else {
-  fail('Grok hooks.json', 'missing');
+  fail('Grok hooks.json', `missing ${grokHooks}`);
 }
 
 try {
@@ -297,7 +300,7 @@ if (existsSync(installedGrokHooks)) {
     fail('Grok plugin PostToolUse hook', 'run: npx 0xray grok install --force');
   }
 } else {
-  fail('Grok plugin PostToolUse hook', 'hooks.json missing — npx 0xray grok install --force');
+  fail('Grok plugin PostToolUse hook', `missing ${installedGrokHooks} — run: npx 0xray grok install --force`);
 }
 
 console.log('\n' + (failed === 0 ? '🎉 Suit wearable — operate within 0xRay.' : `⚠️  ${failed} check(s) failed — fix before tuning.`));