@indigoai-us/hq-cli 5.345.197 → 5.345.199

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

@@ -3,6 +3,7 @@
  * §4, §5.5, §6.2). Finite sets are string-literal unions plus `const` arrays
  * so the command layer can validate flags explicitly.
  */
+import { type LaneOutcome } from "./outcome.js";
 export declare const LANE_SCHEMA_VERSION: "hq-lane.v1";
 export declare const QUESTION_SCHEMA_VERSION: "hq-lane-question.v1";
 export declare const ENVELOPE_SCHEMA_VERSION: "hq-lane-envelope.v1";
@@ -85,6 +86,76 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
             readonly type: readonly ["string", "null"];
             readonly description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.";
         };
+        readonly outcome: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["state", "outcome", "gathered", "next_steps"];
+            readonly properties: {
+                readonly state: {
+                    readonly enum: readonly ["done", "needs_decision", "partial"];
+                };
+                readonly outcome: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly pattern: "\\S";
+                };
+                readonly gathered: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["label", "text"];
+                        readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly pattern: "\\S";
+                            };
+                            readonly text: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly pattern: "\\S";
+                            };
+                            readonly ref: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly pattern: "\\S";
+                            };
+                        };
+                    };
+                };
+                readonly next_steps: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "\\S";
+                    };
+                };
+                readonly decision_id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly pattern: "\\S";
+                };
+            };
+            readonly allOf: readonly [{
+                readonly if: {
+                    readonly properties: {
+                        readonly state: {
+                            readonly const: "partial";
+                        };
+                    };
+                };
+                readonly then: {
+                    readonly properties: {
+                        readonly next_steps: {
+                            readonly minItems: 1;
+                        };
+                    };
+                };
+            }];
+            readonly description: string;
+        };
     };
     readonly allOf: readonly [{
         readonly if: {
@@ -171,6 +242,57 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
                 };
             };
         };
+    }, {
+        readonly if: {
+            readonly required: readonly ["outcome"];
+            readonly properties: {
+                readonly outcome: {
+                    readonly properties: {
+                        readonly state: {
+                            readonly const: "needs_decision";
+                        };
+                    };
+                };
+            };
+        };
+        readonly then: {
+            readonly anyOf: readonly [{
+                readonly properties: {
+                    readonly outcome: {
+                        readonly required: readonly ["decision_id"];
+                    };
+                };
+            }, {
+                readonly required: readonly ["questions"];
+                readonly properties: {
+                    readonly questions: {
+                        readonly minItems: 1;
+                    };
+                };
+            }];
+        };
+    }, {
+        readonly if: {
+            readonly required: readonly ["outcome"];
+            readonly properties: {
+                readonly decision: {
+                    readonly const: "blocked";
+                };
+            };
+        };
+        readonly then: {
+            readonly properties: {
+                readonly outcome: {
+                    readonly properties: {
+                        readonly state: {
+                            readonly not: {
+                                readonly const: "done";
+                            };
+                        };
+                    };
+                };
+            };
+        };
     }];
     readonly description: string;
 };
@@ -523,7 +645,15 @@ export interface LaneStory {
     verified_at?: string;
     verified_by?: SeniorRef;
 }
