@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/mesh/live/session-event.schema.json

@@ -109,30 +109,7 @@
       "type": "string",
       "minLength": 1,
       "maxLength": 280,
-      "description": "Optional short summary on note, blocked, task_status, and session_end (US-051 quiet report). Redacted; never raw prompts, tokens, or file contents."
-    },
-    "repo": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 128,
-      "description": "Optional git repository basename on session_end for the quiet work report (US-051)."
-    },
-    "gitBranch": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 128,
-      "description": "Optional git branch of the session cwd on session_end (US-051)."
-    },
-    "prUrls": {
-      "type": "array",
-      "maxItems": 5,
-      "items": {
-        "type": "string",
-        "minLength": 1,
-        "maxLength": 256,
-        "pattern": "^https://github\\.com/"
-      },
-      "description": "Optional pull-request URLs seen in the quiet window (US-051)."
+      "description": "Optional short summary allowed only on note, blocked, and task_status. Never prompt-derived content."
     },
     "cwd": {
       "type": "string",

package/dist/lib/mesh/live/session-events-client.d.ts

@@ -23,7 +23,6 @@ export interface SessionEventsPostResult {
     body: unknown;
     ok: boolean;
     retryable: boolean;
-    retryAfterMs?: number;
     networkError?: boolean;
 }
 /** Contract §2.3 batch ingest ack (parsed from a 2xx body). */
@@ -52,7 +51,6 @@ export declare function createSessionEventsPoster(opts: {
     post?: (path: string, body: SessionEventsBatchBody) => Promise<{
         status: number;
         body: unknown;
-        headers?: Pick<Headers, "get">;
     }>;
 }): SessionEventsPoster;
 /** Resolve API base: HQ_VAULT_API_URL overrides DEFAULT_VAULT_API_URL. */

package/dist/lib/mesh/live/session-events-client.js

@@ -15,28 +15,6 @@ export const WRITABLE_CONTEXT_STATUSES = new Set([
     "bound",
     "migration_pending",
 ]);
-/** Parse the Retry-After delta-seconds or HTTP-date form into milliseconds. */
-function parseRetryAfterMs(value, nowMs = Date.now()) {
-    if (value === null || !value.trim())
-        return undefined;
-    const trimmed = value.trim();
-    if (/^\d+$/.test(trimmed)) {
-        const delayMs = Number(trimmed) * 1_000;
-        return Number.isSafeInteger(delayMs) && delayMs > 0 ? delayMs : undefined;
-    }
-    if (/^[+-]/.test(trimmed))
-        return undefined;
-    const retryAtMs = Date.parse(trimmed);
-    if (!Number.isFinite(retryAtMs))
-        return undefined;
-    const delayMs = retryAtMs - nowMs;
-    return delayMs > 0 ? delayMs : undefined;
-}
-function retryAfterForStatus(status, headers) {
-    if (status !== 429 && status !== 503)
-        return undefined;
-    return parseRetryAfterMs(headers?.get("retry-after") ?? null);
-}
 /**
  * Parse a batch ingest response body. Returns null when the body is not an
  * object (caller should retain events rather than treating them as posted).
@@ -87,11 +65,9 @@ export function createSessionEventsPoster(opts) {
         try {
             if (opts.post) {
                 const res = await opts.post(SESSION_EVENTS_PATH, body);
-                const retryAfterMs = retryAfterForStatus(res.status, res.headers);
                 return {
                     status: res.status,
                     body: res.body,
-                    ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
                     ...classifySessionEventsResponse(res.status),
                 };
             }
@@ -112,11 +88,9 @@ export function createSessionEventsPoster(opts) {
                     parsed = { raw: text };
                 }
             }
-            const retryAfterMs = retryAfterForStatus(res.status, res.headers);
             return {
                 status: res.status,
                 body: parsed,
-                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
                 ...classifySessionEventsResponse(res.status),
             };
         }

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

@@ -19,10 +19,6 @@ export declare function ensureSpoolFile(filePath: string): void;
 export declare function appendJsonlLine(filePath: string, line: string): void;
 export declare function appendSpoolLine(line: string, root?: string): string;
 export declare function appendHeldLine(line: string, root?: string): string;
-/** Append a held envelope only when its eventId is not already held. */
-export declare function appendHeldLineIfAbsent(line: string, root?: string): boolean;
-/** Append a deduplicated held batch under one file lock and one write. */
-export declare function appendHeldLinesIfAbsent(lines: string[], root?: string): number;
 export declare function appendDeadLetterLine(line: string, root?: string): string;
 export declare function appendDroppedReceipt(receipt: Record<string, unknown>, root?: string): string;
 export interface ClaimResult {
@@ -53,19 +49,4 @@ export declare function recoverOrphanClaims(root: string): {
 export declare function removeClaimFile(claimPath: string | null): void;
 export declare function deadLetterNonEmpty(root?: string): 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;
-/** Local queues that still lack a usable company attribution. */
-export interface UnattributedEventCounts {
-    spool: number;
-    held: number;
-    deadLetter: number;
-    total: number;
-}
-/**
- * Count the actionable, unfiled events across all local delivery queues.
- * This deliberately does not inspect session state: the signal must stay
- * visible even when state is absent or corrupt.
- */
-export declare function countUnattributedEvents(root?: string): UnattributedEventCounts;
 //# sourceMappingURL=spool.d.ts.map

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

@@ -5,7 +5,6 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomBytes } from "node:crypto";
 import { ensureOwnerDir } from "../../work-context/atomic.js";
 import { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "./paths.js";
 /** Linux PIPE_BUF is typically 4096; keep a conservative ceiling for one line. */
@@ -66,160 +65,12 @@ export function appendSpoolLine(line, root) {
 }
 export function appendHeldLine(line, root) {
     const held = workMeshHeldPath(root ?? workMeshRoot());
-    appendHeldLineIfAbsent(line, root);
+    appendJsonlLine(held, line);
     return held;
 }
-/** Append a held envelope only when its eventId is not already held. */
-export function appendHeldLineIfAbsent(line, root) {
-    return appendHeldLinesIfAbsent([line], root) === 1;
-}
-/** Append a deduplicated held batch under one file lock and one write. */
-export function appendHeldLinesIfAbsent(lines, root) {
-    const heldPath = workMeshHeldPath(root ?? workMeshRoot());
-    ensureSpoolFile(heldPath);
-    return withJsonlLock(heldPath, () => {
-        const seen = readEventIds(heldPath);
-        const append = [];
-        for (const line of lines) {
-            const eventId = heldEventId(line);
-            if (eventId) {
-                if (seen.has(eventId))
-                    continue;
-                seen.add(eventId);
-            }
-            append.push(line);
-        }
-        appendJsonlLines(heldPath, append);
-        return append.length;
-    });
-}
-function heldEventId(line) {
-    try {
-        const parsed = JSON.parse(line);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return null;
-        const record = parsed;
-        const event = record.event && typeof record.event === "object" && !Array.isArray(record.event)
-            ? record.event
-            : record;
-        return typeof event.eventId === "string" && event.eventId.trim() ? event.eventId.trim() : null;
-    }
-    catch {
-        return null;
-    }
-}
-function readEventIds(filePath) {
-    const ids = new Set();
-    let raw;
-    try {
-        raw = fs.readFileSync(filePath, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return ids;
-        throw error;
-    }
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        const eventId = heldEventId(line);
-        if (eventId)
-            ids.add(eventId);
-    }
-    return ids;
-}
-function appendJsonlLines(filePath, lines) {
-    if (lines.length === 0)
-        return;
-    ensureSpoolFile(filePath);
-    fs.appendFileSync(filePath, `${lines.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
-    chmodOwnerFile(filePath);
-}
-const JSONL_LOCK_STALE_MS = 5 * 60_000;
-const JSONL_LOCK_TIMEOUT_MS = 5_000;
-/** Serialize check-and-append with claims; stale locks expire after five minutes. */
-function withJsonlLock(filePath, fn) {
-    const lockPath = `${filePath}.lock`;
-    const token = randomBytes(12).toString("hex");
-    const deadline = Date.now() + JSONL_LOCK_TIMEOUT_MS;
-    const waitCell = new Int32Array(new SharedArrayBuffer(4));
-    while (true) {
-        try {
-            const fd = fs.openSync(lockPath, "wx", 0o600);
-            try {
-                fs.writeSync(fd, JSON.stringify({ pid: process.pid, token, at: Date.now() }));
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-            break;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            let stale = false;
-            try {
-                const before = fs.statSync(lockPath);
-                stale = Date.now() - before.mtimeMs >= JSONL_LOCK_STALE_MS;
-                if (stale) {
-                    const after = fs.statSync(lockPath);
-                    if (before.dev === after.dev && before.ino === after.ino && after.mtimeMs === before.mtimeMs) {
-                        fs.unlinkSync(lockPath);
-                    }
-                    else {
-                        stale = false;
-                    }
-                }
-            }
-            catch (statError) {
-                if (statError.code !== "ENOENT")
-                    throw statError;
-            }
-            if (stale)
-                continue;
-            if (Date.now() >= deadline)
-                throw new SpoolWriteError(`Timed out waiting for ${path.basename(filePath)} lock`);
-            Atomics.wait(waitCell, 0, 0, 10);
-        }
-    }
-    let result;
-    let operationError;
-    let operationFailed = false;
-    try {
-        result = fn();
-    }
-    catch (error) {
-        operationError = error;
-        operationFailed = true;
-    }
-    let cleanupError;
-    try {
-        const record = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-        if (record.token === token)
-            fs.unlinkSync(lockPath);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            cleanupError = error;
-    }
-    if (operationFailed && cleanupError !== undefined) {
-        throw new AggregateError([operationError, cleanupError], "JSONL write and lock cleanup failed");
-    }
-    if (operationFailed)
-        throw operationError;
-    if (cleanupError !== undefined)
-        throw cleanupError;
-    return result;
-}
 export function appendDeadLetterLine(line, root) {
     const dl = workMeshDeadLetterPath(root ?? workMeshRoot());
-    withJsonlLock(dl, () => {
-        ensureSpoolFile(dl);
-        const ids = readEventIds(dl);
-        const eventId = heldEventId(line);
-        if (!eventId || !ids.has(eventId))
-            appendJsonlLine(dl, line);
-    });
+    appendJsonlLine(dl, line);
     return dl;
 }
 export function appendDroppedReceipt(receipt, root) {
@@ -257,8 +108,7 @@ export function claimSpool(root, ts = `${Date.now()}`) {
 }
 export function claimHeld(root, ts = `${Date.now()}`) {
     ensureOwnerDir(root);
-    const heldPath = workMeshHeldPath(root);
-    return withJsonlLock(heldPath, () => claimJsonlByRename(heldPath, workMeshClaimPath("held", ts, root)));
+    return claimJsonlByRename(workMeshHeldPath(root), workMeshClaimPath("held", ts, root));
 }
 /** Match leftover claim files: spool.<ts>.claimed / held.<ts>.claimed (and held.<ts>.held.claimed). */
 const ORPHAN_CLAIM_RE = /^(spool|held)\..+\.claimed$/;
@@ -345,120 +195,4 @@ export function countJsonlLines(filePath) {
     }
     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")) {
-        if (!line.trim())
-            continue;
-        const eventId = heldEventId(line);
-        if (eventId) {
-            if (seen.has(eventId))
-                continue;
-            seen.add(eventId);
-        }
-        count += 1;
-    }
-    return count;
-}
-function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-/**
- * A queue line can be a raw event, a held envelope, or a dead-letter
- * envelope. Count the line when it is explicitly marked NEEDS_COMPANY/NONE,
- * or when its underlying event has no company identity at all.
- */
-function isUnattributedLine(line) {
-    try {
-        const outer = record(JSON.parse(line));
-        if (!outer)
-            return false;
-        const event = record(outer.event) ?? outer;
-        const markers = [
-            outer.heldReason,
-            outer.reason,
-            outer.contextStatus,
-            event.heldReason,
-            event.reason,
-            event.contextStatus,
-            event.company,
-            event.companyUid,
-            event.companySlug,
-        ];
-        if (markers.some((value) => typeof value === "string" &&
-            ["NEEDS_COMPANY", "NONE"].includes(value.trim().toUpperCase()))) {
-            return true;
-        }
-        return ![
-            event.companyUid,
-            event.companySlug,
-            event.company,
-        ].some((value) => typeof value === "string" && value.trim().length > 0);
-    }
-    catch {
-        // Malformed lines are reported separately by the dead-letter count.
-        return false;
-    }
-}
-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;
-    }
-}
-/**
- * Count the actionable, unfiled events across all local delivery queues.
- * This deliberately does not inspect session state: the signal must stay
- * visible even when state is absent or corrupt.
- */
-export function countUnattributedEvents(root) {
-    const meshRoot = root ?? workMeshRoot();
-    const spool = countUnattributedJsonlLines(workMeshSpoolPath(meshRoot));
-    const held = countUnattributedHeldEvents(workMeshHeldPath(meshRoot));
-    const deadLetter = countUnattributedJsonlLines(workMeshDeadLetterPath(meshRoot));
-    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")) {
-        if (!line.trim() || !isUnattributedLine(line))
-            continue;
-        const eventId = heldEventId(line);
-        if (eventId) {
-            if (seen.has(eventId))
-                continue;
-            seen.add(eventId);
-        }
-        count += 1;
-    }
-    return count;
-}
 //# sourceMappingURL=spool.js.map

package/dist/lib/mesh/live/validate-session-event.d.ts

@@ -8,7 +8,7 @@
 import type { ValidateFunction } from "ajv";
 export declare const SESSION_EVENT_SCHEMA_PATH: string;
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export declare const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
+export declare const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
 export declare const PROHIBITED_CONTENT_CLASSES: readonly ["prompts", "model_output", "transcripts", "message_bodies", "tokens", "credentials"];
 export type ProhibitedContentClass = (typeof PROHIBITED_CONTENT_CLASSES)[number];
 /** Fixture field name → prohibited class. */

package/dist/lib/mesh/live/validate-session-event.js

@@ -13,7 +13,7 @@ import Ajv2020 from "ajv/dist/2020.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const SESSION_EVENT_SCHEMA_PATH = join(HERE, "session-event.schema.json");
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
+export const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
 export const PROHIBITED_CONTENT_CLASSES = [
     "prompts",
     "model_output",

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

@@ -5,49 +5,17 @@
  * some 2xx JSON response bodies (US-012). This module:
  *
  *   1. Best-effort records the last-seen status from decoded JSON bodies
- *      (`recordPlanLimitStatus`), and prints the one-time threshold notice
- *      right there — see below.
+ *      (`recordPlanLimitStatus`).
  *   2. Emits a stderr nag at command completion (`emitPlanLimitNag`):
  *      - entries present, none over (≥80% warning): one-line yellow warning,
  *        once per process session
- *      - any resource over: one-line notice, at most once every 6 hours
- *        (persisted in `~/.hq/plan-limit-nag.json`) and once per session
- *
- * The one-time threshold notice (US-035) is the third surface and the only one
- * that does NOT wait for command completion. hq-pro attaches
- * `thresholdCrossings: [{ resource, band, firstSeenAt, used, limit }]` beside
- * `planLimits`, populated from the server's own threshold state, and this
- * module prints each `{resource}:{band}` exactly once per EPISODE — persisted
- * in `~/.hq/plan-limit-nag.json` under `notifiedThresholds`. It prints from the
- * record path so a session that is already running surfaces the notice on its
- * next API call rather than on its next launch, which is the whole point of
- * carrying the crossing on the wire instead of recomputing it locally.
- *
- * "Once per episode", not once per lifetime: the stored value is the server's
- * `firstSeenAt`, so a dimension that drops back under the threshold and climbs
- * again arrives with a new timestamp and notifies again. The server decides
- * when an episode ends; this module only remembers what it has printed.
+ *      - any resource over: boxed notice, at most once per day (persisted in
+ *        `~/.hq/plan-limit-nag.json`) and once per session
  *
  * Additive only — never throws, never touches `process.exitCode`, never
- * writes to stdout. Env off-switch: `HQ_NO_PLAN_LIMIT_NAG=1` silences all
- * three surfaces, the threshold notice included.
- */
-export declare const PLAN_LIMIT_UPGRADE_URL = "https://hq.computer/billing/upgrade";
-/**
- * Cadence of the over-limit per-turn line (US-036). Was once a day; the nag
- * model wants it more often than that and still not on every turn, so the
- * window is six hours — up to four lines in a day for someone working all day,
- * and one for someone who runs a single command.
+ * writes to stdout. Env off-switch: `HQ_NO_PLAN_LIMIT_NAG=1`.
  */
-export declare const OVER_NAG_INTERVAL_MS: number;
-/**
- * Plain-English name for each plan-limit resource key, so a nag line says which
- * dimension is tight rather than only the wire key. The key itself stays in the
- * copy — hooks and support transcripts match on it — and the label is appended
- * only when it differs. An unknown key (a resource this CLI predates) renders
- * as the bare key rather than a guess.
- */
-export declare const PLAN_LIMIT_DIMENSION_LABELS: Record<string, string>;
+export declare const PLAN_LIMIT_UPGRADE_URL = "https://app.indigo-hq.com/billing/upgrade";
 export interface PlanLimitEntry {
     used: number;
     limit: number;
@@ -55,76 +23,12 @@ export interface PlanLimitEntry {
 }
 /** Validated map of resource key → entry. */
 export type PlanLimitsMap = Record<string, PlanLimitEntry>;
-/** The two bands hq-pro reports. Anything else on the wire is ignored. */
-export declare const PLAN_LIMIT_BANDS: readonly ["warn", "over"];
-export type PlanLimitBand = (typeof PLAN_LIMIT_BANDS)[number];
-/** One server-announced threshold crossing, as it arrives on the wire. */
-export interface PlanLimitThresholdCrossing {
-    resource: string;
-    band: PlanLimitBand;
-    /** ISO time the server first recorded this band — the episode identity. */
-    firstSeenAt: string;
-    used: number;
-    limit: number;
-}
 /**
  * Record plan-limit status from a decoded JSON response body.
  * Never throws. Overwrites the last-seen cell when a well-formed
  * `planLimits` object is present; ignores malformed / absent payloads.
  */
-export declare function recordPlanLimitStatus(body: unknown, opts?: {
-    write?: (s: string) => void;
-    statePath?: string;
-}): void;
-/**
- * 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.
- */
-export declare function buildOverLine(overEntries: Array<[string, PlanLimitEntry]>, upgradeUrl: string): string;
-/**
- * My Telemetry is an Individual-plan feature on a personal scope (owner
- * decision 9 / us-044-individual-plan-design.md §11). When hq-pro refuses it,
- * the CLI prints this notice INSTEAD of telemetry output.
- *
- * It lives beside the nag copy so plan wording stays in one file, but it is
- * NOT part of the nag model: no persistence, no throttle, no episode state. It
- * is rendered once, on the spot, by whoever received the refusal. The refusal
- * is a plan fact, so it neither counts toward the nag bands nor is silenced by
- * the nag cadence.
- *
- * Copy names the plan and its price only — no Outposts, no bot pricing (owner
- * decisions 10 and 11).
- */
-export declare const INDIVIDUAL_PLAN_NAME = "Individual";
-export declare const INDIVIDUAL_PRICE_LABEL = "$50/mo";
-/**
- * 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
- * plan without a link rather than inventing one.
- */
-export declare function renderPersonalPlanFeatureNotice(feature: string, upgradeUrl?: string | null): string;
-/**
- * One line per crossing.
- *
- * The copy states the fact and the exit, nothing else. It deliberately does
- * not describe consequences that have not shipped: the hard stops arrive with
- * 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;
-/**
- * Print every crossing this machine has not already printed for this episode.
- *
- * Called from the record path, so a session already running prints on its next
- * API call. Never throws; a state file it cannot read or write degrades to
- * per-process dedupe rather than to silence or to repetition.
- */
-export declare function emitPlanLimitThresholdNotice(crossings: readonly PlanLimitThresholdCrossing[], upgradeUrl: string | null, opts?: {
-    write?: (s: string) => void;
-    statePath?: string;
-}): void;
+export declare function recordPlanLimitStatus(body: unknown): void;
 /**
  * Emit a plan-limit nag to stderr at command completion.
  *