@indigoai-us/hq-cli 5.345.156 → 5.345.159

package/dist/commands/feedback.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import chalk from "chalk";
-import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { ensureCognitoToken, loadCachedTokens } from "../utils/cognito-session.js";
 import { assertVaultApiRequestSupported, vaultApiFetch, } from "../utils/vault-api.js";
 import { collectDiagnostics } from "../utils/feedback-diagnostics.js";
 import { MAX_SCREENSHOTS, uploadScreenshots } from "../utils/feedback-screenshots.js";
@@ -8,6 +8,7 @@ import { FEEDBACK_LOGS_MAX_TOTAL_BYTES, FEEDBACK_LOGS_MIN_USEFUL_BYTES, collectF
 import { uploadLogBundle } from "../utils/feedback-log-bundle.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { cachedLatestVersion } from "../utils/version-check.js";
+import { registerFeedbackShowCommand } from "./feedback-show.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";
@@ -199,7 +200,151 @@ export async function submitFeedback(opts) {
         throw new Error(`Failed to submit feedback: ${errMsg}`);
     }
     const data = (await res.json());
-    return { id: data.id };
+    return {
+        id: data.id,
+        ...(typeof data.publicUrl === "string" && data.publicUrl.length > 0
+            ? { publicUrl: data.publicUrl }
+            : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Public ticket pages: `hq feedback link <id>` and `hq feedback update <id>`
+// ---------------------------------------------------------------------------
+/** Customer-visible states accepted by `hq feedback update --state`. */
+export const PUBLIC_TICKET_STATES = [
+    "triaged",
+    "in-progress",
+    "shipped",
+    "verified",
+    "resolved",
+];
+const FEEDBACK_ID_RE = /^feedback_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+export function assertFeedbackId(id) {
+    if (!FEEDBACK_ID_RE.test(id)) {
+        throw new Error(`Invalid feedback id '${id}': expected the full feedback_<uuid> id printed by hq feedback.`);
+    }
+}
+/**
+ * The staff feedback routes gate on the id token's email claim, so send the
+ * cached id token when a person session has one. Machine identities already
+ * get their id token back from ensureCognitoToken.
+ */
+async function resolveStaffToken() {
+    const token = await ensureCognitoToken({ interactive: false });
+    const cached = loadCachedTokens();
+    return typeof cached?.idToken === "string" && cached.idToken.length > 0
+        ? cached.idToken
+        : token;
+}
+async function readFeedbackError(res) {
+    const data = await res.json().catch(() => ({}));
+    return data &&
+        typeof data === "object" &&
+        !Array.isArray(data) &&
+        typeof data.error === "string"
+        ? data.error
+        : res.statusText;
+}
+function publicUrlFrom(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    const url = data.publicUrl;
+    return typeof url === "string" && url.length > 0 ? url : null;
+}
+/** Resolve (and lazily mint) the public tracking link for a ticket. */
+export async function fetchFeedbackLink(opts) {
+    const res = await vaultApiFetch({
+        token: opts.token,
+        path: `/v1/feedback/${opts.id}`,
+        method: "PATCH",
+        body: { ensurePublicToken: true },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to get the public link for ${opts.id}: ${await readFeedbackError(res)}`);
+    }
+    const url = publicUrlFrom(await res.json());
+    if (!url) {
+        throw new Error(`The server did not return a public link for ${opts.id}. Public ticket pages may not be deployed yet.`);
+    }
+    return url;
+}
+/** Post a customer-visible update; the server also mirrors it into #hq-feedback. */
+export async function postFeedbackUpdate(opts) {
+    const res = await vaultApiFetch({
+        token: opts.token,
+        path: `/v1/feedback/${opts.id}`,
+        method: "PATCH",
+        body: { publicUpdate: { state: opts.state, note: opts.note } },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to update ${opts.id}: ${await readFeedbackError(res)}`);
+    }
+    const data = (await res.json());
+    return {
+        publicUrl: publicUrlFrom(data),
+        slack: typeof data.publicUpdateSlack === "string" ? data.publicUpdateSlack : null,
+    };
+}
+function registerLinkSubcommand(feedbackCmd) {
+    feedbackCmd
+        .command("link")
+        .description("Print the public tracking link for a ticket (status.hqforwork.com)")
+        .argument("<id>", "Feedback id (feedback_<uuid>)")
+        .action(async (id) => {
+        try {
+            assertFeedbackId(id);
+            const token = await resolveStaffToken();
+            assertVaultApiRequestSupported({ token, path: `/v1/feedback/${id}` });
+            const url = await fetchFeedbackLink({ id, token });
+            console.log(`Track: ${url}`);
+        }
+        catch (err) {
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+function registerUpdateSubcommand(feedbackCmd) {
+    feedbackCmd
+        .command("update")
+        .description("Post a customer-visible status update on a ticket's public page and its #hq-feedback thread")
+        .argument("<id>", "Feedback id (feedback_<uuid>)")
+        .requiredOption("--state <state>", `One of: ${PUBLIC_TICKET_STATES.join(", ")}`)
+        .requiredOption("--note <text>", "What the customer should read (plain text, up to 2000 characters)")
+        .action(async (id, opts) => {
+        try {
+            assertFeedbackId(id);
+            if (!PUBLIC_TICKET_STATES.includes(opts.state)) {
+                throw new Error(`Invalid --state '${opts.state}': expected one of ${PUBLIC_TICKET_STATES.join(", ")}.`);
+            }
+            const note = opts.note.trim();
+            if (note.length === 0)
+                throw new Error("--note must not be empty.");
+            if (note.length > 2000)
+                throw new Error("--note must be at most 2000 characters.");
+            const token = await resolveStaffToken();
+            assertVaultApiRequestSupported({ token, path: `/v1/feedback/${id}` });
+            const result = await postFeedbackUpdate({
+                id,
+                token,
+                state: opts.state,
+                note,
+            });
+            console.log(`Updated: ${id} -> ${opts.state}`);
+            if (result.publicUrl)
+                console.log(`Track: ${result.publicUrl}`);
+            if (result.slack === "failed") {
+                console.error(chalk.yellow("Warning:"), "the update was saved but the #hq-feedback thread post failed.");
+            }
+            else if (result.slack === "skipped") {
+                console.error(chalk.yellow("Note:"), "the ticket has no #hq-feedback thread, so nothing was posted to Slack.");
+            }
+        }
+        catch (err) {
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
 }
 function registerSubcommand(feedbackCmd, type) {
     feedbackCmd
@@ -284,6 +429,8 @@ function registerSubcommand(feedbackCmd, type) {
                 logsEnabled,
             });
             console.log(`Submitted: ${result.id}`);
+            if (result.publicUrl)
+                console.log(`Track: ${result.publicUrl}`);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
@@ -297,5 +444,8 @@ export function registerFeedbackCommand(program) {
         .description("Submit a bug report or feature request to HQ");
     registerSubcommand(feedbackCmd, "bug");
     registerSubcommand(feedbackCmd, "feature");
+    registerLinkSubcommand(feedbackCmd);
+    registerUpdateSubcommand(feedbackCmd);
+    registerFeedbackShowCommand(feedbackCmd);
 }
 //# sourceMappingURL=feedback.js.map

package/dist/commands/files.d.ts

@@ -9,6 +9,30 @@ export declare const FILES_SHARE_EMPTY_PREFIX_WARNING_FLAG = "files.share-empty-
 export declare function parseDuration(input: string): number | null;
 /** PRD upper bound on browser-launch share-session expiry. */
 export declare const MAX_SHARE_SESSION_EXPIRY_MS: number;
+/**
+ * A more specific ACL row under a prefix, as hq-pro reports it. File ACL
+ * resolution picks the single most specific row that covers a key, so each of
+ * these rows replaces the broader prefix's grants for the keys it covers
+ * (feedback_466fe8b8).
+ */
+export interface AclMaskingRow {
+    path: string;
+    open: boolean;
+    creatorUid: string;
+    grantees: Array<{
+        granteeType: string;
+        granteeId: string;
+        permission: string;
+    }>;
+}
+/** The warning `hq files share` prints when a grant is shadowed by more specific rows. */
+export declare function formatShadowedGrantWarning(input: {
+    prefix: string;
+    principal: string;
+    permission: string;
+    companySlug?: string;
+    maskedBy: AclMaskingRow[];
+}): string;
 export interface ShareSessionResponse {
     url: string;
     token?: string;

package/dist/commands/files.js

@@ -9,6 +9,7 @@ import { looksLikeCompanyUid } from "../utils/vault-api.js";
 import { AuthError } from "../utils/auth-error.js";
 import { formatAccessDenied, offerAccessLadder, } from "../utils/access-denied-hint.js";
 import { fetchChannels, matchChannelsByName } from "./dm.js";
+import { suggestChannels, withChannelSuggestions } from "./channel-suggest.js";
 import { resolveCompanySlug, resolvePersonWithRosterFallback, } from "./people.js";
 import { findHqRoot } from "../utils/manifest.js";
 import { maxLength } from "../utils/table-width.js";
@@ -55,6 +56,39 @@ function privateFolderExplanation(prefix) {
     return (`Private folder '${prefix}' — write can create only a new direct child. ` +
         "Children are creator-only; this grant does not read, list, overwrite, or delete them.");
 }
+function describeMaskingGrantees(row) {
+    if (row.open)
+        return "open (all members read)";
+    if (row.grantees.length === 0)
+        return "none (creator only)";
+    return row.grantees
+        .map((g) => g.granteeType === "company-wide"
+        ? `everyone:${g.permission}`
+        : `${g.granteeId}:${g.permission}`)
+        .join(", ");
+}
+function printMaskingTable(rows) {
+    const PATH_W = Math.max(4, ...rows.map((r) => displayAclPattern(r.path).length));
+    const CREATOR_W = Math.max(7, ...rows.map((r) => r.creatorUid.length));
+    console.log(chalk.bold(["PATH".padEnd(PATH_W), "CREATOR".padEnd(CREATOR_W), "GRANTS"].join("  ")));
+    for (const row of rows) {
+        console.log([
+            displayAclPattern(row.path).padEnd(PATH_W),
+            row.creatorUid.padEnd(CREATOR_W),
+            describeMaskingGrantees(row),
+        ].join("  "));
+    }
+}
+/** The warning `hq files share` prints when a grant is shadowed by more specific rows. */
+export function formatShadowedGrantWarning(input) {
+    const paths = input.maskedBy.map((row) => `'${row.path}'`).join(", ");
+    const company = input.companySlug ? ` --company ${input.companySlug}` : "";
+    return (`Warning: this grant takes no effect under ${input.maskedBy.length} more specific rule(s) ` +
+        `that do not include ${input.principal}: ${paths}. ` +
+        "Access under those paths is unchanged (the most specific rule wins). " +
+        `Share them too, for example: hq files share '${input.maskedBy[0]?.path ?? "<path>"}' --with ${input.principal} --permission ${input.permission}${company}` +
+        " — or remove the rule with hq files unshare.");
+}
 function formatAclPatternConflict(prefix, serverMessage) {
     const privatePattern = prefix.endsWith("/*")
         ? prefix.slice(0, -1)
@@ -544,6 +578,14 @@ export function registerFilesCommand(program) {
                 console.log("\nGranted on descendant prefixes (do not affect this prefix's access):");
                 printEntryTable(tree.children, true);
             }
+            if (Array.isArray(tree.masking) && tree.masking.length > 0) {
+                console.log(`\nMore specific rules under ${displayAclPattern(tree.prefix)} (each replaces this prefix's grants for its own paths):`);
+                printMaskingTable(tree.masking);
+                if (tree.maskingTruncated) {
+                    console.log(chalk.gray("  ...list truncated; use --json for the first page."));
+                }
+                console.log(chalk.gray(`A grant on ${displayAclPattern(tree.prefix)} does not reach these paths unless they grant the same principal. Share each path too, or remove its rule with hq files unshare.`));
+            }
             const allEntries = [...tree.direct, ...tree.inherited, ...tree.children];
             if (allEntries.some((entry) => entry.granteeType === "company-wide")) {
                 console.log(chalk.gray("\nCompany-wide grants apply to every active member, including guests. Demoting someone to guest does not exclude them. Use hq members remove to end membership, or hq access <path> --as <email> to see effective access."));
@@ -704,7 +746,7 @@ async function resolveShareChannelTarget(params) {
     const channels = await fetchChannels(token);
     const matches = matchChannelsByName(channels, params.channelName);
     if (matches.length === 0) {
-        console.error(chalk.red(`No channel named '${params.channelName}' — run \`hq channels\` to see your channels.`));
+        console.error(chalk.red(withChannelSuggestions(`No channel named '${params.channelName}' — run \`hq channels\` to see your channels.`, suggestChannels(channels, params.channelName))));
         process.exit(1);
     }
     if (matches.length > 1) {
@@ -894,6 +936,15 @@ async function runDirectGrant(params) {
     if (isPrivateFolderPattern(printedPrefix)) {
         console.log(chalk.gray(privateFolderExplanation(printedPrefix)));
     }
+    if (Array.isArray(data.maskedBy) && data.maskedBy.length > 0) {
+        console.warn(chalk.yellow(formatShadowedGrantWarning({
+            prefix: printedPrefix,
+            principal: isAll ? "@all" : principal,
+            permission: params.permission,
+            ...(params.companySlug ? { companySlug: params.companySlug } : {}),
+            maskedBy: data.maskedBy,
+        })));
+    }
     if (typeof data.record?.error === "string" &&
         typeof data.record.status === "number" &&
         data.record.status >= 400) {

package/dist/commands/integrations-connect.js

@@ -548,12 +548,16 @@ async function connectViaOAuth(token, companyUid, target, opts) {
         ...target.ref,
         ...(requestedScopes ? { scopes: requestedScopes } : {}),
     };
-    if (opts.linkOnly)
-        return await linkOnlySignIn(token, companyUid, target, opts, startInput);
+    const userClient = await resolveUserOAuthClient(opts, target.label);
+    if (opts.linkOnly) {
+        return await linkOnlySignIn(token, companyUid, target, opts, {
+            ...startInput,
+            ...(userClient ?? {}),
+        });
+    }
     // A user-registered app pins the console callback and skips the loopback
     // entirely — see `userClientSignIn` for why an ephemeral port cannot be the
     // redirect URI here.
-    const userClient = await resolveUserOAuthClient(opts, target.label);
     if (userClient)
         return await userClientSignIn(token, companyUid, target, opts, userClient, requestedScopes);
     // A loopback listener only works if the browser runs on THIS machine. Over

package/dist/commands/lanes-accounts.js

@@ -9,9 +9,11 @@ import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/c
 import { resolveLaneEffort } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { CAPACITY_ONLY_REASON } from "../lib/capacity/accounts.js";
+import { claudeOpenCommand } from "../lib/capacity/ledger.js";
 import { accountQuotaView, clearAccountQuota, loadQuotaState } from "../lib/lanes/quota.js";
 import { resolveLaneModel } from "../lib/lanes/spawn.js";
 import { leadLaneIds } from "../lib/lanes/admission.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 export function createLaneAccountsHandlers(deps) {
     const { admitQueuedFromCtx, automaticBalanceMoveHistoryReason, ensureDir, laneWithRecoveredProviderSession, loadClaudeBalanceHostSnapshots, parseRemoteJson, prepareAccountMove, printJson, reconcileHostFromCtx, resolveCallerPath } = deps;
     const VENDOR_LOGIN = {
@@ -124,6 +126,7 @@ export function createLaneAccountsHandlers(deps) {
             hostname: ctx.hostname(),
             homedir: ctx.homedir,
             probe: ctx.probeProvider,
+            readClaudeCredential: ctx.readClaudeCredential,
             env: ctx.env,
         }).map((status) => {
             const accountCfg = config.providers[provider].accounts[status.id];
@@ -146,6 +149,10 @@ export function createLaneAccountsHandlers(deps) {
                     error: "home_missing",
                     fix_command: `hq lanes accounts set-home ${provider} ${status.id} <host-home>`,
                 } : {}),
+                ...(provider === "claude" && status.sign_in_state === "expired" ? {
+                    error: "sign_in_expired",
+                    fix_command: `${claudeOpenCommand(status.home, ctx.homedir())} then run /login`,
+                } : {}),
                 ...(provider === "claude" ? {
                     identity: status.identity ?? null,
                     credential_matches_interactive: differs === null ? null : !differs,
@@ -192,7 +199,11 @@ export function createLaneAccountsHandlers(deps) {
         const balanceGateEnabled = true;
         const recentUsageEnabled = await deps.readClaudeAccountBalanceSignalsEnabled(ctx);
         const loads = accountLoadsForReport({ hosts: loaded.snapshots, config, quotaState });
-        const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
+        const suggestions = planClaudeBalanceMoves({
+            hosts: loaded.snapshots,
+            config,
+            laneCompany: (lane) => resolveLaneCompany(hqRoot, lane).company,
+        });
         const selections = loaded.snapshots.map((host) => {
             try {
                 const selection = selectClaudeAccount({
@@ -428,6 +439,7 @@ export function createLaneAccountsHandlers(deps) {
             existsSync: ctx.existsSync,
             hostname,
             probe: ctx.probeProvider,
+            readClaudeCredential: ctx.readClaudeCredential,
             env: ctx.env,
         });
         if (status.logged_in !== true) {
@@ -567,6 +579,7 @@ export function createLaneAccountsHandlers(deps) {
             existsSync: ctx.existsSync,
             hostname: ctx.hostname(),
             probe: ctx.probeProvider,
+            readClaudeCredential: ctx.readClaudeCredential,
             env: ctx.env,
         });
         if (status.logged_in !== true) {
@@ -584,6 +597,7 @@ export function createLaneAccountsHandlers(deps) {
                 existsSync: ctx.existsSync,
                 hostname: ctx.hostname(),
                 probe: ctx.probeProvider,
+                readClaudeCredential: ctx.readClaudeCredential,
                 env: ctx.env,
             }),
         });
@@ -613,6 +627,7 @@ export function createLaneAccountsHandlers(deps) {
                 existsSync: ctx.existsSync,
                 hostname: ctx.hostname(),
                 probe: ctx.probeProvider,
+                readClaudeCredential: ctx.readClaudeCredential,
                 env: ctx.env,
             }),
         });

package/dist/commands/lanes-loop.js

@@ -101,7 +101,16 @@ export async function runLaneLoopController(ctx, laneId, deps) {
             execute: async ({ envelope, signal, fresh, sessionId, repairError }) => {
                 let current = readLane(hqRoot, laneId);
                 const data = envelope;
-                const storyId = typeof data.story_id === "string" && data.story_id.trim() ? data.story_id.trim() : current.story_id;
+                const envelopeStory = typeof data.story_id === "string" && data.story_id.trim() ? data.story_id.trim() : undefined;
+                // A lane created with --no-story keeps no_story_reason and an empty
+                // story_id; the record schema rejects both together. Ignore an
+                // envelope story on such a lane instead of writing a record that can
+                // no longer be loaded or cancelled.
+                const ignoreEnvelopeStory = envelopeStory !== undefined && !current.story_id && !!current.no_story_reason;
+                if (ignoreEnvelopeStory) {
+                    process.stderr.write(`hq lanes: ignoring envelope story_id ${envelopeStory} for no-story lane ${laneId}\n`);
+                }
+                const storyId = envelopeStory !== undefined && !ignoreEnvelopeStory ? envelopeStory : current.story_id;
                 if (storyId !== current.story_id) {
                     current = retryUpdateLane(hqRoot, laneId, "command", (record) => {
                         const stories = laneStories(record);
@@ -153,8 +162,8 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                 fs.writeFileSync(briefPath, [
                     "Follow the lane worker instructions and complete this single bounded phase.",
                     handoffRepairEnabled
-                        ? "Return the standard hq-lane-envelope.v1 envelope when the phase is complete. For a section 8 phase envelope, put a complete hq-phase-handoff/v1 object in artifacts. The lane envelope decision uses done/ask/blocked; handoff status uses passed/failed/blocked. Allowed handoff status values are passed, failed, blocked. Allowed back_pressure values for tests, lint, typecheck, and build are pass, fail, skip. Include story_id, phase, worker_id, summary, files_changed, commits, back_pressure, and context_for_next."
-                        : "Return the standard hq-lane-envelope.v1 envelope when the phase is complete. For a section 8 phase envelope, put a complete hq-phase-handoff/v1 object in artifacts; it must identify the requested story_id and phase and include worker_id, status, summary, files_changed, commits, back_pressure (tests/lint/typecheck/build), and context_for_next.",
+                        ? "Return the standard hq-lane-envelope.v1 envelope when the phase is complete. For a section 8 phase envelope, put a complete hq-phase-handoff/v1 object in artifacts. The lane envelope decision uses done/ask/blocked; handoff status uses passed/failed/blocked. Allowed handoff status values are passed, failed, blocked. Allowed back_pressure values for tests, lint, typecheck, and build are pass, fail, skip. Include story_id, phase, worker_id, summary, files_changed, commits, back_pressure, and context_for_next. summary, context_for_next, and each ac_evidence evidence are single strings, never arrays. Copy each acceptance criterion verbatim into ac_evidence[].criterion; keep its 0-based index and do not shorten or paraphrase the text."
+                        : "Return the standard hq-lane-envelope.v1 envelope when the phase is complete. For a section 8 phase envelope, put a complete hq-phase-handoff/v1 object in artifacts; it must identify the requested story_id and phase and include worker_id, status, summary, files_changed, commits, back_pressure (tests/lint/typecheck/build), and context_for_next. summary, context_for_next, and each ac_evidence evidence are single strings, never arrays. Copy each acceptance criterion verbatim into ac_evidence[].criterion; keep its 0-based index and do not shorten or paraphrase the text.",
                     repairInstructions,
                     "",
                     prompt,
@@ -173,6 +182,7 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                     }
                     await spawnLaneWorker(hqRoot, current, {
                         env: ctx.env,
+                        readClaudeCredential: ctx.readClaudeCredential,
                         modelDeps: { readFileSync: ctx.readFileSync, probe: ctx.probeProvider, env: ctx.env },
                         existsSync: ctx.existsSync,
                         spawnProcess: ctx.spawnProcess,
@@ -201,7 +211,7 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                     await deps.resumeLane(laneId, {
                         text: `Read ${briefPath} and follow it as the complete instruction for this phase.`,
                         project: current.project_id,
-                        story: storyId,
+                        ...(storyId ? { story: storyId } : {}),
                         freshThread: fresh,
                         ...(sessionId ? { loopSessionId: sessionId } : {}),
                         ...(repairError !== undefined ? { loopHandoffRepair: true } : {}),

package/dist/commands/lanes-message.js

@@ -560,16 +560,17 @@ export function createLaneMessageHandlers(deps) {
                         ? err.details.account_reasons.filter((reason) => reason !== null && typeof reason === "object" && !Array.isArray(reason))
                         : [];
                     const held = reasons.filter((reason) => reason.reason === "quota_held");
-                    if (held.length === 0)
+                    const companyUnavailable = reasons.some((reason) => reason.reason === "company_mismatch");
+                    if (held.length === 0 && !companyUnavailable)
                         throw err;
                     const resetTimes = held
                         .map((reason) => reason.quota_reset_at)
                         .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
                         .sort((a, b) => Date.parse(a) - Date.parse(b));
-                    if (resetTimes.length === 0)
+                    if (resetTimes.length === 0 && !companyUnavailable)
                         throw err;
                     quotaHoldDeferred = {
-                        quota_reset_at: resetTimes[0],
+                        ...(resetTimes[0] !== undefined ? { quota_reset_at: resetTimes[0] } : {}),
                         ...(lane.model !== undefined ? { model: lane.model } : {}),
                     };
                     automaticAccountSelection = undefined;
@@ -911,6 +912,7 @@ export function createLaneMessageHandlers(deps) {
                                     }
                                     const started = spawnLaneWorker(hqRoot, lane, {
                                         env: ctx.env,
+                                        readClaudeCredential: ctx.readClaudeCredential,
                                         modelDeps: {
                                             readFileSync: ctx.readFileSync,
                                             probe: ctx.probeProvider,
@@ -974,7 +976,7 @@ export function createLaneMessageHandlers(deps) {
             const deliveryStatus = move?.queued
                 ? "queued_on_target_account"
                 : queuedOnQuotaHold
-                    ? "queued_on_quota_hold"
+                    ? quotaHoldDeferred?.quota_reset_at === undefined ? "queued_on_account" : "queued_on_quota_hold"
                     : queuedOnAdmission
                         ? "queued_on_admission"
                         : mechanism === "dropbox"

package/dist/commands/lanes-resume.js

@@ -98,6 +98,8 @@ export function createLaneResumeHandlers(deps) {
         const hqRoot = ctx.hqRoot();
         const resolution = await deps.resolveCommandLane(ctx, laneId);
         let lane = resolution.lane;
+        // Use the resolved identity for every later exact-path write and audit.
+        laneId = lane.lane_id;
         if (opts.freshThread === true && lane.loop_mode !== true) {
             throw new LanesError("fresh_thread_loop_only", "--fresh-thread is reserved for loop-lane phases", { lane_id: laneId });
         }
@@ -333,9 +335,10 @@ export function createLaneResumeHandlers(deps) {
                     .map((reason) => reason.quota_reset_at)
                     .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
                     .sort((a, b) => Date.parse(a) - Date.parse(b));
-                if (resets.length === 0)
+                const companyUnavailable = reasons.some((reason) => reason.reason === "company_mismatch");
+                if (resets.length === 0 && !companyUnavailable)
                     throw err;
-                quotaHoldDeferred = { quota_reset_at: resets[0], account_reasons: reasons };
+                quotaHoldDeferred = { ...(resets[0] !== undefined ? { quota_reset_at: resets[0] } : {}), account_reasons: reasons };
             }
         }
         const profileRefreshAccount = opts.account === undefined && refreshProfileSettings && resumeProfile !== undefined &&
@@ -555,12 +558,24 @@ export function createLaneResumeHandlers(deps) {
                     ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                     at: quotaHoldAt,
                 };
-                resumed = markSpawnFailure(hqRoot, laneId, "account_quota_exhausted", {
-                    provider: lane.provider,
-                    account: lane.account ?? null,
-                    quota_reset_at: quotaHoldDeferred.quota_reset_at,
-                    account_reasons: quotaHoldDeferred.account_reasons,
-                }, { resumeTrigger: "resume", pendingResume, at: quotaHoldAt });
+                resumed = quotaHoldDeferred.quota_reset_at === undefined
+                    ? casUpdateLane(hqRoot, laneId, (current) => ({
+                        ...current,
+                        state: "queued",
+                        queued_reason: "account_retry",
+                        queued_details: undefined,
+                        queued_at: quotaHoldAt,
+                        admission_reserved_at: undefined,
+                        terminal_reason: undefined,
+                        terminal_details: undefined,
+                        pending_resume: pendingResume,
+                    }))
+                    : markSpawnFailure(hqRoot, laneId, "account_quota_exhausted", {
+                        provider: lane.provider,
+                        account: lane.account ?? null,
+                        quota_reset_at: quotaHoldDeferred.quota_reset_at,
+                        account_reasons: quotaHoldDeferred.account_reasons,
+                    }, { resumeTrigger: "resume", pendingResume, at: quotaHoldAt });
                 queuedOnQuotaHold = true;
             }
             else if (move?.queued) {
@@ -617,6 +632,7 @@ export function createLaneResumeHandlers(deps) {
                         }
                         const started = spawnLaneWorker(hqRoot, lane, {
                             env: ctx.env,
+                            readClaudeCredential: ctx.readClaudeCredential,
                             modelDeps: {
                                 readFileSync: ctx.readFileSync,
                                 probe: ctx.probeProvider,
@@ -624,6 +640,7 @@ export function createLaneResumeHandlers(deps) {
                             },
                             existsSync: ctx.existsSync,
                             spawnProcess: ctx.spawnProcess,
+                            statfs: ctx.statfs,
                             proveDetached: ctx.proveDetached,
                             killProcess: ctx.killProcess,
                             now: ctx.now,
@@ -647,8 +664,14 @@ export function createLaneResumeHandlers(deps) {
                             compact: opts.compact !== false,
                             effort: resumeEffort ?? recordedResumeEffort(lane),
                         });
-                        storySwitchWorkerStarted = true;
-                        deps.onLaneWorkerStarted?.(laneId, "resume");
+                        if (started.state === "running") {
+                            storySwitchWorkerStarted = true;
+                            deps.onLaneWorkerStarted?.(laneId, "resume");
+                        }
+                        else if (started.state === "queued") {
+                            // The spawn preflight can hold on disk even after admission passed.
+                            queuedOnAdmission = true;
+                        }
                         return started;
                     }, hireGrantContext);
                 }, ctx.sleep);
@@ -658,7 +681,7 @@ export function createLaneResumeHandlers(deps) {
                 : null;
             if (deliveryText !== undefined && messageId !== undefined) {
                 // Same audit copy a message resume leaves; nothing drains it. Archive only
-                // after a successful spawn so a concurrent resume cannot leave a phantom.
+                // after the launch starts or durably queues its resume instruction.
                 archiveResumeMessage(hqRoot, laneId, {
                     at,
                     message_id: messageId,
@@ -703,10 +726,10 @@ export function createLaneResumeHandlers(deps) {
                 delivery_status: move?.queued
                     ? "queued_on_target_account"
                     : queuedOnQuotaHold
-                        ? "queued_on_quota_hold"
+                        ? quotaHoldDeferred?.quota_reset_at === undefined ? "queued_on_account" : "queued_on_quota_hold"
                         : queuedOnAdmission
                             ? "queued_on_admission"
-                            : "worker_spawned",
+                            : next.state === "running" ? "worker_spawned" : "not_started",
                 account_move: move ? accountMoveSummary(move) : null,
                 resumed_session_id: resumed.last_resume?.session_id ?? null,
                 last_resume: next.last_resume ?? null,

package/dist/commands/lanes-shared.d.ts

@@ -1,8 +1,10 @@
+import type { StatFs } from "../lib/lanes/disk-guard.js";
 import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneAdmissionLock, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import type { CpuBusySource, MemoryHold } from "../lib/lanes/throttle.js";
 import type { ProbeCommand } from "../lib/lanes/models.js";
+import type { ClaudeCredentialReader } from "../lib/lanes/claude-credential.js";
 import type { FocusGuardReason } from "../lib/lanes/focus-guard.js";
 import type { KillProcessFn, ProveDetachedFn, SpawnProcessFn } from "../lib/lanes/spawn.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -284,6 +286,7 @@ export interface Ctx {
     mesh: LanesMesh;
     sleep: (ms: number) => Promise<void>;
     spawnProcess?: SpawnProcessFn;
+    statfs?: StatFs;
     proveDetached?: ProveDetachedFn;
     killProcess?: KillProcessFn;
     isAlive?: (pid: number) => boolean;
@@ -296,6 +299,8 @@ export interface Ctx {
     runSystemctl?: RunCommand;
     /** Runs a provider CLI probe (`grok models`, `claude --help`) for --model validation. */
     probeProvider?: ProbeCommand;
+    /** Claude access-token expiry check for account status. Absent in tests that fake the probe. */
+    readClaudeCredential?: ClaudeCredentialReader;
     resolveMachineIdentity: () => MachineIdentity;
     runCompaction?: RunCompactionFn;
     locateTranscript?: (home: string, sessionId: string) => string | null;

package/dist/commands/lanes-shared.js

@@ -25,13 +25,23 @@ export function assertCurrentResumeAccountAvailable(ctx, lane) {
             ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`
             : `Account ${JSON.stringify(lane.account)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, { provider: lane.provider, account: lane.account ?? "", ...(account?.disabled_reason !== undefined ? { reason: account.disabled_reason } : {}) });
     }
-    if (accountStatus(lane.provider, lane.account, config, {
+    const status = accountStatus(lane.provider, lane.account, config, {
         existsSync: ctx.existsSync,
         hostname: ctx.hostname(),
         probe: ctx.probeProvider,
+        readClaudeCredential: ctx.readClaudeCredential,
         env: ctx.env,
-    }).logged_in !== true) {
-        throw new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: lane.account, lane_id: lane.lane_id });
+    });
+    if (status.logged_in !== true) {
+        const expired = status.sign_in_state === "expired";
+        throw new LanesError("account_not_logged_in", expired
+            ? `Account ${lane.account} for ${lane.provider} has an expired Claude sign-in; open Claude Code on this account and run /login`
+            : `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, {
+            provider: lane.provider,
+            account: lane.account,
+            lane_id: lane.lane_id,
+            ...(expired ? { sign_in_state: "expired", sign_in_expires_at: status.sign_in_expires_at ?? null } : {}),
+        });
     }
 }
 export function accountMoveSummary(move) {