@indigoai-us/hq-cli 5.228.0 → 5.228.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.228.2] — 2026-09-27
+
+## [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

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: "";

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": "",

package/dist/commands/lanes.js

@@ -1668,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", {
@@ -3617,9 +3621,15 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         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,
@@ -3629,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,
             }),
@@ -3682,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 &&
@@ -3690,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,
@@ -3712,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,
@@ -3719,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 });
@@ -4717,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" &&
@@ -6913,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", {});
@@ -6925,7 +7050,25 @@ async function runReparent(ctx, laneId, opts) {
         ...(initial.senior.kind === "lane" && initial.senior.id ? [initial.senior.id] : []),
         ...(nextSenior.kind === "lane" && nextSenior.id ? [nextSenior.id] : []),
     ];
-    withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts));
+    return withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts));
+}
+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();
@@ -6996,7 +7139,11 @@ function runReparentLocked(ctx, laneId, opts) {
                 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) => {
@@ -7041,12 +7188,13 @@ function runReparentLocked(ctx, laneId, opts) {
             };
         });
     }
-    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",
@@ -8979,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")

package/dist/lib/flag-registry-worker-mode-cache.d.ts

@@ -3,6 +3,13 @@ interface CachedWorkerMode {
     version: number;
     value: boolean;
 }
+export type FlagRegistryWorkerModeCacheOperation = "read" | "write";
+export type FlagRegistryWorkerModeCacheStep = "mkdir" | "write_temp" | "link" | "unlink" | "prune" | "readdir" | "read";
+/** Build bounded filesystem diagnostics without exposing the state directory. */
+export declare function flagRegistryWorkerModeCacheFailureContext(error: unknown, operation: FlagRegistryWorkerModeCacheOperation, filePath: string, env?: NodeJS.ProcessEnv): {
+    exception: unknown;
+    tags: Record<string, string>;
+};
 /** Keep the last server snapshot decision for this one startup-mode flag. */
 export declare function flagRegistryWorkerModeCachePath(stateDir: string, scopeIdentifiers: readonly string[]): string;
 /** A missing, invalid, or inaccessible cache never enables the rollout. */

package/dist/lib/flag-registry-worker-mode-cache.js

