@indigoai-us/hq-cli 5.241.0 → 5.243.0

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

@@ -0,0 +1,155 @@
+import type { LaneCompanyRef, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, 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 { ProbeCommand } from "../lib/lanes/models.js";
+import type { KillProcessFn, ProveDetachedFn, SpawnProcessFn } from "../lib/lanes/spawn.js";
+import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
+import type { RunCompactionFn } from "../lib/lanes/compaction.js";
+import type { LaneMesh, LaneMeshEvent } from "../lib/lanes/mesh-events.js";
+import type { BalanceHostGap, BalanceHostSnapshot } from "../lib/lanes/claude-balance.js";
+export interface SpawnLoginResult {
+    status: number;
+}
+export type LanesMesh = LaneMesh;
+export interface Ctx {
+    hqRoot: () => string;
+    cwd: () => string;
+    /** Directory the process was in before hq lanes chdir'd to the HQ root. */
+    callerCwd: () => string;
+    env: NodeJS.ProcessEnv;
+    now: () => Date;
+    hostname: () => string;
+    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
+    resolveActiveCompany: (company: string) => Promise<LaneCompanyRef | null>;
+    listOutpostIds: () => Promise<string[]>;
+    readOutpostIdentity: () => OutpostIdentity;
+    spawnLogin: (opts: {
+        command: string;
+        args: string[];
+        env: NodeJS.ProcessEnv;
+        cwd?: string;
+    }) => Promise<SpawnLoginResult>;
+    throttleDeps: ThrottleDeps;
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, encoding: "utf8") => string;
+    readStdin: () => string;
+    homedir: () => string;
+    mesh: LanesMesh;
+    sleep: (ms: number) => Promise<void>;
+    spawnProcess?: SpawnProcessFn;
+    proveDetached?: ProveDetachedFn;
+    killProcess?: KillProcessFn;
+    isAlive?: (pid: number) => boolean;
+    readStarttime?: (pid: number) => number | null;
+    watcherLoopDeps?: Pick<WatcherLoopDeps, "sleep" | "spawnRepair">;
+    stopSleepMs?: (ms: number) => void;
+    livenessDeps?: LivenessDeps;
+    presenceConnected?: boolean;
+    systemdRoot?: string;
+    runSystemctl?: RunCommand;
+    /** Runs a provider CLI probe (`grok models`, `claude --help`) for --model validation. */
+    probeProvider?: ProbeCommand;
+    resolveMachineIdentity: () => MachineIdentity;
+    runCompaction?: RunCompactionFn;
+    locateTranscript?: (home: string, sessionId: string) => string | null;
+    monitorEvidence: MonitorEvidenceReader;
+    stageOutpostPayload: (outpostId: string, bytes: Uint8Array) => Promise<{
+        getUrl: string;
+    }>;
+    dispatchOutpostExec: (input: {
+        outpostId: string;
+        command: string;
+        timeoutSeconds?: number;
+        waitMs?: number;
+    }) => Promise<OutpostDispatchResult>;
+    backfillOutpostIdentity: (expectedId: string) => "created" | "unchanged";
+    fetchText: (url: string) => Promise<string>;
+    lanePlacementEnabled: () => boolean;
+    storyLedgerEnabled: () => boolean;
+    isSsmOwnerDispatch: () => boolean;
+    withGrantHireLocks: typeof withLaneHireLocks;
+    laneTrackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    trackerActor: () => string | null;
+}
+export interface PrimaryOwnedOutpostQuestion {
+    question: QuestionRecord;
+    lane: LaneRecord;
+    host: string;
+    audience: SeniorRef;
+}
+export interface OutpostQuestionListError {
+    host: string;
+    error: string;
+}
+export interface OutpostQuestionLoad {
+    questions: PrimaryOwnedOutpostQuestion[];
+    errors: OutpostQuestionListError[];
+}
+export interface OutpostQuestionRow {
+    question: QuestionRecord;
+    audience: SeniorRef;
+}
+export interface QuestionCompanyGroup {
+    company: LaneCompanyRef | null;
+    lanes: LaneRecord[];
+}
+export interface LaneAccountsHandlerDeps {
+    automaticBalanceMoveHistoryReason(ctx: Ctx, lane: LaneRecord): AccountHistoryEntry["reason"];
+    ensureDir(dir: string): void;
+    laneWithRecoveredProviderSession(hqRoot: string, lane: LaneRecord): LaneRecord;
+    loadClaudeBalanceHostSnapshots(ctx: Ctx, hqRoot: string, config: LanesConfig): Promise<{
+        snapshots: BalanceHostSnapshot[];
+        unavailableHosts: BalanceHostGap[];
+    }>;
+    parseRemoteJson(stdout: string, surface: string): Record<string, unknown> | null;
+    prepareAccountMove(ctx: Ctx, lane: LaneRecord, input: {
+        account: string;
+        cliModel: undefined;
+        accountHistoryReason: AccountHistoryEntry["reason"];
+        deferTurnStart: true;
+    }): Promise<{
+        lane: LaneRecord;
+        from: string | null;
+        to: string;
+    }>;
+    printJson(value: unknown): void;
+    reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
+    resolveCallerPath(callerCwd: string, filePath: string): string;
+}
+export interface LaneQuestionsHandlerDeps {
+    CAPACITY_PROBE_TIMEOUT_MS: number;
+    MAX_PLACEMENT_OUTPOSTS: number;
+    OUTPOST_QUESTION_LOOKUP_CONCURRENCY: number;
+    assertLaneRunsHereForOperatorMutation(ctx: Ctx, lane: LaneRecord, action: string): void;
+    assertQuestionCompanyMatchesLane(question: QuestionRecord, lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company" | "project_id">, code: string, hqRoot?: string): void;
+    casUpdateQuestion(hqRoot: string, questionId: string, updater: (current: QuestionRecord) => QuestionRecord): QuestionRecord;
+    effectiveLaneQuestionCompany(lane: Pick<LaneRecord, "company" | "mesh_company" | "project_id" | "lane_id">, hqRoot?: string): LaneCompanyRef | null;
+    emitLaneMeshEvent(ctx: Ctx, company: LaneCompanyRef | null | undefined, threadId: string | undefined, event: LaneMeshEvent, payload: Record<string, unknown>): Promise<void>;
+    groupQuestionLanesByCompany(hqRoot: string, lanes: LaneRecord[], fallbackCompany?: LaneCompanyRef): QuestionCompanyGroup[];
+    isQuestionAnswer(value: unknown): value is QuestionAnswer;
+    laneIsHostedHere(ctx: Ctx, lane: LaneRecord): boolean;
+    livenessDepsFromCtx(ctx: Ctx): LivenessDeps;
+    loadAllLanes(hqRoot: string): LaneRecord[];
+    loadAllQuestions(hqRoot: string): QuestionRecord[];
+    mapWithConcurrency<T, R>(values: readonly T[], concurrency: number, map: (value: T, index: number) => Promise<R>): Promise<R[]>;
+    mintMessageId(): string;
+    parseOutpostQuestionAudience(raw: unknown, outpostId: string, index: number): SeniorRef;
+    parseOutpostQuestionBody(raw: unknown, outpostId: string, questionId: string): QuestionBody | null;
+    parseRemoteJson(stdout: string, surface: string): Record<string, unknown> | null;
+    parseSeniorRef(raw: string): SeniorRef;
+    questionCompanyForLane(question: QuestionRecord, lane: Pick<LaneRecord, "company" | "mesh_company" | "project_id" | "lane_id">, hqRoot?: string): LaneCompanyRef | null;
+    questionCompanyRefMatches(recordCompany: LaneCompanyRef | null | undefined, filter: LaneCompanyRef): boolean;
+    questionListCompanyArg(company: LaneCompanyRef | null): string | undefined;
+    readOutpostQuestionRecords(ctx: Ctx, outpostId: string, company: LaneCompanyRef | null): Promise<OutpostQuestionRow[]>;
+    readQuestionBody(hqRoot: string, question: QuestionRecord): QuestionBody | null;
+    printJson(value: unknown): void;
+    readSessionMeta(hqRoot: string, sessionId: string, ctx: Ctx): Record<string, unknown> | null;
+    reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
+    resolveActiveQuestionCompany(ctx: Ctx, message?: string): Promise<LaneCompanyRef>;
+    resolveAudience(hqRoot: string, question: QuestionRecord, ctx: Ctx): SeniorRef;
+    sameQuestionAnswer(left: QuestionAnswer | undefined, right: QuestionAnswer): boolean;
+    sameQuestionCompany(a: LaneCompanyRef | null, b: LaneCompanyRef | null): boolean;
+    seniorOfSession(hqRoot: string, sessionId: string, ctx: Ctx): SeniorRef;
+    writeAnswerDeliveryFailed(hqRoot: string, laneId: string, questionId: string, err: unknown, at: string): void;
+}
+//# sourceMappingURL=lanes-shared.d.ts.map

package/dist/commands/lanes-shared.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lanes-shared.js.map

package/dist/commands/lanes.d.ts

@@ -6,11 +6,14 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
+import type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
+export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
+export { resolveAnswerChoice } from "./lanes-questions.js";
 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 { emitLaneDecisionEvents } from "../lib/lanes/mesh-events.js";
 import { MAX_LANE_DEPTH, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
@@ -21,11 +24,7 @@ export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
 export declare const LANES_RUNS_REL: string;
-export interface SpawnLoginResult {
-    status: number;
-}
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
-export type LanesMesh = LaneMesh;
 export { emitLaneDecisionEvents };
 export interface LanesCommandDeps {
     hqRoot?: () => string;
@@ -91,20 +90,13 @@ export interface LanesCommandDeps {
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
-    /** Test seam for the default-off Outpost question visibility gate. */
-    laneOutpostQuestionVisibilityEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for the hq-flags gated tracker commands. */
     laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    /** Test seam for the default-off host-scoped account-home writer gate. */
-    laneHostScopedAccountHomesEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for recording approvals against the active identity. */
     trackerActor?: () => string | null;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
-export declare const LANE_OUTPOST_QUESTION_VISIBILITY_FLAG = "lanes.outpost-question-visibility";
-export declare const LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG = "lanes.host-scoped-account-homes";
 export declare function parseSeniorRef(raw: string): SeniorRef;
-export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
 export declare function parseQuestionBody(raw: unknown): QuestionBody | null;
 /**
  * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist