@indigoai-us/hq-cli 5.345.48 → 5.345.50

package/dist/commands/dm.js

@@ -5,6 +5,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { isMachineIdentity } from "@indigoai-us/hq-cloud";
 import { peekIdToken } from "../utils/id-token.js";
 import { EMAIL_PATTERN, RECIPIENT_UID_PATTERN } from "../lib/notify-recipient.js";
+import { dmForwardCliEnabled } from "./dm-forward-flag.js";
 /**
  * Classify a recipient arg as an email or a person/agent uid. Mirrors the
  * email/uid heuristic used by `hq members`. Returns null for neither.
@@ -346,6 +347,32 @@ function friendlyDmError(status, code, fallback) {
         return `Server error: ${fallback}`;
     return fallback;
 }
+function friendlyForwardError(code) {
+    switch (code) {
+        case "FORWARD_SOURCE_NOT_FOUND":
+            return "Source message not found or you cannot read it.";
+        case "INVALID_FORWARD_OF":
+            return "Invalid source message reference; provide a valid eventId and --from value.";
+        case "INVALID_FILE_ACCESS":
+            return "Invalid file access choice; use --grant-files or --omit-files.";
+        case "FORWARD_FILE_ACCESS_REQUIRED":
+            return "Some forwarded files are not readable by the recipient.";
+        case "FORWARD_FILES_NOT_ALLOWED":
+            return "Files cannot be granted for this channel or cross-company forward.";
+        case "CROSS_COMPANY_ACK_REQUIRED":
+            return "Warning: this forward crosses company boundaries; review the destination and retry with --cross-company.";
+        case "CROSS_COMPANY_FORBIDDEN":
+            return "Cross-company forwarding requires owner or admin access in both companies.";
+        case "FORWARD_FILE_SHARE_FORBIDDEN":
+            return "You do not have permission to share one or more forwarded files.";
+        case "FORWARD_FILE_GRANT_FAILED":
+            return "The recipient could not be granted access to a forwarded file; no message was sent.";
+        case "RECIPIENT_NOT_FOUND":
+            return "Recipient not found or not reachable.";
+        default:
+            return "Message forwarding failed; check the source and destination, then try again.";
+    }
+}
 /**
  * Resolve a connection request from a pending-requests list by a caller-supplied
  * identifier (email, personUid, or pairKey). Pure → unit-testable.
@@ -529,6 +556,21 @@ export async function fetchChannelMembers(token, channelId) {
     const data = (await res.json());
     return data.members ?? [];
 }
+/** Resolve structured mentions in a channel message body, failing before post on invalid names. */
+async function resolveChannelBodyMentions(token, channelId, body) {
+    const tokens = parseMentionTokens(body);
+    if (tokens.length === 0)
+        return { ok: true, body, mentions: [] };
+    const members = await fetchChannelMembers(token, channelId);
+    const resolved = resolveMentions(tokens, members);
+    if (!resolved.ok)
+        return resolved;
+    return {
+        ok: true,
+        body: stripMentionQuotes(body),
+        mentions: resolved.mentions,
+    };
+}
 /** Fetch a channel history page (GET /v1/notify/channels/{id}/messages). Newest-first. */
 async function fetchChannelMessages(token, channelId, query = {}) {
     const res = await vaultApiFetch({
@@ -546,9 +588,9 @@ async function fetchChannelMessages(token, channelId, query = {}) {
 /**
  * Channel DM path: `hq dm vyg-dev "msg"`, `hq dm '#vyg-dev' "msg"`, or
  * `hq dm --channel vyg-dev "msg"`. Resolves the caller's channel by name via
- * GET /v1/notify/channels, then posts the message into it. Scheduling /
- * prompt / details are 1:1-DM features and are rejected here rather than
- * silently dropped.
+ * GET /v1/notify/channels, then posts the message into it. Scheduling remains
+ * a 1:1-DM feature; prompt and details are supported for channel sends while
+ * the dm.forward-cli kill switch is enabled.
  */
 async function runChannelSend(channelName, message, opts) {
     try {
@@ -557,12 +599,17 @@ async function runChannelSend(channelName, message, opts) {
             console.error(chalk.red(`A message body is required: hq dm ${channelName} "<message>" (or hq dm --channel ${channelName} "<message>").`));
             process.exit(1);
         }
-        const unsupported = [
-            opts.prompt || opts.promptFile ? "--prompt/--prompt-file" : null,
-            opts.details || opts.detailsFile ? "--details/--details-file" : null,
-            opts.at ? "--at" : null,
-            opts.in ? "--in" : null,
-        ].filter(Boolean);
+        const hasChannelContext = opts.prompt !== undefined || opts.promptFile !== undefined ||
+            opts.details !== undefined || opts.detailsFile !== undefined;
+        if (hasChannelContext && !dmForwardCliEnabled()) {
+            console.error(chalk.red("Channel --details/--prompt support is disabled by the dm.forward-cli kill switch."));
+            process.exit(1);
+        }
+        if (opts.promptFile === "" || opts.detailsFile === "") {
+            console.error(chalk.red("--prompt-file and --details-file require a non-empty path."));
+            process.exit(1);
+        }
+        const unsupported = [opts.at ? "--at" : null, opts.in ? "--in" : null].filter(Boolean);
         if (unsupported.length > 0) {
             console.error(chalk.red(`${unsupported.join(", ")} ${unsupported.length === 1 ? "is" : "are"} only supported for 1:1 DMs, not channel messages.`));
             process.exit(1);
@@ -599,21 +646,16 @@ async function runChannelSend(channelName, message, opts) {
         // and posts the text literally.
         let mentions = [];
         if (opts.mentions !== false) {
-            const tokens = parseMentionTokens(body);
-            if (tokens.length > 0) {
-                const members = await fetchChannelMembers(token, channel.channelId);
-                const resolved = resolveMentions(tokens, members);
-                if (!resolved.ok) {
-                    console.error(chalk.red(resolved.error));
-                    process.exit(1);
-                    return;
-                }
-                mentions = resolved.mentions;
+            const resolved = await resolveChannelBodyMentions(token, channel.channelId, body);
+            if (!resolved.ok) {
+                console.error(chalk.red(resolved.error));
+                process.exit(1);
+                return;
             }
+            body = resolved.body;
+            mentions = resolved.mentions;
         }
         // Send the human-readable form: the quotes only existed for parsing.
-        if (mentions.length > 0)
-            body = stripMentionQuotes(body);
         let audience;
         if (opts.audience !== undefined && opts.audience !== "") {
             if (!DM_AUDIENCE_VALUES.includes(opts.audience)) {
@@ -622,6 +664,12 @@ async function runChannelSend(channelName, message, opts) {
             audience = opts.audience;
         }
         const payload = { body };
+        const prompt = opts.promptFile ? readFileSync(opts.promptFile, "utf8") : opts.prompt;
+        const details = opts.detailsFile ? readFileSync(opts.detailsFile, "utf8") : opts.details;
+        if (prompt !== undefined)
+            payload.prompt = prompt;
+        if (details !== undefined)
+            payload.details = details;
         if (mentions.length > 0)
             payload.mentions = mentions;
         if (rootEventId)
@@ -736,6 +784,130 @@ async function runDmSend(recipient, message, opts) {
         process.exit(1);
     }
 }
+async function resolveForwardSourceConversation(token, source) {
+    if (source.includes(",")) {
+        throw new Error("--from accepts one person or channel, not a group recipient list.");
+    }
+    const channelName = parseChannelName(source);
+    if (channelName !== null) {
+        const channel = await resolveChannel(token, channelName);
+        return { conversationId: channel.channelId };
+    }
+    const recipient = detectRecipient(source);
+    if (!recipient) {
+        throw new Error("--from must be a person email, person/agent UID, or channel name/ID.");
+    }
+    if (recipient.toPersonUid)
+        return { conversationId: recipient.toPersonUid };
+    const res = await vaultApiFetch({ token, path: "/v1/notify/contacts" });
+    if (!res.ok)
+        throw new Error("Could not resolve the source person; use their person UID.");
+    const data = (await res.json());
+    const peer = (data.contacts ?? []).find((contact) => contact.email?.trim().toLowerCase() === recipient.toEmail);
+    if (!peer?.personUid)
+        throw new Error("Source person not found in your contacts; use their person UID.");
+    return { conversationId: peer.personUid };
+}
+async function runDmForward(eventId, opts) {
+    try {
+        if (!dmForwardCliEnabled()) {
+            console.error(chalk.red("Message forwarding is disabled by the dm.forward-cli kill switch."));
+            process.exit(1);
+        }
+        if (opts.grantFiles && opts.omitFiles) {
+            console.error(chalk.red("Choose only one of --grant-files or --omit-files."));
+            process.exit(1);
+        }
+        if (opts.note !== undefined && opts.noteFile !== undefined) {
+            console.error(chalk.red("Choose only one of --note or --note-file."));
+            process.exit(1);
+        }
+        if (!eventId.trim()) {
+            console.error(chalk.red("A source eventId is required."));
+            process.exit(1);
+        }
+        if (opts.to.includes(",")) {
+            console.error(chalk.red("--to accepts one recipient or channel, not a group recipient list."));
+            process.exit(1);
+        }
+        const note = opts.noteFile !== undefined
+            ? readFileSync(opts.noteFile, "utf8")
+            : opts.note;
+        const token = await ensureCognitoToken();
+        const source = await resolveForwardSourceConversation(token, opts.from);
+        const destinationChannelName = parseChannelName(opts.to);
+        const fileAccess = opts.grantFiles ? "grant" : opts.omitFiles ? "omit" : undefined;
+        const shared = {
+            ...(note !== undefined ? { body: note } : {}),
+            forwardOf: { conversationId: source.conversationId, eventId: eventId.trim() },
+            ...(fileAccess ? { fileAccess } : {}),
+            ...(opts.crossCompany ? { acknowledgeCrossCompany: true } : {}),
+        };
+        let path;
+        let payload;
+        let destinationLabel;
+        if (destinationChannelName !== null) {
+            const channel = await resolveChannel(token, destinationChannelName);
+            path = `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/messages`;
+            payload = { ...shared };
+            if (note !== undefined) {
+                const resolved = await resolveChannelBodyMentions(token, channel.channelId, note);
+                if (!resolved.ok) {
+                    console.error(chalk.red(resolved.error));
+                    process.exit(1);
+                    return;
+                }
+                payload.body = resolved.body;
+                if (resolved.mentions.length > 0)
+                    payload.mentions = resolved.mentions;
+            }
+            destinationLabel = `#${channel.name ?? destinationChannelName}`;
+        }
+        else {
+            const recipient = detectRecipient(opts.to);
+            if (!recipient) {
+                console.error(chalk.red("--to must be a person email, person/agent UID, or channel name/ID."));
+                process.exit(1);
+            }
+            path = "/v1/notify/dm";
+            payload = { ...recipient, ...shared };
+            destinationLabel = opts.to;
+        }
+        const res = await vaultApiFetch({ token, path, method: "POST", body: payload });
+        if (!res.ok) {
+            const err = (await res.json().catch(() => ({})));
+            const code = typeof err.code === "string" ? err.code : undefined;
+            if (code === "FORWARD_FILE_ACCESS_REQUIRED") {
+                console.error(chalk.yellow(friendlyForwardError(code)));
+                const files = Array.isArray(err.files) ? err.files : [];
+                for (const item of files) {
+                    if (!item || typeof item !== "object")
+                        continue;
+                    const file = item;
+                    const label = typeof file.name === "string" ? file.name : "forwarded file";
+                    const location = typeof file.vaultPath === "string" ? file.vaultPath :
+                        typeof file.path === "string" ? file.path : undefined;
+                    console.error(chalk.dim(`  - ${label}${location ? ` (${location})` : ""}`));
+                }
+                console.error(chalk.dim("Retry with --grant-files or --omit-files."));
+            }
+            else {
+                console.error(chalk.red(friendlyForwardError(code)));
+            }
+            process.exit(1);
+        }
+        const data = (await res.json().catch(() => ({})));
+        if (typeof data.eventId !== "string" || !data.eventId.trim()) {
+            console.error(chalk.red("Forward succeeded without returning an eventId."));
+            process.exit(1);
+        }
+        console.log(chalk.green(`Message forwarded to ${destinationLabel}. New eventId: ${data.eventId}`));
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 async function runDmRequests() {
     try {
         const token = await ensureCognitoToken();
@@ -871,7 +1043,11 @@ export function formatThreadMessage(m, nowMs) {
     const who = m.direction === "out" ? "you" : senderLabel(m);
     const when = chalk.dim(formatRelativeTime(m.createdAt, nowMs));
     const audienceTag = m.audience === "agent" ? chalk.dim(" [agent]") : "";
-    return `${arrow} ${chalk.bold(who)} ${when}${audienceTag}\n    ${firstLine(m.body)}${formatAttachments(m)}`;
+    const id = m.eventId ? `  ${chalk.dim(m.eventId)}` : "";
+    const forwarded = m.forwardedFrom?.senderName
+        ? `\n    ${chalk.dim(`Forwarded from ${m.forwardedFrom.senderName}`)}`
+        : "";
+    return `${arrow} ${chalk.bold(who)} ${when}${audienceTag}${id}${forwarded}\n    ${firstLine(m.body)}${formatAttachments(m)}`;
 }
 /** Render one channel/group message line. */
 export function formatChannelMessage(m, nowMs, opts = {}) {
@@ -886,7 +1062,10 @@ export function formatChannelMessage(m, nowMs, opts = {}) {
         (senderLabel(m).toLowerCase() === "hq"
             ? "System notification (no text provided)."
             : "(no message text)");
-    return `${indent}${who} ${when}${idPart}\n${bodyIndent}${readableBody}${formatAttachments(m, bodyIndent)}`;
+    const forwarded = m.forwardedFrom?.senderName
+        ? `${bodyIndent}${chalk.dim(`Forwarded from ${m.forwardedFrom.senderName}`)}\n`
+        : "";
+    return `${indent}${who} ${when}${idPart}\n${forwarded}${bodyIndent}${readableBody}${formatAttachments(m, bodyIndent)}`;
 }
 /**
  * Read the caller's person/agent uid and email from a JWT we already hold.
@@ -1330,16 +1509,29 @@ export function registerDmCommand(program) {
         .option("--channel <name>", "Post the message to one of your DM channels by name (e.g. --channel vyg-dev)")
         .option("--no-mentions", "Do not resolve `@name` in a channel message into structured mentions — post the text literally")
         .option("--thread <eventId>", 'Reply in a channel thread. Pass a root eventId from `hq dm channel`, or `last` for your most recent top-level message in that channel')
-        .option("--prompt <text>", "Agent-context prompt the recipient can one-click copy into their agent (1:1 DMs only)")
-        .option("--prompt-file <path>", "Read the agent prompt from a file (1:1 DMs only)")
-        .option("--details <text>", "Longer detail shown in the recipient's DM detail window (1:1 DMs only)")
-        .option("--details-file <path>", "Read the details from a file (1:1 DMs only)")
+        .option("--prompt <text>", "Agent-context prompt the recipient can one-click copy into their agent (1:1 DMs; channel sends also supported)")
+        .option("--prompt-file <path>", "Read the agent prompt from a file (1:1 DMs; channel sends also supported)")
+        .option("--details <text>", "Longer detail shown in the recipient's DM detail window (1:1 DMs; channel sends also supported)")
+        .option("--details-file <path>", "Read the details from a file (1:1 DMs; channel sends also supported)")
         .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time; 1:1 DMs only)")
         .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)")
         .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both")
         .action(async (recipient, message, opts) => {
         await runDmSend(recipient, message, opts);
     });
+    dm
+        .command("forward <eventId>")
+        .description("Forward a DM or channel message through the existing send routes.")
+        .requiredOption("--from <person|channel>", "Source person email/UID or channel name/ID")
+        .requiredOption("--to <person|agent|channel>", "Destination person email/UID, agent UID, or channel name/ID")
+        .option("--note <text>", "Optional note to add above the forwarded message")
+        .option("--note-file <path>", "Read the optional forward note from a file")
+        .option("--grant-files", "Grant the recipient access to files they cannot currently open")
+        .option("--omit-files", "Omit files the recipient cannot currently open")
+        .option("--cross-company", "Confirm forwarding across company boundaries")
+        .action(async (eventId, opts) => {
+        await runDmForward(eventId, opts);
+    });
     dm
         .command("inbox")
         .description("List your recent incoming direct messages.")

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}`);

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/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/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. */