@indigoai-us/hq-cli 5.345.147 → 5.345.149

package/dist/lib/lanes/admission-host.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
+import { observeLocalHostIdentity } from "./local-host-identity.js";
 export const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
 export const OUTPOST_DIR = "/etc/outpost";
 export function readOutpostIdentity(existsSync = (p) => fs.existsSync(p), readFileSync = (p) => fs.readFileSync(p, "utf8")) {
@@ -25,9 +26,15 @@ export function readOutpostIdentity(existsSync = (p) => fs.existsSync(p), readFi
 }
 export function resolveAdmissionHost(deps = {}) {
     const identity = deps.readOutpostIdentity?.() ?? readOutpostIdentity(deps.existsSync, deps.readFileSync);
+    const hostname = (deps.hostname ?? os.hostname)();
+    const observed = observeLocalHostIdentity({
+        homedir: deps.homedir?.() ?? os.homedir(),
+        hostname,
+    });
     return {
-        hostname: (deps.hostname ?? os.hostname)(),
+        hostname,
         outpostId: identity.kind === "id" ? identity.id : null,
+        ...(observed ? { machineId: observed.id, aliases: observed.aliases } : {}),
     };
 }
 /** `primary` names the controller registry unless the caller is a different Outpost. */

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

@@ -3,6 +3,10 @@ import { type LaneRecord, type LanesConfig } from "./types.js";
 export interface AdmissionHost {
     hostname: string;
     outpostId: string | null;
+    /** Stable id from ~/.hq/lane-host.json, when this process has read one. */
+    machineId?: string;
+    /** Hostnames this machine has already used. */
+    aliases?: readonly string[];
 }
 export type AdmissionCapReason = "provider_cap" | "account_cap" | "profile_cap";
 export declare const ADMISSION_LOCK_STALE_MS = 30000;

package/dist/lib/lanes/admission.js

@@ -2,8 +2,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { accountMaxRunning } from "./config.js";
 import { LanesError } from "./errors.js";
+import { localHostIdsReferToSameMachine } from "./local-host-identity.js";
 import { quotaBlockFor } from "./quota.js";
-import { isTerminalLaneState } from "./types.js";
+import { isSubagentLane, isTerminalLaneState } from "./types.js";
 export const ADMISSION_LOCK_STALE_MS = 30_000;
 const ADMISSION_LOCK_TIMEOUT_MS = 5_000;
 const ADMISSION_RESERVATION_GRACE_MS = 30_000;
@@ -117,7 +118,7 @@ export function laneRunsOnHost(lane, host) {
     if (host.outpostId && lane.host.kind === "outpost") {
         return lane.host.id === host.outpostId;
     }
-    return lane.host.kind === "local" && lane.host.id === host.hostname;
+    return lane.host.kind === "local" && localHostIdsReferToSameMachine(lane.host.id, host);
 }
 export function compareLaneQueueOrder(a, b) {
     if (b.priority !== a.priority)
@@ -188,6 +189,9 @@ export function laneOccupiesRunningSlot(lane, nowMs = Date.now()) {
     // count as a second owner of the slot that blocked it.
     if (lane.state === "queued" && lane.queued_reason === "account_cap")
         return false;
+    // A subagent lane runs inside its senior session, not in an HQ provider slot.
+    if (isSubagentLane(lane))
+        return false;
     return lane.state === "running" ||
         hasActiveAdmissionReservation(lane, nowMs) ||
         hasActivePendingResume(lane, nowMs);

package/dist/lib/lanes/envelope-repair-dispatch.d.ts

@@ -17,6 +17,11 @@ export interface EnvelopeRepairDispatchDeps {
     env?: NodeJS.ProcessEnv;
     spawnSync?: (command: string, args: string[], options: EnvelopeRepairDispatchOptions) => EnvelopeRepairDispatchResult;
 }
+/**
+ * True for the detached lane runner scripts. They are not the hq CLI: running
+ * one with `lanes ...` argv starts that runner for a lane named "lanes".
+ */
+export declare function isLaneRunnerEntry(entry: string): boolean;
 /**
  * Dispatch repair into the currently installed CLI. A watcher can stay alive
  * across upgrades, so repair must not call its in-memory spawn implementation.

package/dist/lib/lanes/envelope-repair-dispatch.js

@@ -1,6 +1,14 @@
 import { spawnSync as nodeSpawnSync } from "node:child_process";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
+const LANE_RUNNER_ENTRY_NAMES = new Set(["watcher-main", "worker-process", "remote-control-lane"]);
+/**
+ * True for the detached lane runner scripts. They are not the hq CLI: running
+ * one with `lanes ...` argv starts that runner for a lane named "lanes".
+ */
+export function isLaneRunnerEntry(entry) {
+    return LANE_RUNNER_ENTRY_NAMES.has(path.basename(entry).replace(/\.[cm]?[jt]s$/, ""));
+}
 /**
  * Dispatch repair into the currently installed CLI. A watcher can stay alive
  * across upgrades, so repair must not call its in-memory spawn implementation.
@@ -28,7 +36,10 @@ export function spawnEnvelopeRepairViaCurrentCli(hqRoot, lane, input, deps = {})
     });
     const env = deps.env ?? process.env;
     const cliEntry = env.HQ_LANE_CLI_ENTRY?.trim();
-    if (!cliEntry || !path.isAbsolute(cliEntry) || path.resolve(cliEntry) !== cliEntry) {
+    if (!cliEntry ||
+        !path.isAbsolute(cliEntry) ||
+        path.resolve(cliEntry) !== cliEntry ||
+        isLaneRunnerEntry(cliEntry)) {
         throw new LanesError("repair_cli_entry_invalid", "Lane watcher has no valid absolute hq CLI entrypoint for envelope repair", { lane_id: lane.lane_id });
     }
     const result = run(process.execPath, [cliEntry, "lanes", "_spawn-envelope-repair"], {

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

@@ -36,8 +36,8 @@ export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQu
 export type { EnvelopeRepairDecision, LatestEnvelopeFile } from "./watcher.js";
 export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
 export type { CreateLaneMeshOptions, LaneMesh, LaneMeshEvent, WireEventKind, WireThreadEvent, } from "./mesh-events.js";
-export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, parseVmStatAvailableMb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
-export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
+export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, MEMORY_PRESSURE_SYSCTLS, SYSCTL_BIN, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, formatMemoryHoldMessage, isCpuCheckEnabled, parseMemAvailableKb, parseMemoryPressureSysctl, parseVmStatAvailableMb, readAvailableMemMb, readMemorySignal, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
+export type { CpuTimes, MemoryHold, MemoryPressureLevel, MemorySignal, MemorySignalSource, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
 export type { EffectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";

package/dist/lib/lanes/index.js

@@ -20,7 +20,7 @@ export { PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TE
 export { SILENCE_MS, WATCHER_DECISION_EVENTS, WATCHER_OUT_MAX_BYTES, WATCHER_POLL_MS, WATCHER_SIGNAL_KINDS, appendCappedLog, appendWatcherSignal, applyTerminalToLane, classifyLaneExit, clearLaneStalled, isPidAlive, laneIdentityFromRecord, markLaneStalled, notifySlotFreed, parseWatcherSignalKind, readLatestEnvelope, runWatcherLoop, stalledReason, tickWatcher, watcherEventsPath, watcherLastSignalPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQuestionIds, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
 export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
-export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, parseVmStatAvailableMb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
+export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, MEMORY_PRESSURE_SYSCTLS, SYSCTL_BIN, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, formatMemoryHoldMessage, isCpuCheckEnabled, parseMemAvailableKb, parseMemoryPressureSysctl, parseVmStatAvailableMb, readAvailableMemMb, readMemorySignal, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";

package/dist/lib/lanes/keep-alive.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { dropboxInboxHasMessages } from "./dropbox.js";
 import { appendCappedHistory, listQuestionIds, readQuestion, retryUpdateLane } from "./store.js";
-import { isTerminalLaneState, isIsoDateTime, } from "./types.js";
+import { isSubagentLane, isTerminalLaneState, isIsoDateTime, } from "./types.js";
 export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS = 24 * 60 * 60 * 1000;
@@ -24,6 +24,9 @@ export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
 const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
 /** Shared resume transition for terminal gate follow-ups. */
 export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
+    // HQ holds no provider session for a subagent lane, so it can never resume one.
+    if (isSubagentLane(current))
+        return { lane: current, resumeQueued: false, resumeSkippedReason: "no_provider_session" };
     if (options.mergeExisting && current.pending_resume !== undefined) {
         return {
             lane: {

package/dist/lib/lanes/local-host-identity.d.ts

@@ -0,0 +1,40 @@
+export declare const LANE_HOST_SCHEMA = "hq-lane-host.v1";
+export declare const LANE_HOST_FILENAME = "lane-host.json";
+export interface LocalHostIdentity {
+    schema_version: typeof LANE_HOST_SCHEMA;
+    id: string;
+    aliases: string[];
+    /** Hardware UUID, `/etc/machine-id`, or Windows MachineGuid. Absent on older files. */
+    hardware_id?: string;
+}
+export interface LocalHostMatch {
+    hostname: string;
+    machineId?: string;
+    aliases?: readonly string[];
+}
+export declare function laneHostIdentityPath(homedir: string): string;
+/** True when `recordedId` is this machine's stable id, current hostname, or a known earlier hostname. */
+export declare function localHostIdsReferToSameMachine(recordedId: string, host: LocalHostMatch): boolean;
+/**
+ * Read the stable id, creating it once. A lost race re-reads the winner
+ * instead of minting a second id that would strand the lanes just created.
+ * A stored hardware id that does not match this machine mints a new id so a
+ * cloned home directory does not keep the source machine's id.
+ */
+export declare function resolveLocalHostIdentity(input: {
+    homedir: string;
+    hostname: string;
+    createId?: () => string;
+    readHardwareId?: () => string | null;
+}): LocalHostIdentity;
+/**
+ * Read an existing identity. Does not create the file, record a hostname,
+ * or replace an id. A hardware mismatch returns null so a cloned id is not
+ * treated as this machine.
+ */
+export declare function observeLocalHostIdentity(input: {
+    homedir: string;
+    hostname: string;
+    readHardwareId?: () => string | null;
+}): LocalHostIdentity | null;
+//# sourceMappingURL=local-host-identity.d.ts.map

package/dist/lib/lanes/local-host-identity.js

@@ -0,0 +1,314 @@
+import { spawnSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+export const LANE_HOST_SCHEMA = "hq-lane-host.v1";
+export const LANE_HOST_FILENAME = "lane-host.json";
+const MAX_ALIASES = 32;
+/**
+ * mDNS and DHCP rename a machine by swapping only this suffix
+ * (`Mac.localdomain` → `Mac.lan`). The label before the first dot must match,
+ * and the entire remainder must be one of these. `ec2.internal` and public
+ * DNS names are not in the set.
+ *
+ * A lane stamped with the bare label (`Mac`) matches a current or recorded
+ * name whose first label is that same word (`Mac.lan`). Two different
+ * machines that share a short label and a lane store can still collide for
+ * an old hostname-stamped lane. New lanes record the stable id below, and a
+ * copied home directory remints that id when the hardware id differs.
+ */
+const LINK_LOCAL_SUFFIXES = new Set(["local", "localdomain", "lan", "home"]);
+const HOST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+export function laneHostIdentityPath(homedir) {
+    return path.join(homedir, ".hq", LANE_HOST_FILENAME);
+}
+function corruptIdentity(file, problem, details = {}) {
+    return new LanesError("host_identity_corrupt", `${problem} The lane host file is ${file}. Restore that file, or delete it if no lane's host id came from it, then retry. Do not edit a lane's host.id by hand.`, { path: file, ...details });
+}
+function assertHostId(file, id) {
+    const trimmed = id.trim();
+    if (!HOST_ID_PATTERN.test(trimmed)) {
+        throw corruptIdentity(file, `Lane host id ${JSON.stringify(id)} is not a stable host id.`);
+    }
+    return trimmed;
+}
+function linkLocalLabel(name) {
+    const trimmed = name.trim();
+    const dot = trimmed.indexOf(".");
+    if (dot <= 0)
+        return null;
+    const suffix = trimmed.slice(dot + 1);
+    if (!LINK_LOCAL_SUFFIXES.has(suffix))
+        return null;
+    const label = trimmed.slice(0, dot);
+    return label.length > 0 ? label : null;
+}
+function linkLocalSameMachine(recorded, current) {
+    const recordedLabel = linkLocalLabel(recorded);
+    const currentLabel = linkLocalLabel(current);
+    return recordedLabel !== null && recordedLabel === currentLabel;
+}
+function firstLabel(name) {
+    const trimmed = name.trim();
+    const dot = trimmed.indexOf(".");
+    return dot === -1 ? trimmed : trimmed.slice(0, dot);
+}
+/** A bare stamp (`Mac`) and a longer name with that first label (`Mac.lan`) are the same machine. */
+function bareLabelSameMachine(recorded, current) {
+    const left = recorded.trim();
+    const right = current.trim();
+    if (!left || !right || left === right)
+        return false;
+    const leftBare = !left.includes(".");
+    const rightBare = !right.includes(".");
+    if (leftBare === rightBare)
+        return false;
+    const bare = leftBare ? left : right;
+    const dotted = leftBare ? right : left;
+    return bare === firstLabel(dotted);
+}
+function sameMachineName(recorded, current) {
+    return linkLocalSameMachine(recorded, current) || bareLabelSameMachine(recorded, current);
+}
+/** True when `recordedId` is this machine's stable id, current hostname, or a known earlier hostname. */
+export function localHostIdsReferToSameMachine(recordedId, host) {
+    const recorded = recordedId.trim();
+    if (!recorded)
+        return false;
+    const hostname = host.hostname.trim();
+    if (hostname !== "" && recorded === hostname)
+        return true;
+    const machineId = host.machineId?.trim();
+    if (machineId && recorded === machineId)
+        return true;
+    const aliases = host.aliases ?? [];
+    if (aliases.some((alias) => alias.trim() === recorded))
+        return true;
+    if (hostname !== "" && sameMachineName(recorded, hostname))
+        return true;
+    return aliases.some((alias) => sameMachineName(recorded, alias));
+}
+function cleanedAliases(file, aliases) {
+    if (!Array.isArray(aliases)) {
+        throw corruptIdentity(file, "Lane host identity aliases must be a list.");
+    }
+    const cleaned = [];
+    for (const alias of aliases) {
+        if (typeof alias !== "string") {
+            throw corruptIdentity(file, "Lane host identity aliases must be strings.");
+        }
+        const trimmed = alias.trim();
+        if (!trimmed || cleaned.includes(trimmed))
+            continue;
+        cleaned.push(trimmed);
+    }
+    return cleaned;
+}
+function withHostname(aliases, hostname) {
+    const host = hostname.trim();
+    const next = [...aliases];
+    if (host && !next.includes(host))
+        next.push(host);
+    if (next.length <= MAX_ALIASES)
+        return next;
+    const kept = next.slice(next.length - MAX_ALIASES);
+    if (host && !kept.includes(host)) {
+        kept.shift();
+        kept.push(host);
+    }
+    return kept;
+}
+function normalizeHardwareId(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > 128 || /\s/.test(trimmed))
+        return null;
+    return trimmed;
+}
+function parseIdentity(file, raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw corruptIdentity(file, "Lane host identity file is not valid JSON.");
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw corruptIdentity(file, "Lane host identity file is not an object.");
+    }
+    const record = parsed;
+    if (record.schema_version !== LANE_HOST_SCHEMA) {
+        throw corruptIdentity(file, "Lane host identity file has the wrong schema.", {
+            schema_version: record.schema_version ?? null,
+        });
+    }
+    if (typeof record.id !== "string") {
+        throw corruptIdentity(file, "Lane host identity file is missing an id.");
+    }
+    let hardwareId;
+    if (record.hardware_id !== undefined) {
+        const normalized = normalizeHardwareId(record.hardware_id);
+        if (!normalized) {
+            throw corruptIdentity(file, "Lane host identity hardware id is not usable.");
+        }
+        hardwareId = normalized;
+    }
+    return {
+        schema_version: LANE_HOST_SCHEMA,
+        id: assertHostId(file, record.id),
+        aliases: cleanedAliases(file, record.aliases),
+        ...(hardwareId ? { hardware_id: hardwareId } : {}),
+    };
+}
+function serialize(identity) {
+    return `${JSON.stringify(identity, null, 2)}\n`;
+}
+function readIdentityFile(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    return parseIdentity(file, raw);
+}
+function sameAliases(left, right) {
+    return left.length === right.length && left.every((alias, index) => alias === right[index]);
+}
+function writeIdentity(file, identity) {
+    const dir = path.dirname(file);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${LANE_HOST_FILENAME}.${crypto.randomBytes(6).toString("hex")}.tmp`);
+    fs.writeFileSync(tmp, serialize(identity));
+    fs.renameSync(tmp, file);
+}
+function readTextFile(file) {
+    try {
+        const text = fs.readFileSync(file, "utf8").trim();
+        return text || null;
+    }
+    catch {
+        return null;
+    }
+}
+let cachedHardwareId;
+function readPlatformHardwareId() {
+    if (process.platform === "darwin") {
+        const result = spawnSync("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+            encoding: "utf8",
+            timeout: 2000,
+        });
+        if (result.error || result.status !== 0)
+            return null;
+        const match = (result.stdout ?? "").match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+        return match?.[1]?.trim() || null;
+    }
+    if (process.platform === "linux") {
+        return readTextFile("/etc/machine-id") ?? readTextFile("/var/lib/dbus/machine-id");
+    }
+    if (process.platform === "win32") {
+        const result = spawnSync("reg", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"], {
+            encoding: "utf8",
+            timeout: 2000,
+        });
+        if (result.error || result.status !== 0)
+            return null;
+        const match = (result.stdout ?? "").match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+        return match?.[1]?.trim() || null;
+    }
+    return null;
+}
+function currentHardwareId(readHardwareId) {
+    if (readHardwareId)
+        return normalizeHardwareId(safeRead(readHardwareId));
+    if (cachedHardwareId !== undefined)
+        return cachedHardwareId;
+    cachedHardwareId = normalizeHardwareId(safeRead(readPlatformHardwareId));
+    return cachedHardwareId;
+}
+function safeRead(read) {
+    try {
+        return read();
+    }
+    catch {
+        return null;
+    }
+}
+function mintIdentity(file, hostname, hardwareId, createId) {
+    return {
+        schema_version: LANE_HOST_SCHEMA,
+        id: assertHostId(file, (createId ?? (() => crypto.randomUUID()))()),
+        aliases: hostname ? [hostname] : [],
+        ...(hardwareId ? { hardware_id: hardwareId } : {}),
+    };
+}
+function alignStoredIdentity(file, existing, hostname, hardwareId, createId) {
+    if (hardwareId && existing.hardware_id && existing.hardware_id !== hardwareId) {
+        const reminted = mintIdentity(file, hostname, hardwareId, createId);
+        writeIdentity(file, reminted);
+        return reminted;
+    }
+    const aliases = withHostname(existing.aliases, hostname);
+    const next = {
+        ...existing,
+        aliases,
+        ...(hardwareId && !existing.hardware_id ? { hardware_id: hardwareId } : {}),
+    };
+    if (next.hardware_id === existing.hardware_id && sameAliases(aliases, existing.aliases))
+        return existing;
+    writeIdentity(file, next);
+    return next;
+}
+/**
+ * Read the stable id, creating it once. A lost race re-reads the winner
+ * instead of minting a second id that would strand the lanes just created.
+ * A stored hardware id that does not match this machine mints a new id so a
+ * cloned home directory does not keep the source machine's id.
+ */
+export function resolveLocalHostIdentity(input) {
+    const hostname = input.hostname.trim();
+    if (!hostname) {
+        throw new LanesError("host_identity_unknown", "Cannot resolve this host for lane placement", {});
+    }
+    const file = laneHostIdentityPath(input.homedir);
+    const hardwareId = currentHardwareId(input.readHardwareId);
+    const existing = readIdentityFile(file);
+    if (existing)
+        return alignStoredIdentity(file, existing, hostname, hardwareId, input.createId);
+    const created = mintIdentity(file, hostname, hardwareId, input.createId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    try {
+        fs.writeFileSync(file, serialize(created), { flag: "wx" });
+    }
+    catch (err) {
+        if (err.code !== "EEXIST")
+            throw err;
+        const raced = readIdentityFile(file);
+        if (!raced) {
+            throw corruptIdentity(file, "Lane host identity file disappeared while it was created.");
+        }
+        return alignStoredIdentity(file, raced, hostname, hardwareId, input.createId);
+    }
+    return created;
+}
+/**
+ * Read an existing identity. Does not create the file, record a hostname,
+ * or replace an id. A hardware mismatch returns null so a cloned id is not
+ * treated as this machine.
+ */
+export function observeLocalHostIdentity(input) {
+    const file = laneHostIdentityPath(input.homedir);
+    const existing = readIdentityFile(file);
+    if (!existing)
+        return null;
+    const hardwareId = currentHardwareId(input.readHardwareId);
+    if (hardwareId && existing.hardware_id && existing.hardware_id !== hardwareId)
+        return null;
+    return existing;
+}
+//# sourceMappingURL=local-host-identity.js.map

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

@@ -1,4 +1,4 @@
-import type { LaneRecord } from "./types.js";
+import { type LaneRecord } from "./types.js";
 import { type LegacyPoolFinding } from "./legacy-pool.js";
 export declare const DEFAULT_REAP_MIN_AGE_MINUTES = 120;
 export declare const REAP_SINGLE_FLIGHT_LOCK_STALE_MS: number;

package/dist/lib/lanes/reaper.js

@@ -8,6 +8,7 @@ import { laneRunsOnHost } from "./admission.js";
 import { laneRunDir, isPidRecordAlive, readPidRecord, readProcStarttime } from "./spawn.js";
 import { readAllLanes, readLane } from "./store.js";
 import { LanesError } from "./errors.js";
+import { isSubagentLane } from "./types.js";
 import { findLegacyPoolLanes, stopLegacyPoolLane } from "./legacy-pool.js";
 export const DEFAULT_REAP_MIN_AGE_MINUTES = 120;
 export const REAP_SINGLE_FLIGHT_LOCK_STALE_MS = 60 * 60 * 1000;
@@ -220,6 +221,12 @@ export async function classifyLocalLanes(root, now, minAgeMinutes, deps = {}) {
         const ageMs = now.getTime() - Date.parse(lane.created_at);
         const age = Number.isFinite(ageMs) ? Math.max(0, Math.floor(ageMs / 60_000)) : 0;
         const finding = { lane_id: lane.lane_id, orphaned: false, reason: "not_a_candidate", age_minutes: age };
+        if (isSubagentLane(lane)) {
+            // A subagent lane has no process tree to reap; its senior session owns it.
+            finding.reason = "subagent_runner";
+            result.push(finding);
+            continue;
+        }
         const laneRunDirectory = laneRunDir(root, lane.lane_id);
         const workerRecord = readPidRecord(path.join(laneRunDirectory, "worker.pid"));
         const watcherRecord = readPidRecord(path.join(laneRunDirectory, "watcher.pid"));

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

@@ -87,6 +87,10 @@ export interface ReconcileSummary {
 export interface ReconcileHost {
     hostname: string;
     outpostId: string | null;
+    /** Stable id from ~/.hq/lane-host.json, when this process has read one. */
+    machineId?: string;
+    /** Hostnames this machine has already used. */
+    aliases?: readonly string[];
 }
 export interface ReconcileDeps {
     now: () => Date;

package/dist/lib/lanes/reconcile.js

@@ -22,7 +22,7 @@ import { terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./gr
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, nextEnvelopePath, readPidRecord, readProcStarttime, readSpawnManifest, markSpawnFailure, stopLaneProcesses, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, retryUpdateLane, 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 { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readMemorySignal, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "./registry-flag.js";
 import { LANE_BLOCKED_ESCALATION_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, LANE_ENVELOPE_REPAIR_GUIDANCE_FLAG, } from "./flag-keys.js";
 import { checkLaneDiskSpace, configuredCodexRolloutHomes, laneDiskAccount, retainCodexRollouts } from "./disk-guard.js";
@@ -32,7 +32,7 @@ import { monitorSessionDir } from "../monitor.js";
 import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
 import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, dueKeepAliveNextCheckMs, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { isFailedQuotaKeepAliveLane, providerSupportsSessionResume } from "./delivery.js";
-import { LANE_PROVIDERS, isIsoDateTime, isTerminalLaneState } from "./types.js";
+import { LANE_PROVIDERS, isIsoDateTime, isSubagentLane, isTerminalLaneState } from "./types.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { deliverQuotaNotice, quotaLaneNotice } from "./quota-notice.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -1586,6 +1586,10 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
     for (const lane of lanes) {
         if (lane.state !== "running")
             continue;
+        // No HQ process backs a subagent lane, so a missing pid is not a dead
+        // worker. Its senior session reports progress and the final envelope.
+        if (isSubagentLane(lane))
+            continue;
         const local = laneRunsHere(lane, deps.host);
         if (local) {
             const runDir = laneRunDir(hqRoot, lane.lane_id);
@@ -2097,11 +2101,12 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
     const busy = deps.cpuBusyFraction !== undefined
         ? deps.cpuBusyFraction
         : await resolveCpuBusyFraction(throttleDeps);
-    const availableMemMb = readAvailableMemMb(throttleDeps);
+    const memory = readMemorySignal(throttleDeps);
     const nowMs = now.getTime();
     const decision = evaluateThrottle({
         busy,
-        availableMemMb,
+        availableMemMb: memory?.available_mb ?? null,
+        memory,
         cpuCheckEnabled: isCpuCheckEnabled(throttleDeps.env),
         state: throttleState,
         throttle: config.throttle,
@@ -3570,11 +3575,14 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
     if (deps.dryRun) {
         const loaded = readThrottleState(throttleStatePath(hqRoot), throttleDeps);
         const state = loaded === "missing" ? emptyThrottleState() : loaded;
+        const busy = deps.cpuBusyFraction !== undefined
+            ? deps.cpuBusyFraction
+            : deps.cpuObservation?.busy ?? await resolveCpuBusyFraction(throttleDeps);
+        const memory = readMemorySignal(throttleDeps);
         throttleDecision = evaluateThrottle({
-            busy: deps.cpuBusyFraction !== undefined
-                ? deps.cpuBusyFraction
-                : deps.cpuObservation?.busy ?? await resolveCpuBusyFraction(throttleDeps),
-            availableMemMb: readAvailableMemMb(throttleDeps),
+            busy,
+            availableMemMb: memory?.available_mb ?? null,
+            memory,
             cpuCheckEnabled: isCpuCheckEnabled(throttleDeps.env),
             state,
             throttle: config.throttle,

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

@@ -190,6 +190,17 @@ export declare const STANDING_AUTHORIZATION: string;
  * turn while it was still running; nothing in the brief said not to.
  */
 export declare const FOREGROUND_ONLY_RULE: string;
+/**
+ * Temp-home rule carried in every composed brief, for every provider. Lanes
+ * that ran tests under a raw mktemp HOME re-downloaded the Rust toolchain and
+ * pnpm store (1.4-1.8 GB) per run and never deleted the folder; on 2026-10-18
+ * that refilled about 45 GB of disk.
+ *
+ * The wrapper path is absolute because a worker's cwd is often a repo, not
+ * the HQ root. The wrapper ships in hq-core (hq-core-staging#1420); until an
+ * install has it, the command fails with "No such file".
+ */
+export declare function tempHomeRule(hqRoot: string): string;
 /**
  * The answers as written by the reconcile pass (`answered-questions.json`),
  * reduced to id + choice. A malformed file reads as no inline answers; the
@@ -288,6 +299,15 @@ export declare function markSpawnFailure(hqRoot: string, laneId: string, reasonR
  * Must run before the worker is spawned.
  */
 export declare function refuseOutpostSelfTarget(hqRoot: string, lane: LaneRecord, deps: SpawnLaneDeps): void;
+/**
+ * The hq CLI entry a watcher runs internal `hq lanes` commands through. A
+ * watcher admits queued lanes and retries accounts from its own process,
+ * where process.argv[1] is watcher-main.js rather than the CLI. Recording that
+ * path made envelope repair run `watcher-main.js lanes _spawn-envelope-repair`,
+ * which started a watcher for a lane named "lanes". A runner script in argv[1]
+ * is replaced by the CLI entry that ships beside this module.
+ */
+export declare function resolveHqCliEntry(override: string | undefined, argvEntry?: string | undefined, existsSync?: (file: string) => boolean): string | undefined;
 /** Arm (or re-arm) the detached per-lane watcher. */
 export declare function armLaneWatcher(hqRoot: string, laneId: string, deps?: SpawnLaneDeps): number;
 export interface SpawnManifestFile {