@indigoai-us/hq-cli 5.157.0 → 5.158.0

package/dist/commands/lanes.js

@@ -12,10 +12,13 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
-import { readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
+import { resolveProcessFlagGate } from "../lib/flag-registry.js";
+import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
-import { buildOutpostLaneCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
+import { backfillOutpostIdentityMarker as backfillOutpostIdentityMarkerImpl, createOutpostIdentityMarkerIfMissing, validateOutpostIdentityId, } from "../lib/lanes/outpost-identity.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
@@ -42,6 +45,10 @@ const VENDOR_LOGIN = {
     grok: { command: "grok", args: ["login"] },
 };
 export { emitLaneDecisionEvents };
+export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+function defaultLanePlacementEnabled() {
+    return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
+}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -227,7 +234,12 @@ function resolveDeps(deps = {}) {
             })),
         stageOutpostPayload: deps.stageOutpostPayload ?? defaultStageOutpostPayload,
         dispatchOutpostExec: deps.dispatchOutpostExec ?? defaultDispatchOutpostExec,
+        backfillOutpostIdentity: deps.backfillOutpostIdentity ?? ((expectedId) => backfillOutpostIdentityMarkerImpl(expectedId, {
+            read: () => deps.readOutpostIdentity?.() ?? readOutpostIdentity(),
+            createIfMissing: createOutpostIdentityMarkerIfMissing,
+        })),
         fetchText: deps.fetchText ?? defaultFetchText,
+        lanePlacementEnabled: deps.lanePlacementEnabled ?? defaultLanePlacementEnabled,
     };
 }
 function livenessDepsFromCtx(ctx) {
@@ -402,6 +414,150 @@ function requireQuestionBody(hqRoot, question) {
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
+const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
+const MAX_PLACEMENT_OUTPOSTS = 16;
+function outpostIdentityUnknownError(message, expectedId, details = {}) {
+    const expected = expectedId ?? "<expected-outpost-id>";
+    const command = `hq lanes outpost-identity backfill --id ${expected}`;
+    return new LanesError("outpost_identity_unknown", message, {
+        ...details,
+        ...(expectedId !== undefined ? { expected_id: expectedId } : {}),
+        marker_path: OUTPOST_ID_PATH,
+        fix_command: command,
+        fix: `Run ${command} from a registered host, or write ${JSON.stringify(`${expected}\n`)} to ${OUTPOST_ID_PATH}.`,
+    });
+}
+function laneHostFromCtx(ctx, expectedId) {
+    const identity = ctx.readOutpostIdentity();
+    if (identity.kind === "unknown") {
+        throw outpostIdentityUnknownError("Cannot resolve this host for lane placement", expectedId);
+    }
+    if (identity.kind === "id")
+        return { kind: "outpost", id: identity.id };
+    const hostname = ctx.hostname().trim();
+    if (!hostname) {
+        throw new LanesError("host_identity_unknown", "Cannot resolve this host for lane placement", {});
+    }
+    return { kind: "local", id: hostname };
+}
+async function readOutpostCapacity(ctx, outpostId) {
+    let result;
+    try {
+        result = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostCapacityCommand(),
+            timeoutSeconds: CAPACITY_PROBE_TIMEOUT_MS / 1000,
+            waitMs: CAPACITY_PROBE_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_capacity_unavailable", `Could not read capacity from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId });
+    }
+    if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
+        throw new LanesError("outpost_capacity_unavailable", `Outpost ${outpostId} did not return a successful capacity snapshot`, {
+            outpost_id: outpostId,
+            status: result.status,
+            done: result.done ?? false,
+            exit_code: result.exitCode,
+        });
+    }
+    let raw;
+    try {
+        raw = JSON.parse(result.stdout);
+    }
+    catch (err) {
+        throw new LanesError("outpost_capacity_unavailable", `Outpost ${outpostId} returned invalid capacity JSON: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId });
+    }
+    const snapshot = parseHostCapacitySnapshot(raw);
+    if (snapshot.host.kind !== "outpost" || snapshot.host.id !== outpostId) {
+        throw new LanesError("outpost_capacity_identity_mismatch", `Capacity response from Outpost ${outpostId} identified a different host`, { requested_outpost_id: outpostId, reported_host: snapshot.host });
+    }
+    return snapshot;
+}
+async function loadHostCapacitySnapshots(ctx, hqRoot, config = loadLanesConfig(hqRoot)) {
+    const localHost = laneHostFromCtx(ctx);
+    let outpostIds;
+    try {
+        outpostIds = await ctx.listOutpostIds();
+    }
+    catch (err) {
+        throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${dispatchErrorMessage(err)}`, {});
+    }
+    if (outpostIds.length > MAX_PLACEMENT_OUTPOSTS ||
+        outpostIds.some((id) => typeof id !== "string" || id.trim() === "") ||
+        new Set(outpostIds).size !== outpostIds.length) {
+        throw new LanesError("outpost_list_invalid", "Outpost list is malformed or exceeds the placement limit", {
+            count: outpostIds.length,
+            maximum: MAX_PLACEMENT_OUTPOSTS,
+        });
+    }
+    const remoteIds = outpostIds
+        .map((id) => id.trim())
+        // `primary` aliases the controller when running on the primary box. From
+        // another Outpost it identifies a separate host and must be measured.
+        .filter((id) => id !== "primary" ||
+        (localHost.kind === "outpost" && localHost.id !== "primary"))
+        .filter((id) => localHost.kind !== "outpost" || id !== localHost.id)
+        .sort();
+    const local = buildHostCapacitySnapshot({
+        host: localHost,
+        lanes: loadAllLanes(hqRoot),
+        config,
+        existsSync: ctx.existsSync,
+        now: ctx.now(),
+    });
+    const remote = await Promise.all(remoteIds.map(async (id) => {
+        try {
+            return {
+                ok: true,
+                snapshot: await readOutpostCapacity(ctx, id),
+            };
+        }
+        catch (err) {
+            const error = isLanesError(err) ? err.error : "outpost_capacity_unavailable";
+            return {
+                ok: false,
+                unavailable: {
+                    host: { kind: "outpost", id },
+                    outpost_id: id,
+                    error,
+                },
+            };
+        }
+    }));
+    const snapshots = [
+        local,
+        ...remote.flatMap((result) => result.ok ? [result.snapshot] : []),
+    ];
+    const unavailable = remote.flatMap((result) => result.ok ? [] : [result.unavailable]);
+    return {
+        snapshots,
+        entries: [
+            local,
+            ...remote.map((result) => result.ok
+                ? result.snapshot
+                : { host: result.unavailable.host, error: result.unavailable.error }),
+        ],
+        skippedHosts: unavailable.map(({ outpost_id, error }) => ({ outpost_id, error })),
+    };
+}
+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>"] });
+}
+function assertPlacementEnabled(ctx) {
+    if (ctx.lanePlacementEnabled())
+        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 });
+}
 function loadAllQuestions(hqRoot) {
     return listQuestionIds(hqRoot).map((id) => readQuestion(hqRoot, id));
 }
