@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.274.0

package/dist/commands/lanes-move.js

@@ -0,0 +1,342 @@
+import * as path from "node:path";
+import { chooseHostForLane } from "../lib/lanes/host-capacity.js";
+import { laneRunsHere, loadLanesConfig, loadWorkerProfile, readLane, updateLane, withLaneAdmissionLock, } from "../lib/lanes/index.js";
+import { LanesError, isLanesError } from "../lib/lanes/errors.js";
+import { buildOutpostMoveTargetCommand, dispatchErrorMessage, } from "../lib/lanes/outpost-dispatch.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
+import { assertPlacementEnabled, parsePlacementPolicy, readLanePlacementEnabled, } from "./lanes-shared.js";
+export function createLaneMoveHandlers(deps) {
+    const { assertKnownOutpost, assertLaneRunsHereForOperatorMutation, dispatchCreatedOutpostLane, loadHostCapacitySnapshots, ownerErrorFromOutput, parseRemoteJson, printJson, readJsonFile, reconcileHostFromCtx, runDir, timeoutPath, } = deps;
+    function laneCanMoveBeforeStart(lane) {
+        return lane.state === "queued" &&
+            lane.pickup_validation_pending !== true &&
+            lane.admission_reserved_at === undefined &&
+            lane.provider_session_id === undefined &&
+            lane.provider_session_id_absent === undefined &&
+            lane.provider_home_at_spawn === undefined &&
+            lane.last_resume === undefined &&
+            lane.last_run_usage === undefined &&
+            lane.last_host_report_at === undefined &&
+            lane.pending_resume === undefined;
+    }
+    function readLaneTimeout(hqRoot, laneId) {
+        const raw = readJsonFile(timeoutPath(hqRoot, laneId));
+        if (raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw) ||
+            typeof raw.timeout_secs !== "number" ||
+            typeof raw.deadline_at !== "string" ||
+            !Number.isSafeInteger(raw.timeout_secs) ||
+            raw.timeout_secs <= 0 ||
+            !Number.isFinite(Date.parse(raw.deadline_at))) {
+            throw new LanesError("lane_timeout_invalid", `Lane ${laneId} has a malformed timeout record`, {
+                lane_id: laneId,
+            });
+        }
+        const record = raw;
+        return { timeout_secs: record.timeout_secs, deadline_at: record.deadline_at };
+    }
+    async function runMove(ctx, laneId, opts) {
+        const hqRoot = ctx.hqRoot();
+        const policy = parsePlacementPolicy(opts.placement ?? "");
+        const source = readLane(hqRoot, laneId);
+        const placementCompany = resolveLaneCompany(hqRoot, source).company ?? undefined;
+        let placementGate;
+        const placementEnabled = () => {
+            placementGate ??= readLanePlacementEnabled(ctx, placementCompany);
+            return placementGate;
+        };
+        await assertPlacementEnabled(ctx, placementCompany, placementEnabled);
+        if (!laneCanMoveBeforeStart(source)) {
+            throw new LanesError(source.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${source.state}`, { lane_id: laneId, state: source.state });
+        }
+        const sourceHost = source.host;
+        const config = loadLanesConfig(hqRoot);
+        const capacity = await loadHostCapacitySnapshots(ctx, hqRoot, config);
+        let targetSnapshots = capacity.snapshots.filter((snapshot) => snapshot.host.kind !== sourceHost.kind || snapshot.host.id !== sourceHost.id);
+        if (policy.kind === "outpost") {
+            targetSnapshots = targetSnapshots.filter((snapshot) => snapshot.host.kind === "outpost" && snapshot.host.id === policy.id);
+        }
+        else if (policy.kind === "local") {
+            targetSnapshots = targetSnapshots.filter((snapshot) => snapshot.host.kind === "local");
+        }
+        const profileAccounts = source.worker_profile === undefined
+            ? undefined
+            : loadWorkerProfile(hqRoot, source.worker_profile).meta.accounts;
+        const allowedAccounts = source.admission_accounts ?? profileAccounts;
+        const choice = chooseHostForLane(targetSnapshots, {
+            provider: source.provider,
+            ...(source.account !== undefined ? { account: source.account } : {}),
+            ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
+        });
+        let moved;
+        if (laneRunsHere(source, reconcileHostFromCtx(ctx))) {
+            moved = await commitLaneMove(ctx, laneId, choice.host, choice.account, placementEnabled);
+        }
+        else if (source.host.kind === "outpost") {
+            moved = await dispatchRemoteLaneMove(ctx, source, choice.host, choice.account);
+        }
+        else {
+            throw new LanesError("lane_remote", `Cannot move lane ${laneId} from this host; its state is owned by ${source.host.kind}:${source.host.id}`, { lane_id: laneId, host: source.host, action: "move" });
+        }
+        printJson({
+            ok: true,
+            action: "move",
+            lane_id: laneId,
+            state: moved.state,
+            host: moved.host,
+            account: moved.account ?? null,
+            lane: moved,
+        });
+    }
+    async function commitLaneMove(ctx, laneId, target, account, readPlacementEnabled) {
+        const hqRoot = ctx.hqRoot();
+        const before = readLane(hqRoot, laneId);
+        assertLaneRunsHereForOperatorMutation(ctx, before, "move-target");
+        await assertPlacementEnabled(ctx, resolveLaneCompany(hqRoot, before).company ?? undefined, readPlacementEnabled);
+        if (before.host.kind === target.kind && before.host.id === target.id) {
+            throw new LanesError("lane_move_same_host", `Lane ${laneId} is already on ${target.kind}:${target.id}`, {
+                lane_id: laneId,
+                host: target,
+            });
+        }
+        if (!laneCanMoveBeforeStart(before)) {
+            throw new LanesError(before.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${before.state}`, { lane_id: laneId, state: before.state });
+        }
+        if (target.kind === "outpost") {
+            let known;
+            try {
+                known = await ctx.listOutpostIds();
+            }
+            catch (err) {
+                throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${dispatchErrorMessage(err)}`, {});
+            }
+            assertKnownOutpost(target.id, known);
+        }
+        const accountConfig = loadLanesConfig(hqRoot).providers[before.provider].accounts[account];
+        if (accountConfig === undefined || !accountConfig.enabled) {
+            throw new LanesError("lane_move_account_invalid", `Account ${account} is unavailable for ${before.provider}`, {
+                lane_id: laneId,
+                provider: before.provider,
+                account,
+            });
+        }
+        const profileAccounts = before.worker_profile === undefined
+            ? undefined
+            : loadWorkerProfile(hqRoot, before.worker_profile).meta.accounts;
+        const allowedAccounts = before.admission_accounts ?? profileAccounts;
+        if (allowedAccounts !== undefined &&
+            !allowedAccounts.includes(account)) {
+            throw new LanesError("lane_move_account_invalid", `Account ${account} is not allowed by lane ${laneId}`, {
+                lane_id: laneId,
+                account,
+                allowed_accounts: allowedAccounts,
+            });
+        }
+        const briefText = target.kind === "outpost"
+            ? (() => {
+                const briefPath = path.join(runDir(hqRoot, laneId), "brief.md");
+                if (!ctx.existsSync(briefPath)) {
+                    throw new LanesError("lane_move_brief_missing", `Lane ${laneId} has no stored brief to dispatch`, {
+                        lane_id: laneId,
+                    });
+                }
+                return ctx.readFileSync(briefPath, "utf8");
+            })()
+            : undefined;
+        const timeout = target.kind === "outpost" ? readLaneTimeout(hqRoot, laneId) : undefined;
+        const moved = await withLaneAdmissionLock(hqRoot, before.provider, async () => {
+            const current = readLane(hqRoot, laneId);
+            assertLaneRunsHereForOperatorMutation(ctx, current, "move-target");
+            if (!laneCanMoveBeforeStart(current)) {
+                throw new LanesError(current.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} started before the move could commit`, { lane_id: laneId, state: current.state });
+            }
+            return updateLane(hqRoot, laneId, current.version, "command", (live) => ({
+                ...live,
+                host: target,
+                account,
+                queued_reason: undefined,
+                admission_reserved_at: undefined,
+            }));
+        }, ctx.sleep);
+        if (target.kind !== "outpost")
+            return moved;
+        try {
+            return await dispatchCreatedOutpostLane(ctx, {
+                hqRoot,
+                lane: moved,
+                outpostId: target.id,
+                briefText: briefText ?? "",
+                timeout,
+                preserveQueuedOnFailure: true,
+            });
+        }
+        catch (err) {
+            const dispatchDetails = isLanesError(err) ? err.details : {};
+            const commandId = typeof dispatchDetails.command_id === "string" &&
+                dispatchDetails.command_id.trim() !== ""
+                ? dispatchDetails.command_id
+                : undefined;
+            const definitelyNotSubmitted = commandId === undefined &&
+                dispatchDetails.outcome_unknown !== true &&
+                dispatchDetails.done !== false;
+            const knownNoPersistence = (isLanesError(err) && err.error === "outpost_self_target") ||
+                (dispatchDetails.done === true && dispatchDetails.pickup_persisted === false);
+            if (!definitelyNotSubmitted && !knownNoPersistence) {
+                const checkCommand = `hq lanes show ${laneId}`;
+                const message = `Failed to dispatch lane ${laneId} to Outpost ${target.id}; outcome is unknown and the lane remains assigned to Outpost ${target.id}. ` +
+                    `Check the target copy by running \`${checkCommand}\` on Outpost ${target.id}. ` +
+                    dispatchErrorMessage(err);
+                throw new LanesError("lane_move_dispatch_failed", message, {
+                    lane_id: laneId,
+                    message,
+                    source_host: before.host,
+                    target_host: target,
+                    source_restored: false,
+                    outcome: "unknown",
+                    ...(commandId !== undefined ? { command_id: commandId } : {}),
+                    check_command: checkCommand,
+                    ...(dispatchDetails.owner_error !== undefined
+                        ? { owner_error: dispatchDetails.owner_error }
+                        : {}),
+                });
+            }
+            let restored = false;
+            let rollbackError;
+            try {
+                restored = await withLaneAdmissionLock(hqRoot, before.provider, async () => {
+                    const current = readLane(hqRoot, laneId);
+                    if (current.version !== moved.version ||
+                        current.state !== "queued" ||
+                        current.host.kind !== target.kind ||
+                        current.host.id !== target.id ||
+                        current.account !== account) {
+                        return false;
+                    }
+                    updateLane(hqRoot, laneId, current.version, "command", (live) => ({
+                        ...live,
+                        host: before.host,
+                        account: before.account,
+                        queued_reason: before.queued_reason,
+                        admission_reserved_at: before.admission_reserved_at,
+                    }));
+                    return true;
+                }, ctx.sleep);
+            }
+            catch (restoreErr) {
+                rollbackError = restoreErr;
+            }
+            const dispatchMessage = dispatchErrorMessage(err);
+            const outcome = restored
+                ? "the lane stayed queued on its source"
+                : rollbackError === undefined
+                    ? "the lane changed after the move and was not overwritten"
+                    : `source restoration failed: ${dispatchErrorMessage(rollbackError)}`;
+            const message = `Failed to dispatch lane ${laneId} to Outpost ${target.id}; ${outcome}: ${dispatchMessage}`;
+            throw new LanesError("lane_move_dispatch_failed", message, {
+                lane_id: laneId,
+                message,
+                source_host: before.host,
+                target_host: target,
+                source_restored: restored,
+                ...(dispatchDetails.owner_error !== undefined
+                    ? { owner_error: dispatchDetails.owner_error }
+                    : {}),
+                ...(rollbackError !== undefined
+                    ? { rollback_error: dispatchErrorMessage(rollbackError) }
+                    : {}),
+            });
+        }
+    }
+    async function dispatchRemoteLaneMove(ctx, source, target, account) {
+        if (source.host.kind !== "outpost") {
+            throw new LanesError("lane_move_wrong_host", `Lane ${source.lane_id} is not Outpost-hosted`, {
+                lane_id: source.lane_id,
+                host: source.host,
+            });
+        }
+        let dispatched;
+        try {
+            dispatched = await ctx.dispatchOutpostExec({
+                outpostId: source.host.id,
+                command: buildOutpostMoveTargetCommand({
+                    laneId: source.lane_id,
+                    host: target,
+                    account,
+                }),
+                timeoutSeconds: 120,
+                waitMs: 120_000,
+            });
+        }
+        catch (err) {
+            throw new LanesError("lane_move_dispatch_failed", `Could not ask Outpost ${source.host.id} to move lane ${source.lane_id}: ${dispatchErrorMessage(err)}`, { lane_id: source.lane_id, source_outpost: source.host.id });
+        }
+        const ownerError = ownerErrorFromOutput(dispatched.stdout);
+        if (ownerError) {
+            throw new LanesError("outpost_dispatch_failed", `Outpost ${source.host.id} rejected the lane move: ${ownerError.message}`, {
+                lane_id: source.lane_id,
+                source_outpost: source.host.id,
+                command_id: dispatched.commandId,
+                status: dispatched.status,
+                done: dispatched.done ?? false,
+                exit_code: dispatched.exitCode,
+                owner_error: ownerError,
+            });
+        }
+        if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+            throw new LanesError("lane_move_dispatch_failed", `Outpost ${source.host.id} did not confirm the lane move`, {
+                lane_id: source.lane_id,
+                source_outpost: source.host.id,
+                command_id: dispatched.commandId,
+                status: dispatched.status,
+                done: dispatched.done ?? false,
+                exit_code: dispatched.exitCode,
+            });
+        }
+        const remote = parseRemoteJson(dispatched.stdout, "Outpost lane move");
+        const remoteHost = remote?.host;
+        if (remote?.ok !== true ||
+            remote.action !== "move-target" ||
+            remote.lane_id !== source.lane_id ||
+            remote.state !== "queued" ||
+            remote.account !== account ||
+            remoteHost === null || typeof remoteHost !== "object" || Array.isArray(remoteHost) ||
+            remoteHost.kind !== target.kind ||
+            remoteHost.id !== target.id) {
+            throw new LanesError("lane_move_unconfirmed", `Outpost ${source.host.id} returned an invalid lane move result`, {
+                lane_id: source.lane_id,
+                source_outpost: source.host.id,
+                target,
+            });
+        }
+        return {
+            ...source,
+            state: "queued",
+            host: target,
+            account,
+        };
+    }
+    async function runMoveTarget(ctx, laneId, opts) {
+        const kind = opts.hostKind?.trim();
+        const id = opts.hostId?.trim();
+        const account = opts.account?.trim();
+        if ((kind !== "local" && kind !== "outpost") || !id || !account) {
+            throw new LanesError("lane_move_target_invalid", "Move target requires a valid host kind, host id, and account", {
+                host_kind: kind ?? null,
+                host_id: id ?? null,
+                account: account ?? null,
+            });
+        }
+        const moved = await commitLaneMove(ctx, laneId, { kind, id }, account);
+        printJson({
+            ok: true,
+            action: "move-target",
+            lane_id: moved.lane_id,
+            state: moved.state,
+            host: moved.host,
+            account: moved.account ?? null,
+        });
+    }
+    return { runMove, runMoveTarget };
+}
+//# sourceMappingURL=lanes-move.js.map

