@indigoai-us/hq-cli 5.345.47 → 5.345.49

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

@@ -2,10 +2,13 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { createRequire } from "node:module";
 import { spawn, spawnSync } from "node:child_process";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 import { shellDisplayPath } from "../lib/core-utils/shell-display-path.js";
+import { validSessionId, resolveSessionId as resolveSharedSessionId } from "../lib/core-utils/session-id.js";
 export const HQ_SESSION_ASSET = "core/scripts/hq-session.sh";
+const requireSessionDependency = createRequire(import.meta.url);
 export const HQ_SESSION_HELP = [
     "hq-core: public",
     "hq-session.sh — read/write the current session's metadata.",
@@ -15,6 +18,9 @@ export const HQ_SESSION_HELP = [
     "  core/scripts/hq-session.sh path                  # print path to current meta.yaml",
     "  core/scripts/hq-session.sh get <key>             # read a key from meta.yaml",
     "  core/scripts/hq-session.sh set <key> <value>     # set/replace a top-level key",
+    "  add company <slug>          # add a company to the session lock set",
+    "  remove company <slug>       # remove a company from the session lock set",
+    "  get company_slugs           # print locked companies, primary first",
     "",
     "Reserved value:",
     "  set company_slug personal   # bind the session to no-company (personal) work",
@@ -105,44 +111,69 @@ const defaultDependencies = () => ({
             ...(result.error ? { error: result.error } : {}),
         };
     },
+    multiCompanyLockEnabled: false,
 });
 function isExpectedFsMiss(error) {
     const code = error?.code;
     return code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP";
 }
