@indigoai-us/hq-cli 5.227.1 → 5.228.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [5.228.1] — 2026-09-27
+
+### Fixed
+
+- Reparenting an Outpost lane from the primary now dispatches to the owner,
+  where the hierarchy, tenant, depth, and enabled hire-grant checks are repeated.
+  The primary syncs the changed lane and each descendant whose depth changed.
+  `hq lanes show <lane-id>` refreshes that Outpost lane and its descendants
+  from the owner, including senior history, depth, and grants. Lane sessions
+  now share their lane's depth, and an SSM owner dispatch can change a
+  user-senior lane's grant without allowing a lane caller to impersonate the
+  user.
+
+## [5.228.0] — 2026-09-27
+
+### Changed
+
+- Lane hire grants and Claude account balancing are always active.
+  `backfill-grants --apply` refuses to write; dry-run output remains available.
+
 ## [5.227.1] — 2026-09-27
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -7480,6 +7480,28 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "JSON on stdout (always)";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "reparent-target";
+        readonly description: "";
+        readonly aliases: readonly [];
+        readonly hidden: true;
+        readonly usage: "[options] <lane-id>";
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: false;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--senior <ref>";
+            readonly description: "New senior ref";
+        }, {
+            readonly flags: "--reason <text>";
+            readonly description: "Why the lane is being re-parented";
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "grant-target";
         readonly description: "";
@@ -8285,7 +8307,7 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "claude";
             }, {
                 readonly flags: "--apply";
-                readonly description: "Move eligible between-turn sessions (requires the Claude account balance gate)";
+                readonly description: "Move eligible between-turn sessions to balance Claude accounts";
             }, {
                 readonly flags: "--json";
                 readonly description: "JSON on stdout (always)";

package/dist/command-catalog.generated.js

@@ -9670,6 +9670,35 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "reparent-target",
+                "description": "",
+                "aliases": [],
+                "hidden": true,
+                "usage": "[options] <lane-id>",
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": false
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--senior <ref>",
+                        "description": "New senior ref"
+                    },
+                    {
+                        "flags": "--reason <text>",
+                        "description": "Why the lane is being re-parented"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "grant-target",
                 "description": "",
@@ -10717,7 +10746,7 @@ export const COMMAND_CATALOG = [
                             },
                             {
                                 "flags": "--apply",
-                                "description": "Move eligible between-turn sessions (requires the Claude account balance gate)"
+                                "description": "Move eligible between-turn sessions to balance Claude accounts"
                             },
                             {
                                 "flags": "--json",

package/dist/commands/lanes.d.ts

@@ -10,10 +10,9 @@ import { type TrackerMeshRequest } from "../lib/lanes/tracker-mesh.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";
-export { LANE_HIRE_GRANTS_FLAG };
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
-import { LANE_HIRE_GRANTS_FLAG, 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 { 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";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -87,16 +86,12 @@ export interface LanesCommandDeps {
     monitorEvidence?: MonitorEvidenceReader;
     /** Test seam for the default-off outpost placement rollout flag. */
     lanePlacementEnabled?: () => boolean;
-    /** Test seam for the default-off lane hire-grants rollout gate. */
-    laneHireGrantsEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for the default-off story ledger flag. */
     storyLedgerEnabled?: () => boolean;
     /** Test seam for the SSM-only Outpost owner grant path. */
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
-    /** Test seam for the Claude account-balancing gate. */
-    laneClaudeAccountBalanceEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** 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. */

package/dist/commands/lanes.js

@@ -27,11 +27,10 @@ import { defaultTrackerActor, LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG, regis
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.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";
-export { LANE_HIRE_GRANTS_FLAG };
 import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostQuestionListCommand, buildOutpostQuestionShowCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { outpostHireSummaryCacheKey, readOutpostHireSummaryCache, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
-import { BALANCE_MOVABLE_STATES, CLAUDE_ACCOUNT_BALANCE_FLAG, accountLoadsForReport, assertBalanceApplyEnabled, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-account-balance.js";
+import { BALANCE_MOVABLE_STATES, accountLoadsForReport, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-balance.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";
@@ -42,7 +41,7 @@ import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
@@ -77,20 +76,12 @@ export const LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG = "lanes.host-scoped-account-ho
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
-function defaultLaneClaudeAccountBalanceEnabled(company) {
-    // Keep the local HQ_FLAG override and the registry reader's fail-closed
-    // behavior, matching the lane hire-grants gate.
-    return readLanesRegistryFlag(CLAUDE_ACCOUNT_BALANCE_FLAG, { company });
-}
 function defaultLaneTrackerEnabled(company) {
     return readLanesRegistryFlag(LANES_TRACKER_FLAG, { company });
 }
 function defaultLaneTrackerMeshEnabled(company) {
     return readLanesRegistryFlag(LANES_TRACKER_MESH_FLAG, { company });
 }
-function defaultLaneHireGrantsEnabled(company) {
-    return readLanesRegistryFlag(LANE_HIRE_GRANTS_FLAG, { company });
-}
 function defaultLaneOutpostQuestionVisibilityEnabled(company, env) {
     return readLanesRegistryFlag(LANE_OUTPOST_QUESTION_VISIBILITY_FLAG, {
         company,
@@ -320,11 +311,9 @@ function resolveDeps(deps = {}) {
         })),
         fetchText: deps.fetchText ?? defaultFetchText,
         lanePlacementEnabled: deps.lanePlacementEnabled ?? defaultLanePlacementEnabled,
-        laneHireGrantsEnabled: deps.laneHireGrantsEnabled ?? defaultLaneHireGrantsEnabled,
         storyLedgerEnabled: deps.storyLedgerEnabled ?? laneStoryLedgerEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
-        laneClaudeAccountBalanceEnabled: deps.laneClaudeAccountBalanceEnabled ?? defaultLaneClaudeAccountBalanceEnabled,
         laneOutpostQuestionVisibilityEnabled: deps.laneOutpostQuestionVisibilityEnabled ??
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
@@ -1022,9 +1011,6 @@ async function laneHirePresentation(ctx, lane, lanes) {
         laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
         return { ...local, hire_source: "local" };
     }
-    if (!await ctx.laneHireGrantsEnabled(lane.company)) {
-        return { ...local, hire_source: "local" };
-    }
     try {
         return { ...(await ownerLaneHireFields(ctx, lane)), hire_source: "owner" };
     }
@@ -1059,8 +1045,6 @@ async function withResumeHireAdmission(ctx, lane, fn) {
         !lane.senior.id) {
         return fn();
     }
-    if (!await ctx.laneHireGrantsEnabled(lane.company))
-        return fn();
     return withHireGrantAdmission(hqRoot, lane.senior.id, (snapshot) => {
         const current = readLane(hqRoot, lane.lane_id);
         // A different resume already reactivated this lane; it occupies the slot
@@ -1684,7 +1668,11 @@ function depthOfRef(hqRoot, ref, ctx, visited = new Set(), override) {
                 senior: ref,
             });
         }
-        return depthOfRef(hqRoot, seniorOfSession(hqRoot, ref.id, ctx), ctx, visited, override) + 1;
+        const sessionSenior = seniorOfSession(hqRoot, ref.id, ctx);
+        const seniorDepth = depthOfRef(hqRoot, sessionSenior, ctx, visited, override);
+        // A lane's execution session shares the lane's depth. Other sessions are
+        // their own authority hop, including user-owned and nested sessions.
+        return seniorDepth + (sessionSenior.kind === "lane" ? 0 : 1);
     }
     if (!ref.id) {
         throw new LanesError("invalid_senior_ref", "Lane senior is missing an id", {
@@ -2664,18 +2652,14 @@ async function runCreate(ctx, opts) {
     }
     const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
     assertSeniorExists(hqRoot, senior, ctx);
-    // Resolve tenant context before the registry read so the flag evaluator
-    // applies the same company scope as this lane.
     const company = companyFlag
         ? await ctx.resolveCompany(companyFlag)
         : null;
-    const hireGrantsEnabled = await ctx.laneHireGrantsEnabled(company);
     if (requestedHireGrant !== undefined &&
         !callerMatchesSenior(ctx, senior)) {
         throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(senior)} may set a lane's hire grant`, { senior, hire_grant: requestedHireGrant });
     }
-    if (hireGrantsEnabled &&
-        ctx.env.HQ_LANE_ID?.trim() &&
+    if (ctx.env.HQ_LANE_ID?.trim() &&
         !callerMatchesSenior(ctx, senior)) {
         throw new LanesError("hire_grant_unauthorized", `Only senior lane ${senior.id} may create a direct child lane`, { senior_lane_id: senior.id });
     }
@@ -3031,7 +3015,7 @@ async function runCreate(ctx, opts) {
     }
     const allowedAccounts = validatedAccounts.size > 0 ? [...validatedAccounts] : profileAccounts;
     let accountSelection;
-    if (provider === "claude" && await ctx.laneClaudeAccountBalanceEnabled(company)) {
+    if (provider === "claude") {
         const targetHost = placementHostOverride ?? (outpostId !== undefined
             ? { kind: "outpost", id: outpostId }
             : laneHostFromCtx(ctx));
@@ -3223,13 +3207,13 @@ async function runCreate(ctx, opts) {
         };
         const lane = senior.kind === "lane"
             ? withHireGrantAdmission(hqRoot, senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
-                if (hireGrantsEnabled && isTerminalLaneState(parent.state)) {
+                if (isTerminalLaneState(parent.state)) {
                     throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot hire lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
                 }
-                if (hireGrantsEnabled && children.length >= parentGrant) {
+                if (children.length >= parentGrant) {
                     throw hireGrantCapacityError(parent, children);
                 }
-                if (hireGrantsEnabled && hireGrant > availableChildGrant) {
+                if (hireGrant > availableChildGrant) {
                     throw new LanesError("hire_grant_carve_exceeded", `Lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining after its other alive children. Ask its senior to raise its grant before assigning ${hireGrant}.`, {
                         senior_lane_id: parent.lane_id,
                         parent_grant: parentGrant,
@@ -3622,7 +3606,6 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
     let grantContext;
     let grantHierarchy;
     if (action === "grant") {
-        const enforcementEnabled = await ctx.laneHireGrantsEnabled(lane.company);
         let hierarchy = loadAllLanes(ctx.hqRoot());
         const ownerLanes = await readOutpostLaneRecords(ctx, outpostId);
         const byId = new Map(hierarchy.map((record) => [record.lane_id, record]));
@@ -3631,16 +3614,22 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         }
         hierarchy = [...byId.values()];
         grantHierarchy = hierarchy;
-        grantContext = createOutpostHireGrantContext(lane, hierarchy, enforcementEnabled);
+        grantContext = createOutpostHireGrantContext(lane, hierarchy);
     }
     let dispatched;
     try {
         dispatched = await ctx.dispatchOutpostExec({
             outpostId,
             command: buildOutpostLaneCommand({
-                action: action === "grant" ? "grant-target" : action,
+                action: action === "grant"
+                    ? "grant-target"
+                    : action === "reparent"
+                        ? "reparent-target"
+                        : action,
                 laneId: lane.lane_id,
-                hqBinary: action === "grant" ? outpostCliOverride(ctx, outpostId) : undefined,
+                hqBinary: action === "grant" || action === "reparent"
+                    ? outpostCliOverride(ctx, outpostId)
+                    : undefined,
                 text: options.text,
                 project: options.project,
                 story: options.story,
@@ -3650,6 +3639,8 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
                 worker: options.worker,
                 keepAlive: options.keepAlive,
                 hire: options.hire,
+                senior: options.senior,
+                reason: options.reason,
                 grantContext,
                 compact: options.compact,
             }),
@@ -3703,6 +3694,9 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
             owner_error: ownerErrorFromOutput(dispatched.stdout),
         });
     }
+    const changedDescendantIds = action === "reparent"
+        ? parseReparentDescendantIds(remote?.changed_descendant_ids, lane.lane_id, outpostId)
+        : [];
     const resultConfirmed = remote !== null &&
         remote.ok === true &&
         remote.action === action &&
@@ -3711,8 +3705,11 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
             ? remote.accepted === true
             : action === "grant"
                 ? remote.hire_grant === Number(options.hire)
-                : remote.delivery_status === "worker_spawned" ||
-                    remote.delivery_status === "queued_on_target_account");
+                : action === "reparent"
+                    ? remote.lane !== null && typeof remote.lane === "object" &&
+                        Array.isArray(remote.changed_descendant_ids)
+                    : remote.delivery_status === "worker_spawned" ||
+                        remote.delivery_status === "queued_on_target_account");
     if (!resultConfirmed) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without a confirmed ${action} result for lane ${lane.lane_id}`, {
             lane_id: lane.lane_id,
@@ -3733,6 +3730,25 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         });
         return;
     }
+    if (action === "reparent") {
+        const ownerLane = syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, remote.lane, undefined, { allowNonTerminal: true });
+        const descendants = [];
+        for (const descendantId of changedDescendantIds) {
+            const ownerDescendant = await readOutpostLaneSnapshot(ctx, outpostId, descendantId);
+            descendants.push(syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
+        }
+        printJson({
+            ...remote,
+            lane_id: ownerLane.lane_id,
+            lane: ownerLane,
+            changed_descendant_ids: changedDescendantIds,
+            descendants,
+            outpost_id: outpostId,
+            outpost_command_id: dispatched.commandId,
+            outpost_transport: "outposts_exec",
+        });
+        return;
+    }
     printJson({
         ...remote,
         outpost_id: outpostId,
@@ -3740,6 +3756,42 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         outpost_transport: "outposts_exec",
     });
 }
+function parseReparentDescendantIds(value, laneId, outpostId) {
+    if (!Array.isArray(value) || value.some((id) => typeof id !== "string" || id.trim() === "")) {
+        throw new LanesError("outpost_reparent_result_invalid", `Outpost ${outpostId} returned an invalid descendant list for lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId });
+    }
+    const ids = value;
+    if (new Set(ids).size !== ids.length || ids.includes(laneId)) {
+        throw new LanesError("outpost_reparent_result_invalid", `Outpost ${outpostId} returned duplicate or self-referential descendants for lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, descendant_lane_ids: ids });
+    }
+    return ids;
+}
+async function readOutpostLaneSnapshot(ctx, outpostId, laneId) {
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneCommand({
+                action: "show",
+                laneId,
+                hqBinary: outpostCliOverride(ctx, outpostId),
+            }),
+            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
+            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_lane_sync_unavailable", `Could not refresh descendant lane ${laneId} from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: laneId, outpost_id: outpostId });
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        throw new LanesError("outpost_lane_sync_unavailable", `Outpost ${outpostId} did not confirm the snapshot for descendant lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, command_id: dispatched.commandId });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost descendant lane snapshot");
+    if (!remote || remote.ok !== true || remote.action !== "show" || remote.lane === undefined) {
+        throw new LanesError("outpost_lane_sync_invalid", `Outpost ${outpostId} returned an invalid snapshot for descendant lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, command_id: dispatched.commandId });
+    }
+    return remote.lane;
+}
 async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
@@ -4177,25 +4229,15 @@ async function runList(ctx, opts) {
     })
         .sort(compareLaneQueueOrder);
     const ownerEligibleLaneIds = new Set();
-    const companyContexts = new Map();
     for (const lane of selectedLanes) {
         if (lane.host.kind !== "outpost" ||
             isTerminalLaneState(lane.state) ||
             laneRunsHere(lane, host)) {
             continue;
         }
-        const companyKey = JSON.stringify([
-            lane.company?.uid ?? null,
-            lane.company?.slug ?? null,
-        ]);
         ownerEligibleLaneIds.add(lane.lane_id);
-        companyContexts.set(companyKey, lane.company);
     }
-    const enabledByCompany = new Map(await Promise.all([...companyContexts.entries()].map(async ([companyKey, company]) => [
-        companyKey,
-        await ctx.laneHireGrantsEnabled(company),
-    ])));
-    const ownerLanes = [];
+    const ownerLanes = selectedLanes.filter((lane) => ownerEligibleLaneIds.has(lane.lane_id));
     const hireByLane = new Map();
     for (const lane of selectedLanes) {
         if (!ownerEligibleLaneIds.has(lane.lane_id)) {
@@ -4205,18 +4247,6 @@ async function runList(ctx, opts) {
             });
             continue;
         }
-        const companyKey = JSON.stringify([
-            lane.company?.uid ?? null,
-            lane.company?.slug ?? null,
-        ]);
-        if (enabledByCompany.get(companyKey))
-            ownerLanes.push(lane);
-        else {
-            hireByLane.set(lane.lane_id, {
-                ...laneHireFields(lane, allLanes),
-                hire_source: "local",
-            });
-        }
     }
     if (ownerLanes.length > 0) {
         const ownerSummaries = await batchOwnerLaneHireFields(ctx, ownerLanes);
@@ -4760,9 +4790,38 @@ async function runMoveTarget(ctx, laneId, opts) {
         account: moved.account ?? null,
     });
 }
+async function refreshOutpostLaneCopiesForShow(ctx, lane, localLanes) {
+    if (lane.host.kind !== "outpost" || laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
+        return lane;
+    }
+    const outpostId = lane.host.id;
+    const descendantIds = localLanes
+        .filter((candidate) => candidate.lane_id !== lane.lane_id &&
+        candidate.host.kind === "outpost" && candidate.host.id === outpostId &&
+        walkHitsLane(ctx.hqRoot(), candidate.senior, lane.lane_id, ctx))
+        .map((candidate) => candidate.lane_id);
+    const refresh = async (laneId) => {
+        try {
+            const ownerLane = await readOutpostLaneSnapshot(ctx, outpostId, laneId);
+            return syncLaneRecordFromOwner(ctx.hqRoot(), laneId, outpostId, ownerLane, undefined, { allowNonTerminal: true });
+        }
+        catch (err) {
+            const detail = isLanesError(err)
+                ? `${err.error}: ${err.message}`
+                : `outpost_lane_sync_unavailable: ${dispatchErrorMessage(err)}`;
+            process.stderr.write(`hq lanes: owner snapshot refresh failed for lane ${laneId}: ${detail}\n`);
+            return null;
+        }
+    };
+    const refreshed = await mapWithConcurrency([lane.lane_id, ...descendantIds], OUTPOST_HIRE_SUMMARY_CONCURRENCY, refresh);
+    const refreshedLane = refreshed[0] ?? null;
+    return refreshedLane ?? lane;
+}
 async function runShow(ctx, laneId) {
     const hqRoot = ctx.hqRoot();
-    const storedLane = readLane(hqRoot, laneId);
+    const initialLane = readLane(hqRoot, laneId);
+    const initialLanes = loadAllLanes(hqRoot);
+    const storedLane = await refreshOutpostLaneCopiesForShow(ctx, initialLane, initialLanes);
     const allLanes = loadAllLanes(hqRoot);
     const hire = await laneHirePresentation(ctx, storedLane, allLanes);
     const remoteQueued = storedLane.state === "queued" &&
@@ -4852,8 +4911,6 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
         (!grantContext || !sameHireGrantSenior(initial.senior, grantContext.expected_senior))) {
         throw new LanesError("hire_grant_senior_changed", `Lane ${laneId}'s senior changed after the primary authorized its grant update`, { lane_id: laneId, current_senior: initial.senior });
     }
-    const enforce = grantContext?.enforcement_enabled ??
-        await ctx.laneHireGrantsEnabled(initial.company);
     const lockedLaneIds = [
         laneId,
         ...(initial.senior.kind === "lane" && initial.senior.id
@@ -4878,7 +4935,7 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
                 ? mergeOwnerLaneHierarchy(grantContext.hierarchy, loadAllLanes(hqRoot))
                 : grantContext.hierarchy
             : loadAllLanes(hqRoot);
-        if (enforce && current.senior.kind === "lane") {
+        if (current.senior.kind === "lane") {
             if (!current.senior.id) {
                 throw new LanesError("hire_grant_senior_invalid", `Lane ${laneId} has a lane senior without an id`, {
                     lane_id: laneId,
@@ -4908,19 +4965,17 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
                 });
             }
         }
-        if (enforce) {
-            const children = aliveDirectChildren(hierarchy, current.lane_id);
-            const allocated = assignedChildHireGrants(children);
-            const minimumGrant = Math.max(allocated, children.length);
-            if (hireGrant < minimumGrant) {
-                throw new LanesError(allocated > children.length ? "hire_grant_below_allocated" : "hire_grant_below_occupancy", `Lane ${laneId} cannot lower its grant to ${hireGrant}; it has ${children.length} alive children and ${allocated} grant allocated to them`, {
-                    lane_id: laneId,
-                    requested_hire_grant: hireGrant,
-                    alive_children: children.map((child) => child.lane_id),
-                    alive_child_count: children.length,
-                    assigned_child_grants: allocated,
-                });
-            }
+        const children = aliveDirectChildren(hierarchy, current.lane_id);
+        const allocated = assignedChildHireGrants(children);
+        const minimumGrant = Math.max(allocated, children.length);
+        if (hireGrant < minimumGrant) {
+            throw new LanesError(allocated > children.length ? "hire_grant_below_allocated" : "hire_grant_below_occupancy", `Lane ${laneId} cannot lower its grant to ${hireGrant}; it has ${children.length} alive children and ${allocated} grant allocated to them`, {
+                lane_id: laneId,
+                requested_hire_grant: hireGrant,
+                alive_children: children.map((child) => child.lane_id),
+                alive_child_count: children.length,
+                assigned_child_grants: allocated,
+            });
         }
         return retryUpdateLane(hqRoot, laneId, "command", (record) => ({
             ...record,
@@ -5011,11 +5066,8 @@ async function runBackfillGrants(ctx, opts) {
     }
     const apply = Boolean(opts.apply);
     const hqRoot = ctx.hqRoot();
-    if (apply && await ctx.laneHireGrantsEnabled(null)) {
-        throw new LanesError("hire_grant_backfill_gate_enabled", "Backfill must be applied and verified before lanes.hire-grants is enabled", { flag: LANE_HIRE_GRANTS_FLAG });
-    }
-    if (apply && ctx.env.HQ_LANE_ID?.trim()) {
-        throw new LanesError("hire_grant_backfill_unauthorized", "A lane cannot apply the hire-grant backfill; run it from an operator session", {});
+    if (apply) {
+        throw new LanesError("hire_grant_backfill_gate_enabled", "Grant backfill can only be applied before always-on enforcement is released", {});
     }
     const allLanes = loadAllLanes(hqRoot);
     const profileIds = new Set(allLanes
@@ -5040,76 +5092,11 @@ async function runBackfillGrants(ctx, opts) {
         if (maxConcurrent !== undefined)
             profileMaxConcurrent.set(profileId, maxConcurrent);
     }
-    let rows = planHireGrantBackfill(allLanes, profileMaxConcurrent);
-    if (apply) {
-        const lanesById = new Map(allLanes.map((lane) => [lane.lane_id, lane]));
-        const targetCompanies = new Map();
-        for (const row of rows) {
-            if (row.action === "unchanged")
-                continue;
-            const lane = lanesById.get(row.lane_id);
-            if (!lane) {
-                throw new LanesError("hire_grant_backfill_target_changed", `Backfill target lane ${row.lane_id} is unavailable`, { lane_id: row.lane_id });
-            }
-            const company = lane.company;
-            if (!company)
-                continue;
-            targetCompanies.set(JSON.stringify([company.uid ?? null, company.slug ?? null]), company);
-        }
-        const companyGates = await Promise.all([...targetCompanies.values()].map((company) => ctx.laneHireGrantsEnabled(company)));
-        if (companyGates.some(Boolean)) {
-            throw new LanesError("hire_grant_backfill_gate_enabled", "Backfill must be applied and verified before lanes.hire-grants is enabled", { flag: LANE_HIRE_GRANTS_FLAG });
-        }
-        const shortfalls = rows.filter((row) => row.grant_shortfall > 0);
-        if (shortfalls.length > 0) {
-            throw new LanesError("hire_grant_backfill_allocation_shortfall", "Existing parent grants do not cover the grants allocated to alive children; resolve these rows before applying the backfill", { lanes: shortfalls });
-        }
-        rows = rows.map((row) => {
-            if (row.action === "unchanged")
-                return row;
-            const lane = readLane(hqRoot, row.lane_id);
-            const lockIds = [
-                lane.lane_id,
-                ...(lane.senior.kind === "lane" && lane.senior.id ? [lane.senior.id] : []),
-            ];
-            return withLaneHireLocks(hqRoot, lockIds, () => {
-                const current = readLane(hqRoot, row.lane_id);
-                if (current.hire_grant !== undefined) {
-                    return {
-                        ...row,
-                        existing_grant: current.hire_grant,
-                        proposed_grant: current.hire_grant,
-                        action: "unchanged",
-                    };
-                }
-                const latestLanes = loadAllLanes(hqRoot);
-                const latestRow = planHireGrantBackfill(latestLanes, profileMaxConcurrent)
-                    .find((candidate) => candidate.lane_id === current.lane_id);
-                if (!latestRow) {
-                    throw new LanesError("hire_grant_backfill_target_changed", `Lane ${current.lane_id} no longer qualifies for the hire-grant backfill`, { lane_id: current.lane_id });
-                }
-                if (latestRow.grant_shortfall > 0) {
-                    throw new LanesError("hire_grant_backfill_allocation_shortfall", `Lane ${current.lane_id}'s existing grant does not cover grants allocated to its alive children`, { lane: latestRow });
-                }
-                const proposed = latestRow.proposed_grant;
-                const written = retryUpdateLane(hqRoot, current.lane_id, "command", (record) => ({
-                    ...record,
-                    ...(record.hire_grant === undefined ? { hire_grant: proposed } : {}),
-                }));
-                const value = written.hire_grant ?? 0;
-                return {
-                    ...row,
-                    existing_grant: value,
-                    proposed_grant: value,
-                    action: value === proposed ? "set" : "unchanged",
-                };
-            });
-        });
-    }
+    const rows = planHireGrantBackfill(allLanes, profileMaxConcurrent);
     printJson({
         ok: true,
         action: "backfill-grants",
-        mode: apply ? "apply" : "dry-run",
+        mode: "dry-run",
         lanes: rows,
     });
 }
@@ -5584,7 +5571,6 @@ async function prepareAccountMove(ctx, lane, input) {
 async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, options = {}) {
     if (lane.provider !== "claude")
         return undefined;
-    const balanceEnabled = await ctx.laneClaudeAccountBalanceEnabled(lane.company);
     const hqRoot = ctx.hqRoot();
     const config = loadLanesConfig(hqRoot);
     const currentConfig = lane.account === undefined
@@ -5601,19 +5587,6 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     const accountNeedsRepair = lane.account !== undefined &&
         (currentConfig?.enabled !== true || currentLogin === false);
     const repairUnavailableAccount = options.repairUnavailableAccount === true && accountNeedsRepair;
-    if (!balanceEnabled && !(options.repairUnavailableAccount && accountNeedsRepair)) {
-        if (lane.account === undefined)
-            return undefined;
-        if (currentConfig === undefined || !currentConfig.enabled) {
-            throw new AccountResolutionError(currentConfig === undefined ? "unknown_account" : "account_disabled", currentConfig === undefined
-                ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for claude`
-                : `Account ${JSON.stringify(lane.account)} is unavailable for claude`, { provider: "claude", account: lane.account });
-        }
-        if (currentLogin === false) {
-            throw new LanesError("account_not_logged_in", `Account ${lane.account} for claude is not logged in`, { provider: "claude", account: lane.account, lane_id: lane.lane_id });
-        }
-        return undefined;
-    }
     const profile = workerProfile?.profile ?? (lane.worker_profile !== undefined
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
@@ -5641,28 +5614,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     const mayRebalance = BALANCE_MOVABLE_STATES.includes(lane.state);
     if (!accountNeedsRepair && !mayRebalance)
         return undefined;
-    const balanceHosts = balanceEnabled
-        ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
-        : (() => {
-            const lanes = loadAllLanes(hqRoot).filter((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
-            return {
-                snapshots: [{
-                        capacity: buildHostCapacitySnapshot({
-                            host: lane.host,
-                            lanes,
-                            config,
-                            existsSync: ctx.existsSync,
-                            probe: ctx.probeProvider,
-                            env: ctx.env,
-                            hostname: ctx.hostname(),
-                            now: ctx.now(),
-                        }),
-                        lanes,
-                        laneListAvailable: true,
-                    }],
-                unavailableHosts: [],
-            };
-        })();
+    const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
     const targetHost = balanceHosts.snapshots.find((host) => host.capacity.host.kind === lane.host.kind && host.capacity.host.id === lane.host.id);
     const currentTargetAccount = lane.account === undefined
         ? undefined
@@ -6294,7 +6246,6 @@ async function applyClaudeBalanceMove(ctx, suggestion) {
         return { lane_id: suggestion.lane_id, host: suggestion.host, from: suggestion.from, to: suggestion.to, state: suggestion.state };
     }
     const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), suggestion.lane_id));
-    assertBalanceApplyEnabled(await ctx.laneClaudeAccountBalanceEnabled(lane.company));
     if (lane.state === "running") {
         throw new LanesError("lane_running", `Lane ${lane.lane_id} is running; balance never moves a running turn`, {
             lane_id: lane.lane_id,
@@ -6324,7 +6275,6 @@ async function applyClaudeBalanceMove(ctx, suggestion) {
 }
 async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
     const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), laneId));
-    assertBalanceApplyEnabled(await ctx.laneClaudeAccountBalanceEnabled(lane.company));
     assertLaneRunsHereForOperatorMutation(ctx, lane, "balance-move-target");
     if (lane.provider !== "claude") {
         throw new LanesError("claude_account_balance_provider_mismatch", `Lane ${laneId} does not use Claude`, {
@@ -7065,6 +7015,29 @@ function archiveResumeMessage(hqRoot, laneId, message) {
     fs.writeFileSync(path.join(dir, `${message.message_id}.resume.jsonl`), `${JSON.stringify(message)}\n`, "utf8");
 }
 async function runReparent(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    if (!opts.senior) {
+        throw new LanesError("missing_senior", "--senior is required", {});
+    }
+    const initial = readLane(hqRoot, laneId);
+    if (initial.host.kind === "outpost" && !laneRunsHere(initial, reconcileHostFromCtx(ctx))) {
+        await dispatchOutpostLaneCommand(ctx, initial, "reparent", {
+            senior: opts.senior,
+            reason: opts.reason,
+        });
+        return;
+    }
+    const result = await reparentOnOwner(ctx, laneId, opts);
+    printJson({
+        ok: true,
+        action: "reparent",
+        lane_id: result.lane.lane_id,
+        lane: result.lane,
+        pending_questions: result.pendingQuestions,
+        changed_descendant_ids: result.changedDescendantIds,
+    });
+}
+async function reparentOnOwner(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     if (!opts.senior) {
         throw new LanesError("missing_senior", "--senior is required", {});
@@ -7072,19 +7045,32 @@ async function runReparent(ctx, laneId, opts) {
     const nextSenior = parseSeniorRef(opts.senior);
     assertSeniorExists(hqRoot, nextSenior, ctx);
     const initial = readLane(hqRoot, laneId);
-    const needsHireGrantGate = nextSenior.kind === "lane" &&
-        seniorKey(initial.senior) !== seniorKey(nextSenior);
-    const hireGrantsEnabled = needsHireGrantGate
-        ? await ctx.laneHireGrantsEnabled(initial.company)
-        : false;
     const lockIds = [
         laneId,
         ...(initial.senior.kind === "lane" && initial.senior.id ? [initial.senior.id] : []),
         ...(nextSenior.kind === "lane" && nextSenior.id ? [nextSenior.id] : []),
     ];
-    withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts, hireGrantsEnabled));
+    return withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts));
 }
-function runReparentLocked(ctx, laneId, opts, hireGrantsEnabled) {
+async function runReparentOwnerTarget(ctx, laneId, opts) {
+    if (!ctx.isSsmOwnerDispatch()) {
+        throw new LanesError("outpost_reparent_dispatch_unauthorized", "The Outpost reparent target is available only to an SSM Run Command dispatch", { lane_id: laneId });
+    }
+    const lane = readLane(ctx.hqRoot(), laneId);
+    if (lane.host.kind !== "outpost" || !laneIsHostedHere(ctx, lane)) {
+        throw new LanesError("lane_remote", `Outpost reparent target cannot mutate lane ${laneId} on this host`, { lane_id: laneId, host: lane.host });
+    }
+    const result = await reparentOnOwner(ctx, laneId, opts);
+    printJson({
+        ok: true,
+        action: "reparent",
+        lane_id: result.lane.lane_id,
+        lane: result.lane,
+        pending_questions: result.pendingQuestions,
+        changed_descendant_ids: result.changedDescendantIds,
+    });
+}
+function runReparentLocked(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     if (!opts.senior) {
         throw new LanesError("missing_senior", "--senior is required", {});
@@ -7098,8 +7084,7 @@ function runReparentLocked(ctx, laneId, opts, hireGrantsEnabled) {
     }
     const seniorCompany = companyOfSenior(hqRoot, nextSenior, ctx);
     assertSameTenant(lane.company, nextSenior, seniorCompany, { lane_id: laneId });
-    if (hireGrantsEnabled &&
-        nextSenior.kind === "lane" &&
+    if (nextSenior.kind === "lane" &&
         seniorKey(lane.senior) !== seniorKey(nextSenior)) {
         const parent = readLane(hqRoot, nextSenior.id);
         if (isTerminalLaneState(parent.state)) {
@@ -7154,7 +7139,11 @@ function runReparentLocked(ctx, laneId, opts, hireGrantsEnabled) {
                 to_depth: descendantDepth,
             });
         }
-        descendants.push({ laneId: other.lane_id, depth: descendantDepth });
+        descendants.push({
+            laneId: other.lane_id,
+            depth: descendantDepth,
+            changed: descendantDepth !== oldDescendantDepth,
+        });
     }
     const at = ctx.now().toISOString();
     const updated = casUpdateLane(hqRoot, laneId, (current) => {
@@ -7199,12 +7188,13 @@ function runReparentLocked(ctx, laneId, opts, hireGrantsEnabled) {
             };
         });
     }
-    printJson({
-        ok: true,
-        action: "reparent",
+    return {
         lane: updated,
-        pending_questions: pending.length,
-    });
+        pendingQuestions: pending.length,
+        changedDescendantIds: descendants
+            .filter((descendant) => descendant.changed)
+            .map((descendant) => descendant.laneId),
+    };
 }
 const CANONICAL_LOG_STREAMS = [
     "watcher.err",
@@ -8558,27 +8548,9 @@ async function runAccountsBalance(ctx, opts) {
     const hqRoot = ctx.hqRoot();
     const config = loadLanesConfig(hqRoot);
     const loaded = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
-    const laneBalanceGateEnabled = new Map();
-    const companyBalanceGateEnabled = new Map();
-    const lanes = loaded.snapshots.flatMap((host) => host.lanes);
-    for (const lane of lanes) {
-        const companyKey = JSON.stringify([lane.company?.uid ?? null, lane.company?.slug ?? null]);
-        let enabled = companyBalanceGateEnabled.get(companyKey);
-        if (enabled === undefined) {
-            enabled = await ctx.laneClaudeAccountBalanceEnabled(lane.company);
-            companyBalanceGateEnabled.set(companyKey, enabled);
-        }
-        laneBalanceGateEnabled.set(lane.lane_id, enabled);
-    }
-    // With no lanes there is no tenant scope to resolve, so report and enforce
-    // the unscoped/default gate. Otherwise the report reflects whether any
-    // represented lane company has the gate enabled.
-    if (lanes.length === 0) {
-        companyBalanceGateEnabled.set(JSON.stringify([null, null]), await ctx.laneClaudeAccountBalanceEnabled());
-    }
-    const balanceGateEnabled = [...companyBalanceGateEnabled.values()].some(Boolean);
-    if (opts.apply)
-        assertBalanceApplyEnabled(balanceGateEnabled);
+    // Retain the established response field for clients; balancing is now
+    // unconditional, so this compatibility value is always true.
+    const balanceGateEnabled = true;
     const loads = accountLoadsForReport({ hosts: loaded.snapshots, config });
     const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
     const selections = loaded.snapshots.map((host) => {
@@ -8640,16 +8612,6 @@ async function runAccountsBalance(ctx, opts) {
                 });
                 continue;
             }
-            if (laneBalanceGateEnabled.get(suggestion.lane_id) !== true) {
-                skipped.push({
-                    lane_id: suggestion.lane_id,
-                    host: suggestion.host,
-                    from: suggestion.from,
-                    to: suggestion.to,
-                    reason: "claude_account_balance_disabled",
-                });
-                continue;
-            }
             try {
                 moved.push(await applyClaudeBalanceMove(ctx, suggestion));
             }
@@ -9165,6 +9127,14 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runCreate(ctx, opts);
     }));
+    lanes
+        .command("reparent-target", { hidden: true })
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--senior <ref>", "New senior ref")
+        .option("--reason <text>", "Why the lane is being re-parented")
+        .action(wrap(async (laneId, opts) => {
+        await runReparentOwnerTarget(ctx, laneId, opts);
+    }));
     lanes
         .command("grant-target", { hidden: true })
         .argument("<lane-id>", "Lane id")
@@ -9514,7 +9484,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("balance")
         .description("Report Claude account load and suggest safe between-turn moves")
         .requiredOption("--provider <name>", "claude")
-        .option("--apply", "Move eligible between-turn sessions (requires the Claude account balance gate)")
+        .option("--apply", "Move eligible between-turn sessions to balance Claude accounts")
         .option("--json", "JSON on stdout (always)")
         .action(wrap(async (opts) => {
         await runAccountsBalance(ctx, opts);

package/dist/lib/lanes/{claude-account-balance.d.ts → claude-balance.d.ts}

@@ -1,7 +1,6 @@
 import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
 import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
-export declare const CLAUDE_ACCOUNT_BALANCE_FLAG = "lanes.claude-account-balance";
 export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
 export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
 export interface BalanceHostSnapshot {
@@ -82,5 +81,4 @@ export declare function planClaudeBalanceMoves(input: {
     hosts: readonly BalanceHostSnapshot[];
     config: LanesConfig;
 }): BalanceMoveSuggestion[];
-export declare function assertBalanceApplyEnabled(enabled: boolean): void;
-//# sourceMappingURL=claude-account-balance.d.ts.map
+//# sourceMappingURL=claude-balance.d.ts.map

package/dist/lib/lanes/{claude-account-balance.js → claude-balance.js}

@@ -1,5 +1,4 @@
 import { LanesError } from "./errors.js";
-export const CLAUDE_ACCOUNT_BALANCE_FLAG = "lanes.claude-account-balance";
 export const BALANCE_LIVE_STATES = ["running", "queued", "awaiting_input"];
 export const BALANCE_MOVABLE_STATES = ["interrupted", "done", "awaiting_input"];
 function sameHost(a, b) {
@@ -263,9 +262,4 @@ export function planClaudeBalanceMoves(input) {
     }
     return suggestions;
 }
-export function assertBalanceApplyEnabled(enabled) {
-    if (!enabled) {
-        throw new LanesError("claude_account_balance_disabled", `Applying Claude account balance moves requires hq-flags gate ${CLAUDE_ACCOUNT_BALANCE_FLAG}`, { flag: CLAUDE_ACCOUNT_BALANCE_FLAG });
-    }
-}
-//# sourceMappingURL=claude-account-balance.js.map
+//# sourceMappingURL=claude-balance.js.map

package/dist/lib/lanes/{hire-grants.d.ts → grants.d.ts}

@@ -1,6 +1,5 @@
 import { type LaneRecord } from "./types.js";
 import { LanesError } from "./errors.js";
-export declare const LANE_HIRE_GRANTS_FLAG = "lanes.hire-grants";
 export type LaneHireGrantRow = Pick<LaneRecord, "lane_id" | "state" | "senior" | "hire_grant">;
 export declare function aliveDirectChildren<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string): T[];
 export declare function assignedChildHireGrants(children: readonly LaneHireGrantRow[], exceptLaneId?: string): number;
@@ -27,4 +26,4 @@ export interface HireGrantBackfillRow {
 }
 /** Select alive manager lanes and calculate the non-destructive one-time backfill. */
 export declare function planHireGrantBackfill(lanes: readonly LaneRecord[], profileMaxConcurrent: ReadonlyMap<string, number>): HireGrantBackfillRow[];
-//# sourceMappingURL=hire-grants.d.ts.map
+//# sourceMappingURL=grants.d.ts.map

package/dist/lib/lanes/{hire-grants.js → grants.js}

@@ -1,7 +1,6 @@
 import { isTerminalLaneState } from "./types.js";
 import { listLaneIds, readLane, withLaneHireLocks } from "./store.js";
 import { LanesError } from "./errors.js";
-export const LANE_HIRE_GRANTS_FLAG = "lanes.hire-grants";
 export function aliveDirectChildren(lanes, parentLaneId) {
     return lanes.filter((lane) => lane.senior.kind === "lane" &&
         lane.senior.id === parentLaneId &&
@@ -144,4 +143,4 @@ export function planHireGrantBackfill(lanes, profileMaxConcurrent) {
     })
         .sort((a, b) => a.lane_id.localeCompare(b.lane_id));
 }
-//# sourceMappingURL=hire-grants.js.map
+//# sourceMappingURL=grants.js.map

package/dist/lib/lanes/hire-grant-dispatch.d.ts

@@ -13,7 +13,7 @@ export interface OutpostHireGrantContext {
     hierarchy: HireGrantLaneSnapshot[];
 }
 /** Encode only the owner-relevant hierarchy from the primary's complete store. */
-export declare function createOutpostHireGrantContext(target: LaneRecord, lanes: readonly LaneRecord[], enforcementEnabled: boolean): string;
+export declare function createOutpostHireGrantContext(target: LaneRecord, lanes: readonly LaneRecord[]): string;
 /** Decode and validate an owner grant context, binding it to the target lane. */
 export declare function parseOutpostHireGrantContext(encoded: string, targetLaneId: string): OutpostHireGrantContext;
 export declare function sameHireGrantSenior(a: SeniorRef, b: SeniorRef): boolean;

package/dist/lib/lanes/hire-grant-dispatch.js

@@ -1,4 +1,4 @@
-import { aliveDirectChildren } from "./hire-grants.js";
+import { aliveDirectChildren } from "./grants.js";
 import { LanesError } from "./errors.js";
 import { isLaneState, isSeniorKind, } from "./types.js";
 const HIRE_GRANT_CONTEXT_SCHEMA = "hq-lane-hire-grant-context.v1";
@@ -24,29 +24,27 @@ function snapshot(lane) {
     };
 }
 /** Encode only the owner-relevant hierarchy from the primary's complete store. */
-export function createOutpostHireGrantContext(target, lanes, enforcementEnabled) {
+export function createOutpostHireGrantContext(target, lanes) {
     const current = lanes.find((lane) => lane.lane_id === target.lane_id);
     if (!current || !sameSenior(current.senior, target.senior)) {
         throw new LanesError("hire_grant_hierarchy_unavailable", `Cannot build an authoritative hire-grant hierarchy for lane ${target.lane_id}`, { lane_id: target.lane_id });
     }
     const relevant = new Map();
     relevant.set(current.lane_id, current);
-    if (enforcementEnabled) {
-        if (current.senior.kind === "lane") {
-            const parentId = current.senior.id;
-            const parent = parentId ? lanes.find((lane) => lane.lane_id === parentId) : undefined;
-            if (!parent) {
-                throw new LanesError("hire_grant_senior_invalid", `Lane ${target.lane_id} has no senior lane in the primary hierarchy`, { lane_id: target.lane_id, senior_lane_id: parentId ?? null });
-            }
-            relevant.set(parent.lane_id, parent);
-            for (const sibling of aliveDirectChildren(lanes, parent.lane_id)) {
-                relevant.set(sibling.lane_id, sibling);
-            }
+    if (current.senior.kind === "lane") {
+        const parentId = current.senior.id;
+        const parent = parentId ? lanes.find((lane) => lane.lane_id === parentId) : undefined;
+        if (!parent) {
+            throw new LanesError("hire_grant_senior_invalid", `Lane ${target.lane_id} has no senior lane in the primary hierarchy`, { lane_id: target.lane_id, senior_lane_id: parentId ?? null });
         }
-        for (const child of aliveDirectChildren(lanes, current.lane_id)) {
-            relevant.set(child.lane_id, child);
+        relevant.set(parent.lane_id, parent);
+        for (const sibling of aliveDirectChildren(lanes, parent.lane_id)) {
+            relevant.set(sibling.lane_id, sibling);
         }
     }
+    for (const child of aliveDirectChildren(lanes, current.lane_id)) {
+        relevant.set(child.lane_id, child);
+    }
     const hierarchy = [...relevant.values()]
         .map(snapshot)
         .sort((a, b) => a.lane_id.localeCompare(b.lane_id));
@@ -55,7 +53,7 @@ export function createOutpostHireGrantContext(target, lanes, enforcementEnabled)
     }
     const context = {
         schema_version: HIRE_GRANT_CONTEXT_SCHEMA,
-        enforcement_enabled: enforcementEnabled,
+        enforcement_enabled: true,
         expected_senior: copySenior(current.senior),
         hierarchy,
     };
@@ -150,7 +148,7 @@ export function parseOutpostHireGrantContext(encoded, targetLaneId) {
     if (!target || !sameSenior(target.senior, expectedSenior)) {
         throw contextError("Outpost grant context does not match the target's expected senior");
     }
-    if (record.enforcement_enabled && expectedSenior.kind === "lane" &&
+    if (expectedSenior.kind === "lane" &&
         (!expectedSenior.id || !byId.has(expectedSenior.id))) {
         throw contextError("Outpost grant context is missing the target's senior lane");
     }

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

@@ -3,8 +3,8 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
-export type { HireGrantBackfillRow } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
+export type { HireGrantBackfillRow } from "./grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } 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";

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" | "grant-target";
+    action: "message" | "resume" | "stop" | "show" | "grant" | "grant-target" | "reparent-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -40,6 +40,8 @@ export interface OutpostLaneCommand {
     keepAlive?: boolean;
     hire?: string;
     grantContext?: string;
+    senior?: string;
+    reason?: string;
     compact?: boolean;
 }
 export declare function buildOutpostQuestionAnswerCommand(input: {

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

@@ -150,6 +150,8 @@ export function buildOutpostLaneCommand(input) {
         ["--worker", input.worker],
         ["--hire", input.hire],
         ["--grant-context", input.grantContext],
+        ["--senior", input.senior],
+        ["--reason", input.reason],
     ]) {
         if (value !== undefined)
             args.push(flag, value);

package/dist/lib/lanes/reconcile.js

@@ -15,7 +15,7 @@ import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { loadWorkerProfile } from "./profile.js";
-import { LANE_HIRE_GRANTS_FLAG, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
+import { terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
@@ -807,7 +807,6 @@ export async function runPassBody(hqRoot, deps) {
     }
     const readRegistryFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
     const keepAliveFlagCompanies = new Map();
-    const keepAliveHireGrantFlagCompanies = new Map();
     for (const lane of lanes) {
         if (!(lane.state === "done" || lane.state === "interrupted" || lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") ||
             (lane.keep_alive !== true && lane.worker_profile === undefined) ||
@@ -824,30 +823,18 @@ export async function runPassBody(hqRoot, deps) {
         }
         const key = keepAliveCompanyKey(lane.company);
         keepAliveFlagCompanies.set(key, lane.company);
-        if (lane.senior.kind === "lane" && lane.senior.id) {
-            keepAliveHireGrantFlagCompanies.set(key, lane.company);
-        }
     }
     const keepAliveFlagByCompany = new Map();
-    const keepAliveHireGrantFlagByCompany = new Map();
     const env = deps.env ?? process.env;
-    await Promise.all([
-        ...[...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
-            keepAliveFlagByCompany.set(key, await readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
-                company: company ?? undefined,
-                env,
-            }));
-        }),
-        ...[...keepAliveHireGrantFlagCompanies.entries()].map(async ([key, company]) => {
-            keepAliveHireGrantFlagByCompany.set(key, await readRegistryFlag(LANE_HIRE_GRANTS_FLAG, {
-                company: company ?? undefined,
-                env,
-            }));
-        }),
-    ]);
+    await Promise.all([...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
+        keepAliveFlagByCompany.set(key, await readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
+            company: company ?? undefined,
+            env,
+        }));
+    }));
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
-        resumeKeepAlive(hqRoot, freshLanes, summary, deps, now, keepAliveFlagByCompany, keepAliveHireGrantFlagByCompany);
+        resumeKeepAlive(hqRoot, freshLanes, summary, deps, now, keepAliveFlagByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
@@ -1545,7 +1532,7 @@ function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
         throw new LanesError("keep_alive_envelope_timestamp_unavailable", `Cannot stat latest envelope for lane ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id, path: filePath });
     }
 }
-function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, hireGrantFlagByCompany) {
+function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -1882,8 +1869,7 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, hireG
         }), deps.dryRun);
         const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
         let queued;
-        if (seniorId &&
-            hireGrantFlagByCompany.get(keepAliveCompanyKey(current.company)) === true) {
+        if (seniorId) {
             try {
                 queued = withHireGrantAdmission(hqRoot, seniorId, (snapshot) => {
                     const latestLane = readLane(hqRoot, current.lane_id);

package/dist/lib/lanes/spawn.js

@@ -15,7 +15,7 @@ import { fileURLToPath } from "node:url";
 import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { buildHostCapacitySnapshot } from "./host-capacity.js";
-import { selectClaudeAccount } from "./claude-account-balance.js";
+import { selectClaudeAccount } from "./claude-balance.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";

package/package.json

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