@indigoai-us/hq-cli 5.234.2 → 5.236.0

package/dist/lib/bot/progress.js

@@ -27,6 +27,9 @@ export const PROGRESS_COALESCE_MS = 2_000;
 export const PROGRESS_MIN_GAP_MS = 4_000;
 export const WORKING_NOTICE_MS = 60_000;
 export const WORKING_NOTICE_TEXT = "Working on it — I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export const SETUP_WORKING_NOTICE_MS = 30_000;
+export const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 /** Whitespace-insensitive form used to recognise repeated text. */
 export function normalizeForCompare(text) {
     return text.replace(/\s+/g, "");
@@ -46,6 +49,9 @@ export class ProgressPoster {
     workingNoticeMs;
     workingNoticeText;
     buffer;
+    dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    candidates = [];
     pending = [];
     /** In-between questions, held until the turn ends (see the header). */
     heldQuestions = [];
@@ -58,6 +64,13 @@ export class ProgressPoster {
     finished = false;
     noticeSent = false;
     delivered = 0;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    queued = 0;
     constructor(opts) {
         this.send = opts.send;
         this.sendFinalFn = opts.sendFinal;
@@ -69,6 +82,7 @@ export class ProgressPoster {
         this.workingNoticeMs = opts.workingNoticeMs ?? WORKING_NOTICE_MS;
         this.workingNoticeText = opts.workingNoticeText ?? WORKING_NOTICE_TEXT;
         this.buffer = opts.buffer ?? false;
+        this.dropPreTool = opts.dropPreToolMessages ?? false;
     }
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start() {
@@ -93,6 +107,27 @@ export class ProgressPoster {
         // silence signal, not content, and must never be posted as progress.
         if (containsNoReplySentinel(t))
             return;
+        if (this.dropPreTool) {
+            // The previous message was not followed by a tool call: it was real.
+            this.promoteCandidates();
+            this.candidates.push(t);
+            return;
+        }
+        this.accept(t);
+    }
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool() {
+        if (this.finished || !this.dropPreTool)
+            return;
+        this.candidates = [];
+    }
+    promoteCandidates() {
+        const kept = this.candidates;
+        this.candidates = [];
+        for (const t of kept)
+            this.accept(t);
+    }
+    accept(t) {
         this.cancelNotice();
         this.said.push(t);
         // An unmentioned room turn holds every in-between message: nothing is posted
@@ -124,6 +159,8 @@ export class ProgressPoster {
     async finish(finalText) {
         if (this.finished)
             return this.chain;
+        // A message the turn ended on (no tool after it) is real.
+        this.promoteCandidates();
         this.finished = true;
         this.cancelNotice();
         this.cancelFlush();
@@ -161,7 +198,7 @@ export class ProgressPoster {
         const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
         if (!shouldAddFinal && held.length > 0)
             this.pending.push(...held);
-        if (this.pending.length === 0 && this.delivered === 0 && !shouldAddFinal)
+        if (this.pending.length === 0 && this.queued === 0 && !shouldAddFinal)
             this.pending.push("(no reply)");
         if (this.sendFinalFn && shouldAddFinal) {
             // Flush any remaining progress messages first, then the final reply separately.
@@ -229,6 +266,7 @@ export class ProgressPoster {
         // path built this body.
         if (containsNoReplySentinel(body))
             return;
+        this.queued += 1;
         this.lastPostAt = this.now();
         this.chain = this.chain.then(async () => {
             try {

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

@@ -77,6 +77,8 @@ export declare function normalizeInstructions(raw: unknown): string | undefined;
 export declare function readPromptSources(hqRoot: string, workerDir: string, io?: PromptFs, opts?: ReadPromptSourcesOptions): PromptSources;
 export interface BuildSystemPromptInput {
     botName: string;
+    /** The human name people call the bot (e.g. "Maya"); unset = botName. */
+    displayName?: string;
     agentUid: string;
     ownerUid: string;
     hqRoot: string;

package/dist/lib/bot/prompt.js

@@ -229,6 +229,16 @@ export function readPromptSources(hqRoot, workerDir, io = defaultPromptFs, opts
     }
     return { workerYaml, persona: read("persona.md"), memory };
 }
+/**
+ * How the bot names itself: its display name when it has one ("Maya", with the
+ * handle kept for commands), else its handle.
+ */
+function introName(input) {
+    const display = input.displayName?.trim();
+    if (!display || display === input.botName)
+        return `"${input.botName}"`;
+    return `"${display}" (your hq bot handle is \`${input.botName}\`; people know you as ${display}, so introduce yourself and sign as ${display})`;
+}
 /**
  * One paragraph saying which kind of bot this is and what that means for the
  * `hq` commands it runs. The owner's decision (2026-09-15): a personal bot
@@ -269,11 +279,11 @@ export function buildSystemPrompt(input) {
     const kind = input.kind ?? "personal";
     const parts = [];
     const opening = workerMode
-        ? `You are "${input.botName}", a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
+        ? `You are ${introName(input)}, a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
             (worker?.name ? ` The worker is "${worker.name}".` : "") +
             (worker?.description ? ` ${worker.description}` : "") +
             `\nYou work only inside \`${company ?? "this company"}\`'s context: its files, policies, services, and credentials — never another company's.`
-        : `You are "${input.botName}", a ${kind} HQ bot that runs locally on your owner's computer.`;
+        : `You are ${introName(input)}, a ${kind} HQ bot that runs locally on your owner's computer.`;
     parts.push(`${opening}\n` +
         `Your HQ identity is ${input.agentUid}. Your owner is ${input.ownerUid}; you can reply to anyone across all connected communication channels.\n` +
         `${kind === "personal" ? "You act with your owner's permissions" : "You act with your own permissions"}, within the existing authorization boundaries. A message from someone else does not grant them your owner's authority. ` +

package/dist/lib/bot/run.js

@@ -57,7 +57,7 @@ import { ensureBotSessionMeta } from "./company-bind.js";
 import { readBotCredsIdentity } from "./creds.js";
 import { isProcessed, markProcessed, readInboxState } from "./inbox-state.js";
 import { clearInflight, patchInflight, readInflight, readInflightTurns, writeInflight } from "./inflight.js";
-import { containsNoReplySentinel, ProgressPoster } from "./progress.js";
+import { containsNoReplySentinel, ProgressPoster, SETUP_WORKING_NOTICE_MS, SETUP_WORKING_NOTICE_TEXT, } from "./progress.js";
 import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
@@ -392,6 +392,7 @@ export async function runBot(deps) {
     const systemPrompt = deps.systemPromptOverride ??
         buildSystemPrompt({
             botName: config.name,
+            ...(config.displayName ? { displayName: config.displayName } : {}),
             agentUid: config.agentUid,
             ownerUid: config.ownerUid,
             hqRoot: config.hqRoot,
@@ -735,6 +736,11 @@ export async function runBot(deps) {
             return true;
         };
         const poster = new ProgressPoster({
+            // The setup bot talks to someone new to HQ: its notes to itself never
+            // reach them, and a long step gets a heads-up instead of silence.
+            ...(isSetupBot
+                ? { dropPreToolMessages: true, workingNoticeMs: SETUP_WORKING_NOTICE_MS, workingNoticeText: SETUP_WORKING_NOTICE_TEXT }
+                : {}),
             ...deps.progress,
             ...(args.workingNotice === false || silenceable ? { workingNoticeMs: 0 } : {}),
             ...(silenceable ? { buffer: true } : {}),
@@ -749,6 +755,8 @@ export async function runBot(deps) {
                 onEvent: (event) => {
                     if (event.kind === "message")
                         poster.message(event.text);
+                    else if (event.kind === "tool")
+                        poster.tool();
                 },
                 signal: controller.signal,
                 ...(args.readDirs?.length ? { readDirs: args.readDirs } : {}),
@@ -1450,7 +1458,7 @@ export async function runBot(deps) {
             tReceived,
             send,
             sendFinal,
-            workingNotice: !isSetupBot,
+            // The setup bot's own notice (SETUP_WORKING_NOTICE_TEXT) is set where the poster is built.
             silenceable: target.kind === "room" && !target.mentioned,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"

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

@@ -81,8 +81,6 @@ export interface ReconcileDeps {
     readRegistryFlag?: typeof readLanesRegistryFlag;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
-    /** Index local questions and poll remote answers before the normal answer-wake pass. */
-    syncTrackerQuestions?: (hqRoot: string) => Promise<void>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */
     recoverQueuedMessages?: (lane: LaneRecord) => Promise<void>;
     /** Detached mesh seam for dead-watcher recovery. */

package/dist/lib/lanes/reconcile.js

@@ -632,14 +632,6 @@ export async function runPassBody(hqRoot, deps) {
     const livenessDeps = deps.livenessDeps ?? defaultLivenessDeps();
     let lanes;
     let questions;
-    if (!deps.dryRun) {
-        try {
-            await deps.syncTrackerQuestions?.(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     try {
         lanes = loadLaneRecords(hqRoot, summary);
         questions = loadQuestionRecords(hqRoot, summary);
@@ -843,14 +835,6 @@ export async function runPassBody(hqRoot, deps) {
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
-    if (!deps.dryRun && deps.syncTrackerQuestions) {
-        try {
-            await deps.syncTrackerQuestions(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
             writeHeartbeatFile(hqRoot, summary, nowIso);

package/dist/lib/lanes/store.js

@@ -738,15 +738,7 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
-    const mesh_question_id = raw.mesh_question_id;
-    if (mesh_question_id !== undefined && (typeof mesh_question_id !== "string" || !mesh_question_id.trim())) {
-        throw new LaneSchemaError("mesh_question_id must be a non-empty string when present", { path: filePath, value: mesh_question_id });
-    }
-    const mesh_delivered_at = raw.mesh_delivered_at === undefined ? null : raw.mesh_delivered_at;
-    if (mesh_delivered_at !== null && (typeof mesh_delivered_at !== "string" || !Number.isFinite(Date.parse(mesh_delivered_at)))) {
-        throw new LaneSchemaError("mesh_delivered_at must be a valid timestamp or null", { path: filePath, value: mesh_delivered_at });
-    }
-    return { ...raw, delivered_at, mesh_delivered_at };
+    return { ...raw, delivered_at };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`:

package/dist/lib/lanes/tracker-store.d.ts

@@ -22,17 +22,13 @@ export interface TrackerStore {
     read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
     list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
     create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): StoreValue<TrackerRecord>;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): StoreValue<TrackerRecord>;
 }
 export interface LocalTrackerStore extends TrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
     create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): TrackerRecord;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
 }
 export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map

package/dist/lib/lanes/tracker-store.js

@@ -238,7 +238,7 @@ export function createLocalTrackerStore(projectDirectory, now = () => new Date()
             writeExclusive(path.join(directory, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`);
             return record;
         },
-        update(kind, id, expectedVersion, change, _metadata) {
+        update(kind, id, expectedVersion, change) {
             const file = recordPath(root, kind, id);
             const directory = ensureKindDirectory(root, kind);
             return withRecordLock(file, () => {

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

@@ -662,10 +662,6 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
-    /** Work Mesh's server-issued id; absent for pre-TRK-9 local questions. */
-    mesh_question_id?: string;
-    /** Local checkpoint that the server accepted this question's delivery stamp. */
-    mesh_delivered_at?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/dist/node-network-compat.d.ts

@@ -1,28 +1,19 @@
 /**
  * Node network defaults for HQ CLI entry points.
  *
- * The compatibility timeout remains the default. On a canary where IPv6 is
- * advertised but unusable, the default-off hq-flags gate can also prefer IPv4
- * and disable automatic family racing before the CLI issues its first request.
+ * The compatibility timeout remains the default for HQ CLI entry points.
  *
  * Keep this module safe to import immediately after the Node version preflight.
- * The hq-flags reader loads dynamically so an unsupported runtime exits through
- * the preflight rather than failing during module linking.
  */
 export declare const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
 export interface NodeNetworkCompatibilityOptions {
     nodeOptions?: string;
     execArgv?: readonly string[];
-    forceIpv4?: boolean;
     /**
      * Inject the net timeout setter (tests). Pass null to simulate a runtime
      * that lacks setDefaultAutoSelectFamilyAttemptTimeout.
      */
     setAttemptTimeout?: ((milliseconds: number) => void) | null;
-    /** Inject Node's automatic family selection setter (tests). */
-    setAutoSelectFamily?: ((enabled: boolean) => void) | null;
-    /** Inject Node's DNS result-order setter (tests). */
-    setDefaultResultOrder?: ((order: "ipv4first") => void) | null;
 }
 export declare function configureNodeNetworkCompatibility(options?: NodeNetworkCompatibilityOptions): boolean;
 //# sourceMappingURL=node-network-compat.d.ts.map

package/dist/node-network-compat.js

@@ -1,15 +1,10 @@
 /**
  * Node network defaults for HQ CLI entry points.
  *
- * The compatibility timeout remains the default. On a canary where IPv6 is
- * advertised but unusable, the default-off hq-flags gate can also prefer IPv4
- * and disable automatic family racing before the CLI issues its first request.
+ * The compatibility timeout remains the default for HQ CLI entry points.
  *
  * Keep this module safe to import immediately after the Node version preflight.
- * The hq-flags reader loads dynamically so an unsupported runtime exits through
- * the preflight rather than failing during module linking.
  */
-import * as nodeDns from "node:dns";
 import * as nodeNet from "node:net";
 export const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
 const ATTEMPT_TIMEOUT_OPTION = "--network-family-autoselection-attempt-timeout";
@@ -19,18 +14,6 @@ function hasExplicitAttemptTimeout(nodeOptions, execArgv) {
         execArgv.some((argument) => argument === ATTEMPT_TIMEOUT_OPTION ||
             argument.startsWith(ATTEMPT_TIMEOUT_OPTION + "=")));
 }
-function hasExplicitFamilySelection(nodeOptions, execArgv) {
-    const optionPattern = /(?:^|\s)(?:--network-family-autoselection|--enable-network-family-autoselection|--no-network-family-autoselection|--dns-result-order)(?:=|\s|$)/;
-    return (optionPattern.test(nodeOptions) ||
-        execArgv.some((argument) => argument === "--network-family-autoselection" ||
-            argument === "--enable-network-family-autoselection" ||
-            argument === "--no-network-family-autoselection" ||
-            argument === "--dns-result-order" ||
-            argument.startsWith("--network-family-autoselection=") ||
-            argument.startsWith("--enable-network-family-autoselection=") ||
-            argument.startsWith("--no-network-family-autoselection=") ||
-            argument.startsWith("--dns-result-order=")));
-}
 function resolveSetAttemptTimeout(override) {
     if (override === null)
         return undefined;
@@ -39,69 +22,19 @@ function resolveSetAttemptTimeout(override) {
     const fn = nodeNet.setDefaultAutoSelectFamilyAttemptTimeout;
     return typeof fn === "function" ? fn.bind(nodeNet) : undefined;
 }
-function resolveSetAutoSelectFamily(override) {
-    if (override === null)
-        return undefined;
-    if (override)
-        return override;
-    const fn = nodeNet.setDefaultAutoSelectFamily;
-    return typeof fn === "function" ? fn.bind(nodeNet) : undefined;
-}
-function resolveSetDefaultResultOrder(override) {
-    if (override === null)
-        return undefined;
-    if (override)
-        return override;
-    const fn = nodeDns.setDefaultResultOrder;
-    return typeof fn === "function" ? fn.bind(nodeDns) : undefined;
-}
-function applyIpv4Preference(options, nodeOptions, execArgv) {
-    if (!options.forceIpv4 || hasExplicitFamilySelection(nodeOptions, execArgv)) {
-        return false;
-    }
-    const setAutoSelectFamily = resolveSetAutoSelectFamily(options.setAutoSelectFamily);
-    const setDefaultResultOrder = resolveSetDefaultResultOrder(options.setDefaultResultOrder);
-    if (!setAutoSelectFamily || !setDefaultResultOrder)
-        return false;
-    setDefaultResultOrder("ipv4first");
-    setAutoSelectFamily(false);
-    return true;
-}
 export function configureNodeNetworkCompatibility(options = {}) {
     const nodeOptions = options.nodeOptions ?? process.env.NODE_OPTIONS ?? "";
     const execArgv = options.execArgv ?? process.execArgv;
-    const ipv4Applied = applyIpv4Preference(options, nodeOptions, execArgv);
     if (hasExplicitAttemptTimeout(nodeOptions, execArgv)) {
-        return ipv4Applied;
+        return false;
     }
     const setAttemptTimeout = resolveSetAttemptTimeout(options.setAttemptTimeout);
     if (!setAttemptTimeout) {
         // Runtime lacks the API; the Node preflight should already have exited.
-        return ipv4Applied;
+        return false;
     }
     setAttemptTimeout(HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS);
     return true;
 }
-async function applyHqFlaggedIpv4Preference() {
-    try {
-        const { nodeNetworkForceIpv4Enabled } = await import("./node-network-compat-flag.js");
-        if (nodeNetworkForceIpv4Enabled &&
-            (await nodeNetworkForceIpv4Enabled())) {
-            configureNodeNetworkCompatibility({ forceIpv4: true });
-        }
-    }
-    catch (error) {
-        const rawName = error instanceof Error ? error.name : "UnknownError";
-        const errorName = /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(rawName)
-            ? rawName
-            : "UnknownError";
-        process.stderr.write("HQ network IPv4 flag lookup failed (" +
-            errorName +
-            "); using default off.\n");
-    }
-}
-// Preserve the historical timeout before any flag request. If the hq-flags
-// lookup succeeds, the IPv4 preference is applied before command dispatch.
 configureNodeNetworkCompatibility();
-await applyHqFlaggedIpv4Preference();
 //# sourceMappingURL=node-network-compat.js.map

package/package.json

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

package/dist/lib/lanes/tracker-mesh-questions.d.ts

@@ -1,54 +0,0 @@
-import type { LaneCompanyRef, QuestionRecord } from "./types.js";
-import { type TrackerMeshRequest } from "./tracker-mesh.js";
-export type TrackerMeshQuestionAudience = "owner" | "operator" | "lane";
-export type TrackerMeshQuestionStatus = "pending" | "answered" | "cancelled";
-export interface TrackerMeshQuestionRow {
-    questionId: string;
-    threadId: string;
-    companyUid: string;
-    projectId: string;
-    laneId: string;
-    host: {
-        kind: string;
-        id: string;
-    };
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context?: string;
-    options: string[];
-    recommended?: string;
-    askedAt: string;
-    status: TrackerMeshQuestionStatus;
-    choice?: string;
-    notes?: string;
-    answeredBy?: string;
-    answeredAt?: string;
-    deliveredAt?: string;
-}
-export interface TrackerMeshQuestionInput {
-    laneId: string;
-    threadId?: string;
-    projectId: string;
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context: string;
-    options: string[];
-    recommended?: string;
-}
-export interface TrackerMeshQuestionClient {
-    create(input: TrackerMeshQuestionInput): Promise<TrackerMeshQuestionRow>;
-    list(statuses?: readonly TrackerMeshQuestionStatus[]): Promise<TrackerMeshQuestionRow[]>;
-    answer(questionId: string, choice: string, notes?: string): Promise<TrackerMeshQuestionRow>;
-    delivered(questionId: string): Promise<TrackerMeshQuestionRow>;
-}
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export declare function deliverTrackerMeshQuestionOnce(question: QuestionRecord, company: LaneCompanyRef, client: Pick<TrackerMeshQuestionClient, "delivered">, persist: (deliveredAt: string) => QuestionRecord): Promise<QuestionRecord>;
-export declare function createTrackerMeshQuestionClient(options: {
-    company: LaneCompanyRef;
-    request?: TrackerMeshRequest;
-}): TrackerMeshQuestionClient;
-//# sourceMappingURL=tracker-mesh-questions.d.ts.map

package/dist/lib/lanes/tracker-mesh-questions.js

@@ -1,138 +0,0 @@
-import { meshJson, requireToken } from "../mesh/client.js";
-import { LanesError } from "./errors.js";
-import { mapWorkMeshTrackerError } from "./tracker-mesh.js";
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export async function deliverTrackerMeshQuestionOnce(question, company, client, persist) {
-    if (!question.mesh_question_id || question.status !== "answered" ||
-        !question.delivered_at || question.mesh_delivered_at)
-        return question;
-    const delivered = await client.delivered(question.mesh_question_id);
-    if (delivered.questionId !== question.mesh_question_id ||
-        delivered.companyUid !== company.uid ||
-        delivered.laneId !== question.lane_id ||
-        delivered.projectId !== question.project_id ||
-        !delivered.deliveredAt) {
-        throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not stamp the expected question as delivered", {
-            mesh_question_id: question.mesh_question_id,
-            question_id: question.question_id,
-        });
-    }
-    return persist(delivered.deliveredAt);
-}
-const ROOT = "/v1/work-mesh/tracker/questions";
-const AUDIENCES = ["owner", "operator", "lane"];
-const STATUSES = ["pending", "answered", "cancelled"];
-const MAX_PAGES_PER_FILTER = 10;
-function invalidResponse(field) {
-    throw new LanesError("tracker_mesh_response_invalid", `Work Mesh returned an invalid tracker question ${field}`, { field });
-}
-function parseQuestion(raw, company) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return invalidResponse("row");
-    const row = raw;
-    if (typeof row.questionId !== "string" || !row.questionId ||
-        typeof row.threadId !== "string" || !row.threadId ||
-        row.companyUid !== company.uid ||
-        typeof row.projectId !== "string" || !row.projectId ||
-        typeof row.laneId !== "string" || !row.laneId ||
-        !AUDIENCES.includes(row.audience) ||
-        !STATUSES.includes(row.status) ||
-        typeof row.question !== "string" ||
-        !Array.isArray(row.options) || row.options.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.audienceChain) || row.audienceChain.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.routingHistory) ||
-        typeof row.askedAt !== "string" || !Number.isFinite(Date.parse(row.askedAt)))
-        return invalidResponse("row");
-    if (row.context !== undefined && typeof row.context !== "string")
-        return invalidResponse("context");
-    if (row.recommended !== undefined && typeof row.recommended !== "string")
-        return invalidResponse("recommended");
-    if (row.choice !== undefined && typeof row.choice !== "string")
-        return invalidResponse("choice");
-    if (row.notes !== undefined && typeof row.notes !== "string")
-        return invalidResponse("notes");
-    if (row.answeredBy !== undefined && typeof row.answeredBy !== "string")
-        return invalidResponse("answeredBy");
-    if (row.answeredAt !== undefined && (typeof row.answeredAt !== "string" || !Number.isFinite(Date.parse(row.answeredAt))))
-        return invalidResponse("answeredAt");
-    if (row.deliveredAt !== undefined && (typeof row.deliveredAt !== "string" || !Number.isFinite(Date.parse(row.deliveredAt))))
-        return invalidResponse("deliveredAt");
-    if (!row.host || typeof row.host !== "object" || Array.isArray(row.host) || typeof row.host.kind !== "string" || typeof row.host.id !== "string")
-        return invalidResponse("host");
-    return row;
-}
-export function createTrackerMeshQuestionClient(options) {
-    const { company } = options;
-    if (!company.slug.trim() || !company.uid.trim()) {
-        throw new LanesError("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker questions", {});
-    }
-    const request = options.request ?? (async (endpoint, init) => {
-        const token = await requireToken({ interactive: false });
-        return meshJson(token, endpoint, init);
-    });
-    const call = async (endpoint, init) => {
-        try {
-            const result = await request(endpoint, init);
-            if (!result || typeof result !== "object" || Array.isArray(result))
-                return invalidResponse("response");
-            return result;
-        }
-        catch (err) {
-            throw mapWorkMeshTrackerError(err);
-        }
-    };
-    return {
-        async create(input) {
-            const result = await call(ROOT, { method: "POST", body: { companyUid: company.uid, ...input } });
-            return parseQuestion(result.question, company);
-        },
-        async list(requestedStatuses = STATUSES) {
-            const uniqueStatuses = [...new Set(requestedStatuses)];
-            if (uniqueStatuses.some((status) => !STATUSES.includes(status))) {
-                throw new LanesError("tracker_mesh_query_invalid", "Unsupported Work Mesh tracker question status filter", { statuses: uniqueStatuses });
-            }
-            const rows = new Map();
-            for (const audience of AUDIENCES) {
-                for (const status of uniqueStatuses) {
-                    let cursor;
-                    for (let page = 0; page < MAX_PAGES_PER_FILTER; page += 1) {
-                        const query = { companyUid: company.uid, audience, status, limit: "100", ...(cursor ? { cursor } : {}) };
-                        const result = await call(ROOT, { method: "GET", query });
-                        if (!Array.isArray(result.questions))
-                            return invalidResponse("questions list");
-                        for (const raw of result.questions) {
-                            const row = parseQuestion(raw, company);
-                            if (row.audience !== audience || row.status !== status)
-                                return invalidResponse("filter scope");
-                            rows.set(row.questionId, row);
-                        }
-                        if (result.nextCursor === undefined)
-                            break;
-                        if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor)
-                            return invalidResponse("cursor");
-                        if (page === MAX_PAGES_PER_FILTER - 1) {
-                            throw new LanesError("tracker_mesh_response_incomplete", "Work Mesh tracker question list exceeded its bounded page limit", { audience, status, max_pages: MAX_PAGES_PER_FILTER });
-                        }
-                        cursor = result.nextCursor;
-                    }
-                }
-            }
-            return [...rows.values()].sort((a, b) => b.askedAt.localeCompare(a.askedAt) || a.questionId.localeCompare(b.questionId));
-        },
-        async answer(questionId, choice, notes) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/answer`, {
-                method: "POST",
-                body: { companyUid: company.uid, choice, ...(notes === undefined ? {} : { notes }) },
-            });
-            return parseQuestion(result.question, company);
-        },
-        async delivered(questionId) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/delivered`, {
-                method: "POST",
-                body: { companyUid: company.uid },
-            });
-            return parseQuestion(result.question, company);
-        },
-    };
-}
-//# sourceMappingURL=tracker-mesh-questions.js.map

package/dist/lib/lanes/tracker-mesh.d.ts

@@ -1,19 +0,0 @@
-import { LanesError } from "./errors.js";
-import type { LaneCompanyRef } from "./types.js";
-import type { TrackerStore } from "./tracker-store.js";
-export interface TrackerMeshRequestInit {
-    method?: string;
-    body?: Record<string, unknown>;
-    query?: Record<string, string>;
-}
-export type TrackerMeshRequest = (path: string, init: TrackerMeshRequestInit) => Promise<unknown>;
-export interface WorkMeshTrackerStoreOptions {
-    company: LaneCompanyRef;
-    projectId: string;
-    request?: TrackerMeshRequest;
-    now?: () => Date;
-    clientRecordId?: () => string;
-}
-export declare function mapWorkMeshTrackerError(err: unknown): LanesError;
-export declare function createWorkMeshTrackerStore(options: WorkMeshTrackerStoreOptions): TrackerStore;
-//# sourceMappingURL=tracker-mesh.d.ts.map