@@ -731,6 +887,11 @@ function assertSameTenant(laneCompany, senior, seniorCompany, extra = {}) {
 function recordMatchesCompany(lane, filter) {
     return companyRefMatches(lane.company, filter) || companyRefMatches(lane.mesh_company, filter);
 }
+function sameLaneCompany(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return (a.uid !== "" && a.uid === b.uid) || (a.slug !== "" && a.slug === b.slug);
+}
 function companyRefMatches(recordCompany, filter) {
     return (recordCompany !== null &&
         recordCompany !== undefined &&
@@ -1384,6 +1545,23 @@ function mintMessageId() {
 }
 async function runCreate(ctx, opts) {
     const hqRoot = ctx.hqRoot();
+    const requestedPlacement = opts.placement !== undefined
+        ? parsePlacementPolicy(opts.placement)
+        : undefined;
+    const defaultPlacement = opts.defaultPlacement !== undefined
+        ? parsePlacementPolicy(opts.defaultPlacement)
+        : undefined;
+    if (opts.outpost !== undefined && requestedPlacement !== undefined) {
+        throw new LanesError("lane_placement_conflict", "Pass either --outpost or --placement, not both", {});
+    }
+    let placementGate;
+    const placementEnabled = () => {
+        placementGate ??= ctx.lanePlacementEnabled();
+        return placementGate;
+    };
+    if ((requestedPlacement !== undefined || defaultPlacement !== undefined) && !placementEnabled()) {
+        assertPlacementEnabled(ctx);
+    }
     const companyFlag = opts.company?.trim();
     const meshCompanyFlag = opts.meshCompany?.trim();
     const project = opts.project?.trim();
@@ -1460,6 +1638,13 @@ async function runCreate(ctx, opts) {
         profile?.meta.provider ??
         parseLaneProvider("codex");
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === provider;
+    const cliModel = parseCliModel(opts.model);
+    // Validated here because `claude --effort <unknown>` only warns and runs.
+    const cliEffort = parseCliEffort(provider, opts.effort);
+    const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
+    const profileEffort = profileDefaultsApply ? profile?.meta.effort : undefined;
+    const profileAccount = profileDefaultsApply ? profile?.meta.account : undefined;
+    const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
     const briefAbs = resolveCallerPath(ctx.callerCwd(), briefFile);
     if (!ctx.existsSync(briefAbs)) {
         throw new LanesError("brief_not_found", `Brief file not found: ${briefAbs}`, {
@@ -1467,7 +1652,102 @@ async function runCreate(ctx, opts) {
         });
     }
     const config = loadLanesConfig(hqRoot);
-    const outpostId = opts.outpost?.trim() || undefined;
+    let outpostId = opts.outpost?.trim() || undefined;
+    let placementHostOverride;
+    let autoPlacementChoice;
+    let autoPlacementSkippedHosts = [];
+    let inheritedPlacement;
+    const callerLaneId = ctx.env.HQ_LANE_ID?.trim() || undefined;
+    if (requestedPlacement === undefined &&
+        outpostId === undefined &&
+        callerLaneId !== undefined &&
+        placementEnabled()) {
+        const callerLane = tryReadLane(hqRoot, callerLaneId);
+        if (!callerLane) {
+            throw new LanesError("lane_not_found", `Caller lane ${callerLaneId} not found`, {
+                lane_id: callerLaneId,
+            });
+        }
+        if (callerLane.placement_default !== undefined) {
+            if (!sameLaneCompany(company, callerLane.company)) {
+                throw new LanesError("lane_placement_tenant_mismatch", "Cannot inherit placement from a manager lane in another tenant", { caller_lane_id: callerLaneId });
+            }
+            inheritedPlacement = callerLane.placement_default;
+        }
+    }
+    const placementToApply = requestedPlacement ?? inheritedPlacement;
+    const outpostTargets = new Set();
+    if (placementToApply?.kind === "outpost")
+        outpostTargets.add(placementToApply.id);
+    if (defaultPlacement?.kind === "outpost")
+        outpostTargets.add(defaultPlacement.id);
+    for (const target of outpostTargets) {
+        if (target === opts.outpost?.trim())
+            continue;
+        let known;
+        try {
+            known = await ctx.listOutpostIds();
+        }
+        catch (err) {
+            throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${dispatchErrorMessage(err)}`, {});
+        }
+        assertKnownOutpost(target, known);
+    }
+    if (placementToApply !== undefined) {
+        const currentHost = laneHostFromCtx(ctx);
+        if (placementToApply.kind === "local") {
+            placementHostOverride = currentHost;
+            outpostId = undefined;
+        }
+        else if (placementToApply.kind === "outpost") {
+            if (currentHost.kind === "outpost" && currentHost.id === placementToApply.id) {
+                placementHostOverride = currentHost;
+                outpostId = undefined;
+            }
+            else {
+                placementHostOverride = { kind: "outpost", id: placementToApply.id };
+                outpostId = placementToApply.id;
+            }
+        }
+        else {
+            const capacity = await loadHostCapacitySnapshots(ctx, hqRoot, config);
+            autoPlacementSkippedHosts = capacity.skippedHosts;
+            const requestedAccount = opts.account !== undefined
+                ? opts.account.trim()
+                : profileAccount !== undefined && profileAccounts === undefined
+                    ? profileAccount
+                    : undefined;
+            if (opts.account !== undefined && requestedAccount === "") {
+                throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(opts.account)} for ${provider}`, { provider, account: opts.account, enabled: [] });
+            }
+            try {
+                autoPlacementChoice = chooseHostForLane(capacity.snapshots, {
+                    provider,
+                    ...(requestedAccount !== undefined ? { account: requestedAccount } : {}),
+                    ...(profileAccounts !== undefined ? { allowedAccounts: profileAccounts } : {}),
+                });
+            }
+            catch (err) {
+                if (autoPlacementSkippedHosts.length > 0 &&
+                    isLanesError(err) &&
+                    err.error === "lane_placement_no_capacity") {
+                    throw new LanesError(err.error, `${err.message}; skipped Outposts: ${autoPlacementSkippedHosts.map((host) => host.outpost_id).join(", ")}`, { ...err.details, skipped_hosts: autoPlacementSkippedHosts });
+                }
+                throw err;
+            }
+            placementHostOverride = autoPlacementChoice.host;
+            if (autoPlacementChoice.host.kind === currentHost.kind &&
+                autoPlacementChoice.host.id === currentHost.id) {
+                outpostId = undefined;
+            }
+            else if (autoPlacementChoice.host.kind === "outpost") {
+                outpostId = autoPlacementChoice.host.id;
+            }
+            else {
+                outpostId = undefined;
+            }
+        }
+    }
     let originHost;
     let originHostSource;
     if (outpostId) {
@@ -1478,16 +1758,12 @@ async function runCreate(ctx, opts) {
         originHost = identity.id;
         originHostSource = identity.source;
     }
-    const cliModel = parseCliModel(opts.model);
-    // Validated here because `claude --effort <unknown>` only warns and runs.
-    const cliEffort = parseCliEffort(provider, opts.effort);
-    const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
-    const profileEffort = profileDefaultsApply ? profile?.meta.effort : undefined;
-    const profileAccount = profileDefaultsApply ? profile?.meta.account : undefined;
-    const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
     let pinnedAccount;
     const accountWasExplicit = Boolean(opts.account && opts.account.trim() !== "");
-    if (outpostId) {
+    if (autoPlacementChoice !== undefined) {
+        pinnedAccount = autoPlacementChoice.account;
+    }
+    else if (outpostId) {
         if (accountWasExplicit) {
             pinnedAccount = opts.account.trim();
         }
@@ -1515,7 +1791,9 @@ async function runCreate(ctx, opts) {
         });
         pinnedAccount = resolved.id;
     }
-    if (outpostId !== undefined && profile !== undefined) {
+    if (outpostId !== undefined &&
+        profile !== undefined &&
+        !placementEnabled()) {
         throw new LanesError("worker_profile_outpost_unsupported", `Worker profile ${JSON.stringify(profile.id)} cannot be used with --outpost; personal profiles are local-only`, {
             worker: profile.id,
             outpost: outpostId,
@@ -1719,9 +1997,9 @@ async function runCreate(ctx, opts) {
                 throw admission.error;
             }
         }
-        const host = outpostId !== undefined
+        const host = placementHostOverride ?? (outpostId !== undefined
             ? { kind: "outpost", id: outpostId }
-            : { kind: "local", id: ctx.hostname() };
+            : { kind: "local", id: ctx.hostname() });
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
         const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
         const lane = createLane(hqRoot, {
@@ -1759,6 +2037,9 @@ async function runCreate(ctx, opts) {
                 : {}),
             provider,
             account: pinnedAccount,
+            ...(defaultPlacement !== undefined
+                ? { placement_default: defaultPlacement }
+                : {}),
             ...(balancedAdmissionAccounts !== undefined
                 ? { admission_accounts: balancedAdmissionAccounts }
                 : {}),
@@ -1884,6 +2165,9 @@ async function runCreate(ctx, opts) {
         effort: started.effort ?? null,
         effort_source: started.effort_source ?? null,
         host: started.host,
+        ...(autoPlacementSkippedHosts.length > 0
+            ? { skipped_hosts: autoPlacementSkippedHosts }
+            : {}),
         company: started.company,
         project_id: started.project_id,
         story_id: started.story_id,
@@ -1904,7 +2188,7 @@ async function runCreate(ctx, opts) {
     });
 }
 async function dispatchCreatedOutpostLane(ctx, input) {
-    const { hqRoot, lane, outpostId, briefText, timeout } = input;
+    const { hqRoot, lane, outpostId, briefText, timeout, preserveQueuedOnFailure = false, } = input;
     const payload = {
         lane,
         brief: briefText,
@@ -1915,8 +2199,26 @@ async function dispatchCreatedOutpostLane(ctx, input) {
         const staged = await ctx.stageOutpostPayload(outpostId, bytes);
         const command = buildOutpostPickupCommand(staged.getUrl);
         const dispatched = await ctx.dispatchOutpostExec({ outpostId, command });
+        if (preserveQueuedOnFailure && dispatched.done !== true) {
+            throw new LanesError("outpost_dispatch_failed", "Outpost pickup exec has not finished; its outcome is unknown", {
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+                command_id: dispatched.commandId,
+                status: dispatched.status,
+                done: false,
+                outcome_unknown: true,
+            });
+        }
         const remote = parseRemotePickupJson(dispatched.stdout);
         if (remote?.error === "outpost_self_target") {
+            if (preserveQueuedOnFailure) {
+                throw new LanesError("outpost_self_target", `Outpost ${outpostId} resolved to the lane's current host`, {
+                    outpost_id: outpostId,
+                    lane_id: lane.lane_id,
+                    command_id: dispatched.commandId,
+                    done: dispatched.done,
+                });
+            }
             const cancelled = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
                 ...current,
                 state: "cancelled",
@@ -1927,8 +2229,28 @@ async function dispatchCreatedOutpostLane(ctx, input) {
             await emitLaneTerminalStateSoft(ctx, cancelled);
             return cancelled;
         }
+        if (preserveQueuedOnFailure && remote?.pickup_persisted === false) {
+            throw new LanesError("outpost_dispatch_failed", "Outpost pickup finished and reported that it did not persist the lane", {
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+                command_id: dispatched.commandId,
+                done: true,
+                pickup_persisted: false,
+                status: dispatched.status,
+                exit_code: dispatched.exitCode,
+            });
+        }
         const stdoutTrimmed = dispatched.stdout.trim();
         if (remote === null && stdoutTrimmed !== "" && dispatched.status !== "Success") {
+            if (preserveQueuedOnFailure) {
+                throw new LanesError("outpost_dispatch_failed", "Outpost pickup command failed", {
+                    outpost_id: outpostId,
+                    lane_id: lane.lane_id,
+                    command_id: dispatched.commandId,
+                    status: dispatched.status,
+                    exit_code: dispatched.exitCode,
+                });
+            }
             const failed = markDispatchFailure(hqRoot, lane.lane_id, {
                 outpost_id: outpostId,
                 command_id: dispatched.commandId,
@@ -1948,6 +2270,15 @@ async function dispatchCreatedOutpostLane(ctx, input) {
         }
         const dispatchOk = dispatched.status === "Success" || dispatched.exitCode === 0;
         if (!dispatchOk) {
+            if (preserveQueuedOnFailure) {
+                throw new LanesError("outpost_dispatch_failed", "Outpost pickup command failed", {
+                    outpost_id: outpostId,
+                    lane_id: lane.lane_id,
+                    command_id: dispatched.commandId,
+                    status: dispatched.status,
+                    exit_code: dispatched.exitCode,
+                });
+            }
             const failed = markDispatchFailure(hqRoot, lane.lane_id, {
                 outpost_id: outpostId,
                 command_id: dispatched.commandId,
@@ -1964,12 +2295,29 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 command_id: dispatched.commandId,
             });
         }
-        return casUpdateLane(hqRoot, lane.lane_id, (current) => ({
-            ...current,
-            outpost_command_id: dispatched.commandId,
-        }));
+        try {
+            return casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+                ...current,
+                outpost_command_id: dispatched.commandId,
+            }));
+        }
+        catch (err) {
+            if (!preserveQueuedOnFailure)
+                throw err;
+            const message = dispatchErrorMessage(err);
+            throw new LanesError("outpost_dispatch_failed", `Outpost pickup completed but its command id could not be recorded: ${message}`, {
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+                command_id: dispatched.commandId,
+                done: true,
+                outcome_unknown: true,
+                message,
+            });
+        }
     }
     catch (err) {
+        if (preserveQueuedOnFailure)
+            throw err;
         if (isLanesError(err) &&
             err.error === DISPATCH_TERMINAL_REASON &&
             readLane(hqRoot, lane.lane_id).state === "failed") {
@@ -2009,12 +2357,27 @@ function parseRemoteJson(stdout, surface) {
     }
     return null;
 }
+function verifyOutpostProfileContent(hqRoot, lane) {
+    if (lane.host.kind !== "outpost" || lane.worker_profile === undefined)
+        return;
+    const expectedHash = lane.worker_profile_hash;
+    const profile = loadWorkerProfile(hqRoot, lane.worker_profile);
+    if (expectedHash !== profile.contentHash) {
+        throw new LanesError("worker_profile_hash_mismatch", `Worker profile ${JSON.stringify(lane.worker_profile)} on Outpost ${lane.host.id} does not match the hash recorded by the creator`, {
+            lane_id: lane.lane_id,
+            worker: lane.worker_profile,
+            outpost: lane.host.id,
+            expected_hash: expectedHash ?? null,
+            actual_hash: profile.contentHash,
+        });
+    }
+}
 function laneIsHostedHere(ctx, lane) {
     if (lane.host.kind !== "outpost")
         return true;
     const identity = ctx.readOutpostIdentity();
     if (identity.kind === "unknown") {
-        throw new LanesError("outpost_identity_unknown", `Cannot determine whether this process is Outpost ${lane.host.id}; refusing local lane delivery`, { lane_id: lane.lane_id, outpost_id: lane.host.id });
+        throw outpostIdentityUnknownError(`Cannot determine whether this process is Outpost ${lane.host.id}; refusing local lane delivery`, lane.host.id, { lane_id: lane.lane_id, outpost_id: lane.host.id });
     }
     return identity.kind === "id" && identity.id === lane.host.id;
 }
@@ -2122,37 +2485,58 @@ function ingestPickupPayload(hqRoot, payload, now) {
     }
     return lane;
 }
+function pickupNotPersistedError(err) {
+    const message = dispatchErrorMessage(err);
+    if (isLanesError(err)) {
+        return new LanesError(err.error, message, {
+            ...err.details,
+            message,
+            pickup_persisted: false,
+        });
+    }
+    return new LanesError("outpost_pickup_failed", message, {
+        message,
+        pickup_persisted: false,
+    });
+}
 async function runPickup(ctx, opts) {
     const hqRoot = ctx.hqRoot();
-    const payloadFile = opts.payloadFile?.trim();
-    const payloadUrl = opts.payloadUrl?.trim();
-    if (!payloadFile && !payloadUrl) {
-        throw new LanesError("missing_payload", "--payload-file or --payload-url is required", {});
-    }
-    if (payloadFile && payloadUrl) {
-        throw new LanesError("invalid_payload", "Pass only one of --payload-file or --payload-url", {});
-    }
-    let rawText;
-    if (payloadUrl) {
-        rawText = await ctx.fetchText(payloadUrl);
-    }
-    else {
-        const abs = resolveCallerPath(ctx.callerCwd(), payloadFile);
-        if (!ctx.existsSync(abs)) {
-            throw new LanesError("brief_not_found", `Payload file not found: ${abs}`, {
-                path: abs,
-            });
-        }
-        rawText = ctx.readFileSync(abs, "utf8");
-    }
-    let parsedJson;
+    let payload;
     try {
-        parsedJson = JSON.parse(rawText);
+        const payloadFile = opts.payloadFile?.trim();
+        const payloadUrl = opts.payloadUrl?.trim();
+        if (!payloadFile && !payloadUrl) {
+            throw new LanesError("missing_payload", "--payload-file or --payload-url is required", {});
+        }
+        if (payloadFile && payloadUrl) {
+            throw new LanesError("invalid_payload", "Pass only one of --payload-file or --payload-url", {});
+        }
+        let rawText;
+        if (payloadUrl) {
+            rawText = await ctx.fetchText(payloadUrl);
+        }
+        else {
+            const abs = resolveCallerPath(ctx.callerCwd(), payloadFile);
+            if (!ctx.existsSync(abs)) {
+                throw new LanesError("brief_not_found", `Payload file not found: ${abs}`, {
+                    path: abs,
+                });
+            }
+            rawText = ctx.readFileSync(abs, "utf8");
+        }
+        let parsedJson;
+        try {
+            parsedJson = JSON.parse(rawText);
+        }
+        catch (err) {
+            throw new LanesError("outpost_payload_invalid", `Pickup payload is not JSON: ${err instanceof Error ? err.message : String(err)}`, {});
+        }
+        payload = parseOutpostPickupPayload(parsedJson);
+        verifyOutpostProfileContent(hqRoot, payload.lane);
     }
     catch (err) {
-        throw new LanesError("outpost_payload_invalid", `Pickup payload is not JSON: ${err instanceof Error ? err.message : String(err)}`, {});
+        throw pickupNotPersistedError(err);
     }
-    const payload = parseOutpostPickupPayload(parsedJson);
     const ingested = ingestPickupPayload(hqRoot, payload, ctx.now());
     if (ingested.host.kind === "outpost") {
         try {
@@ -2340,7 +2724,428 @@ async function runList(ctx, opts) {
                 : false,
         };
     });
-    printJson({ ok: true, action: "list", lanes });
+    const host_capacity = ctx.lanePlacementEnabled()
+        ? (await loadHostCapacitySnapshots(ctx, hqRoot)).entries
+        : undefined;
+    printJson({
+        ok: true,
+        action: "list",
+        lanes,
+        ...(host_capacity !== undefined ? { host_capacity } : {}),
+    });
+}
+async function runCapacity(ctx) {
+    const hqRoot = ctx.hqRoot();
+    const host = laneHostFromCtx(ctx);
+    const snapshot = buildHostCapacitySnapshot({
+        host,
+        lanes: loadAllLanes(hqRoot),
+        config: loadLanesConfig(hqRoot),
+        existsSync: ctx.existsSync,
+        now: ctx.now(),
+    });
+    printJson(snapshot);
+}
+async function runOutpostIdentityBackfill(ctx, opts) {
+    const id = opts.id?.trim();
+    if (!id) {
+        throw new LanesError("outpost_identity_id_invalid", "Outpost identity backfill requires --id <outpost-id>", {});
+    }
+    validateOutpostIdentityId(id);
+    const identity = ctx.readOutpostIdentity();
+    if (identity.kind === "unknown" || (identity.kind === "id" && identity.id === id)) {
+        const result = ctx.backfillOutpostIdentity(id);
+        printJson({
+            ok: true,
+            action: "outpost-identity-backfill",
+            outpost_id: id,
+            changed: result === "created",
+            marker_path: OUTPOST_ID_PATH,
+        });
+        return;
+    }
+    let known;
+    try {
+        known = await ctx.listOutpostIds();
+    }
+    catch (err) {
+        throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${dispatchErrorMessage(err)}`, {});
+    }
+    assertKnownOutpost(id, known);
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId: id,
+            command: buildOutpostIdentityBackfillCommand(id),
+            timeoutSeconds: 30,
+            waitMs: 30_000,
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_identity_backfill_failed", `Could not backfill Outpost ${id}: ${dispatchErrorMessage(err)}`, { expected_id: id, marker_path: OUTPOST_ID_PATH, outpost_id: id });
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        throw new LanesError("outpost_identity_backfill_failed", `Outpost ${id} did not confirm the identity marker backfill`, {
+            expected_id: id,
+            marker_path: OUTPOST_ID_PATH,
+            outpost_id: id,
+            command_id: dispatched.commandId,
+            status: dispatched.status,
+            done: dispatched.done ?? false,
+            exit_code: dispatched.exitCode,
+        });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost identity backfill");
+    if (remote?.ok !== true ||
+        remote.action !== "outpost-identity-backfill-target" ||
+        remote.outpost_id !== id ||
+        typeof remote.changed !== "boolean" ||
+        remote.marker_path !== OUTPOST_ID_PATH) {
+        throw new LanesError("outpost_identity_backfill_unconfirmed", `Outpost ${id} returned an invalid identity backfill result`, { outpost_id: id, expected_id: id, marker_path: OUTPOST_ID_PATH });
+    }
+    printJson({
+        ok: true,
+        action: "outpost-identity-backfill",
+        outpost_id: id,
+        changed: remote.changed,
+        marker_path: OUTPOST_ID_PATH,
+        outpost_command_id: dispatched.commandId,
+    });
+}
+async function runOutpostIdentityBackfillTarget(ctx, opts) {
+    const expectedId = opts.expectedId?.trim();
+    if (!expectedId) {
+        throw new LanesError("outpost_identity_id_invalid", "Outpost identity target requires --expected-id <outpost-id>", {});
+    }
+    validateOutpostIdentityId(expectedId);
+    const identity = ctx.readOutpostIdentity();
+    if (identity.kind === "not_outpost") {
+        throw new LanesError("outpost_identity_not_host", `Identity backfill target is not an Outpost; expected ${OUTPOST_DIR} to exist`, { expected_id: expectedId, marker_path: OUTPOST_ID_PATH });
+    }
+    const result = ctx.backfillOutpostIdentity(expectedId);
+    printJson({
+        ok: true,
+        action: "outpost-identity-backfill-target",
+        outpost_id: expectedId,
+        changed: result === "created",
+        marker_path: OUTPOST_ID_PATH,
+    });
+}
+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) {
+    assertPlacementEnabled(ctx);
+    const hqRoot = ctx.hqRoot();
+    const policy = parsePlacementPolicy(opts.placement ?? "");
+    const source = readLane(hqRoot, laneId);
+    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);
+    }
+    else if (source.host.kind === "outpost") {
+        moved = await dispatchRemoteLaneMove(ctx, source, choice.host, choice.account);
+    }
+    else {
+        const currentHost = laneHostFromCtx(ctx);
+        throw new LanesError("lane_move_wrong_host", `Move lane ${laneId} from its current host (${source.host.kind}:${source.host.id})`, { lane_id: laneId, lane_host: source.host, current_host: currentHost });
+    }
+    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) {
+    assertPlacementEnabled(ctx);
+    const hqRoot = ctx.hqRoot();
+    const sourceHost = laneHostFromCtx(ctx);
+    const admissionHost = reconcileHostFromCtx(ctx);
+    const before = readLane(hqRoot, laneId);
+    if (!laneRunsHere(before, admissionHost)) {
+        throw new LanesError("lane_move_wrong_host", `Move lane ${laneId} from its current host (${before.host.kind}:${before.host.id})`, { lane_id: laneId, lane_host: before.host, current_host: sourceHost });
+    }
+    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);
+        if (!laneRunsHere(current, admissionHost)) {
+            throw new LanesError("lane_move_conflict", `Lane ${laneId} changed hosts before the move`, {
+                lane_id: laneId,
+                host: current.host,
+            });
+        }
+        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,
+            });
+        }
+        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,
+            ...(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 });
+    }
+    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,
+    });
 }
 async function runShow(ctx, laneId) {
     const hqRoot = ctx.hqRoot();
@@ -4236,6 +5041,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--timeout <secs>", "Deadline in seconds (warns, does not kill)")
         .option("--priority <n>", "Queue priority; higher runs first", "1")
         .option("--outpost <id>", "Run on this Outpost instead of the local host")
+        .option("--placement <mode>", "local | auto | outpost:<id>")
+        .option("--default-placement <mode>", "Default placement for lanes launched by this lane: local | auto | outpost:<id>")
         .action(wrap(async (opts) => {
         await runCreate(ctx, opts);
     }));
@@ -4251,6 +5058,45 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runList(ctx, opts);
     }));
+    lanes
+        .command("capacity")
+        .description("Report this host's lane capacity by provider and account")
+        .option("--json", "JSON on stdout (always)")
+        .action(wrap(async () => {
+        await runCapacity(ctx);
+    }));
+    const outpostIdentity = lanes
+        .command("outpost-identity")
+        .description("Repair this host's Outpost identity marker")
+        .command("backfill")
+        .description("Write a missing Outpost identity marker without replacing an existing value")
+        .requiredOption("--id <outpost-id>", "Expected id of this host's Outpost");
+    outpostIdentity.action(wrap(async (opts) => {
+        await runOutpostIdentityBackfill(ctx, opts);
+    }));
+    lanes
+        .command("outpost-identity-backfill-target", { hidden: true })
+        .requiredOption("--expected-id <outpost-id>", "Expected id of this Outpost")
+        .action(wrap(async (opts) => {
+        await runOutpostIdentityBackfillTarget(ctx, opts);
+    }));
+    lanes
+        .command("move")
+        .description("Move an unstarted queued lane to a host with capacity")
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--placement <mode>", "local | auto | outpost:<id>")
+        .action(wrap(async (laneId, opts) => {
+        await runMove(ctx, laneId, opts);
+    }));
+    lanes
+        .command("move-target", { hidden: true })
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--host-kind <kind>", "local | outpost")
+        .requiredOption("--host-id <id>", "Target host id")
+        .requiredOption("--account <id>", "Provider account id")
+        .action(wrap(async (laneId, opts) => {
+        await runMoveTarget(ctx, laneId, opts);
+    }));
     lanes
         .command("admit")
         .description("Try to admit the oldest eligible queued lane")