@indigoai-us/hq-cli 5.154.0 → 5.156.0

package/dist/commands/mesh.js

@@ -59,14 +59,22 @@ export function formatCheckLines(threads, company, projectId) {
     const scope = projectId
         ? `${company.companySlug || company.companyUid}/${projectId}`
         : company.companySlug || company.companyUid;
-    const lines = [`Work mesh: ${threads.length} active thread(s) for ${scope}`];
+    const lines = [`Work mesh: ${threads.length} thread(s) for ${scope}`];
     for (const thread of threads.slice(0, 8)) {
         const owner = thread.ownerUid ? ` owner=${thread.ownerUid}` : "";
         const summary = thread.progressSummary ||
             thread.sourceSignalSummary ||
             thread.blockedReason ||
             "";
-        lines.push(`- ${thread.threadStatus ?? "unknown"} ${thread.threadId ?? "?"}${owner}${summary ? `: ${summary}` : ""}`);
+        const lane = thread.kind === "lane" ? thread.lane : undefined;
+        const laneDetails = lane
+            ? ` lane=${lane.laneId} laneStatus=${thread.laneStatus ?? "unknown"}` +
+                ` story=${lane.storyId ?? "unknown"} profile=${lane.workerProfile ?? "unknown"}` +
+                ` model=${lane.model ?? "unknown"} account=${lane.account ?? "unknown"}` +
+                `${lane.parentLaneId ? ` parent=${lane.parentLaneId}` : ""}`
+            : "";
+        const machine = thread.senderMachineUid ? ` machine=${thread.senderMachineUid}` : "";
+        lines.push(`- ${thread.threadStatus ?? "unknown"} ${thread.threadId ?? "?"}${owner}${machine}${laneDetails}${summary ? `: ${summary}` : ""}`);
     }
     return lines;
 }
