@indigoai-us/hq-cli 5.310.0 → 5.311.1

package/dist/lib/lanes/autopilot-registry.js

@@ -0,0 +1,192 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { joinCommandParts, withRemoteHqDir } from "@indigoai-us/hq-cloud/outposts";
+import { isControllerAliasOutpostId } from "./admission-host.js";
+import { LanesError } from "./errors.js";
+export const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
+export const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const OUTPOST_LEAD_REGISTRY_REFRESH_MS = 6 * 60 * 60 * 1000;
+export const LEAD_REGISTRY_REL = path.join("workspace", "lane-briefs", "juniors.json");
+export const OUTPOST_LEAD_REGISTRY_STATE_REL = path.join("workspace", "lane-briefs", "autopilot-outpost-registry-state.json");
+export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseSourceRegistry(file) {
+    let parsed;
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected a regular file");
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new LanesError("lead_autopilot_registry_unreadable", `Cannot read primary lead registry ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+    // A retired-only registry has no leads, matching the autopilot reader.
+    if (isRecord(parsed) && parsed.juniors === undefined && Array.isArray(parsed.retired))
+        return [];
+    if (!isRecord(parsed) || !Array.isArray(parsed.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid primary lead registry ${file}: juniors must be an array`, { path: file });
+    }
+    return parsed.juniors.map((row, index) => {
+        if (!isRecord(row) ||
+            ["team", "lane", "host", "status", "prd"].some((key) => typeof row[key] !== "string" || !row[key].trim())) {
+            throw new LanesError("lead_autopilot_registry_invalid", `Invalid primary lead registry ${file}: juniors[${index}] must name team, lane, host, status, and prd`, { path: file, index });
+        }
+        return row;
+    });
+}
+export function buildOutpostLeadRegistry(input) {
+    if (!input.outpostId.trim() || !Number.isFinite(Date.parse(input.generatedAt))) {
+        throw new LanesError("lead_autopilot_registry_invalid", "Outpost registry target and generation time must be valid", { outpost_id: input.outpostId });
+    }
+    return {
+        schema_version: OUTPOST_LEAD_REGISTRY_SCHEMA,
+        outpost_id: input.outpostId,
+        generated_at: new Date(input.generatedAt).toISOString(),
+        juniors: input.rows.filter((row) => row.host === input.outpostId),
+    };
+}
+/** Stage a host-filtered registry on the Outpost using an atomic local rename. */
+export function buildOutpostLeadRegistryInstallCommand(registry) {
+    const encoded = Buffer.from(`${JSON.stringify(registry)}\n`, "utf8").toString("base64");
+    const script = [
+        'const fs=require("node:fs"),path=require("node:path");',
+        'const root=process.cwd(),dir=path.join(root,"workspace","lane-briefs"),file=path.join(dir,"juniors.json");',
+        "fs.mkdirSync(dir,{recursive:true});const realRoot=fs.realpathSync(root),realDir=fs.realpathSync(dir);",
+        'if(realDir!==realRoot&&!realDir.startsWith(realRoot+path.sep))throw Error("registry directory escapes HQ root");',
+        'try{const s=fs.lstatSync(file);if(!s.isFile()||s.isSymbolicLink())throw Error("registry destination must be a regular file")}catch(e){if(e.code!=="ENOENT")throw e}',
+        `const bytes=Buffer.from("${encoded}","base64"),tmp=file+"."+process.pid+".tmp";`,
+        'fs.writeFileSync(tmp,bytes,{mode:0o600,flag:"wx"});try{fs.renameSync(tmp,file)}catch(e){try{fs.unlinkSync(tmp)}catch{}throw e}',
+    ].join("");
+    return withRemoteHqDir(joinCommandParts(["node", "-e", script]));
+}
+function companySlug(row) {
+    const match = /^companies\/([a-z0-9][a-z0-9._-]*)\//i.exec(row.prd);
+    return match?.[1] ?? null;
+}
+function readDeliveryState(file) {
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected regular state file");
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isRecord(value) ||
+            value.schema_version !== "hq-lanes-outpost-registry-delivery-state.v1" ||
+            !isRecord(value.delivered)) {
+            throw new Error("invalid delivery state shape");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { schema_version: "hq-lanes-outpost-registry-delivery-state.v1", delivered: {} };
+        }
+        throw new LanesError("lead_autopilot_registry_state_invalid", `Cannot read registry delivery state: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+}
+function writeDeliveryState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        fs.renameSync(temp, file);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== "ENOENT")
+                throw cleanupError;
+        }
+        throw error;
+    }
+}
+export async function syncOutpostLeadRegistries(input) {
+    const sourceFile = path.join(input.hqRoot, LEAD_REGISTRY_REL);
+    // Most HQ installs have no lead registry. Nothing to deliver is not a reconcile failure.
+    if (!fs.existsSync(sourceFile))
+        return [];
+    const sourceRows = parseSourceRegistry(sourceFile);
+    const eligible = [];
+    const skipped = [];
+    const enabledByCompany = new Map();
+    for (const row of sourceRows) {
+        const slug = companySlug(row);
+        if (!slug) {
+            skipped.push({ lane: row.lane, reason: "company_unresolved" });
+            continue;
+        }
+        let enabled = enabledByCompany.get(slug);
+        if (enabled === undefined) {
+            const company = await input.resolveCompany(slug);
+            enabled = await input.readFlag(LEAD_AUTOPILOT_FLAG, { company });
+            enabledByCompany.set(slug, enabled);
+        }
+        if (!enabled) {
+            skipped.push({ lane: row.lane, reason: "flag_off" });
+            continue;
+        }
+        eligible.push(row);
+    }
+    const stateFile = path.join(input.hqRoot, OUTPOST_LEAD_REGISTRY_STATE_REL);
+    const state = readDeliveryState(stateFile);
+    const results = [];
+    const targets = [...new Set(input.outpostIds.map((id) => id.trim()))]
+        .filter((id) => id && !isControllerAliasOutpostId(id, input.localHost))
+        .sort();
+    for (const outpostId of targets) {
+        const registry = buildOutpostLeadRegistry({ rows: eligible, outpostId, generatedAt: input.generatedAt });
+        // Hash only the rows. A new generated_at alone does not trigger a remote write.
+        const hash = crypto.createHash("sha256").update(JSON.stringify(registry.juniors)).digest("hex");
+        const prior = state.delivered[outpostId];
+        const age = prior ? Date.parse(input.generatedAt) - Date.parse(prior.at) : Infinity;
+        const shouldDispatch = !prior ||
+            prior.hash !== hash ||
+            !Number.isFinite(age) ||
+            age < 0 ||
+            age >= OUTPOST_LEAD_REGISTRY_REFRESH_MS;
+        if (shouldDispatch) {
+            const result = await input.dispatch({
+                outpostId,
+                command: buildOutpostLeadRegistryInstallCommand(registry),
+                timeoutSeconds: 120,
+                waitMs: 120_000,
+            });
+            if (result.done !== true || result.exitCode !== 0) {
+                throw new LanesError("lead_autopilot_registry_sync_failed", `Could not sync lead registry to Outpost ${outpostId}`, { outpost_id: outpostId, exit_code: result.exitCode, done: result.done === true });
+            }
+            state.delivered[outpostId] = { hash, at: new Date(input.generatedAt).toISOString() };
+            writeDeliveryState(stateFile, state);
+        }
+        results.push({
+            outpost_id: outpostId,
+            row_count: registry.juniors.length,
+            skipped: skipped.filter(({ lane }) => sourceRows.some((row) => row.lane === lane && row.host === outpostId)),
+            dispatched: shouldDispatch,
+        });
+    }
+    return results;
+}
+export function validateOutpostLeadRegistry(input) {
+    const value = input.registry;
+    if (!isRecord(value) ||
+        value.schema_version !== OUTPOST_LEAD_REGISTRY_SCHEMA ||
+        value.outpost_id !== input.outpostId ||
+        typeof value.generated_at !== "string" ||
+        !Array.isArray(value.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Outpost ${input.outpostId} has an invalid lead registry`, { outpost_id: input.outpostId });
+    }
+    const age = input.now.getTime() - Date.parse(value.generated_at);
+    if (!Number.isFinite(age) || age < 0 || age > OUTPOST_LEAD_REGISTRY_MAX_AGE_MS) {
+        throw new LanesError("lead_autopilot_registry_stale", `Outpost ${input.outpostId} lead registry is stale`, { outpost_id: input.outpostId, generated_at: value.generated_at });
+    }
+    if (value.juniors.some((row) => !isRecord(row) || row.host !== input.outpostId)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Outpost ${input.outpostId} registry contains rows for another host`, { outpost_id: input.outpostId });
+    }
+    return value;
+}
+//# sourceMappingURL=autopilot-registry.js.map

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

@@ -43,6 +43,8 @@ export interface AutopilotPassResult {
         lead_lane: string;
         reason: string;
     }>;
+    /** Set on an Outpost that has not received a lead registry from the primary yet. */
+    registry?: "missing";
 }
 interface ProjectStory {
     id: string;

package/dist/lib/lanes/autopilot.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { laneRunsOnHost } from "./admission.js";
+import { isControllerAliasOutpostId } from "./admission-host.js";
+import { LEAD_REGISTRY_REL, validateOutpostLeadRegistry } from "./autopilot-registry.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { LanesError } from "./errors.js";
 import { resolveLaneCompany } from "./lane-company.js";
@@ -37,21 +39,28 @@ function readJsonFile(filePath, code) {
         throw new LanesError(code, `Cannot parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
     }
 }
