@indigoai-us/hq-cli 5.345.44 → 5.345.46

package/dist/commands/lanes.js

@@ -37,7 +37,9 @@ import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
-import { LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
+import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
+import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
+import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -86,6 +88,133 @@ import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../l
 import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
+export function openPullRequestsForProject(hqRoot, metadata) {
+    const configured = metadata.repos;
+    if (!Array.isArray(configured)) {
+        throw new Error("project does not name repositories");
+    }
+    if (configured.length === 0)
+        return [];
+    const all = [];
+    const reposRoot = fs.realpathSync(path.resolve(hqRoot, "repos")) + path.sep;
+    for (const repo of configured) {
+        if (repo === null || typeof repo !== "object" || typeof repo.path !== "string") {
+            throw new Error("project repository entry is invalid");
+        }
+        const repoPath = repo.path;
+        if (!/^repos\/(private|public)\/[a-zA-Z0-9._/-]+$/.test(repoPath)) {
+            throw new Error("project repository path is outside repos");
+        }
+        if (repoPath.split("/").some((segment) => segment === "." || segment === "..")) {
+            throw new Error("project repository path is outside repos");
+        }
+        const repoDir = path.resolve(hqRoot, repoPath);
+        const canonicalRepoDir = fs.realpathSync(repoDir);
+        if (!canonicalRepoDir.startsWith(reposRoot))
+            throw new Error("project repository path is outside repos");
+        const remoteResult = spawnSync("git", ["-C", repoDir, "remote", "get-url", "origin"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        if (remoteResult.status !== 0)
+            throw new Error("project repository remote could not be read");
+        const remote = remoteResult.stdout.trim();
+        const match = remote.match(/^(?:https:\/\/github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?\/?$/i);
+        if (!match)
+            throw new Error("project repository is not a GitHub repository");
+        const endpoint = `repos/${match[1]}/${match[2]}/pulls?state=open&per_page=100`;
+        const result = spawnSync("gh", ["api", "--paginate", "--slurp", endpoint], {
+            encoding: "utf8",
+            timeout: 20_000,
+            windowsHide: true,
+        });
+        if (result.status !== 0)
+            throw new Error("GitHub pull request lookup failed");
+        const pages = JSON.parse(result.stdout || "[]");
+        if (!Array.isArray(pages))
+            throw new Error("GitHub pull request response was invalid");
+        for (const page of pages) {
+            if (!Array.isArray(page))
+                throw new Error("GitHub pull request page was invalid");
+            for (const item of page) {
+                if (item === null || typeof item !== "object")
+                    throw new Error("GitHub pull request entry was invalid");
+                const pr = item;
+                if (!Number.isInteger(pr.number) || typeof pr.created_at !== "string" || !Number.isFinite(Date.parse(pr.created_at))) {
+                    throw new Error("GitHub pull request entry was invalid");
+                }
+                all.push({ number: pr.number, created_at: pr.created_at, repository: `${match[1]}/${match[2]}` });
+            }
+        }
+    }
+    return all;
+}
+async function focusGuardAssessment(ctx, input) {
+    if (input.overrideReason !== undefined) {
+        const normalizedReason = input.overrideReason.trim();
+        if (!normalizedReason) {
+            throw new LanesError("focus_override_reason_required", "--focus-override requires a non-empty reason", {
+                story_ids: input.storyIds,
+            });
+        }
+        assertNoSecretText("focus override reason", normalizedReason);
+    }
+    let enabled = false;
+    try {
+        enabled = ctx.focusGuardEnabled
+            ? await ctx.focusGuardEnabled(input.company ?? undefined)
+            : await readLanesRegistryFlagFailOff(LANE_FOCUS_GUARD_FLAG, {
+                company: input.company,
+                env: ctx.env,
+            });
+    }
+    catch (error) {
+        process.stderr.write(`${JSON.stringify({
+            event: "lanes.focus_guard.flag_read_failed",
+            error: error instanceof Error ? error.name : "UnknownError",
+            fallback: false,
+        })}\n`);
+    }
+    if (!enabled)
+        return { enabled: false, reasons: [] };
+    const project = readProjectStoryFocusData(ctx.hqRoot(), input.projectId, input.company?.slug);
+    let pullRequests;
+    let pullRequestLookupFailed = false;
+    if (input.checkTeamBlockers) {
+        try {
+            pullRequests = openPullRequestsForProject(ctx.hqRoot(), project.metadata);
+        }
+        catch (error) {
+            pullRequestLookupFailed = true;
+            process.stderr.write(`${JSON.stringify({
+                event: "lanes.focus_guard.pr_lookup_failed",
+                project_id: input.projectId,
+                error: error instanceof Error ? error.name : "UnknownError",
+            })}\n`);
+        }
+    }
+    const tenantLanes = loadAllLanes(ctx.hqRoot()).filter((lane) => lane.company?.slug === input.company?.slug && (lane.project_id === input.projectId ||
+        lane.stories?.some((story) => story.project_id === input.projectId) === true));
+    const reasons = assertFocusGuardAllows(enabled, {
+        storyIds: input.storyIds,
+        stories: project.userStories.map((story) => ({
+            id: typeof story.id === "string" ? story.id : "",
+            focus_id: story.focus_id,
+            kpi: story.kpi,
+            state: story.state,
+            status: story.status,
+            lane: story.lane,
+            lanes: story.lanes,
+        })),
+        lanes: tenantLanes,
+        ...(pullRequests === undefined ? {} : { pullRequests }),
+        pullRequestLookupFailed,
+        now: ctx.now(),
+        checkTeamBlockers: input.checkTeamBlockers,
+    }, input.overrideReason);
+    return { enabled: true, reasons };
+}
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
@@ -329,6 +458,7 @@ function resolveDeps(deps = {}) {
         fetchText: deps.fetchText ?? defaultFetchText,
         lanePlacementEnabled: deps.lanePlacementEnabled ?? defaultLanePlacementEnabled,
         storyLedgerEnabled: deps.storyLedgerEnabled ?? laneStoryLedgerEnabled,
+        focusGuardEnabled: deps.focusGuardEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
         mergeReviewEnabled: deps.mergeReviewEnabled,
@@ -1726,11 +1856,13 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
             const companyMatches = !hostlessUlidLookup || ownerLookupGate === true || (ownerLookupGate === "check-company" &&
                 laneCompany !== undefined && laneCompany !== null &&
                 await options.allowHostlessOwnerLookup(laneCompany));
-            if (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
+            const exactOutpostOwnedMatch = !hostlessUlidLookup &&
+                lane.lane_id === laneId && lane.host.kind === "outpost" && lane.host.id === outpostId;
+            if (exactOutpostOwnedMatch || (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
                 sanitizeHostComponent(lane.host.id) === hostSuffix) ||
                 (hostlessUlidLookup && laneUlidPart(lane.lane_id) === requestedUlid &&
                     sanitizeHostComponent(lane.host.id) === recordedSuffix &&
-                    companyMatches))) {
+                    companyMatches)))) {
                 matches.push({ outpostId, lane });
             }
         }
@@ -1784,7 +1916,7 @@ function commandLaneNotFound(laneId, outpostHint, details = {}) {
     const hint = outpostHint
         ? "; pass --outpost <id> to confirm a registered Outpost"
         : "";
-    return new LanesError("lane_not_found", `Lane ${laneId} was not found locally or on a registered Outpost with a matching host suffix${hint}`, { lane_id: laneId, ...details });
+    return new LanesError("lane_not_found", `Could not resolve lane ${laneId}: no matching local record or reachable registered Outpost owner record was found${hint}`, { lane_id: laneId, ...details });
 }
 async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config, options = {}) {
     const localHost = laneHostFromCtx(ctx);
@@ -3033,6 +3165,12 @@ async function runCreate(ctx, opts) {
     if (opts.story !== undefined && opts.noStory !== undefined) {
         throw new LanesError("story_selection_conflict", "Pass either --story or --no-story, not both", {});
     }
+    if (opts.focusOverride !== undefined) {
+        if (!opts.focusOverride.trim()) {
+            throw new LanesError("focus_override_reason_required", "--focus-override requires a non-empty reason", {});
+        }
+        assertNoSecretText("focus override reason", opts.focusOverride.trim());
+    }
     if (opts.noStory !== undefined && !noStoryReason) {
         throw new LanesError("missing_no_story_reason", "--no-story requires a non-empty reason", {});
     }
@@ -3046,6 +3184,9 @@ async function runCreate(ctx, opts) {
         throw new LanesError("missing_story", "--additional-story values must be non-empty", {});
     }
     const storyIds = story ? [story, ...additionalStories] : [];
+    if (opts.focusOverride !== undefined && storyIds.length === 0) {
+        throw new LanesError("focus_override_story_required", "--focus-override requires --story", {});
+    }
     if (new Set(storyIds).size !== storyIds.length) {
         throw new LanesError("duplicate_story", "A lane cannot carry the same project/story more than once", {
             project_id: project,
@@ -3113,6 +3254,15 @@ async function runCreate(ctx, opts) {
     if (storyIds.length > 0 && ctx.storyLedgerEnabled()) {
         validateProjectStories(hqRoot, project, storyIds, company?.slug);
     }
+    const focusAssessment = storyIds.length > 0
+        ? await focusGuardAssessment(ctx, {
+            projectId: project,
+            storyIds,
+            company,
+            checkTeamBlockers: true,
+            overrideReason: opts.focusOverride,
+        })
+        : { enabled: false, reasons: [] };
     let meshCompany = company;
     if (meshCompanyFlag) {
         const resolvedMeshCompany = await ctx.resolveCompany(meshCompanyFlag);
@@ -3767,6 +3917,53 @@ async function runCreate(ctx, opts) {
     }
     let lane = persisted.lane;
     const { admission, validation } = persisted;
+    if (focusAssessment.enabled && opts.focusOverride !== undefined) {
+        const focusOverride = makeFocusOverride({
+            reason: opts.focusOverride,
+            laneId: lane.lane_id,
+            at: ctx.now().toISOString(),
+            storyId: story ?? "",
+        });
+        try {
+            appendProjectFocusOverride(hqRoot, project, company?.slug, focusOverride);
+            lane = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+                ...appendLaneFocusOverride(current, focusOverride),
+            }));
+        }
+        catch (error) {
+            try {
+                removeProjectFocusOverride(hqRoot, project, company?.slug, focusOverride);
+            }
+            catch (cleanupError) {
+                process.stderr.write(`${JSON.stringify({
+                    event: "lanes.focus_guard.override_rollback_failed",
+                    lane_id: lane.lane_id,
+                    error: cleanupError instanceof Error ? cleanupError.name : "UnknownError",
+                })}\n`);
+            }
+            try {
+                casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+                    ...current,
+                    state: "failed",
+                    queued_reason: undefined,
+                    queued_details: undefined,
+                    admission_reserved_at: undefined,
+                    terminal_reason: "focus_override_persist_failed",
+                }));
+            }
+            catch (markError) {
+                process.stderr.write(`${JSON.stringify({
+                    event: "lanes.focus_guard.lane_fail_mark_failed",
+                    lane_id: lane.lane_id,
+                    error: markError instanceof Error ? markError.name : "UnknownError",
+                })}\n`);
+            }
+            throw new LanesError("focus_override_persist_failed", "Could not persist the focus override; lane launch was refused", {
+                lane_id: lane.lane_id,
+                error: error instanceof Error ? error.name : "UnknownError",
+            });
+        }
+    }
     if (meshCompany) {
         try {
             lane = await ensureLaneThreadRecord(ctx, lane);
@@ -4521,6 +4718,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                 text: options.text,
                 project: options.project,
                 story: options.story,
+                focusOverride: options.focusOverride,
                 account: options.account,
                 model: options.model,
                 effort: options.effort,
@@ -4735,7 +4933,9 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
         if (action === "reparent") {
             for (const descendantId of changedDescendantIds) {
                 const ownerDescendant = await readOutpostLaneSnapshot(ctx, outpostId, descendantId);
-                descendants.push(syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
+                descendants.push(behavior.syncPrimary === false
+                    ? dispatchedOwnerLane(ctx, descendantId, outpostId, ownerDescendant, behavior)
+                    : syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
             }
         }
         const questionCancellation = action === "resume" && lane.state === "awaiting_input" && behavior.afterFallbackResume
@@ -5964,8 +6164,15 @@ async function printGrantResult(ctx, hqRoot, updated, hierarchy) {
  * next `set` or an explicit resume `--effort`/`--worker`.
  */
 async function runSet(ctx, laneId, opts) {
+    if (opts.company !== undefined) {
+        if (opts.model !== undefined || opts.effort !== undefined || opts.reason !== undefined) {
+            throw new LanesError("lane_set_company_exclusive", "--company cannot be combined with --model, --effort, or --reason", { lane_id: laneId });
+        }
+        await runRepairCompany(ctx, laneId, { company: opts.company });
+        return;
+    }
     if (opts.model === undefined && opts.effort === undefined) {
-        throw new LanesError("lane_set_empty", "hq lanes set needs --model or --effort", { lane_id: laneId });
+        throw new LanesError("lane_set_empty", "hq lanes set needs --company, --model, or --effort", { lane_id: laneId });
     }
     const reason = opts.reason?.trim();
     if (opts.reason !== undefined && !reason) {
@@ -7312,11 +7519,21 @@ 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);
+    const target = await resolveCommandLaneTarget(ctx, laneId);
+    const initial = target.lane;
+    if (target.remoteOnly) {
+        await dispatchOutpostLaneCommand(ctx, initial, "reparent", {
+            senior: opts.senior,
+            reason: opts.reason,
+        }, {
+            syncPrimary: false,
+            expectedOwnerHost: target.ownerHost,
+        });
+        return;
+    }
     if (initial.host.kind === "outpost" && !laneRunsHere(initial, reconcileHostFromCtx(ctx))) {
         await dispatchOutpostLaneCommand(ctx, initial, "reparent", {
             senior: opts.senior,
@@ -7324,7 +7541,7 @@ async function runReparent(ctx, laneId, opts) {
         });
         return;
     }
-    const result = await reparentOnOwner(ctx, laneId, opts);
+    const result = await reparentOnOwner(ctx, initial.lane_id, opts);
     printJson({
         ok: true,
         action: "reparent",
@@ -7579,7 +7796,7 @@ async function repairCompanyOnOwner(ctx, laneId, opts, emitResult = true) {
         if (current.company !== null) {
             if (sameLaneCompany(current.company, company))
                 return current;
-            throw new LanesError("lane_company_already_set", `Lane ${laneId} already belongs to ${current.company.slug}; company repair only fills missing attribution`, { lane_id: laneId, company: current.company.slug, requested_company: company.slug });
+            throw new LanesError("lane_company_already_set", `Cannot set lane ${laneId} to ${company.slug}: it already belongs to ${current.company.slug}`, { lane_id: laneId, company: current.company.slug, requested_company: company.slug });
         }
         return {
             ...current,
@@ -7935,7 +8152,7 @@ async function dispatchPrimaryLaneMessage(ctx, laneId, options) {
         printJson(response);
     return response;
 }
-async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
+async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false, behavior = {}) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch stop to`, { lane_id: lane.lane_id });
     }
@@ -7967,6 +8184,14 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
     const commandId = dispatched.commandId?.trim();
     const ownerError = ownerErrorFromOutput(dispatched.stdout);
     if (isDefiniteOutpostLaneNotFound(dispatched, lane.lane_id, ownerError)) {
+        if (behavior.syncPrimary === false) {
+            throw new LanesError("lane_not_found", ownerError.message, {
+                ...ownerError.details,
+                lane_id: lane.lane_id,
+                outpost_id: outpostId,
+                command_id: commandId,
+            });
+        }
         const at = ctx.now().toISOString();
         const updated = markRemoteLaneLost(ctx.hqRoot(), lane.lane_id, outpostId, at, "command", reason);
         if (updated.terminal_reason !== "remote_lost") {
@@ -8081,7 +8306,9 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
         state = ownerLane.state;
         cancelledQuestions = parseRemoteCancelledQuestionIds(remote.cancelled_questions, lane.lane_id, outpostId, commandId);
     }
-    const updated = syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, ownerLane);
+    const updated = behavior.syncPrimary === false
+        ? ownerLane
+        : syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, ownerLane);
     if (!quiet)
         printJson({
             ok: true,
@@ -8109,9 +8336,14 @@ async function runStop(ctx, laneId, reason, quiet = false) {
     if (operatorReason !== undefined)
         assertNoSecretText("stop reason", operatorReason);
     const hqRoot = ctx.hqRoot();
-    const lane = readLane(hqRoot, laneId);
+    const target = await resolveCommandLaneTarget(ctx, laneId);
+    const lane = target.lane;
     if (!quiet && lane.state !== "queued" && !isTerminalLaneState(lane.state)) {
-        process.stderr.write(stopTerminalWarning(laneId));
+        process.stderr.write(stopTerminalWarning(lane.lane_id));
+    }
+    if (target.remoteOnly) {
+        await dispatchOutpostLaneStop(ctx, lane, operatorReason, quiet, { syncPrimary: false });
+        return;
     }
     if (lane.host.kind === "outpost" && !laneRunsHereForOperatorMutation(ctx, lane)) {
         await dispatchOutpostLaneStop(ctx, lane, operatorReason, quiet);
@@ -8885,6 +9117,7 @@ export function registerLanesCommand(parent, deps = {}) {
         casUpdateLane,
         dispatchOutpostLaneCommand,
         dispatchPrimaryLaneMessage,
+        focusGuardAssessment,
         drainHookStatusFor,
         laneIsHostedHere,
         laneWithRecoveredProviderSession,
@@ -8916,6 +9149,7 @@ export function registerLanesCommand(parent, deps = {}) {
         automaticBalanceMoveHistoryReason,
         authorizeFailedResume,
         authorizeResumeProfileRepin,
+        focusGuardAssessment,
         casUpdateLane,
         dispatchOutpostLaneCommand: async (commandCtx, lane, action, options, behavior) => {
             await dispatchOutpostLaneCommand(commandCtx, lane, action, options, behavior);
@@ -9031,6 +9265,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--mesh-company <slug|uid>", "Explicit Work Mesh company for a personal lane; membership is verified")
         .requiredOption("--project <slug>", "HQ project slug")
         .option("--story <id>", "Story id from the project's prd.json")
+        .option("--focus-override <reason>", "Human-approved reason to override the lane focus guard")
         .addOption(noStoryOption)
         .option("--additional-story <id>", "Additional story carried by this lane; repeatable and discouraged when active", collectRepeatable)
         .requiredOption("--brief-file <path>", "Path to the lane brief")
@@ -9093,8 +9328,9 @@ export function registerLanesCommand(parent, deps = {}) {
     }));
     lanes
         .command("set")
-        .description("Change the model or effort a lane uses from its next resume")
+        .description("Change lane settings or bind its missing company attribution")
         .argument("<lane-id>", "Lane id")
+        .option("--company <slug>", "Bind missing company attribution to this lane")
         .option("--model <model>", "Model for the lane's next and later turns")
         .option("--effort <level>", "Effort for the lane's next and later turns")
         .option("--reason <text>", "Why the settings changed; recorded in settings_history")
@@ -9305,6 +9541,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--text-file <path>", "Read message text from a file")
         .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
         .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
+        .option("--focus-override <reason>", "Human-approved reason to override the lane focus guard")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")
@@ -9361,6 +9598,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--reason <text>", "Required explanation for resuming from failed")
         .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
         .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
+        .option("--focus-override <reason>", "Human-approved reason to override the lane focus guard")
         .option("--account <id>", "Move the lane's session to this account of its provider before resuming")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")

package/dist/commands/meetings.js

@@ -520,7 +520,10 @@ export function registerMeetingsCommand(program) {
             }
             const token = await ensureCognitoToken();
             const companyId = await getCompanyUid(token, companySlug);
-            const recorderPersonUid = await resolveCallerPersonUid(token);
+            // The import endpoint records a person as the recorder (prs_* only).
+            const recorderPersonUid = await resolveCallerPersonUid(token, undefined, {
+                command: "hq meetings import",
+            });
             const res = await vaultApiFetch({
                 token,
                 method: "POST",

package/dist/lib/anywhere-person-setting.d.ts

@@ -10,6 +10,17 @@ export interface ReadHqAnywherePersonSettingOptions {
 }
 /** Returns null when the person preference cannot be read; callers must fail closed. */
 export declare function readHqAnywherePersonSetting(options?: ReadHqAnywherePersonSettingOptions): Promise<boolean | null>;
+/**
+ * Wrap a setting reader so a failed read (null) returns the last successfully
+ * read value for `graceMs`. A long-running caller such as hqd re-reads every
+ * minute, and one slow request would otherwise switch HQ Anywhere off for
+ * every session. A newly read value, including off, always applies at once;
+ * with no successful read inside the window the result stays null (closed).
+ */
+export declare function stickyPersonSettingReader(read: () => Promise<boolean | null>, options: {
+    graceMs: number;
+    now?: () => number;
+}): () => Promise<boolean | null>;
 export declare function evaluateAnywhereRuntime(flagEnabled: boolean, setting: boolean | null): {
     enabled: boolean;
     setting: boolean | null;

package/dist/lib/anywhere-person-setting.js

@@ -28,6 +28,25 @@ export async function readHqAnywherePersonSetting(options = {}) {
         return null;
     }
 }
+/**
+ * Wrap a setting reader so a failed read (null) returns the last successfully
+ * read value for `graceMs`. A long-running caller such as hqd re-reads every
+ * minute, and one slow request would otherwise switch HQ Anywhere off for
+ * every session. A newly read value, including off, always applies at once;
+ * with no successful read inside the window the result stays null (closed).
+ */
+export function stickyPersonSettingReader(read, options) {
+    const now = options.now ?? Date.now;
+    let last = null;
+    return async () => {
+        const value = await read();
+        if (value !== null) {
+            last = { value, at: now() };
+            return value;
+        }
+        return last && now() - last.at <= options.graceMs ? last.value : null;
+    };
+}
 export function evaluateAnywhereRuntime(flagEnabled, setting) {
     return { enabled: flagEnabled && setting === true, setting };
 }

package/dist/lib/daemon/ops/mcp.d.ts

@@ -13,7 +13,16 @@ export interface McpToolResult {
 }
 export declare function jsonResult(value: unknown): McpToolResult;
 export declare function resolveHqMcpEndpoint(env?: NodeJS.ProcessEnv): URL;
-export declare function defaultMcpToken(): Promise<string>;
+/** Test seams for {@link defaultMcpToken}. */
+export interface McpTokenDeps {
+    tokenSource?: () => string;
+    mcpAudienceToken?: () => Promise<string>;
+    cognitoToken?: (options: {
+        tokenSource: "person" | "machine";
+        interactive: false;
+    }) => Promise<string>;
+}
+export declare function defaultMcpToken(deps?: McpTokenDeps): Promise<string>;
 export interface HqMcpBridgeOptions {
     endpoint?: URL;
     env?: NodeJS.ProcessEnv;

package/dist/lib/daemon/ops/mcp.js

@@ -27,24 +27,31 @@ export function resolveHqMcpEndpoint(env = process.env) {
         throw error;
     }
 }
-export async function defaultMcpToken() {
-    const { ensureCognitoToken, resolveCognitoTokenSource } = await import("../../../utils/cognito-session.js");
-    if (resolveCognitoTokenSource() !== "machine") {
-        const { getMcpAudienceToken, McpOAuthError } = await import("../mcp-oauth.js");
+export async function defaultMcpToken(deps = {}) {
+    const session = deps.tokenSource && deps.cognitoToken ? null : await import("../../../utils/cognito-session.js");
+    const tokenSource = deps.tokenSource ?? session.resolveCognitoTokenSource;
+    const cognitoToken = deps.cognitoToken ?? ((options) => session.ensureCognitoToken(options));
+    if (tokenSource() !== "machine") {
+        const mcpAudienceToken = deps.mcpAudienceToken ?? (async () => (await import("../mcp-oauth.js")).getMcpAudienceToken());
         try {
-            return await getMcpAudienceToken();
+            return await mcpAudienceToken();
         }
-        catch (error) {
-            if (error instanceof McpOAuthError)
-                throw new McpOpError(error.code, error.message);
-            throw new McpOpError("hq_mcp_auth_required", "Hosted MCP sign-in is required. Run `hq mcp login` and retry.");
+        catch {
+            // No `hq mcp login`: hosted hq-mcp also accepts the HQ sign-in client,
+            // so reuse the session hq-cli and the desktop app already hold.
+        }
+        try {
+            return await cognitoToken({ tokenSource: "person", interactive: false });
+        }
+        catch {
+            throw new McpOpError("hq_mcp_auth_required", "Sign in to HQ with `hq login`, then retry.");
         }
     }
     try {
         // Send this box's existing machine token. The hosted hq-mcp audience check
         // accepts it only when it was issued for hqMcpMachineClient; otherwise the
         // server rejects it. This helper does not inspect the credential's client ID.
-        return await ensureCognitoToken({ tokenSource: "machine", interactive: false });
+        return await cognitoToken({ tokenSource: "machine", interactive: false });
     }
     catch {
         throw new McpOpError("hq_mcp_auth_required", "An hq-mcp machine token is unavailable. Configure this box with hq-pro's hqMcpMachineClient ID, then retry the daemon call.");

package/dist/lib/daemon/run.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { CLI_VERSION } from "../../cli-version.js";
 import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
-import { anywhereRuntimeAllowed } from "../anywhere-person-setting.js";
+import { anywhereRuntimeAllowed, readHqAnywherePersonSetting, stickyPersonSettingReader } from "../anywhere-person-setting.js";
 import { currentPackageUseLeaseInstall, currentPackageUseUpdateRequested } from "../../utils/package-use-lease.js";
 import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/version-gate.js";
 import { agentKitPaths } from "../agent-kit/paths.js";
@@ -77,6 +77,8 @@ export function handoffForPackageUpdateRequest(requested, restartDaemon) {
 const LEGACY_PROBE_TTL_MS = 60_000;
 /** A flag read that has not answered by then counts as off. */
 const HANDOFF_FLAG_TIMEOUT_MS = 10_000;
+/** How long hqd keeps the last read HQ Anywhere setting when a re-read fails. */
+const HQD_PERSON_SETTING_GRACE_MS = 30 * 60_000;
 export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null, staged = { version: null }, currentSyncRunnerSource = null) {
     // A managed copy lives in the daemon directory, so it survives a CLI
     // replacement. Before lease release pickHqCloud returns it only when it is
@@ -838,13 +840,17 @@ export async function runDaemon(opts) {
     // hqd: the session/company socket every runtime talks to (hq-anywhere US-008).
     let hqdShutdown = null;
     let stopHeartbeat = () => { };
+    const readPersonSetting = stickyPersonSettingReader(() => readHqAnywherePersonSetting({
+        env,
+        onError: (name) => log("warn", `hqd person setting read failed (${name}); keeping the last read value for up to ${HQD_PERSON_SETTING_GRACE_MS / 60_000} minutes`),
+    }), { graceMs: HQD_PERSON_SETTING_GRACE_MS });
     const hqdListener = await startHqdRuntimeListener({
         isEnabled: async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
             refreshFlag: async () => {
                 const { refreshFlagRegistrySnapshot } = await import("../flag-registry.js");
                 await refreshFlagRegistrySnapshot(5_000);
             },
-            onError: (name) => log("warn", `hqd person setting read failed (${name}); runtime remains off`),
+            readSetting: readPersonSetting,
         })),
         startServer: async () => {
             const startConfig = readDaemonConfig(paths.configPath);

package/dist/lib/doctor/checks/sync-runtime.d.ts

@@ -1,5 +1,7 @@
 import type { CheckResult } from "../types.js";
 export declare const SYNC_RUNTIME_WINDOW_MS: number;
+/** Ignore timing and restart signals until a newly started receiver has settled. */
+export declare const SYNC_RUNTIME_RESTART_WARMUP_MS: number;
 export interface SyncRuntimeOptions {
     now: number;
     conflictCount?: number;