-function asciiWhitespace(value) {
-    return value.replace(/[\t\n\v\f\r ]/g, "");
-}
-function validSessionId(value) {
-    return value.length > 0 && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
-}
-function sessionIdFromEnv(env) {
-    for (const name of [
-        "HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID",
-        "CODEX_SESSION_ID", "CODEX_THREAD_ID", "GROK_SESSION_ID",
-    ]) {
-        const value = asciiWhitespace(env[name] ?? "");
-        if (validSessionId(value))
-            return value;
-    }
-    return "";
+export { validSessionId } from "../lib/core-utils/session-id.js";
+function resolveSessionId(root, deps) {
+    return resolveSharedSessionId(root, deps.env, deps.readFile);
 }
-function sessionIdFromCurrentFile(root, deps) {
-    const filePath = path.join(root, "workspace", "sessions", ".current");
-    if (!deps.isFile(filePath))
-        return "";
+function isRegisteredCompany(root, slug, deps) {
+    if (!slug || slug.startsWith("_") || slug === "companies" || slug === "unaffiliated_repos")
+        return false;
     try {
-        const value = asciiWhitespace(deps.readFile(filePath, "utf8"));
-        return validSessionId(value) ? value : "";
+        const yaml = requireSessionDependency("js-yaml");
+        const value = yaml.load(deps.readFile(path.join(root, "companies", "manifest.yaml"), "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const companies = value.companies;
+        return Boolean(companies && typeof companies === "object" && !Array.isArray(companies) && Object.hasOwn(companies, slug));
     }
-    catch (error) {
-        if (isExpectedFsMiss(error))
-            return "";
-        throw error;
+    catch {
+        return false;
     }
 }
-function resolveSessionId(root, deps) {
-    return sessionIdFromEnv(deps.env) || sessionIdFromCurrentFile(root, deps);
+function withCompanyLock(root, sessionId, action) {
+    const lock = path.join(root, "workspace", "sessions", sessionId, ".company-lock-set.lock");
+    const deadline = Date.now() + 30_000;
+    while (true) {
+        try {
+            fs.mkdirSync(lock);
+            fs.writeFileSync(path.join(lock, "pid"), `${process.pid}\n`, "utf8");
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                const owner = Number.parseInt(fs.readFileSync(path.join(lock, "pid"), "utf8").trim(), 10);
+                if (Number.isInteger(owner) && owner > 0) {
+                    try {
+                        process.kill(owner, 0);
+                    }
+                    catch (probeError) {
+                        if (probeError.code === "ESRCH") {
+                            fs.rmSync(lock, { recursive: true, force: true });
+                            continue;
+                        }
+                    }
+                }
+            }
+            catch { /* The shell writer may be between mkdir and writing pid. */ }
+            if (Date.now() >= deadline)
+                throw new Error("hq-session: timed out waiting for company lock update");
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        fs.rmSync(lock, { recursive: true, force: true });
+    }
 }
 function findMetaValue(contents, key) {
     for (const line of contents.split("\n")) {
@@ -155,6 +186,50 @@ function findMetaValue(contents, key) {
     return { found: false, value: "" };
 }
 function getMetaValue(contents, key) { return findMetaValue(contents, key).value; }
+function writeCompanyMetadata(contents, companies) {
+    const primary = companies[0] ?? "";
+    const records = contents.split("\n");
+    if (records.at(-1) === "")
+        records.pop();
+    const replaced = [];
+    let havePrimary = false;
+    let haveCompanies = false;
+    for (const line of records) {
+        const first = line.match(/^\s*(\S+)/)?.[1] ?? "";
+        if (first === "company_slug:") {
+            if (!havePrimary)
+                replaced.push(`company_slug: ${primary}`);
+            havePrimary = true;
+        }
+        else if (first === "company_slugs:") {
+            if (!haveCompanies)
+                replaced.push(`company_slugs: ${companies.join(",")}`);
+            haveCompanies = true;
+        }
+        else
+            replaced.push(line);
+    }
+    if (!havePrimary)
+        replaced.push(`company_slug: ${primary}`);
+    if (!haveCompanies)
+        replaced.push(`company_slugs: ${companies.join(",")}`);
+    return `${replaced.join("\n")}\n`;
+}
+function metaCompanySlugs(contents) {
+    const listed = getMetaValue(contents, "company_slugs");
+    const primary = getMetaValue(contents, "company_slug");
+    const candidates = listed ? listed.split(",") : primary ? [primary] : [];
+    const seen = new Set();
+    const result = candidates.filter((slug) => {
+        if (!/^[A-Za-z0-9_-]+$/.test(slug) || seen.has(slug))
+            return false;
+        seen.add(slug);
+        return true;
+    });
+    if (result.length > 1 && result.includes("personal"))
+        return primary ? [primary] : [];
+    return primary && result[0] !== primary ? [primary] : result;
+}
 const WORK_MESH_SESSION_START_COMMAND = 'event=$HQ_CORE_SESSION_EVENT_JSON; unset HQ_CORE_SESSION_EVENT_JSON; printf "%s" "$event" | bash "$1" SessionStart';
 function recordWorkMeshSessionStart(input) {
     const hook = path.join(input.root, "core", "hooks", "SessionStart", "35-work-mesh-session-start.sh");
@@ -218,8 +293,33 @@ function runWorkMeshProjectRebind(input) {
     }
     return { stdout: result.stdout, stderr: result.stderr };
 }
+function registerWorkMeshCompany(root, sessionId, company, metadata, cwd, deps) {
+    const library = path.join(root, "core", "scripts", "lib");
+    if (!deps.isFile(path.join(library, "work-mesh-enqueue.sh")) ||
+        !deps.isFile(path.join(library, "work-mesh-live-rebind.sh")))
+        return { stdout: "", stderr: "" };
+    const script = [
+        '. "$1/work-mesh-enqueue.sh" 2>/dev/null || true',
+        '. "$1/work-mesh-live-hook.sh" 2>/dev/null || true',
+        '. "$1/work-mesh-live-rebind.sh" 2>/dev/null || true',
+        'if command -v work_mesh_live_write_binding_marker >/dev/null 2>&1; then work_mesh_live_write_binding_marker "$2" "$3" "$4" "$5" || true; fi',
+    ].join("\n");
+    const result = deps.runCommand("bash", ["-c", script, "_", library, sessionId, company,
+        getMetaValue(metadata, "project"), getMetaValue(metadata, "task")], cwd, {
+        ...deps.env,
+        HQ_ROOT: root,
+        PWD: deps.env.PWD || cwd,
+    });
+    if (result.error) {
+        const code = result.error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return { stdout: "", stderr: "" };
+        throw result.error;
+    }
+    return { stdout: result.stdout, stderr: result.stderr };
+}
 function recordHqSessionWorkMeshEffects(input, deps) {
-    if (input.key === "company_slug" && input.value && input.value !== input.previous && input.value !== "personal") {
+    if ((input.key === "company_slug" || input.key === "company_slugs") && input.value && input.value !== input.previous && input.value !== "personal") {
         const stderr = recordWorkMeshSessionStart({
             sessionId: input.sessionId,
             root: input.root,
@@ -443,14 +543,18 @@ function atomicWrite(filePath, contents, deps) {
         throw error;
     }
 }
-function mintScopeCapability(root, sessionId, company, deps) {
-    if (!root || !sessionId || !company || !/^[A-Za-z0-9_-]+$/.test(company))
+function mintScopeCapability(root, sessionId, companies, deps, includeSet = false) {
+    const company = companies[0] ?? "";
+    if (!root || !sessionId || !company || companies.some((slug) => !/^[A-Za-z0-9_-]+$/.test(slug)))
         return false;
     const directory = path.join(root, "workspace", "sessions", sessionId);
     const filePath = path.join(directory, "scope-capability.json");
     try {
         deps.mkdir(directory);
-        const value = { session_id: sessionId, company_slug: company, minted_at: timestamp(deps.now()) };
+        const mintedAt = timestamp(deps.now());
+        const value = includeSet
+            ? { session_id: sessionId, company_slug: company, minted_at: mintedAt, company_slugs: companies }
+            : { session_id: sessionId, company_slug: company, minted_at: mintedAt };
         atomicWrite(filePath, `${JSON.stringify(value, null, 2)}\n`, deps);
         return true;
     }
@@ -489,7 +593,7 @@ export function executeHqSession(argv, context, overrides = {}) {
     if (!subcommand || subcommand === "-h" || subcommand === "--help" || subcommand === "help") {
         return { code: 0, stdout: HQ_SESSION_HELP, stderr: "" };
     }
-    if (!["current", "path", "get", "set"].includes(subcommand)) {
+    if (!["current", "path", "get", "set", "add", "remove"].includes(subcommand)) {
         return { code: 1, stdout: "", stderr: `hq-session: unknown subcommand '${subcommand}'\n${HQ_SESSION_HELP}` };
     }
     if (subcommand === "current") {
@@ -505,7 +609,15 @@ export function executeHqSession(argv, context, overrides = {}) {
         if (!metaPath || !deps.isFile(metaPath))
             return { code: 0, stdout: "", stderr: "" };
         try {
-            const result = findMetaValue(deps.readFile(metaPath, "utf8"), key);
+            const contents = deps.readFile(metaPath, "utf8");
+            if (key === "company_slugs") {
+                const primary = getMetaValue(contents, "company_slug");
+                const slugs = deps.multiCompanyLockEnabled
+                    ? metaCompanySlugs(contents).filter((slug) => slug === "personal" || exactCompanyDir(root, slug, deps))
+                    : primary ? [primary] : [];
+                return { code: 0, stdout: slugs.length ? `${slugs.join(",")}\n` : "", stderr: "" };
+            }
+            const result = findMetaValue(contents, key);
             return { code: 0, stdout: result.found ? `${result.value}\n` : "", stderr: "" };
         }
         catch (error) {
@@ -517,10 +629,71 @@ export function executeHqSession(argv, context, overrides = {}) {
             throw error;
         }
     }
+    if (subcommand === "add" || subcommand === "remove") {
+        const kind = args[0] ?? "";
+        const slug = args[1] ?? "";
+        if (kind !== "company" || args.length < 2 || !slug) {
+            return { code: 1, stdout: "", stderr: `usage: hq-session.sh ${subcommand} company <slug>\n` };
+        }
+        if (subcommand === "add" && !deps.multiCompanyLockEnabled) {
+            return { code: 1, stdout: "", stderr: "hq-session: adding a company is unavailable because hooks.multi-company-session-lock is off\n" };
+        }
+        if (!/^[A-Za-z0-9_-]+$/.test(slug)) {
+            return { code: 1, stdout: "", stderr: `hq-session: invalid company_slug: '${slug}' (allowed characters: A-Z a-z 0-9 - _)\n` };
+        }
+        const dir = path.join(root, "companies", slug);
+        if (subcommand === "add" && (slug === "personal" || !isRegisteredCompany(root, slug, deps) || deps.isSymlink(dir) || hasCompanyCaseAlias(root, slug, deps) || !exactCompanyDir(root, slug, deps))) {
+            return { code: 1, stdout: "", stderr: `hq-session: company_slug must use the exact real directory name: '${slug}'\n` };
+        }
+        const sessionId = sessionOverride || resolveSessionId(root, deps);
+        if (!sessionId)
+            return { code: 1, stdout: "", stderr: "hq-session: no current session — pass --session-id <id> to target a session explicitly.\n" };
+        deps.mkdir(path.join(root, "workspace", "sessions", sessionId));
+        return withCompanyLock(root, sessionId, () => {
+            const target = path.join(root, "workspace", "sessions", sessionId, "meta.yaml");
+            try {
+                deps.mkdir(path.dirname(target));
+                const existed = deps.isFile(target);
+                const oldText = existed ? deps.readFile(target, "utf8") : `session_id: ${sessionId}\nstarted_at: "${timestamp(deps.now())}"\nsenior: user\n`;
+                const rawCompanies = metaCompanySlugs(oldText);
+                const companies = rawCompanies.filter((company) => company === "personal" || exactCompanyDir(root, company, deps));
+                if (subcommand === "add" && companies.includes(slug))
+                    return { code: 0, stdout: "", stderr: "" };
+                const next = subcommand === "add"
+                    ? [...(companies[0] === "personal" ? [] : companies), slug]
+                    : companies.filter((value) => value !== slug);
+                if (!next.length)
+                    return { code: 1, stdout: "", stderr: "hq-session: cannot remove the last locked company; use set company_slug <slug> instead\n" };
+                if (subcommand === "remove" && !rawCompanies.includes(slug))
+                    return { code: 0, stdout: "", stderr: "" };
+                const updatedText = writeCompanyMetadata(oldText, next);
+                atomicWrite(target, updatedText, deps);
+                if (!mintScopeCapability(root, sessionId, next, deps, true)) {
+                    if (existed)
+                        atomicWrite(target, oldText, deps);
+                    else
+                        deps.remove(target);
+                    return { code: 1, stdout: "", stderr: `hq-session: failed to mint scope-capability for session ${sessionId}; metadata was restored\n` };
+                }
+                const stdout = subcommand === "add" ? emitHardPolicies(root, slug, deps) : "";
+                const primaryChanged = next[0] !== companies[0];
+                const workMeshOutput = primaryChanged
+                    ? registerWorkMeshCompany(root, sessionId, next[0], updatedText, context.cwd, deps)
+                    : { stdout: "", stderr: "" };
+                return { code: 0, stdout: stdout + workMeshOutput.stdout, stderr: workMeshOutput.stderr };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { code: 1, stdout: "", stderr: `${message}\n` };
+            }
+        });
+    }
     const key = args[0] ?? "";
     const value = args[1] ?? "";
     if (!key || args.length < 2)
         return { code: 1, stdout: "", stderr: "usage: hq-session.sh set <key> <value>\n" };
+    if (key === "company_slugs")
+        return { code: 1, stdout: "", stderr: "hq-session: set company_slugs is unsupported; use add/remove company to update the validated lock set\n" };
     if (key === "company_slug" && value) {
         if (!/^[A-Za-z0-9_-]+$/.test(value)) {
             return { code: 1, stdout: "", stderr: `hq-session: invalid company_slug: '${value}' (allowed characters: A-Z a-z 0-9 - _)\n` };
@@ -548,35 +721,39 @@ export function executeHqSession(argv, context, overrides = {}) {
             const initial = `session_id: ${sessionId}\nstarted_at: "${timestamp(deps.now())}"\nsenior: user\n`;
             deps.writeFile(target, initial, 0o666 & ~deps.umask());
         }
-        let previous = "";
-        try {
-            previous = getMetaValue(deps.readFile(target, "utf8"), key);
-        }
-        catch {
-            previous = "";
-        }
         const oldText = deps.readFile(target, "utf8");
+        const previous = getMetaValue(oldText, key);
+        const companySetChanged = key === "company_slug" && value !== ""
+            && JSON.stringify(metaCompanySlugs(oldText)) !== JSON.stringify([value]);
         const records = oldText.split("\n");
         if (records.at(-1) === "")
             records.pop();
+        const clearProjectTask = key === "company_slug" && previous !== "" && value !== previous;
         let found = false;
-        const replaced = records.map((line) => {
+        const replaced = [];
+        for (const line of records) {
             const first = line.match(/^\s*(\S+)/)?.[1] ?? "";
-            if (first !== `${key}:`)
-                return line;
-            found = true;
-            return `${key}: ${value}`;
-        });
+            if (clearProjectTask && (first === "project:" || first === "task:"))
+                continue;
+            if (first === `${key}:`) {
+                found = true;
+                replaced.push(`${key}: ${value}`);
+            }
+            else
+                replaced.push(line);
+        }
         if (!found)
             replaced.push(`${key}: ${value}`);
-        const updatedText = `${replaced.join("\n")}\n`;
+        let updatedText = `${replaced.join("\n")}\n`;
+        if (key === "company_slug")
+            updatedText = writeCompanyMetadata(updatedText, value ? [value] : []);
         atomicWrite(target, updatedText, deps);
         let stdout = "";
-        if (key === "company_slug" && value && value !== previous) {
-            if (!mintScopeCapability(root, sessionId, value, deps)) {
+        if (key === "company_slug" && value && companySetChanged) {
+            if (!mintScopeCapability(root, sessionId, [value], deps, true)) {
                 return { code: 1, stdout: "", stderr: `hq-session: failed to mint scope-capability for session ${sessionId}\n` };
             }
-            if (value !== "personal")
+            if (value !== previous && value !== "personal")
                 stdout = emitHardPolicies(root, value, deps);
         }
         const workMeshOutput = recordHqSessionWorkMeshEffects({
@@ -597,7 +774,20 @@ export function executeHqSession(argv, context, overrides = {}) {
 }
 /** Signature consumed by the lightweight fast-core dispatcher. */
 export async function runHqSessionFast(argv, _stdin, cwd, hqRoot) {
-    const result = executeHqSession(argv, { cwd, hqRoot });
+    const commandArgs = argv[0] === "--session-id"
+        ? argv.slice(2)
+        : argv[0]?.startsWith("--session-id=") ? argv.slice(1) : argv;
+    const needsMultiCompanyFlag = commandArgs[0] === "add"
+        || (commandArgs[0] === "get" && commandArgs[1] === "company_slugs");
+    let enabled = false;
+    if (needsMultiCompanyFlag) {
+        const [{ fastFlagEnabled }, { MULTI_COMPANY_SESSION_LOCK_FLAG }] = await Promise.all([
+            import("../native-fast-route.js"),
+            import("../lib/cli-flag-keys.js"),
+        ]);
+        enabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+    }
+    const result = executeHqSession(argv, { cwd, hqRoot }, { multiCompanyLockEnabled: enabled });
     if (result.stdout)
         process.stdout.write(result.stdout);
     if (result.stderr)

package/dist/commands/core-resolve-company-native.d.ts

@@ -23,6 +23,7 @@ export type ResolveCompanyDependencies = {
     onHqExit?: (args: readonly string[]) => void;
     pid?: number;
     random?: () => number;
+    multiCompanyLockEnabled?: boolean;
 };
 export declare function resolveCompany(args: readonly string[], dependencies: ResolveCompanyDependencies): Promise<ResolveCompanyResult>;
 export declare function runResolveCompanyFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, _commandName?: string, _hqRootArg?: string, stdinReader?: () => Promise<string>): Promise<number>;

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

@@ -4,6 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 import { buildCmdExeSpawnPlan, isWindowsBatchFile } from "../utils/windows-spawn.js";
+import { fastFlagEnabled } from "../native-fast-route.js";
 export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
 export const RESOLVE_COMPANY_HELP = [
     "hq-core: public",
@@ -143,7 +144,7 @@ function sessionId(root, env, fileSystem) {
     const current = readFile(path.join(root, "workspace/sessions/.current"), fileSystem)?.replace(/[ \t\n\v\f\r]/g, "") ?? "";
     return validSessionId(current) ? current : "";
 }
-function sessionCompany(root, env, fileSystem) {
+function sessionCompany(root, env, fileSystem, multiCompanyLockEnabled = false) {
     const helper = path.join(root, "core/scripts/hq-session.sh");
     try {
         fileSystem.accessSync(helper, fs.constants.X_OK);
@@ -151,19 +152,19 @@ function sessionCompany(root, env, fileSystem) {
     catch (error) {
         const code = errorCode(error);
         if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP")
-            return "";
+            return { company: "", companies: [] };
         throw error;
     }
     // A directory may be executable according to access(2), but `bash directory`
     // fails without output, just as hq-session.sh does here.
     if (!isFile(helper, fileSystem))
-        return "";
+        return { company: "", companies: [] };
     const id = sessionId(root, env, fileSystem);
     if (!id)
-        return "";
+        return { company: "", companies: [] };
     const meta = readFile(path.join(root, "workspace/sessions", id, "meta.yaml"), fileSystem);
     if (meta === undefined)
-        return "";
+        return { company: "", companies: [] };
     let value = "";
     for (const line of meta.split("\n")) {
         const firstField = line.replace(/^[ \t]+/, "").split(/[ \t]+/, 1)[0];
@@ -174,7 +175,30 @@ function sessionCompany(root, env, fileSystem) {
     }
     // The shell's command substitution strips trailing newlines, then tr removes
     // all remaining whitespace and double quotes from the helper's output.
-    return value.replace(/[ \t\n\v\f\r"]/g, "");
+    value = value.replace(/[ \t\n\v\f\r"]/g, "");
+    if (!value || !multiCompanyLockEnabled)
+        return { company: value, companies: value ? [value] : [] };
+    let listed = "";
+    for (const line of meta.split("\n")) {
+        if (line.replace(/^[ \t]+/, "").split(/[ \t]+/, 1)[0] !== "company_slugs:")
+            continue;
+        listed = line.replace(/^[^:]+:[ \t]*/, "").replace(/^"|"$/g, "");
+        break;
+    }
+    const companies = [...new Set((listed ? listed.split(",") : [value]).filter((slug) => /^[A-Za-z0-9_-]+$/.test(slug) &&
+            (slug === "personal" || (() => {
+                try {
+                    return fileSystem.statSync(path.join(root, "companies", slug)).isDirectory() && !fileSystem.lstatSync(path.join(root, "companies", slug)).isSymbolicLink();
+                }
+                catch {
+                    return false;
+                }
+            })())))];
+    if (companies[0] !== value)
+        return { company: "", companies: [] };
+    if (companies.length > 1 && companies.includes("personal"))
+        return { company: value, companies: [value] };
+    return { company: value, companies };
 }
 function fleetIdentityPresent(rootPrefix, env, fileSystem) {
     if (env.HQ_AGENT_WORKDIR || env.HQ_AGENT_COMPANY_DIR || env.HQ_AGENT_IDENTITY_FILE)
@@ -386,8 +410,9 @@ function runHq(args, env, timeoutMs, cwd, command = "hq", onExitObserved) {
         });
     });
 }
-function output(company, source) {
-    return { code: 0, stdout: Buffer.from(`{"company":"${company}","source":"${source}"}\n`), stderr: Buffer.alloc(0) };
+function output(company, source, companies) {
+    const payload = { company, source, ...(source === "session" && companies ? { companies } : {}) };
+    return { code: 0, stdout: Buffer.from(`${JSON.stringify(payload)}\n`), stderr: Buffer.alloc(0) };
 }
 function parseArgs(args) {
     let root = "";
@@ -519,9 +544,13 @@ export async function resolveCompany(args, dependencies) {
     const promptMatch = promptSlug(prompt, slugs);
     if (promptMatch)
         return output(promptMatch, "prompt");
-    const sessionMatch = sessionCompany(root, env, fileSystem);
-    if (sessionMatch && knownSlugs.has(sessionMatch))
-        return output(sessionMatch, "session");
+    const sessionMatch = sessionCompany(root, env, fileSystem, dependencies.multiCompanyLockEnabled);
+    if (sessionMatch.company && knownSlugs.has(sessionMatch.company)) {
+        const companies = sessionMatch.companies.filter((slug) => knownSlugs.has(slug));
+        return dependencies.multiCompanyLockEnabled
+            ? output(sessionMatch.company, "session", companies.length ? companies : [sessionMatch.company])
+            : output(sessionMatch.company, "session");
+    }
     if (fleetIdentityPresent(env.HQ_AGENT_ROOT_PREFIX ?? "", env, fileSystem))
         return output("", "none");
     // jq is intentionally no longer needed. The native route is always hosted by
@@ -574,6 +603,7 @@ export async function runResolveCompanyFast(args, stdin, cwd, hqRoot, _commandNa
         hqRoot,
         stdin: actualStdin,
         stdinIsTty: process.stdin.isTTY === true,
+        multiCompanyLockEnabled: await fastFlagEnabled("hooks.multi-company-session-lock"),
     });
     process.stdout.write(result.stdout);
     if (result.stderr.length)

package/dist/commands/feedback.d.ts

@@ -4,6 +4,8 @@ import { collectFeedbackLogs, feedbackLogsEnabled } from "../utils/feedback-logs
 import { type LogBundleRef } from "../utils/feedback-log-bundle.js";
 export declare const FEEDBACK_LATEST_VERSION_FLAG = "feedback.latest-version";
 export declare const FEEDBACK_LATEST_VERSION_FLAG_FALLBACK = false;
+export declare const FEEDBACK_REPORTER_KIND_FLAG = "feedback.reporter-kind";
+export declare const FEEDBACK_REPORTER_KIND_FLAG_FALLBACK = true;
 export declare const BODY_MAX_BYTES: number;
 /** Validate fields that must be valid before feedback attachments are uploaded. */
 export declare function validateFeedbackContent(title: string, body: string): void;
@@ -44,7 +46,15 @@ export interface FeedbackSubmitOptions {
     diagnostics?: DiagnosticsBlob;
     /** Precomputed setting so environment lookup happens before attachments upload. */
     logsEnabled?: boolean;
+    /** Optional one-way override: callers can mark human sessions as agent. */
+    reporterOverride?: "agent";
 }
+export interface FeedbackReporterMark {
+    reporter_kind: "agent" | "human";
+    reporter_source: string;
+}
+/** Resolve a safe reporter classification without returning any env values. */
+export declare function resolveFeedbackReporter(env?: NodeJS.ProcessEnv, isTTY?: boolean, override?: string): FeedbackReporterMark;
 export declare function readBodyFile(bodyFile: string, stdin?: NodeJS.ReadableStream): Promise<string>;
 /**
  * Attach redacted `~/.hq` log tails to `diagnostics` if, and only if, they fit

package/dist/commands/feedback.js

@@ -10,6 +10,8 @@ import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { cachedLatestVersion } from "../utils/version-check.js";
 export const FEEDBACK_LATEST_VERSION_FLAG = "feedback.latest-version";
 export const FEEDBACK_LATEST_VERSION_FLAG_FALLBACK = false;
+export const FEEDBACK_REPORTER_KIND_FLAG = "feedback.reporter-kind";
+export const FEEDBACK_REPORTER_KIND_FLAG_FALLBACK = true;
 export const BODY_MAX_BYTES = 64 * 1024;
 /** Validate fields that must be valid before feedback attachments are uploaded. */
 export function validateFeedbackContent(title, body) {
@@ -46,6 +48,32 @@ function validateFeedbackRequestSize(requestBody) {
  * after attaching, so this reserve only needs to be roughly right.
  */
 const LOGS_ENVELOPE_RESERVE_BYTES = 1024;
+const AGENT_RUNTIME_MARKERS = [
+    "HQ_LANE_ID",
+    "HQ_POLICY_WORKER_DIR",
+    "HQ_AGENT_DIR",
+    "CODEX_THREAD_ID",
+    "CODEX_SESSION_ID",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_SESSION_ID",
+    "HQ_SESSION_ID",
+    "GROK_SESSION_ID",
+];
+/** Resolve a safe reporter classification without returning any env values. */
+export function resolveFeedbackReporter(env = process.env, isTTY = process.stdin.isTTY === true, override) {
+    for (const marker of AGENT_RUNTIME_MARKERS) {
+        if (env[marker]?.trim()) {
+            return { reporter_kind: "agent", reporter_source: marker };
+        }
+    }
+    if (override === "agent") {
+        return { reporter_kind: "agent", reporter_source: "CLI_REPORTER_OVERRIDE" };
+    }
+    return {
+        reporter_kind: "human",
+        reporter_source: isTTY ? "stdin_isTTY" : "no_agent_runtime_marker",
+    };
+}
 function buildFeedbackRequestBody(opts) {
     const requestBody = {
         type: opts.type,
@@ -53,6 +81,10 @@ function buildFeedbackRequestBody(opts) {
         body: opts.body,
         diagnostics: opts.diagnostics,
     };
+    if (opts.reporterMark) {
+        requestBody.reporter_kind = opts.reporterMark.reporter_kind;
+        requestBody.reporter_source = opts.reporterMark.reporter_source;
+    }
     if (opts.company) {
         requestBody.company = opts.company;
     }
@@ -124,6 +156,9 @@ export async function submitFeedback(opts) {
     // which invokes the same validator before uploading any attachments.
     validateFeedbackContent(opts.title, opts.body);
     const diagnostics = opts.diagnostics ?? collectDiagnostics();
+    const reporterMark = opts.type === "bug" && resolveProcessFlagGate(FEEDBACK_REPORTER_KIND_FLAG, { fallback: FEEDBACK_REPORTER_KIND_FLAG_FALLBACK }, () => FEEDBACK_REPORTER_KIND_FLAG_FALLBACK)
+        ? resolveFeedbackReporter(process.env, process.stdin.isTTY === true, opts.reporterOverride)
+        : undefined;
     const requestBody = buildFeedbackRequestBody({
         type: opts.type,
         title: opts.title,
@@ -132,6 +167,7 @@ export async function submitFeedback(opts) {
         diagnostics,
         screenshots: opts.screenshots,
         logBundle: opts.logBundle,
+        reporterMark,
     });
     // Direct callers can supply attachment references; ensure the complete base
     // envelope still fits before adding optional inline logs or making a request.
@@ -172,12 +208,16 @@ function registerSubcommand(feedbackCmd, type) {
         .requiredOption("--title <text>", "Short title for the report")
         .requiredOption("--body-file <path>", "Path to a markdown file with the body; use - to read from stdin")
         .option("--company <slug>", "Company slug to associate with the report")
+        .option("--reporter <kind>", "Mark this bug report as agent-filed (only 'agent' is accepted)")
         .option("--screenshot <path>", `Attach a screenshot (repeatable, up to ${MAX_SCREENSHOTS}; .png/.jpg/.jpeg/.webp/.gif)`, (value, prev) => [...prev, value], [])
         // Commander turns `--no-logs` into a boolean `logs` that defaults to true,
         // so the default is "attach logs" and the flag is the opt-out.
         .option("--no-logs", "Do not attach redacted tails of your ~/.hq log files (also: HQ_FEEDBACK_LOGS=0)")
         .action(async (opts) => {
         try {
+            if (opts.reporter !== undefined && (opts.reporter !== "agent" || type !== "bug")) {
+                throw new Error("Invalid --reporter value: only bug reports may use 'agent'.");
+            }
             const token = await ensureCognitoToken({ interactive: false });
             const body = await readBodyFile(opts.bodyFile);
             validateFeedbackContent(opts.title, body);
@@ -192,6 +232,9 @@ function registerSubcommand(feedbackCmd, type) {
                     diagnostics.latestVersion = latestVersion;
             }
             const logsEnabled = opts.logs !== false && feedbackLogsEnabled();
+            const reporterMark = type === "bug" && resolveProcessFlagGate(FEEDBACK_REPORTER_KIND_FLAG, { fallback: FEEDBACK_REPORTER_KIND_FLAG_FALLBACK }, () => FEEDBACK_REPORTER_KIND_FLAG_FALLBACK)
+                ? resolveFeedbackReporter(process.env, process.stdin.isTTY === true, opts.reporter)
+                : undefined;
             // Validate the serialized server request envelope before screenshots
             // or the log bundle can create remote objects. Attachment references
             // are added and checked again inside submitFeedback after upload.
@@ -201,6 +244,7 @@ function registerSubcommand(feedbackCmd, type) {
                 body,
                 company: opts.company,
                 diagnostics,
+                reporterMark,
             }));
             // vaultApiFetch can reject an hqk_ token or an invalid API base URL
             // locally before fetch. Check the mandatory POST, and the screenshot
@@ -236,6 +280,7 @@ function registerSubcommand(feedbackCmd, type) {
                 includeLogs: opts.logs !== false,
                 logBundle,
                 diagnostics,
+                reporterOverride: opts.reporter === "agent" ? "agent" : undefined,
                 logsEnabled,
             });
             console.log(`Submitted: ${result.id}`);