@indigoai-us/hq-cli 5.91.0 → 5.92.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [5.92.0]
+
+### Changed
+
+- `hq core codex-skill-bridge` now runs as native, tested TypeScript instead of
+  a bundled shell asset, completing the `hq core` utility migration. Install,
+  status, doctor, dry-run, stale-HQ-root repair, blocked-target refusal, legacy
+  `.Codex` handling, and the local-config path rewrite are all preserved and
+  proven byte-identical to the shell implementation by a differential suite
+  covering sixteen scenarios. The scaffold script still ships for loose HQ
+  trees. (#325)
+
 ## [5.91.0]
 
 ### Changed

package/dist/commands/core.js

@@ -41,6 +41,7 @@ import { ontologyReadmeDrift } from "../lib/core-utils/ontology-readme-drift.js"
 import { resizeScreenshot } from "../lib/core-utils/resize-screenshot.js";
 import { tokenUsageReport } from "../lib/core-utils/token-usage-report.js";
 import { createWorktree } from "../lib/core-utils/worktree.js";
+import { runCodexSkillBridgeCommand } from "../lib/core-utils/codex-skill-bridge-entry.js";
 /**
  * These commands are now native implementations. Their retained shell assets
  * are deliberately claimed in SCAFFOLD_ONLY_ASSETS: loose HQ trees still ship
@@ -53,6 +54,7 @@ export const NATIVE_UTILITY_COMMANDS = [
     { name: "resize-screenshot", root: "cwd", summary: "Downscale a screenshot for context efficiency", run: (args) => resizeScreenshot(args) },
     { name: "token-usage-report", root: "cwd", summary: "Report session token usage", run: (args) => tokenUsageReport(args) },
     { name: "worktree", root: "live", summary: "Create a git worktree under workspace/worktrees/", run: (args, context) => createWorktree(args, { cwd: context.cwd, hqRoot: context.hqRoot }) },
+    { name: "codex-skill-bridge", root: "live", summary: "Install/inspect the Codex skill bridge", run: (args, context) => runCodexSkillBridgeCommand(args, { root: context.hqRoot ?? context.cwd }) },
 ];
 export const NATIVE_SCAFFOLD_COMMANDS = [
     {
@@ -183,13 +185,6 @@ export const SCAFFOLD_COMMANDS = [
         root: "cwd",
         summary: "Refresh qmd collections after a sync",
     },
-    // ---- Reporting and utilities (live tree) ----
-    {
-        name: "codex-skill-bridge",
-        asset: "core/scripts/codex-skill-bridge.sh",
-        root: "live",
-        summary: "Install/inspect the Codex skill bridge",
-    },
 ];
 /**
  * Bundled solely for HQ-root scaffolds, which still need these as loose files.
@@ -197,6 +192,7 @@ export const SCAFFOLD_COMMANDS = [
  * direct `hq core` command.
  */
 export const SCAFFOLD_ONLY_ASSETS = [
+    { asset: "core/scripts/codex-skill-bridge.sh", root: "live", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/detect-stale-core-policy-mirror.sh", root: "live", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/hq-status-summary.sh", root: "cwd", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/ontology-readme-drift.sh", root: "live", summary: "Scaffold-only native utility companion" },

package/dist/lib/core-utils/codex-skill-bridge-entry.d.ts

@@ -0,0 +1,13 @@
+/** CLI adapter for the native Codex skill bridge. */
+import { type UtilityIo } from "./common.js";
+export type CodexSkillBridgeOptions = UtilityIo & {
+    root?: string;
+    home?: string;
+};
+/**
+ * Mirrors the shell entry point: usage on `--help` (exit 0) or a missing
+ * command (exit 1), single-line stderr plus exit 1 for refusals, and the
+ * unhealthy-check count as `status`/`install`'s exit code.
+ */
+export declare function runCodexSkillBridgeCommand(args?: string[], options?: CodexSkillBridgeOptions): number;
+//# sourceMappingURL=codex-skill-bridge-entry.d.ts.map

package/dist/lib/core-utils/codex-skill-bridge-entry.js

@@ -0,0 +1,48 @@
+/** CLI adapter for the native Codex skill bridge. */
+import { ioFor, line } from "./common.js";
+import { BridgeError, BridgeHelp, USAGE, parseArgs, runCodexSkillBridge, } from "./codex-skill-bridge.js";
+/**
+ * Mirrors the shell entry point: usage on `--help` (exit 0) or a missing
+ * command (exit 1), single-line stderr plus exit 1 for refusals, and the
+ * unhealthy-check count as `status`/`install`'s exit code.
+ */
+export function runCodexSkillBridgeCommand(args = [], options = {}) {
+    const { stdout, stderr } = ioFor(options);
+    const defaultRoot = options.root ?? process.env.HQ_ROOT ?? process.cwd();
+    const home = options.home ?? process.env.HOME ?? "";
+    let parsed;
+    try {
+        parsed = parseArgs(args, defaultRoot);
+    }
+    catch (error) {
+        if (error instanceof BridgeHelp) {
+            line(stdout, USAGE);
+            return 0;
+        }
+        if (error instanceof BridgeError) {
+            // An empty message is the shell's "no command given" path: usage, exit 1.
+            if (!error.message) {
+                line(stdout, USAGE);
+                return 1;
+            }
+            line(stderr, error.message);
+            return 1;
+        }
+        throw error;
+    }
+    try {
+        return runCodexSkillBridge(parsed, {
+            home,
+            out: (text) => line(stdout, text),
+            err: (text) => line(stderr, text),
+        });
+    }
+    catch (error) {
+        if (error instanceof BridgeError) {
+            line(stderr, error.message);
+            return 1;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=codex-skill-bridge-entry.js.map

package/dist/lib/core-utils/codex-skill-bridge.d.ts

@@ -0,0 +1,31 @@
+export type BridgeCommand = "status" | "install" | "doctor";
+export type BridgeOptions = {
+    command: BridgeCommand;
+    hqRoot: string;
+    oldRoots: string[];
+    repairLocalConfig: boolean;
+    dryRun: boolean;
+};
+export type BridgeIo = {
+    home: string;
+    out: (line: string) => void;
+    err: (line: string) => void;
+};
+/** Thrown for the shell's `fail`/refusal paths: message to stderr, exit 1. */
+export declare class BridgeError extends Error {
+    name: string;
+}
+export declare const USAGE = "Usage:\n  scripts/codex-skill-bridge.sh status [--root <path>]\n  scripts/codex-skill-bridge.sh install [--root <path>] [--repair-local-config] [--old-root <path>]\n  scripts/codex-skill-bridge.sh doctor [--root <path>] [--old-root <path>] [--dry-run]\n\nCommands:\n  status   Show bridge health, output-style bridge health, and stale HQ roots without changing files.\n  install  Install or repair HQ-owned Claude -> Codex bridges.\n  doctor   Repair bridges and rewrite local machine config from old HQ roots to this root.\n\nOptions:\n  --root <path>             HQ root to repair. Defaults to this script's parent.\n  --old-root <path>         Old HQ root to rewrite. Repeatable. Auto-detected when omitted.\n  --repair-local-config     With install, also rewrite local config paths.\n  --dry-run                 With doctor, print intended config rewrites without changing files.";
+/** Signals `--help`: caller prints usage and exits 0. */
+export declare class BridgeHelp extends Error {
+}
+export declare function parseArgs(argv: string[], defaultRoot: string): BridgeOptions;
+/** `strip_known_hq_subpath`: returns undefined when no known suffix matches. */
+export declare function stripKnownHqSubpath(target: string): string | undefined;
+/** `is_hq_root_like`: basename HQ, no brace placeholders, not the bare path. */
+export declare function isHqRootLike(candidate: string): boolean;
+/** `output_style_slug`: lowercase, collapse space/underscore, strip oddities. */
+export declare function outputStyleSlug(name: string): string;
+/** Runs one bridge command; returns the process exit code. */
+export declare function runCodexSkillBridge(options: BridgeOptions, io: BridgeIo): number;
+//# sourceMappingURL=codex-skill-bridge.d.ts.map

package/dist/lib/core-utils/codex-skill-bridge.js

@@ -0,0 +1,505 @@
+/**
+ * Native port of `core/scripts/codex-skill-bridge.sh`.
+ *
+ * The bridge symlinks HQ's `.claude` sources into the places Codex and the
+ * agents runtime look for them, and repairs links (and optionally local config
+ * paths) left pointing at an HQ root that has since moved.
+ *
+ * Every path derives from the resolved HQ root and `HOME`, so callers — and
+ * the differential suite — can exercise the whole surface hermetically.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Thrown for the shell's `fail`/refusal paths: message to stderr, exit 1. */
+export class BridgeError extends Error {
+    name = "BridgeError";
+}
+export const USAGE = `Usage:
+  scripts/codex-skill-bridge.sh status [--root <path>]
+  scripts/codex-skill-bridge.sh install [--root <path>] [--repair-local-config] [--old-root <path>]
+  scripts/codex-skill-bridge.sh doctor [--root <path>] [--old-root <path>] [--dry-run]
+
+Commands:
+  status   Show bridge health, output-style bridge health, and stale HQ roots without changing files.
+  install  Install or repair HQ-owned Claude -> Codex bridges.
+  doctor   Repair bridges and rewrite local machine config from old HQ roots to this root.
+
+Options:
+  --root <path>             HQ root to repair. Defaults to this script's parent.
+  --old-root <path>         Old HQ root to rewrite. Repeatable. Auto-detected when omitted.
+  --repair-local-config     With install, also rewrite local config paths.
+  --dry-run                 With doctor, print intended config rewrites without changing files.`;
+/** Signals `--help`: caller prints usage and exits 0. */
+export class BridgeHelp extends Error {
+}
+export function parseArgs(argv, defaultRoot) {
+    let command = "";
+    let hqRoot = defaultRoot;
+    const oldRoots = [];
+    let repairLocalConfig = false;
+    let dryRun = false;
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === "status" || arg === "install" || arg === "doctor") {
+            if (command)
+                throw new BridgeError("Only one command may be provided.");
+            command = arg;
+        }
+        else if (arg === "--root") {
+            if (index + 1 >= argv.length)
+                throw new BridgeError("--root requires a path.");
+            hqRoot = argv[++index];
+        }
+        else if (arg.startsWith("--root=")) {
+            hqRoot = arg.slice("--root=".length);
+        }
+        else if (arg === "--old-root") {
+            if (index + 1 >= argv.length)
+                throw new BridgeError("--old-root requires a path.");
+            oldRoots.push(argv[++index]);
+        }
+        else if (arg.startsWith("--old-root=")) {
+            oldRoots.push(arg.slice("--old-root=".length));
+        }
+        else if (arg === "--repair-local-config") {
+            repairLocalConfig = true;
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "-h" || arg === "--help") {
+            throw new BridgeHelp();
+        }
+        else {
+            throw new BridgeError(`Unknown argument: ${arg}`);
+        }
+    }
+    if (!command)
+        throw new BridgeError("");
+    return { command, hqRoot, oldRoots, repairLocalConfig, dryRun };
+}
+/** `canonical_dir`: the shell resolves via `cd … && pwd`, so symlinks collapse. */
+function canonicalDir(directory) {
+    return fs.realpathSync(directory);
+}
+function configurePaths(hqRootInput, home) {
+    const hqRoot = canonicalDir(hqRootInput);
+    const claudeSource = path.join(hqRoot, ".claude");
+    const projectCodexDir = path.join(hqRoot, ".codex");
+    const legacyCodexDir = path.join(hqRoot, ".Codex");
+    return {
+        hqRoot,
+        skillsSource: path.join(claudeSource, "skills"),
+        claudeSource,
+        commandsSource: path.join(claudeSource, "commands"),
+        hooksSource: path.join(claudeSource, "hooks"),
+        policiesSource: path.join(claudeSource, "policies"),
+        settingsFile: path.join(claudeSource, "settings.json"),
+        outputStylesSource: path.join(claudeSource, "output-styles"),
+        globalSkillsTarget: path.join(home, ".codex", "skills", "hq"),
+        globalAgentsSkillsTarget: path.join(home, ".agents", "skills", "hq"),
+        repoAgentsSkillsTarget: path.join(hqRoot, ".agents", "skills"),
+        projectCodexDir,
+        projectClaudeTarget: path.join(projectCodexDir, "claude"),
+        projectPromptsTarget: path.join(projectCodexDir, "prompts"),
+        projectOutputStyleTarget: path.join(projectCodexDir, "output-style.md"),
+        legacyCodexDir,
+        legacyClaudeTarget: path.join(legacyCodexDir, "claude"),
+        legacyPromptsTarget: path.join(legacyCodexDir, "prompts"),
+        legacyOutputStyleTarget: path.join(legacyCodexDir, "output-style.md"),
+    };
+}
+function isSymlink(target) {
+    try {
+        return fs.lstatSync(target).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** `[[ -e ]]`: follows links, so a dangling symlink is not "exists". */
+function exists(target) {
+    return fs.existsSync(target);
+}
+function listEntries(directory) {
+    try {
+        return fs.readdirSync(directory);
+    }
+    catch {
+        return [];
+    }
+}
+/** Directory or symlink child holding a SKILL.md, matching the shell's find. */
+function skillDirectories(skillsSource) {
+    return listEntries(skillsSource).filter((name) => {
+        const child = path.join(skillsSource, name);
+        let isDirOrLink = false;
+        try {
+            const stat = fs.lstatSync(child);
+            isDirOrLink = stat.isDirectory() || stat.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+        return isDirOrLink && fs.existsSync(path.join(child, "SKILL.md"));
+    });
+}
+function markdownFiles(directory) {
+    return listEntries(directory).filter((name) => {
+        if (!name.endsWith(".md"))
+            return false;
+        try {
+            return fs.lstatSync(path.join(directory, name)).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function plainFiles(directory) {
+    return listEntries(directory).filter((name) => {
+        try {
+            return fs.lstatSync(path.join(directory, name)).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * `normalize_link_target`: absolute targets pass through; relative ones resolve
+ * against the link's directory, with existing paths canonicalised.
+ */
+function normalizeLinkTarget(target) {
+    const linkTarget = fs.readlinkSync(target);
+    if (path.isAbsolute(linkTarget))
+        return linkTarget;
+    const targetDir = canonicalDir(path.dirname(target));
+    const resolved = path.join(targetDir, linkTarget);
+    if (fs.existsSync(resolved)) {
+        if (fs.statSync(resolved).isDirectory())
+            return canonicalDir(resolved);
+        return path.join(canonicalDir(path.dirname(resolved)), path.basename(resolved));
+    }
+    return resolved;
+}
+/** `strip_known_hq_subpath`: returns undefined when no known suffix matches. */
+export function stripKnownHqSubpath(target) {
+    const outputStyle = target.match(/^(.*)\/\.claude\/output-styles\/[^/]*\.md$/);
+    if (outputStyle)
+        return outputStyle[1];
+    for (const suffix of ["/.claude/skills", "/.claude/commands", "/.claude"]) {
+        if (target.endsWith(suffix))
+            return target.slice(0, -suffix.length);
+    }
+    return undefined;
+}
+/** `is_hq_root_like`: basename HQ, no brace placeholders, not the bare path. */
+export function isHqRootLike(candidate) {
+    if (candidate.includes("{") || candidate.includes("}"))
+        return false;
+    if (candidate === "/Documents/HQ")
+        return false;
+    return path.basename(candidate) === "HQ";
+}
+function activeOutputStyleName(paths) {
+    let contents;
+    try {
+        contents = fs.readFileSync(paths.settingsFile, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    // The shell greps line-wise and keeps the LAST match.
+    let match;
+    for (const line of contents.split("\n")) {
+        const found = line.match(/"outputStyle"[ \t]*:[ \t]*"([^"]*)"/);
+        if (found)
+            match = found[1];
+    }
+    return match;
+}
+/** `output_style_slug`: lowercase, collapse space/underscore, strip oddities. */
+export function outputStyleSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[ \t\n_]+/g, "-")
+        .replace(/[^a-z0-9.-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-/, "")
+        .replace(/-$/, "");
+}
+function resolveOutputStyleSourceFile(paths) {
+    const styleName = activeOutputStyleName(paths);
+    if (!styleName)
+        return undefined;
+    const source = path.join(paths.outputStylesSource, `${outputStyleSlug(styleName)}.md`);
+    try {
+        if (!fs.lstatSync(source).isFile())
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return source;
+}
+/** `bridge_target_is_repairable`: same suffix under a different HQ-like root. */
+function bridgeTargetIsRepairable(currentTarget, source, hqRoot) {
+    const expectedSuffix = source.startsWith(hqRoot) ? source.slice(hqRoot.length) : source;
+    const targetRoot = stripKnownHqSubpath(currentTarget);
+    if (!targetRoot)
+        return false;
+    if (!isHqRootLike(targetRoot))
+        return false;
+    if (targetRoot === hqRoot)
+        return false;
+    return currentTarget.slice(targetRoot.length) === expectedSuffix;
+}
+function printLinkStatus(io, state, paths, label, source, target) {
+    io.out(`${label}:`);
+    io.out(`  source: ${source}`);
+    io.out(`  target: ${target}`);
+    if (isSymlink(target)) {
+        const resolvedTarget = normalizeLinkTarget(target);
+        io.out("  bridge: installed");
+        io.out(`  points to: ${resolvedTarget}`);
+        if (resolvedTarget === source) {
+            io.out("  status: healthy");
+        }
+        else if (bridgeTargetIsRepairable(resolvedTarget, source, paths.hqRoot)) {
+            io.out("  status: stale HQ root (repairable)");
+            state.failures += 1;
+        }
+        else {
+            io.out("  status: unexpected target");
+            state.failures += 1;
+        }
+    }
+    else if (exists(target)) {
+        io.out("  bridge: blocked");
+        io.out("  status: target exists and is not a symlink");
+        state.failures += 1;
+    }
+    else {
+        io.out("  bridge: not installed");
+        state.failures += 1;
+    }
+}
+function repairOrCreateSymlink(io, options, paths, label, source, target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (isSymlink(target)) {
+        const resolvedTarget = normalizeLinkTarget(target);
+        if (resolvedTarget === source) {
+            io.out(`${label} already installed.`);
+            return;
+        }
+        if (bridgeTargetIsRepairable(resolvedTarget, source, paths.hqRoot)) {
+            if (options.dryRun) {
+                io.out(`Would repair ${label}: ${resolvedTarget} -> ${source}`);
+                return;
+            }
+            fs.unlinkSync(target);
+            fs.symlinkSync(source, target);
+            io.out(`Repaired ${label}: ${resolvedTarget} -> ${source}`);
+            return;
+        }
+        throw new BridgeError(`Refusing to replace existing symlink: ${target} -> ${resolvedTarget}`);
+    }
+    if (exists(target)) {
+        throw new BridgeError(`Refusing to overwrite existing path: ${target}`);
+    }
+    if (options.dryRun) {
+        io.out(`Would install ${label}: ${target} -> ${source}`);
+        return;
+    }
+    fs.symlinkSync(source, target);
+    io.out(`Installed ${label}.`);
+}
+function configFiles(paths) {
+    return [
+        path.join(paths.hqRoot, ".mcp.json"),
+        path.join(paths.claudeSource, "settings.json"),
+        path.join(paths.claudeSource, "settings.local.json"),
+        path.join(paths.projectCodexDir, "config.toml"),
+        path.join(paths.legacyCodexDir, "config.toml"),
+    ].filter((file) => {
+        try {
+            return fs.statSync(file).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** `extract_hq_roots_from_file`: absolute paths ending in `/HQ` or `/HQ/`. */
+function extractHqRootsFromFile(file) {
+    let contents;
+    try {
+        contents = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const matches = contents.match(/\/[^"\s]+\/HQ(\/|$)/gm) ?? [];
+    return matches.map((match) => (match.endsWith("/") ? match.slice(0, -1) : match));
+}
+function collectStaleRoots(paths, options, includeExplicit) {
+    const roots = [];
+    if (includeExplicit) {
+        for (const root of options.oldRoots)
+            if (root)
+                roots.push(root);
+    }
+    for (const target of [
+        paths.globalSkillsTarget,
+        paths.globalAgentsSkillsTarget,
+        paths.repoAgentsSkillsTarget,
+        paths.projectClaudeTarget,
+        paths.projectPromptsTarget,
+        paths.projectOutputStyleTarget,
+        paths.legacyClaudeTarget,
+        paths.legacyPromptsTarget,
+        paths.legacyOutputStyleTarget,
+    ]) {
+        if (!isSymlink(target))
+            continue;
+        const stripped = stripKnownHqSubpath(normalizeLinkTarget(target));
+        if (stripped)
+            roots.push(stripped);
+    }
+    for (const file of configFiles(paths))
+        roots.push(...extractHqRootsFromFile(file));
+    // `sort -u` then filter, matching the shell's ordering exactly.
+    return [...new Set(roots)]
+        .sort()
+        .filter((root) => root && root !== paths.hqRoot && isHqRootLike(root));
+}
+function printStaleRootReport(io, paths, options) {
+    const roots = collectStaleRoots(paths, options, false);
+    if (roots.length === 0) {
+        io.out("Stale HQ roots: none detected");
+        return;
+    }
+    io.out("Stale HQ roots detected:");
+    for (const root of roots)
+        io.out(`  - ${root}`);
+}
+function rewriteLocalConfigRoots(io, paths, options) {
+    const roots = collectStaleRoots(paths, options, true);
+    if (roots.length === 0) {
+        io.out("No stale local config roots to rewrite.");
+        return;
+    }
+    let rewroteAny = false;
+    for (const file of configFiles(paths)) {
+        let changedFile = false;
+        for (const oldRoot of roots) {
+            if (!oldRoot)
+                continue;
+            let contents = fs.readFileSync(file, "utf8");
+            if (!contents.includes(oldRoot))
+                continue;
+            if (options.dryRun) {
+                io.out(`Would rewrite ${file}: ${oldRoot} -> ${paths.hqRoot}`);
+                continue;
+            }
+            contents = contents.split(oldRoot).join(paths.hqRoot);
+            fs.writeFileSync(file, contents);
+            changedFile = true;
+        }
+        if (changedFile) {
+            io.out(`Rewrote local config paths in ${file}.`);
+            rewroteAny = true;
+        }
+    }
+    if (!rewroteAny && !options.dryRun)
+        io.out("No local config files needed rewriting.");
+}
+function printOutputStyleStatus(io, state, paths) {
+    const styleName = activeOutputStyleName(paths);
+    io.out(`Active output style: ${styleName || "not configured"}`);
+    const source = resolveOutputStyleSourceFile(paths);
+    if (source) {
+        printLinkStatus(io, state, paths, "Project Codex output-style bridge", source, paths.projectOutputStyleTarget);
+        if (exists(paths.legacyCodexDir) || isSymlink(paths.legacyOutputStyleTarget)) {
+            io.out("");
+            printLinkStatus(io, state, paths, "Legacy .Codex output-style bridge", source, paths.legacyOutputStyleTarget);
+        }
+        return;
+    }
+    io.out("Project Codex output-style bridge:");
+    io.out("  source: unavailable");
+    io.out(`  target: ${paths.projectOutputStyleTarget}`);
+    io.out("  status: active output style has no .claude/output-styles/*.md bridge source");
+    state.failures += 1;
+}
+/** Returns the shell's status exit code: the number of unhealthy checks. */
+function printStatus(io, paths, options) {
+    const skillTotal = skillDirectories(paths.skillsSource).length;
+    const skillWith = skillDirectories(paths.skillsSource).filter((name) => fs.existsSync(path.join(paths.skillsSource, name, "agents", "openai.yaml"))).length;
+    const state = { failures: 0 };
+    io.out(`HQ Claude source: ${paths.claudeSource}`);
+    io.out(`Skills in source: ${skillTotal} (${skillWith} with agents/openai.yaml, ${skillTotal - skillWith} without)`);
+    io.out(`Hooks in source: ${plainFiles(paths.hooksSource).length}`);
+    io.out(`Policies in source: ${markdownFiles(paths.policiesSource).length}`);
+    io.out("");
+    printLinkStatus(io, state, paths, "Global skills bridge (legacy)", paths.skillsSource, paths.globalSkillsTarget);
+    io.out("");
+    printLinkStatus(io, state, paths, "Global agents skills bridge", paths.skillsSource, paths.globalAgentsSkillsTarget);
+    io.out("");
+    printLinkStatus(io, state, paths, "Repo agents skills bridge", paths.skillsSource, paths.repoAgentsSkillsTarget);
+    io.out("");
+    printLinkStatus(io, state, paths, "Project Claude mirror", paths.claudeSource, paths.projectClaudeTarget);
+    io.out("");
+    printOutputStyleStatus(io, state, paths);
+    if (exists(paths.legacyCodexDir) ||
+        isSymlink(paths.legacyClaudeTarget) ||
+        isSymlink(paths.legacyPromptsTarget)) {
+        io.out("");
+        printLinkStatus(io, state, paths, "Legacy .Codex Claude mirror", paths.claudeSource, paths.legacyClaudeTarget);
+    }
+    io.out("");
+    printStaleRootReport(io, paths, options);
+    return state.failures;
+}
+function validateSources(paths) {
+    if (!fs.existsSync(paths.skillsSource) || !fs.statSync(paths.skillsSource).isDirectory()) {
+        throw new BridgeError(`Missing skills source directory: ${paths.skillsSource}`);
+    }
+    if (!fs.existsSync(paths.claudeSource) || !fs.statSync(paths.claudeSource).isDirectory()) {
+        throw new BridgeError(`Missing Claude source directory: ${paths.claudeSource}`);
+    }
+}
+function installBridge(io, paths, options) {
+    validateSources(paths);
+    const outputStyleSource = resolveOutputStyleSourceFile(paths);
+    if (!outputStyleSource) {
+        throw new BridgeError(`Active outputStyle must have a matching ${paths.outputStylesSource}/<style>.md file.`);
+    }
+    repairOrCreateSymlink(io, options, paths, "global Codex skill bridge (legacy)", paths.skillsSource, paths.globalSkillsTarget);
+    repairOrCreateSymlink(io, options, paths, "global agents skill bridge", paths.skillsSource, paths.globalAgentsSkillsTarget);
+    repairOrCreateSymlink(io, options, paths, "repo agents skill bridge", paths.skillsSource, paths.repoAgentsSkillsTarget);
+    repairOrCreateSymlink(io, options, paths, "project Codex Claude mirror", paths.claudeSource, paths.projectClaudeTarget);
+    repairOrCreateSymlink(io, options, paths, "project Codex output-style bridge", outputStyleSource, paths.projectOutputStyleTarget);
+    if (exists(paths.legacyCodexDir) ||
+        isSymlink(paths.legacyClaudeTarget) ||
+        isSymlink(paths.legacyPromptsTarget)) {
+        repairOrCreateSymlink(io, options, paths, "legacy .Codex Claude mirror", paths.claudeSource, paths.legacyClaudeTarget);
+        repairOrCreateSymlink(io, options, paths, "legacy .Codex output-style bridge", outputStyleSource, paths.legacyOutputStyleTarget);
+    }
+    if (options.repairLocalConfig) {
+        io.out("");
+        rewriteLocalConfigRoots(io, paths, options);
+    }
+    io.out("");
+    return printStatus(io, paths, options);
+}
+/** Runs one bridge command; returns the process exit code. */
+export function runCodexSkillBridge(options, io) {
+    const paths = configurePaths(options.hqRoot, io.home);
+    if (options.command === "status")
+        return printStatus(io, paths, options);
+    const effective = options.command === "doctor" ? { ...options, repairLocalConfig: true } : options;
+    return installBridge(io, paths, effective);
+}
+//# sourceMappingURL=codex-skill-bridge.js.map

package/package.json

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