-function parseRegistry(hqRoot) {
-    const file = path.join(hqRoot, "workspace", "lane-briefs", "juniors.json");
+function parseRegistry(hqRoot, outpostId, now) {
+    const file = path.join(hqRoot, LEAD_REGISTRY_REL);
     let stat;
     try {
         stat = fs.lstatSync(file);
     }
     catch (error) {
-        if (error.code === "ENOENT")
+        if (error.code === "ENOENT") {
+            // An Outpost without a delivered registry reports it; it does not fail reconcile.
+            // The primary delivers nothing when it has no registry or every company is flagged off.
+            if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+                return null;
             return [];
+        }
         throw new LanesError("lead_autopilot_registry_invalid", `Cannot inspect ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
     }
     if (!stat.isFile() || stat.isSymbolicLink()) {
         throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: expected a regular file`, { path: file });
     }
     const raw = readJsonFile(file, "lead_autopilot_registry_invalid");
+    if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+        return validateOutpostLeadRegistry({ registry: raw, outpostId, now }).juniors;
     if (isRecord(raw) && raw.juniors === undefined && Array.isArray(raw.retired))
         return [];
     if (!isRecord(raw) || !Array.isArray(raw.juniors)) {
@@ -407,8 +416,12 @@ function recordOperatorEscalation(hqRoot, record) {
 }
 async function runLeadAutopilotPassUnlocked(input) {
     const { hqRoot, host, now } = input;
+    const effectiveOutpostId = input.outpostId !== null && isControllerAliasOutpostId(input.outpostId, { kind: "outpost", id: input.outpostId }) ? null : input.outpostId;
     const result = { ok: true, host, evaluated: 0, sent: [], started: [], escalated: [], skipped: [] };
-    const leads = parseRegistry(hqRoot);
+    const registered = parseRegistry(hqRoot, input.outpostId, now);
+    if (registered === null)
+        result.registry = "missing";
+    const leads = registered ?? [];
     const lanes = readAllLanes(hqRoot);
     const byId = new Map(lanes.map((lane) => [lane.lane_id, lane]));
     const stateFile = path.join(hqRoot, "workspace", "lane-briefs", "autopilot-state.json");
@@ -429,7 +442,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             ? lead.host.kind === "local"
             : lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host;
         if (!hostMatchesRegistry ||
-            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: input.outpostId })) {
+            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: effectiveOutpostId })) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });
             continue;
         }