+export interface LaneSignal {
+    signal_id: string;
+    type: string;
+    source_ref: string;
+    title: string;
+}
 export interface LaneRecord {
+    signal?: LaneSignal;
+    signal_link?: string;
     schema_version: typeof LANE_SCHEMA_VERSION | string;
     lane_id: string;
     /** CLI release that most recently wrote this lane record. Absent on legacy rows. */
@@ -729,6 +859,11 @@ export interface LaneRecord {
     story_status?: StoryStatus;
     /** Envelope parser failures retained when a usable ask is recovered. */
     envelope_validation_errors?: string[];
+    /**
+     * Copied from the last ingested envelope's optional `outcome` block.
+     * Cleared when a later envelope carries no outcome.
+     */
+    outcome?: LaneOutcome;
     /** Set by the reconcile pass when `--timeout` has passed (spec §5.7). */
     overdue?: boolean;
     overdue_at?: string;
@@ -1027,6 +1162,8 @@ export interface LaneEnvelope {
     story_complete_reason?: string;
     /** The worker's fingerprint, or null when it could not be built. Optional. */
     fingerprint?: string | null;
+    /** Optional structured result block (see outcome.ts). */
+    outcome?: LaneOutcome;
 }
 export interface AccountConfig {
     /** Company slug or UID owning this account. Untagged accounts are personal. */

package/dist/lib/lanes/types.js

@@ -4,6 +4,7 @@
  * so the command layer can validate flags explicitly.
  */
 import { LanesError, LaneSchemaError } from "./errors.js";
+import { LANE_OUTCOME_ENVELOPE_RULES, LANE_OUTCOME_JSON_SCHEMA, parseLaneOutcome, } from "./outcome.js";
 export const LANE_SCHEMA_VERSION = "hq-lane.v1";
 export const QUESTION_SCHEMA_VERSION = "hq-lane-question.v1";
 export const ENVELOPE_SCHEMA_VERSION = "hq-lane-envelope.v1";
@@ -53,6 +54,7 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
             type: ["string", "null"],
             description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.",
         },
+        outcome: LANE_OUTCOME_JSON_SCHEMA,
     },
     allOf: [
         {
@@ -80,11 +82,16 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
                 else: { not: { required: ["story_complete_reason"] } },
             },
         },
+        ...LANE_OUTCOME_ENVELOPE_RULES,
     ],
     description: "questions is present and non-empty exactly when decision is ask. " +
         "blocked_reason is present exactly when decision is blocked. " +
         "story_complete true requires story_status done; story_complete false requires story_status other than done; " +
