@indigoai-us/hq-cli 5.187.0 → 5.188.1

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

@@ -10,7 +10,7 @@ export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export type { HostCapacityAccount, HostCapacityProvider, HostCapacitySnapshot, HostPlacementChoice, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneAccountSelection, LaneAccountSelectionConsidered, LaneAccountSelectionHostCount, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -27,7 +27,7 @@ export interface OutpostDispatchResult {
     stderr: string;
 }
 export interface OutpostLaneCommand {
-    action: "message" | "resume" | "stop" | "show" | "grant";
+    action: "message" | "resume" | "stop" | "show" | "grant" | "grant-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -36,6 +36,7 @@ export interface OutpostLaneCommand {
     account?: string;
     model?: string;
     hire?: string;
+    grantContext?: string;
     compact?: boolean;
 }
 export interface OutpostExecPort {
@@ -61,12 +62,21 @@ export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPa
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
 /** Bounded, read-only capacity query executed by the target Outpost CLI. */
 export declare function buildOutpostCapacityCommand(): string;
+/** Read the lane records owned by an Outpost for exact per-account state counts. */
+export declare function buildOutpostLaneListCommand(): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;
     host: LaneHost;
     account: string;
 }): string;
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export declare function buildOutpostBalanceMoveCommand(input: {
+    laneId: string;
+    account: string;
+    fromAccount: string;
+    expectedState: LaneRecord["state"];
+}): string;
 /** Idempotently backfill the marker on the selected Outpost. */
 export declare function buildOutpostIdentityBackfillCommand(expectedId: string): string;
 /** Build the same `hq outposts exec` remote command used by lane pickup. */

package/dist/lib/lanes/outpost-dispatch.js

@@ -46,6 +46,10 @@ export function buildOutpostPickupCommand(payloadUrl) {
 export function buildOutpostCapacityCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "capacity", "--json"]));
 }
