@indigoai-us/hq-cli 5.308.0 → 5.309.0

package/CHANGELOG.md

@@ -2,7 +2,17 @@
 
 ## [Unreleased]
 
+## [5.309.0] — 2026-10-01
+- `hq lanes autopilot run` now evaluates leads based on lane ownership rather than a host label, and reports registered leads assigned to another host as skipped.
+- Allow non-overlapping story-prefix teams to share a project in lane checks and reports.
+
 ## [5.308.0] — 2026-10-01
+- Added native `hq core audit-log`, `git-pack-extension-check`, `pin`, and `refresh-vault-access` commands behind the default-off `core-native-utilities` flag.
+- CI now cancels superseded pull-request benchmarks and reserves the additional Windows and macOS checks for changes that affect those platform paths. Main pushes retain all platform checks.
+- `hq lanes list` now settles legacy failed-dispatch mirrors as undispatched only after a successful strict owner snapshot returns no row; snapshot errors and mirrors with a host report remain unverified.
+- Outpost pickup and remote database requests now time out, and failed pending DM lookups are reported.
+
+## [5.307.0] — 2026-10-01
 - Add native `hq core resolve-company` on the fast route behind the default-off `core-native-utilities` gate.
 
 - Stop immediately when hq-deploy repeats an app-list cursor while resolving apps.

package/dist/commands/lanes-checks.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
+import { type TrackerCheckTeam } from "../lib/lanes/tracker-checks.js";
 import { type TrackerKind, type TrackerRecord } from "../lib/lanes/tracker-store.js";