package/dist/commands/lanes-resume.js

@@ -124,7 +124,9 @@ export function createLaneResumeHandlers(deps) {
             throw new LanesError("worker_profile_hash_mismatch", "Profile re-pin context is only valid on an Outpost owner dispatch", { lane_id: laneId });
         }
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
-            await withResumeHireAdmission(ctx, lane, () => undefined);
+            if (!resolution.remoteOnly) {
+                await withResumeHireAdmission(ctx, lane, () => undefined);
+            }
             await dispatchOutpostLaneCommand(ctx, lane, "resume", opts, resolution.remoteOnly
                 ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
                 : undefined);

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

@@ -1,4 +1,4 @@
-import type { LaneCompanyRef, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
+import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, 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";
@@ -41,6 +41,8 @@ export interface LaneMessageOptions {
     effort?: string;
     worker?: string;
     grantContext?: string;
+    /** Primary-verified caller identity for a superseded Outpost message. */
+    supersededMessageCallerId?: string;
     monitorEvent?: {
         monitor_id: string;
         description: string;
@@ -237,10 +239,15 @@ export interface Ctx {
     storyLedgerEnabled: () => boolean;
     isSsmOwnerDispatch: () => boolean;
     withGrantHireLocks: typeof withLaneHireLocks;
-    laneTrackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    trackerActor: () => string | null;
 }
+export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export declare function defaultLanePlacementEnabled(company: LaneCompanyRef | undefined): Promise<boolean>;
+export declare function readLanePlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined): Promise<boolean>;
+export declare function processLanePlacementCompany(ctx: Ctx): LaneCompanyRef | undefined;
+export declare function parsePlacementPolicy(raw: string): LanePlacementPolicy;
+export declare function assertPlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined, readPlacementEnabled?: () => Promise<boolean>): Promise<void>;
 export interface LaneWaitCommandOptions {
     any?: string[];
     for?: string[];
@@ -267,6 +274,35 @@ export interface LaneWatchHandlerDeps {
     printJson(value: unknown): void;
     readOutpostCapacity(ctx: Ctx, outpostId: string): Promise<HostCapacitySnapshot>;
 }
+export interface LaneMoveHandlerDeps {
+    assertKnownOutpost(requested: string, known: string[]): void;
+    assertLaneRunsHereForOperatorMutation(ctx: Ctx, lane: LaneRecord, action: string): void;
+    dispatchCreatedOutpostLane(ctx: Ctx, input: {
+        hqRoot: string;
+        lane: LaneRecord;
+        outpostId: string;
+        briefText: string;
+        timeout?: {
+            timeout_secs: number;
+            deadline_at: string;
+        };
+        preserveQueuedOnFailure?: boolean;
+    }): Promise<LaneRecord>;
+    loadHostCapacitySnapshots(ctx: Ctx, hqRoot: string, config: LanesConfig): Promise<{
+        snapshots: HostCapacitySnapshot[];
+    }>;
+    ownerErrorFromOutput(stdout: string): {
+        error: string;
+        message: string;
+        details: Record<string, unknown>;
+    } | undefined;
+    parseRemoteJson(stdout: string, surface: string): Record<string, unknown> | null;
+    printJson(value: unknown): void;
+    readJsonFile(filePath: string): unknown | null;
+    reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
+    runDir(hqRoot: string, laneId: string): string;
+    timeoutPath(hqRoot: string, laneId: string): string;
+}
 export interface PrimaryOwnedOutpostQuestion {
     question: QuestionRecord;
     lane: LaneRecord;

package/dist/commands/lanes-shared.js

@@ -1,3 +1,5 @@
+import { resolveProcessFlagCompanyContext } from "../lib/flag-registry.js";
+import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneEffort } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { AccountResolutionError, accountStatus, loadLanesConfig } from "../lib/lanes/index.js";
@@ -92,4 +94,61 @@ export function recordedResumeEffort(lane) {
         source: lane.effort_source ?? "none",
     };
 }
+export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+function lanePlacementFlagErrorCode(error) {
+    if (error && typeof error === "object") {
+        for (const key of ["code", "error", "name"]) {
+            const value = error[key];
+            if (typeof value === "string" && value.trim())
+                return value;
+        }
+    }
+    return "UnknownError";
+}
+function reportLanePlacementFlagReadFailure(error) {
+    process.stderr.write(`${JSON.stringify({
+        event: "lanes.outpost_load_balancing.flag_read_failed",
+        flag: LANE_OUTPOST_LOAD_BALANCING_FLAG,
+        error: lanePlacementFlagErrorCode(error),
+        fallback: false,
+    })}\n`);
+}
+export function defaultLanePlacementEnabled(company) {
+    return readLanesRegistryFlag(LANE_OUTPOST_LOAD_BALANCING_FLAG, {
+        company,
+        reportFailure: reportLanePlacementFlagReadFailure,
+    });
+}
+export async function readLanePlacementEnabled(ctx, company) {
+    try {
+        return await ctx.lanePlacementEnabled(company);
+    }
+    catch (error) {
+        reportLanePlacementFlagReadFailure(error);
+        return false;
+    }
+}
+export function processLanePlacementCompany(ctx) {
+    const context = resolveProcessFlagCompanyContext(ctx.env);
+    if (!context.companySlug)
+        return undefined;
+    return { slug: context.companySlug, uid: context.companyUid ?? "" };
+}
+export function parsePlacementPolicy(raw) {
+    const value = raw.trim();
+    if (value === "local")
+        return { kind: "local" };
+    if (value === "auto")
+        return { kind: "auto" };
+    const match = /^outpost:(.+)$/.exec(value);
+    const id = match?.[1]?.trim();
+    if (id)
+        return { kind: "outpost", id };
+    throw new LanesError("lane_placement_invalid", `Invalid placement ${JSON.stringify(raw)}. Accepted: local, auto, outpost:<id>`, { value: raw, accepted: ["local", "auto", "outpost:<id>"] });
+}
+export async function assertPlacementEnabled(ctx, company, readPlacementEnabled = () => readLanePlacementEnabled(ctx, company)) {
+    if (await readPlacementEnabled())
+        return;
+    throw new LanesError("lane_placement_disabled", `Lane placement options require hq-flags gate ${LANE_OUTPOST_LOAD_BALANCING_FLAG}`, { flag: LANE_OUTPOST_LOAD_BALANCING_FLAG });
+}
 //# sourceMappingURL=lanes-shared.js.map

package/dist/commands/lanes.d.ts

@@ -8,6 +8,7 @@
 import { Command } from "commander";
 import { type LanesMesh, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
+export { LANE_OUTPOST_LOAD_BALANCING_FLAG } 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";
@@ -90,14 +91,11 @@ 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 hq-flags gated tracker commands. */
-    laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** Test seam for the review-before-merge registry flag. */
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    /** Test seam for recording approvals against the active identity. */
-    trackerActor?: () => string | null;
+    /** Test seam for the repository-merge-hold registry flag. */
+    mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
-export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function parseQuestionBody(raw: unknown): QuestionBody | null;
 /**