@indigoai-us/hq-cli 5.153.0 → 5.155.0

package/CHANGELOG.md

@@ -2,12 +2,50 @@
 
 ## [Unreleased]
 
+## [5.155.0] — 2026-09-24
+
+### Fixed
+
+- Lane respawns keep their recorded account to preserve provider sessions and
+  prompt caches. Automatic moves now record why they happened and are limited
+  to model changes, usage limits, and unavailable or logged-out accounts.
+- Account retries share the provider admission lock and the host-scoped provider,
+  account, and profile checks used by normal admission. Active reservations and
+  earlier eligible queue entries keep their place; blocked retries remain queued
+  for normal admission. Retries skip accounts already rejected for login and
+  retain message, resume, and answer context when queued.
+- Watcher retries resolve the current process hostname and Outpost identity, so
+  local-kind and Outpost-kind lanes on one Outpost share admission caps.
+- Account enable and registration now require a positive login check. Provider
+  startup messages for logged-out accounts trigger failover to another eligible
+  account or a named `account_not_logged_in` failure.
+
+### Added
+
+- Provider config can list accounts in preference order for a lane's first
+  assignment. Disabled, logged-out, usage-limited, and capped accounts are
+  skipped. If no preferred account is eligible, hq-cli chooses the least-loaded
+  eligible account. Running and resumed lanes keep their recorded account.
+
+## [5.154.0] — 2026-09-24
+
+### Fixed
+
+- Local bots can now open files attached in HQ chat. The new `hq_attachment_fetch` agent tool downloads a chat or DM attachment into a private folder under the bot's agent directory and returns its local path, content type, and size (text files also come back inline). It accepts only the scope-relative `chat/attachments/...` paths that `hq_inbox_read` reports, fetches only from the bot's own company or from a DM the bot is part of, refuses files over 26 MiB, and uses the API the bot enrolled against. Because the attachment reference comes from the sender, any other vault path (for example `knowledge/...`, or a folder) is refused and the bot is pointed at `hq_files_read`. Previously `hq_files_read` rejected those paths and could not read binary files such as .xlsx.
+
 ## [5.153.0] — 2026-09-23
 
 ### Fixed
 
 - `hq mesh context prd-sync` rebinds a session to the PRD's project when that project is in the same company, then emits `task_status` against the new project so the Board and channel line land there. A PRD in another company is still skipped and does not rebind.
 
+### Tests
+
+- Cover Outpost admission when account a is at its Codex cap and account b
+  has queued work with available capacity.
+- Cover fresh pending resumes and answered-lane resumes against provider
+  capacity.
+
 ## [5.152.1] — 2026-09-23
 
 ### Fixed

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

@@ -9,6 +9,7 @@
  * hq binary with the machine-identity env pinned.
  */
 import { Command } from "commander";
+import type { Readable } from "node:stream";
 import { McpServer } from "../lib/agent-kit/mcp/jsonrpc.js";
 import { type HqRunResult, type McpToolClients } from "../lib/agent-kit/mcp/tools.js";
 import { type AgentKitPaths } from "../lib/agent-kit/paths.js";
@@ -17,7 +18,9 @@ export declare const AGENT_MCP_SERVER_NAME = "hq-agent";
 export declare const AGENT_MCP_INSTRUCTIONS: string;
 export declare const HQ_SUBPROCESS_TIMEOUT_MS = 120000;
 export declare function defaultRunHq(nodeBinary: string, hqBinary: string, env: NodeJS.ProcessEnv): (args: string[]) => Promise<HqRunResult>;
-export declare function defaultMcpClients(creds: ExternalMachineCreds, credsPath: string, paths?: Pick<AgentKitPaths, "inboxDir">): McpToolClients;
+export declare function defaultMcpClients(creds: ExternalMachineCreds, credsPath: string, paths?: Pick<AgentKitPaths, "inboxDir" | "attachmentsDir">): McpToolClients;
+/** Drain a stream into memory, refusing past `max` bytes. */
+export declare function readBounded(body: Readable, max: number): Promise<Buffer>;
 export declare function createAgentMcpServer(clients: McpToolClients): McpServer;
 export declare function registerAgentMcpCommand(agent: Command): void;
 //# sourceMappingURL=agent-mcp.d.ts.map

package/dist/commands/agent-mcp.js

@@ -12,7 +12,10 @@ import { spawn } from "node:child_process";
 import * as os from "node:os";
 import { CLI_VERSION } from "../cli-version.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { vaultApiFetch } from "../utils/vault-api.js";
+import { GetObjectCommand } from "@aws-sdk/client-s3";
+import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
+import { createCompanyPresignClient } from "./files-browse.js";
+import { MAX_ATTACHMENT_BYTES } from "../lib/agent-kit/mcp/attachments.js";
 import { McpServer } from "../lib/agent-kit/mcp/jsonrpc.js";
 import { buildAgentMcpTools } from "../lib/agent-kit/mcp/tools.js";
 import { readKitConfig } from "../lib/agent-kit/kit-config.js";
@@ -21,6 +24,7 @@ import { requireExternalCreds } from "./agent-kit.js";
 export const AGENT_MCP_SERVER_NAME = "hq-agent";
 export const AGENT_MCP_INSTRUCTIONS = "You are acting inside HQ as an enrolled external agent. Tools run as that machine identity: " +
     "hq_whoami (identity), hq_search / hq_files_list / hq_files_read (company vault), " +
+    "hq_attachment_fetch (download a chat attachment — a chat/attachments/… vaultPath on an inbox message — any file type), " +
     "hq_secrets_list / hq_secrets_exec (secrets by NAME only — values are never returned), " +
     "hq_inbox_read / hq_dm_send / hq_inbox_done (read pending HQ messages, reply, then mark each handled), hq_work_mesh_status (what the team is doing). " +
     "Never ask a user for a token or secret value; if a secret is missing, name it and ask an admin to add it.";
