@indigoai-us/hq-cli 5.331.0 → 5.332.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+## [5.332.0] — 2026-10-02
+- Match macOS shell behavior in native core commands for text, diagnostics, and file modes.
+- `hq mcp status` now recognizes the real Claude plugin MCP definition and Codex PATH commands, while global and `hq-anywhere` pack installs share one Codex hook per event and one `hq` MCP server.
+
 ## [5.331.0] — 2026-10-02
 - Prevent duplicate Claude hook dispatch inside the HQ root when global hooks are installed.
 

package/assets/scaffold/core/scripts/policy-age-report.sh

@@ -51,6 +51,33 @@ done
 [ "${#DIRS[@]}" -gt 0 ] || DIRS=("$HQ_ROOT/personal/policies" "$HQ_ROOT/core/policies")
 command -v jq >/dev/null 2>&1 || { echo "policy-age-report: jq required" >&2; exit 2; }
 NOW_EPOCH="${HQ_POLICY_REPORT_NOW_EPOCH:-$(date +%s)}"
+if [ -n "${HQ_POLICY_REPORT_NOW_EPOCH:-}" ]; then
+  CLOCK_INPUT="$HQ_POLICY_REPORT_NOW_EPOCH"
+  if [[ ! "$CLOCK_INPUT" =~ ^[+-]?[0-9]+$ ]]; then
+    printf 'policy-age-report: HQ_POLICY_REPORT_NOW_EPOCH must be an integer: %s\n' "$CLOCK_INPUT" >&2
+    exit 1
+  fi
+  CLOCK_NEGATIVE=0
+  CLOCK_DIGITS="$CLOCK_INPUT"
+  case "$CLOCK_DIGITS" in
+    -*) CLOCK_NEGATIVE=1; CLOCK_DIGITS="${CLOCK_DIGITS#-}" ;;
+    +*) CLOCK_DIGITS="${CLOCK_DIGITS#+}" ;;
+  esac
+  while [[ "${#CLOCK_DIGITS}" -gt 1 && "${CLOCK_DIGITS:0:1}" = 0 ]]; do
+    CLOCK_DIGITS="${CLOCK_DIGITS:1}"
+  done
+  CLOCK_LIMIT=9223372036854775807
+  [ "$CLOCK_NEGATIVE" = 1 ] && CLOCK_LIMIT=9223372036854775808
+  if [[ "${#CLOCK_DIGITS}" -gt "${#CLOCK_LIMIT}" ]] || { [[ "${#CLOCK_DIGITS}" -eq "${#CLOCK_LIMIT}" ]] && (LC_ALL=C; [[ "$CLOCK_DIGITS" > "$CLOCK_LIMIT" ]]); }; then
+    printf 'policy-age-report: HQ_POLICY_REPORT_NOW_EPOCH must be an integer: %s\n' "$CLOCK_INPUT" >&2
+    exit 1
+  fi
+  if [ "$CLOCK_NEGATIVE" = 1 ]; then
+    NOW_EPOCH=$((0 - 10#$CLOCK_DIGITS))
+  else
+    NOW_EPOCH=$((10#$CLOCK_DIGITS))
+  fi
+fi
 TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
 
 # One pass over every ledger: slug<TAB>mtime, then reduce to count + max mtime.

package/dist/commands/core-derive-trigger-facts-native.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { runBundledScript } from "../utils/run-bundled-script.js";
+import { isByteOrientedLocale } from "../lib/core-utils/byte-oriented-locale.js";
 export const DERIVE_TRIGGER_FACTS_ASSET = "core/scripts/derive-trigger-facts.sh";
 const TEXT_FACT_AWK = "core/scripts/lib/trigger-fact-text.awk";
 const TRANSCRIPT_TAIL_MAX_BYTES = 1_048_576;
@@ -19,8 +20,7 @@ function asciiLower(value) {
     return value.replace(/[A-Z]/g, (letter) => String.fromCharCode(letter.charCodeAt(0) + 32));
 }
 function localeLower(value, env) {
-    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "C";
-    if (/^(?:C|POSIX)(?:$|\.(?!utf-?8$))/i.test(locale))
+    if (isByteOrientedLocale(env, process.platform))
         return asciiLower(value);
     // glibc applies towlower independently to each character. Lowercase code
     // points separately so JavaScript does not apply context-sensitive sigma.

package/dist/commands/core-hq-session-native.js

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
+import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 export const HQ_SESSION_ASSET = "core/scripts/hq-session.sh";
 export const HQ_SESSION_HELP = [
     "hq-core: public",
@@ -483,7 +484,7 @@ export function executeHqSession(argv, context, overrides = {}) {
         }
         catch (error) {
             if (error?.code === "EACCES" || error?.code === "EPERM") {
-                return { code: 2, stdout: "", stderr: `awk: fatal: cannot open file \`${metaPath}' for reading: Permission denied\n` };
+                return { code: 2, stdout: "", stderr: awkCannotOpenFileDiagnostic(metaPath, "Permission denied", 6, process.platform, deps.env.PATH) };
             }
             if (isExpectedFsMiss(error))
                 return { code: 1, stdout: "", stderr: `awk: cannot open ${metaPath} (Permission denied)\n` };

package/dist/commands/core-migrate-policy-triggers-native.js

@@ -5,6 +5,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { evaluateTrigger } from "../utils/core-eval-trigger.js";
+import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 export const MIGRATE_POLICY_TRIGGERS_ASSET = "core/scripts/migrate-policy-triggers.sh";
 const ON_LIVE = "[PreToolUse, PostToolUse, UserPromptSubmit, AssistantIntent]";
 const ON_START = "[SessionStart]";
@@ -151,9 +152,11 @@ function deriveWhen(trigger, rawTags, enforcementRaw) {
 }
 function writeAtomic(fileSystem, target, bytes) {
     const temporary = path.join(path.dirname(target), `.migrate-policy-triggers.${process.pid}.${Math.random().toString(16).slice(2)}`);
+    // The shell writes through mktemp, whose private mode survives the rename on both platforms.
+    const mode = 0o600;
     try {
-        fileSystem.writeFileSync(temporary, bytes, { encoding: "utf8", mode: 0o600, flag: "wx" });
-        fileSystem.chmodSync(temporary, 0o600);
+        fileSystem.writeFileSync(temporary, bytes, { encoding: "utf8", mode, flag: "wx" });
+        fileSystem.chmodSync(temporary, mode);
         fileSystem.renameSync(temporary, target);
         return true;
     }
@@ -165,11 +168,11 @@ function writeAtomic(fileSystem, target, bytes) {
         return false;
     }
 }
-function unreadablePolicyDiagnostic(filename, error) {
+function unreadablePolicyDiagnostic(filename, error, pathValue) {
     const code = error.code;
     const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : "No such file or directory";
     const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/migrate-policy-triggers.sh");
-    const awk = `awk: fatal: cannot open file \`${filename}' for reading: ${message}\n`;
+    const awk = awkCannotOpenFileDiagnostic(filename, message, 1, process.platform, pathValue);
     return `${script}: line 314: ${filename}: ${message}\n${awk.repeat(3)}`;
 }
 function shellGlobMd(fileSystem, directory) {
@@ -293,7 +296,7 @@ export function runMigratePolicyTriggers(args, deps) {
                     original = fileSystem.readFileSync(filename, "utf8");
                 }
                 catch (error) {
-                    stderr += unreadablePolicyDiagnostic(filename, error);
+                    stderr += unreadablePolicyDiagnostic(filename, error, deps.env.PATH);
                     untriggered += 1;
                     continue;
                 }

package/dist/commands/core-policy.js

@@ -8,6 +8,7 @@ import { resolveLiveRoot, resolveBundledAsset } from '../utils/hq-roots.js';
 import { runBundledScript } from '../utils/run-bundled-script.js';
 import { describeCoreCommand } from './core-command-catalog.js';
 import { runPolicyFrontmatter as runPolicyFrontmatterImpl } from './core-policy-frontmatter.js';
+import { awkCannotOpenFileDiagnostic } from '../lib/core-utils/awk-diagnostics.js';
 const POLICY_AGE_REPORT_ASSET = 'core/scripts/policy-age-report.sh';
 const POLICY_RETIRE_ASSET = 'core/scripts/policy-retire.sh';
 const POLICY_FRONTMATTER_ASSET = 'core/scripts/read-policy-frontmatter.sh';
@@ -266,7 +267,7 @@ function epochFromDate(value) {
         return 0;
     return Math.floor(parsed / 1000);
 }
-function countLedgerRows(directory, withMtime, recursive) {
+function countLedgerRows(directory, withMtime, recursive, awkPath) {
     const counts = new Map();
     const newest = new Map();
     let anyFiles = false;
@@ -299,7 +300,7 @@ function countLedgerRows(directory, withMtime, recursive) {
             catch (error) {
                 const code = error.code;
                 if (withMtime && (code === 'EACCES' || code === 'EPERM')) {
-                    stderr += `awk: fatal: cannot open file \`${full}' for reading: Permission denied\n`;
+                    stderr += awkCannotOpenFileDiagnostic(full, 'Permission denied', 1, process.platform, awkPath);
                     continue;
                 }
                 if (expectedFsMiss(error))
@@ -391,12 +392,11 @@ export function runPolicyAgeReport(args, root, env = process.env, nowEpoch = Mat
             const epoch = bashInteger(env.HQ_POLICY_REPORT_NOW_EPOCH);
             if (epoch === undefined) {
                 const value = env.HQ_POLICY_REPORT_NOW_EPOCH;
-                if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
-                    throw new Error(`${resolveBundledAsset(POLICY_AGE_REPORT_ASSET)}: line 96: ${value}: unbound variable`);
-                }
-                throw new Error(`${resolveBundledAsset(POLICY_AGE_REPORT_ASSET)}: line 96: ${value}: invalid arithmetic value`);
+                throw new Error(`policy-age-report: HQ_POLICY_REPORT_NOW_EPOCH must be an integer: ${value}`);
+            }
+            else {
+                now = Number(epoch);
             }
-            now = Number(epoch);
         }
     }
     catch (error) {
@@ -404,8 +404,9 @@ export function runPolicyAgeReport(args, root, env = process.env, nowEpoch = Mat
     }
     const ledgerDir = env.HQ_POLICY_LEDGER_DIR || path.join(root, 'workspace/orchestrator/policy-trigger-state');
     const retrievalDir = env.HQ_POLICY_RETRIEVAL_LEDGER_DIR || path.join(root, 'workspace/orchestrator/policy-retrieval-state');
-    const usage = countLedgerRows(ledgerDir, true, true);
-    const retrieval = countLedgerRows(retrievalDir, false, false);
+    const awkPath = env.PATH ?? '/usr/bin:/bin';
+    const usage = countLedgerRows(ledgerDir, true, true, awkPath);
+    const retrieval = countLedgerRows(retrievalDir, false, false, awkPath);
     const dirs = parsed.dirs.length > 0 ? parsed.dirs : [path.join(root, 'personal/policies'), path.join(root, 'core/policies')];
     const rows = [];
     let stderr = usage.stderr + retrieval.stderr;
@@ -439,13 +440,13 @@ export function runPolicyAgeReport(args, root, env = process.env, nowEpoch = Mat
             const singleIncident = ['user-correction', 'session-learning', 'back-pressure-failure'].includes(source) && (version || '1') === '1';
             const classes = [];
             if (fired === 0) {
-                const comparison = bashTestGreaterOrEqual(ageDays, parsed.minAge, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 130);
+                const comparison = bashTestGreaterOrEqual(ageDays, parsed.minAge, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 157);
                 stderr += comparison.stderr;
                 if (comparison.value && usage.anyFiles)
                     classes.push('never-fired');
             }
             if (fired > 0) {
-                const comparison = bashTestGreaterOrEqual(lastAge, parsed.dormantDays, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 131);
+                const comparison = bashTestGreaterOrEqual(lastAge, parsed.dormantDays, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 158);
                 stderr += comparison.stderr;
                 if (comparison.value)
                     classes.push('dormant');
@@ -455,7 +456,7 @@ export function runPolicyAgeReport(args, root, env = process.env, nowEpoch = Mat
             if (refs.renamed.length > 0)
                 classes.push('renamed-refs');
             if (singleIncident) {
-                const comparison = bashTestGreaterOrEqual(ageDays, parsed.incidentDays, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 135);
+                const comparison = bashTestGreaterOrEqual(ageDays, parsed.incidentDays, resolveBundledAsset(POLICY_AGE_REPORT_ASSET), 162);
                 stderr += comparison.stderr;
                 if (comparison.value && fired <= 1)
                     classes.push('single-incident-old');

package/dist/commands/core-resolve-company-native.js

@@ -2,6 +2,7 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
 export const RESOLVE_COMPANY_HELP = [
     "hq-core: public",
@@ -36,7 +37,7 @@ function readFile(filePath, fileSystem) {
         throw error;
     }
 }
-function readManifest(filePath, fileSystem) {
+function readManifest(filePath, fileSystem, pathValue) {
     try {
         return fileSystem.readFileSync(filePath, "utf8");
     }
@@ -46,7 +47,7 @@ function readManifest(filePath, fileSystem) {
             return {
                 code: 0,
                 stdout: Buffer.from('{"company":"","source":"none"}\n'),
-                stderr: Buffer.from("awk: fatal: cannot open file `" + filePath + "' for reading: Permission denied\n"),
+                stderr: Buffer.from(awkCannotOpenFileDiagnostic(filePath, "Permission denied", 1, process.platform, pathValue)),
             };
         }
         if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP")
@@ -340,7 +341,7 @@ export async function resolveCompany(args, dependencies) {
     const manifest = path.join(root, "companies/manifest.yaml");
     if (!isFile(manifest, fileSystem))
         return output("", "none");
-    const manifestResult = readManifest(manifest, fileSystem);
+    const manifestResult = readManifest(manifest, fileSystem, env.PATH ?? "/usr/bin:/bin");
     if (typeof manifestResult !== "string")
         return manifestResult;
     const manifestText = manifestResult;

package/dist/commands/core-share-suggestion-state-native.d.ts

@@ -13,6 +13,7 @@ export type ShareSuggestionDependencies = {
     fs?: Pick<typeof fs, "existsSync" | "statSync" | "readFileSync" | "writeFileSync" | "appendFileSync" | "renameSync" | "unlinkSync" | "mkdirSync">;
     now?: () => Date;
     stdinIsTty?: boolean;
+    platform?: NodeJS.Platform;
 };
 export declare function runShareSuggestionState(args: readonly string[], stdin: string, deps: ShareSuggestionDependencies): HookHelperOutput;
 //# sourceMappingURL=core-share-suggestion-state-native.d.ts.map

package/dist/commands/core-share-suggestion-state-native.js

@@ -1,6 +1,7 @@
 /** Native port of share-suggestion-state.sh; kept dependency-light for hooks. */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { isByteOrientedLocale } from "../lib/core-utils/byte-oriented-locale.js";
 export const SHARE_SUGGESTION_STATE_ASSET = "core/scripts/share-suggestion-state.sh";
 const isObj = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const sortKeys = (value) => Array.isArray(value) ? value.map(sortKeys)
@@ -148,6 +149,7 @@ export function runShareSuggestionState(args, stdin, deps) {
     if (!root)
         return failFromShellMain("share-suggestion-state: unable to resolve HQ root\n");
     const { fileSystem: f, env, isoNow } = makeContext(deps);
+    const platform = deps.platform ?? process.platform;
     const stateHome = path.join(root, "workspace/orchestrator/share-suggestions");
     const historyPath = path.join(stateHome, "history.jsonl");
     const suppressionsPath = path.join(stateHome, "suppressions.jsonl");
@@ -169,10 +171,20 @@ export function runShareSuggestionState(args, stdin, deps) {
             catch { /* locate the first existing non-directory parent when present */ }
         }
         const reason = code === "ENOTDIR" ? "Not a directory" : code === "EACCES" || code === "EPERM" ? "Permission denied" : code === "EEXIST" ? "File exists" : (error instanceof Error ? error.message : String(error));
-        return failFromShellMain(`mkdir: cannot create directory ‘${blockedPath}’: ${reason}\nshare-suggestion-state: unable to create state directory\n`);
+        const mkdirError = platform === "darwin"
+            ? `mkdir: ${blockedPath}: ${reason}\n`
+            : `mkdir: cannot create directory ‘${blockedPath}’: ${reason}\n`;
+        return failFromShellMain(`${mkdirError}share-suggestion-state: unable to create state directory\n`);
     }
-    const sessionBytes = Buffer.from(rawSession, "utf8");
-    const sessionId = Array.from(sessionBytes, (byte) => byte === 45 || byte === 95 || (byte >= 48 && byte <= 57) || (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122) ? String.fromCharCode(byte) : "_").join("") || "unknown";
+    const sessionUnits = platform === "darwin" && !isByteOrientedLocale(env, platform)
+        ? Array.from(rawSession)
+        : Buffer.from(rawSession, "utf8");
+    const sessionId = Array.from(sessionUnits, (unit) => {
+        const code = typeof unit === "number" ? unit : unit.codePointAt(0);
+        return code === 45 || code === 95 || (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
+            ? String.fromCharCode(code)
+            : "_";
+    }).join("") || "unknown";
     const pendingPath = path.join(stateHome, `${sessionId}.json`);
     // Bash command substitution removes every trailing LF before exporting the payload.
     const payloadRaw = deps.stdinIsTty ? "" : stdin.replace(/\n+$/, "");

package/dist/commands/install-global.js

@@ -11,7 +11,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { spawnSync } from 'node:child_process';
-import { buildCodexServerDef, claudeConfigFormat, codexConfigFormat, isCodexInstalled, jsonFormat, mergeCodexServer, registerCodexServer, unregisterCodexServer, mergeClaudeServer, readConfigDoc, realpathOrSelf, registerClaudeServer, resolveEnv, unregisterClaudeServer, writeConfigAtomic, } from './mcp-registration.js';
+import { buildCodexServerDef, claudeConfigFormat, codexConfigFormat, codexRemovalFormat, isCodexInstalled, jsonFormat, mergeCodexServer, removeCodexServer, registerCodexServer, unregisterCodexServer, mergeClaudeServer, readConfigDoc, realpathOrSelf, registerClaudeServer, resolveEnv, unregisterClaudeServer, writeConfigAtomic, } from './mcp-registration.js';
 import { seedRegistryFromHqRoot } from './link.js';
 import { resolveHqRoot } from './doctor.js';
 import { anywhereRuntimeEnabled, AnywhereRuntimeDisabledError } from './anywhere-runtime-flag.js';
@@ -685,8 +685,14 @@ export function installGlobalCodex(opts) {
     const hooksNext = addCodexHooks(hooksDoc, hqRoot, hookTarget);
     const tomlOld = readOrNull(t.configToml);
     const tomlDoc = readConfigDoc(t.configToml, codexConfigFormat).doc;
+    const codexServers = tomlDoc.value.mcp_servers;
+    const legacyPackServerPresent = codexServers?.['hq-anywhere']?._hqPack === HQ_ANYWHERE_PACK;
     // Collision check runs here too, so a dry run surfaces a conflicting "hq" server.
-    const tomlNext = mergeCodexServer(HQ_MCP_SERVER_NAME, buildCodexServerDef(manifest, HQ_ANYWHERE_PACK, () => null, new Set()))(tomlDoc);
+    const codexDef = buildCodexServerDef(manifest, HQ_ANYWHERE_PACK, () => null, new Set());
+    const migrationBase = legacyPackServerPresent
+        ? codexConfigFormat.parse(codexRemovalFormat.serialize(removeCodexServer('hq-anywhere', HQ_ANYWHERE_PACK)(tomlDoc)))
+        : tomlDoc;
+    const tomlNext = mergeCodexServer(HQ_MCP_SERVER_NAME, codexDef)(migrationBase);
     if (pointerOld !== pointerNew)
         touched.push(hqPointer);
     if (mdOld !== mdNew)
@@ -697,7 +703,7 @@ export function installGlobalCodex(opts) {
         touched.push(path.join(t.skillsDir, `${SKILL_LINK_PREFIX}${s}`));
     if (hooksNext !== hooksDoc)
         touched.push(t.hooksJson);
-    if (tomlNext !== tomlDoc)
+    if (tomlNext !== tomlDoc || legacyPackServerPresent)
         touched.push(t.configToml);
     touched.push(regFile, t.stateFile);
     if (opts.dryRun) {
@@ -746,6 +752,9 @@ export function installGlobalCodex(opts) {
         assertName: 'hooks',
         env: { home },
     });
+    if (legacyPackServerPresent) {
+        unregisterCodexServer({ name: 'hq-anywhere', pack: HQ_ANYWHERE_PACK, env: { home } });
+    }
     registerCodexServer({ name: HQ_MCP_SERVER_NAME, manifest, pack: HQ_ANYWHERE_PACK, env: { home } });
     let seeded = [];
     let ownedSeeded = [];
@@ -792,14 +801,15 @@ export function uninstallGlobalCodex(opts = {}) {
         throw new Error('No HQ global install found (no install state and no ~/.hq/root).');
     const regFile = opts.registryFile ?? registryFile(registryDir(home, env));
     const claudeStillInstalled = fs.existsSync(claudeTargets(home).stateFile);
+    const packStillInstalled = fs.existsSync(path.join(hqRoot, 'core', 'packages', 'hq-anywhere', 'package.yaml'));
     const touched = [];
     const tomlDoc = readConfigDoc(t.configToml, codexConfigFormat).doc;
     const servers = tomlDoc.value.mcp_servers;
-    if (servers?.[HQ_MCP_SERVER_NAME]?._hqPack === HQ_ANYWHERE_PACK)
+    if (!packStillInstalled && servers?.[HQ_MCP_SERVER_NAME]?._hqPack === HQ_ANYWHERE_PACK)
         touched.push(t.configToml);
     const hooksOriginal = state ? state.hooks.original : null;
     const hooksDoc = readConfigDoc(t.hooksJson, jsonFormat).doc;
-    const hooksNext = removeCodexHooks(hooksDoc, hqRoot);
+    const hooksNext = packStillInstalled ? hooksDoc : removeCodexHooks(hooksDoc, hqRoot);
     if (hooksNext !== hooksDoc)
         touched.push(t.hooksJson);
     const source = hqSkillsSource(hqRoot);
@@ -848,7 +858,8 @@ export function uninstallGlobalCodex(opts = {}) {
         log(lineDiff(jsonFormat.serialize(hooksDoc), jsonFormat.serialize(hooksNext)));
         return touched;
     }
-    unregisterCodexServer({ name: HQ_MCP_SERVER_NAME, pack: HQ_ANYWHERE_PACK, env: { home } });
+    if (!packStillInstalled)
+        unregisterCodexServer({ name: HQ_MCP_SERVER_NAME, pack: HQ_ANYWHERE_PACK, env: { home } });
     // Removal re-serializes the TOML (dropping comments). When what is left equals
     // the pre-install document, put the original bytes back.
     const tomlOriginal = state?.configToml.original ?? null;
@@ -858,12 +869,12 @@ export function uninstallGlobalCodex(opts = {}) {
             writeFileAtomic(realpathOrSelf(t.configToml), tomlOriginal);
         }
     }
-    if (fs.existsSync(t.hooksJson)) {
+    if (!packStillInstalled && fs.existsSync(t.hooksJson)) {
         writeConfigAtomic({
             target: t.hooksJson,
             pack: HQ_ANYWHERE_PACK,
-            format: restoringRemovalFormat(hooksOriginal, (doc) => removeCodexHooks(doc, hqRoot) !== doc),
-            merge: (doc) => removeCodexHooks(doc, hqRoot),
+            format: restoringRemovalFormat(hooksOriginal, (doc) => (packStillInstalled ? doc : removeCodexHooks(doc, hqRoot)) !== doc),
+            merge: (doc) => packStillInstalled ? doc : removeCodexHooks(doc, hqRoot),
             assertName: 'hooks',
             env: { home },
         });

package/dist/commands/mcp-registration.d.ts

@@ -529,6 +529,8 @@ export interface RegisterServerOptions {
      * injected `env.home`, so in tests it lands in the tmpdir — never the real ~/.
      */
     audit?: boolean;
+    /** Preserve the globally installed Codex HQ endpoint while still registering Claude. */
+    preserveCodex?: boolean;
 }
 /** Outcome of registering one server into one surface. */
 export interface RegisterSurfaceResult {
@@ -645,6 +647,8 @@ export declare function registerMcpServers(pkg: string, names: string[], options
      * Omitted → read `HQ_DISABLE_MCP_REGISTRATION` directly.
      */
     registrationEnabled?: boolean;
+    /** Preserve the global Codex HQ endpoint when the same pack also wires Claude. */
+    preserveCodex?: boolean;
 }): RegisterServerResult[];
 /** smol-toml's value-table type (its `parse` return + `stringify` input). */
 type TomlTable = Record<string, unknown>;
@@ -825,6 +829,8 @@ export interface UnregisterServerOptions {
      * that call {@link unregisterClaudeServer}/{@link unregisterCodexServer} directly.
      */
     audit?: boolean;
+    /** Keep the shared Codex hq endpoint while the global installer still owns it. */
+    preserveCodex?: boolean;
 }
 /**
  * Un-register ONE server from the PINNED single Claude surface (top-level
@@ -924,6 +930,7 @@ export declare function unregisterMcpServers(pkg: string, names: string[], optio
     /** Lock tuning + backup stamp passthrough (tests). */
     lock?: AcquireLockOptions;
     stamp?: string;
+    preserveCodex?: boolean;
 }): UnregisterServerResult[];
 export {};
 //# sourceMappingURL=mcp-registration.d.ts.map

package/dist/commands/mcp-registration.js

@@ -1177,7 +1177,9 @@ export function registerServer(opts) {
     const codexPrevHash = audit ? hashFileContents(codexTarget) : '';
     let codex;
     try {
-        codex = registerCodexServer(opts);
+        codex = opts.preserveCodex
+            ? { skipped: true, reason: 'shared global install owns Codex hq endpoint' }
+            : registerCodexServer(opts);
     }
     catch (e) {
         if (audit) {
@@ -1302,6 +1304,7 @@ export function registerMcpServers(pkg, names, options) {
             env: options?.env,
             lock: options?.lock,
             stamp: options?.stamp,
+            preserveCodex: options?.preserveCodex && pkg === 'hq-anywhere' && name === 'hq',
         });
     });
 }
@@ -2113,7 +2116,9 @@ export function unregisterServer(opts) {
     const codexPrevHash = audit ? hashFileContents(codexTarget) : '';
     let codex;
     try {
-        codex = unregisterCodexServer(opts);
+        codex = opts.preserveCodex
+            ? { skipped: true, reason: 'Codex hq endpoint remains owned by the global install' }
+            : unregisterCodexServer(opts);
     }
     catch (e) {
         if (audit) {
@@ -2242,6 +2247,7 @@ export function unregisterMcpServers(pkg, names, options) {
             env: options?.env,
             lock: options?.lock,
             stamp: options?.stamp,
+            preserveCodex: options?.preserveCodex,
         });
     });
 }

package/dist/commands/mcp-status.js

@@ -23,8 +23,9 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { isExecutableOnPath } from '../utils/resolve-executable.js';
 import { anywhereRuntimeEnabled } from './anywhere-runtime-flag.js';
-import { claudeTargets } from '../lib/install/claude-targets.js';
+import { claudeTargets, MCP_SUBPROCESS_PATH } from '../lib/install/claude-targets.js';
 import { HQ_PACK_PROVENANCE_KEY, SECRET_REDACTION, backupRoot, claudeConfigFormat, claudeConfigPath, codexConfigFormat, codexConfigPath, CODEX_MCP_SERVERS_KEY, ConfigParseError, isCodexInstalled, readConfigDoc, resolveEnv, } from './mcp-registration.js';
 // ---------------------------------------------------------------------------
 // Pure status computation.
@@ -40,7 +41,11 @@ function provenanceOf(def) {
 }
 /** The transport string off a def (`type`), or '' when not a string. */
 function transportOf(def) {
-    return typeof def.type === 'string' ? def.type : '';
+    if (typeof def.type === 'string')
+        return def.type;
+    // Claude Code's plugin .mcp.json omits `type` for command-backed servers;
+    // both Claude and Codex interpret that shape as stdio.
+    return typeof def.command === 'string' ? 'stdio' : '';
 }
 /**
  * The target off a def — url (http/sse) or command(+args) (stdio). NEVER a
@@ -124,9 +129,15 @@ function findAnywherePluginMcp(home) {
 function pluginAndCodexMcpEquivalent(plugin, codex) {
     const pArgs = Array.isArray(plugin.args) ? plugin.args : [];
     const cArgs = Array.isArray(codex.args) ? codex.args : [];
-    const pluginTarget = plugin.type === 'stdio' && plugin.command === '/bin/sh' && pArgs.length === 3 && pArgs[0] === '${CLAUDE_PLUGIN_ROOT}/scripts/hq-claude-plugin-launch.sh' && pArgs[1] === 'mcp' && pArgs[2] === 'serve';
-    const codexTarget = codex.type === 'stdio' && typeof codex.command === 'string' && /(^|\/)hq$/.test(codex.command) && cArgs.length === 2 && cArgs[0] === 'mcp' && cArgs[1] === 'serve';
-    return pluginTarget && codexTarget && JSON.stringify(headerKeysOf(plugin)) === JSON.stringify(headerKeysOf(codex)) && JSON.stringify(envKeysOf(plugin)) === JSON.stringify(envKeysOf(codex));
+    const pluginTarget = transportOf(plugin) === 'stdio' && plugin.command === '/bin/sh' && pArgs.length === 3 && pArgs[0] === '${CLAUDE_PLUGIN_ROOT}/scripts/hq-claude-plugin-launch.sh' && pArgs[1] === 'mcp' && pArgs[2] === 'serve';
+    const bareOrAbsoluteHq = typeof codex.command === 'string' && /(^|[\\/])hq(?:\.exe)?$/.test(codex.command) && cArgs.length === 2 && cArgs[0] === 'mcp' && cArgs[1] === 'serve';
+    const globalNodeEntry = typeof codex.command === 'string' && path.isAbsolute(codex.command) && /(^|[\\/])node(?:\.exe)?$/.test(codex.command) && cArgs.length === 3 && typeof cArgs[0] === 'string' && path.isAbsolute(cArgs[0]) && cArgs[1] === 'mcp' && cArgs[2] === 'serve';
+    const codexTarget = transportOf(codex) === 'stdio' && (bareOrAbsoluteHq || globalNodeEntry);
+    const pluginEnv = plugin.env && typeof plugin.env === 'object' ? plugin.env : {};
+    const codexEnv = codex.env && typeof codex.env === 'object' ? codex.env : {};
+    const envMatch = JSON.stringify(envKeysOf(plugin)) === JSON.stringify(envKeysOf(codex)) ||
+        (globalNodeEntry && Object.keys(pluginEnv).length === 0 && Object.keys(codexEnv).length === 1 && codexEnv.PATH === MCP_SUBPROCESS_PATH);
+    return pluginTarget && codexTarget && JSON.stringify(headerKeysOf(plugin)) === JSON.stringify(headerKeysOf(codex)) && envMatch;
 }
 /** Scan the Claude runtime: read `~/.claude.json`, collect HQ-owned servers. */
 function scanClaude(env) {
@@ -208,12 +219,15 @@ function isLaunchable(def) {
     if (transportOf(def) !== 'stdio')
         return true;
     const command = def.command;
-    if (typeof command !== 'string' || !path.isAbsolute(command) || !fs.existsSync(command)) {
+    if (typeof command !== 'string' || !commandIsLaunchable(command))
         return false;
-    }
     const args = Array.isArray(def.args) ? def.args : [];
     return args.every((a) => typeof a !== 'string' || !path.isAbsolute(a) || fs.existsSync(a));
 }
+/** Codex resolves bare MCP commands through the host process PATH. */
+function commandIsLaunchable(command) {
+    return isExecutableOnPath(command);
+}
 /** List the most-recent backup dir names under `backupRoot` (newest first, capped). */
 function recentBackups(env) {
     const root = backupRoot(env);

package/dist/commands/pack-install.d.ts

@@ -336,6 +336,24 @@ export declare function confirmMcp(pkg: PackManifest, payloadDir: string, allowM
  * authorization response. No cached value is a fallback.
  */
 export declare function makeInstallSecretResolver(secretNames: string[], company?: string): Promise<SecretResolver>;
+/**
+ * Register one pack's `contributes.mcp` servers into the shared Claude/Codex
+ * agent configs, PER SERVER, so a single unresolvable `${secret:NAME}` defers
+ * ONLY that server instead of aborting the whole install. Returns the registered
+ * and skipped (deferred) server-name lists for the one-line summary.
+ *
+ * Per-server policy:
+ *   - SUCCESS                       → push to `registered`.
+ *   - McpManifestError matching
+ *     `/cannot resolve \$\{secret:/` → SKIP (push to `skipped`), warn on stderr,
+ *     install still succeeds (the key gets minted later, then a re-install wires it).
+ *   - ANY OTHER error               → RE-THROW (abort install). Only the
+ *     unresolvable-secret case is swallowed.
+ */
+export declare function wireMcpServers(pkg: PackManifest, destDir: string, company?: string): Promise<{
+    registered: string[];
+    skipped: string[];
+}>;
 /**
  * Install the fetched payload to `<hqRoot>/core/packages/<pkg.name>/` (HQ
  * v12+ layout). The HQ template (`hq-core` / `hq-core-staging`) ships

package/dist/commands/pack-install.js

@@ -46,13 +46,14 @@ import semverValid from 'semver/functions/valid.js';
 import semverValidRange from 'semver/ranges/valid.js';
 import semverGt from 'semver/functions/gt.js';
 import { findHqRoot } from '../utils/manifest.js';
-import { readHqVersion, routeContribution, listInstalledPacks } from '../utils/pack-contributions.js';
+import { codexTargets } from '../lib/install/codex-targets.js';
+import { readHqVersion, routeContribution, listInstalledPacks, mcpServerNameForContribution } from '../utils/pack-contributions.js';
 import { CONTRIBUTION_TABLE, payloadFor } from '../utils/contribution-table.js';
 import { safeExtractTarball } from './safe-extract.js';
 import { getCompanyUid, vaultApiFetch, vaultApiFetchPublic, } from '../utils/vault-api.js';
 import { ensureCognitoToken } from '../utils/cognito-session.js';
 import { formatApiKeyCapabilityDenial, peekHqApiKey, } from '../utils/resolve-vault-credential.js';
-import { redactSecrets, SECRET_REDACTION, isMcpRegistrationEnabled, registerMcpServers, McpManifestError, } from './mcp-registration.js';
+import { redactSecrets, SECRET_REDACTION, codexConfigFormat, codexConfigPath, isMcpRegistrationEnabled, registerMcpServers, readConfigDoc, unregisterMcpServers, McpManifestError, } from './mcp-registration.js';
 import { listSecretCacheScopes } from '../utils/secrets-cache.js';
 import { loadRevealedSecrets } from './secrets.js';
 import { syncCodexPackHooks, syncCodexPackSkills } from '../lib/install/codex-pack-contributions.js';
@@ -1492,7 +1493,7 @@ function extractDeferredSecretName(message) {
  *   - ANY OTHER error               → RE-THROW (abort install). Only the
  *     unresolvable-secret case is swallowed.
  */
-async function wireMcpServers(pkg, destDir, company) {
+export async function wireMcpServers(pkg, destDir, company) {
     const loadManifest = (name) => loadMcpManifestFrom(destDir, name);
     const registered = [];
     const skipped = [];
@@ -1501,14 +1502,29 @@ async function wireMcpServers(pkg, destDir, company) {
     const registrationEnabled = isMcpRegistrationEnabled();
     for (const name of pkg.contributes.mcp ?? []) {
         try {
+            // The reserved hq-anywhere pack shares the global `hq` endpoint. Remove
+            // the pre-pairing alias left by older installs before registering `hq`.
+            const registrationName = mcpServerNameForContribution(pkg.name, name);
+            const codexHome = process.env.HOME ?? os.homedir();
+            const globalStatePresent = pkg.name === 'hq-anywhere' && fs.existsSync(codexTargets(codexHome).stateFile);
+            const codexDoc = globalStatePresent ? readConfigDoc(codexConfigPath({ home: codexHome }), codexConfigFormat).doc : undefined;
+            const codexServers = codexDoc?.value.mcp_servers;
+            const globalCodexOwnsHq = globalStatePresent && codexServers?.hq?._hqPack === pkg.name;
             const resolveSecret = await makeInstallSecretResolver(collectManifestSecretNames(loadManifest(name)), company);
             // Per-server call: registerMcpServers throws on the FIRST unresolvable
             // secret, so calling it one name at a time lets us catch + continue.
-            const results = registerMcpServers(pkg.name, [name], {
-                loadManifest,
+            const results = registerMcpServers(pkg.name, [registrationName], {
+                loadManifest: (registeredName) => loadManifest(registeredName === registrationName ? name : registeredName),
                 resolveSecret,
                 registrationEnabled,
+                preserveCodex: globalCodexOwnsHq,
             });
+            // Only retire the pre-pairing alias after the canonical registration has
+            // been written to Codex. A kill switch, absent Codex runtime, or deferred
+            // secret must leave the prior working entry untouched.
+            if (registrationName !== name && results.some((result) => !('skipped' in result.codex) || (globalCodexOwnsHq && result.codex.reason === 'shared global install owns Codex hq endpoint'))) {
+                unregisterMcpServers(pkg.name, [name]);
+            }
             if (results.length > 0)
                 registered.push(name);
         }
@@ -1763,7 +1779,7 @@ export async function installPack(source, opts = {}) {
         const codexHome = process.env.HOME ?? os.homedir();
         const packHooks = pkg.contributes.hooks ?? [];
         const skillWarnings = syncCodexPackSkills(destDir, pkg.name, pkg.contributes.skills ?? [], false, codexHome);
-        syncCodexPackHooks(destDir, packHooks, false, codexHome);
+        syncCodexPackHooks(destDir, packHooks, false, codexHome, hqRoot, pkg.name);
         for (const warning of skillWarnings)
             say(chalk.yellow(`  ! ${warning}`));
         // US-007 — register `contributes.mcp` servers into the shared Claude/Codex

package/dist/commands/packs.js

@@ -18,6 +18,7 @@
  */
 import * as fs from 'fs';
 import * as os from 'os';
+import { codexTargets } from '../lib/install/codex-targets.js';
 import * as path from 'path';
 import * as readline from 'readline';
 import { spawnSync } from 'child_process';
@@ -252,7 +253,7 @@ async function runUpdate(name, opts) {
             // Remove Codex registrations and skills from the old manifest before the
             // pack directory is replaced. The replacement may rename its commands or
             // drop contributions entirely, so the new manifest cannot clean those.
-            syncCodexPackHooks(pack.dir, m.contributes?.hooks ?? [], true);
+            syncCodexPackHooks(pack.dir, m.contributes?.hooks ?? [], true, process.env.HOME ?? os.homedir(), hqRoot, pname);
             syncCodexPackSkills(pack.dir, pname, m.contributes?.skills ?? [], true);
             // Un-wire old contributions first so a contribution dropped by the new
             // version doesn't leave a dangling host symlink. installPack re-wires.
@@ -314,7 +315,7 @@ async function runUninstall(name, opts) {
     // marker/absolute command still points at this pack.
     try {
         const home = process.env.HOME ?? os.homedir();
-        syncCodexPackHooks(packDir, contributes.hooks ?? [], true, home);
+        syncCodexPackHooks(packDir, contributes.hooks ?? [], true, home, hqRoot, name);
         warnings.push(...syncCodexPackSkills(packDir, name, contributes.skills ?? [], true, home));
     }
     catch (e) {
@@ -325,7 +326,12 @@ async function runUninstall(name, opts) {
     // pack's `_hqPack`, and skip-and-warns on any foreign/unstamped same-named entry.
     // Tolerant of a Codex-less host / absent config; idempotent on re-run.
     try {
-        const mcp = unwirePackMcp(name, contributes);
+        const home = process.env.HOME ?? os.homedir();
+        const globalCodexState = codexTargets(home).stateFile;
+        const mcp = unwirePackMcp(name, contributes, {
+            env: { home },
+            preserveCodex: name === 'hq-anywhere' && fs.existsSync(globalCodexState),
+        });
         for (const server of mcp.servers) {
             if ('skipped' in server.claude)
                 continue; // (claude is always inspected; never skipped)

package/dist/lib/core-utils/awk-diagnostics.d.ts

@@ -0,0 +1,2 @@
+export declare function awkCannotOpenFileDiagnostic(filename: string, reason: string, sourceLine?: number, platform?: NodeJS.Platform, pathValue?: string | undefined): string;
+//# sourceMappingURL=awk-diagnostics.d.ts.map

package/dist/lib/core-utils/awk-diagnostics.js

@@ -0,0 +1,39 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * The bundled shell companions emit awk's open-file diagnostic. GNU awk and
+ * the BSD awk shipped by macOS format that diagnostic differently. Prefer
+ * the executable selected by PATH; macOS runners can put GNU awk ahead of the
+ * system awk.
+ */
+function usesGnuAwk(pathValue, platform) {
+    for (const directory of (pathValue ?? "/usr/bin:/bin").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        const candidate = path.join(directory, "awk");
+        try {
+            if (!fs.statSync(candidate).isFile())
+                continue;
+            fs.accessSync(candidate, fs.constants.X_OK);
+            const resolved = fs.realpathSync(candidate);
+            if (/^gawk(?:[-.]|$)/i.test(path.basename(resolved)))
+                return true;
+            if (resolved.split(path.sep).some((segment) => /^gawk(?:[-.]|$)/i.test(segment)))
+                return true;
+            // Some runners expose GNU awk under the generic name `awk`.
+            if (fs.readFileSync(resolved).includes(Buffer.from("GNU Awk")))
+                return true;
+            return platform !== "darwin";
+        }
+        catch {
+            // execvp continues through PATH entries that lack an executable awk.
+        }
+    }
+    return platform !== "darwin";
+}
+export function awkCannotOpenFileDiagnostic(filename, reason, sourceLine = 1, platform = process.platform, pathValue = process.env.PATH) {
+    if (!usesGnuAwk(pathValue, platform))
+        return `awk: can't open file ${filename}\n source line number ${sourceLine}\n`;
+    return `awk: fatal: cannot open file \`${filename}' for reading: ${reason}\n`;
+}
+//# sourceMappingURL=awk-diagnostics.js.map

package/dist/lib/core-utils/byte-oriented-locale.d.ts

@@ -0,0 +1,5 @@
+type LocaleEnvironment = Partial<Pick<NodeJS.ProcessEnv, "LC_ALL" | "LC_CTYPE" | "LANG">>;
+/** Whether the effective locale makes the shell's character classes byte-oriented. */
+export declare function isByteOrientedLocale(env: LocaleEnvironment, platform?: NodeJS.Platform, localeDirectory?: string): boolean;
+export {};
+//# sourceMappingURL=byte-oriented-locale.d.ts.map

package/dist/lib/core-utils/byte-oriented-locale.js

@@ -0,0 +1,23 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+function macLocaleIsRecognized(locale, localeDirectory) {
+    // Locale names accepted by macOS are backed by LC_CTYPE data in this directory.
+    // Keep the complete libc locale name intact; Intl's locale database is unrelated.
+    if (locale.includes("/"))
+        return false;
+    return fs.existsSync(path.join(localeDirectory, locale, "LC_CTYPE"));
+}
+/** Whether the effective locale makes the shell's character classes byte-oriented. */
+export function isByteOrientedLocale(env, platform = process.platform, localeDirectory = "/usr/share/locale") {
+    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    if (!locale)
+        return true;
+    if (/^(?:C|POSIX)$/i.test(locale) || /^C@/i.test(locale))
+        return true;
+    if (platform === "darwin")
+        return !macLocaleIsRecognized(locale, localeDirectory);
+    if (/^(?:C|POSIX)\./i.test(locale))
+        return !/^\w+\.utf-?8$/i.test(locale);
+    return false;
+}
+//# sourceMappingURL=byte-oriented-locale.js.map

package/dist/lib/install/codex-pack-contributions.d.ts

@@ -2,7 +2,7 @@ type Doc = Record<string, unknown>;
 export declare function syncCodexPackSkills(packDir: string, packName: string, names: string[], remove?: boolean, home?: string): string[];
 export declare function mergeCodexPackHooks(doc: Doc, packDir: string, items: string[]): Doc;
 export declare function removeCodexPackHooks(doc: Doc, packDir: string, items: string[]): Doc;
-export declare function syncCodexPackHooks(packDir: string, items: string[], remove?: boolean, home?: string): void;
+export declare function syncCodexPackHooks(packDir: string, items: string[], remove?: boolean, home?: string, hqRoot?: string, packName?: string): void;
 export declare function readCodexPackHooks(target: string): Doc;
 export {};
 //# sourceMappingURL=codex-pack-contributions.d.ts.map

package/dist/lib/install/codex-pack-contributions.js

@@ -3,6 +3,8 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { anywhereRuntimeEnabled } from '../../commands/anywhere-runtime-flag.js';
 import { jsonFormat, readConfigDoc, writeConfigAtomic } from '../../commands/mcp-registration.js';
+import { hookTargetFor } from '../../commands/install-global.js';
+import { addCodexHooks, codexTargets, removeCodexHooks } from './codex-targets.js';
 const configFormat = {
     parse: jsonFormat.parse,
     serialize: jsonFormat.serialize,
@@ -186,14 +188,35 @@ function removeCommands(hooks, commands) {
             delete hooks[event];
     }
 }
-export function syncCodexPackHooks(packDir, items, remove = false, home = os.homedir()) {
+export function syncCodexPackHooks(packDir, items, remove = false, home = os.homedir(), hqRoot, packName = 'hq-anywhere') {
     assertContributionNames(items);
     if ((!remove && !anywhereRuntimeEnabled()) || !fs.existsSync(path.join(home, '.codex')))
         return;
     const codexItems = items.filter((item) => fs.existsSync(path.join(packDir, 'hooks', `${item}-hooks.json`)));
     if (codexItems.length === 0)
         return;
+    const sharedAnywherePack = packName === 'hq-anywhere';
+    const sharedGlobalInstall = sharedAnywherePack && fs.existsSync(codexTargets(home).stateFile);
+    // The global Codex installer owns the canonical command while its state is
+    // present. The pack still contributes skills/MCP, but must not register a
+    // second hook or remove the shared hook during pack uninstall/update.
+    if (sharedGlobalInstall)
+        return;
     const target = hooksPath(home);
+    if (hqRoot && sharedAnywherePack) {
+        const hookTarget = hookTargetFor(hqRoot, home);
+        writeConfigAtomic({
+            target,
+            pack: 'hq-anywhere',
+            format: configFormat,
+            merge: (doc) => remove
+                ? removeCodexHooks(removeCodexPackHooks(doc, packDir, codexItems), hqRoot)
+                : addCodexHooks(removeCodexPackHooks(doc, packDir, codexItems), hqRoot, hookTarget),
+            assertName: remove ? `hooks-remove:${path.resolve(hqRoot)}${path.sep}` : codexItems[0],
+            env: { home },
+        });
+        return;
+    }
     writeConfigAtomic({
         target, pack: 'hq-anywhere', format: configFormat,
         merge: (doc) => remove ? removeCodexPackHooks(doc, packDir, codexItems) : mergeCodexPackHooks(doc, packDir, codexItems),

package/dist/lib/install/codex-targets.js

@@ -93,7 +93,9 @@ function isAdapterEntry(entry, hqRoot) {
         return false;
     const cmd = entry.command;
     return (typeof cmd === 'string' &&
-        (cmd.includes(JSON.stringify(codexAdapterPath(hqRoot))) || cmd.includes(JSON.stringify(shimPath(hqRoot)))));
+        (cmd.includes(JSON.stringify(codexAdapterPath(hqRoot))) ||
+            cmd.includes(JSON.stringify(shimPath(hqRoot))) ||
+            cmd.includes(JSON.stringify(path.join(hqRoot, 'core', 'packages', 'hq-anywhere', 'hooks', 'codex.sh')))));
 }
 /**
  * Add one HQ hook group per event; idempotent. An HQ entry for the other

package/dist/utils/pack-contributions.d.ts

@@ -54,6 +54,8 @@ export type { WireMode };
  * rather than relying on `linkFor` happening to return `null`.
  */
 export declare function routeContribution(key: PackContributeKey): WireMode;
+/** Keep the reserved hq-anywhere pack on the same user-visible MCP name as global HQ. */
+export declare function mcpServerNameForContribution(packName: string, contributionName: string): string;
 /**
  * The subset of a pack's declared `contributes` keys that are `wire: 'merge'`
  * (e.g. `mcp`) — the keys that MUST be routed to `registerMcpServers` (US-006)
@@ -142,6 +144,8 @@ export interface UnwirePackMcpOptions {
     lock?: AcquireLockOptions;
     /** Backup timestamp override (deterministic tests). */
     stamp?: string;
+    /** Keep the shared Codex `hq` endpoint when global Codex install state remains. */
+    preserveCodex?: boolean;
 }
 /**
  * Un-register the `wire: 'merge'` (MCP) servers a pack declares — the parallel to

package/dist/utils/pack-contributions.js

@@ -60,6 +60,10 @@ export { CONTRIBUTION_TABLE };
 export function routeContribution(key) {
     return CONTRIBUTION_TABLE[key].wire;
 }
+/** Keep the reserved hq-anywhere pack on the same user-visible MCP name as global HQ. */
+export function mcpServerNameForContribution(packName, contributionName) {
+    return packName === 'hq-anywhere' && contributionName === 'hq-anywhere' ? 'hq' : contributionName;
+}
 /**
  * The subset of a pack's declared `contributes` keys that are `wire: 'merge'`
  * (e.g. `mcp`) — the keys that MUST be routed to `registerMcpServers` (US-006)
@@ -333,14 +337,26 @@ export function unwirePack(hqRoot, packDir, contributes) {
 export function unwirePackMcp(packName, contributes, options) {
     const servers = [];
     for (const key of mergeKeys(contributes)) {
-        const names = (contributes[key] ?? []).filter((n) => typeof n === 'string' && n.length > 0);
-        if (names.length === 0)
+        const declaredNames = (contributes[key] ?? []).filter((n) => typeof n === 'string' && n.length > 0);
+        if (declaredNames.length === 0)
             continue;
-        servers.push(...unregisterMcpServers(packName, names, {
-            env: options?.env,
-            lock: options?.lock,
-            stamp: options?.stamp,
-        }));
+        for (const declaredName of declaredNames) {
+            const registeredName = mcpServerNameForContribution(packName, declaredName);
+            if (registeredName !== declaredName) {
+                // Remove the prior pack-only alias from older installs during upgrade/uninstall.
+                servers.push(...unregisterMcpServers(packName, [declaredName], {
+                    env: options?.env,
+                    lock: options?.lock,
+                    stamp: options?.stamp,
+                }));
+            }
+            servers.push(...unregisterMcpServers(packName, [registeredName], {
+                env: options?.env,
+                lock: options?.lock,
+                stamp: options?.stamp,
+                preserveCodex: options?.preserveCodex && packName === 'hq-anywhere' && registeredName === 'hq',
+            }));
+        }
     }
     return { servers };
 }

package/dist/utils/resolve-executable.d.ts

@@ -0,0 +1,3 @@
+export declare function executableCandidates(command: string, pathValue?: string, platform?: NodeJS.Platform, pathExt?: string): string[];
+export declare function isExecutableOnPath(command: string, pathValue?: string, platform?: NodeJS.Platform, pathExt?: string): boolean;
+//# sourceMappingURL=resolve-executable.d.ts.map

package/dist/utils/resolve-executable.js

@@ -0,0 +1,23 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function executableCandidates(command, pathValue = process.env.PATH ?? '', platform = process.platform, pathExt = process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM') {
+    const extensions = platform === 'win32'
+        ? (pathExt || '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+        : [''];
+    const candidates = path.isAbsolute(command)
+        ? [command]
+        : pathValue.split(platform === 'win32' ? ';' : path.delimiter).filter(Boolean).flatMap((directory) => extensions.map((extension) => path.join(directory, `${command}${extension}`)));
+    return candidates;
+}
+export function isExecutableOnPath(command, pathValue = process.env.PATH ?? '', platform = process.platform, pathExt = process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM') {
+    return executableCandidates(command, pathValue, platform, pathExt).some((candidate) => {
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return fs.statSync(candidate).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+//# sourceMappingURL=resolve-executable.js.map

package/package.json

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