+/** Read the lane records owned by an Outpost for exact per-account state counts. */
+export function buildOutpostLaneListCommand() {
+    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "list", "--json"]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([
@@ -61,6 +65,21 @@ export function buildOutpostMoveTargetCommand(input) {
         input.account,
     ]));
 }
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export function buildOutpostBalanceMoveCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "balance-move-target",
+        input.laneId,
+        "--account",
+        input.account,
+        "--from-account",
+        input.fromAccount,
+        "--expected-state",
+        input.expectedState,
+    ]));
+}
 /** Idempotently backfill the marker on the selected Outpost. */
 export function buildOutpostIdentityBackfillCommand(expectedId) {
     return withRemoteHqDir(joinCommandParts([
@@ -86,6 +105,7 @@ export function buildOutpostLaneCommand(input) {
         ["--account", input.account],
         ["--model", input.model],
         ["--hire", input.hire],
+        ["--grant-context", input.grantContext],
     ]) {
         if (value !== undefined)
             args.push(flag, value);

package/dist/lib/lanes/ssm-command-context.d.ts

@@ -0,0 +1,12 @@
+export interface SsmRunCommandContextDeps {
+    platform?: string;
+    parentPid?: number;
+    readFileSync?: (path: string, encoding: "utf8") => string;
+}
+/**
+ * True only for a Linux process descended from the root-owned SSM Run Command
+ * worker chain. Outpost owner-only lane mutations use this to distinguish an
+ * SSM dispatch from a normal local CLI invocation.
+ */
+export declare function isSsmRunCommandProcess(deps?: SsmRunCommandContextDeps): boolean;
+//# sourceMappingURL=ssm-command-context.d.ts.map

package/dist/lib/lanes/ssm-command-context.js

@@ -0,0 +1,52 @@
+import * as fs from "node:fs";
+const SSM_WORKER_CHAIN = [
+    "ssm-document-wo",
+    "ssm-agent-worke",
+    "amazon-ssm-agen",
+];
+/**
+ * True only for a Linux process descended from the root-owned SSM Run Command
+ * worker chain. Outpost owner-only lane mutations use this to distinguish an
+ * SSM dispatch from a normal local CLI invocation.
+ */
+export function isSsmRunCommandProcess(deps = {}) {
+    if ((deps.platform ?? process.platform) !== "linux")
+        return false;
+    const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
+    let pid = deps.parentPid ?? process.ppid;
+    const lineage = [];
+    for (let depth = 0; depth < 32 && pid > 1; depth += 1) {
+        let status;
+        let command;
+        try {
+            status = readFileSync(`/proc/${pid}/status`, "utf8");
+            command = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
+        }
+        catch (err) {
+            const code = err !== null && typeof err === "object" && "code" in err
+                ? err.code
+                : undefined;
+            if (code === "ENOENT" || code === "EACCES" || code === "EPERM")
+                return false;
+            throw err;
+        }
+        const parentMatch = /^PPid:\s*(\d+)\s*$/m.exec(status);
+        const uidMatch = /^Uid:\s*\d+\s+(\d+)\s+\d+\s+\d+\s*$/m.exec(status);
+        if (!parentMatch || !uidMatch || !command)
+            return false;
+        const parentPid = Number(parentMatch[1]);
+        const effectiveUid = Number(uidMatch[1]);
+        if (!Number.isSafeInteger(parentPid) || !Number.isSafeInteger(effectiveUid))
+            return false;
+        lineage.push({ pid, parentPid, command, effectiveUid });
+        pid = parentPid;
+    }
+    for (let start = 0; start <= lineage.length - SSM_WORKER_CHAIN.length; start += 1) {
+        const chain = lineage.slice(start, start + SSM_WORKER_CHAIN.length);
+        if (chain.every((entry, index) => entry.effectiveUid === 0 && entry.command.startsWith(SSM_WORKER_CHAIN[index]))) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=ssm-command-context.js.map

package/dist/lib/lanes/store.js

@@ -473,6 +473,9 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (raw.account_selection !== undefined) {
+        parseLaneAccountSelection(raw.account_selection, filePath);
+    }
     if (raw.placement_default !== undefined) {
         const placement = raw.placement_default;
         if (!isPlainObject(placement) ||
@@ -494,6 +497,89 @@ export function parseLaneRecord(raw, filePath) {
     // a parse/rewrite cycle (spec §5.1 field-preservation).
     return raw;
 }
+function parseLaneAccountSelection(value, filePath) {
+    const failure = (field) => new LaneSchemaError(`Invalid account_selection.${field}`, {
+        path: filePath,
+        field: `account_selection.${field}`,
+    });
+    if (!isPlainObject(value))
+        throw failure("must be an object");
+    const selection = value;
+    if (typeof selection.account !== "string" || selection.account.trim() === "")
+        throw failure("account");
+    if (selection.signal !== "usage" && selection.signal !== "lane_count" && selection.signal !== "explicit")
+        throw failure("signal");
+    if (selection.reason !== "least_loaded" && selection.reason !== "explicit")
+        throw failure("reason");
+    if (typeof selection.selected_at !== "string" || !Number.isFinite(Date.parse(selection.selected_at)))
+        throw failure("selected_at");
+    const parseHost = (host, field) => {
+        if (!isPlainObject(host) || !isHostKind(host.kind) || typeof host.id !== "string" || host.id.trim() === "")
+            throw failure(field);
+    };
+    parseHost(selection.target_host, "target_host");
+    if (!Array.isArray(selection.considered) || !Array.isArray(selection.skipped_accounts) || !Array.isArray(selection.unavailable_hosts)) {
+        throw failure("arrays");
+    }
+    for (const [index, rowValue] of selection.considered.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`considered.${index}`);
+        const row = rowValue;
+        if (typeof row.account !== "string" || row.account.trim() === "" || typeof row.eligible !== "boolean" || typeof row.live_lanes !== "number" || !Number.isInteger(row.live_lanes) || row.live_lanes < 0 || typeof row.counts_complete !== "boolean" || !Array.isArray(row.hosts))
+            throw failure(`considered.${index}`);
+        if (row.ineligible_reason !== undefined && typeof row.ineligible_reason !== "string")
+            throw failure(`considered.${index}.ineligible_reason`);
+        if (row.usage !== null) {
+            if (!isPlainObject(row.usage))
+                throw failure(`considered.${index}.usage`);
+            for (const key of ["five_hour_percent", "weekly_percent"]) {
+                const percent = row.usage[key];
+                if (percent !== undefined && (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0 || percent > 100))
+                    throw failure(`considered.${index}.usage.${key}`);
+            }
+            if (row.usage.sampled_at !== undefined && (typeof row.usage.sampled_at !== "string" || !Number.isFinite(Date.parse(row.usage.sampled_at))))
+                throw failure(`considered.${index}.usage.sampled_at`);
+        }
+        for (const [hostIndex, hostValue] of row.hosts.entries()) {
+            if (!isPlainObject(hostValue))
+                throw failure(`considered.${index}.hosts.${hostIndex}`);
+            const host = hostValue;
+            parseHost(host.host, `considered.${index}.hosts.${hostIndex}.host`);
+            if (typeof host.enabled !== "boolean" || !(host.logged_in === null || typeof host.logged_in === "boolean"))
+                throw failure(`considered.${index}.hosts.${hostIndex}.status`);
+            if (!(host.live_lanes === null || (typeof host.live_lanes === "number" && Number.isInteger(host.live_lanes) && host.live_lanes >= 0)))
+                throw failure(`considered.${index}.hosts.${hostIndex}.live_lanes`);
+            if (!isPlainObject(host.lane_counts))
+                throw failure(`considered.${index}.hosts.${hostIndex}.lane_counts`);
+            for (const key of ["running", "queued", "awaiting_input"]) {
+                const count = host.lane_counts[key];
+                if (!(count === null || (typeof count === "number" && Number.isInteger(count) && count >= 0)))
+                    throw failure(`considered.${index}.hosts.${hostIndex}.lane_counts.${key}`);
+            }
+            if (!["lane_list", "capacity", "capacity_partial", "unavailable"].includes(String(host.count_source)))
+                throw failure(`considered.${index}.hosts.${hostIndex}.count_source`);
+        }
+    }
+    for (const [index, rowValue] of selection.skipped_accounts.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`skipped_accounts.${index}`);
+        const row = rowValue;
+        if (typeof row.account !== "string" || row.account.trim() === "" || typeof row.reason !== "string" || row.reason.trim() === "")
+            throw failure(`skipped_accounts.${index}`);
+        parseHost(row.host, `skipped_accounts.${index}.host`);
+    }
+    for (const [index, rowValue] of selection.unavailable_hosts.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`unavailable_hosts.${index}`);
+        const row = rowValue;
+        if (typeof row.reason !== "string" || row.reason.trim() === "")
+            throw failure(`unavailable_hosts.${index}`);
+        if (isPlainObject(row.host) && row.host.kind === "unknown" && row.host.id === "unknown")
+            continue;
+        parseHost(row.host, `unavailable_hosts.${index}.host`);
+    }
+    return selection;
+}
 export function parseQuestionRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Question record must be a JSON object", {

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

@@ -230,6 +230,52 @@ export interface LaneHost {
     kind: HostKind;
     id: string;
 }
+export interface LaneAccountSelectionHostCount {
+    host: LaneHost;
+    enabled: boolean;
+    logged_in: boolean | null;
+    live_lanes: number | null;
+    lane_counts: {
+        running: number | null;
+        queued: number | null;
+        awaiting_input: number | null;
+    };
+    count_source: "lane_list" | "capacity" | "capacity_partial" | "unavailable";
+}
+export interface LaneAccountSelectionConsidered {
+    account: string;
+    eligible: boolean;
+    ineligible_reason?: string;
+    live_lanes: number;
+    counts_complete: boolean;
+    usage: {
+        five_hour_percent?: number;
+        weekly_percent?: number;
+        sampled_at?: string;
+    } | null;
+    hosts: LaneAccountSelectionHostCount[];
+}
+/** Decision evidence saved with a Claude lane when account balancing is active. */
+export interface LaneAccountSelection {
+    account: string;
+    signal: "usage" | "lane_count" | "explicit";
+    reason: "least_loaded" | "explicit";
+    target_host: LaneHost;
+    selected_at: string;
+    considered: LaneAccountSelectionConsidered[];
+    skipped_accounts: Array<{
+        account: string;
+        host: LaneHost;
+        reason: string;
+    }>;
+    unavailable_hosts: Array<{
+        host: LaneHost | {
+            kind: "unknown";
+            id: "unknown";
+        };
+        reason: string;
+    }>;
+}
 export interface SeniorHistoryEntry {
     from: SeniorRef;
     to: SeniorRef;
@@ -309,6 +355,8 @@ export interface LaneRecord {
     worker_policy_delivery?: "hook" | "prompt";
     provider: LaneProvider;
     account?: string;
+    /** Recent Claude account-selection evidence for a create or automatic resume move. */
+    account_selection?: LaneAccountSelection;
     /** Eligible accounts for a queue entry created without an explicit account. */
     admission_accounts?: string[];
     /**

package/dist/lib/lanes/types.js

@@ -224,7 +224,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
+    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
     last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.187.0",
+  "version": "5.188.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {