@indigoai-us/hq-cli 5.345.42 → 5.345.44

package/dist/lib/lanes/flag-keys.js

@@ -1,5 +1,8 @@
 /** hq-flags keys used by lane command behavior. */
+export const LANE_FOCUS_DASHBOARD_FLAG = "lanes-focus-dashboard";
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Enables same-provider automatic lane recovery after provider quota exhaustion. */
+export const LANE_QUOTA_ACCOUNT_FAILOVER_FLAG = "lanes.quota-account-failover";
 /** Gives live senior lanes Claude admission precedence and reserves host capacity for them. */
 export const LANE_LEAD_ADMISSION_PRIORITY_FLAG = "lanes.lead-admission-priority";
 /** Refresh provider/model/effort from a worker profile when a done lane takes a new story. */
@@ -24,4 +27,6 @@ export const LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG = "lanes.autopilot-headline-
 export const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot-outpost-native-leads";
 /** Allows applying an operator-reviewed repair of messages stranded in bare-ULID dropboxes. */
 export const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
+/** Allows a Claude lane to leave an exhausted profile account pin for an eligible account. */
+export const LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG = "lanes.profile-pin-exhausted-fallback";
 //# sourceMappingURL=flag-keys.js.map

package/dist/lib/lanes/grants.js

@@ -28,7 +28,7 @@ export function terminalChildResumeHireGrantError(current, snapshot, finishedChi
     }
     if (children.length >= parentGrant)
         return hireGrantCapacityError(parent, children);
-    const requestedGrant = current.hire_grant ?? 0;
+    const requestedGrant = current.released_hire_grant ?? current.hire_grant ?? 0;
     if (requestedGrant > availableChildGrant) {
         return new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but ${terminal ? "terminal" : "finished"} child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
             senior_lane_id: parent.lane_id,

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

@@ -35,6 +35,8 @@ export interface ReconcileChange {
     from?: string;
     to?: string;
     reason?: string;
+    account?: string;
+    quota_reset_at?: string;
     /** The attempted provider PATH when admission found no executable. */
     searched_path?: string;
 }

package/dist/lib/lanes/reconcile.js

@@ -23,7 +23,7 @@ import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecor
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "./registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, } from "./flag-keys.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, } from "./flag-keys.js";
 import { checkLaneDiskSpace, configuredCodexRolloutHomes, laneDiskAccount, retainCodexRollouts } from "./disk-guard.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.js";
@@ -66,6 +66,43 @@ function spawnDepsForHost(deps) {
         admissionHost: deps.host,
     };
 }
+async function resumeDueQuotaHeldLanes(hqRoot, lanes, summary, deps, now) {
+    const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    for (const lane of lanes) {
+        const resetAt = typeof lane.quota_reset_at === "string" ? Date.parse(lane.quota_reset_at) : NaN;
+        if (lane.state !== "interrupted" ||
+            !["quota_held", "account_quota_exhausted", "account_model_unavailable"].includes(lane.terminal_reason ?? "") ||
+            !Number.isFinite(resetAt) || resetAt > now.getTime() || !laneRunsHere(lane, deps.host))
+            continue;
+        try {
+            const company = resolveLaneCompany(hqRoot, lane);
+            const enabled = await readLanesRegistryFlagFailOff(LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, {
+                company: company.company,
+                companyUidSource: laneCompanyUidSource(company.source),
+                env: deps.env,
+            }, readFlag);
+            if (!enabled)
+                continue;
+            const recovered = await retryLaneOnAlternateAccount(hqRoot, lane, "usage_limit", "reconcile", { ...spawnDepsForHost(deps), now: () => now, quotaAccountFailoverEnabled: true, dryRun: deps.dryRun });
+            summary.resumed.push({
+                id: lane.lane_id,
+                from: "interrupted",
+                to: recovered.state,
+                account: recovered.account,
+                reason: recovered.terminal_reason === "quota_held" ? "quota_held" : "quota_reset",
+                ...(recovered.quota_reset_at ? { quota_reset_at: recovered.quota_reset_at } : {}),
+            });
+            if (!deps.dryRun)
+                summary.heartbeats.push(`${lane.lane_id}:quota-account-retry`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            summary.errors.push({ message: `${lane.lane_id}: quota retry failed: ${message}` });
+            summary.ok = false;
+            process.stderr.write(`hq lanes reconcile: quota retry failed for ${lane.lane_id}: ${message}\n`);
+        }
+    }
+}
 function logSkip(skip) {
     process.stderr.write(`hq lanes reconcile: skipped ${skip.kind}${skip.id ? ` ${skip.id}` : ""}: ${skip.why}\n`);
 }
@@ -940,6 +977,7 @@ export async function runPassBody(hqRoot, deps) {
     if (deps.terminalKeepAliveCandidate) {
         return runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, deps.terminalKeepAliveCandidate);
     }
+    await resumeDueQuotaHeldLanes(hqRoot, lanes, summary, deps, now);
     let presenceConnected;
     try {
         presenceConnected =

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

@@ -66,6 +66,10 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** Test seam for the default-off quota account failover registry gate. */
+    quotaAccountFailoverEnabled?: boolean;
+    /** Return the selected retry transition without writing or starting a worker. */
+    dryRun?: boolean;
     /** Absolute CLI entry captured when the watcher is armed; tests may inject it. */
     hqCliEntry?: string;
     hostname?: string;

package/dist/lib/lanes/spawn.js

@@ -29,6 +29,9 @@ import { registryWorkerRecord } from "./registry-persona.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
 import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
+import { LANE_QUOTA_ACCOUNT_FAILOVER_FLAG } from "./flag-keys.js";
+import { readLanesRegistryFlagFailOff } from "./registry-flag.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
@@ -516,6 +519,19 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
     const env = deps.env ?? process.env;
     const admissionHost = deps.admissionHost ?? resolveAdmissionHost();
     const hostname = deps.hostname?.trim() || admissionHost.hostname.trim() || resolveAdmissionHost().hostname;
+    const now = (deps.now ?? (() => new Date()))();
+    const at = now.toISOString();
+    const nowMs = now.getTime();
+    const retryFromState = lane.state === "interrupted" &&
+        (lane.terminal_reason === "quota_held" ||
+            lane.terminal_reason === "account_quota_exhausted" ||
+            lane.terminal_reason === "account_model_unavailable")
+        ? "interrupted"
+        : "running";
+    const retryingExpiredQuota = retryFromState === "interrupted" &&
+        typeof lane.quota_reset_at === "string" &&
+        Number.isFinite(Date.parse(lane.quota_reset_at)) &&
+        Date.parse(lane.quota_reset_at) <= nowMs;
     const modelDeps = {
         ...deps.modelDeps,
         env: deps.modelDeps?.env ?? env,
@@ -525,13 +541,38 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         env,
     };
     const profile = lane.worker_profile ? loadWorkerProfile(hqRoot, lane.worker_profile) : undefined;
+    let quotaFailoverEnabled = false;
+    if (reason === "usage_limit") {
+        if (deps.quotaAccountFailoverEnabled !== undefined) {
+            quotaFailoverEnabled = deps.quotaAccountFailoverEnabled;
+        }
+        else {
+            try {
+                const laneCompany = resolveLaneCompany(hqRoot, lane);
+                quotaFailoverEnabled = await readLanesRegistryFlagFailOff(LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, { company: laneCompany.company, companyUidSource: laneCompanyUidSource(laneCompany.source), env });
+            }
+            catch (error) {
+                process.stderr.write(`${JSON.stringify({
+                    event: "lanes.quota_account_failover.company_context_failed",
+                    error: error instanceof Error ? error.name : "NonError",
+                    fallback: false,
+                })}\n`);
+            }
+        }
+    }
     const profileModel = profile?.meta.provider === lane.provider ? profile.meta.model : undefined;
     const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const unavailableAccounts = previouslyUnavailableAccounts(lane);
     const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
-        .filter(([id, account]) => id !== lane.account && !unavailableAccounts.has(id) && account.enabled)
+        .filter(([id, account]) => (id !== lane.account || (quotaFailoverEnabled && reason === "usage_limit" && retryingExpiredQuota)) &&
+        !unavailableAccounts.has(id) && account.enabled)
+        .filter(([id]) => !quotaFailoverEnabled ||
+        (profile?.meta.provider !== lane.provider ||
+            (profile.meta.accounts !== undefined
+                ? profile.meta.accounts.includes(id)
+                : profile.meta.account === undefined || profile.meta.account === id)))
         .filter(([id]) => accountStatus(lane.provider, id, config, {
         existsSync,
         hostname,
@@ -545,6 +586,7 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         existsSync,
         accountDeps,
         hostname,
+        now,
         ...(pinnedModel ?? profileModel ? { model: pinnedModel ?? profileModel } : {}),
         allowedAccounts,
     };
@@ -553,11 +595,96 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         target = selectBalancedAccount(lane.provider, config, modelContext);
     }
     catch (err) {
+        if (quotaFailoverEnabled &&
+            reason === "usage_limit" &&
+            err instanceof AccountResolutionError &&
+            err.error === "account_quota_exhausted") {
+            const quotaAccountReasons = Array.isArray(err.details.account_reasons)
+                ? err.details.account_reasons
+                : [];
+            const resetAt = quotaAccountReasons
+                .map((candidate) => candidate.quota_reset_at)
+                .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
+                .sort((a, b) => Date.parse(a) - Date.parse(b))[0];
+            if (resetAt) {
+                const accountReasons = Object.entries(config.providers[lane.provider].accounts).map(([id, account]) => {
+                    const quotaReason = quotaAccountReasons.find((candidate) => candidate.account === id);
+                    if (quotaReason)
+                        return quotaReason;
+                    if (id === lane.account)
+                        return { account: id, reason: "source_account_quota_exhausted" };
+                    if (unavailableAccounts.has(id))
+                        return { account: id, reason: "previously_unavailable" };
+                    if (!account.enabled)
+                        return { account: id, reason: "disabled" };
+                    if (quotaFailoverEnabled && profile?.meta.provider === lane.provider &&
+                        profile.meta.account !== undefined && profile.meta.account !== id) {
+                        return { account: id, reason: "worker_profile_account_pin" };
+                    }
+                    if (quotaFailoverEnabled && profile?.meta.provider === lane.provider &&
+                        profile.meta.accounts !== undefined && !profile.meta.accounts.includes(id)) {
+                        return { account: id, reason: "worker_profile_account_not_allowed" };
+                    }
+                    if (accountStatus(lane.provider, id, config, {
+                        existsSync,
+                        hostname,
+                        ...(accountDeps?.probe ? { probe: accountDeps.probe } : {}),
+                        ...(accountDeps?.env ? { env: accountDeps.env } : {}),
+                    }).logged_in !== true)
+                        return { account: id, reason: "login_required" };
+                    if (!supportsSpawnModel(lane.provider, id, config, pinnedModel, profileModel, modelDeps, hostname)) {
+                        return { account: id, reason: "model_or_pin_incompatible" };
+                    }
+                    return { account: id, reason: "eligible_but_not_selected" };
+                });
+                const holdLane = (current) => {
+                    if (current.state !== retryFromState ||
+                        current.account !== lane.account ||
+                        current.provider_session_id !== lane.provider_session_id) {
+                        throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while quota recovery was prepared`, { lane_id: lane.lane_id, state: current.state, account: current.account ?? null });
+                    }
+                    return {
+                        ...current,
+                        state: "interrupted",
+                        terminal_reason: "quota_held",
+                        terminal_details: {
+                            reason: err.error,
+                            account_reasons: accountReasons,
+                        },
+                        quota_reset_at: resetAt,
+                        interrupted_at: at,
+                    };
+                };
+                if (deps.dryRun)
+                    return holdLane(lane);
+                return retryUpdateLane(hqRoot, lane.lane_id, writer, holdLane);
+            }
+        }
         if (reason === "account_unavailable" || unavailableAccounts.size > 0) {
             throw new LanesError("account_not_logged_in", `Account ${lane.account ?? "(none)"} for ${lane.provider} is unavailable and no other logged-in account can serve this lane`, { provider: lane.provider, account: lane.account ?? null });
         }
         throw err;
     }
+    if (deps.dryRun) {
+        const entry = {
+            from: lane.account ?? null,
+            to: target.id,
+            at,
+            reason,
+        };
+        return {
+            ...lane,
+            state: "queued",
+            queued_reason: "account_retry",
+            queued_at: at,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            interrupted_at: undefined,
+            quota_reset_at: undefined,
+            account: target.id,
+            account_history: appendCappedHistory(lane.account_history ?? [], entry),
+        };
+    }
     const source = lane.account ? config.providers[lane.provider].accounts[lane.account] : undefined;
     const sessionId = providerSupportsSessionResume(lane.provider) &&
         typeof lane.provider_session_id === "string" &&
@@ -572,12 +699,9 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
             sessionId,
         }));
     }
-    const now = (deps.now ?? (() => new Date()))();
-    const at = now.toISOString();
-    const nowMs = now.getTime();
     return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
         const current = readLane(hqRoot, lane.lane_id);
-        if (current.state !== "running" ||
+        if (current.state !== retryFromState ||
             current.account !== lane.account ||
             current.provider_session_id !== lane.provider_session_id) {
             throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {
@@ -603,6 +727,8 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
                 admission_reserved_at: undefined,
                 terminal_reason: undefined,
                 terminal_details: undefined,
+                interrupted_at: undefined,
+                quota_reset_at: undefined,
                 account: target.id,
                 account_history: appendCappedHistory(row.account_history ?? [], entry),
                 pending_resume: sessionId
@@ -621,7 +747,7 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         const capacityReason = laneAdmissionCapReason(admissionLanes, candidate, config, admissionHost, profile?.meta.max_concurrent, nowMs);
         const earlierEligibleLane = hasEarlierEligibleQueuedLane(admissionLanes, candidate, config, admissionHost, profileMaxFor, nowMs);
         const moved = retryUpdateLane(hqRoot, lane.lane_id, writer, (row) => {
-            if (row.state !== "running" ||
+            if (row.state !== retryFromState ||
                 row.account !== lane.account ||
                 row.provider_session_id !== lane.provider_session_id) {
                 throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {

package/dist/lib/lanes/store.js

@@ -442,6 +442,16 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.hire_grant,
         });
     }
+    if (raw.released_hire_grant !== undefined &&
+        (typeof raw.released_hire_grant !== "number" ||
+            !Number.isSafeInteger(raw.released_hire_grant) ||
+            raw.released_hire_grant < 0)) {
+        throw new LaneSchemaError("Expected non-negative safe integer for released_hire_grant", {
+            path: filePath,
+            field: "released_hire_grant",
+            value: raw.released_hire_grant,
+        });
+    }
     if (raw.keep_alive !== undefined && typeof raw.keep_alive !== "boolean") {
         throw new LaneSchemaError("keep_alive must be a boolean", {
             path: filePath,
@@ -1603,6 +1613,31 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
                 throw new LanesError("lane_writer_unauthorized", `Writer ${writer} cannot write lane field ${key}`, { writer, field: key });
             }
         }
+        if (!isTerminalLaneState(current.state) && isTerminalLaneState(updated.state)) {
+            const releasedGrant = updated.hire_grant ?? current.hire_grant ?? 0;
+            return {
+                ...updated,
+                released_hire_grant: releasedGrant,
+                hire_grant: 0,
+            };
+        }
+        if (isTerminalLaneState(current.state) && !isTerminalLaneState(updated.state) &&
+            current.released_hire_grant !== undefined) {
+            return {
+                ...updated,
+                hire_grant: current.released_hire_grant,
+                released_hire_grant: undefined,
+            };
+        }
+        if (isTerminalLaneState(updated.state) &&
+            (updated.hire_grant !== current.hire_grant ||
+                updated.released_hire_grant !== current.released_hire_grant)) {
+            return {
+                ...updated,
+                hire_grant: 0,
+                released_hire_grant: updated.released_hire_grant ?? updated.hire_grant ?? 0,
+            };
+        }
         return updated;
     }, deps, {
         beforeWrite: (current) => assertLaneStoreWriteAllowed(current, laneId, writer),

package/dist/lib/lanes/tracker-report.d.ts

@@ -12,10 +12,20 @@ interface TrackerReportStory {
     id: string;
     title: string;
     status: ReportStoryStatus;
+    focus_id?: unknown;
+    kpi?: unknown;
+    owner?: string | null;
+    deadline?: string | null;
     references?: string[];
     updated_at?: string;
     source_path: string;
 }
+export interface TrackerReportFocusOverride {
+    reason: string;
+    by_lane: string;
+    at: string;
+    story: string;
+}
 export interface TrackerReportIssue {
     path: string;
     field: string;
@@ -47,6 +57,7 @@ export interface TrackerReportTeamInput {
     team: string;
     project_id: string;
     stories: readonly TrackerReportStory[];
+    focus_overrides?: readonly TrackerReportFocusOverride[];
     pull_requests: readonly TrackerReportPullRequest[];
     releases: readonly TrackerReportRelease[];
     blockers: readonly TrackerReportRecord[];
@@ -61,8 +72,42 @@ export interface TrackerReportInput {
     generated_at: string;
     since: string;
     since_source: "explicit" | "previous_report" | "first_run";
+    focus_dashboard_enabled?: boolean;
     teams: readonly TrackerReportTeamInput[];
 }
+interface TrackerFocusItem {
+    team: string;
+    project_id: string;
+    story_id: string;
+    title: string;
+    owner: string | null;
+    deadline: string | null;
+    state: ReportStoryStatus;
+    focus_id: unknown;
+    kpi: unknown;
+    override_reason: string | null;
+}
+interface TrackerTeamFocusShare {
+    team: string;
+    project_id: string;
+    window_start: string;
+    window_end: string;
+    work_story_count: number;
+    focused_story_count: number;
+    share_percent: number | null;
+    status: "red" | "ok" | "no_work";
+}
+interface TrackerFocusOverride extends TrackerReportFocusOverride {
+    team: string;
+    project_id: string;
+}
+interface TrackerFocusDashboard {
+    window_start: string;
+    window_end: string;
+    focus_list: TrackerFocusItem[];
+    team_focus_shares: TrackerTeamFocusShare[];
+    overrides: TrackerFocusOverride[];
+}
 interface ReportTimedStory {
     id: string;
     title: string;
@@ -140,6 +185,7 @@ export interface TrackerOwnerReport {
     generated_at: string;
     since: string;
     since_source: TrackerReportInput["since_source"];
+    focus_dashboard?: TrackerFocusDashboard;
     teams: TrackerOwnerTeamReport[];
 }
 interface TrackerTeamKpi {

package/dist/lib/lanes/tracker-report.js

@@ -231,6 +231,73 @@ function validatedWindow(input) {
     }
     return { generatedAt, since, sinceTime, generatedAtTime };
 }
+function hasFocus(story) {
+    const present = (value) => typeof value === "string"
+        ? value.trim().length > 0
+        : value !== undefined && value !== null;
+    return present(story.focus_id) || present(story.kpi);
+}
+function recentlyWorked(story, sinceTime, throughTime) {
+    if (story.updated_at === undefined)
+        return false;
+    const at = Date.parse(validTimestamp(story.updated_at, "updated_at", story.source_path, { story_id: story.id }));
+    return at >= sinceTime && at <= throughTime;
+}
+function buildFocusDashboard(teams, generatedAt, generatedAtTime) {
+    const windowStartTime = generatedAtTime - 24 * 60 * 60 * 1000;
+    const windowStart = new Date(windowStartTime).toISOString();
+    const focusList = [];
+    const teamFocusShares = [];
+    const overrides = [];
+    for (const team of teams) {
+        const teamOverrides = [...(team.focus_overrides ?? [])]
+            .filter((override) => Number.isFinite(Date.parse(override.at)) && Date.parse(override.at) <= generatedAtTime)
+            .sort((a, b) => a.at.localeCompare(b.at) || a.story.localeCompare(b.story));
+        overrides.push(...teamOverrides.map((override) => ({ ...override, team: team.team, project_id: team.project_id })));
+        const latestOverrideByStory = new Map();
+        for (const override of teamOverrides)
+            latestOverrideByStory.set(override.story, override.reason);
+        for (const story of team.stories) {
+            if (story.status === "dropped")
+                continue;
+            const activeOrRecentlyWorked = story.status === "in_progress" || recentlyWorked(story, windowStartTime, generatedAtTime);
+            const overrideReason = latestOverrideByStory.get(story.id) ?? null;
+            if (activeOrRecentlyWorked && (hasFocus(story) || overrideReason !== null)) {
+                focusList.push({
+                    team: team.team,
+                    project_id: team.project_id,
+                    story_id: story.id,
+                    title: story.title,
+                    owner: story.owner ?? null,
+                    deadline: story.deadline ?? null,
+                    state: story.status,
+                    focus_id: story.focus_id ?? null,
+                    kpi: story.kpi ?? null,
+                    override_reason: overrideReason,
+                });
+            }
+        }
+        const workStories = team.stories.filter((story) => story.status === "in_progress" || (story.status !== "dropped" && recentlyWorked(story, windowStartTime, generatedAtTime)));
+        const focusedStoryCount = workStories.filter(hasFocus).length;
+        const sharePercent = workStories.length === 0
+            ? null
+            : Math.round((focusedStoryCount / workStories.length) * 1000) / 10;
+        teamFocusShares.push({
+            team: team.team,
+            project_id: team.project_id,
+            window_start: windowStart,
+            window_end: generatedAt,
+            work_story_count: workStories.length,
+            focused_story_count: focusedStoryCount,
+            share_percent: sharePercent,
+            status: sharePercent === null ? "no_work" : focusedStoryCount / workStories.length < 0.8 ? "red" : "ok",
+        });
+    }
+    focusList.sort((a, b) => (a.deadline ?? "\uffff").localeCompare(b.deadline ?? "\uffff") || a.team.localeCompare(b.team) || a.story_id.localeCompare(b.story_id));
+    teamFocusShares.sort((a, b) => a.team.localeCompare(b.team));
+    overrides.sort((a, b) => a.at.localeCompare(b.at) || a.team.localeCompare(b.team) || a.story.localeCompare(b.story));
+    return { window_start: windowStart, window_end: generatedAt, focus_list: focusList, team_focus_shares: teamFocusShares, overrides };
+}
 function removeInvalidEntity(team, err) {
     if (!(err instanceof LanesError))
         return null;
@@ -316,7 +383,7 @@ export function buildTrackerOwnerReport(input) {
         }
         seen.add(team.team);
     }
-    return {
+    const report = {
         schema_version: "hq-lanes-owner-report.v1",
         company: input.company,
         generated_at: window.generatedAt,
@@ -326,6 +393,10 @@ export function buildTrackerOwnerReport(input) {
             .map((team) => withRecoverableTeamErrors(team, (safeTeam) => teamOwnerReport(safeTeam, input.company, window.sinceTime, window.generatedAtTime)))
             .sort((a, b) => a.team.localeCompare(b.team)),
     };
+    if (input.focus_dashboard_enabled === true) {
+        report.focus_dashboard = buildFocusDashboard(eligibleTeams, window.generatedAt, window.generatedAtTime);
+    }
+    return report;
 }
 function teamKpis(team, company, throughTime) {
     return team.kpis
@@ -460,6 +531,19 @@ export function renderTrackerOwnerReportText(report) {
         `Owner report for ${report.company}`,
         `Reporting window: ${report.since} through ${report.generated_at} (${report.since_source.replaceAll("_", " ")})`,
     ];
+    if (report.focus_dashboard) {
+        lines.push("", `Focus dashboard (last 24h: ${report.focus_dashboard.window_start} through ${report.focus_dashboard.window_end})`, "Focus list:");
+        lines.push(...listOrNone(report.focus_dashboard.focus_list, (item) => `${item.team}/${item.story_id} — ${item.title}; owner: ${item.owner ?? "unknown"}; deadline: ${item.deadline ?? "none"}; state: ${item.state}${item.override_reason ? `; override: ${item.override_reason}` : ""}`));
+        lines.push("Team focus share:");
+        lines.push(...listOrNone(report.focus_dashboard.team_focus_shares, (share) => {
+            if (share.share_percent === null)
+                return `${share.team}: no in-progress or worked stories`;
+            const color = share.status === "red" ? "RED under 80%" : "OK";
+            return `${share.team}: ${share.share_percent}% (${share.focused_story_count}/${share.work_story_count}); ${color}`;
+        }));
+        lines.push("Focus guard overrides:");
+        lines.push(...listOrNone(report.focus_dashboard.overrides, (override) => `${override.team}/${override.story} by ${override.by_lane} (${override.at}): ${override.reason}`));
+    }
     for (const team of report.teams) {
         lines.push("", `${team.team} (${team.project_id})`, "Progress:", "  Stories moved to done:");
         lines.push(...listOrNone(team.progress.stories_moved_to_done, (story) => `${story.id} — ${story.title} (${story.at})${story.references.length ? `; references: ${story.references.join(", ")}` : ""}`));

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

@@ -584,6 +584,8 @@ export interface LaneRecord {
     keep_alive_exhausted_at?: string;
     /** Maximum number of direct child lanes this lane may keep alive; old records default to 0. */
     hire_grant?: number;
+    /** Hire grant returned to the senior while this terminal lane is inactive. */
+    released_hire_grant?: number;
     /** Content hash of the profile last applied to this lane. */
     worker_profile_hash?: string;
     /** Registry persona selected by the profile, pinned at lane creation. */
@@ -785,7 +787,7 @@ export interface AccountHistoryEntry {
     from: string | null;
     to: string;
     at: string;
-    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "load_balance" | "keep_alive_resume" | "operator_move";
+    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "load_balance" | "keep_alive_resume" | "operator_move" | "profile_pin_exhausted";
 }
 export interface FailedResumeHistoryEntry {
     at: string;

package/dist/lib/lanes/types.js

@@ -228,6 +228,7 @@ export const LANE_FIELD_WRITERS = {
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], ledger_sync_error: ["story-ledger"], pending_question_ids: ["story-ledger"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],
+    released_hire_grant: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],

package/dist/main.js

@@ -43,7 +43,7 @@ import { isCompanySelectionError } from "./utils/company-selection-error.js";
 import { canOfferTeamUpgrade, formatPlanGateError, offerTeamUpgrade, offerUpgradeLink, planGateErrorFromVaultError, } from "./utils/plan-gate-error.js";
 import { upgradeToTeam } from "./utils/team-upgrade.js";
 import { printCachedVersionNudge, printVersionAndNudge, refreshVersionCache, staleAgainstCachedLatest, } from "./utils/version-check.js";
-import { enforceVersionGate, isLocalDependencyInstall, resolveRunningInstall, shouldSkipGate, } from "./utils/version-gate.js";
+import { enforceVersionGate, getVersionGatePhase, isLocalDependencyInstall, resolveRunningInstall, shouldSkipGate, } from "./utils/version-gate.js";
 import { autoUpdateAndReexec } from "./utils/self-update.js";
 import { CLI_VERSION } from "./cli-version.js";
 import { findLazyCommand, registerCommandCatalog } from "./lazy-commands.js";
@@ -262,6 +262,10 @@ export async function runCli() {
             env: process.env,
             entryPath: RUNNING_ENTRY_PATH,
             stderr: process.stderr,
+            deps: {
+                resolveInstall: resolveRunningInstall,
+                versionGatePhase: getVersionGatePhase,
+            },
         });
         if (registration.reexecStatus !== undefined) {
             // The re-exec'd child ran the command on the settled tree; carry its exit

package/dist/startup-registration.d.ts

@@ -16,6 +16,7 @@
  * style of handleTopLevelError so the whole seam is unit-testable without real
  * spawns, waits, or a real install tree.
  */
+import type { VersionGatePhase } from "./utils/version-gate.js";
 import { type InstallRewriteSignalArgs, type WaitForInstallTreeSettledArgs, type WaitForInstallTreeSettledResult } from "./utils/install-tree-torn.js";
 /**
  * Set on the re-exec'd child so it can NEVER wait or re-exec again — distinct
@@ -74,6 +75,8 @@ export interface RegisterRecoveryDeps {
     waitForSettled?: (args: WaitForInstallTreeSettledArgs) => Promise<WaitForInstallTreeSettledResult>;
     /** Positive writer-signal probe for the eval-throw gate (defaults to installRewriteInProgress). */
     rewriteInProgress?: (args: InstallRewriteSignalArgs) => boolean;
+    /** Current version-gate phase for diagnostics; defaults to unknown for early entry recovery. */
+    versionGatePhase?: () => VersionGatePhase;
     /** node flags to forward to the re-exec child (defaults to process.execArgv). */
     execArgv?: readonly string[];
 }