@indigoai-us/hq-cli 5.122.1 → 5.123.0

package/dist/lib/billing/plan-lock.js

@@ -1,59 +1,54 @@
 /**
- * `plan-lock` (starter-plan-hard-limits / US-011, rewritten for US-036) — the
- * CLI-side read + render of a workspace's Starter plan-limit state.
+ * CLI-side read + render of a workspace's Starter plan-limit nag
+ * (starter-plan-hard-limits / US-011, rewritten for US-036, then US-040).
  *
  * Starter (free) workspaces are capped on members, integrations, secrets and
  * agents (deployments and storage nag but never arm a stop). Going over does
  * NOT stop the workspace working (US-033 owner decision 12): everything that
  * exists keeps working, and the only two things that pause are adding new
  * files to the vault and adding new secrets (owner decision 13). Every string
- * this module renders is a nag, never a claim that HQ has stopped. The state
- * is NOT decided here — hq-pro is the single source of truth and ships the
- * answer on `GET /membership/me` as a per-company `planLock` object. This
- * module only reads that field and renders it.
+ * this module renders is a nag, never a claim that HQ has stopped.
+ *
+ * US-040: hq-pro no longer attaches `planLock` on `/membership/me` or
+ * `/v1/billing/usage-limits`. This module reads the nag payload from
+ * usage-limits (`planLimits` resource rows, top-level `freeMonth`,
+ * `upgradeUrl`) and never a lock object.
  *
  * Copy rule (US-036): no string a customer reads may contain "locked" or
  * "read-only". `plan-lock.test.ts` scans every rendered string for both.
  *
- * Member counts are decoration, never a second opinion: the count comes from
- * `GET /v1/billing/usage-limits` on a best-effort basis and its absence only
- * removes the "n of 5" detail from the notice. An absent field is UNKNOWN, so
- * nothing here ever infers a lock (or an unlock) from missing data
- * (hq-absent-field-never-means-constraining-value).
+ * An absent field is UNKNOWN, so nothing here ever infers over-limit from
+ * missing data (hq-absent-field-never-means-constraining-value).
  */
 import chalk from "chalk";
 import { vaultApiFetch } from "../../utils/vault-api.js";
 /**
- * Mirror of hq-pro's `PlanLockReason`. Owner decision 7 (2026-09-17) fixes the
- * nagging set at these four: `deployments` and `storageBytes` are nag-only and
- * never appear here. An unrecognised reason is dropped by `parsePlanLock`, so a
- * server that adds a fifth dimension renders as the generic line rather than as
- * a false claim about members.
+ * Dimensions the bind notice names with a remedy. Owner decision 7 (2026-09-17)
+ * fixes the nagging set at these four: `deployments` and `storageBytes` are
+ * nag-only and never appear here.
  */
-export const PLAN_LOCK_REASONS = [
+export const PLAN_LIMIT_REASONS = [
     "users",
     "integrations",
     "secrets",
     "agents",
 ];
-function isPlanLockReason(value) {
-    return PLAN_LOCK_REASONS.includes(value);
-}
-/** Starter member cap quoted when the server did not send `removeMembersTo`. */
+/** @deprecated US-040 — alias of {@link PLAN_LIMIT_REASONS}. */
+export const PLAN_LOCK_REASONS = PLAN_LIMIT_REASONS;
+/** Starter member cap quoted when the server did not send a users.limit. */
 export const STARTER_MEMBER_TARGET = 5;
 /**
- * Starter integration cap quoted when the server did not send
- * `disconnectIntegrationsTo`. One: Starter includes a single integration
- * (US-020 owner decision 11, 2026-09-17 — it was zero before that).
+ * Starter integration cap quoted when the server did not send a limit.
+ * One: Starter includes a single integration (US-020 owner decision 11).
  */
 export const STARTER_INTEGRATION_TARGET = 1;
-/** Starter secret cap quoted when the server did not send `removeSecretsTo`. */
+/** Starter secret cap quoted when the server did not send a secrets.limit. */
 export const STARTER_SECRET_TARGET = 10;
-/** Starter agent cap quoted when the server did not send `deprovisionAgentsTo`. */
+/** Starter agent cap quoted when the server did not send an agents.limit. */
 export const STARTER_AGENT_TARGET = 0;
 /** Upgrade destination quoted when the server did not send one. */
 export const DEFAULT_UPGRADE_URL = "https://hq.computer/billing";
-/** The paid plan the lock wall sends owners to. Copy lives in ONE place. */
+/** The paid plan the nag sends owners to. Copy lives in ONE place. */
 export const WORKFORCE_PLAN_LABEL = "HQ Workforce ($500/mo)";
 function finiteNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -64,58 +59,65 @@ function asRecord(value) {
     }
     return value;
 }
+/** Published Starter cap for a dimension, quoted when the server sends no limit. */
+function starterCap(reason) {
+    switch (reason) {
+        case "users":
+            return STARTER_MEMBER_TARGET;
+        case "integrations":
+            return STARTER_INTEGRATION_TARGET;
+        case "secrets":
+            return STARTER_SECRET_TARGET;
+        case "agents":
+            return STARTER_AGENT_TARGET;
+    }
+}
 /**
- * Defensively parse a `planLock` payload. Anything malformed returns null —
- * the caller then behaves exactly as if the server had sent nothing, which is
- * "unknown", not "locked".
+ * Parse one usage row. An absent or null `limit` is UNKNOWN, never zero: the
+ * renderer quotes the published Starter cap instead of "7 of 0 members"
+ * (hq-absent-field-never-means-constraining-value).
  */
-export function parsePlanLock(value) {
+function parseUsageRow(reason, value) {
     const rec = asRecord(value);
     if (!rec)
         return null;
-    if (typeof rec.locked !== "boolean")
+    const used = finiteNumber(rec.used);
+    if (used === null)
         return null;
-    const reasons = [];
-    if (Array.isArray(rec.reasons)) {
-        for (const reason of rec.reasons) {
-            if (isPlanLockReason(reason))
-                reasons.push(reason);
-        }
-    }
-    const fix = asRecord(rec.fixOptions);
-    const removeMembersTo = finiteNumber(fix?.removeMembersTo) ?? STARTER_MEMBER_TARGET;
-    const disconnectIntegrationsTo = finiteNumber(fix?.disconnectIntegrationsTo);
-    const removeSecretsTo = finiteNumber(fix?.removeSecretsTo);
-    const deprovisionAgentsTo = finiteNumber(fix?.deprovisionAgentsTo);
-    const fixOptions = {
-        removeMembersTo,
-        disconnectIntegrations: fix?.disconnectIntegrations === true,
-    };
-    // Absent stays absent: an omitted remedy target is UNKNOWN, and the renderer
-    // quotes the published Starter cap rather than inventing a server answer.
-    if (disconnectIntegrationsTo !== null) {
-        fixOptions.disconnectIntegrationsTo = disconnectIntegrationsTo;
-    }
-    if (removeSecretsTo !== null)
-        fixOptions.removeSecretsTo = removeSecretsTo;
-    if (deprovisionAgentsTo !== null) {
-        fixOptions.deprovisionAgentsTo = deprovisionAgentsTo;
-    }
+    const limit = finiteNumber(rec.limit);
+    return { used, limit: limit ?? starterCap(reason) };
+}
+function rowIsOver(value) {
+    const rec = asRecord(value);
+    if (!rec)
+        return false;
+    if (rec.over === true)
+        return true;
+    const used = finiteNumber(rec.used);
+    const limit = finiteNumber(rec.limit);
+    return used !== null && limit !== null && used > limit;
+}
+export function parseFreeMonth(value) {
+    const rec = asRecord(value);
+    if (!rec)
+        return undefined;
+    if (rec.eligible !== true)
+        return undefined;
+    const url = typeof rec.url === "string" && rec.url.trim().length > 0
+        ? rec.url.trim()
+        : undefined;
+    const trialDays = finiteNumber(rec.trialDays) ?? undefined;
     return {
-        locked: rec.locked,
-        reasons,
-        upgradeUrl: typeof rec.upgradeUrl === "string" && rec.upgradeUrl.trim().length > 0
-            ? rec.upgradeUrl.trim()
-            : DEFAULT_UPGRADE_URL,
-        fixOptions,
+        eligible: true,
+        ...(trialDays !== undefined ? { trialDays } : {}),
+        ...(url ? { url } : {}),
     };
 }
 /**
  * Pick the membership row for `companySlug` (or `cmp_…` uid) out of a decoded
- * `/membership/me` body and return its parsed lock. No matching row — or no
- * `planLock` on it — is UNKNOWN, so this returns null rather than guessing.
+ * `/membership/me` body. No matching row is UNKNOWN. Does not read `planLock`.
  */
-export function selectPlanLock(body, companyRef) {
+export function selectCompanyMembership(body, companyRef) {
     const rec = asRecord(body);
     const rows = Array.isArray(rec?.memberships) ? rec.memberships : [];
     const ref = companyRef.trim().toLowerCase();
@@ -129,11 +131,7 @@ export function selectPlanLock(body, companyRef) {
         const uid = typeof row.companyUid === "string" ? row.companyUid.toLowerCase() : "";
         if (slug !== ref && uid !== ref)
             continue;
-        const lock = parsePlanLock(row.planLock);
-        if (!lock)
-            return null;
         return {
-            lock,
             companyUid: typeof row.companyUid === "string" ? row.companyUid : undefined,
         };
     }
@@ -159,12 +157,68 @@ export function selectMemberUsage(body) {
         : STARTER_MEMBER_TARGET;
     return { used: users.used, limit };
 }
+function selectUpgradeUrl(body) {
+    const rec = asRecord(body);
+    const raw = rec?.upgradeUrl;
+    if (typeof raw === "string" && raw.trim().length > 0)
+        return raw.trim();
+    return DEFAULT_UPGRADE_URL;
+}
 /**
- * Read the live lock for one company: `planLock` from `/membership/me`, plus a
- * best-effort member count for the notice. Returns null when the server did not
- * answer with a lock for this company — callers must then say nothing.
+ * Read over-limit dimensions from a usage-limits body. `planLimits` nested
+ * map is preferred when present; otherwise the top-level resource rows.
  */
-export async function fetchPlanLockStatus(token, companyRef, opts = {}) {
+export function selectOverReasons(body) {
+    const rec = asRecord(body);
+    if (!rec)
+        return [];
+    const nested = asRecord(rec.planLimits);
+    const source = nested ?? rec;
+    const reasons = [];
+    for (const key of PLAN_LIMIT_REASONS) {
+        if (rowIsOver(source[key]))
+            reasons.push(key);
+    }
+    return reasons;
+}
+export function selectUsages(body) {
+    const rec = asRecord(body);
+    if (!rec)
+        return {};
+    const nested = asRecord(rec.planLimits);
+    const source = nested ?? rec;
+    const out = {};
+    for (const key of PLAN_LIMIT_REASONS) {
+        const row = parseUsageRow(key, source[key]);
+        if (row)
+            out[key] = row;
+    }
+    return out;
+}
+function statusFromUsage(companySlug, companyUid, body) {
+    const usages = selectUsages(body);
+    const reasons = selectOverReasons(body);
+    const rec = asRecord(body);
+    const anyOverFlag = rec?.anyOver === true;
+    return {
+        companySlug,
+        companyUid,
+        over: anyOverFlag || reasons.length > 0,
+        reasons,
+        members: selectMemberUsage(body) ?? usages.users,
+        usages,
+        upgradeUrl: selectUpgradeUrl(body),
+        freeMonth: parseFreeMonth(rec?.freeMonth),
+        plan: selectPlan(body) ?? undefined,
+        checkedAt: new Date().toISOString(),
+    };
+}
+/**
+ * Read the live nag for one company from usage-limits. `/membership/me` is
+ * used only to resolve slug → companyUid. Returns null when the server did
+ * not answer for this company — callers must then say nothing.
+ */
+export async function fetchPlanLimitStatus(token, companyRef, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 8000;
     const res = await vaultApiFetch({
         token,
@@ -173,42 +227,29 @@ export async function fetchPlanLockStatus(token, companyRef, opts = {}) {
     });
     if (!res.ok)
         return null;
-    const selected = selectPlanLock(await res.json().catch(() => null), companyRef);
-    if (!selected)
+    const selected = selectCompanyMembership(await res.json().catch(() => null), companyRef);
+    if (!selected?.companyUid)
+        return null;
+    try {
+        const usage = await vaultApiFetch({
+            token,
+            path: "/v1/billing/usage-limits",
+            query: { companyUid: selected.companyUid },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!usage.ok)
+            return null;
+        const body = await usage.json().catch(() => null);
+        if (!body)
+            return null;
+        return statusFromUsage(companyRef, selected.companyUid, body);
+    }
+    catch {
         return null;
-    let members;
-    let plan;
-    // Decoration only. The lock answer above is authoritative; the usage read
-    // adds the member count and the plan id that the notices and the `Plan:`
-    // orientation line quote. A failure here must never suppress — or invent —
-    // a lock, so every field it feeds stays optional.
-    if (selected.companyUid) {
-        try {
-            const usage = await vaultApiFetch({
-                token,
-                path: "/v1/billing/usage-limits",
-                query: { companyUid: selected.companyUid },
-                signal: AbortSignal.timeout(timeoutMs),
-            });
-            if (usage.ok) {
-                const body = await usage.json().catch(() => null);
-                members = selectMemberUsage(body) ?? undefined;
-                plan = selectPlan(body) ?? undefined;
-            }
-        }
-        catch {
-            // Network/timeout: leave both unknown.
-        }
     }
-    return {
-        companySlug: companyRef,
-        companyUid: selected.companyUid,
-        lock: selected.lock,
-        members,
-        plan,
-        checkedAt: new Date().toISOString(),
-    };
 }
+/** @deprecated US-040 — alias of {@link fetchPlanLimitStatus}. */
+export const fetchPlanLockStatus = fetchPlanLimitStatus;
 /** Why the workspace is over, one clause per reason. */
 export function reasonLabel(reason) {
     switch (reason) {
@@ -222,48 +263,80 @@ export function reasonLabel(reason) {
             return "agents are not included on Starter";
     }
 }
-function integrationTarget(lock) {
-    return lock.fixOptions.disconnectIntegrationsTo ?? STARTER_INTEGRATION_TARGET;
-}
-function secretTarget(lock) {
-    return lock.fixOptions.removeSecretsTo ?? STARTER_SECRET_TARGET;
-}
-function agentTarget(lock) {
-    return lock.fixOptions.deprovisionAgentsTo ?? STARTER_AGENT_TARGET;
+function usageTarget(reason, status) {
+    const used = status.usages[reason]?.limit;
+    if (typeof used === "number")
+        return used;
+    switch (reason) {
+        case "users":
+            return status.members?.limit ?? STARTER_MEMBER_TARGET;
+        case "integrations":
+            return STARTER_INTEGRATION_TARGET;
+        case "secrets":
+            return STARTER_SECRET_TARGET;
+        case "agents":
+            return STARTER_AGENT_TARGET;
+    }
 }
 /** The remedy sentence for one reason — what the owner does to clear it. */
-function reasonRemedy(reason, lock) {
+function reasonRemedy(reason, status) {
+    const target = usageTarget(reason, status);
     switch (reason) {
         case "users":
-            return `remove members until you are at ${lock.fixOptions.removeMembersTo} or fewer`;
+            return `remove members until you are at ${target} or fewer`;
         case "integrations":
-            return `disconnect integrations until you are at ${integrationTarget(lock)} or fewer`;
+            return `disconnect integrations until you are at ${target} or fewer`;
         case "secrets":
-            return `delete secrets until you are at ${secretTarget(lock)} or fewer`;
-        case "agents": {
-            const target = agentTarget(lock);
+            return `delete secrets until you are at ${target} or fewer`;
+        case "agents":
             return target > 0
                 ? `deprovision agents until you are at ${target} or fewer`
                 : "deprovision the workspace's agents";
-        }
     }
 }
 /** The short per-reason clause used inside the one-line turn notice. */
 function reasonDetail(reason, status) {
-    const { lock, members } = status;
+    const row = status.usages[reason];
+    const target = usageTarget(reason, status);
+    switch (reason) {
+        case "users":
+            return row || status.members
+                ? `${(row ?? status.members).used} of ${target} members`
+                : `over its ${target}-member limit`;
+        case "integrations":
+            return row
+                ? `${row.used} of ${target} integrations`
+                : `over its ${target}-integration limit`;
+        case "secrets":
+            return row
+                ? `${row.used} of ${target} secrets`
+                : `over its ${target}-secret limit`;
+        case "agents":
+            return "agents are not included on Starter";
+    }
+}
+function usageLine(reason, status) {
+    const row = status.usages[reason];
+    const target = usageTarget(reason, status);
     switch (reason) {
         case "users": {
-            const target = lock.fixOptions.removeMembersTo;
+            const members = row ?? status.members;
             return members
-                ? `${members.used} of ${target} members`
-                : `over its ${target}-member limit`;
+                ? `  Members: ${members.used} of ${target}.`
+                : `  Members allowed on Starter: ${target}.`;
         }
         case "integrations":
-            return `over its ${integrationTarget(status.lock)}-integration limit`;
+            return row
+                ? `  Integrations: ${row.used} of ${target}.`
+                : `  Integrations allowed on Starter: ${target}.`;
         case "secrets":
-            return `over its ${secretTarget(status.lock)}-secret limit`;
+            return row
+                ? `  Secrets: ${row.used} of ${target}.`
+                : `  Secrets allowed on Starter: ${target}.`;
         case "agents":
-            return "agents are not included on Starter";
+            return row
+                ? `  Agents: ${row.used} of ${target}.`
+                : `  Agents allowed on Starter: ${target}.`;
     }
 }
 /**
@@ -285,43 +358,41 @@ function capitalize(text) {
  * against the cap, and the ways out. Plain text — colour is applied by the
  * caller so scripts capturing stdout get a clean block.
  *
- * Every line is derived from `lock.reasons`. A workspace over on secrets is
+ * Every line is derived from `status.reasons`. A workspace over on secrets is
  * never told it has too many members, and an empty reason list (a server
  * dimension this CLI does not know) renders a generic line rather than a claim
  * about a dimension nobody measured.
  */
 export function renderPlanLimitNotice(status) {
-    const { lock, members, companySlug } = status;
+    const { companySlug, freeMonth } = status;
     const lines = [];
     lines.push(`HQ Starter — ${companySlug} is over its plan limits.`);
-    const reasons = lock.reasons.length
-        ? lock.reasons.map(reasonLabel).join("; ")
+    const reasons = status.reasons.length
+        ? status.reasons.map(reasonLabel).join("; ")
         : "over the Starter plan limits";
     lines.push(`  Why: ${reasons}.`);
-    if (lock.reasons.includes("users")) {
-        const target = lock.fixOptions.removeMembersTo;
-        lines.push(members
-            ? `  Members: ${members.used} of ${target}.`
-            : `  Members allowed on Starter: ${target}.`);
-    }
-    if (lock.reasons.includes("integrations")) {
-        lines.push(`  Integrations allowed on Starter: ${integrationTarget(lock)}.`);
-    }
-    if (lock.reasons.includes("secrets")) {
-        lines.push(`  Secrets allowed on Starter: ${secretTarget(lock)}.`);
-    }
-    if (lock.reasons.includes("agents")) {
-        lines.push(`  Agents allowed on Starter: ${agentTarget(lock)}.`);
+    for (const reason of status.reasons) {
+        lines.push(usageLine(reason, status));
     }
     lines.push(HARD_STOP_SENTENCE_LINES[0]);
     lines.push(HARD_STOP_SENTENCE_LINES[1]);
-    lines.push("  Two ways to sort it:");
-    const remedy = lock.reasons.length
-        ? lock.reasons.map((reason) => reasonRemedy(reason, lock)).join(", and ")
+    const remedy = status.reasons.length
+        ? status.reasons.map((reason) => reasonRemedy(reason, status)).join(", and ")
         : "come back under the Starter plan limits";
-    lines.push(`    1. ${capitalize(remedy)}.`);
-    lines.push(`    2. Upgrade to ${WORKFORCE_PLAN_LABEL}.`);
-    lines.push(`  Upgrade: ${lock.upgradeUrl}`);
+    const freeMonthUrl = freeMonth?.url;
+    const hasFreeMonth = Boolean(freeMonth?.eligible && freeMonthUrl);
+    if (hasFreeMonth) {
+        lines.push("  Three ways to sort it:");
+        lines.push(`    1. Start your free month — add a card, first month free: ${freeMonthUrl}`);
+        lines.push(`    2. ${capitalize(remedy)}.`);
+        lines.push(`    3. Upgrade to ${WORKFORCE_PLAN_LABEL}.`);
+    }
+    else {
+        lines.push("  Two ways to sort it:");
+        lines.push(`    1. ${capitalize(remedy)}.`);
+        lines.push(`    2. Upgrade to ${WORKFORCE_PLAN_LABEL}.`);
+    }
+    lines.push(`  Upgrade: ${status.upgradeUrl}`);
     return lines.join("\n");
 }
 /**
@@ -329,24 +400,22 @@ export function renderPlanLimitNotice(status) {
  * Kept to a single line on purpose — it repeats each turn.
  */
 export function renderPlanLimitLine(status) {
-    const detail = status.lock.reasons.length
-        ? status.lock.reasons
-            .map((reason) => reasonDetail(reason, status))
-            .join("; ")
+    const detail = status.reasons.length
+        ? status.reasons.map((reason) => reasonDetail(reason, status)).join("; ")
         : "over the Starter plan limits";
     return (`Company ${status.companySlug} is over its Starter limits (${detail}). ` +
-        `New files and new secrets are paused until this is sorted: ${status.lock.upgradeUrl}`);
+        `New files and new secrets are paused until this is sorted: ${status.upgradeUrl}`);
 }
 /**
  * The `Plan: …` orientation line. Starter only: a paid or enterprise
  * workspace — and an UNKNOWN plan — gets no line at all.
  */
 export function renderPlanLine(status) {
-    if (status.lock.locked)
+    if (status.over)
         return "Plan: Starter — over its limits";
     if (status.plan !== "free")
         return null;
-    const target = status.lock.fixOptions.removeMembersTo;
+    const target = status.members?.limit ?? STARTER_MEMBER_TARGET;
     if (status.members) {
         return `Plan: Starter — ${status.members.used} of ${target} members`;
     }

package/dist/lib/bot/api.d.ts

@@ -85,8 +85,11 @@ export declare class BotApiError extends Error {
     readonly status: number;
     readonly path: string;
     readonly code?: string | undefined;
-    constructor(status: number, path: string, code?: string | undefined, detail?: string);
+    readonly retryAfterMs?: number | undefined;
+    constructor(status: number, path: string, code?: string | undefined, detail?: string, retryAfterMs?: number | undefined);
 }
+/** Parse a Retry-After header (delta-seconds or HTTP-date) to milliseconds. */
+export declare function retryAfterHeaderMs(value: string | null | undefined, nowMs?: number): number | undefined;
 export interface BotApiOptions {
     token: TokenSupplier;
     baseUrl?: string;

package/dist/lib/bot/api.js

@@ -11,14 +11,32 @@ export class BotApiError extends Error {
     status;
     path;
     code;
-    constructor(status, path, code, detail) {
+    retryAfterMs;
+    constructor(status, path, code, detail, retryAfterMs) {
         super(`HQ API ${path} → ${status}${code ? ` ${code}` : ""}${detail ? `: ${detail}` : ""}`);
         this.status = status;
         this.path = path;
         this.code = code;
+        this.retryAfterMs = retryAfterMs;
         this.name = "BotApiError";
     }
 }
+/** Parse a Retry-After header (delta-seconds or HTTP-date) to milliseconds. */
+export function retryAfterHeaderMs(value, nowMs = Date.now()) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.round(seconds * 1000);
+    }
+    const dateMs = Date.parse(trimmed);
+    if (!Number.isNaN(dateMs))
+        return Math.max(0, dateMs - nowMs);
+    return undefined;
+}
 async function readError(res) {
     try {
         const body = (await res.json());
@@ -54,7 +72,7 @@ export class BotApi {
         });
         if (!accept.includes(res.status)) {
             const err = await readError(res);
-            throw new BotApiError(res.status, path, err.code, err.detail);
+            throw new BotApiError(res.status, path, err.code, err.detail, retryAfterHeaderMs(res.headers.get("Retry-After")));
         }
         const text = await res.text();
         return { status: res.status, body: (text ? JSON.parse(text) : {}) };

package/dist/lib/bot/daemon.d.ts

@@ -81,7 +81,17 @@ export interface BotDaemonDeps {
      */
     announce?: (result: BotDaemonResult) => void;
 }
-/** Write the unit and load it (RunAtLoad starts the bot immediately). */
+export declare function launchdPlistProgramArguments(plist: string): string[];
+/** The hq script path baked into an installed unit, or null if none. */
+export declare function installedDaemonHqBinary(p: BotDaemonPaths, io?: {
+    existsSync(path: string): boolean;
+    readFileSync(path: string, encoding: "utf8"): string;
+}): string | null;
+/**
+ * Rewrite the unit when its hq path is missing or is the pre-move
+ * toolchain/node/bin/hq while toolchain/npm-global/bin/hq exists.
+ */
+export declare function repairBotDaemonIfStale(p: BotDaemonPaths, deps?: BotDaemonDeps): BotDaemonResult | null;
 export declare function installBotDaemon(p: BotDaemonPaths, deps?: BotDaemonDeps): BotDaemonResult;
 export declare function uninstallBotDaemon(p: BotDaemonPaths, deps?: BotDaemonDeps): BotDaemonResult;
 export declare function botDaemonStatus(p: BotDaemonPaths, deps?: BotDaemonDeps): BotDaemonResult;