@indigoai-us/hq-cli 5.345.92 → 5.345.93

package/dist/lib/capacity/widget.js

@@ -0,0 +1,418 @@
+import { isExpiredReason, redactProviderTokens, } from "./ledger.js";
+const STYLE = [
+    ".cap{display:flex;flex-direction:column;gap:12px;padding:4px 0}",
+    ".prov{border:1px solid var(--border);border-radius:12px;padding:14px 16px}",
+    ".ph{display:flex;align-items:center;gap:8px;margin-bottom:10px;font-size:15px;font-weight:500;color:var(--text-primary)}",
+    ".acct{padding:10px 0;border-top:1px solid var(--border)}",
+    ".acct:first-of-type{border-top:none;padding-top:0}",
+    ".ah{display:flex;justify-content:space-between;align-items:baseline;gap:8px;margin-bottom:8px}",
+    ".an{font-size:14px;font-weight:500;color:var(--text-primary)}",
+    ".as{font-size:12px;color:var(--text-secondary)}",
+    ".row{display:grid;grid-template-columns:110px 1fr 44px 150px;align-items:center;gap:10px;font-size:13px;color:var(--text-secondary);margin:5px 0}",
+    ".bar{height:8px;border-radius:4px;background:var(--surface-1);border:1px solid var(--border);overflow:hidden}",
+    ".fill{height:100%}",
+    ".pct{text-align:right;color:var(--text-primary);font-variant-numeric:tabular-nums}",
+    ".pill{font-size:11px;padding:2px 8px;border-radius:999px}",
+].join("\n");
+const PROVIDER_ORDER = ["claude", "codex", "grok"];
+const ICONS = {
+    claude: "ti-sparkles",
+    codex: "ti-code",
+    grok: "ti-bolt",
+};
+const PILL_STYLE = {
+    danger: "background:var(--bg-danger);color:var(--text-danger)",
+    warning: "background:var(--bg-warning);color:var(--text-warning)",
+    accent: "background:var(--bg-accent);color:var(--text-accent)",
+    success: "background:var(--bg-success);color:var(--text-success)",
+    muted: "background:var(--surface-1);color:var(--text-secondary);border:1px solid var(--border)",
+};
+const TOKEN_LEAK = /sk-ant-|Bearer\s+\S+|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/i;
+export function capacityWidgetTimeZone(env = process.env) {
+    const fromEnv = env.TZ?.trim();
+    if (fromEnv && isTimeZone(fromEnv))
+        return fromEnv;
+    const resolved = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (resolved && isTimeZone(resolved))
+        return resolved;
+    return "UTC";
+}
+export function renderCapacityWidget(input) {
+    if (input.ledgerMissing) {
+        return renderEmpty("No capacity accounts to show.", "No accounts in the ledger. Turn collection on with hq capacity enable.");
+    }
+    if (input.collectorEnabled === false) {
+        return renderEmpty("Capacity collection is off.", "Collection is off. Turn it on with hq capacity enable.");
+    }
+    const view = input.view;
+    const providers = orderedProviders(view);
+    if (!view || providers.length === 0) {
+        return renderEmpty("No capacity accounts to show.", "No accounts in the ledger. Turn collection on with hq capacity enable.");
+    }
+    const accounts = providers.flatMap((provider) => provider.accounts ?? []);
+    const readAt = newestObserved(accounts, view.generatedAt, input.nowMs);
+    const readTime = clockTime(readAt, input.timeZone);
+    const names = providers.map((provider) => providerTitle(provider.provider));
+    const summary = `Usage and reset times for every signed-in ${joinNames(names)} account, read from the HQ capacity ledger at ${readTime}.`;
+    const cards = providers.map((provider) => renderProvider(provider, input)).join("\n\n");
+    const body = `${cards}\n\n${renderFooter(readTime, input.stale === true)}\n`;
+    return frame(summary, body);
+}
+function renderEmpty(summary, message) {
+    return frame(summary, `<p class="as">${esc(message)}</p>`);
+}
+function frame(summary, body) {
+    return [
+        `<h2 class="sr-only">${esc(summary)}</h2>`,
+        "<style>",
+        STYLE,
+        "</style>",
+        '<div class="cap">',
+        body,
+        "</div>",
+    ].join("\n");
+}
+function orderedProviders(view) {
+    if (!view)
+        return [];
+    return [...view.providers]
+        .filter((provider) => (provider.accounts?.length ?? 0) > 0)
+        .sort((a, b) => {
+        const rank = providerRank(a.provider) - providerRank(b.provider);
+        if (rank !== 0)
+            return rank;
+        return a.provider.localeCompare(b.provider);
+    });
+}
+function providerRank(provider) {
+    const index = PROVIDER_ORDER.indexOf(provider);
+    return index === -1 ? PROVIDER_ORDER.length : index;
+}
+function renderProvider(provider, input) {
+    const accounts = provider.accounts ?? [];
+    const plan = providerPlan(provider.provider, accounts);
+    const icon = ICONS[provider.provider];
+    const iconHtml = icon ? `<i class="ti ${icon}" aria-hidden="true"></i>` : "";
+    const planHtml = plan ? `<span class="as" style="margin-left:auto">${esc(plan)}</span>` : "";
+    const blocks = accounts.map((account) => renderAccount(provider.provider, account, input));
+    return [
+        '<div class="prov">',
+        `<div class="ph">${iconHtml}${esc(providerTitle(provider.provider))}${planHtml}</div>`,
+        "",
+        blocks.join("\n\n"),
+        "</div>",
+    ].join("\n");
+}
+function renderAccount(provider, account, input) {
+    const name = accountName(provider, account);
+    const usage = isUsageOnly(provider, account, input.accounts ?? [])
+        ? ' <span class="as">usage only</span>'
+        : "";
+    const auth = authKind(account);
+    if (auth === "expired" || auth === "signed_out") {
+        const pill = auth === "expired" ? "Token expired" : "Signed out";
+        return [
+            '<div class="acct">',
+            `<div class="ah"><span class="an" style="color:var(--text-secondary)">${esc(name)}${usage}</span><span class="pill" style="${PILL_STYLE.muted}">${pill}</span></div>`,
+            `<div class="as">${esc(lastReadLine(account, input.timeZone))}</div>`,
+            "</div>",
+        ].join("\n");
+    }
+    const limits = visibleLimits(account.limits);
+    const pill = statusPill(limits);
+    const rows = limits.map((limit) => renderLimit(limit, input));
+    return [
+        '<div class="acct">',
+        `<div class="ah"><span class="an">${esc(name)}${usage}</span><span class="pill" style="${PILL_STYLE[pill.tone]}">${esc(pill.text)}</span></div>`,
+        ...rows,
+        "</div>",
+    ].join("\n");
+}
+function renderLimit(limit, input) {
+    const percent = shownPercent(limit.usedPercent);
+    const color = barColor(limit.usedPercent);
+    const width = Math.min(100, percent);
+    return `<div class="row"><span>${esc(limitLabel(limit))}</span><div class="bar"><div class="fill" style="width:${width}%;background:${color}"></div></div><span class="pct">${percent}%</span><span>${esc(resetLabel(limit, input.nowMs, input.timeZone))}</span></div>`;
+}
+function renderFooter(readTime, stale) {
+    const read = `${stale ? "Stale: " : ""}Read ${readTime} from hq capacity`;
+    return [
+        '<div style="display:flex;align-items:center;gap:14px;flex-wrap:wrap;font-size:12px;color:var(--text-secondary)">',
+        '<span><span style="display:inline-block;width:10px;height:10px;border-radius:2px;background:var(--text-accent);margin-right:5px"></span>under 70%</span>',
+        '<span><span style="display:inline-block;width:10px;height:10px;border-radius:2px;background:var(--text-warning);margin-right:5px"></span>70 to 89%</span>',
+        '<span><span style="display:inline-block;width:10px;height:10px;border-radius:2px;background:var(--text-danger);margin-right:5px"></span>90% and up</span>',
+        `<span style="margin-left:auto">${esc(read)}</span>`,
+        `<button onclick="sendPrompt('/capacity')" style="font-size:12px;padding:4px 10px;border-radius:var(--radius);border:1px solid var(--border);background:transparent;color:var(--text-primary);cursor:pointer"><i class="ti ti-refresh" aria-hidden="true"></i> Refresh</button>`,
+        "</div>",
+    ].join("\n");
+}
+function statusPill(limits) {
+    const exhausted = pickExhausted(limits);
+    if (exhausted)
+        return { text: usedUpText(exhausted), tone: "danger" };
+    const highest = limits.reduce((max, limit) => {
+        if (typeof limit.usedPercent !== "number" || !Number.isFinite(limit.usedPercent))
+            return max;
+        return Math.max(max, limit.usedPercent);
+    }, 0);
+    if (highest >= 70)
+        return { text: "Running low", tone: "warning" };
+    if (highest >= 50)
+        return { text: "Half used", tone: "accent" };
+    return { text: "Plenty left", tone: "success" };
+}
+function pickExhausted(limits) {
+    const exhausted = limits.filter((limit) => limit.state === "exhausted");
+    if (exhausted.length === 0)
+        return null;
+    const scoped = exhausted.filter((limit) => limit.kind === "weekly_scoped" && limit.scope?.trim());
+    const pool = scoped.length > 0 ? scoped : exhausted;
+    return [...pool].sort((a, b) => (b.usedPercent ?? -1) - (a.usedPercent ?? -1) || a.limitId.localeCompare(b.limitId))[0] ?? null;
+}
+function usedUpText(limit) {
+    const scope = limit.scope?.trim();
+    if (scope)
+        return `${scope} used up`;
+    if (limit.kind === "session")
+        return "Session used up";
+    if (limit.kind === "weekly_all" || limit.kind === "weekly_scoped")
+        return "Weekly used up";
+    if (limit.kind === "credits")
+        return "Credits used up";
+    if (limit.kind === "on_demand")
+        return "On demand used up";
+    if (limit.kind === "prepaid")
+        return "Prepaid used up";
+    return "Limit used up";
+}
+function visibleLimits(limits) {
+    return limits
+        .filter((limit) => {
+        if (limit.kind === "session" || limit.kind === "weekly_all" || limit.kind === "weekly_scoped")
+            return true;
+        // Credit, spend and prepaid rows only matter once something is used.
+        return typeof limit.usedPercent === "number" && Number.isFinite(limit.usedPercent) && limit.usedPercent > 0;
+    })
+        .sort((a, b) => {
+        const rank = limitRank(a) - limitRank(b);
+        if (rank !== 0)
+            return rank;
+        const scope = (a.scope ?? "").localeCompare(b.scope ?? "");
+        if (scope !== 0)
+            return scope;
+        return a.limitId.localeCompare(b.limitId);
+    });
+}
+function limitRank(limit) {
+    if (limit.kind === "session")
+        return 0;
+    if (limit.kind === "weekly_all")
+        return 1;
+    if (limit.kind === "weekly_scoped")
+        return 2;
+    return 3;
+}
+function limitLabel(limit) {
+    if (limit.kind === "session") {
+        const minutes = limit.windowMinutes;
+        if (minutes && minutes > 0 && minutes % 60 === 0)
+            return `Session (${minutes / 60}h)`;
+        if (minutes && minutes > 0)
+            return `Session (${minutes}m)`;
+        return "Session";
+    }
+    if (limit.kind === "weekly_all")
+        return "Weekly";
+    if (limit.kind === "weekly_scoped") {
+        const scope = limit.scope?.trim();
+        return scope ? `${scope} weekly` : "Weekly";
+    }
+    if (limit.kind === "credits")
+        return limit.limitId === "spend" ? "Spend" : "Extra usage";
+    if (limit.kind === "on_demand")
+        return "On demand";
+    if (limit.kind === "prepaid")
+        return "Prepaid";
+    return "Limit";
+}
+function resetLabel(limit, nowMs, timeZone) {
+    const raw = limit.resetsAt ? Date.parse(limit.resetsAt) : Number.NaN;
+    // Providers stamp resets a few milliseconds either side of the minute
+    // (11:59:59.970); show the minute the reset belongs to.
+    const resetsAtMs = Number.isNaN(raw) ? raw : Math.round(raw / 60_000) * 60_000;
+    const past = !Number.isNaN(resetsAtMs) && resetsAtMs < nowMs;
+    if (limit.state === "reset-pending" || past)
+        return "resetting now";
+    if (Number.isNaN(resetsAtMs))
+        return limit.usedPercent === 0 ? "idle" : "no reset time";
+    const days = calendarDayDiff(resetsAtMs, nowMs, timeZone);
+    const time = clockTime(resetsAtMs, timeZone);
+    if (days <= 0)
+        return days === 0 ? `resets today ${time}` : "resetting now";
+    if (days === 1)
+        return `resets tomorrow ${time}`;
+    const parts = weekMonth(resetsAtMs, timeZone);
+    if (days <= 6)
+        return `resets ${parts.weekday} ${time}`;
+    return `resets ${parts.weekday} ${parts.month} ${parts.day}, ${time}`;
+}
+function providerPlan(provider, accounts) {
+    const labels = new Set();
+    for (const account of accounts) {
+        for (const limit of account.limits) {
+            const plan = limit.planType?.trim();
+            if (!plan || sensitive(plan))
+                continue;
+            labels.add(plainPlan(provider, plan));
+        }
+    }
+    if (labels.size !== 1)
+        return null;
+    return [...labels][0] ?? null;
+}
+function plainPlan(provider, planType) {
+    if (provider === "grok")
+        return "Grok Build";
+    const key = planType.trim().toLowerCase();
+    if (key === "max" || key.startsWith("max ") || key.startsWith("max_") || key.startsWith("max-"))
+        return "Max plans";
+    if (key === "pro")
+        return "Pro plan";
+    if (key === "plus")
+        return "Plus plan";
+    const words = planType.trim().replace(/[_-]+/g, " ");
+    const sentence = words.charAt(0).toUpperCase() + words.slice(1);
+    if (/ plans?$/i.test(sentence))
+        return sentence;
+    return `${sentence} plan`;
+}
+function accountName(provider, account) {
+    const org = account.organization?.trim();
+    if (org && !sensitive(org))
+        return org;
+    const labels = account.labels.filter((label) => label.trim() && !sensitive(label));
+    const named = labels.find((label) => label !== "default");
+    if (named)
+        return named;
+    if (provider === "claude")
+        return "Claude Code terminal (default)";
+    return "Default account";
+}
+function isUsageOnly(provider, account, accounts) {
+    const labels = new Set(account.labels);
+    return accounts.some((row) => row.provider === provider && labels.has(row.label) && row.lanes === false);
+}
+function authKind(account) {
+    if (account.authState === "expired" || isExpiredReason(account.reason))
+        return "expired";
+    if (account.authState === "signed_out" || account.signedOut || account.reason?.startsWith("signed out:")) {
+        return "signed_out";
+    }
+    return "ok";
+}
+function lastReadLine(account, timeZone) {
+    const observed = account.observedAt ? Date.parse(account.observedAt) : Number.NaN;
+    const lead = Number.isNaN(observed) ? "Last checked at an unknown time." : `Last checked ${clockTime(observed, timeZone)}.`;
+    const sentence = reasonSentence(account.reason);
+    return sentence ? `${lead} ${sentence}` : lead;
+}
+function reasonSentence(reason) {
+    if (!reason)
+        return null;
+    let text = redactProviderTokens(reason).replace(/^(expired|signed out):\s*/i, "").trim();
+    if (!text || sensitive(text))
+        return null;
+    text = text.charAt(0).toUpperCase() + text.slice(1);
+    if (!/[.!?]$/.test(text))
+        text += ".";
+    return text;
+}
+function newestObserved(accounts, fallbackIso, nowMs) {
+    let latest = "";
+    for (const account of accounts) {
+        if (account.observedAt && account.observedAt > latest)
+            latest = account.observedAt;
+    }
+    const parsed = Date.parse(latest || fallbackIso);
+    return Number.isNaN(parsed) ? nowMs : parsed;
+}
+function shownPercent(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.round(value));
+}
+function barColor(value) {
+    const percent = typeof value === "number" && Number.isFinite(value) ? value : 0;
+    if (percent >= 90)
+        return "var(--text-danger)";
+    if (percent >= 70)
+        return "var(--text-warning)";
+    return "var(--text-accent)";
+}
+function calendarDayDiff(targetMs, nowMs, timeZone) {
+    const start = Date.parse(`${dateKey(nowMs, timeZone)}T00:00:00Z`);
+    const end = Date.parse(`${dateKey(targetMs, timeZone)}T00:00:00Z`);
+    return Math.round((end - start) / 86_400_000);
+}
+function dateKey(ms, timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).format(new Date(ms));
+}
+function clockTime(ms, timeZone) {
+    const parts = partsOf(ms, timeZone, { hour: "numeric", minute: "2-digit", hour12: true });
+    return `${parts.hour}:${parts.minute} ${parts.dayPeriod}`;
+}
+function weekMonth(ms, timeZone) {
+    const parts = partsOf(ms, timeZone, { weekday: "short", month: "short", day: "numeric" });
+    return { weekday: parts.weekday ?? "", month: parts.month ?? "", day: parts.day ?? "" };
+}
+function partsOf(ms, timeZone, options) {
+    const parts = new Intl.DateTimeFormat("en-US", { ...options, timeZone }).formatToParts(new Date(ms));
+    return Object.fromEntries(parts.filter((part) => part.type !== "literal").map((part) => [part.type, part.value]));
+}
+function providerTitle(provider) {
+    if (provider === "claude")
+        return "Claude";
+    if (provider === "codex")
+        return "Codex";
+    if (provider === "grok")
+        return "Grok";
+    const cleaned = provider.trim();
+    if (!cleaned)
+        return "Provider";
+    return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+function joinNames(names) {
+    if (names.length === 0)
+        return "provider";
+    if (names.length === 1)
+        return names[0] ?? "provider";
+    if (names.length === 2)
+        return `${names[0]} and ${names[1]}`;
+    return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+function sensitive(value) {
+    return value.includes("@") || TOKEN_LEAK.test(value);
+}
+function esc(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function isTimeZone(value) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value }).format(0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=widget.js.map

package/dist/lib/lanes/spawn.js

@@ -36,6 +36,7 @@ import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
+import { emitDispatchAdvisory } from "../capacity/read.js";
 import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
 import { markAnsweredQuestionsDelivered } from "./questions.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
@@ -1837,6 +1838,15 @@ function spawnDetached(spawnProcess, command, args, env, cwd, stdoutPath, stderr
             closeFd(errFd, stderrPath);
     }
 }
+/** One advisory line before the provider process starts. Never changes the spawn. */
+function noteCapacityAdvisory(lane, env) {
+    emitDispatchAdvisory({
+        chosenEngine: lane.provider,
+        caller: "lanes",
+        story: lane.story_id.trim() ? lane.story_id : null,
+        env,
+    });
+}
 function spawnTrackedWorker(spawnProcess, command, args, env, cwd, stdoutPath, stderrPath, exitPath) {
     try {
         fs.unlinkSync(exitPath);
@@ -2724,6 +2734,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let workerPid;
     let watcherPid;
     try {
+        noteCapacityAdvisory(lane, env);
         workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, deps.workingDirectory ?? pendingResume?.working_directory ?? hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
@@ -3034,6 +3045,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const previous = readSpawnManifest(runDir);
     let workerPid;
     try {
+        noteCapacityAdvisory(lane, env);
         workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,

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

@@ -19,6 +19,7 @@ import { PresenceClient, type MqttConnectFn } from "./presence.js";
 import { TranscriptWatcher, type TranscriptFs } from "./transcript-watch.js";
 import { type MeshEmitMode } from "./mode.js";
 import { type CommandRunner, type LegacyListenPlatform } from "./legacy-listen.js";
+import { type StartCapacitySchedulerOptions } from "../../../capacity/scheduler.js";
 export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
@@ -123,6 +124,10 @@ export interface DaemonRunDeps {
     now?: () => Date;
     /** Host for legacy listen retirement. Tests inject this; default is process.platform. */
     legacyListenPlatform?: LegacyListenPlatform;
+    /** Ledger root for the capacity scheduler. Defaults to the home capacity directory. */
+    capacityRoot?: string;
+    /** Injected capacity scheduler options (tests). Timers, root, clock, and log stay with the daemon. */
+    capacityScheduler?: Omit<StartCapacitySchedulerOptions, "timers" | "root" | "now" | "log">;
     /** Service-manager runner for legacy listen retirement (tests inject). */
     legacyListenRun?: CommandRunner;
     windowsLegacyTaskPresent?: boolean;

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

@@ -40,6 +40,8 @@ import { resolveRunningCliEntry } from "./install.js";
 import { readDaemonConfig } from "./config.js";
 import { retireLegacyListen } from "./legacy-listen.js";
 import { startWorkCacheSubscriber } from "./work-subscribe.js";
+import { capacityRoot } from "../../../capacity/ledger.js";
+import { startCapacityScheduler, } from "../../../capacity/scheduler.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
@@ -605,6 +607,7 @@ export async function runMeshDaemon(deps = {}) {
     let boardIntervalHandle = null;
     let transcriptIntervalHandle = null;
     let watcher = null;
+    let stopCapacity = null;
     /** Shared with transcript watcher: sessionIds seen on the hook/spool path. */
     const lastHookEventAt = new Map();
     const lastHookTurnEndAt = new Map();
@@ -621,7 +624,7 @@ export async function runMeshDaemon(deps = {}) {
         return true;
     };
     if (emitPath && deps.enableTranscriptWatch !== false) {
-        const hqRoot = deps.hqRoot ?? env.HQ_ROOT?.trim() ?? undefined;
+        const hqRoot = deps.hqRoot ?? (env.HQ_ROOT?.trim() || undefined);
         const getToken = deps.getToken ?? defaultGetToken;
         transcriptWatcher = new TranscriptWatcher({
             home,
@@ -877,6 +880,14 @@ export async function runMeshDaemon(deps = {}) {
         stopped = true;
         shutdownController.abort();
         log(dir, "daemon stopping");
+        try {
+            stopCapacity?.();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(dir, `capacity scheduler stop error: ${msg.slice(0, 120)}`);
+        }
+        stopCapacity = null;
         if (debounceHandle !== null)
             timers.clearTimeout(debounceHandle);
         if (flushIntervalHandle !== null)
@@ -938,6 +949,23 @@ export async function runMeshDaemon(deps = {}) {
         }
         log(dir, "daemon stopped");
     };
+    try {
+        const capacity = startCapacityScheduler({
+            home,
+            ...deps.capacityScheduler,
+            timers,
+            root: deps.capacityRoot ?? capacityRoot(env, home),
+            now,
+            log: (line) => log(dir, line),
+            enumerateAccounts: true,
+            hqRoot: deps.hqRoot ?? (env.HQ_ROOT?.trim() || undefined),
+        });
+        stopCapacity = capacity.stop;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(dir, `capacity scheduler start failed: ${msg.slice(0, 120)}`);
+    }
     const onSignal = () => {
         void stop().finally(() => exit(0));
     };

package/package.json

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