@indigoai-us/hq-cli 5.345.47 → 5.345.49

package/dist/commands/lanes-message.js

@@ -13,7 +13,7 @@ import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { findRetiredLaneEntry, keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { isTerminalLaneState } from "../lib/lanes/types.js";
-import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
+import { readLanesRegistryFlag, readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
 import { appendLaneFocusOverride, focusGuardRefusal, makeFocusOverride } from "../lib/lanes/focus-guard.js";
 import { appendProjectFocusOverride, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
@@ -192,7 +192,7 @@ export function createLaneMessageHandlers(deps) {
                 : "superseded";
         }
         if (exclusion === "superseded" && currentLane.state !== "done" && currentLane.state !== "interrupted") {
-            const runningSupersededMessageDeliveryEnabled = await readLanesRegistryFlag(LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, { company: companyForLane(currentLane), env: ctx.env });
+            const runningSupersededMessageDeliveryEnabled = await readLanesRegistryFlagFailOpen(LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, { company: companyForLane(currentLane), env: ctx.env });
             if (runningSupersededMessageDeliveryEnabled) {
                 const latestLane = readLane(ctx.hqRoot(), currentLane.lane_id);
                 if (latestLane.state === "killed" || latestLane.state === "cancelled") {

package/dist/commands/lanes.js

@@ -36,7 +36,7 @@ import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
-import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
+import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
 import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
@@ -1898,7 +1898,7 @@ async function resolveMessageLaneTarget(ctx, laneId) {
                 const localOverride = readLanesFlagLocalOverride(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, ctx.env);
                 return localOverride ?? "check-company";
             }
-            return readLanesRegistryFlag(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, {
+            return readLanesRegistryFlagFailOpen(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, {
                 company,
                 env: ctx.env,
             });

package/dist/commands/mcp-serve.js

@@ -16,12 +16,16 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { CLI_VERSION } from "../cli-version.js";
 import { HQ_ANYWHERE_RUNTIME_FLAG } from "../lib/anywhere-runtime-flag-key.js";
-import { anywhereRuntimeAllowed } from "../lib/anywhere-person-setting.js";
 import { createLineSplitter, HqdClientError, hqdRequest, hqdSocketPath } from "../lib/daemon/protocol.js";
 import { releaseCurrentPackageUseLease, releasePackageUseLeaseAfterResidentPreload } from "../utils/package-use-lease.js";
 import { preloadResidentPackageModules, reportResidentPackagePreloadFailure, RESIDENT_PACKAGE_MODULES } from "../utils/resident-package-preload.js";
 export const MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
 const UNREACHABLE_CODES = new Set(["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE", "ETIMEDOUT", "ESOCKET", "EACCES"]);
+function hasPersonTokenCache(env, home) {
+    // Mirrors personTokenCacheFile() in utils/cognito-session.ts; duplicated so this path does not load that module.
+    const stateDir = env.HQ_STATE_DIR?.trim() || path.join(home, ".hq");
+    return fs.existsSync(path.join(stateDir, "cognito-tokens.json"));
+}
 /** HQ root for prompts: HQ_ROOT, else the ~/.hq/root pointer written by `hq install --global`. */
 export function readHqRoot(env, home) {
     const fromEnv = env.HQ_ROOT?.trim();
@@ -54,9 +58,18 @@ export async function runMcpServe(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const socketPath = hqdSocketPath(home, env);
     const timeoutMs = opts.timeoutMs ?? 120_000;
-    if (!(await (opts.runtimeAllowed ?? (() => anywhereRuntimeAllowed(env, {
-        onError: (name) => process.stderr.write(`HQ Anywhere person setting unavailable (${name}); access remains off.\n`),
-    })))())) {
+    const runtimeAllowed = opts.runtimeAllowed ?? (async () => {
+        // A person token is required to read the opt-in setting. Deny a fresh
+        // install before loading the hq-flags and Cognito readers.
+        if (!hasPersonTokenCache(env, home))
+            return false;
+        const { anywhereRuntimeAllowed } = await import("../lib/anywhere-person-setting.js");
+        return anywhereRuntimeAllowed(env, {
+            home,
+            onError: (name) => process.stderr.write(`HQ Anywhere person setting unavailable (${name}); access remains off.\n`),
+        });
+    });
+    if (!(await runtimeAllowed())) {
         process.stderr.write(`HQ Anywhere is not enabled. The ${HQ_ANYWHERE_RUNTIME_FLAG} flag and your HQ Anywhere person setting must both be on.\n`);
         process.exitCode = 1;
         return;

package/dist/commands/secrets.d.ts

@@ -2,6 +2,11 @@ import type { Command } from "commander";
 export { buildSecretUsage, emitEnvExportsAndExit, loadRevealedSecrets, parseSecretNameList, runSecretsEnvCommand, } from "../secrets-env-action.js";
 export type { SecretLoadResponse, SecretScriptLockMode, SecretTier, SecretUsage, SecretUsageChannel } from "../secrets-env-action.js";
 export type { SecretScriptUsage, SecretMetadata, SecretLoadSuccessRow } from "../secrets-env-action.js";
+type SessionCompanyLock = {
+    sessionId: string;
+    companies: string[];
+} | undefined;
+export declare function readSessionCompanyLock(env?: NodeJS.ProcessEnv): SessionCompanyLock;
 import { vaultApiFetch, getCompanyUid, getEntityUid } from "../utils/vault-api.js";
 export type { VaultApiOptions } from "../utils/vault-api.js";
 export { vaultApiFetch, getCompanyUid, getEntityUid };

package/dist/commands/secrets.js

@@ -1,9 +1,153 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
 import { buildSecretUsage, extractApiMessage, highSecuritySandboxOnlyMessage, loadRevealedSecrets, normalizeScriptLockMode, normalizeSecretTier, parseSecretNameList, runSecretsEnvCommand, scopeOpts, secretsCredentialOptions, } from "../secrets-env-action.js";
 export { buildSecretUsage, emitEnvExportsAndExit, loadRevealedSecrets, parseSecretNameList, runSecretsEnvCommand, } from "../secrets-env-action.js";
+export function readSessionCompanyLock(env = process.env) {
+    const root = resolveDefaultHqRoot({ env });
+    const sessionId = resolveSessionId(root, env);
+    if (!sessionId)
+        return undefined;
+    const sessionDir = path.join(root, "workspace/sessions", sessionId);
+    const capabilityPath = path.join(sessionDir, "scope-capability.json");
+    const metaPath = path.join(sessionDir, "meta.yaml");
+    let primary;
+    let companies;
+    let hasCapability = false;
+    try {
+        fs.lstatSync(capabilityPath);
+        hasCapability = true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTDIR")
+            throw new Error("Cannot verify this session's company lock because its scope capability is unreadable.");
+    }
+    if (hasCapability) {
+        let value;
+        try {
+            value = JSON.parse(fs.readFileSync(capabilityPath, "utf8"));
+        }
+        catch {
+            throw new Error("Cannot verify this session's company lock because its scope capability is unreadable.");
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Cannot verify this session's company lock because its scope capability is invalid.");
+        const cap = value;
+        if (cap.session_id !== sessionId)
+            throw new Error("Cannot verify this session's company lock because its scope capability does not match the active session.");
+        if (typeof cap.company_slug !== "string" || !/^[A-Za-z0-9_-]+$/.test(cap.company_slug))
+            throw new Error("Cannot verify this session's company lock because its scope capability is invalid.");
+        primary = cap.company_slug;
+        if (cap.company_slugs === undefined)
+            companies = [primary];
+        else if (Array.isArray(cap.company_slugs)
+            && cap.company_slugs.length > 0
+            && cap.company_slugs.every((slug) => typeof slug === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(slug))
+            && cap.company_slugs[0] === primary
+            && new Set(cap.company_slugs).size === cap.company_slugs.length
+            && ((primary === "personal" && cap.company_slugs.length === 1)
+                || (primary !== "personal" && !cap.company_slugs.includes("personal"))))
+            companies = [...cap.company_slugs];
+        else
+            throw new Error("Cannot verify this session's company lock because its scope capability is invalid.");
+    }
+    else {
+        try {
+            const meta = fs.readFileSync(metaPath, "utf8");
+            const read = (key) => meta.split(/\r?\n/).find((line) => new RegExp(`^\\s*${key}:`).test(line))?.replace(/^\s*[^:]+:\s*/, "").replace(/^"|"$/g, "") ?? "";
+            primary = read("company_slug");
+            const hasList = meta.split(/\r?\n/).some((line) => /^\s*company_slugs:/.test(line));
+            const listed = hasList ? read("company_slugs") : "";
+            if (hasList && (!listed || !primary))
+                throw new Error("invalid company lock");
+            companies = hasList ? listed.split(",") : primary ? [primary] : [];
+            if (companies.some((slug) => !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(slug)))
+                throw new Error("invalid company lock");
+            if (new Set(companies).size !== companies.length)
+                throw new Error("invalid company lock");
+            if (primary && companies[0] !== primary)
+                throw new Error("invalid company lock");
+            if (companies.length > 1 && companies.includes("personal"))
+                throw new Error("invalid company lock");
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES")
+                return { sessionId, companies: [] };
+            throw new Error("Cannot verify this session's company lock because its metadata is invalid.");
+        }
+    }
+    const real = companies.filter((slug) => {
+        if (slug === "personal")
+            return true;
+        try {
+            const companyPath = path.join(root, "companies", slug);
+            const stat = fs.lstatSync(companyPath);
+            return stat.isDirectory() && !stat.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    });
+    if (primary && real[0] !== primary)
+        return { sessionId, companies: [] };
+    return { sessionId, companies: real };
+}
+function companyUidForSlug(root, slug) {
+    try {
+        const doc = yaml.load(fs.readFileSync(path.join(root, "companies", "manifest.yaml"), "utf8"));
+        const uid = doc.companies?.[slug]?.cloud_uid;
+        return typeof uid === "string" && looksLikeCompanyUid(uid) ? uid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function companySlugForUid(root, companies, uid) {
+    if (!looksLikeCompanyUid(uid))
+        return undefined;
+    try {
+        const doc = yaml.load(fs.readFileSync(path.join(root, "companies", "manifest.yaml"), "utf8"));
+        return companies.find((slug) => doc.companies?.[slug]?.cloud_uid === uid);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveApiKeyCompanyWithinLock(input) {
+    let candidates = input.companies;
+    if (input.requestedCompany) {
+        const companySlug = input.companies.includes(input.requestedCompany)
+            ? input.requestedCompany
+            : companySlugForUid(input.root, input.companies, input.requestedCompany);
+        if (!companySlug) {
+            throw new Error("HQ_API_KEY is not bound to a company in this session's locked company set.");
+        }
+        candidates = [companySlug];
+    }
+    for (const companySlug of candidates) {
+        const companyUid = companyUidForSlug(input.root, companySlug);
+        if (!companyUid)
+            continue;
+        const response = await vaultApiFetch({ token: input.token, path: `/v1/keys/secrets/${encodeURIComponent(companyUid)}` });
+        if (response.ok)
+            return { companyUid, companySlug };
+        if (response.status === 401)
+            throw new Error("HQ_API_KEY is invalid or no longer active.");
+        if (response.status !== 403)
+            throw new Error(`Could not verify HQ_API_KEY company scope (HTTP ${response.status}).`);
+    }
+    throw new Error("HQ_API_KEY is not bound to a company in this session's locked company set.");
+}
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { removeCacheEntry, clearAllCache } from "../utils/secrets-cache.js";
 import { isHqCliChild, releaseChildWrapperPackageUseLeaseAfterStart } from "../utils/child-wrapper-lease.js";
+import { resolveDefaultHqRoot } from "../utils/hq-root-resolver.js";
+import { fastFlagEnabled } from "../native-fast-route.js";
+import { MULTI_COMPANY_SESSION_LOCK_FLAG } from "../lib/cli-flag-keys.js";
+import { resolveSessionId } from "../lib/core-utils/session-id.js";
 import { secretsExecChildExitCode } from "../utils/child-wrapper-exit.js";
 import { isPlanGateError } from "../utils/plan-gate-error.js";
 import { SECRET_NAME_PATTERN, GROUP_ID_PATTERN, EMAIL_PATTERN } from "./_patterns.js";
@@ -1085,6 +1229,7 @@ export function registerSecretsCommand(program) {
         .command("exec")
         .description("Run a command with secrets injected as env vars")
         .requiredOption("--only <keys>", "Secret names to inject (comma-separated; may be repeated) (required)", collectSecretNames)
+        .option("--company <slug>", "Company slug (resolves to companyUid)")
         .option("--script <path>", "Attach local script identity for script-locked secrets")
         .option("--script-id <id>", "Stable script identifier approved by policy")
         .allowUnknownOption(true)
@@ -1104,10 +1249,44 @@ export function registerSecretsCommand(program) {
                 process.exit(1);
             }
             const keys = parseSecretNameList(_opts.only);
+            const multiCompanyLockEnabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+            const sessionLock = multiCompanyLockEnabled ? readSessionCompanyLock(process.env) : undefined;
+            const parentScope = secrets.opts();
+            const inheritedCompany = parentScope.company;
+            const requestedCompany = _opts.company ?? inheritedCompany;
+            const hasLockedCompanies = (sessionLock?.companies.length ?? 0) > 0;
+            const lockRoot = hasLockedCompanies ? resolveDefaultHqRoot({ env: process.env }) : undefined;
+            const selectedCompany = (hasLockedCompanies && requestedCompany && looksLikeCompanyUid(requestedCompany)
+                ? companySlugForUid(lockRoot, sessionLock.companies, requestedCompany) ?? requestedCompany
+                : requestedCompany)
+                ?? (multiCompanyLockEnabled && !parentScope.personal ? sessionLock?.companies[0] : undefined);
+            if (hasLockedCompanies && selectedCompany && !sessionLock.companies.includes(selectedCompany)) {
+                throw new Error(`Company '${selectedCompany}' is outside this session's locked company set.`);
+            }
+            if (hasLockedCompanies && parentScope.personal && !sessionLock.companies.includes("personal")) {
+                throw new Error("Personal scope is outside this session's locked company set.");
+            }
+            if (hasLockedCompanies && !selectedCompany && !parentScope.personal) {
+                throw new Error("This session has no locked company scope for secrets exec.");
+            }
+            if (hasLockedCompanies && !requestedCompany && sessionLock.companies.length > 1) {
+                console.error(`Using primary company ${sessionLock.companies[0]} from this session's lock; pass --company <slug> to choose another locked company.`);
+            }
+            const secretScope = selectedCompany === "personal"
+                ? scopeOpts({ personal: true })
+                : scopeOpts({ ...parentScope, ...(selectedCompany ? { company: selectedCompany } : {}) });
             const cred = await resolveVaultCredentialForCapability("secrets:read", "secrets exec", secretsCredentialOptions());
+            const apiKeyCompany = cred.kind === "api-key" && hasLockedCompanies
+                ? await resolveApiKeyCompanyWithinLock({
+                    token: cred.token,
+                    root: lockRoot,
+                    companies: sessionLock.companies,
+                    ...(requestedCompany ? { requestedCompany } : {}),
+                })
+                : undefined;
             const companyUid = cred.kind === "api-key"
-                ? "__api_key__"
-                : await getEntityUid(cred.token, scopeOpts(secrets.opts()), { allowOfflineScopeFallback: true });
+                ? (apiKeyCompany?.companyUid ?? "__api_key__")
+                : await getEntityUid(cred.token, secretScope, { allowOfflineScopeFallback: true });
             const readSecrets = async () => loadRevealedSecrets(cred.token, companyUid, keys, cred.kind === "cognito"
                 ? await buildSecretUsage("exec", _opts.script, _opts.scriptId)
                 : undefined, { allowOfflineFallback: true });

package/dist/commands/workers.d.ts

@@ -6,12 +6,15 @@ import { type RegistryWorker } from "../lib/workers-registry/read.js";
  * company_slug. Undefined when no session context is set. Pure/read-only.
  */
 export declare function resolveActiveCompany(hqRoot: string): string | undefined;
+/** Resolve the active ordered lock set; default-off preserves primary-only access. */
+export declare function resolveActiveCompanies(hqRoot: string, multiCompanyLockEnabled: boolean): string[] | undefined;
+export declare function denyWorkerCompanyOutsideLock(company: string, lockedCompanies: string[] | undefined): boolean;
 /**
  * Membership-aware access filter for worker discovery: public workers always;
  * company workers only for the active company. Mirrors the /run skill and the
  * inject-worker-suggestion hook so all three surfaces agree.
  */
-export declare function filterAccessibleWorkers(workers: RegistryWorker[], activeCompany: string | undefined): RegistryWorker[];
+export declare function filterAccessibleWorkers(workers: RegistryWorker[], activeCompany: string | string[] | undefined): RegistryWorker[];
 /**
  * The company-relative vault prefix for a worker, e.g.
  * companies/indigo/workers/deal-brain/ -> workers/deal-brain/. Returns null for

package/dist/commands/workers.js

@@ -7,6 +7,9 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid } from "./secrets.js";
 import { GROUP_ID_PATTERN, EMAIL_PATTERN, toSharedFolderGlob } from "./_patterns.js";
 import { findHqRoot } from "../utils/manifest.js";
+import { fastFlagEnabled } from "../native-fast-route.js";
+import { MULTI_COMPANY_SESSION_LOCK_FLAG } from "../lib/cli-flag-keys.js";
+import { resolveSessionId } from "../lib/core-utils/session-id.js";
 export { readWorkerRegistry } from "../lib/workers-registry/read.js";
 import { readWorkerRegistry } from "../lib/workers-registry/read.js";
 /**
@@ -14,34 +17,68 @@ import { readWorkerRegistry } from "../lib/workers-registry/read.js";
  * company_slug. Undefined when no session context is set. Pure/read-only.
  */
 export function resolveActiveCompany(hqRoot) {
+    return resolveActiveCompanies(hqRoot, false)?.[0];
+}
+/** Resolve the active ordered lock set; default-off preserves primary-only access. */
+export function resolveActiveCompanies(hqRoot, multiCompanyLockEnabled) {
+    const current = resolveSessionId(hqRoot);
+    if (!current)
+        return undefined;
     try {
-        const currentFile = path.join(hqRoot, "workspace/sessions/.current");
-        const current = fs.readFileSync(currentFile, "utf8").trim();
-        if (!current)
-            return undefined;
         const metaPath = path.join(hqRoot, "workspace/sessions", current, "meta.yaml");
         if (!fs.existsSync(metaPath))
-            return undefined;
+            return multiCompanyLockEnabled ? [] : undefined;
         const meta = yaml.load(fs.readFileSync(metaPath, "utf8"));
-        const co = meta?.company_slug;
-        return typeof co === "string" && co ? co : undefined;
+        const primary = meta?.company_slug;
+        if (typeof primary !== "string" || !/^[A-Za-z0-9_-]+$/.test(primary))
+            return multiCompanyLockEnabled ? [] : undefined;
+        const rawListed = meta?.company_slugs;
+        const listed = multiCompanyLockEnabled && typeof rawListed === "string"
+            ? rawListed.split(",")
+            : [primary];
+        if (!multiCompanyLockEnabled)
+            return [primary];
+        const companies = [...new Set(listed.filter((slug) => {
+                if (typeof slug !== "string" || !/^[A-Za-z0-9_-]+$/.test(slug))
+                    return false;
+                if (slug === "personal")
+                    return true;
+                try {
+                    const stat = fs.lstatSync(path.join(hqRoot, "companies", slug));
+                    return stat.isDirectory() && !stat.isSymbolicLink();
+                }
+                catch {
+                    return false;
+                }
+            }))];
+        if (companies.length > 1 && companies.includes("personal"))
+            return [primary];
+        return companies[0] === primary ? companies : undefined;
     }
     catch {
-        return undefined;
+        return multiCompanyLockEnabled ? [] : undefined;
     }
 }
+export function denyWorkerCompanyOutsideLock(company, lockedCompanies) {
+    if (lockedCompanies === undefined || lockedCompanies.includes(company))
+        return false;
+    console.error(`Company '${company}' is outside this session's locked company set.`);
+    process.exitCode = 1;
+    return true;
+}
 /**
  * Membership-aware access filter for worker discovery: public workers always;
  * company workers only for the active company. Mirrors the /run skill and the
  * inject-worker-suggestion hook so all three surfaces agree.
  */
 export function filterAccessibleWorkers(workers, activeCompany) {
+    const allowed = new Set(Array.isArray(activeCompany) ? activeCompany : activeCompany ? [activeCompany] : []);
     return workers.filter((w) => {
         if (w.visibility === "public")
             return true;
         if (!w.company)
             return false;
-        return activeCompany !== undefined && w.company === activeCompany;
+        return allowed.has(w.company);
     });
 }
 /**
@@ -159,14 +196,18 @@ async function runWorkersShare(workerId, opts) {
     console.log(chalk.green("✓"), `Shared worker '${workerId}' with ${classified.label} (${permission}).`);
     console.log(chalk.dim(`  Vault prefix ${prefix} granted in company '${companySlug}'. It will sync to granted members and appear in their /run list.`));
 }
-function runWorkersList(opts) {
+async function runWorkersList(opts) {
     const hqRoot = findHqRoot();
-    const activeCompany = opts.company ?? resolveActiveCompany(hqRoot);
-    let workers = filterAccessibleWorkers(readWorkerRegistry(hqRoot), activeCompany);
+    const enabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+    const lockedCompanies = resolveActiveCompanies(hqRoot, enabled);
+    if (enabled && opts.company && denyWorkerCompanyOutsideLock(opts.company, lockedCompanies))
+        return;
+    const activeCompanies = opts.company ? [opts.company] : lockedCompanies;
+    let workers = filterAccessibleWorkers(readWorkerRegistry(hqRoot), activeCompanies);
     if (opts.shared)
         workers = workers.filter((w) => Boolean(w.grants && w.grants.trim()));
     if (opts.mine)
-        workers = workers.filter((w) => Boolean(w.company) && w.company === activeCompany);
+        workers = workers.filter((w) => Boolean(w.company) && activeCompanies?.includes(w.company) === true);
     if (workers.length === 0) {
         console.log("No accessible workers.");
         return;
@@ -185,8 +226,9 @@ function runWorkersList(opts) {
         }
     };
     printGroup("Public", publicWorkers);
-    if (activeCompany)
-        printGroup(activeCompany, companyWorkers);
+    for (const company of activeCompanies ?? []) {
+        printGroup(company, companyWorkers.filter((worker) => worker.company === company));
+    }
     console.log(chalk.dim("\nUsage: hq run {worker-id} [skill] [args]"));
     console.log(chalk.dim("Share a company worker: hq workers share {worker-id} --with {grp_<name>|@all} --permission read"));
 }

package/dist/lib/anywhere-person-setting.d.ts

@@ -6,6 +6,7 @@ export interface ReadHqAnywherePersonSettingOptions {
     fetchImpl?: typeof fetch;
     apiBaseUrl?: string;
     env?: NodeJS.ProcessEnv;
+    home?: string;
     onError?: (errorName: string) => void;
 }
 /** Returns null when the person preference cannot be read; callers must fail closed. */

package/dist/lib/anywhere-person-setting.js

@@ -1,8 +1,20 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { anywhereRuntimeEnabledFromSnapshot } from "./anywhere-runtime-fast-flag.js";
+function hasPersonTokenCache(env, home) {
+    // Mirrors personTokenCacheFile() in utils/cognito-session.ts; duplicated so this path does not load that module.
+    const stateDir = env.HQ_STATE_DIR?.trim() || path.join(home, ".hq");
+    return fs.existsSync(path.join(stateDir, "cognito-tokens.json"));
+}
 /** Returns null when the person preference cannot be read; callers must fail closed. */
 export async function readHqAnywherePersonSetting(options = {}) {
     const env = options.env ?? process.env;
     try {
+        // Avoid loading the Cognito SDK on the common fresh-install path. There is
+        // no person token to refresh or use until a cache exists.
+        if (!options.getPersonToken && !hasPersonTokenCache(env, options.home ?? env.HOME ?? os.homedir()))
+            return null;
         const getPersonToken = options.getPersonToken ?? (async () => {
             const { ensureCognitoToken } = await import("../utils/cognito-session.js");
             return ensureCognitoToken({ interactive: false, tokenSource: "person" });

package/dist/lib/anywhere-runtime-fast-flag.js

@@ -1,9 +1,11 @@
 import { readLocalOverride, resolveFlag } from "@indigoai-us/hq-flags-client";
 import { resolveProcessFlagCompanyContext } from "./process-flag-company-context.js";
 import { readFlagSnapshotFile, readPersonFlagSnapshotFile } from "./flag-snapshot-file.js";
-import { HQ_ANYWHERE_RUNTIME_FLAG } from "./anywhere-runtime-flag-key.js";
+import { HQ_ANYWHERE_RUNTIME_FLAG, hqAnywhereRuntimeLocallyDisabled } from "./anywhere-runtime-flag-key.js";
 /** Resolve the Anywhere gate from hq-flags without loading the CLI's large worker bundle. */
 export function anywhereRuntimeEnabledFromSnapshot(env = process.env) {
+    if (hqAnywhereRuntimeLocallyDisabled(env))
+        return false;
     const local = readLocalOverride(HQ_ANYWHERE_RUNTIME_FLAG, env);
     if (local !== null)
         return local;
@@ -17,13 +19,13 @@ export function anywhereRuntimeEnabledFromSnapshot(env = process.env) {
     const snapshot = persisted
         ? { version: 0, flags: persisted.flags }
         : null;
-    // HQ Anywhere authorizes a capability, so a missing or stale snapshot fails closed.
+    // The flag is a fail-safe kill switch: unknown registry state keeps HQ Anywhere enabled.
     return resolveFlag({
         flagKey: HQ_ANYWHERE_RUNTIME_FLAG,
         env,
         snapshot,
         companyIdentifiers: [company.companyUid, company.companySlug].filter((value) => Boolean(value)),
-        lookup: { fallback: false },
+        lookup: { fallback: true },
     }).value;
 }
 //# sourceMappingURL=anywhere-runtime-fast-flag.js.map

package/dist/lib/anywhere-runtime-flag-key.d.ts

@@ -1,3 +1,5 @@
-/** hq-flags key for the staged HQ Anywhere runtime. The registry default is off. */
+/** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export declare const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+/** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
+export declare function hqAnywhereRuntimeLocallyDisabled(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=anywhere-runtime-flag-key.d.ts.map

package/dist/lib/anywhere-runtime-flag-key.js

@@ -1,3 +1,8 @@
-/** hq-flags key for the staged HQ Anywhere runtime. The registry default is off. */
+/** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+/** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
+export function hqAnywhereRuntimeLocallyDisabled(env = process.env) {
+    const value = env.HQ_FLAG_HQ_ANYWHERE_RUNTIME;
+    return value === "false" || value === "0";
+}
 //# sourceMappingURL=anywhere-runtime-flag-key.js.map

package/dist/lib/cli-flag-keys.d.ts

@@ -1,3 +1,4 @@
 /** hq-flags keys used by CLI-wide routes. */
 export declare const CLI_COMMAND_HELP_CATALOG_FLAG = "cli.command-help-catalog";
+export declare const MULTI_COMPANY_SESSION_LOCK_FLAG = "hooks.multi-company-session-lock";
 //# sourceMappingURL=cli-flag-keys.d.ts.map

package/dist/lib/cli-flag-keys.js

@@ -1,3 +1,4 @@
 /** hq-flags keys used by CLI-wide routes. */
 export const CLI_COMMAND_HELP_CATALOG_FLAG = "cli.command-help-catalog";
+export const MULTI_COMPANY_SESSION_LOCK_FLAG = "hooks.multi-company-session-lock";
 //# sourceMappingURL=cli-flag-keys.js.map

package/dist/lib/core-utils/session-id.d.ts

@@ -0,0 +1,6 @@
+export declare const SESSION_ID_ENV_KEYS: readonly ["HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "GROK_SESSION_ID"];
+export declare function validSessionId(value: string): boolean;
+export declare function sessionIdFromEnv(env: NodeJS.ProcessEnv): string;
+/** Resolve the caller's session before using the global, last-writer-wins .current fallback. */
+export declare function resolveSessionId(root: string, env?: NodeJS.ProcessEnv, readFile?: (filePath: string, encoding: BufferEncoding) => string): string;
+//# sourceMappingURL=session-id.d.ts.map

package/dist/lib/core-utils/session-id.js

@@ -0,0 +1,35 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const SESSION_ID_ENV_KEYS = [
+    "HQ_SESSION_ID",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_SESSION_ID",
+    "CODEX_SESSION_ID",
+    "CODEX_THREAD_ID",
+    "GROK_SESSION_ID",
+];
+export function validSessionId(value) {
+    return Boolean(value) && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
+}
+export function sessionIdFromEnv(env) {
+    for (const key of SESSION_ID_ENV_KEYS) {
+        const value = (env[key] ?? "").replace(/[\t\n\v\f\r ]/g, "");
+        if (validSessionId(value))
+            return value;
+    }
+    return "";
+}
+/** Resolve the caller's session before using the global, last-writer-wins .current fallback. */
+export function resolveSessionId(root, env = process.env, readFile = (filePath, encoding) => fs.readFileSync(filePath, encoding)) {
+    const fromEnv = sessionIdFromEnv(env);
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const current = readFile(path.join(root, "workspace", "sessions", ".current"), "utf8").replace(/[\t\n\v\f\r ]/g, "");
+        return validSessionId(current) ? current : "";
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=session-id.js.map

package/dist/lib/daemon/catalog.js

@@ -230,7 +230,7 @@ function planService(service, ctx) {
             return [
                 base(service, {
                     kind: "scheduled",
-                    // Polls every 15 s so keep-alive resumes are admitted on time (#1396).
+                    // Polls every 15 s so local keep-alive resumes are admitted on time (#1396).
                     // Each pass is a fresh `hq` node process (~1.8 s CPU, ~200 MB RSS), so
                     // desktops first check the lane store in-process
                     // (lanes-reconcile-guard.ts) and fall back to the pre-#1396 60 s

package/dist/lib/daemon/flag.d.ts

@@ -1,7 +1,7 @@
 /**
  * Feature flags read by the daemon. The daemon runs for weeks, so each read
  * asks the registry again instead of holding a per-process answer, and it
- * reads as off unless the registry itself says on (or a local override does).
+ * reads as each flag's fallback unless the registry or a local override decides it.
  */
 import { type FlagClientOptions, type FlagResolution } from "@indigoai-us/hq-flags-client";
 /** Outposts hand running services to the next daemon on a CLI update instead of restarting them all. */