@indigoai-us/hq-cli 5.83.0 → 5.85.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [5.85.0]
+
+### Changed
+
+- Checkpoint Stop-gate eligibility is now runtime-specific: Claude Code is
+  enabled for every HQ account, Codex is enabled only for the designated
+  operator account (including delegated identities), and other Codex accounts
+  and runtimes remain disabled. Runtime-specific verdict caches prevent one
+  host's eligibility from leaking into another. (#295)
+
+## [5.84.0]
+
+### Added
+
+- `hq reindex` now trusts every Codex project hook owned by the active
+  HQ root and refreshes Grok folder trust plus the shipped user-hook
+  bridge. Global, plugin, and other-repository hooks remain untouched;
+  absent runtimes stay non-fatal and converged runs are quiet. (#293)
+
 ## [5.83.0]
 
 ### Added

package/dist/commands/core-checkpoint.js

@@ -307,12 +307,23 @@ function writeStamps(liveRoot, sessionId) {
         fs.writeFileSync(stampPath, timestamp);
     return stampPaths;
 }
-function gateEligibility() {
+const CODEX_CHECKPOINT_ACCOUNT = "hassaan@getindigo.ai";
+function checkpointGateRuntime() {
+    const runtime = (process.env.HQ_CHECKPOINT_RUNTIME ?? "claude").trim().toLowerCase();
+    if (runtime === "claude" || runtime === "codex")
+        return runtime;
+    return "other";
+}
+function gateEligibility(runtime) {
     const forced = process.env.HQ_CHECKPOINT_GATE;
     if (forced === "0")
         return false;
     if (forced === "1")
         return true;
+    if (runtime === "claude")
+        return true;
+    if (runtime !== "codex")
+        return false;
     try {
         const tokenPath = path.join(homedir(), ".hq", "cognito-tokens.json");
         const tokens = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
@@ -320,19 +331,7 @@ function gateEligibility() {
             return false;
         const claims = peekIdToken(tokens.idToken);
         const candidateEmails = [claims.email, claims["custom:delegatedEmail"]];
-        const configured = (process.env.HQ_CHECKPOINT_GATE_DOMAINS ?? "")
-            .split(",")
-            .map((candidate) => candidate.trim().toLowerCase())
-            .filter(Boolean);
-        const hasEligibleDomain = (candidate) => {
-            if (typeof candidate !== "string")
-                return false;
-            const domain = candidate.split("@").at(-1)?.toLowerCase();
-            if (!domain)
-                return false;
-            return domain === "getindigo.ai" || configured.includes(domain);
-        };
-        return candidateEmails.some(hasEligibleDomain);
+        return candidateEmails.some((candidate) => typeof candidate === "string" && candidate.toLowerCase() === CODEX_CHECKPOINT_ACCOUNT);
     }
     catch {
         return false;
@@ -341,8 +340,9 @@ function gateEligibility() {
 function writeGateVerdict(liveRoot) {
     const stateDir = path.join(liveRoot, "workspace", "orchestrator", "hook-state");
     fs.mkdirSync(stateDir, { recursive: true });
-    const eligible = gateEligibility();
-    fs.writeFileSync(path.join(stateDir, "checkpoint-gate-eligible"), eligible ? "1" : "0");
+    const runtime = checkpointGateRuntime();
+    const eligible = gateEligibility(runtime);
+    fs.writeFileSync(path.join(stateDir, `checkpoint-gate-eligible-${runtime}`), eligible ? "1" : "0");
     printResult(eligible ? "eligible" : "ineligible");
 }
 function backendOnPath(name) {

package/dist/commands/reindex.js

@@ -1,6 +1,7 @@
 /**
  * hq reindex — surface namespaced skills, mirror the personal overlay into
- * core/, and regenerate the workers registry.
+ * core/, regenerate the workers registry, and converge HQ-owned hook trust for
+ * Codex and Grok.
  *
  * Thin wrapper over @indigoai-us/hq-cloud's reindex(), which execs the bundled
  * scripts/reindex.sh against the HQ root. This command is what the hq-core
@@ -27,6 +28,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as yaml from 'js-yaml';
 import { reindex, rescue } from '@indigoai-us/hq-cloud';
+import { trustHqRuntimeHooks } from '../utils/hook-trust.js';
 import { findHqRoot } from '../utils/manifest.js';
 const HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse'];
 const HOOK_CHECK_RELATIVE_PATH = path.join('core', 'scripts', 'check-hq-hooks.sh');
@@ -207,11 +209,11 @@ export function registerReindexCommand(program) {
     program
         .command('reindex')
         .alias('master-sync')
-        .description('Surface namespaced skills, mirror the personal overlay into core/, and regenerate the workers registry')
+        .description('Surface namespaced skills, regenerate the workers registry, and trust HQ hooks for Codex and Grok')
         .option('--repo-root <path>', 'HQ root to operate on (defaults to the current directory)')
         .option('--from-hook', 'Invoked from a Claude/Codex lifecycle hook: never wait on the per-root operation lock — if a sync/rescue holds it, skip this reindex instead of blocking the session (equivalent to --lock-timeout 0)')
         .option('--lock-timeout <seconds>', 'Bound the wait for the per-root operation lock (seconds). 0 = refuse immediately; omitted = wait indefinitely (the interactive default). --from-hook implies 0; an explicit --lock-timeout wins.')
-        .action((opts) => {
+        .action(async (opts) => {
         // Resolve the lock-wait bound. An explicit --lock-timeout wins; otherwise
         // --from-hook forces 0 (refuse-fast) so a hook fired while a sync/rescue
         // holds the shared per-root operation lock can never stall the agent.
@@ -233,7 +235,10 @@ export function registerReindexCommand(program) {
             process.env.HQ_OP_LOCK_TIMEOUT = String(lockTimeoutSec);
         }
         const { status } = reindex({ repoRoot: opts.repoRoot });
-        repairExtremeHookDrift(resolveHqRoot(opts.repoRoot), status === 0);
+        const hqRoot = resolveHqRoot(opts.repoRoot);
+        repairExtremeHookDrift(hqRoot, status === 0);
+        if (status === 0)
+            await trustHqRuntimeHooks(hqRoot);
         process.exit(status);
     });
 }

package/dist/utils/hook-trust.d.ts

@@ -0,0 +1,35 @@
+export interface CodexRpcClient {
+    request(method: string, params: unknown): Promise<unknown>;
+    close(): Promise<void>;
+}
+type SpawnSyncLike = (command: string, args: string[], options: {
+    cwd: string;
+    encoding: 'utf8';
+    stdio: 'pipe';
+}) => {
+    status: number | null;
+    stdout?: string | Buffer | null;
+    stderr?: string | Buffer | null;
+    error?: Error;
+};
+export interface HookTrustDependencies {
+    createCodexClient: (cwd: string) => Promise<CodexRpcClient>;
+    spawnSync: SpawnSyncLike;
+    homeDir?: () => string;
+}
+export interface RuntimeHookTrustResult {
+    runtime: 'codex' | 'grok';
+    status: 'trusted' | 'unchanged' | 'skipped' | 'failed';
+    trusted: number;
+    reason?: string;
+}
+/** Start a short-lived Codex app-server and complete its JSONL handshake. */
+export declare function createCodexAppServerClient(cwd: string, executable?: string, args?: string[]): Promise<CodexRpcClient>;
+/** Trust only hooks declared by this HQ root's project `.codex/` layer. */
+export declare function trustCodexProjectHooks(hqRoot: string, deps?: HookTrustDependencies): Promise<RuntimeHookTrustResult>;
+/** Grok trusts hooks at folder scope; the shipped installer also refreshes the HQ bridge. */
+export declare function trustGrokProjectHooks(hqRoot: string, deps?: HookTrustDependencies): RuntimeHookTrustResult;
+/** Converge hook trust without turning an absent runtime into a reindex failure. */
+export declare function trustHqRuntimeHooks(hqRoot: string, deps?: HookTrustDependencies): Promise<RuntimeHookTrustResult[]>;
+export {};
+//# sourceMappingURL=hook-trust.d.ts.map

package/dist/utils/hook-trust.js

@@ -0,0 +1,314 @@
+import { spawn, spawnSync as nodeSpawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+const CODEX_REQUEST_TIMEOUT_MS = 10_000;
+function errorMessage(value) {
+    return value instanceof Error ? value.message : String(value);
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isHookMetadata(value) {
+    const hook = asObject(value);
+    return (hook !== undefined &&
+        typeof hook.key === 'string' &&
+        typeof hook.currentHash === 'string' &&
+        typeof hook.enabled === 'boolean' &&
+        typeof hook.isManaged === 'boolean' &&
+        typeof hook.source === 'string' &&
+        typeof hook.sourcePath === 'string' &&
+        ['managed', 'untrusted', 'trusted', 'modified'].includes(String(hook.trustStatus)));
+}
+function hooksFromListResponse(response) {
+    const data = asObject(response)?.data;
+    if (!Array.isArray(data))
+        return { hooks: [], errors: ['hooks/list returned no data array'] };
+    const hooks = [];
+    const errors = [];
+    for (const rawEntry of data) {
+        const entry = asObject(rawEntry);
+        if (!entry)
+            continue;
+        if (Array.isArray(entry.hooks))
+            hooks.push(...entry.hooks.filter(isHookMetadata));
+        if (Array.isArray(entry.errors)) {
+            for (const rawError of entry.errors) {
+                const parsed = asObject(rawError);
+                if (typeof parsed?.message === 'string')
+                    errors.push(parsed.message);
+                else if (typeof rawError === 'string')
+                    errors.push(rawError);
+            }
+        }
+    }
+    return { hooks, errors };
+}
+function isWithin(child, parent) {
+    const relative = path.relative(parent, child);
+    return relative !== '' && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative);
+}
+function hqProjectHooks(hqRoot, hooks) {
+    const codexLayer = path.resolve(hqRoot, '.codex');
+    return hooks.filter((hook) => hook.source === 'project' &&
+        !hook.isManaged &&
+        isWithin(path.resolve(hook.sourcePath), codexLayer));
+}
+/** Start a short-lived Codex app-server and complete its JSONL handshake. */
+export async function createCodexAppServerClient(cwd, executable = 'codex', args = ['app-server']) {
+    const child = spawn(executable, args, {
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const lines = readline.createInterface({ input: child.stdout });
+    const pending = new Map();
+    let nextId = 0;
+    let stderr = '';
+    let exited;
+    child.stderr.on('data', (chunk) => {
+        if (stderr.length < 4_096)
+            stderr += String(chunk).slice(0, 4_096 - stderr.length);
+    });
+    const rejectPending = (error) => {
+        exited = error;
+        for (const request of pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(error);
+        }
+        pending.clear();
+    };
+    child.on('error', (error) => rejectPending(error));
+    child.on('exit', (code, signal) => {
+        if (pending.size === 0)
+            return;
+        const detail = stderr.trim();
+        rejectPending(new Error(`Codex app-server exited before replying (${signal ? `signal ${signal}` : `status ${code ?? 'unknown'}`})${detail ? `: ${detail}` : ''}`));
+    });
+    lines.on('line', (line) => {
+        let message;
+        try {
+            message = asObject(JSON.parse(line));
+        }
+        catch {
+            return;
+        }
+        if (!message || typeof message.id !== 'number')
+            return;
+        const request = pending.get(message.id);
+        if (!request)
+            return;
+        pending.delete(message.id);
+        clearTimeout(request.timer);
+        const rpcError = asObject(message.error);
+        if (rpcError) {
+            request.reject(new Error(String(rpcError.message ?? 'Codex app-server request failed')));
+        }
+        else {
+            request.resolve(message.result);
+        }
+    });
+    const send = (message) => {
+        if (exited)
+            throw exited;
+        child.stdin.write(`${JSON.stringify(message)}\n`);
+    };
+    const request = (method, params) => {
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`Codex app-server request timed out: ${method}`));
+            }, CODEX_REQUEST_TIMEOUT_MS);
+            pending.set(id, { resolve, reject, timer });
+            try {
+                send({ method, id, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                pending.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    };
+    await request('initialize', {
+        clientInfo: {
+            name: 'hq_cli',
+            title: 'HQ CLI',
+            version: '1',
+        },
+    });
+    send({ method: 'initialized', params: {} });
+    return {
+        request,
+        async close() {
+            lines.close();
+            if (!child.killed) {
+                child.stdin.end();
+                child.kill();
+            }
+        },
+    };
+}
+const DEFAULT_DEPS = {
+    createCodexClient: createCodexAppServerClient,
+    spawnSync: nodeSpawnSync,
+    homeDir: () => process.env.HOME ?? os.homedir(),
+};
+/** Trust only hooks declared by this HQ root's project `.codex/` layer. */
+export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
+    if (!fs.existsSync(path.join(hqRoot, '.codex'))) {
+        return { runtime: 'codex', status: 'skipped', trusted: 0, reason: 'project .codex layer absent' };
+    }
+    let client;
+    try {
+        client = await deps.createCodexClient(hqRoot);
+        const discovered = hooksFromListResponse(await client.request('hooks/list', { cwds: [hqRoot] }));
+        if (discovered.errors.length > 0) {
+            return {
+                runtime: 'codex',
+                status: 'failed',
+                trusted: 0,
+                reason: discovered.errors.join('; '),
+            };
+        }
+        const projectHooks = hqProjectHooks(hqRoot, discovered.hooks);
+        if (projectHooks.length === 0) {
+            return {
+                runtime: 'codex',
+                status: 'skipped',
+                trusted: 0,
+                reason: 'no HQ project hooks discovered',
+            };
+        }
+        const pending = projectHooks.filter((hook) => hook.trustStatus === 'untrusted' || hook.trustStatus === 'modified');
+        if (pending.length === 0) {
+            return { runtime: 'codex', status: 'unchanged', trusted: 0 };
+        }
+        const state = Object.fromEntries(pending.map((hook) => [
+            hook.key,
+            {
+                enabled: hook.enabled,
+                trusted_hash: hook.currentHash,
+            },
+        ]));
+        await client.request('config/batchWrite', {
+            edits: [{ keyPath: 'hooks.state', value: state, mergeStrategy: 'upsert' }],
+            reloadUserConfig: true,
+        });
+        const verified = hooksFromListResponse(await client.request('hooks/list', { cwds: [hqRoot] }));
+        const verifiedByKey = new Map(verified.hooks.map((hook) => [hook.key, hook]));
+        const stillPending = pending
+            .filter((hook) => verifiedByKey.get(hook.key)?.trustStatus !== 'trusted')
+            .map((hook) => hook.key);
+        if (verified.errors.length > 0 || stillPending.length > 0) {
+            return {
+                runtime: 'codex',
+                status: 'failed',
+                trusted: 0,
+                reason: [...verified.errors, ...stillPending].join('; '),
+            };
+        }
+        return { runtime: 'codex', status: 'trusted', trusted: pending.length };
+    }
+    catch (error) {
+        return { runtime: 'codex', status: 'failed', trusted: 0, reason: errorMessage(error) };
+    }
+    finally {
+        if (client) {
+            try {
+                await client.close();
+            }
+            catch {
+                // Trust state is already persisted; shutdown is best-effort.
+            }
+        }
+    }
+}
+function regexEscape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function filesMatch(left, right) {
+    try {
+        return fs.readFileSync(left).equals(fs.readFileSync(right));
+    }
+    catch {
+        return false;
+    }
+}
+function grokTrustIsCurrent(hqRoot, home) {
+    const grokHome = path.join(home, '.grok');
+    const rootPattern = regexEscape(hqRoot);
+    let modernTrust;
+    let legacyTrust;
+    let config;
+    try {
+        modernTrust = fs.readFileSync(path.join(grokHome, 'trusted_folders.toml'), 'utf8');
+        legacyTrust = fs.readFileSync(path.join(grokHome, 'trusted-hook-projects'), 'utf8');
+        config = fs.readFileSync(path.join(grokHome, 'config.toml'), 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const folderTrusted = new RegExp(`^\\[folders\\."${rootPattern}"\\]\\s*\\n(?:(?!\\[)[^\\n]*\\n)*trusted\\s*=\\s*true\\b`, 'm').test(modernTrust);
+    const legacyTrusted = legacyTrust.split(/\r?\n/).includes(hqRoot);
+    const claudeCompatQuiet = /^\[compat\.claude\]\s*\n(?:(?!\[)[^\n]*\n)*hooks\s*=\s*false\b/m.test(config);
+    const sourceHooks = path.join(hqRoot, '.grok', 'hooks');
+    const userHooks = path.join(grokHome, 'hooks');
+    return (folderTrusted &&
+        legacyTrusted &&
+        claudeCompatQuiet &&
+        filesMatch(path.join(sourceHooks, 'hq-grok-user-bridge.sh'), path.join(userHooks, 'hq-hq-bridge.sh')) &&
+        filesMatch(path.join(sourceHooks, 'hq-grok-user-bridge.json'), path.join(userHooks, 'hq-hq-bridge.json')));
+}
+/** Grok trusts hooks at folder scope; the shipped installer also refreshes the HQ bridge. */
+export function trustGrokProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
+    const script = path.join(hqRoot, 'core', 'scripts', 'grok-trust.sh');
+    if (!fs.existsSync(script)) {
+        return { runtime: 'grok', status: 'skipped', trusted: 0, reason: 'grok-trust.sh absent' };
+    }
+    const home = deps.homeDir?.() ?? process.env.HOME ?? os.homedir();
+    if (grokTrustIsCurrent(hqRoot, home)) {
+        return { runtime: 'grok', status: 'unchanged', trusted: 0 };
+    }
+    const result = deps.spawnSync('bash', [script], {
+        cwd: hqRoot,
+        encoding: 'utf8',
+        stdio: 'pipe',
+    });
+    if (result.error || result.status !== 0) {
+        const detail = String(result.stderr ?? '').trim().split('\n')[0];
+        return {
+            runtime: 'grok',
+            status: 'failed',
+            trusted: 0,
+            reason: result.error?.message ??
+                (detail || `grok-trust.sh exited ${result.status ?? 'unknown'}`),
+        };
+    }
+    return { runtime: 'grok', status: 'trusted', trusted: 1 };
+}
+/** Converge hook trust without turning an absent runtime into a reindex failure. */
+export async function trustHqRuntimeHooks(hqRoot, deps = DEFAULT_DEPS) {
+    const results = [
+        await trustCodexProjectHooks(hqRoot, deps),
+        trustGrokProjectHooks(hqRoot, deps),
+    ];
+    for (const result of results) {
+        if (result.status === 'trusted') {
+            if (result.runtime === 'codex') {
+                console.log(`reindex: trusted ${result.trusted} Codex HQ hook${result.trusted === 1 ? '' : 's'}`);
+            }
+            else {
+                console.log('reindex: refreshed Grok HQ hook trust');
+            }
+        }
+        else if (result.status === 'failed') {
+            console.warn(`reindex: could not trust ${result.runtime} HQ hooks: ${result.reason ?? 'unknown error'}`);
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=hook-trust.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.83.0",
+  "version": "5.85.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {