@indigoai-us/hq-cli 5.125.0 → 5.127.0

package/dist/lib/lanes/accounts.js

@@ -0,0 +1,318 @@
+/**
+ * Provider account resolution (spec §5.5).
+ *
+ * Naming an account and omitting one mean different things: an explicit
+ * disabled id is refused; omitting picks the least-loaded eligible account.
+ * Status reports `configured` and `logged_in` separately. logged_in is
+ * derived from whether a provider credential file EXISTS — this module
+ * never reads, prints, copies, or hashes that file.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { AccountResolutionError } from "./errors.js";
+import { isTerminalLaneState } from "./types.js";
+import { accountMaxRunning } from "./config.js";
+import { listLaneIds, readLane } from "./store.js";
+import { loadQuotaState, quotaBlockFor } from "./quota.js";
+export const PROVIDER_HOME_ENV = {
+    claude: "CLAUDE_CONFIG_DIR",
+    codex: "CODEX_HOME",
+    grok: "GROK_HOME",
+};
+export const AUTH_JSON_NAME = "auth.json";
+export const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
+/**
+ * Credential filenames are a property of the provider. Codex and Grok write
+ * auth.json. Claude Code writes .credentials.json (never auth.json) inside
+ * the config dir, and can also authenticate via the OS keychain with no
+ * file here at all.
+ */
+export const PROVIDER_CREDENTIAL_FILES = {
+    claude: [CLAUDE_CREDENTIALS_NAME],
+    codex: [AUTH_JSON_NAME],
+    grok: [AUTH_JSON_NAME],
+};
+function defaultAccountDeps() {
+    return { existsSync: (p) => fs.existsSync(p) };
+}
+function enabledIds(provider) {
+    return Object.entries(provider.accounts)
+        .filter(([, account]) => account.enabled)
+        .map(([id]) => id);
+}
+export function credentialPaths(provider, home) {
+    return PROVIDER_CREDENTIAL_FILES[provider].map((name) => path.join(home, name));
+}
+/**
+ * Existence-only probe. Callers must not read the files this returns paths to.
+ */
+export function hasCredentialFile(provider, home, existsSync) {
+    for (const filePath of credentialPaths(provider, home)) {
+        if (existsSync(filePath))
+            return true;
+    }
+    return false;
+}
+/**
+ * Claude with no file in the config dir is unknown, not logged out: the
+ * credential may live in the OS keychain or an API-key helper. Codex and
+ * Grok write auth.json when logged in, so absence is logged out.
+ */
+export function authStateFor(provider, present) {
+    if (present)
+        return "file";
+    if (provider === "claude")
+        return "unknown";
+    return "absent";
+}
+export function loggedInFromAuthState(state) {
+    if (state === "file")
+        return true;
+    if (state === "absent")
+        return false;
+    return null;
+}
+/** Admission and listing share this: refuse only a conclusive logged-out. */
+export function isLoggedOut(status) {
+    return status.logged_in === false;
+}
+/** Auto-select requires a proven credential file, not Claude-unknown. */
+export function isCredentialProven(status) {
+    return status.logged_in === true;
+}
+/**
+ * Occupying states hold a slot: running / awaiting_input / blocked have a
+ * live (or paused-live) worker; queued holds a queue slot that will take a
+ * running slot. Terminal states do not count.
+ */
+export function isOccupyingLaneState(state) {
+    return !isTerminalLaneState(state);
+}
+export function occupyingLaneCount(lanes, provider, accountId) {
+    let n = 0;
+    for (const lane of lanes) {
+        if (lane.provider !== provider)
+            continue;
+        if (lane.account !== accountId)
+            continue;
+        if (!isOccupyingLaneState(lane.state))
+            continue;
+        n += 1;
+    }
+    return n;
+}
+export function runningLaneCount(lanes, provider, accountId) {
+    let n = 0;
+    for (const lane of lanes) {
+        if (lane.provider !== provider)
+            continue;
+        if (lane.account !== accountId)
+            continue;
+        if (lane.state !== "running")
+            continue;
+        n += 1;
+    }
+    return n;
+}
+/** Most recent created_at on this account+provider, any state. Null if none. */
+export function lastStartedAt(lanes, provider, accountId) {
+    let latest = null;
+    for (const lane of lanes) {
+        if (lane.provider !== provider)
+            continue;
+        if (lane.account !== accountId)
+            continue;
+        if (latest === null || lane.created_at > latest)
+            latest = lane.created_at;
+    }
+    return latest;
+}
+function defaultLoadLanes(hqRoot) {
+    return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
+}
+function compareEligible(a, b) {
+    if (a.occupying !== b.occupying)
+        return a.occupying - b.occupying;
+    if (a.lastStarted === null && b.lastStarted === null) {
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    }
+    if (a.lastStarted === null)
+        return -1;
+    if (b.lastStarted === null)
+        return 1;
+    if (a.lastStarted !== b.lastStarted) {
+        return a.lastStarted < b.lastStarted ? -1 : 1;
+    }
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function modelForAccount(provider, accountId, config, ctx) {
+    // Same order as resolveLaneModel: an explicit lane model, then --model,
+    // then the account default, then the provider default.
+    if (ctx.model !== undefined && ctx.model.trim().length > 0)
+        return ctx.model.trim();
+    if (ctx.cliModel !== undefined && ctx.cliModel.trim().length > 0)
+        return ctx.cliModel.trim();
+    const accountModel = config.providers[provider].accounts[accountId]?.model;
+    if (accountModel !== undefined && accountModel.trim().length > 0)
+        return accountModel.trim();
+    const providerModel = config.providers[provider].model;
+    if (providerModel !== undefined && providerModel.trim().length > 0)
+        return providerModel.trim();
+    return undefined;
+}
+function throwIfQuotaBlocked(block, provider, accountId) {
+    if (!block.blocked || !block.reason)
+        return;
+    const model = block.model ?? "(no model)";
+    if (block.reason === "account_model_unavailable") {
+        throw new AccountResolutionError("account_model_unavailable", `Account ${JSON.stringify(accountId)} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
+            provider,
+            account: accountId,
+            model: block.model ?? null,
+            marker: block.marker ?? null,
+        });
+    }
+    throw new AccountResolutionError("account_quota_exhausted", `Account ${JSON.stringify(accountId)} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}`, {
+        provider,
+        account: accountId,
+        model: block.model ?? null,
+        quota_reset_at: block.quota_reset_at ?? null,
+    });
+}
+function boundAccount(provider, id, account) {
+    return {
+        provider,
+        id,
+        home: account.home,
+        enabled: true,
+        envVar: PROVIDER_HOME_ENV[provider],
+    };
+}
+/**
+ * Pick among enabled, credential-proven accounts by occupying count
+ * (lowest wins). Ties break to least-recently-started (oldest created_at),
+ * then account id ascending. Accounts at max_running are excluded from
+ * start-eligible; if every proven account is at cap the pick still returns
+ * one so admission can queue rather than overflow.
+ */
+export function selectBalancedAccount(provider, config, ctx = {}) {
+    const providerCfg = config.providers[provider];
+    const existsSync = ctx.existsSync ?? ((p) => fs.existsSync(p));
+    const enabled = enabledIds(providerCfg);
+    if (enabled.length === 0) {
+        throw new AccountResolutionError("no_enabled_account", `No enabled account for provider ${provider}`, { provider, ineligible: "none_enabled" });
+    }
+    const proven = [];
+    for (const id of enabled) {
+        const account = providerCfg.accounts[id];
+        if (hasCredentialFile(provider, account.home, existsSync))
+            proven.push(id);
+    }
+    if (proven.length === 0) {
+        throw new AccountResolutionError("no_enabled_account", `No logged-in account for provider ${provider}`, { provider, ineligible: "none_logged_in", enabled });
+    }
+    const hqRoot = ctx.hqRoot;
+    const lanes = ctx.loadLanes !== undefined
+        ? ctx.loadLanes(hqRoot ?? "")
+        : hqRoot !== undefined
+            ? defaultLoadLanes(hqRoot)
+            : [];
+    const now = ctx.now ?? new Date();
+    const quota = hqRoot !== undefined ? loadQuotaState(hqRoot) : null;
+    const runnable = quota
+        ? proven.filter((id) => {
+            const block = quotaBlockFor(quota, provider, id, modelForAccount(provider, id, config, ctx), now);
+            return !block.blocked;
+        })
+        : proven;
+    if (quota && runnable.length === 0) {
+        const sample = proven[0];
+        const block = quotaBlockFor(quota, provider, sample, modelForAccount(provider, sample, config, ctx), now);
+        throwIfQuotaBlocked(block, provider, sample);
+    }
+    const underCap = runnable.filter((id) => {
+        const cap = accountMaxRunning(providerCfg, id);
+        return runningLaneCount(lanes, provider, id) < cap;
+    });
+    const pool = underCap.length > 0 ? underCap : runnable;
+    const ranked = pool
+        .map((id) => ({
+        id,
+        occupying: occupyingLaneCount(lanes, provider, id),
+        lastStarted: lastStartedAt(lanes, provider, id),
+    }))
+        .sort(compareEligible);
+    const chosen = ranked[0].id;
+    return boundAccount(provider, chosen, providerCfg.accounts[chosen]);
+}
+export function resolveAccount(provider, requestedId, config, ctx = {}) {
+    const providerCfg = config.providers[provider];
+    const enabled = enabledIds(providerCfg);
+    if (requestedId !== undefined && requestedId.length > 0) {
+        const account = providerCfg.accounts[requestedId];
+        if (account === undefined) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(requestedId)} for ${provider}. Enabled: ${enabled.join(", ") || "(none)"}`, {
+                provider,
+                account: requestedId,
+                enabled,
+            });
+        }
+        if (!account.enabled) {
+            throw new AccountResolutionError("account_disabled", `Account ${JSON.stringify(requestedId)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, {
+                account: requestedId,
+                reason: account.disabled_reason ?? "",
+            });
+        }
+        if (ctx.hqRoot !== undefined) {
+            const now = ctx.now ?? new Date();
+            const block = quotaBlockFor(loadQuotaState(ctx.hqRoot), provider, requestedId, modelForAccount(provider, requestedId, config, ctx), now);
+            throwIfQuotaBlocked(block, provider, requestedId);
+        }
+        return boundAccount(provider, requestedId, account);
+    }
+    return selectBalancedAccount(provider, config, ctx);
+}
+/** Codex/Grok path. Kept for callers that still name auth.json. */
+export function authJsonPath(home) {
+    return path.join(home, AUTH_JSON_NAME);
+}
+export function accountStatus(provider, accountId, config, deps = defaultAccountDeps()) {
+    const envVar = PROVIDER_HOME_ENV[provider];
+    const account = config.providers[provider].accounts[accountId];
+    if (account === undefined) {
+        return {
+            provider,
+            id: accountId,
+            home: "",
+            enabled: false,
+            configured: false,
+            logged_in: false,
+            auth_state: "absent",
+            envVar,
+        };
+    }
+    const present = hasCredentialFile(provider, account.home, deps.existsSync);
+    const auth_state = authStateFor(provider, present);
+    const status = {
+        provider,
+        id: accountId,
+        home: account.home,
+        enabled: account.enabled,
+        configured: true,
+        logged_in: loggedInFromAuthState(auth_state),
+        auth_state,
+        envVar,
+    };
+    if (account.disabled_reason !== undefined) {
+        status.disabled_reason = account.disabled_reason;
+    }
+    return status;
+}
+export function listAccountStatuses(provider, config, deps = defaultAccountDeps()) {
+    return Object.keys(config.providers[provider].accounts).map((id) => accountStatus(provider, id, config, deps));
+}
+/** Environment assignment the worker process should receive. */
+export function accountEnv(resolved) {
+    return { [resolved.envVar]: resolved.home };
+}
+//# sourceMappingURL=accounts.js.map

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

@@ -0,0 +1,96 @@
+/**
+ * Automatic compaction of a resumed Claude lane.
+ *
+ * Owner directives 2026-09-22: "if it's been an hour since last msg, always
+ * run compact" and "there should be a way to run compact automatically using
+ * code written in hqcli".
+ *
+ * Every `--resume` replays the whole conversation. When a resume is due
+ * (`now - last_message_at >= compact_after_ms`), hq-cli first runs
+ * `claude -p --resume <sid> "/compact"` in the lane's account, then starts
+ * the resume as usual. The decision is made at resume time only; there is no
+ * timer.
+ *
+ * Measured 2026-09-22 on account d, claude-opus-5, effort low: a session
+ * with 71,853 cache-read tokens on a control turn was compacted in print
+ * mode. The `/compact` call's own JSON result reports `num_turns: 0` and
+ * zero usage, so it cannot be used as evidence. The session transcript
+ * gained a `compact_boundary` record (`trigger: manual`,
+ * `preTokens: 71899`), the session id was unchanged, and the next turn read
+ * 10,383 cache tokens plus 9,136 cache-creation tokens and still recalled a
+ * value from before the compaction. The transcript boundary is therefore
+ * the success signal this module checks.
+ *
+ * Nothing here logs the prompt, the summary or a response body. The
+ * transcript is read only for `compact_boundary` system records, and only
+ * their `compactMetadata.preTokens` is kept.
+ */
+import type { LaneCompactionRecord, LaneRecord, LaneRunUsage } from "./types.js";
+export declare const COMPACTION_MECHANISM: "claude_print_compact";
+/** The whole prompt of the compaction turn. */
+export declare const COMPACTION_PROMPT = "/compact";
+/** Upper bound on the synchronous `/compact` call. */
+export declare const COMPACTION_TIMEOUT_MS: number;
+export interface CompactionDecision {
+    due: boolean;
+    reference_at: string;
+    elapsed_ms: number;
+    threshold_ms: number;
+}
+/**
+ * Whether a resume of this lane must compact first. The reference is the
+ * last accepted operator message, else the lane's creation (the brief is the
+ * first message). Only Claude lanes resume a session, so only they compact.
+ */
+export declare function compactionDue(lane: Pick<LaneRecord, "provider" | "last_message_at" | "created_at">, nowMs: number, thresholdMs: number): CompactionDecision;
+export interface CompactBoundaryProbe {
+    count: number;
+    last_pre_tokens: number | null;
+}
+/** Locate `<home>/projects/<cwd-slug>/<sid>.jsonl` without deriving the slug. */
+export declare function findSessionTranscript(home: string, sessionId: string): string | null;
+/** Count compact boundaries in a transcript. Other lines are never parsed. */
+export declare function probeCompactBoundaries(transcriptPath: string | null): CompactBoundaryProbe;
+export interface CompactionCommandResult {
+    status: number | null;
+    error?: string;
+}
+export type RunCompactionFn = (input: {
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    stderrPath: string;
+    timeoutMs: number;
+}) => CompactionCommandResult;
+/** Synchronous `/compact`. stdout is discarded; stderr goes to the run dir. */
+export declare const defaultRunCompaction: RunCompactionFn;
+export interface CompactLaneSessionInput {
+    command: string;
+    /** Full argv of `claude -p --resume <sid> "/compact" …`, built by buildProviderCommand. */
+    args: string[];
+    sessionId: string;
+    accountHome: string;
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    logsDir: string;
+    decision: CompactionDecision;
+    before: LaneRunUsage | null;
+    now: () => Date;
+    run?: RunCompactionFn;
+    locateTranscript?: (home: string, sessionId: string) => string | null;
+}
+/**
+ * Run `/compact` on the recorded session and report what happened. A failed
+ * or ineffective compaction is recorded, not thrown: the resume that needed
+ * it still has a message to deliver.
+ */
+export declare function compactLaneSession(input: CompactLaneSessionInput): LaneCompactionRecord;
+/**
+ * Counters of the first run after the last compaction. Known once that run
+ * has exited and no later run has started: the watcher writes
+ * `last_run_usage` at exit, and `last_resume.at` still equals the
+ * compaction's `resume_at`.
+ */
+export declare function compactionAfterUsage(lane: LaneRecord): LaneRunUsage | null;
+//# sourceMappingURL=compaction.d.ts.map

package/dist/lib/lanes/compaction.js

@@ -0,0 +1,197 @@
+/**
+ * Automatic compaction of a resumed Claude lane.
+ *
+ * Owner directives 2026-09-22: "if it's been an hour since last msg, always
+ * run compact" and "there should be a way to run compact automatically using
+ * code written in hqcli".
+ *
+ * Every `--resume` replays the whole conversation. When a resume is due
+ * (`now - last_message_at >= compact_after_ms`), hq-cli first runs
+ * `claude -p --resume <sid> "/compact"` in the lane's account, then starts
+ * the resume as usual. The decision is made at resume time only; there is no
+ * timer.
+ *
+ * Measured 2026-09-22 on account d, claude-opus-5, effort low: a session
+ * with 71,853 cache-read tokens on a control turn was compacted in print
+ * mode. The `/compact` call's own JSON result reports `num_turns: 0` and
+ * zero usage, so it cannot be used as evidence. The session transcript
+ * gained a `compact_boundary` record (`trigger: manual`,
+ * `preTokens: 71899`), the session id was unchanged, and the next turn read
+ * 10,383 cache tokens plus 9,136 cache-creation tokens and still recalled a
+ * value from before the compaction. The transcript boundary is therefore
+ * the success signal this module checks.
+ *
+ * Nothing here logs the prompt, the summary or a response body. The
+ * transcript is read only for `compact_boundary` system records, and only
+ * their `compactMetadata.preTokens` is kept.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const COMPACTION_MECHANISM = "claude_print_compact";
+/** The whole prompt of the compaction turn. */
+export const COMPACTION_PROMPT = "/compact";
+/** Upper bound on the synchronous `/compact` call. */
+export const COMPACTION_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Whether a resume of this lane must compact first. The reference is the
+ * last accepted operator message, else the lane's creation (the brief is the
+ * first message). Only Claude lanes resume a session, so only they compact.
+ */
+export function compactionDue(lane, nowMs, thresholdMs) {
+    const reference_at = lane.last_message_at ?? lane.created_at;
+    const refMs = Date.parse(reference_at);
+    const elapsed_ms = Number.isFinite(refMs) ? nowMs - refMs : 0;
+    return {
+        due: lane.provider === "claude" && Number.isFinite(refMs) && elapsed_ms >= thresholdMs,
+        reference_at,
+        elapsed_ms,
+        threshold_ms: thresholdMs,
+    };
+}
+/** Locate `<home>/projects/<cwd-slug>/<sid>.jsonl` without deriving the slug. */
+export function findSessionTranscript(home, sessionId) {
+    const projects = path.join(home, "projects");
+    let dirs;
+    try {
+        dirs = fs.readdirSync(projects);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+    for (const dir of dirs) {
+        const candidate = path.join(projects, dir, `${sessionId}.jsonl`);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** Count compact boundaries in a transcript. Other lines are never parsed. */
+export function probeCompactBoundaries(transcriptPath) {
+    if (transcriptPath === null)
+        return { count: 0, last_pre_tokens: null };
+    let text;
+    try {
+        text = fs.readFileSync(transcriptPath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { count: 0, last_pre_tokens: null };
+        throw err;
+    }
+    let count = 0;
+    let last = null;
+    for (const line of text.split("\n")) {
+        if (!line.includes('"compact_boundary"'))
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch (err) {
+            process.stderr.write(`hq lanes: skipped an unparseable line in ${transcriptPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+            continue;
+        }
+        if (rec.type !== "system" || rec.subtype !== "compact_boundary")
+            continue;
+        count += 1;
+        const meta = rec.compactMetadata;
+        const pre = meta?.preTokens;
+        last = typeof pre === "number" && Number.isFinite(pre) ? pre : null;
+    }
+    return { count, last_pre_tokens: last };
+}
+/** Synchronous `/compact`. stdout is discarded; stderr goes to the run dir. */
+export const defaultRunCompaction = (input) => {
+    fs.mkdirSync(path.dirname(input.stderrPath), { recursive: true });
+    const errFd = fs.openSync(input.stderrPath, "a");
+    try {
+        const result = spawnSync(input.command, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: ["ignore", "ignore", errFd],
+            timeout: input.timeoutMs,
+        });
+        if (result.error) {
+            return { status: result.status, error: result.error.message };
+        }
+        return { status: result.status };
+    }
+    finally {
+        fs.closeSync(errFd);
+    }
+};
+/**
+ * Run `/compact` on the recorded session and report what happened. A failed
+ * or ineffective compaction is recorded, not thrown: the resume that needed
+ * it still has a message to deliver.
+ */
+export function compactLaneSession(input) {
+    const run = input.run ?? defaultRunCompaction;
+    const locate = input.locateTranscript ?? findSessionTranscript;
+    const started = input.now();
+    const beforeProbe = probeCompactBoundaries(locate(input.accountHome, input.sessionId));
+    const result = run({
+        command: input.command,
+        args: input.args,
+        env: input.env,
+        cwd: input.cwd,
+        stderrPath: path.join(input.logsDir, "compact.err"),
+        timeoutMs: COMPACTION_TIMEOUT_MS,
+    });
+    const afterProbe = probeCompactBoundaries(locate(input.accountHome, input.sessionId));
+    const duration_ms = input.now().getTime() - started.getTime();
+    let outcome;
+    let reason;
+    if (afterProbe.count > beforeProbe.count) {
+        outcome = "compacted";
+    }
+    else if (result.status !== 0 || result.error !== undefined) {
+        outcome = "failed";
+        reason = result.error ?? `exit status ${String(result.status)}`;
+    }
+    else {
+        outcome = "no_effect";
+        reason = "the session transcript gained no compact_boundary record";
+    }
+    if (outcome !== "compacted") {
+        process.stderr.write(`hq lanes: compaction of session ${input.sessionId} ${outcome}: ${reason ?? ""}\n`);
+    }
+    return {
+        at: started.toISOString(),
+        mechanism: COMPACTION_MECHANISM,
+        session_id: input.sessionId,
+        outcome,
+        ...(reason !== undefined ? { reason } : {}),
+        duration_ms,
+        elapsed_ms: input.decision.elapsed_ms,
+        reference_at: input.decision.reference_at,
+        pre_tokens: outcome === "compacted" ? afterProbe.last_pre_tokens : null,
+        before: input.before,
+        after: null,
+    };
+}
+/**
+ * Counters of the first run after the last compaction. Known once that run
+ * has exited and no later run has started: the watcher writes
+ * `last_run_usage` at exit, and `last_resume.at` still equals the
+ * compaction's `resume_at`.
+ */
+export function compactionAfterUsage(lane) {
+    const c = lane.last_compaction;
+    if (c === undefined)
+        return null;
+    if (c.after !== null)
+        return c.after;
+    if (c.resume_at === undefined || lane.state === "running" || lane.state === "queued") {
+        return null;
+    }
+    if (lane.last_resume?.at !== c.resume_at)
+        return null;
+    return lane.last_run_usage ?? null;
+}
+//# sourceMappingURL=compaction.js.map

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