@@ -1,8 +1,116 @@
+import { execFileSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 export const FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG = "cli.flag-worker-self-contained";
+class FlagRegistryWorkerModeCacheStepError extends Error {
+    cacheStep;
+    originalError;
+    constructor(cacheStep, originalError) {
+        super(`Flag registry worker-mode cache failed at ${cacheStep}`);
+        this.cacheStep = cacheStep;
+        this.originalError = originalError;
+        this.name = "FlagRegistryWorkerModeCacheStepError";
+    }
+}
+const KNOWN_ERRNOS = new Set([
+    "EACCES",
+    "EBUSY",
+    "EEXIST",
+    "EIO",
+    "EISDIR",
+    "EMFILE",
+    "ENFILE",
+    "ENOENT",
+    "ENOSPC",
+    "ENOTDIR",
+    "EPERM",
+    "EROFS",
+]);
+function withCacheFsStep(cacheStep, operation) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        if (error instanceof FlagRegistryWorkerModeCacheStepError)
+            throw error;
+        throw new FlagRegistryWorkerModeCacheStepError(cacheStep, error);
+    }
+}
+function originalCacheError(error) {
+    return error instanceof FlagRegistryWorkerModeCacheStepError
+        ? error.originalError
+        : error;
+}
+function cacheErrorCode(error) {
+    const original = originalCacheError(error);
+    return typeof original === "object" && original !== null && "code" in original
+        ? original.code
+        : undefined;
+}
+function directoryHasUchg(directory) {
+    if (process.platform !== "darwin")
+        return "unknown";
+    try {
+        const rawFlags = execFileSync("/usr/bin/stat", ["-f", "%f", directory], { timeout: 1000 }).toString("utf8").trim();
+        if (!/^\d+$/.test(rawFlags))
+            return "unknown";
+        const flags = Number(rawFlags);
+        if (!Number.isSafeInteger(flags))
+            return "unknown";
+        return String((flags & 0x00000002) !== 0 || (flags & 0x00020000) !== 0);
+    }
+    catch {
+        // This bounded diagnostic is best-effort; preserve unknown and the original cache error.
+        return "unknown";
+    }
+}
+/** Build bounded filesystem diagnostics without exposing the state directory. */
+export function flagRegistryWorkerModeCacheFailureContext(error, operation, filePath, env = process.env) {
+    const cacheError = error instanceof FlagRegistryWorkerModeCacheStepError
+        ? error
+        : undefined;
+    const directory = path.dirname(filePath);
+    let dirExists = "unknown";
+    let stats;
+    try {
+        stats = fs.statSync(directory);
+        dirExists = "true";
+    }
+    catch (metadataError) {
+        if (cacheErrorCode(metadataError) === "ENOENT")
+            dirExists = "false";
+        // Keep inaccessible metadata unknown; diagnostics must not hide the cache error.
+    }
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    const ownerMatches = typeof uid === "number" && typeof stats?.uid === "number"
+        ? String(stats.uid === uid)
+        : "unknown";
+    const dirMode = typeof stats?.mode === "number"
+        ? (stats.mode & 0o777).toString(8).padStart(3, "0")
+        : "unknown";
+    const dirHasUchg = directoryHasUchg(directory);
+    const rawErrno = cacheErrorCode(error);
+    const errno = typeof rawErrno === "string" && KNOWN_ERRNOS.has(rawErrno)
+        ? rawErrno
+        : "UNKNOWN";
+    const stateDirSource = env.HQ_STATE_DIR?.trim() ? "env" : "home";
+    return {
+        exception: originalCacheError(error),
+        tags: {
+            cache_op: operation,
+            cache_step: cacheError?.cacheStep ?? (operation === "read" ? "read" : "write_temp"),
+            errno,
+            state_dir_source: stateDirSource,
+            dir_exists: dirExists,
+            dir_owner_matches_uid: ownerMatches,
+            dir_mode: dirMode,
+            dir_has_uchg: dirHasUchg,
+            cache_path_kind: "<stateDir>/flags/<basename>",
+        },
+    };
+}
 /** Keep the last server snapshot decision for this one startup-mode flag. */
 export function flagRegistryWorkerModeCachePath(stateDir, scopeIdentifiers) {
     const basename = scopeIdentifiers.length === 0
@@ -17,11 +125,11 @@ export function flagRegistryWorkerModeCachePath(stateDir, scopeIdentifiers) {
 export function readCachedFlagRegistryWorkerMode(filePath) {
     let latest = readCacheRecordIfPresent(filePath);
     const directory = path.dirname(filePath);
-    if (!fs.existsSync(directory))
+    if (!withCacheFsStep("read", () => fs.existsSync(directory)))
         return latest;
     const basename = path.basename(filePath);
     const versionedPrefix = `${basename}.v`;
-    for (const entry of fs.readdirSync(directory)) {
+    for (const entry of withCacheFsStep("readdir", () => fs.readdirSync(directory))) {
         if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
             continue;
         const versionedPath = path.join(directory, entry);
@@ -32,7 +140,7 @@ export function readCachedFlagRegistryWorkerMode(filePath) {
     return latest;
 }
 export function writeCachedFlagRegistryWorkerMode(filePath, snapshot) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    withCacheFsStep("mkdir", () => fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 }));
     const existing = readCachedFlagRegistryWorkerMode(filePath);
     if (existing && snapshot.version < existing.version)
         return;
@@ -42,26 +150,27 @@ export function writeCachedFlagRegistryWorkerMode(filePath, snapshot) {
     const versionedPath = `${filePath}.v${snapshot.version}.json`;
     const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
     try {
-        fs.writeFileSync(tempPath, `${JSON.stringify(snapshot)}\n`, {
+        withCacheFsStep("write_temp", () => fs.writeFileSync(tempPath, `${JSON.stringify(snapshot)}\n`, {
             encoding: "utf8",
             mode: 0o600,
             flag: "wx",
-        });
+        }));
         try {
-            fs.linkSync(tempPath, versionedPath);
+            withCacheFsStep("link", () => fs.linkSync(tempPath, versionedPath));
         }
         catch (error) {
             if (!isAlreadyExistsError(error))
                 throw error;
             const existingVersion = readCacheRecord(versionedPath);
             if (existingVersion.value !== snapshot.value) {
-                throw new Error("Conflicting flag-registry worker cache values share a version");
+                throw new FlagRegistryWorkerModeCacheStepError("link", new Error("Conflicting flag-registry worker cache values share a version"));
             }
         }
     }
     finally {
-        if (fs.existsSync(tempPath))
-            fs.unlinkSync(tempPath);
+        if (withCacheFsStep("unlink", () => fs.existsSync(tempPath))) {
+            withCacheFsStep("unlink", () => fs.unlinkSync(tempPath));
+        }
     }
     pruneOlderCacheRecords(filePath);
 }
@@ -76,7 +185,8 @@ function isCachedWorkerMode(value) {
         "value" in value && typeof value.value === "boolean";
 }
 function readCacheRecord(filePath) {
-    const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    const contents = withCacheFsStep("read", () => fs.readFileSync(filePath, "utf8"));
+    const value = JSON.parse(contents);
     if (!isCachedWorkerMode(value)) {
         throw new Error("Cached flag-registry worker mode has an invalid shape");
     }
@@ -97,14 +207,14 @@ function pruneOlderCacheRecords(filePath) {
     const directory = path.dirname(filePath);
     const basename = path.basename(filePath);
     const versionedPrefix = `${basename}.v`;
-    for (const entry of fs.readdirSync(directory)) {
+    for (const entry of withCacheFsStep("readdir", () => fs.readdirSync(directory))) {
         if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
             continue;
         const recordPath = path.join(directory, entry);
         const record = readCacheRecordIfPresent(recordPath);
         if (record && record.version < latest.version) {
             try {
-                fs.unlinkSync(recordPath);
+                withCacheFsStep("prune", () => fs.unlinkSync(recordPath));
             }
             catch (error) {
                 if (!isNotFoundError(error))
@@ -112,11 +222,11 @@ function pruneOlderCacheRecords(filePath) {
             }
         }
     }
-    if (fs.existsSync(filePath)) {
+    if (withCacheFsStep("prune", () => fs.existsSync(filePath))) {
         const legacyRecord = readCacheRecordIfPresent(filePath);
         if (legacyRecord && legacyRecord.version < latest.version) {
             try {
-                fs.unlinkSync(filePath);
+                withCacheFsStep("prune", () => fs.unlinkSync(filePath));
             }
             catch (error) {
                 if (!isNotFoundError(error))
@@ -136,11 +246,9 @@ function readCacheRecordIfPresent(filePath) {
     }
 }
 function isAlreadyExistsError(error) {
-    return typeof error === "object" && error !== null &&
-        "code" in error && error.code === "EEXIST";
+    return cacheErrorCode(error) === "EEXIST";
 }
 function isNotFoundError(error) {
-    return typeof error === "object" && error !== null &&
-        "code" in error && error.code === "ENOENT";
+    return cacheErrorCode(error) === "ENOENT";
 }
 //# sourceMappingURL=flag-registry-worker-mode-cache.js.map

package/dist/lib/flag-registry.js

@@ -14,7 +14,7 @@ import { workContextRoot } from "./work-context/paths.js";
 import { readCompaniesManifestMap } from "./work-context/repo-remote.js";
 import { loadCachedTokens, resolveDefaultHqRoot } from "../utils/cognito-session.js";
 import { resolveFlagRegistryEndpoint, } from "./flag-registry-endpoint.js";
-import { FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG, flagRegistryStateDir, flagRegistryWorkerModeCachePath, readCachedFlagRegistryWorkerMode, writeCachedFlagRegistryWorkerMode, } from "./flag-registry-worker-mode-cache.js";
+import { FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG, flagRegistryWorkerModeCacheFailureContext, flagRegistryStateDir, flagRegistryWorkerModeCachePath, readCachedFlagRegistryWorkerMode, writeCachedFlagRegistryWorkerMode, } from "./flag-registry-worker-mode-cache.js";
 import { FLAG_REGISTRY_WORKER_SOURCE } from "./flag-registry-worker-source.generated.js";
 export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
@@ -140,8 +140,13 @@ function selfContainedWorkerEnabled(company) {
         return readCachedFlagRegistryWorkerMode(filePath)?.value ?? false;
     }
     catch (error) {
-        Sentry.captureException(error, {
-            tags: { component: "flag-registry-worker-mode-cache", worker: "flag-registry" },
+        const failure = flagRegistryWorkerModeCacheFailureContext(error, "read", filePath);
+        Sentry.captureException(failure.exception, {
+            tags: {
+                component: "flag-registry-worker-mode-cache",
+                worker: "flag-registry",
+                ...failure.tags,
+            },
         });
         return false;
     }
@@ -165,8 +170,14 @@ function cacheWorkerModeFromSnapshot(snapshot, company) {
         writeCachedFlagRegistryWorkerMode(flagRegistryWorkerModeCachePath(flagRegistryStateDir(), scopes), { version: snapshot.version, value: decision.value });
     }
     catch (error) {
-        Sentry.captureException(error, {
-            tags: { component: "flag-registry-worker-mode-cache", worker: "flag-registry" },
+        const filePath = flagRegistryWorkerModeCachePath(flagRegistryStateDir(), scopes);
+        const failure = flagRegistryWorkerModeCacheFailureContext(error, "write", filePath);
+        Sentry.captureException(failure.exception, {
+            tags: {
+                component: "flag-registry-worker-mode-cache",
+                worker: "flag-registry",
+                ...failure.tags,
+            },
         });
     }
 }

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/package.json

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