-        "story_complete_reason is required whenever story_complete is present.",
+        "story_complete_reason is required whenever story_complete is present. " +
+        "outcome is optional; outcome.state is done, needs_decision or partial. " +
+        "needs_decision requires outcome.decision_id or a non-empty questions[]; " +
+        "partial requires at least one outcome.next_steps entry; " +
+        "outcome.state done is rejected when decision is blocked.",
 };
 export const LANE_STATES = [
     "queued",
@@ -247,6 +254,7 @@ export const REQUIRED_LANE_RECORD_FIELDS = [
 export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spawn", "story-ledger"];
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
+    signal: ["creator"], signal_link: ["creator"],
     schema_version: ["creator"], lane_id: ["creator"], written_by_version: [], owner_written_by_version: [], company: ["creator", "command"], company_history: ["command"],
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], focus_overrides: ["command"], ledger_sync_error: ["story-ledger"], pending_question_ids: ["story-ledger"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
@@ -260,7 +268,7 @@ export const LANE_FIELD_WRITERS = {
     provider: ["creator", "command"], runner: ["creator"], remote_control: ["creator"], remote_control_title: ["creator"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], account_pick: ["creator"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["command", "watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
-    last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"], outcome: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
@@ -322,6 +330,7 @@ export function parseLaneEnvelope(raw, options = {}) {
         "story_complete",
         "story_complete_reason",
         "fingerprint",
+        "outcome",
     ].includes(key));
     if (extra.length > 0) {
         throw new LaneSchemaError(`Lane envelope rejects unknown properties: ${extra.join(", ")}`, { extra });
@@ -453,6 +462,12 @@ export function parseLaneEnvelope(raw, options = {}) {
     if (typeof raw.blocked_reason === "string") {
         envelope.blocked_reason = raw.blocked_reason;
     }
+    if (raw.outcome !== undefined) {
+        envelope.outcome = parseLaneOutcome(raw.outcome, {
+            decision: envelope.decision,
+            questionCount: envelope.questions?.length ?? 0,
+        });
+    }
     return envelope;
 }
 //# sourceMappingURL=types.js.map

package/dist/lib/lanes/watcher.js

@@ -425,6 +425,8 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
                 },
                 ...(envelope.decision !== "blocked" ? { keep_alive_blocked_resume_streak: 0 } : {}),
                 envelope_validation_errors: opts.envelopeValidationErrors,
+                // The last envelope's outcome block; undefined clears a stale one.
+                outcome: envelope.outcome,
             };
             if (!approvalGate.violation && approvalGate.approvedIdsToConsume.length > 0) {
                 next.registry_worker_approval_history = approvalGate.approvedIdsToConsume.reduce((history, approvalId) => appendCappedHistory(history, {
@@ -509,6 +511,8 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
             const storySwitch = applyStorySwitchEnvelope(current, envelope, at, envelopeRef);
             if (envelope.decision !== "blocked")
                 next.keep_alive_blocked_resume_streak = 0;
+            // The last envelope's outcome block; undefined clears a stale one.
+            next.outcome = envelope.outcome;
             next.last_envelope = {
                 ref: envelopeRef,
                 decision: envelope.decision,

package/dist/lib/live-meetings.d.ts

@@ -0,0 +1,19 @@
+export interface LiveMeetingBot {
+    meetingId?: string;
+    meetingUrl?: string;
+    recallBotId?: string;
+    botId?: string;
+    companyId?: string;
+    meetingTitle?: string;
+    title?: string;
+    status?: string;
+    scheduledStartTime?: string;
+    createdAt?: string;
+    linesSoFar?: number;
+    transcriptLineCount?: number;
+    sourceLanded?: boolean;
+    savedTranscriptPath?: string;
+}
+/** The attended list used by meetings live and the Executive's poll producer. */
+export declare function fetchAttendedLiveBots(token: string, companyId: string, strict?: boolean, signal?: AbortSignal): Promise<LiveMeetingBot[]>;
+//# sourceMappingURL=live-meetings.d.ts.map

package/dist/lib/live-meetings.js

@@ -0,0 +1,23 @@
+import { vaultApiFetch } from "../utils/vault-api.js";
+/** The attended list used by meetings live and the Executive's poll producer. */
+export async function fetchAttendedLiveBots(token, companyId, strict = false, signal) {
+    try {
+        const res = await vaultApiFetch({ token, path: "/v1/meetings", query: { companyId, view: "live" }, ...(signal ? { signal } : {}) });
+        if (!res.ok) {
+            if (strict)
+                throw new Error("Could not list attended meetings");
+            return [];
+        }
+        const data = (await res.json());
+        if (strict && !Array.isArray(data.bots))
+            throw new Error("Invalid attended meetings response");
+        return Array.isArray(data.bots) ? data.bots : [];
+    }
+    catch (err) {
+        if (strict)
+            throw err;
+        // Older servers and offline callers retain the CLI's own-notetaker list.
+        return [];
+    }
+}
+//# sourceMappingURL=live-meetings.js.map

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

@@ -12,7 +12,7 @@ import { workContextRoot } from "../../../work-context/paths.js";
 import { outboxQuarantineStatusEnabled } from "../../../work-context/outbox-quarantine-status-flag.js";
 import { formatDroppedPresenceCompany } from "./credentials.js";
 import { formatOwnerPushStatus, ownerPushStatusForAccount, readOwnerInboxPushState, } from "./owner-inbox-push.js";
-import { countDistinctHeldEvents, countJsonlLines, countUnattributedEvents, } from "../spool.js";
+import { countDistinctHeldEvents, countJsonlLines, countUnattributedEvents, forEachJsonlLine, } from "../spool.js";
 import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../paths.js";
 import { daemonDir, daemonPidPath } from "./paths.js";
 import { readEmitState } from "../emit.js";
@@ -31,11 +31,10 @@ function oldestJsonlAgeMs(filePath, nowMs) {
     if (!fs.existsSync(filePath))
         return undefined;
     try {
-        const text = fs.readFileSync(filePath, "utf8");
         let oldest;
-        for (const line of text.split("\n")) {
+        forEachJsonlLine(filePath, (line) => {
             if (!line.trim())
-                continue;
+                return;
             try {
                 const obj = JSON.parse(line);
                 const at = (typeof obj.at === "string" && obj.at) ||
@@ -43,10 +42,10 @@ function oldestJsonlAgeMs(filePath, nowMs) {
                     (obj.event && typeof obj.event.at === "string" && obj.event.at) ||
                     undefined;
                 if (!at)
-                    continue;
+                    return;
                 const t = Date.parse(at);
                 if (!Number.isFinite(t))
-                    continue;
+                    return;
                 const age = nowMs - t;
                 if (oldest === undefined || age > oldest)
                     oldest = age;
@@ -54,7 +53,7 @@ function oldestJsonlAgeMs(filePath, nowMs) {
             catch {
                 /* skip */
             }
-        }
+        });
         return oldest;
     }
     catch {

package/dist/lib/mesh/live/spool.d.ts

@@ -44,6 +44,14 @@ export declare function recoverOrphanClaims(root: string): {
 };
 export declare function removeClaimFile(claimPath: string | null): void;
 export declare function deadLetterNonEmpty(root?: string): boolean;
+/**
+ * Visit each line of a JSONL file without loading the whole file into one
+ * string. Queue files (dead-letter especially) can grow past V8's ~512 MB
+ * string ceiling, where readFileSync(..., "utf8") throws. Splits on the raw
+ * newline byte so multi-byte UTF-8 sequences are never cut. Returns false when
+ * the file cannot be opened.
+ */
+export declare function forEachJsonlLine(filePath: string, visit: (line: string) => void): boolean;
 export declare function countJsonlLines(filePath: string): number;
 /** Count held eventIds once; legacy rows without an eventId remain line-counted. */
 export declare function countDistinctHeldEvents(filePath: string): number;

package/dist/lib/mesh/live/spool.js

@@ -334,40 +334,71 @@ export function deadLetterNonEmpty(root) {
         return false;
     }
 }
+/** Chunk size for streaming JSONL reads. */
+const JSONL_READ_CHUNK_BYTES = 1024 * 1024;
+/**
+ * Visit each line of a JSONL file without loading the whole file into one
+ * string. Queue files (dead-letter especially) can grow past V8's ~512 MB
+ * string ceiling, where readFileSync(..., "utf8") throws. Splits on the raw
+ * newline byte so multi-byte UTF-8 sequences are never cut. Returns false when
+ * the file cannot be opened.
+ */
+export function forEachJsonlLine(filePath, visit) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+    }
+    catch {
+        return false;
+    }
+    try {
+        const chunk = Buffer.alloc(JSONL_READ_CHUNK_BYTES);
+        let carry = Buffer.alloc(0);
+        for (;;) {
+            const n = fs.readSync(fd, chunk, 0, chunk.length, null);
+            if (n <= 0)
+                break;
+            let data = carry.length > 0 ? Buffer.concat([carry, chunk.subarray(0, n)]) : chunk.subarray(0, n);
+            let start = 0;
+            for (let nl = data.indexOf(0x0a, start); nl !== -1; nl = data.indexOf(0x0a, start)) {
+                visit(data.toString("utf8", start, nl));
+                start = nl + 1;
+            }
+            carry = Buffer.from(data.subarray(start));
+            data = Buffer.alloc(0);
+        }
+        if (carry.length > 0)
+            visit(carry.toString("utf8"));
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return true;
+}
 export function countJsonlLines(filePath) {
-    if (!fs.existsSync(filePath))
-        return 0;
-    const raw = fs.readFileSync(filePath, "utf8");
     let n = 0;
-    for (const line of raw.split("\n")) {
+    forEachJsonlLine(filePath, (line) => {
         if (line.trim())
             n += 1;
-    }
+    });
     return n;
 }
 /** Count held eventIds once; legacy rows without an eventId remain line-counted. */
 export function countDistinctHeldEvents(filePath) {
-    let raw;
-    try {
-        raw = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        // A concurrent claim can rename held.jsonl between existence and read checks.
-        return 0;
-    }
     const seen = new Set();
     let count = 0;
-    for (const line of raw.split("\n")) {
+    // A concurrent claim can rename held.jsonl away; a missing file counts as 0.
+    forEachJsonlLine(filePath, (line) => {
         if (!line.trim())
-            continue;
+            return;
         const eventId = heldEventId(line);
         if (eventId) {
             if (seen.has(eventId))
-                continue;
+                return;
             seen.add(eventId);
         }
         count += 1;
-    }
+    });
     return count;
 }
 function record(value) {
@@ -413,17 +444,12 @@ function isUnattributedLine(line) {
     }
 }
 function countUnattributedJsonlLines(filePath) {
-    if (!fs.existsSync(filePath))
-        return 0;
-    try {
-        return fs
-            .readFileSync(filePath, "utf8")
-            .split("\n")
-            .filter((line) => line.trim() && isUnattributedLine(line)).length;
-    }
-    catch {
-        return 0;
-    }
+    let n = 0;
+    forEachJsonlLine(filePath, (line) => {
+        if (line.trim() && isUnattributedLine(line))
+            n += 1;
+    });
+    return n;
 }
 /**
  * Count the actionable, unfiled events across all local delivery queues.
@@ -438,27 +464,20 @@ export function countUnattributedEvents(root) {
     return { spool, held, deadLetter, total: spool + held + deadLetter };
 }
 function countUnattributedHeldEvents(filePath) {
-    let raw;
-    try {
-        raw = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        // A concurrent held claim may rename this file between the read and open.
-        return 0;
-    }
     const seen = new Set();
     let count = 0;
-    for (const line of raw.split("\n")) {
+    // A concurrent held claim may rename this file away; a missing file counts as 0.
+    forEachJsonlLine(filePath, (line) => {
         if (!line.trim() || !isUnattributedLine(line))
-            continue;
+            return;
         const eventId = heldEventId(line);
         if (eventId) {
             if (seen.has(eventId))
-                continue;
+                return;
             seen.add(eventId);
         }
         count += 1;
-    }
+    });
     return count;
 }
 //# sourceMappingURL=spool.js.map

package/dist/lib/plan-limit-nag.d.ts

@@ -49,6 +49,28 @@ export declare const OVER_NAG_INTERVAL_MS: number;
  * as the bare key rather than a guess.
  */
 export declare const PLAN_LIMIT_DIMENSION_LABELS: Record<string, string>;
+/**
+ * The account a nag payload is about, as hq-pro labels it (`account` beside
+ * `planLimits`). One command can touch a personal vault and a company vault,
+ * so the line names which one is over (feedback_b1867fe6).
+ */
+export type PlanLimitAccount = {
+    kind: "person";
+} | {
+    kind: "company";
+    slug: string | null;
+};
+/**
+ * Render one amount of a resource. Storage arrives in bytes; printed raw it
+ * reads as "47012700666 of 10737418240". It is shown in GB with one decimal,
+ * so a 10 GB ceiling reads "10.0 GB", matching the plan's own wording.
+ */
+export declare function formatPlanLimitAmount(key: string, n: number): string;
+/**
+ * The account as a noun phrase: "your personal account", "the acme company",
+ * or "this account" when an older hq-pro sent no label.
+ */
+export declare function planLimitAccountPhrase(account: PlanLimitAccount | null | undefined): string;
 export interface PlanLimitEntry {
     used: number;
     limit: number;
@@ -75,10 +97,13 @@ export declare function recordPlanLimitStatus(body: unknown, opts?: {
 /**
  * The over-limit per-turn line (US-036 §2.2). One line, not the old box: it
  * now repeats up to four times a day, and a multi-line box at that cadence
- * reads as breakage rather than as a nag. It states the two paused things and
- * never claims the workspace has stopped working.
+ * reads as breakage rather than as a nag. It names the account and states the
+ * facts. It claims no pause: being over is not being refused. A refusal comes
+ * back from hq-pro as its own error with its own sentence, and that is the
+ * only place a pause is reported (feedback_b1867fe6, where this line told a
+ * person their uploads were paused right after two uploads succeeded).
  */
-export declare function buildOverLine(overEntries: Array<[string, PlanLimitEntry]>, upgradeUrl: string): string;
+export declare function buildOverLine(overEntries: Array<[string, PlanLimitEntry]>, upgradeUrl: string, account?: PlanLimitAccount | null): string;
 /**
  * The notice a personal feature refusal prints. `upgradeUrl` is the server's
  * own checkout target; an older hq-pro sends none, and the line then names the
@@ -95,7 +120,7 @@ export declare function renderPersonalPlanFeatureNotice(feature: string, upgrade
  * their own story, and a notice that announces a pause nobody is experiencing
  * reads as a bug.
  */
-export declare function renderThresholdNotice(crossing: PlanLimitThresholdCrossing, upgradeUrl: string): string;
+export declare function renderThresholdNotice(crossing: PlanLimitThresholdCrossing, upgradeUrl: string, account?: PlanLimitAccount | null): string;
 /**
  * Print every crossing this machine has not already printed for this episode.
  *
@@ -106,6 +131,7 @@ export declare function renderThresholdNotice(crossing: PlanLimitThresholdCrossi
 export declare function emitPlanLimitThresholdNotice(crossings: readonly PlanLimitThresholdCrossing[], upgradeUrl: string | null, opts?: {
     write?: (s: string) => void;
     statePath?: string;
+    account?: PlanLimitAccount | null;
 }): void;
 /**
  * Emit a plan-limit nag to stderr at command completion.