@@ -320,6 +328,9 @@ function mergeProjectRepos(current, planned) {
     return [...planned, ...current.filter((repo) => !plannedPaths.has(repo.path))];
 }
 async function runProjectSet(projectId, opts) {
+    if (opts.channel !== undefined && !opts.channel.trim()) {
+        fail("PROJECT_CHANNEL_INVALID: --channel must be a non-empty channel id.");
+    }
     if (opts.storiesFile && opts.storiesJson) {
         fail("Pass only one of --stories-file or --stories-json.");
     }
@@ -358,6 +369,7 @@ async function runProjectSet(projectId, opts) {
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
     const PROJECT_CHANGED = "The Board changed while you were editing. Re-run to pick up the latest.";
     let view;
+    let registration;
     if (!current) {
         const ensured = await ensureProjectBoard({
             token,
@@ -367,10 +379,12 @@ async function runProjectSet(projectId, opts) {
             description: opts.description !== undefined ? opts.description : source?.description ?? "",
             stories: source?.stories ?? [],
             repos: explicitRepos ?? source?.repos ?? [],
+            channelId: opts.channel,
         });
         view = ensured.view;
+        registration = ensured.registration;
     }
-    else {
+    else if (opts.name !== undefined || opts.description !== undefined || source !== undefined || explicitRepos !== undefined) {
         try {
             view = await putProjectView(token, company.companyUid, projectId, {
                 name: opts.name?.trim() || source?.name || current.name,
@@ -395,18 +409,30 @@ async function runProjectSet(projectId, opts) {
             throw err;
         }
     }
+    else {
+        view = current;
+    }
+    if (current && opts.channel !== undefined) {
+        registration = await registerMeshProject(token, company.companyUid, projectId, opts.channel);
+    }
     if (!current && opts.create) {
         noteCallingSessionBound(view.projectId, company);
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "project.set", principalUid, ...view }, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "project.set",
+            principalUid,
+            ...view,
+            ...(registration ? { registration } : {}),
+        }, null, 2));
         return;
     }
     console.log(`Work mesh: project ${view.projectId} set (${view.name}; ${view.stories.length} stories)`);
 }
 async function runProjectRegister(projectId, opts) {
-    if (opts.channel?.trim()) {
-        fail("--channel is not supported by the current Work Mesh registration API; omit it to let the server create or bind the project channel.");
+    if (opts.channel !== undefined && !opts.channel.trim()) {
+        fail("PROJECT_CHANNEL_INVALID: --channel must be a non-empty channel id.");
     }
     const { token, company } = await withCompany(opts);
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
@@ -425,7 +451,7 @@ async function runProjectRegister(projectId, opts) {
     }
     let registration;
     try {
-        registration = await registerMeshProject(token, company.companyUid, projectId);
+        registration = await registerMeshProject(token, company.companyUid, projectId, opts.channel);
     }
     catch (err) {
         const failure = err;
@@ -1787,6 +1813,7 @@ export function registerMeshCommand(program) {
         .option("--stories-json <json>", "Story array or JSON object with userStories")
         .option("--repos-json <json>", "Repository array, such as [{path,branch}]")
         .option("--repo <path[@branch]>", "Repository binding (repeatable)", collectRepeatable)
+        .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--create", "Create the Board view when the GET is a 404")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectSet(projectId, opts))());
@@ -1801,7 +1828,7 @@ export function registerMeshCommand(program) {
         .command("register <projectId>")
         .description("Register an existing Board and bind its project channel; use project ensure to create or repair a Board")
         .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
-        .option("--channel <channelId>", "Reserved: the current server chooses the project channel")
+        .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectRegister(projectId, opts))());
     mesh

package/dist/lib/lanes/accounts.d.ts

@@ -4,8 +4,8 @@
  * Naming an account and omitting one mean different things: an explicit
  * disabled id is refused; omitting picks the least-loaded eligible account.
  * Status reports `configured` and `logged_in` separately. logged_in is
- * derived from whether a provider credential file EXISTS — this module
- * never reads, prints, copies, or hashes that file.
+ * derived from credential-file existence or a provider status command; this
+ * module never reads, prints, copies, or hashes credential files.
  */
 import { type LaneRecord, type LaneProvider } from "./types.js";
 import type { LanesConfig } from "./types.js";
@@ -19,13 +19,22 @@ export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
  * file here at all.
  */
 export declare const PROVIDER_CREDENTIAL_FILES: Record<LaneProvider, readonly string[]>;
-export type AuthState = "file" | "absent" | "unknown";
+export type AuthState = "file" | "status" | "absent" | "unknown";
+export interface AccountStatusProbeResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
 export interface AccountDeps {
     existsSync: (p: string) => boolean;
+    /** Provider status output is parsed for a boolean only; it is never printed. */
+    probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => AccountStatusProbeResult;
+    env?: NodeJS.ProcessEnv;
 }
 export interface AccountResolveContext {
     hqRoot?: string;
     existsSync?: (p: string) => boolean;
+    accountDeps?: Omit<AccountDeps, "existsSync">;
     loadLanes?: (hqRoot: string) => LaneRecord[];
     /** Already-resolved model for this lane. Beats cliModel and account defaults. */
     model?: string;
@@ -38,6 +47,8 @@ export interface AccountResolveContext {
      * set is never selected, so no refusal has to be decided under the lock.
      */
     allowedAccounts?: readonly string[];
+    /** Ordered preferences; callers pass these only for a new lane's first assignment. */
+    preferredAccounts?: readonly string[];
 }
 export interface ResolvedAccount {
     provider: LaneProvider;
@@ -54,13 +65,7 @@ export interface AccountStatus {
     disabled_reason?: string;
     /** Present in personal/lanes/config.json. */
     configured: boolean;
-    /**
-     * True when a provider credential file exists. False only when every
-     * candidate is absent AND absence is conclusive for that provider
-     * (Codex, Grok). Null for Claude when no candidate exists: Claude can
-     * authenticate via keychain, so a missing file is not logged-out.
-     * Never inspects file contents.
-     */
+    /** True/false comes from file existence or the provider status command. */
     logged_in: boolean | null;
     auth_state: AuthState;
     envVar: string;
@@ -79,7 +84,7 @@ export declare function authStateFor(provider: LaneProvider, present: boolean):
 export declare function loggedInFromAuthState(state: AuthState): boolean | null;
 /** Admission and listing share this: refuse only a conclusive logged-out. */
 export declare function isLoggedOut(status: Pick<AccountStatus, "logged_in">): boolean;
-/** Auto-select requires a proven credential file, not Claude-unknown. */
+/** Auto-select requires a positive file or provider-status login result. */
 export declare function isCredentialProven(status: Pick<AccountStatus, "logged_in">): boolean;
 /**
  * Occupying states hold a slot: running / awaiting_input / blocked have a

package/dist/lib/lanes/accounts.js

@@ -4,8 +4,8 @@
  * Naming an account and omitting one mean different things: an explicit
  * disabled id is refused; omitting picks the least-loaded eligible account.
  * Status reports `configured` and `logged_in` separately. logged_in is
- * derived from whether a provider credential file EXISTS — this module
- * never reads, prints, copies, or hashes that file.
+ * derived from credential-file existence or a provider status command; this
+ * module never reads, prints, copies, or hashes credential files.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -76,7 +76,7 @@ export function loggedInFromAuthState(state) {
 export function isLoggedOut(status) {
     return status.logged_in === false;
 }
-/** Auto-select requires a proven credential file, not Claude-unknown. */
+/** Auto-select requires a positive file or provider-status login result. */
 export function isCredentialProven(status) {
     return status.logged_in === true;
 }
@@ -205,8 +205,12 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
     }
     const proven = [];
     for (const id of enabled) {
-        const account = providerCfg.accounts[id];
-        if (hasCredentialFile(provider, account.home, existsSync))
+        const status = accountStatus(provider, id, config, {
+            existsSync,
+            ...(ctx.accountDeps?.probe ? { probe: ctx.accountDeps.probe } : {}),
+            ...(ctx.accountDeps?.env ? { env: ctx.accountDeps.env } : {}),
+        });
+        if (status.logged_in === true)
             proven.push(id);
     }
     if (proven.length === 0) {
@@ -235,6 +239,9 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
         const cap = accountMaxRunning(providerCfg, id);
         return runningLaneCount(lanes, provider, id) < cap;
     });
+    const preferred = underCap.length > 0
+        ? ctx.preferredAccounts?.find((id) => underCap.includes(id))
+        : undefined;
     const pool = underCap.length > 0 ? underCap : runnable;
     const ranked = pool
         .map((id) => ({
@@ -243,7 +250,7 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
         lastStarted: lastStartedAt(lanes, provider, id),
     }))
         .sort(compareEligible);
-    const chosen = ranked[0].id;
+    const chosen = preferred ?? ranked[0].id;
     return boundAccount(provider, chosen, providerCfg.accounts[chosen]);
 }
 export function resolveAccount(provider, requestedId, config, ctx = {}) {
@@ -293,14 +300,28 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
         };
     }
     const present = hasCredentialFile(provider, account.home, deps.existsSync);
-    const auth_state = authStateFor(provider, present);
+    let auth_state = authStateFor(provider, present);
+    let logged_in = loggedInFromAuthState(auth_state);
+    if (!present && provider === "claude" && deps.probe !== undefined) {
+        try {
+            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: account.home });
+            const providerStatus = claudeLoginStatus(result);
+            if (providerStatus !== null) {
+                auth_state = "status";
+                logged_in = providerStatus;
+            }
+        }
+        catch {
+            process.stderr.write(`hq lanes: Claude auth status probe failed for account ${accountId}\n`);
+        }
+    }
     const status = {
         provider,
         id: accountId,
         home: account.home,
         enabled: account.enabled,
         configured: true,
-        logged_in: loggedInFromAuthState(auth_state),
+        logged_in,
         auth_state,
         envVar,
     };
@@ -312,6 +333,27 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
 export function listAccountStatuses(provider, config, deps = defaultAccountDeps()) {
     return Object.keys(config.providers[provider].accounts).map((id) => accountStatus(provider, id, config, deps));
 }
+function claudeLoginStatus(result) {
+    const text = result.stdout.trim();
+    if (text.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed !== null &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed) &&
+                typeof parsed.loggedIn === "boolean") {
+                return parsed.loggedIn;
+            }
+        }
+        catch (err) {
+            process.stderr.write(`hq lanes: Claude auth status returned invalid JSON: ${err instanceof Error ? err.message : String(err)}\n`);
+            return null;
+        }
+    }
+    if (/\bnot logged in\b/i.test(`${result.stdout}\n${result.stderr}`))
+        return false;
+    return null;
+}
 /** Environment assignment the worker process should receive. */
 export function accountEnv(resolved) {
     return { [resolved.envVar]: resolved.home };

package/dist/lib/lanes/admission-host.d.ts

@@ -0,0 +1,19 @@
+import type { AdmissionHost } from "./admission.js";
+export declare const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
+export declare const OUTPOST_DIR = "/etc/outpost";
+export type OutpostIdentity = {
+    kind: "id";
+    id: string;
+} | {
+    kind: "unknown";
+} | {
+    kind: "not_outpost";
+};
+export declare function readOutpostIdentity(existsSync?: (p: string) => boolean, readFileSync?: (p: string) => string): OutpostIdentity;
+export declare function resolveAdmissionHost(deps?: {
+    hostname?: () => string;
+    readOutpostIdentity?: () => OutpostIdentity;
+    existsSync?: (p: string) => boolean;
+    readFileSync?: (p: string) => string;
+}): AdmissionHost;
+//# sourceMappingURL=admission-host.d.ts.map

package/dist/lib/lanes/admission-host.js

@@ -0,0 +1,33 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+export const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
+export const OUTPOST_DIR = "/etc/outpost";
+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" };
+}
+export function resolveAdmissionHost(deps = {}) {
+    const identity = deps.readOutpostIdentity?.() ?? readOutpostIdentity(deps.existsSync, deps.readFileSync);
+    return {
+        hostname: (deps.hostname ?? os.hostname)(),
+        outpostId: identity.kind === "id" ? identity.id : null,
+    };
+}
+//# sourceMappingURL=admission-host.js.map