@@ -54,12 +58,34 @@ export function defaultMcpClients(creds, credsPath, paths = agentKitPaths(os.hom
         HQ_VAULT_API_URL: creds.apiBaseUrl,
         NO_COLOR: "1",
     };
+    const getToken = () => ensureCognitoToken({ tokenSource: "machine", interactive: false });
+    let companyUid;
     return {
         creds,
         paths,
         syncFiles: readKitConfig(agentKitPaths(os.homedir(), process.env), CLI_VERSION).syncFiles,
         runHq: defaultRunHq(process.execPath, process.argv[1], env),
-        getToken: () => ensureCognitoToken({ tokenSource: "machine", interactive: false }),
+        getToken,
+        resolveCompanyUid: async () => {
+            // Pin the enrolled API: DEFAULT_VAULT_API_URL was read from env at module
+            // load, before `hq agent mcp` sets HQ_VAULT_API_URL from the creds.
+            companyUid ??= getCompanyUid(await getToken(), creds.companySlug, creds.apiBaseUrl);
+            try {
+                return await companyUid;
+            }
+            catch (err) {
+                companyUid = undefined;
+                throw err;
+            }
+        },
+        downloadVaultObject: async (scopeUid, key) => {
+            // Same presign path `hq files cat` uses; the vault API's per-key ACL decides.
+            const client = createCompanyPresignClient({ token: await getToken(), companyUid: scopeUid, baseUrl: creds.apiBaseUrl });
+            const res = await client.send(new GetObjectCommand({ Bucket: scopeUid, Key: key }));
+            if (!res.Body)
+                throw new Error(`no body returned for '${key}'`);
+            return readBounded(res.Body, MAX_ATTACHMENT_BYTES);
+        },
         apiJson: async (token, path, init) => {
             const res = await vaultApiFetch({
                 token,
@@ -74,6 +100,21 @@ export function defaultMcpClients(creds, credsPath, paths = agentKitPaths(os.hom
         },
     };
 }
+/** Drain a stream into memory, refusing past `max` bytes. */
+export async function readBounded(body, max) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of body) {
+        const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += b.length;
+        if (total > max) {
+            body.destroy();
+            throw new Error(`object exceeds the ${max}-byte attachment limit`);
+        }
+        chunks.push(b);
+    }
+    return Buffer.concat(chunks);
+}
 export function createAgentMcpServer(clients) {
     return new McpServer({
         name: AGENT_MCP_SERVER_NAME,

package/dist/commands/files-browse.d.ts

@@ -450,6 +450,12 @@ export declare function createCompanyPresignClient(input: {
      * (keys on these errors are bucket-relative and carry no slug).
      */
     companySlug?: string;
+    /**
+     * Control-plane origin for list/presign calls. Defaults to
+     * DEFAULT_VAULT_API_URL (via vaultApiFetch); an enrolled agent passes its
+     * own `apiBaseUrl` so its token only goes to the API it enrolled against.
+     */
+    baseUrl?: string;
 }): FilesBrowseS3Client;
 /**
  * Production company-mode client factory — closes over the caller's token and

package/dist/commands/files-browse.js

@@ -678,7 +678,7 @@ export const PRESIGN_BUFFER_MAX_BYTES = 32 * 1024 * 1024;
  * `send(...)` as if it held an S3 client.
  */
 export function createCompanyPresignClient(input) {
-    const { token, companyUid, companySlug } = input;
+    const { token, companyUid, companySlug, baseUrl } = input;
     const denied = (message, key, extra) => Object.assign(new Error(message), {
         status: 403,
         key,
@@ -692,7 +692,7 @@ export function createCompanyPresignClient(input) {
             query.prefix = prefix;
         if (cmd.input.ContinuationToken)
             query.cursor = cmd.input.ContinuationToken;
-        const res = await vaultApiFetch({ token, path: "/v1/files/list", query });
+        const res = await vaultApiFetch({ token, baseUrl, path: "/v1/files/list", query });
         if (!res.ok) {
             const body = (await res.json().catch(() => ({})));
             const message = body.message ?? body.error ?? `files list failed (${res.status})`;
@@ -723,6 +723,7 @@ export function createCompanyPresignClient(input) {
         const key = cmd.input.Key;
         const res = await vaultApiFetch({
             token,
+            baseUrl,
             path: "/v1/files/presign",
             method: "POST",
             body: { company: companyUid, key, op: "get" },

package/dist/commands/lanes.d.ts

@@ -6,6 +6,9 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
+import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
+export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
+export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
 import { MAX_LANE_DEPTH, type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
@@ -16,17 +19,7 @@ import { spawnLaneWorker, type KillProcessFn, type ProveDetachedFn, type SpawnPr
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
-export declare const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
-export declare const OUTPOST_DIR = "/etc/outpost";
 export declare const LANES_RUNS_REL: string;
-export type OutpostIdentity = {
-    kind: "id";
-    id: string;
-} | {
-    kind: "unknown";
-} | {
-    kind: "not_outpost";
-};
 export interface SpawnLoginResult {
     status: number;
 }
@@ -79,7 +72,6 @@ export interface LanesCommandDeps {
     locateTranscript?: (home: string, sessionId: string) => string | null;
     monitorEvidence?: MonitorEvidenceReader;
 }
-export declare function readOutpostIdentity(existsSync?: (p: string) => boolean, readFileSync?: (p: string) => string): OutpostIdentity;
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
 /**

package/dist/commands/lanes.js

@@ -12,13 +12,15 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
+export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 import { buildOutpostLaneCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, isLoggedOut, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -33,8 +35,6 @@ import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ON
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
-export const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
-export const OUTPOST_DIR = "/etc/outpost";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 const VENDOR_LOGIN = {
     claude: { command: "claude", args: ["auth", "login"] },
@@ -133,27 +133,6 @@ async function defaultFetchText(url) {
     }
     return res.text();
 }
-export function readOutpostIdentity(existsSync = (p) => fs.existsSync(p), readFileSync = (p) => fs.readFileSync(p, "utf8")) {
-    const hasMarker = existsSync(OUTPOST_ID_PATH);
-    const hasDir = existsSync(OUTPOST_DIR);
-    if (hasMarker) {
-        let text;
-        try {
-            text = readFileSync(OUTPOST_ID_PATH);
-        }
-        catch (err) {
-            process.stderr.write(`hq lanes: failed to read ${OUTPOST_ID_PATH}: ${err instanceof Error ? err.message : String(err)}\n`);
-            throw err;
-        }
-        const id = text.trim();
-        if (!id)
-            return hasDir ? { kind: "unknown" } : { kind: "not_outpost" };
-        return { kind: "id", id };
-    }
-    if (hasDir)
-        return { kind: "unknown" };
-    return { kind: "not_outpost" };
-}
 function defaultSpawnLogin(opts) {
     return new Promise((resolve, reject) => {
         const child = spawn(opts.command, opts.args, {
@@ -263,11 +242,10 @@ function livenessDepsFromCtx(ctx) {
     };
 }
 function reconcileHostFromCtx(ctx) {
-    const identity = ctx.readOutpostIdentity();
-    return {
-        hostname: ctx.hostname(),
-        outpostId: identity.kind === "id" ? identity.id : null,
-    };
+    return resolveAdmissionHost({
+        hostname: ctx.hostname,
+        readOutpostIdentity: ctx.readOutpostIdentity,
+    });
 }
 export function parseSeniorRef(raw) {
     const trimmed = raw.trim();
@@ -1261,9 +1239,17 @@ export function applyOutpostAccountPickup(hqRoot, laneId, modelDeps = {}) {
     try {
         const resolved = resolveAccount(lane.provider, lane.account, config, {
             hqRoot,
+            accountDeps: {
+                probe: modelDeps.probe,
+                env: modelDeps.env,
+            },
+        });
+        const status = accountStatus(lane.provider, resolved.id, config, {
+            existsSync: (p) => fs.existsSync(p),
+            probe: modelDeps.probe,
+            env: modelDeps.env,
         });
-        const status = accountStatus(lane.provider, resolved.id, config);
-        if (isLoggedOut(status)) {
+        if (status.logged_in !== true) {
             return markPickupFailure(hqRoot, laneId, "account_not_logged_in", {
                 provider: lane.provider,
                 account: resolved.id,
@@ -1549,8 +1535,10 @@ async function runCreate(ctx, opts) {
             resolveAccount(provider, undefined, config, {
                 hqRoot,
                 existsSync: ctx.existsSync,
+                accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
                 model: modelToValidate,
+                preferredAccounts: config.providers[provider].preferred_accounts ?? [],
                 ...(profileAccounts !== undefined
                     ? { allowedAccounts: profileAccounts }
                     : {}),
@@ -1563,7 +1551,11 @@ async function runCreate(ctx, opts) {
                     .filter((id) => id !== candidate &&
                     accounts[id]?.enabled &&
                     (profileAccounts === undefined || profileAccounts.includes(id)) &&
-                    accountStatus(provider, id, config, { existsSync: ctx.existsSync }).logged_in === true)
+                    accountStatus(provider, id, config, {
+                        existsSync: ctx.existsSync,
+                        probe: ctx.probeProvider,
+                        env: ctx.env,
+                    }).logged_in === true)
                     .sort(),
             ];
         const checkedAccounts = [];
@@ -1648,8 +1640,10 @@ async function runCreate(ctx, opts) {
             pinnedAccount = resolveAccount(provider, undefined, config, {
                 hqRoot,
                 existsSync: ctx.existsSync,
+                accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
                 model: cliModel ?? profileModel,
+                preferredAccounts: config.providers[provider].preferred_accounts ?? [],
                 ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
             }).id;
         }
@@ -1797,6 +1791,7 @@ async function runCreate(ctx, opts) {
                 probe: ctx.probeProvider,
                 env: ctx.env,
             },
+            currentModelValidated: !outpostId && modelToValidate !== undefined,
             existsSync: ctx.existsSync,
             spawnProcess: ctx.spawnProcess,
             proveDetached: ctx.proveDetached,
@@ -2196,6 +2191,7 @@ async function runPickup(ctx, opts) {
                     probe: ctx.probeProvider,
                     env: ctx.env,
                 },
+                currentModelValidated: afterAccount.model !== undefined,
                 existsSync: ctx.existsSync,
                 spawnProcess: ctx.spawnProcess,
                 proveDetached: ctx.proveDetached,
@@ -2512,7 +2508,11 @@ async function prepareAccountMove(ctx, lane, input) {
     if (!targetCfg.enabled) {
         throw new AccountResolutionError("account_disabled", `Account ${JSON.stringify(target)} is disabled${targetCfg.disabled_reason ? `: ${targetCfg.disabled_reason}` : ""}`, { provider: lane.provider, account: target, reason: targetCfg.disabled_reason ?? "" });
     }
-    if (isLoggedOut(accountStatus(lane.provider, target, config, { existsSync: ctx.existsSync }))) {
+    if (accountStatus(lane.provider, target, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).logged_in !== true) {
         throw new LanesError("account_not_logged_in", `Account ${target} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: target, lane_id: laneId });
     }
     const profile = lane.worker_profile !== undefined
@@ -3829,7 +3829,11 @@ async function runAccountsList(ctx, opts) {
     // model and effort are what a spawn on each account would start from
     // (spec: --model/--effort, then the account, then the provider).
     const quota = loadQuotaState(hqRoot);
-    const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config).map((status) => {
+    const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).map((status) => {
         const accountCfg = config.providers[provider].accounts[status.id];
         const model = resolveLaneModel({
             accountModel: accountCfg?.model,
@@ -3930,8 +3934,17 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         home,
         enabled: true,
     };
+    const status = accountStatus(provider, id, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    });
+    if (status.logged_in !== true) {
+        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+            ? `Account ${id} for ${provider} is not logged in`
+            : `Could not verify that account ${id} for ${provider} is logged in`, { provider, account: id, home });
+    }
     writeLanesConfig(hqRoot, config);
-    const status = accountStatus(provider, id, loadLanesConfig(hqRoot));
     printJson({ ok: true, action: "accounts.login", account: status });
 }
 async function runAccountsEnable(ctx, providerRaw, accountId) {
@@ -3948,13 +3961,27 @@ async function runAccountsEnable(ctx, providerRaw, accountId) {
                 .map(([id]) => id),
         });
     }
+    const status = accountStatus(provider, accountId, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    });
+    if (status.logged_in !== true) {
+        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+            ? `Account ${accountId} for ${provider} is not logged in`
+            : `Could not verify that account ${accountId} for ${provider} is logged in`, { provider, account: accountId });
+    }
     account.enabled = true;
     delete account.disabled_reason;
     writeLanesConfig(hqRoot, config);
     printJson({
         ok: true,
         action: "accounts.enable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+            existsSync: ctx.existsSync,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }),
     });
 }
 async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
@@ -3978,7 +4005,11 @@ async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
     printJson({
         ok: true,
         action: "accounts.disable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+            existsSync: ctx.existsSync,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }),
     });
 }
 async function runSessionsList(ctx, opts) {

package/dist/lib/agent-kit/mcp/attachments.d.ts

@@ -0,0 +1,99 @@
+/**
+ * `hq_attachment_fetch` — pull a chat attachment named on an inbox item down
+ * to a private local file the bot can open.
+ *
+ * Inbox items carry attachments as `{ vaultPath, companyUid, … }` where
+ * `vaultPath` is SCOPE-relative (`chat/attachments/{dm|chan}/<id>/<file>`) and
+ * `companyUid` is the vault scope the bytes live in: the company uid for a
+ * company channel, or the SENDER's person uid (`prs_…`) for a DM, because a DM
+ * attachment is stored in the sender's personal vault. Neither `hq_files_read`
+ * (which only accepts `companies/<slug>/…` and returns clamped text) nor
+ * anything else on the MCP surface could read those, so bots answered
+ * "I can't open the file".
+ *
+ * Bytes come through the same vault presign path `hq files cat` uses
+ * (`createCompanyPresignClient` → POST /v1/files/presign), minted with the
+ * bot's own machine token, so the server's per-key ACL stays the authority.
+ * The client-side checks here are the tenant boundary the bot can state
+ * before any request leaves the machine. They matter because an attachment
+ * ref is SENDER-controlled while the server authorizes against the BOT's own
+ * access: without them a sender could attach any key the bot can read (say
+ * `knowledge/restricted/x.csv` in the bot's company) and have the bot fetch
+ * it for them.
+ *   - the key must be a plain relative path with no traversal, under
+ *     `chat/attachments/`;
+ *   - a DM key (`chat/attachments/dm/<a>--<b>/…`) must name this bot in the
+ *     pair, whichever scope it is read from;
+ *   - a `cmp_` scope must be the bot's own enrolled company;
+ *   - a `prs_` scope is only a DM attachment between that person and this
+ *     bot (the pair naming both).
+ *
+ * Files land under `<agentDir>/attachments/<scopeUid>/` (dir 0700, file 0600)
+ * with a sanitized name, so nothing from the message can pick the location.
+ */
+/**
+ * Refuse anything larger than this. Chat uploads are capped at 25 MB
+ * (MAX_CHAT_ATTACHMENT_BYTES in hq-desktop-app); 26 MiB leaves a little
+ * headroom over that without letting a crafted key pull a large vault object.
+ */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** Upper bound on the inline text rendering returned alongside the path. */
+export declare const MAX_ATTACHMENT_TEXT_CHARS = 20000;
+/** Every chat upload lands under this prefix in its scope. */
+export declare const CHAT_ATTACHMENT_PREFIX = "chat/attachments/";
+/**
+ * Validate a scope-relative attachment key. Accepts only `chat/attachments/…`
+ * file keys exactly as inbox items carry them. Folder / share refs (`/`,
+ * `…/`) get a "not a chat attachment" error pointing at hq_files_read.
+ * Rejects absolute paths, traversal, empty / dot segments, backslashes and
+ * control characters. Returns the key with any leading slashes stripped.
+ */
+export declare function assertAttachmentKey(p: string): string;
+/** Throws unless `scopeUid` is a well-formed cmp_/prs_ uid. No network. */
+export declare function assertAttachmentScopeUid(scopeUid: string): void;
+/**
+ * The checks that need no network: uid format, DM-pair membership for any
+ * `chat/attachments/dm/…` key, and the prs_ scope rule. Run before resolving
+ * the bot's company so a refused ref never costs (or leaks) a request.
+ */
+export declare function assertAttachmentRef(input: {
+    scopeUid: string;
+    key: string;
+    botEntityUid: string;
+}): void;
+/**
+ * Tenant gate. Throws unless the scope is this bot's own company, or a
+ * person vault holding a DM attachment between that person and this bot.
+ */
+export declare function assertAttachmentScope(input: {
+    scopeUid: string;
+    key: string;
+    botCompanyUid: string;
+    botEntityUid: string;
+}): void;
+/** Reduce an untrusted name to a safe single path component. */
+export declare function sanitizeAttachmentFileName(raw: string): string;
+export interface FetchAttachmentResult {
+    localPath: string;
+    name: string;
+    contentType?: string;
+    sizeBytes: number;
+    vaultPath: string;
+    companyUid: string;
+    /** Inline rendering for text-like files (csv, txt, json, …), bounded. */
+    text?: string;
+    note?: string;
+}
+/**
+ * Download `key` from `scopeUid` and write it privately under `attachmentsDir`.
+ * `download` is the presign-backed reader; the caller has already gated scope.
+ */
+export declare function saveAttachment(input: {
+    attachmentsDir: string;
+    scopeUid: string;
+    key: string;
+    name?: string;
+    contentType?: string;
+    download: (scopeUid: string, key: string) => Promise<Buffer>;
+}): Promise<FetchAttachmentResult>;
+//# sourceMappingURL=attachments.d.ts.map