@indigoai-us/hq-cli 5.126.0 → 5.127.0

package/dist/lib/lanes/hooks-install.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Install and register the lane-resolving drain hook in a provider home.
+ *
+ * Copying the hook files into `<home>/hooks/` is only half of an install. Each
+ * provider discovers hooks differently, and a file the provider never reads
+ * registers nothing:
+ *
+ * - grok reads every `*.json` under `$GROK_HOME/hooks/`, so the registration
+ *   file in that directory is the registration.
+ * - claude reads `$CLAUDE_CONFIG_DIR/settings.json` and nothing under
+ *   `hooks/`. The registration is merged into the `hooks.PreToolUse` array of
+ *   that file.
+ * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.PreToolUse]]`, gated by
+ *   `[features] hooks = true`). The registration is appended to that file.
+ *
+ * Every registration merge keeps what the operator already has and is a
+ * no-op when the entry is present, because this runs on every spawn.
+ * Never merges into hq-hq-bridge.json / hq-hq-bridge.sh.
+ */
+import type { LaneProvider } from "./types.js";
+export declare const DRAIN_HOOK_BASENAME = "hq-lanes-drain";
+export declare const DRAIN_HOOK_TIMEOUT_SECONDS = 30;
+export declare function lanesHookAssetsDir(): string;
+export declare const DRAIN_HOOK_REGISTRATION_KINDS: readonly ["hooks_dir", "settings_json", "config_toml"];
+export type DrainHookRegistrationKind = (typeof DRAIN_HOOK_REGISTRATION_KINDS)[number];
+export declare const PROVIDER_REGISTRATION_KIND: Record<LaneProvider, DrainHookRegistrationKind>;
+export interface DrainHookRegistration {
+    kind: DrainHookRegistrationKind;
+    /** The file the provider CLI reads the registration from. */
+    path: string;
+    /** The exact command string registered, as the provider will execute it. */
+    command: string;
+    /** True when this call wrote the registration; false when it was already present. */
+    changed: boolean;
+}
+export interface DrainHookInstallResult {
+    provider: LaneProvider;
+    home: string;
+    hooksDir: string;
+    files: string[];
+    registration: DrainHookRegistration;
+}
+export declare function drainHookCommand(shPath: string): string;
+export declare function drainHookShPath(providerHome: string): string;
+export declare function renderDrainHookJson(shPath: string): string;
+export interface MergeResult {
+    text: string;
+    changed: boolean;
+}
+/**
+ * Claude Code: `settings.json` is the one file it reads hooks from. Merge the
+ * drain into `hooks.PreToolUse`, keep every other key and every other hook,
+ * and do nothing when a command hook with this exact command string is
+ * already in the list. No `matcher` means every tool call.
+ */
+export declare function mergeClaudeSettingsHook(existingText: string | null, command: string, settingsPath: string): MergeResult;
+/**
+ * Codex: hooks come from `config.toml` in the codex home. The drain is
+ * appended as one `[[hooks.PreToolUse]]` table and `[features] hooks = true`
+ * is ensured. Edits are textual so comments and unrelated tables are kept
+ * byte for byte; the result is re-parsed and must contain the registration,
+ * otherwise nothing is written.
+ */
+export declare function mergeCodexConfigHook(existingText: string | null, command: string, configPath: string): MergeResult;
+export declare function drainHookRegistrationPath(provider: LaneProvider, providerHome: string): string;
+export interface DrainHookRegistrationProbe {
+    kind: DrainHookRegistrationKind;
+    path: string;
+    command: string;
+    /** True when the provider's own registration file carries the drain command. */
+    registered: boolean;
+    /** For claude and codex: whether the registration file exists at all. */
+    file_present: boolean;
+}
+/**
+ * Read the registration back the way the provider CLI would find it. Reports
+ * the state of the file only; it does not prove the provider honours it.
+ */
+export declare function probeDrainHookRegistration(provider: LaneProvider, providerHome: string): DrainHookRegistrationProbe;
+export declare function installDrainHook(provider: LaneProvider, providerHome: string, assetsDir?: string): DrainHookInstallResult;
+//# sourceMappingURL=hooks-install.d.ts.map

package/dist/lib/lanes/hooks-install.js

@@ -0,0 +1,326 @@
+/**
+ * Install and register the lane-resolving drain hook in a provider home.
+ *
+ * Copying the hook files into `<home>/hooks/` is only half of an install. Each
+ * provider discovers hooks differently, and a file the provider never reads
+ * registers nothing:
+ *
+ * - grok reads every `*.json` under `$GROK_HOME/hooks/`, so the registration
+ *   file in that directory is the registration.
+ * - claude reads `$CLAUDE_CONFIG_DIR/settings.json` and nothing under
+ *   `hooks/`. The registration is merged into the `hooks.PreToolUse` array of
+ *   that file.
+ * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.PreToolUse]]`, gated by
+ *   `[features] hooks = true`). The registration is appended to that file.
+ *
+ * Every registration merge keeps what the operator already has and is a
+ * no-op when the entry is present, because this runs on every spawn.
+ * Never merges into hq-hq-bridge.json / hq-hq-bridge.sh.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseToml, TomlError } from "smol-toml";
+import { LanesError } from "./errors.js";
+import { parseLaneProvider } from "./types.js";
+export const DRAIN_HOOK_BASENAME = "hq-lanes-drain";
+export const DRAIN_HOOK_TIMEOUT_SECONDS = 30;
+export function lanesHookAssetsDir() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../assets/lanes-hooks");
+}
+export const DRAIN_HOOK_REGISTRATION_KINDS = [
+    "hooks_dir",
+    "settings_json",
+    "config_toml",
+];
+export const PROVIDER_REGISTRATION_KIND = {
+    claude: "settings_json",
+    codex: "config_toml",
+    grok: "hooks_dir",
+};
+export function drainHookCommand(shPath) {
+    return `bash ${shPath}`;
+}
+export function drainHookShPath(providerHome) {
+    return path.join(providerHome, "hooks", `${DRAIN_HOOK_BASENAME}.sh`);
+}
+function writeIfChanged(dest, contents, mode) {
+    try {
+        const existing = fs.readFileSync(dest);
+        const next = Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
+        if (existing.equals(next))
+            return false;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
+    const tmp = `${dest}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, contents);
+    if (mode !== undefined)
+        fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, dest);
+    return true;
+}
+function readTextIfExists(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** One `{ hooks: [{ type: "command", command }] }` group carries the drain command. */
+function groupsContainCommand(groups, command) {
+    if (!Array.isArray(groups))
+        return false;
+    return groups.some((group) => {
+        if (!isPlainObject(group) || !Array.isArray(group.hooks))
+            return false;
+        return group.hooks.some((hook) => isPlainObject(hook) && hook.type === "command" && hook.command === command);
+    });
+}
+export function renderDrainHookJson(shPath) {
+    return `${JSON.stringify({
+        hooks: {
+            PreToolUse: [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: drainHookCommand(shPath),
+                            timeout: DRAIN_HOOK_TIMEOUT_SECONDS,
+                        },
+                    ],
+                },
+            ],
+        },
+    }, null, 2)}\n`;
+}
+/**
+ * Claude Code: `settings.json` is the one file it reads hooks from. Merge the
+ * drain into `hooks.PreToolUse`, keep every other key and every other hook,
+ * and do nothing when a command hook with this exact command string is
+ * already in the list. No `matcher` means every tool call.
+ */
+export function mergeClaudeSettingsHook(existingText, command, settingsPath) {
+    let root = {};
+    if (existingText !== null && existingText.trim() !== "") {
+        try {
+            root = JSON.parse(existingText);
+        }
+        catch (err) {
+            throw new LanesError("settings_unparseable", `${settingsPath} is not valid JSON; refusing to rewrite it: ${err instanceof Error ? err.message : String(err)}`, { path: settingsPath });
+        }
+    }
+    if (!isPlainObject(root)) {
+        throw new LanesError("settings_unparseable", `${settingsPath} must hold a JSON object; refusing to rewrite it`, { path: settingsPath });
+    }
+    const hooks = root.hooks === undefined ? {} : root.hooks;
+    if (!isPlainObject(hooks)) {
+        throw new LanesError("settings_unparseable", `${settingsPath} has a non-object "hooks" key; refusing to rewrite it`, { path: settingsPath });
+    }
+    const pre = hooks.PreToolUse === undefined ? [] : hooks.PreToolUse;
+    if (!Array.isArray(pre)) {
+        throw new LanesError("settings_unparseable", `${settingsPath} has a non-array "hooks.PreToolUse"; refusing to rewrite it`, { path: settingsPath });
+    }
+    if (groupsContainCommand(pre, command)) {
+        return { text: existingText ?? "", changed: false };
+    }
+    const nextPre = [
+        ...pre,
+        {
+            hooks: [
+                { type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS },
+            ],
+        },
+    ];
+    const nextRoot = { ...root, hooks: { ...hooks, PreToolUse: nextPre } };
+    return { text: `${JSON.stringify(nextRoot, null, 2)}\n`, changed: true };
+}
+function tomlBasicString(value) {
+    // JSON string escapes are a subset of TOML basic-string escapes for the
+    // characters a filesystem path can contain.
+    return JSON.stringify(value);
+}
+function tomlHooksFeatureEnabled(parsed) {
+    return isPlainObject(parsed.features) && parsed.features.hooks === true;
+}
+function tomlHasCommand(parsed, command) {
+    return isPlainObject(parsed.hooks) && groupsContainCommand(parsed.hooks.PreToolUse, command);
+}
+function parseTomlOrThrow(text, configPath, stage) {
+    let parsed;
+    try {
+        parsed = parseToml(text);
+    }
+    catch (err) {
+        const detail = err instanceof TomlError || err instanceof Error ? err.message : String(err);
+        throw new LanesError("config_toml_unparseable", `${configPath} is not valid TOML (${stage}); refusing to rewrite it: ${detail}`, { path: configPath, stage });
+    }
+    if (!isPlainObject(parsed)) {
+        throw new LanesError("config_toml_unparseable", `${configPath} did not parse to a table (${stage}); refusing to rewrite it`, { path: configPath, stage });
+    }
+    return parsed;
+}
+/**
+ * Set `hooks = true` inside `[features]` by editing lines, so the operator's
+ * comments and layout survive. A `[features]` header that exists gets the
+ * key inserted (or an existing `hooks =` line replaced); a missing header is
+ * appended. An inline `features = { ... }` table cannot be edited this way;
+ * the re-parse post-condition in the caller reports that case.
+ */
+function enableTomlHooksFeature(text) {
+    const lines = text.split("\n");
+    const header = lines.findIndex((line) => /^\s*\[features\]\s*(#.*)?$/.test(line));
+    if (header === -1) {
+        const sep = text === "" || text.endsWith("\n") ? "" : "\n";
+        return `${text}${sep}\n[features]\nhooks = true\n`;
+    }
+    for (let i = header + 1; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (/^\s*\[/.test(line))
+            break;
+        if (/^\s*hooks\s*=/.test(line)) {
+            lines[i] = "hooks = true";
+            return lines.join("\n");
+        }
+    }
+    lines.splice(header + 1, 0, "hooks = true");
+    return lines.join("\n");
+}
+/**
+ * Codex: hooks come from `config.toml` in the codex home. The drain is
+ * appended as one `[[hooks.PreToolUse]]` table and `[features] hooks = true`
+ * is ensured. Edits are textual so comments and unrelated tables are kept
+ * byte for byte; the result is re-parsed and must contain the registration,
+ * otherwise nothing is written.
+ */
+export function mergeCodexConfigHook(existingText, command, configPath) {
+    const original = existingText ?? "";
+    const parsed = parseTomlOrThrow(original, configPath, "before merge");
+    const hasCommand = tomlHasCommand(parsed, command);
+    const featureOn = tomlHooksFeatureEnabled(parsed);
+    if (hasCommand && featureOn) {
+        return { text: original, changed: false };
+    }
+    let text = original;
+    if (!featureOn)
+        text = enableTomlHooksFeature(text);
+    if (!hasCommand) {
+        const sep = text === "" || text.endsWith("\n") ? "" : "\n";
+        text =
+            `${text}${sep}\n` +
+                `# hq lanes: drop-box drain for lane workers (no-op unless HQ_LANE_ID is set)\n` +
+                `[[hooks.PreToolUse]]\n` +
+                `matcher = ".*"\n\n` +
+                `[[hooks.PreToolUse.hooks]]\n` +
+                `type = "command"\n` +
+                `command = ${tomlBasicString(command)}\n` +
+                `timeout = ${DRAIN_HOOK_TIMEOUT_SECONDS}\n`;
+    }
+    const check = parseTomlOrThrow(text, configPath, "after merge");
+    if (!tomlHasCommand(check, command) || !tomlHooksFeatureEnabled(check)) {
+        throw new LanesError("config_toml_merge_failed", `Merged ${configPath} does not carry the drain registration; refusing to write it`, { path: configPath, command });
+    }
+    return { text, changed: true };
+}
+export function drainHookRegistrationPath(provider, providerHome) {
+    switch (PROVIDER_REGISTRATION_KIND[provider]) {
+        case "hooks_dir":
+            return path.join(providerHome, "hooks", `${DRAIN_HOOK_BASENAME}.json`);
+        case "settings_json":
+            return path.join(providerHome, "settings.json");
+        case "config_toml":
+            return path.join(providerHome, "config.toml");
+    }
+}
+/**
+ * Read the registration back the way the provider CLI would find it. Reports
+ * the state of the file only; it does not prove the provider honours it.
+ */
+export function probeDrainHookRegistration(provider, providerHome) {
+    const parsed = parseLaneProvider(provider);
+    const kind = PROVIDER_REGISTRATION_KIND[parsed];
+    const regPath = drainHookRegistrationPath(parsed, providerHome);
+    const command = drainHookCommand(drainHookShPath(providerHome));
+    const text = readTextIfExists(regPath);
+    const base = { kind, path: regPath, command, file_present: text !== null };
+    if (text === null)
+        return { ...base, registered: false };
+    try {
+        if (kind === "config_toml") {
+            const toml = parseToml(text);
+            return {
+                ...base,
+                registered: isPlainObject(toml) && tomlHasCommand(toml, command) && tomlHooksFeatureEnabled(toml),
+            };
+        }
+        const json = JSON.parse(text);
+        return {
+            ...base,
+            registered: isPlainObject(json) &&
+                isPlainObject(json.hooks) &&
+                groupsContainCommand(json.hooks.PreToolUse, command),
+        };
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: registration file ${regPath} is unreadable as ${kind}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return { ...base, registered: false };
+    }
+}
+function registerDrainHook(provider, providerHome, shPath) {
+    const kind = PROVIDER_REGISTRATION_KIND[provider];
+    const regPath = drainHookRegistrationPath(provider, providerHome);
+    const command = drainHookCommand(shPath);
+    if (kind === "hooks_dir") {
+        const changed = writeIfChanged(regPath, renderDrainHookJson(shPath), 0o644);
+        return { kind, path: regPath, command, changed };
+    }
+    const existing = readTextIfExists(regPath);
+    const merged = kind === "settings_json"
+        ? mergeClaudeSettingsHook(existing, command, regPath)
+        : mergeCodexConfigHook(existing, command, regPath);
+    if (!merged.changed) {
+        return { kind, path: regPath, command, changed: false };
+    }
+    const tmp = `${regPath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, merged.text, { mode: 0o600 });
+    try {
+        if (existing !== null)
+            fs.chmodSync(tmp, fs.statSync(regPath).mode & 0o777);
+        fs.renameSync(tmp, regPath);
+    }
+    catch (err) {
+        fs.rmSync(tmp, { force: true });
+        throw err;
+    }
+    return { kind, path: regPath, command, changed: true };
+}
+export function installDrainHook(provider, providerHome, assetsDir = lanesHookAssetsDir()) {
+    const parsed = parseLaneProvider(provider);
+    const hooksDir = path.join(providerHome, "hooks");
+    fs.mkdirSync(hooksDir, { recursive: true });
+    const shDest = drainHookShPath(providerHome);
+    const mjsDest = path.join(hooksDir, `${DRAIN_HOOK_BASENAME}.mjs`);
+    writeIfChanged(shDest, fs.readFileSync(path.join(assetsDir, `${DRAIN_HOOK_BASENAME}.sh`)), 0o755);
+    writeIfChanged(mjsDest, fs.readFileSync(path.join(assetsDir, `${DRAIN_HOOK_BASENAME}.mjs`)), 0o755);
+    const registration = registerDrainHook(parsed, providerHome, shDest);
+    const files = [shDest, mjsDest];
+    if (registration.kind === "hooks_dir") {
+        files.push(registration.path);
+    }
+    else {
+        // A registration-shaped file the provider never reads is how this bug hid.
+        fs.rmSync(path.join(hooksDir, `${DRAIN_HOOK_BASENAME}.json`), { force: true });
+    }
+    return { provider: parsed, home: providerHome, hooksDir, files, registration };
+}
+//# sourceMappingURL=hooks-install.js.map

package/dist/lib/lanes/hq-root.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HQ-root resolution for `hq lanes` only (not a global findHqRoot change).
+ *
+ * `findHqRoot` walks for `.claude` or `workers` and ignores `$HQ_ROOT`. Every
+ * git worktree under `workspace/worktrees/` has its own `.claude`, so a
+ * `lanes` command run from a worktree silently operates on an empty store.
+ * The drain hook, watcher, and reconcile timer already read `$HQ_ROOT`.
+ *
+ * Precedence: `$HQ_ROOT` → `$CLAUDE_PROJECT_DIR` → walk up with `isHqRoot`
+ * (`companies/` plus `.claude`|`core`|`personal`). A `.claude`-only worktree
+ * is never a match. Missing both an explicit root and a real HQ tree is an
+ * error — never an empty successful list against the wrong directory.
+ */
+export interface LanesHqRootOpts {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}
+export declare function resolveLanesHqRoot(opts?: LanesHqRootOpts): string;
+//# sourceMappingURL=hq-root.d.ts.map

package/dist/lib/lanes/hq-root.js

@@ -0,0 +1,28 @@
+/**
+ * HQ-root resolution for `hq lanes` only (not a global findHqRoot change).
+ *
+ * `findHqRoot` walks for `.claude` or `workers` and ignores `$HQ_ROOT`. Every
+ * git worktree under `workspace/worktrees/` has its own `.claude`, so a
+ * `lanes` command run from a worktree silently operates on an empty store.
+ * The drain hook, watcher, and reconcile timer already read `$HQ_ROOT`.
+ *
+ * Precedence: `$HQ_ROOT` → `$CLAUDE_PROJECT_DIR` → walk up with `isHqRoot`
+ * (`companies/` plus `.claude`|`core`|`personal`). A `.claude`-only worktree
+ * is never a match. Missing both an explicit root and a real HQ tree is an
+ * error — never an empty successful list against the wrong directory.
+ */
+import { resolveLiveRoot } from "../../utils/hq-roots.js";
+import { LanesError } from "./errors.js";
+export function resolveLanesHqRoot(opts = {}) {
+    try {
+        return resolveLiveRoot({
+            env: opts.env ?? process.env,
+            cwd: opts.cwd,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new LanesError("hq_root_unresolved", message, {});
+    }
+}
+//# sourceMappingURL=hq-root.js.map

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

@@ -4,16 +4,46 @@
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
 export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
-export { DEFAULT_ACCOUNT_HOMES, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, writeLanesConfig, } from "./config.js";
+export { DEFAULT_ACCOUNT_HOMES, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";
-export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, updateLane, updateQuestion, } from "./store.js";
+export { resolveLanesHqRoot } from "./hq-root.js";
+export type { LanesHqRootOpts } from "./hq-root.js";
+export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
+export type { OutpostDispatchResult, OutpostPickupPayload, } from "./outpost-dispatch.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, updateLane, updateQuestion, } from "./store.js";
 export type { StoreDeps } from "./store.js";
+export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
+export type { MachineIdentity, MachineIdentityDeps } from "./machine-identity.js";
+export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";
+export type { DetachProof, DetachedSpawnOptions, KillProcessFn, PidLivenessDecision, PidLivenessProbe, PidRecord, ProveDetachedDeps, ProveDetachedFn, SpawnLaneDeps, SpawnProcessFn, SpawnTerminalReason, StopLaneDeps, StopLaneResult, } from "./spawn.js";
+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 type { TerminalClassification, WatcherDecisionEvent, WatcherLoopDeps, WatcherSignal, WatcherSignalKind, WatcherTickInput, WatcherTickResult, } from "./watcher.js";
+export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQuestionIds, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
+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, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
-export { AUTH_JSON_NAME, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, listAccountStatuses, resolveAccount, } from "./accounts.js";
-export type { AccountStatus, ResolvedAccount } 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, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } 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";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export type { ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
+export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
+export type { ReconcileInstallOpts, ReconcileInstallResult, RunCommand, RunCommandResult, } from "./reconcile-install.js";
 export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
 export type { RegistryWorkerEntry, ResolvedLaneWorker, WorkerTenancy, WorkerYaml, } from "./registry.js";
+export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
+export type { QuestionBody, RaiseLaneQuestionInput } from "./questions.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export type { DeliveryLane, LaneDeliveryMechanism, LaunchPlan, LaunchTrigger, LaunchTriggerKind, ResumableLaneState, ResumeCommandState, SessionIdAbsentReason, WorkerRunResult, } from "./delivery.js";
+export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
+export type { DrainDeps, DrainHookResult, DropboxMessage, ToolActivityRecord, } from "./dropbox.js";
+export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";
+export type { DrainHookInstallResult, DrainHookRegistration, DrainHookRegistrationKind, DrainHookRegistrationProbe, MergeResult, } from "./hooks-install.js";
+export { EFFORT_SOURCES, PROVIDER_EFFORT_LEVELS, appendEffortFlag, defaultEffortForModel, parseCliEffort, parseConfigEffort, resolveLaneEffort, } from "./effort.js";
+export type { EffortSource, ResolvedEffort } from "./effort.js";
+export { COMPACTION_MECHANISM, COMPACTION_PROMPT, COMPACTION_TIMEOUT_MS, compactLaneSession, compactionAfterUsage, compactionDue, defaultRunCompaction, findSessionTranscript, probeCompactBoundaries, } from "./compaction.js";
+export type { CompactBoundaryProbe, CompactionDecision, CompactLaneSessionInput, RunCompactionFn, } from "./compaction.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/lanes/index.js

@@ -3,10 +3,25 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export { DEFAULT_ACCOUNT_HOMES, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, writeLanesConfig, } from "./config.js";
-export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, updateLane, updateQuestion, } from "./store.js";
+export { DEFAULT_ACCOUNT_HOMES, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, writeLanesConfig, } from "./config.js";
+export { resolveLanesHqRoot } from "./hq-root.js";
+export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, updateLane, updateQuestion, } from "./store.js";
+export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
+export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";
+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, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
-export { AUTH_JSON_NAME, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, listAccountStatuses, resolveAccount, } 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, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, 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";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
+export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
+export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";
+export { EFFORT_SOURCES, PROVIDER_EFFORT_LEVELS, appendEffortFlag, defaultEffortForModel, parseCliEffort, parseConfigEffort, resolveLaneEffort, } from "./effort.js";
+export { COMPACTION_MECHANISM, COMPACTION_PROMPT, COMPACTION_TIMEOUT_MS, compactLaneSession, compactionAfterUsage, compactionDue, defaultRunCompaction, findSessionTranscript, probeCompactBoundaries, } from "./compaction.js";
 //# sourceMappingURL=index.js.map

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

@@ -66,7 +66,13 @@ export declare function readLivenessIndex(hqRoot: string, deps?: LivenessDeps):
  * Return the compact index, rebuilding from the spool when missing or stale.
  * Never walks workspace/sessions/.
  */
-export declare function loadLivenessIndex(hqRoot: string, spoolPath?: string, deps?: LivenessDeps): LivenessIndex;
+export declare function loadLivenessIndex(hqRoot: string, spoolPath?: string, deps?: LivenessDeps, persist?: boolean): LivenessIndex;
+/**
+ * Spec §9: a session is also `live` when the mesh daemon reports presence
+ * connected, not only from the spool. Missing state file → not connected.
+ * Unreadable or corrupt state is an error (unknown must not resolve to healthy).
+ */
+export declare function readDaemonPresenceConnected(deps?: LivenessDeps): boolean;
 export declare function sessionLiveness(hqRoot: string, sessionId: string, opts?: {
     spoolPath?: string;
     nowMs?: number;