-import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
+import type { LaneRecord, LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
 export interface LaneChecksDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
@@ -14,7 +15,11 @@ export interface ProjectMapping {
     team: string;
     leadLaneId?: string;
     statusPath: string;
+    storyPrefix?: string;
+    excludePrefix?: string;
 }
+export declare function mappingIncludesStory(mapping: ProjectMapping, storyId: string): boolean;
+export declare function ambiguousProjectMappings(mappings: readonly ProjectMapping[]): Map<string, string[]>;
 export interface ProjectReadResult {
     stories: Array<Record<string, unknown>>;
     mtime: number;
@@ -28,6 +33,7 @@ export interface ProjectReadResult {
 export declare function loadProjectMappings(root: string, company: string, requestedProject?: string): Map<string, ProjectMapping>;
 export declare function readProject(root: string, company: string, prdPath: string, tolerantStories?: boolean): ProjectReadResult;
 export declare function loadCompanyQuestionRecords(root: string, company: LaneCompanyRef, projectId?: string): QuestionRecord[];
+export declare function readTeamInputs(root: string, company: LaneCompanyRef, projects: readonly ProjectMapping[], lanes: readonly LaneRecord[]): TrackerCheckTeam[];
 export declare function pathForTrackerRecord(projectDirectory: string, kind: TrackerKind, id: string): string;
 export declare function listTrackerRecords(projectDirectory: string, kind: TrackerKind): TrackerRecord[];
 export interface TolerantTrackerReadIssue {

package/dist/commands/lanes-checks.js

@@ -12,6 +12,37 @@ import { DEFAULT_ORPHAN_USER_IDLE_HOURS, findOrphanLanes, parseOrphanMinAge, par
 import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
+export function mappingIncludesStory(mapping, storyId) {
+    return (mapping.storyPrefix === undefined || storyId.startsWith(mapping.storyPrefix))
+        && (mapping.excludePrefix === undefined || !storyId.startsWith(mapping.excludePrefix));
+}
+function mappingsOverlap(left, right) {
+    const includes = [left.storyPrefix, right.storyPrefix].filter((value) => value !== undefined);
+    if (includes.length === 2 && !includes[0].startsWith(includes[1]) && !includes[1].startsWith(includes[0]))
+        return false;
+    const commonPrefix = includes.sort((a, b) => b.length - a.length)[0] ?? "";
+    return ![left.excludePrefix, right.excludePrefix].some((excluded) => excluded !== undefined && commonPrefix.startsWith(excluded));
+}
+export function ambiguousProjectMappings(mappings) {
+    const byProject = new Map();
+    for (const mapping of mappings)
+        byProject.set(mapping.projectId, [...(byProject.get(mapping.projectId) ?? []), mapping]);
+    const ambiguous = new Map();
+    for (const [projectId, rows] of byProject) {
+        const conflicts = new Set();
+        for (let i = 0; i < rows.length; i++) {
+            for (let j = i + 1; j < rows.length; j++) {
+                if (mappingsOverlap(rows[i], rows[j])) {
+                    conflicts.add(rows[i].team);
+                    conflicts.add(rows[j].team);
+                }
+            }
+        }
+        if (conflicts.size > 0)
+            ambiguous.set(projectId, [...conflicts].sort());
+    }
+    return ambiguous;
+}
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -165,16 +196,26 @@ export function loadProjectMappings(root, company, requestedProject) {
             const team = validSegment(entry.team, "team");
             const leadLaneId = validSegment(entry.lane, "lead lane id");
             const statusPath = checkCompanyPath(root, company, entry.status, registryPath);
-            if (mappings.has(projectId))
-                return fail("tracker_checks_mapping_ambiguous", "More than one active team maps to a project", { path: registryPath, project_id: projectId });
-            mappings.set(projectId, { projectId, team, leadLaneId, statusPath });
+            const parsePrefix = (field) => {
+                const value = entry[field];
+                if (value === undefined)
+                    return undefined;
+                if (typeof value !== "string" || value.trim() === "") {
+                    return fail("tracker_checks_mapping_invalid", `${field} must be a non-empty string`, { path: registryPath, index, field });
+                }
+                return value.trim();
+            };
+            const storyPrefix = parsePrefix("story_prefix");
+            const excludePrefix = parsePrefix("exclude_prefix");
+            const key = `${projectId}:${team}:${index}`;
+            mappings.set(key, { projectId, team, leadLaneId, statusPath, ...(storyPrefix === undefined ? {} : { storyPrefix }), ...(excludePrefix === undefined ? {} : { excludePrefix }) });
         }
     }
     const projectsRoot = path.join(root, "companies", company, "projects");
     const knownProjectIds = new Set(projectDirectories(root, company));
     for (const projectId of knownProjectIds) {
-        if (projectHasTrackerRecords(root, company, projectId) && !mappings.has(projectId)) {
-            mappings.set(projectId, {
+        if (projectHasTrackerRecords(root, company, projectId) && ![...mappings.values()].some((mapping) => mapping.projectId === projectId)) {
+            mappings.set(`${projectId}:tracker`, {
                 projectId,
                 team: projectId,
                 statusPath: path.join(projectsRoot, projectId, "manager-status.json"),
@@ -183,10 +224,10 @@ export function loadProjectMappings(root, company, requestedProject) {
     }
     if (requestedProject !== undefined) {
         const projectId = validSegment(requestedProject, "project");
-        if (!knownProjectIds.has(projectId) && !mappings.has(projectId)) {
+        if (!knownProjectIds.has(projectId) && ![...mappings.values()].some((mapping) => mapping.projectId === projectId)) {
             return fail("tracker_project_not_found", "Project directory was not found for this company", { project_id: projectId, path: path.join(projectsRoot, projectId) });
         }
-        return new Map([...mappings].filter(([mappedProjectId]) => mappedProjectId === projectId));
+        return new Map([...mappings].filter(([, mapping]) => mapping.projectId === projectId));
     }
     return mappings;
 }
@@ -539,17 +580,18 @@ function readCompanyQuestions(root, company, projectId) {
         surfaced_at: surfacedAt.get(question.question_id) ?? null,
     }));
 }
-function readTeamInputs(root, company, projects, lanes) {
+export function readTeamInputs(root, company, projects, lanes) {
     const inputs = [];
     for (const project of projects) {
         const projectPath = path.join(root, "companies", company.slug, "projects", project.projectId);
         const prdPath = path.join(projectPath, "prd.json");
         const { stories, mtime } = readProject(root, company.slug, prdPath);
-        const teamLanes = lanes.filter((lane) => sameCompanyLane(lane, company) && laneMatchesProject(lane, project.projectId));
+        const teamLanes = lanes.filter((lane) => sameCompanyLane(lane, company) && laneMatchesProject(lane, project.projectId)
+            && (lane.lane_id === project.leadLaneId || mappingIncludesStory(project, lane.story_id)));
         const lead = project.leadLaneId === undefined
             ? undefined
             : teamLanes.find((lane) => lane.lane_id === project.leadLaneId);
-        const openStories = stories.filter((story) => !storyIsDone(story));
+        const openStories = stories.filter((story) => mappingIncludesStory(project, String(story.id)) && !storyIsDone(story));
         const openPrRefs = new Set();
         for (const story of openStories) {
             for (const ref of pullRequestReferences(story.prs ?? []))
@@ -658,7 +700,7 @@ async function readTrackerCheckRecords(root, company, projects) {
     const blockers = [];
     const kpis = [];
     const directives = [];
-    for (const project of projects) {
+    for (const project of [...new Map(projects.map((project) => [project.projectId, project])).values()]) {
         const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
         const store = createLocalTrackerStore(absoluteDirectory);
         const records = {
@@ -715,7 +757,7 @@ export async function resolveTrackerCompany(deps, requested) {
         fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
     return company;
 }
-async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps) {
+async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps, projectErrors) {
     const selectedProjects = [...projects.values()];
     const laneRecords = readScopedLanes(root, company, selectedProjects);
     const warnings = laneRecords.flatMap((lane) => {
@@ -773,6 +815,7 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         company: company.slug,
         generated_at: now.toISOString(),
         ...(warnings.length === 0 ? {} : { warnings }),
+        ...(projectErrors.length === 0 ? {} : { project_errors: projectErrors }),
         checks,
     };
 }
@@ -855,13 +898,20 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
         const root = deps.hqRoot();
         const projectFilter = options.project === undefined ? undefined : validSegment(options.project, "project");
         const minAgeMinutes = parseOrphanMinAge(options.minAge);
-        const projects = loadProjectMappings(root, company.slug, projectFilter);
-        const directiveProjects = projectFilter === undefined
-            ? projects
-            : loadProjectMappings(root, company.slug);
-        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, deps.now(), deps);
+        const allProjects = loadProjectMappings(root, company.slug);
+        const ambiguous = ambiguousProjectMappings([...allProjects.values()]);
+        const selectedAll = projectFilter === undefined ? [...allProjects.values()] : [...allProjects.values()].filter((mapping) => mapping.projectId === projectFilter);
+        const projectErrors = [...ambiguous].filter(([projectId]) => projectFilter === undefined || projectId === projectFilter).map(([project_id, teams]) => ({
+            project_id,
+            code: "tracker_checks_mapping_ambiguous",
+            teams,
+            message: "Team story prefixes overlap for this project",
+        }));
+        const projects = new Map(selectedAll.filter((mapping) => !ambiguous.has(mapping.projectId)).map((mapping, index) => [`${mapping.projectId}:${mapping.team}:${index}`, mapping]));
+        const directiveProjects = new Map([...allProjects.values()].filter((mapping) => !ambiguous.has(mapping.projectId)).map((mapping, index) => [`${mapping.projectId}:${mapping.team}:${index}`, mapping]));
+        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, deps.now(), deps, projectErrors);
         console.log(JSON.stringify(report, null, 2));
-        if (report.checks.some((item) => item.result === "failing"))
+        if (report.checks.some((item) => item.result === "failing") || projectErrors.length > 0)
             process.exitCode = 2;
     }));
     parent.command("orphans")

package/dist/commands/lanes-report.js

@@ -6,7 +6,7 @@ import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
 import { mapSourceStoryStatus } from "../lib/mesh/story-status.js";
 import { buildTrackerOwnerReport, buildTrackerTeamPage, renderTrackerOwnerReportText, renderTrackerTeamPageText, } from "../lib/lanes/tracker-report.js";
 import { FIRST_TRACKER_REPORT_SINCE, readTrackerReportState, writeTrackerReportState, } from "../lib/lanes/tracker-report-state.js";
-import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
+import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, mappingIncludesStory, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -184,6 +184,8 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
             errors.push({ path: prdPath, field: "id", message: "Story id must be a non-empty string" });
             continue;
         }
+        if (!mappingIncludesStory(project, id))
+            continue;
         const title = typeof story.title === "string" ? story.title : "";
         if (!title.trim()) {
             errors.push({ path: prdPath, field: "title", story_id: id, message: "Story title must be a non-empty string" });
@@ -217,7 +219,8 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
         stories.push({ id, title, status, references: refs.references, ...(normalizedUpdatedAt ? { updated_at: normalizedUpdatedAt } : {}), source_path: prdPath });
     }
     const teamQuestions = [];
-    for (const record of questions.filter((question) => question.project_id === project.projectId)) {
+    for (const record of questions.filter((question) => question.project_id === project.projectId
+        && (typeof question.story_id !== "string" || mappingIncludesStory(project, question.story_id)))) {
         const sourcePath = questionRecordPath(root, record.question_id);
         try {
             const body = deps.readQuestionBody(root, record);

package/dist/lib/doctor/checks/codex-wiring.d.ts

@@ -41,10 +41,6 @@
  */
 import { type AllowedDivergenceLoad } from "../allowed-divergence.js";
 import type { CheckContext, CheckResult } from "../types.js";
-/** Basename of the single-adapter script the current architecture routes to. */
-export declare const CODEX_ADAPTER_BASENAME = "hq-codex-hook-adapter.sh";
-/** Library the adapter sources to dispatch `.claude/settings.json` live. */
-export declare const CODEX_DISPATCH_LIB_RELPATH: string;
 /**
  * Lifecycle events the shipped `.codex/config.toml` routes through the adapter.
  * A missing event means the Claude hooks for that event never run under Codex.

package/dist/lib/doctor/checks/codex-wiring.js

@@ -44,9 +44,9 @@ import * as path from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { ALLOWED_DIVERGENCE_RELPATH, loadAllowedDivergence, } from "../allowed-divergence.js";
 /** Basename of the single-adapter script the current architecture routes to. */
-export const CODEX_ADAPTER_BASENAME = "hq-codex-hook-adapter.sh";
+const CODEX_ADAPTER_BASENAME = "hq-codex-hook-adapter.sh";
 /** Library the adapter sources to dispatch `.claude/settings.json` live. */
-export const CODEX_DISPATCH_LIB_RELPATH = path.join("core", "scripts", "lib", "hook-adapter-core.sh");
+const CODEX_DISPATCH_LIB_RELPATH = path.join("core", "scripts", "lib", "hook-adapter-core.sh");
 /**
  * Lifecycle events the shipped `.codex/config.toml` routes through the adapter.
  * A missing event means the Claude hooks for that event never run under Codex.

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

@@ -28,16 +28,6 @@
 import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
 /** The id of the AI-runtime-health family. */
 export declare const RUNTIMES_FAMILY_ID = "runtimes";
-/** Common id prefix for every result this family emits. */
-export declare const RUNTIMES_PREFIX = "runtimes";
-/**
- * The deterministic one-line probe prompt. Health is proven by a round-trip
- * (exit 0 plus non-empty output), not by exact-matching the reply, so a model
- * that answers with anything at all still passes.
- */
-export declare const PROBE_PROMPT = "Reply with exactly: OK";
-/** How long each live probe may run before it is killed and marked UNKNOWN. */
-export declare const DEFAULT_PROBE_TIMEOUT_MS = 120000;
 /** One AI runtime the doctor knows how to find and probe. */
 export interface RuntimeSpec {
     /** Stable key used in check ids, e.g. `runtimes.codex.binary`. */
@@ -94,11 +84,4 @@ export interface RuntimeHealthDeps {
 export declare function checkRuntimeHealth(context: CheckContext, deps?: RuntimeHealthDeps): Promise<CheckResult[]>;
 /** The registered family object. */
 export declare const runtimeHealthFamily: CheckFamily;
-/**
- * Resolve an executable name against PATH with a pure filesystem scan — no
- * process is spawned, keeping the doctor's default run a function of on-disk
- * shape. First PATH entry containing an executable regular file wins, which is
- * exactly the copy a shell would run.
- */
-export declare function resolveOnPath(binary: string): string | null;
 //# sourceMappingURL=runtime-health.d.ts.map

package/dist/lib/doctor/checks/runtime-health.js

@@ -33,15 +33,15 @@ import { planCommandSpawn } from "../../../utils/windows-spawn.js";
 /** The id of the AI-runtime-health family. */
 export const RUNTIMES_FAMILY_ID = "runtimes";
 /** Common id prefix for every result this family emits. */
-export const RUNTIMES_PREFIX = "runtimes";
+const RUNTIMES_PREFIX = "runtimes";
 /**
  * The deterministic one-line probe prompt. Health is proven by a round-trip
  * (exit 0 plus non-empty output), not by exact-matching the reply, so a model
  * that answers with anything at all still passes.
  */
-export const PROBE_PROMPT = "Reply with exactly: OK";
+const PROBE_PROMPT = "Reply with exactly: OK";
 /** How long each live probe may run before it is killed and marked UNKNOWN. */
-export const DEFAULT_PROBE_TIMEOUT_MS = 120_000;
+const DEFAULT_PROBE_TIMEOUT_MS = 120_000;
 /**
  * The three runtimes HQ wires hooks for. Codex runs its probe under its own
  * read-only sandbox and outside-a-repo mode so the probe can never write; the
@@ -243,7 +243,7 @@ export const runtimeHealthFamily = {
  * shape. First PATH entry containing an executable regular file wins, which is
  * exactly the copy a shell would run.
  */
-export function resolveOnPath(binary) {
+function resolveOnPath(binary) {
     const pathVar = process.env.PATH ?? "";
     for (const dir of pathVar.split(path.delimiter)) {
         if (!dir)

package/dist/lib/doctor/checks/scaffold-cli-floor.d.ts

@@ -1,6 +1,5 @@
 import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
 export declare const SCAFFOLD_CLI_FLOOR_FAMILY_ID = "scaffold-cli-floor";
-export declare const SCAFFOLD_CLI_FLOOR_FAMILY_TITLE = "Scaffold CLI compatibility";
 export declare const SCAFFOLD_CLI_FLOOR_CHECK_ID = "scaffold-cli-floor.requires-hq-cli";
 export declare const scaffoldCliFloorFamily: CheckFamily;
 export declare function checkScaffoldCliFloor(context: CheckContext): CheckResult[];

package/dist/lib/doctor/checks/scaffold-cli-floor.js

@@ -4,7 +4,7 @@ import * as yaml from "js-yaml";
 import { CLI_VERSION } from "../../../cli-version.js";
 import { compareScaffoldCliFloor } from "../../scaffold-cli-floor.js";
 export const SCAFFOLD_CLI_FLOOR_FAMILY_ID = "scaffold-cli-floor";
-export const SCAFFOLD_CLI_FLOOR_FAMILY_TITLE = "Scaffold CLI compatibility";
+const SCAFFOLD_CLI_FLOOR_FAMILY_TITLE = "Scaffold CLI compatibility";
 export const SCAFFOLD_CLI_FLOOR_CHECK_ID = "scaffold-cli-floor.requires-hq-cli";
 export const scaffoldCliFloorFamily = {
     id: SCAFFOLD_CLI_FLOOR_FAMILY_ID,

package/dist/lib/doctor/compat.d.ts

@@ -31,22 +31,6 @@ import type { DoctorJsonDocument } from "./json-output.js";
 export declare const CHECK_HQ_HOOKS_PASS_EXIT = 0;
 /** Exit code check-hq-hooks.sh returns on a health failure. Preserved. */
 export declare const CHECK_HQ_HOOKS_FAIL_EXIT = 2;
-/** Exit code check-hq-hooks.sh returns on a usage error. Preserved. */
-export declare const CHECK_HQ_HOOKS_USAGE_EXIT = 64;
-/** The runtime-probe result id: whether hooks actually fired (the ledger). */
-export declare const RUNTIME_ENFORCEMENT_CHECK_ID = "hooks.runtime.enforcement";
-/**
- * The `hq doctor` check ids that correspond to check-hq-hooks.sh's *settings
- * load* scope — the subset of the hooks family the wrapper is allowed to fail
- * on. Deliberately narrow: it covers a missing/invalid settings file, an
- * unquoted `$CLAUDE_PROJECT_DIR` that word-splits on a spaced root, and a hook
- * command that runs a script which is not on disk — and nothing else. The many
- * richer doctor findings (executable bits, orphaned scripts, three-profile
- * membership, Codex/Grok parity, fixture coverage) are intentionally OUT of
- * scope, so the wrapper stays byte-for-byte compatible with callers that only
- * ever cared whether the hook configuration could load.
- */
-export declare const CHECK_HQ_HOOKS_SETTINGS_SCOPE: readonly string[];
 /**
  * Whether hook dispatch was observed this session. Mirrors the wrapper's
  * `HQ runtime enforcement: …` line. `NOT CHECKED` is the default when

package/dist/lib/doctor/compat.js

@@ -31,9 +31,9 @@ export const CHECK_HQ_HOOKS_PASS_EXIT = 0;
 /** Exit code check-hq-hooks.sh returns on a health failure. Preserved. */
 export const CHECK_HQ_HOOKS_FAIL_EXIT = 2;
 /** Exit code check-hq-hooks.sh returns on a usage error. Preserved. */
-export const CHECK_HQ_HOOKS_USAGE_EXIT = 64;
+const CHECK_HQ_HOOKS_USAGE_EXIT = 64;
 /** The runtime-probe result id: whether hooks actually fired (the ledger). */
-export const RUNTIME_ENFORCEMENT_CHECK_ID = "hooks.runtime.enforcement";
+const RUNTIME_ENFORCEMENT_CHECK_ID = "hooks.runtime.enforcement";
 /**
  * The `hq doctor` check ids that correspond to check-hq-hooks.sh's *settings
  * load* scope — the subset of the hooks family the wrapper is allowed to fail
@@ -45,7 +45,7 @@ export const RUNTIME_ENFORCEMENT_CHECK_ID = "hooks.runtime.enforcement";
  * scope, so the wrapper stays byte-for-byte compatible with callers that only
  * ever cared whether the hook configuration could load.
  */
-export const CHECK_HQ_HOOKS_SETTINGS_SCOPE = [
+const CHECK_HQ_HOOKS_SETTINGS_SCOPE = [
     "hooks.settings-present",
     "hooks.settings-required-command-hooks",
     "hooks.settings-valid-json",

package/dist/lib/doctor/platform.d.ts

@@ -126,24 +126,8 @@ export declare function claudeCodeFlagEvidence(env: NodeJS.ProcessEnv): Platform
  * `com.googlecode.iterm2`), so this fires only under a real desktop host.
  */
 export declare function bundleIdEvidence(env: NodeJS.ProcessEnv): PlatformEvidence | null;
-/**
- * Codex runtime environment variables, kept in parity with the canonical shell
- * detector `core/scripts/lib/detect-codex.sh`. Presence of any is a strong Codex
- * signal. One evidence entry is produced per variable found so a single Codex
- * signal can be tested in isolation.
- */
-export declare const CODEX_ENV_VARS: readonly ["CODEX_SANDBOX", "CODEX_SESSION_ID", "CODEX_EXECUTION_ID", "CODEX_AGENT_ID", "CODEX_THREAD_ID", "CODEX_SHELL", "CODEX_CI", "CODEX_INTERNAL_ORIGINATOR_OVERRIDE", "OPENAI_CODEX"];
 /** Every Codex environment signal present in `env`, one entry per variable. */
 export declare function codexEnvEvidence(env: NodeJS.ProcessEnv): PlatformEvidence[];
-/**
- * Grok runtime environment variables. Restricted to variables the Grok host
- * exports into the session (a session id, its workspace root) — HQ's own Grok
- * *launcher* variables (`GROK_BIN`, `GROK_CONFIG`, `XAI_API_KEY`, …) are
- * excluded on purpose: those can be set inside a Claude or Codex session that is
- * merely preparing to launch Grok, and treating them as "we are running under
- * Grok" would be a false positive.
- */
-export declare const GROK_ENV_VARS: readonly ["GROK_SESSION_ID", "GROK_WORKSPACE_ROOT"];
 /** Every Grok environment signal present in `env`, one entry per variable. */
 export declare function grokEnvEvidence(env: NodeJS.ProcessEnv): PlatformEvidence[];
 /**
@@ -157,10 +141,6 @@ export declare function grokEnvEvidence(env: NodeJS.ProcessEnv): PlatformEvidenc
  * on its environment signals instead, and this function does not guess it.
  */
 export declare function ancestryEvidence(ancestors: AncestorProcess[]): PlatformEvidence[];
-/** The one command this module ever launches to read process ancestry. */
-export declare const PS_COMMAND = "ps";
-/** `ps` arguments: every process as `pid ppid comm`, header-suppressed. */
-export declare const PS_ARGS: readonly ["-Ao", "pid=,ppid=,comm="];
 /**
  * Low-level process-table provider: runs a command and returns its stdout, or
  * `null` on failure. This is the single seam through which any process is
@@ -186,12 +166,6 @@ export interface ReadAncestryOptions {
  * environment signals rather than throwing.
  */
 export declare function readProcessAncestry(options?: ReadAncestryOptions): AncestorProcess[];
-/**
- * Collect the environment signals, in a stable order: entrypoint, the Claude
- * flag, bundle id, Codex vars, then Grok vars. Process ancestry is collected
- * separately (and lazily) by {@link detectPlatform}.
- */
-export declare function collectEnvEvidence(env: NodeJS.ProcessEnv): PlatformEvidence[];
 /**
  * Collect every signal from an environment and an explicit ancestor chain, in a
  * stable order: environment signals first, then process ancestry. Exposed for

package/dist/lib/doctor/platform.js

@@ -150,7 +150,7 @@ function looksLikeClaudeDesktopBundle(id) {
  * signal. One evidence entry is produced per variable found so a single Codex
  * signal can be tested in isolation.
  */
-export const CODEX_ENV_VARS = [
+const CODEX_ENV_VARS = [
     "CODEX_SANDBOX",
     "CODEX_SESSION_ID",
     "CODEX_EXECUTION_ID",
@@ -185,7 +185,7 @@ export function codexEnvEvidence(env) {
  * merely preparing to launch Grok, and treating them as "we are running under
  * Grok" would be a false positive.
  */
-export const GROK_ENV_VARS = ["GROK_SESSION_ID", "GROK_WORKSPACE_ROOT"];
+const GROK_ENV_VARS = ["GROK_SESSION_ID", "GROK_WORKSPACE_ROOT"];
 /** Every Grok environment signal present in `env`, one entry per variable. */
 export function grokEnvEvidence(env) {
     const found = [];
@@ -249,9 +249,9 @@ const DEFAULT_MAX_HOPS = 20;
 /** Wall-clock bound for the single `ps` snapshot, keeping startup fast. */
 const PS_TIMEOUT_MS = 250;
 /** The one command this module ever launches to read process ancestry. */
-export const PS_COMMAND = "ps";
+const PS_COMMAND = "ps";
 /** `ps` arguments: every process as `pid ppid comm`, header-suppressed. */
-export const PS_ARGS = ["-Ao", "pid=,ppid=,comm="];
+const PS_ARGS = ["-Ao", "pid=,ppid=,comm="];
 /**
  * Read this process's ancestor chain (nearest parent first) by taking one `ps`
  * snapshot of the process table and walking parent pointers upward. A single
@@ -330,7 +330,7 @@ function defaultPsSpawner(command, args) {
  * flag, bundle id, Codex vars, then Grok vars. Process ancestry is collected
  * separately (and lazily) by {@link detectPlatform}.
  */
-export function collectEnvEvidence(env) {
+function collectEnvEvidence(env) {
     const evidence = [];
     const entrypoint = entrypointEvidence(env);
     if (entrypoint)

package/dist/lib/lanes/autopilot.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { laneRunsOnHost } from "./admission.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { LanesError } from "./errors.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
@@ -406,7 +407,7 @@ function recordOperatorEscalation(hqRoot, record) {
 async function runLeadAutopilotPassUnlocked(input) {
     const { hqRoot, host, now } = input;
     const result = { ok: true, host, evaluated: 0, sent: [], started: [], escalated: [], skipped: [] };
-    const leads = parseRegistry(hqRoot).filter((lead) => lead.host === host || (host === "local" && lead.host === input.hostname));
+    const leads = parseRegistry(hqRoot);
     const lanes = readAllLanes(hqRoot);
     const byId = new Map(lanes.map((lane) => [lane.lane_id, lane]));
     const stateFile = path.join(hqRoot, "workspace", "lane-briefs", "autopilot-state.json");
@@ -422,131 +423,150 @@ async function runLeadAutopilotPassUnlocked(input) {
             continue;
         }
         const registeredLocalHost = registered.host === "local" || registered.host === input.hostname;
-        if ((registeredLocalHost && (lead.host.kind !== "local" || lead.host.id !== input.hostname)) ||
-            (!registeredLocalHost && (lead.host.kind !== "outpost" || lead.host.id !== registered.host || input.outpostId !== registered.host))) {
+        const hostMatchesRegistry = registeredLocalHost
+            ? lead.host.kind === "local"
+            : lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host;
+        if (!hostMatchesRegistry ||
+            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: input.outpostId })) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });
             continue;
         }
-        const enabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_FLAG, { company: lead.company });
-        if (!enabled) {
-            result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
-            continue;
-        }
-        const status = readStatus(hqRoot, registered.status, lead.company.slug);
-        const statusUpdatedAt = typeof status.updated_at === "string" && Number.isFinite(Date.parse(status.updated_at))
-            ? new Date(Date.parse(status.updated_at)).toISOString()
-            : undefined;
-        result.evaluated += 1;
-        const stories = projectStories(hqRoot, registered.prd, lead.company.slug, lead.project_id);
-        const children = lanes.filter((lane) => lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
-        const planned = planLeadAutopilotWakes({
-            lead,
-            children,
-            stories,
-            now,
-            managerStatus: status,
-            keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
-        });
         let stateChanged = false;
-        const activeKeys = new Set(planned.map((wake) => `${lead.lane_id}:${wake.condition}`));
-        for (const key of Object.keys(state.sent)) {
-            if (key.startsWith(`${lead.lane_id}:`) && !activeKeys.has(key)) {
-                delete state.sent[key];
-                stateChanged = true;
+        try {
+            const enabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_FLAG, { company: lead.company });
+            if (!enabled) {
+                result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
+                continue;
             }
-        }
-        for (const wake of planned) {
-            const key = `${lead.lane_id}:${wake.condition}`;
-            const prior = state.sent[key];
-            if (prior?.fingerprint === wake.fingerprint) {
-                if (input.dryRun)
-                    continue;
-                let current = prior;
-                const lastWakeAt = Date.parse(prior.last_wake_at ?? prior.at);
-                if (!Number.isFinite(lastWakeAt)) {
-                    throw new LanesError("lead_autopilot_state_invalid", `Invalid wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
-                }
-                if (statusUpdatedAt === undefined || prior.status_updated_at === undefined) {
-                    throw new LanesError("lead_autopilot_status_activity_unverifiable", `Cannot verify whether lead ${lead.lane_id} acted after its autopilot wake`, { lead_lane: lead.lane_id, story_id: wake.story_id });
-                }
-                if (!prior.acted && Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at)) {
-                    current = { ...prior, acted: true };
-                    state.sent[key] = current;
+            const status = readStatus(hqRoot, registered.status, lead.company.slug);
+            const statusUpdatedAt = typeof status.updated_at === "string" && Number.isFinite(Date.parse(status.updated_at))
+                ? new Date(Date.parse(status.updated_at)).toISOString()
+                : undefined;
+            const stories = projectStories(hqRoot, registered.prd, lead.company.slug, lead.project_id);
+            const children = lanes.filter((lane) => lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
+            const planned = planLeadAutopilotWakes({
+                lead,
+                children,
+                stories,
+                now,
+                managerStatus: status,
+                keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
+            });
+            const activeKeys = new Set(planned.map((wake) => `${lead.lane_id}:${wake.condition}`));
+            for (const key of Object.keys(state.sent)) {
+                if (key.startsWith(`${lead.lane_id}:`) && !activeKeys.has(key)) {
+                    delete state.sent[key];
                     stateChanged = true;
                 }
-                if (wake.condition === "fill_grant" && input.startWorker && !current.acted && !current.auto_started) {
-                    const firstWakeAt = Date.parse(current.at);
-                    if (!Number.isFinite(firstWakeAt)) {
-                        throw new LanesError("lead_autopilot_state_invalid", `Invalid fill-grant wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+            }
+            for (const wake of planned) {
+                const key = `${lead.lane_id}:${wake.condition}`;
+                const prior = state.sent[key];
+                if (prior?.fingerprint === wake.fingerprint) {
+                    if (input.dryRun)
+                        continue;
+                    let current = prior;
+                    const lastWakeAt = Date.parse(prior.last_wake_at ?? prior.at);
+                    if (!Number.isFinite(lastWakeAt)) {
+                        throw new LanesError("lead_autopilot_state_invalid", `Invalid wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                    }
+                    if (statusUpdatedAt === undefined || prior.status_updated_at === undefined) {
+                        throw new LanesError("lead_autopilot_status_activity_unverifiable", `Cannot verify whether lead ${lead.lane_id} acted after its autopilot wake`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                    }
+                    if (!prior.acted && Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at)) {
+                        current = { ...prior, acted: true };
+                        state.sent[key] = current;
+                        stateChanged = true;
                     }
-                    if (now.getTime() - firstWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
-                        const story = stories.find((candidate) => candidate.id === wake.story_id && candidate.status === "todo");
-                        if (!story?.briefPath) {
-                            throw new LanesError("lead_autopilot_story_brief_missing", `Cannot auto-start story ${wake.story_id}: its project record has no valid brief path`, { lead_lane: lead.lane_id, story_id: wake.story_id, project_id: lead.project_id });
+                    if (wake.condition === "fill_grant" && input.startWorker && !current.acted && !current.auto_started) {
+                        const firstWakeAt = Date.parse(current.at);
+                        if (!Number.isFinite(firstWakeAt)) {
+                            throw new LanesError("lead_autopilot_state_invalid", `Invalid fill-grant wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
                         }
-                        if (lead.state !== "running" && lead.state !== "queued") {
-                            current = { ...current, acted: true };
+                        if (now.getTime() - firstWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
+                            const story = stories.find((candidate) => candidate.id === wake.story_id && candidate.status === "todo");
+                            if (!story?.briefPath) {
+                                throw new LanesError("lead_autopilot_story_brief_missing", `Cannot auto-start story ${wake.story_id}: its project record has no valid brief path`, { lead_lane: lead.lane_id, story_id: wake.story_id, project_id: lead.project_id });
+                            }
+                            if (lead.state !== "running" && lead.state !== "queued") {
+                                current = { ...current, acted: true };
+                                state.sent[key] = current;
+                                stateChanged = true;
+                                result.skipped.push({ lead_lane: lead.lane_id, reason: "auto_start_lead_not_active" });
+                            }
+                            else {
+                                const started = await input.startWorker({ lead, story });
+                                current = { ...current, auto_started: true, worker_lane: started.lane_id };
+                                state.sent[key] = current;
+                                stateChanged = true;
+                                result.started.push({ lead_lane: lead.lane_id, story_id: story.id, worker_lane: started.lane_id });
+                            }
+                        }
+                    }
+                    if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
+                        const wakeCount = current.wake_count ?? 1;
+                        if (wakeCount < 2) {
+                            appendDropboxMessage(hqRoot, lead.lane_id, {
+                                at: now.toISOString(),
+                                message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
+                                kind: "system_notice",
+                                text: wake.prompt,
+                            });
+                            current = { ...current, wake_count: 2, last_wake_at: now.toISOString() };
                             state.sent[key] = current;
                             stateChanged = true;
-                            result.skipped.push({ lead_lane: lead.lane_id, reason: "auto_start_lead_not_active" });
+                            result.sent.push(wake);
                         }
                         else {
-                            const started = await input.startWorker({ lead, story });
-                            current = { ...current, auto_started: true, worker_lane: started.lane_id };
+                            const escalation = { team: registered.team, lead_lane: lead.lane_id, condition: wake.condition, story_id: wake.story_id, at: now.toISOString(), fingerprint: wake.fingerprint };
+                            recordOperatorEscalation(hqRoot, escalation);
+                            current = { ...current, escalated_at: now.toISOString() };
                             state.sent[key] = current;
                             stateChanged = true;
-                            result.started.push({ lead_lane: lead.lane_id, story_id: story.id, worker_lane: started.lane_id });
+                            result.escalated.push(escalation);
                         }
                     }
+                    continue;
                 }
-                if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
-                    const wakeCount = current.wake_count ?? 1;
-                    if (wakeCount < 2) {
-                        appendDropboxMessage(hqRoot, lead.lane_id, {
-                            at: now.toISOString(),
-                            message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
-                            kind: "system_notice",
-                            text: wake.prompt,
-                        });
-                        current = { ...current, wake_count: 2, last_wake_at: now.toISOString() };
-                        state.sent[key] = current;
-                        stateChanged = true;
-                        result.sent.push(wake);
-                    }
-                    else {
-                        const escalation = { team: registered.team, lead_lane: lead.lane_id, condition: wake.condition, story_id: wake.story_id, at: now.toISOString(), fingerprint: wake.fingerprint };
-                        recordOperatorEscalation(hqRoot, escalation);
-                        current = { ...current, escalated_at: now.toISOString() };
-                        state.sent[key] = current;
-                        stateChanged = true;
-                        result.escalated.push(escalation);
-                    }
+                if (!input.dryRun) {
+                    appendDropboxMessage(hqRoot, lead.lane_id, {
+                        at: now.toISOString(),
+                        message_id: `lead-autopilot:${wake.fingerprint}`,
+                        kind: "system_notice",
+                        text: wake.prompt,
+                    });
+                    state.sent[key] = {
+                        fingerprint: wake.fingerprint,
+                        at: now.toISOString(),
+                        ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
+                        wake_count: 1,
+                        last_wake_at: now.toISOString(),
+                    };
+                    stateChanged = true;
                 }
-                continue;
+                result.sent.push(wake);
             }
-            if (!input.dryRun) {
-                appendDropboxMessage(hqRoot, lead.lane_id, {
-                    at: now.toISOString(),
-                    message_id: `lead-autopilot:${wake.fingerprint}`,
-                    kind: "system_notice",
-                    text: wake.prompt,
-                });
-                state.sent[key] = {
-                    fingerprint: wake.fingerprint,
-                    at: now.toISOString(),
-                    ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
-                    wake_count: 1,
-                    last_wake_at: now.toISOString(),
-                };
-                stateChanged = true;
-            }
-            result.sent.push(wake);
+            if (!input.dryRun && stateChanged)
+                writeState(stateFile, state);
+            result.evaluated += 1;
+        }
+        catch (error) {
+            if (!input.dryRun && stateChanged)
+                writeState(stateFile, state);
+            if (!(error instanceof LanesError) || LEAD_AUTOPILOT_PASS_FATAL_ERRORS.has(error.error))
+                throw error;
+            result.skipped.push({ lead_lane: lead.lane_id, reason: error.error });
         }
-        if (!input.dryRun && stateChanged)
-            writeState(stateFile, state);
     }
     return result;
 }
+// Tenant-boundary and path-safety failures stop the whole pass; other per-lead
+// data errors skip only that lead.
+const LEAD_AUTOPILOT_PASS_FATAL_ERRORS = new Set([
+    "lead_autopilot_tenant_mismatch",
+    "lead_autopilot_status_path_invalid",
+    "lead_autopilot_escalation_record_invalid",
+]);
 const LEAD_AUTOPILOT_STALE_LOCK_MAX_AGE_MS = 60 * 60_000;
 function processStartIdentity(pid) {
     try {

package/dist/lib/onboarding/errors.d.ts

@@ -4,7 +4,7 @@
  * Each failure class maps to a distinct step in the onboarding flow,
  * making it easy for the installer to show targeted recovery hints.
  */
-export declare class OnboardingError extends Error {
+declare class OnboardingError extends Error {
     readonly step: string;
     readonly cause?: Error | undefined;
     constructor(message: string, step: string, cause?: Error | undefined);
@@ -30,4 +30,5 @@ export declare class InviteAcceptError extends OnboardingError {
 export declare class StsVerifyError extends OnboardingError {
     constructor(message: string, cause?: Error);
 }
+export {};
 //# sourceMappingURL=errors.d.ts.map

package/dist/lib/onboarding/errors.js

@@ -4,7 +4,7 @@
  * Each failure class maps to a distinct step in the onboarding flow,
  * making it easy for the installer to show targeted recovery hints.
  */
-export class OnboardingError extends Error {
+class OnboardingError extends Error {
     step;
     cause;
     constructor(message, step, cause) {

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

@@ -7,11 +7,7 @@
  * invite/accept into create-company and join-company flows with
  * checkpoint/resume.
  */
-export { createCompanyFlow, joinCompanyFlow, resumeOnboarding, onboardingContract, } from "./orchestrator.js";
-export { readCheckpoint, writeCheckpoint, deleteCheckpoint, getCheckpointPath, isStepComplete, } from "./checkpoint.js";
-export { OnboardingError, PersonCreationError, CompanyCreationError, ProvisioningError, MembershipBootstrapError, FirstSyncError, InviteAcceptError, StsVerifyError, } from "./errors.js";
-export type { OnboardingInput, CreateCompanyInput, JoinCompanyInput, OnboardingConfig, OnboardingResult, OnboardingProgress, OnboardingStep, StepStatus, ProgressCallback, OnboardingCheckpoint, DesktopInstallerContract, HqConfig, } from "./types.js";
+export { readCheckpoint } from "./checkpoint.js";
+export type { OnboardingCheckpoint } from "./types.js";
 export { runOnboardCli } from "./cli/onboard.js";
-export type { OnboardCliOptions, OnboardCliResult } from "./cli/onboard.js";
-export { formatProgress, formatSummary, formatError, validateSlug, validateEmail } from "./cli/prompts.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/onboarding/index.js

@@ -7,10 +7,7 @@
  * invite/accept into create-company and join-company flows with
  * checkpoint/resume.
  */
-export { createCompanyFlow, joinCompanyFlow, resumeOnboarding, onboardingContract, } from "./orchestrator.js";
-export { readCheckpoint, writeCheckpoint, deleteCheckpoint, getCheckpointPath, isStepComplete, } from "./checkpoint.js";
-export { OnboardingError, PersonCreationError, CompanyCreationError, ProvisioningError, MembershipBootstrapError, FirstSyncError, InviteAcceptError, StsVerifyError, } from "./errors.js";
-// CLI
+// The CLI command and identity guard are the only consumers of this barrel.
+export { readCheckpoint } from "./checkpoint.js";
 export { runOnboardCli } from "./cli/onboard.js";
-export { formatProgress, formatSummary, formatError, validateSlug, validateEmail } from "./cli/prompts.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/search-index/embed-lock.d.ts

@@ -11,13 +11,6 @@ export type EmbedLockProcessEvents = Pick<NodeJS.Process, 'once'> & {
     removeListener?: NodeJS.Process['removeListener'];
 };
 export type EmbedLockRunResult = 'ran' | 'skipped' | 'busy' | 'unavailable';
-/**
- * Serializes QMD writes started through HQ-managed hq-cli paths. A bare `qmd
- * update` / `qmd embed` (or another tool that does not call this module) cannot
- * participate, because qmd is a third-party package and does not know about
- * HQ's lock protocol.
- */
-export declare const EMBED_LOCK_NAME = "qmd-reindex-bg.lock";
 export declare function defaultEmbedLockDependencies(env?: NodeJS.ProcessEnv): EmbedLockDependencies;
 export declare function lockRoot(home: string): string;
 export declare function lockPath(home: string): string;

package/dist/lib/search-index/embed-lock.js

@@ -6,7 +6,7 @@ import * as path from 'node:path';
  * participate, because qmd is a third-party package and does not know about
  * HQ's lock protocol.
  */
-export const EMBED_LOCK_NAME = 'qmd-reindex-bg.lock';
+const EMBED_LOCK_NAME = 'qmd-reindex-bg.lock';
 export function defaultEmbedLockDependencies(env = process.env) {
     return {
         env,

package/dist/lib/search-index/load-gate.d.ts

@@ -22,10 +22,6 @@ export type LoadGateDependencies = {
     freemem: () => number;
     totalmem: () => number;
 };
-type CpuCounters = {
-    total: number;
-    idle: number;
-};
 export type EmbedLoadDecision = {
     action: 'embed';
     forced: false;
@@ -44,11 +40,8 @@ export declare class LoadGateConfigurationError extends Error {
     constructor(value: string);
 }
 export declare function defaultLoadGateDependencies(env?: NodeJS.ProcessEnv): LoadGateDependencies;
-export declare function parseProcStatAggregate(contents: string): CpuCounters | undefined;
-export declare function cpuBusyPercent(before: CpuCounters, after: CpuCounters): number | undefined;
 /** Sample aggregate CPU busy time over 200 ms, falling back only without /proc/stat. */
 export declare function measureCpuPercent(dependencies: LoadGateDependencies): number;
-export declare function memAvailableFraction(contents: string): number | undefined;
 /** Prefer Linux MemAvailable, because MemFree alone treats reclaimable cache as used memory. */
 export declare function measureMemoryPercent(dependencies: LoadGateDependencies): number;
 export declare function parseLoadThreshold(env: NodeJS.ProcessEnv): number | undefined;
@@ -61,5 +54,4 @@ export declare function loadGateStatePath(home: string): string;
 export declare function checkEmbedLoad(home: string, dependencies: LoadGateDependencies): EmbedLoadDecision;
 /** Reset the starvation counter only after qmd embed has actually returned successfully. */
 export declare function recordSuccessfulEmbed(home: string, dependencies: LoadGateDependencies): void;
-export {};
 //# sourceMappingURL=load-gate.d.ts.map

package/dist/lib/search-index/load-gate.js

@@ -46,7 +46,7 @@ function errorCode(error) {
 function missing(error) {
     return errorCode(error) === 'ENOENT';
 }
-export function parseProcStatAggregate(contents) {
+function parseProcStatAggregate(contents) {
     const line = contents.split('\n').find((candidate) => /^cpu\s+/.test(candidate));
     if (!line)
         return undefined;
@@ -58,7 +58,7 @@ export function parseProcStatAggregate(contents) {
     const idle = values[3] + values[4];
     return total > 0 && Number.isFinite(idle) ? { total, idle } : undefined;
 }
-export function cpuBusyPercent(before, after) {
+function cpuBusyPercent(before, after) {
     const totalDelta = after.total - before.total;
     const idleDelta = after.idle - before.idle;
     if (totalDelta <= 0 || idleDelta < 0)
@@ -117,7 +117,7 @@ export function measureCpuPercent(dependencies) {
         throw new Error('Cannot determine CPU busy time from /proc/stat.');
     return busy;
 }
-export function memAvailableFraction(contents) {
+function memAvailableFraction(contents) {
     const fields = new Map();
     for (const line of contents.split('\n')) {
         const match = /^(MemTotal|MemAvailable):\s+(\d+)\s+kB$/.exec(line.trim());

package/dist/lib/search-index/max-doc-bytes.d.ts

@@ -53,8 +53,6 @@ import * as fs from "node:fs";
  * median and is, in practice, always generated output rather than prose.
  */
 export declare const DEFAULT_INDEX_MAX_DOC_BYTES: number;
-/** Where this module records the ignore entries it generated. */
-export declare function sizeIgnoreRecordPath(hqRoot: string): string;
 /**
  * qmd's config file, resolved the way qmd's own CLI resolves it.
  *
@@ -166,7 +164,7 @@ export declare function findOversizedFiles(collectionPath: string, mask: string,
  */
 export declare function prunablePrefixes(patterns: readonly string[]): string[];
 /** What a single collection ended up ignoring on account of the size cap. */
-export type CappedCollection = {
+type CappedCollection = {
     name: string;
     ignored: string[];
 };
@@ -217,4 +215,5 @@ export type ApplyIndexSizeLimitOptions = {
  * take the lock, so the residual race is documented rather than papered over.
  */
 export declare function applyIndexSizeLimit(hqRoot: string, options?: ApplyIndexSizeLimitOptions): IndexSizeLimitResult;
+export {};
 //# sourceMappingURL=max-doc-bytes.d.ts.map

package/dist/lib/search-index/max-doc-bytes.js

@@ -69,7 +69,7 @@ const EXCLUDED_DIRECTORIES = new Set([
     "build",
 ]);
 /** Where this module records the ignore entries it generated. */
-export function sizeIgnoreRecordPath(hqRoot) {
+function sizeIgnoreRecordPath(hqRoot) {
     return path.join(hqRoot, ".hq", "index-size-ignores.json");
 }
 /** qmd's default index name; the config file and store are both named after it. */

package/package.json

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