package/dist/lib/lanes/config.js

@@ -173,6 +173,29 @@ function parseFastModeModels(value, field) {
     }
     return value.map((model) => model.trim());
 }
+function parsePreferredAccounts(provider, value, accounts) {
+    const field = `providers.${provider}.preferred_accounts`;
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) ||
+        value.some((id) => typeof id !== "string" ||
+            id.trim().length === 0 ||
+            id.trim() !== id)) {
+        throw new LanesConfigError("invalid_preferred_accounts", `${field} must be an array of non-empty account ids without surrounding whitespace`, { provider, field });
+    }
+    const preferred = value;
+    const seen = new Set();
+    for (const id of preferred) {
+        if (seen.has(id)) {
+            throw new LanesConfigError("invalid_preferred_accounts", `${field} contains duplicate account ${JSON.stringify(id)}`, { provider, field, account: id });
+        }
+        if (accounts[id] === undefined) {
+            throw new LanesConfigError("preferred_account_unconfigured", `${field} names unconfigured account ${JSON.stringify(id)}`, { provider, field, account: id, accounts: Object.keys(accounts) });
+        }
+        seen.add(id);
+    }
+    return [...preferred];
+}
 function rejectDuplicateHomes(provider, accounts) {
     const seen = new Map();
     for (const [id, account] of Object.entries(accounts)) {
@@ -232,6 +255,7 @@ function parseProvider(provider, raw, deps) {
         max_running: positiveInt(raw.max_running, `providers.${provider}.max_running`, DEFAULT_PROVIDER_MAX_RUNNING[provider]),
         max_queued: positiveInt(raw.max_queued, `providers.${provider}.max_queued`, DEFAULT_MAX_QUEUED),
         accounts,
+        preferred_accounts: parsePreferredAccounts(provider, raw.preferred_accounts, accounts),
     };
     if (provider === "codex") {
         parsed.fast_mode_models = parseFastModeModels(raw.fast_mode_models, `providers.${provider}.fast_mode_models`);
@@ -301,6 +325,7 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
             max_running: DEFAULT_PROVIDER_MAX_RUNNING[provider],
             max_queued: DEFAULT_MAX_QUEUED,
             accounts: defaultAccountMap(provider, deps),
+            preferred_accounts: [],
         };
         if (provider === "codex")
             providerConfig.fast_mode_models = [];

package/dist/lib/lanes/mesh-events.d.ts

@@ -42,11 +42,11 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
-import type { LaneCompanyRef, LaneEnvelope, LaneRecord } from "./types.js";
-export declare const LANE_MESH_EVENTS: readonly ["lane_started", "lane_progress", "lane_question", "lane_question_at_user", "lane_ask", "lane_blocked", "lane_done"];
+import type { LaneCompanyRef, LaneEnvelope, LaneRecord, TerminalLaneState } from "./types.js";
+export declare const LANE_MESH_EVENTS: readonly ["lane_started", "lane_progress", "lane_question", "lane_question_at_user", "lane_ask", "lane_blocked", "lane_done", "lane_failed", "lane_interrupted", "lane_cancelled", "lane_killed"];
 export type LaneMeshEvent = (typeof LANE_MESH_EVENTS)[number];
 /** Roster kinds this module emits. Subset of the server's `validKinds`. */
-export declare const WIRE_EVENT_KINDS: readonly ["run_started", "run_progress", "run_complete", "question", "note"];
+export declare const WIRE_EVENT_KINDS: readonly ["run_started", "run_progress", "run_complete", "blocked", "question", "note"];
 export type WireEventKind = (typeof WIRE_EVENT_KINDS)[number];
 /** Server caps: activity title/summary 2000, question text 500, note text 500. */
 export declare const WIRE_ACTIVITY_TEXT_MAX = 2000;
@@ -70,6 +70,7 @@ export declare function toWireThreadEvent(event: LaneMeshEvent, payload: Record<
  */
 export interface LaneMesh {
     ensureProjectThread: (company: LaneCompanyRef, projectId: string) => Promise<string>;
+    ensureLaneThread?: (company: LaneCompanyRef, lane: LaneRecord, laneStatus?: string, signal?: AbortSignal) => Promise<string>;
     appendThreadEvent: (company: LaneCompanyRef, threadId: string, event: LaneMeshEvent, payload: Record<string, unknown>, signal?: AbortSignal) => Promise<void>;
     patchStoryStatus: (company: LaneCompanyRef, projectId: string, storyId: string, status: string) => Promise<void>;
 }
@@ -92,6 +93,7 @@ export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;
 /** Company attribution + thread present. Unscoped personal lanes emit nothing. */
 export declare function laneCanEmit(lane: Pick<LaneRecord, "company" | "mesh_company" | "thread_id">): boolean;
+export declare function laneMeshEventIdentity(lane: LaneRecord): Record<string, unknown>;
 /**
  * Spec §8 terminal-envelope events. `done` → lane_done and story → review;
  * `blocked` → lane_blocked; `ask` → lane_ask with the queue ids. The story is
@@ -101,6 +103,8 @@ export declare function emitLaneDecisionEvents(mesh: LaneMesh, lane: LaneRecord,
     questionIds?: string[];
     signal?: AbortSignal;
 }): Promise<void>;
+/** Emit an abnormal terminal state even when the worker produced no envelope. */
+export declare function emitLaneTerminalStateEvent(mesh: LaneMesh, lane: LaneRecord, state: Exclude<TerminalLaneState, "done">, summary?: string, signal?: AbortSignal): Promise<void>;
 export declare function emitLaneProgressEvent(mesh: LaneMesh, lane: LaneRecord, detail: string, signal?: AbortSignal): Promise<void>;
 /**
  * Throttle for lane_progress (spec §8 progress row). True when no progress