@@ -0,0 +1,71 @@
+/**
+ * Load and validate personal/lanes/config.json (spec §5.5).
+ *
+ * A missing file is the documented defaults, not an error. A `providers` key
+ * outside {claude, codex, grok} is rejected with the accepted list. Account
+ * homes are canonicalised with realpath; two account ids for one provider
+ * that resolve to the same home are refused (identity-keyed-cap rule).
+ */
+import * as fs from "node:fs";
+import { type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
+export declare const LANES_CONFIG_REL: string;
+export declare const DEFAULT_MAX_QUEUED = 3;
+export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
+export declare const DEFAULT_CPU_BUSY_RESUME = 0.7;
+export declare const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
+/**
+ * Owner directive 2026-09-22: "if it's been an hour since last msg, always
+ * run compact". Override per provider with `compact_after_ms`.
+ */
+export declare const DEFAULT_COMPACT_AFTER_MS: number;
+/**
+ * Watcher `lane_progress` throttle: at most one thread event per five minutes
+ * per lane, and only when the tick saw new activity. Override per provider
+ * with `progress_event_min_interval_ms`.
+ */
+export declare const DEFAULT_PROGRESS_EVENT_MIN_INTERVAL_MS: number;
+/** Spec §9: last event within 10 minutes → live. */
+export declare const DEFAULT_LIVE_WITHIN_MS: number;
+/** Spec §9: turn_start with no turn_end after 2 hours → lost. */
+export declare const DEFAULT_TURN_START_LOST_MS: number;
+/** Spec §9: no event for 12 hours (and no session_end) → lost. */
+export declare const DEFAULT_SILENT_LOST_MS: number;
+export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
+export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;
+export declare const DEFAULT_ACCOUNT_HOMES: Record<LaneProvider, string>;
+export interface ConfigLoadDeps {
+    homedir: () => string;
+    realpathSync: (p: string) => string;
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, encoding: "utf8") => string;
+}
+export declare function expandHome(home: string, homedir: string): string;
+/**
+ * Canonical principal for an account home: realpath when the path exists,
+ * otherwise resolve existing ancestors and rejoin the missing tail so two
+ * not-yet-created spellings of the same directory still collide.
+ */
+export declare function canonicalizeHome(home: string, deps?: Pick<ConfigLoadDeps, "homedir" | "realpathSync" | "existsSync">): string;
+export declare function documentedDefaultConfig(deps?: ConfigLoadDeps): LanesConfig;
+export declare function parseLanesConfig(raw: unknown, deps?: ConfigLoadDeps): LanesConfig;
+export declare function lanesConfigPath(hqRoot: string): string;
+/**
+ * Load operator config. Missing file → documented defaults. Unreadable or
+ * invalid JSON is an error (never a silent default).
+ */
+export declare function loadLanesConfig(hqRoot: string, deps?: ConfigLoadDeps): LanesConfig;
+export interface ConfigWriteDeps {
+    mkdirSync: typeof fs.mkdirSync;
+    writeFileSync: typeof fs.writeFileSync;
+    renameSync: typeof fs.renameSync;
+    unlinkSync: typeof fs.unlinkSync;
+}
+/** Persist operator config. Homes are stored as already-canonicalised paths. */
+export declare function writeLanesConfig(hqRoot: string, config: LanesConfig, deps?: ConfigWriteDeps): void;
+/** Resume-time compaction threshold for a provider, defaulting to one hour. */
+export declare function providerCompactAfterMs(provider: ProviderConfig): number;
+/** Minimum gap between two `lane_progress` events, defaulting to five minutes. */
+export declare function providerProgressEventMinIntervalMs(provider: ProviderConfig): number;
+/** Account running cap, defaulting to the provider ceiling when unset. */
+export declare function accountMaxRunning(provider: ProviderConfig, accountId: string): number;
+//# sourceMappingURL=config.d.ts.map