package/dist/lib/lanes/claude-balance.d.ts

@@ -1,6 +1,7 @@
 import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
 import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
+import { type QuotaState } from "./quota.js";
 export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
 export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
 export declare const CLAUDE_RECENT_USAGE_WINDOW_MS: number;
@@ -37,6 +38,9 @@ export interface ClaudeAccountLoad {
     target_logged_in: boolean | null;
     eligible: boolean;
     ineligible_reason?: string;
+    quota_reset_at?: string;
+    quota_marker?: string;
+    quota_model?: string;
     live_lanes: number;
     counts_complete: boolean;
     usage: NonNullable<HostCapacityAccount["usage"]> | null;
@@ -74,6 +78,7 @@ export declare function selectClaudeAccount(input: {
     model?: string;
     /** Keep the recorded account eligible for its already-running CLI model. */
     recordedModelAccount?: string;
+    quotaState?: QuotaState;
     /** Recent completed-run tiebreak; callers pass the default-off hq-flags result. */
     recentUsageEnabled?: boolean;
     now?: Date;
@@ -83,6 +88,7 @@ export declare function selectClaudeAccount(input: {
 export declare function accountLoadsForReport(input: {
     hosts: readonly BalanceHostSnapshot[];
     config: LanesConfig;
+    quotaState?: QuotaState;
 }): ClaudeAccountLoad[];
 export declare function planClaudeBalanceMoves(input: {
     hosts: readonly BalanceHostSnapshot[];

package/dist/lib/lanes/claude-balance.js

@@ -1,4 +1,5 @@
 import { LanesError } from "./errors.js";
+import { quotaBlockFor } from "./quota.js";
 export const BALANCE_LIVE_STATES = ["running", "queued", "awaiting_input"];
 export const BALANCE_MOVABLE_STATES = ["interrupted", "done", "awaiting_input"];
 export const CLAUDE_RECENT_USAGE_WINDOW_MS = 5 * 60 * 60 * 1000;
@@ -126,10 +127,16 @@ function buildLoads(input) {
         const hosts = input.hosts.map((host) => accountHostLoad(host, account));
         const targetLoad = hosts.find((host) => sameHost(host.host, targetHost));
         const configuredModel = configAccounts[account]?.model;
+        const quotaModel = input.model ?? configuredModel ?? input.config.providers.claude.model;
+        const quotaBlock = input.quotaState === undefined
+            ? undefined
+            : quotaBlockFor(input.quotaState, "claude", account, quotaModel, input.now);
         const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (account !== input.recordedModelAccount &&
             input.model !== undefined && configuredModel !== undefined && configuredModel !== input.model
             ? "model_mismatch"
-            : undefined);
+            : quotaBlock?.blocked === true
+                ? "quota_held"
+                : undefined);
         if (ineligible !== undefined)
             skipped.push({ account, host: targetHost, reason: ineligible });
         const knownCounts = hosts.flatMap((host) => host.live_lanes === null ? [] : [host.live_lanes]);
@@ -139,6 +146,11 @@ function buildLoads(input) {
             target_logged_in: targetLoad.logged_in,
             eligible: ineligible === undefined,
             ...(ineligible !== undefined ? { ineligible_reason: ineligible } : {}),
+            ...(quotaBlock?.blocked ? {
+                ...(quotaBlock.quota_reset_at !== undefined ? { quota_reset_at: quotaBlock.quota_reset_at } : {}),
+                ...(quotaBlock.marker !== undefined ? { quota_marker: quotaBlock.marker } : {}),
+                ...(quotaBlock.model !== undefined ? { quota_model: quotaBlock.model } : {}),
+            } : {}),
             live_lanes: knownCounts.reduce((sum, count) => sum + count, 0),
             counts_complete: hosts.every((host) => host.live_lanes !== null && host.count_source !== "capacity_partial"),
             usage: input.target.capacity.providers.claude.accounts[account]?.usage ?? null,
@@ -193,6 +205,9 @@ export function selectClaudeAccount(input) {
             account_reasons: loads.map((load) => ({
                 account: load.account,
                 reason: load.ineligible_reason ?? "unavailable",
+                ...(load.quota_reset_at !== undefined ? { quota_reset_at: load.quota_reset_at } : {}),
+                ...(load.quota_marker !== undefined ? { marker: load.quota_marker } : {}),
+                ...(load.quota_model !== undefined ? { model: load.quota_model } : {}),
             })),
             unavailable_hosts: input.unavailableHosts ?? [],
         });
@@ -234,7 +249,7 @@ export function accountLoadsForReport(input) {
     const first = input.hosts[0];
     if (!first)
         return [];
-    return buildLoads({ hosts: input.hosts, target: first, config: input.config, now: new Date() }).loads.map((load) => ({
+    return buildLoads({ hosts: input.hosts, target: first, config: input.config, quotaState: input.quotaState, now: new Date() }).loads.map((load) => ({
         ...load,
         eligible: false,
         ineligible_reason: undefined,

package/dist/lib/lanes/keep-alive.d.ts

@@ -6,6 +6,9 @@ export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
+export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30000;
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export declare const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

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

@@ -11,6 +11,9 @@ export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS = 24 * 60 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
+export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30_000;
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

package/dist/lib/lanes/reconcile.js

@@ -25,7 +25,7 @@ import { readLanesRegistryFlag } from "./registry-flag.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.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_NEXT_CHECK_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, 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, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_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, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -1119,6 +1119,7 @@ export async function runPassBody(hqRoot, deps) {
     const keepAliveFlagByCompany = new Map();
     const nextCheckAtFlagByCompany = new Map();
     const blockedResumeFlagByCompany = new Map();
+    const immediateFirstResumeFlagByCompany = new Map();
     const supersessionLineageAwareByCompany = new Map();
     await Promise.all([...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
         const options = {
@@ -1129,7 +1130,7 @@ export async function runPassBody(hqRoot, deps) {
             lane.keep_alive === true &&
             laneRunsHere(lane, startDeps.host) &&
             keepAliveCompanyKey(resolveLaneCompany(hqRoot, lane).company) === key);
-        const [keepAliveEnabled, nextCheckAtEnabled, lineageAware, blockedResumeEnabled] = await Promise.all([
+        const [keepAliveEnabled, nextCheckAtEnabled, lineageAware, blockedResumeEnabled, immediateFirstResumeEnabled] = await Promise.all([
             readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
             nextCheckAtFlagCompanyKeys.has(key)
                 ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, options)
@@ -1138,10 +1139,12 @@ export async function runPassBody(hqRoot, deps) {
             hasBlockedKeepAliveLane
                 ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, options)
                 : Promise.resolve(false),
+            readRegistryFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
         ]);
         keepAliveFlagByCompany.set(key, keepAliveEnabled);
         nextCheckAtFlagByCompany.set(key, nextCheckAtEnabled);
         blockedResumeFlagByCompany.set(key, blockedResumeEnabled);
+        immediateFirstResumeFlagByCompany.set(key, immediateFirstResumeEnabled);
         supersessionLineageAwareByCompany.set(key, lineageAware);
     }));
     const admissionThrottleDeps = startDeps.throttleDeps ?? defaultThrottleDeps(startDeps.env ?? process.env);
@@ -1162,7 +1165,7 @@ export async function runPassBody(hqRoot, deps) {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
         await closeInterruptedDoneStoryWorkers(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, storyCloseEnabledByCompany);
-        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
@@ -2241,7 +2244,7 @@ function appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, at, reason, dep
         }),
     }), false);
 }
-async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany) {
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -2634,7 +2637,12 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
         const terminalAtMs = initialState === "done"
             ? Math.min(Date.parse(current.updated_at), currentEligibilityAtMs)
             : currentEligibilityAtMs;
-        const attemptEligibleMs = terminalAtMs + leadLaneKeepAliveBackoffMs(attempt);
+        const immediateFirstResumeEnabled = initialState === "done" &&
+            immediateFirstResumeFlagByCompany.get(keepAliveCompanyKey(companyForLane(current))) === true;
+        const attemptDelayMs = immediateFirstResumeEnabled && attempt === 1
+            ? LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS
+            : leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? Math.max(1, attempt - 1) : attempt);
+        const attemptEligibleMs = terminalAtMs + attemptDelayMs;
         const storedNextMs = resetByHuman
             ? Number.NaN
             : Date.parse(current.keep_alive_next_eligible_at ?? "");
@@ -2653,7 +2661,7 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             recordKeepAliveSkipEvent(hqRoot, skipLane, "backoff", skipLane.version, summary, deps, new Date(nextEligibleMs).toISOString());
             continue;
         }
-        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(attempt + 1)).toISOString();
+        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? attempt : attempt + 1)).toISOString();
         const queuedCount = loadLaneRecords(hqRoot, summary).filter((queuedLane) => queuedLane.state === "queued" &&
             queuedLane.provider === current.provider &&
             laneRunsHere(queuedLane, deps.host) &&

package/dist/lib/lanes/spawn.js

@@ -16,6 +16,7 @@ import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBa
 import { effectiveAccountHome } from "./account-home.js";
 import { buildHostCapacitySnapshot } from "./host-capacity.js";
 import { selectClaudeAccount } from "./claude-balance.js";
+import { loadQuotaState } from "./quota.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
@@ -269,6 +270,7 @@ function selectSpawnAccount(input) {
             hosts: [{ capacity, lanes, laneListAvailable: true }],
             targetHost: lane.host,
             config,
+            quotaState: loadQuotaState(hqRoot),
             ...((recordedModel ?? pinnedModel ?? profileModel) !== undefined
                 ? { model: recordedModel ?? pinnedModel ?? profileModel }
                 : {}),

package/dist/lib/mesh/live/daemon/credentials.d.ts

@@ -3,14 +3,7 @@
  * Never logs or persists credential material.
  */
 import type { IotCredentials } from "./presign.js";
-export declare const REALTIME_CREDENTIALS_PATH = "/v1/realtime/credentials";
 export declare const MQTT_KEEPALIVE_SECONDS = 15;
-/** Renew at 80% of credential lifetime. */
-export declare const CREDENTIAL_RENEWAL_FRACTION = 0.8;
-export declare const MIN_RENEWAL_DELAY_MS = 5000;
-/** Long retry when the server refuses credentials (disabled / unsupported). */
-export declare const DEFAULT_REFUSED_RETRY_MS: number;
-export declare const REFUSED_RETRY_ENV = "HQ_MESH_DAEMON_REFUSED_RETRY_MS";
 /**
  * Node's setTimeout treats delays above this as ~1ms (signed 32-bit overflow).
  * Always schedule long waits via {@link scheduleBoundedTimeout}.
@@ -18,10 +11,6 @@ export declare const REFUSED_RETRY_ENV = "HQ_MESH_DAEMON_REFUSED_RETRY_MS";
 export declare const MAX_TIMER_DELAY_MS = 2147483647;
 /** Cap any single retry so a bogus Retry-After cannot park the daemon. */
 export declare const MAX_RETRY_DELAY_MS: number;
-/** Contract-3 vend accepts at most this many preferred company uids. */
-export declare const PREFERRED_COMPANY_LIMIT = 5;
-/** Session files older than this do not count as companies in use. */
-export declare const PREFERRED_SESSION_WINDOW_MS: number;
 /** Preferred-set changes re-vend at most this often. */
 export declare const PREFERRED_REVEND_MIN_MS = 60000;
 export type CredentialVendFailureKind = "refused" | "transient";
@@ -44,14 +33,13 @@ export declare class CredentialVendError extends Error {
     });
 }
 export declare function parseRetryAfterMs(value: string | null | undefined, nowMs?: number): number | undefined;
-export declare function extractVendErrorCode(body: unknown): string | undefined;
 /** True for server "not now" responses that should use the long retry. */
 export declare function isCredentialVendRefused(status: number, code: string | undefined): boolean;
 export declare function classifyCredentialVendFailure(status: number, body: unknown, retryAfterHeader?: string | null, nowMs?: number): CredentialVendError;
 export declare function defaultRefusedRetryMs(env?: NodeJS.ProcessEnv): number;
 /** ±20% jitter around the refused-retry base interval. */
 export declare function refusedRetryDelayMs(baseMs: number, random: () => number): number;
-export interface PresenceCompany {
+interface PresenceCompany {
     companyUid: string;
     presenceTopic: string;
 }
@@ -124,10 +112,6 @@ export declare function shouldRevendPreferredCompanies(input: {
     nowMs: number;
     minIntervalMs?: number;
 }): boolean;
-export declare function contract3VendBody(preferredCompanyUids: readonly string[] | undefined): {
-    contractVersion: 3;
-    preferredCompanyUids?: string[];
-};
 /** Plain doctor line for one company the vend left out. */
 export declare function formatDroppedPresenceCompany(company: DroppedPresenceCompany): string;
 export type CredentialVendPostResult = {
@@ -200,4 +184,5 @@ export declare function createPersonalRealtimeFetcher(opts: {
     baseUrl?: string;
     post?: (path: string, body: unknown) => Promise<CredentialVendPostResult>;
 }): PersonalCredentialsFetcher;
+export {};
 //# sourceMappingURL=credentials.d.ts.map

package/dist/lib/mesh/live/daemon/credentials.js

@@ -9,14 +9,14 @@ import { vaultApiFetch } from "../../../../utils/vault-api.js";
 import { readAgentIdentityCompanyUid } from "../../../work-context/company.js";
 import { readDeviceConfig } from "../../../work-context/config.js";
 import { workContextSessionsDir } from "../../../work-context/paths.js";
-export const REALTIME_CREDENTIALS_PATH = "/v1/realtime/credentials";
+const REALTIME_CREDENTIALS_PATH = "/v1/realtime/credentials";
 export const MQTT_KEEPALIVE_SECONDS = 15;
 /** Renew at 80% of credential lifetime. */
-export const CREDENTIAL_RENEWAL_FRACTION = 0.8;
-export const MIN_RENEWAL_DELAY_MS = 5_000;
+const CREDENTIAL_RENEWAL_FRACTION = 0.8;
+const MIN_RENEWAL_DELAY_MS = 5_000;
 /** Long retry when the server refuses credentials (disabled / unsupported). */
-export const DEFAULT_REFUSED_RETRY_MS = 10 * 60_000;
-export const REFUSED_RETRY_ENV = "HQ_MESH_DAEMON_REFUSED_RETRY_MS";
+const DEFAULT_REFUSED_RETRY_MS = 10 * 60_000;
+const REFUSED_RETRY_ENV = "HQ_MESH_DAEMON_REFUSED_RETRY_MS";
 /**
  * Node's setTimeout treats delays above this as ~1ms (signed 32-bit overflow).
  * Always schedule long waits via {@link scheduleBoundedTimeout}.
@@ -25,9 +25,9 @@ export const MAX_TIMER_DELAY_MS = 2_147_483_647;
 /** Cap any single retry so a bogus Retry-After cannot park the daemon. */
 export const MAX_RETRY_DELAY_MS = 24 * 60 * 60 * 1000;
 /** Contract-3 vend accepts at most this many preferred company uids. */
-export const PREFERRED_COMPANY_LIMIT = 5;
+const PREFERRED_COMPANY_LIMIT = 5;
 /** Session files older than this do not count as companies in use. */
-export const PREFERRED_SESSION_WINDOW_MS = 24 * 60 * 60 * 1000;
+const PREFERRED_SESSION_WINDOW_MS = 24 * 60 * 60 * 1000;
 /** Preferred-set changes re-vend at most this often. */
 export const PREFERRED_REVEND_MIN_MS = 60_000;
 /**
@@ -66,7 +66,7 @@ export function parseRetryAfterMs(value, nowMs = Date.now()) {
     }
     return undefined;
 }
-export function extractVendErrorCode(body) {
+function extractVendErrorCode(body) {
     if (!body || typeof body !== "object" || Array.isArray(body))
         return undefined;
     const code = body.code;
@@ -370,7 +370,7 @@ export function shouldRevendPreferredCompanies(input) {
     const min = input.minIntervalMs ?? PREFERRED_REVEND_MIN_MS;
     return input.nowMs - input.lastVendMs >= min;
 }
-export function contract3VendBody(preferredCompanyUids) {
+function contract3VendBody(preferredCompanyUids) {
     const body = {
         contractVersion: 3,
     };

package/dist/lib/mesh/live/daemon/index.d.ts

@@ -1,14 +1,14 @@
 export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
 export { acquirePidLock, defaultPidLockDeps, parsePidLock, pidLockStatus, readPidLock, releasePidLock, resolveDaemonDir, } from "./pid-lock.js";
 export type { PidLockDeps, PidLockRecord, PidLockResult } from "./pid-lock.js";
-export { CREDENTIAL_RENEWAL_FRACTION, DEFAULT_REFUSED_RETRY_MS, MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, REALTIME_CREDENTIALS_PATH, REFUSED_RETRY_ENV, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, extractVendErrorCode, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
-export type { BoundedTimeoutHandle, Contract3Bundle, CredentialRenewalErrorInfo, CredentialVendFailureKind, CredentialVendPostResult, CredentialsFetcher, PresenceCompany, TimerHost, } from "./credentials.js";
+export { MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
+export type { BoundedTimeoutHandle, Contract3Bundle, CredentialRenewalErrorInfo, CredentialVendFailureKind, CredentialVendPostResult, CredentialsFetcher, TimerHost, } from "./credentials.js";
 export { amzDateOf, hex, presignIotWssUrl, rfc3986Encode } from "./presign.js";
 export type { IotCredentials } from "./presign.js";
 export { CLOSE_LOG_ALWAYS_COUNT, CLOSE_LOG_INTERVAL_MS, CONNECT_STABLE_GRACE_MS, PresenceClient, backoffDelayMs, buildPresencePayload, defaultMqttConnect, isOwnPresenceTopic, } from "./presence.js";
 export type { MeshMqttClientLike, MqttConnectFn, MqttConnectionState, PresenceClientOptions, PresencePayload, PresenceRefusal, } from "./presence.js";
 export { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
-export type { DaemonStateFile, PresenceRefusalState } from "./state.js";
+export type { DaemonStateFile } from "./state.js";
 export { appendDaemonLog, daemonLogLine, ensureDaemonLog, resolveDaemonAssetDir, rotateDaemonLogIfNeeded, } from "./log.js";
 export { BOARD_REFRESH_INTERVAL_MS, createVaultBoardReader, formatBoardMarkdown, refreshBoundSessionBoards, writeBoardMarkdown, } from "./board-refresh.js";
 export type { BoardReader, BoardRefreshDeps, BoardStorySnapshot } from "./board-refresh.js";
@@ -22,6 +22,6 @@ export type { DaemonDoctorDeps, DaemonDoctorReport } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, DAEMON_VERSION_DRIFT_EXIT_CODE, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";
 export type { DaemonHandle, DaemonRunDeps } from "./run.js";
-export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_HOOK_QUIET_ADOPT_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_ENTRY_CAP, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
-export type { DiscoveredTranscript, DiscoverScanMeta, DiscoverTranscriptsResult, TranscriptDiscoverCache, TranscriptFs, TranscriptKind, TranscriptWatchDeps, TranscriptWatchTickResult, } from "./transcript-watch.js";
+export { TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_HOOK_QUIET_ADOPT_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
+export type { DiscoveredTranscript, DiscoverTranscriptsResult, TranscriptDiscoverCache, TranscriptFs, TranscriptWatchDeps, TranscriptWatchTickResult, } from "./transcript-watch.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/mesh/live/daemon/index.js

@@ -1,6 +1,6 @@
 export { DAEMON_DIRNAME, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_NAME, DAEMON_PID_NAME, DAEMON_STATE_NAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, daemonStatePath, sessionBoardPath, } from "./paths.js";
 export { acquirePidLock, defaultPidLockDeps, parsePidLock, pidLockStatus, readPidLock, releasePidLock, resolveDaemonDir, } from "./pid-lock.js";
-export { CREDENTIAL_RENEWAL_FRACTION, DEFAULT_REFUSED_RETRY_MS, MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, REALTIME_CREDENTIALS_PATH, REFUSED_RETRY_ENV, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, extractVendErrorCode, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
+export { MAX_RETRY_DELAY_MS, MAX_TIMER_DELAY_MS, MQTT_KEEPALIVE_SECONDS, CredentialRenewalManager, CredentialVendError, classifyCredentialVendFailure, clampRetryDelayMs, createContract3Fetcher, defaultRefusedRetryMs, isCredentialVendRefused, normalizeContract3Bundle, parseRetryAfterMs, realTimerHost, refusedRetryDelayMs, renewalDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
 export { amzDateOf, hex, presignIotWssUrl, rfc3986Encode } from "./presign.js";
 export { CLOSE_LOG_ALWAYS_COUNT, CLOSE_LOG_INTERVAL_MS, CONNECT_STABLE_GRACE_MS, PresenceClient, backoffDelayMs, buildPresencePayload, defaultMqttConnect, isOwnPresenceTopic, } from "./presence.js";
 export { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
@@ -11,5 +11,5 @@ export { daemonConfigPath, findAncestorHqRoot, isInstallableHqRoot, readDaemonCo
 export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatCliIdentityLines, formatCliMismatchLine, formatDaemonDoctor, listHqBinariesOnPath, } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, DAEMON_VERSION_DRIFT_EXIT_CODE, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";
-export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_HOOK_QUIET_ADOPT_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_ENTRY_CAP, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
+export { TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_HOOK_QUIET_ADOPT_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
 //# sourceMappingURL=index.js.map