@indigoai-us/hq-cli 5.345.191 → 5.345.193

package/dist/lib/bot/progress.js

@@ -37,6 +37,25 @@ export const PRE_TOOL_ASIDE_MAX_CHARS = 40;
  * your agency docs now, then I'll look at the client folders.") and run past
  * the limit; an hq-block is always content the desktop app must draw.
  */
+/**
+ * A heads-up the model writes right before a long piece of work ("Give me
+ * about two minutes to check what's on this computer, then I'll ask my
+ * first question."). A bot that drops every pre-tool message
+ * (`dropPreToolMessages`) still lets ONE of these through per turn, so the
+ * person hears what is happening and how long it takes instead of watching
+ * a spinner. Short, one or two sentences, names a wait, no hq-block.
+ */
+export const WAIT_HEADS_UP_MAX_CHARS = 240;
+export function isWaitHeadsUp(text) {
+    const t = text.trim();
+    // A question is not a heads-up: it would be held as an in-between question
+    // and dropped when the turn ends with a final answer.
+    if (!t || t.length > WAIT_HEADS_UP_MAX_CHARS || t.includes("```") || t.includes("?"))
+        return false;
+    // It has to name a wait. "I'll check the manifest first." is narration
+    // (the setup worker forbids it); "Give me about two minutes" is not.
+    return /\b(?:minutes?|seconds?|a moment|one moment|right back|be back)\b/i.test(t);
+}
 export function isPreToolAside(text) {
     const t = text.trim();
     return t.length < PRE_TOOL_ASIDE_MAX_CHARS && !t.includes("```hq-block");
@@ -61,6 +80,8 @@ export class ProgressPoster {
     workingNoticeText;
     buffer;
     dropPreTool;
+    /** With dropPreToolMessages: one wait heads-up (isWaitHeadsUp) per turn is kept. */
+    headsUpKept = false;
     onDropped;
     /**
      * Messages waiting to learn whether a tool call follows: every message when
@@ -124,6 +145,18 @@ export class ProgressPoster {
             this.enqueueWith(this.workingNoticeText, this.sendProgress);
         }, this.workingNoticeMs);
     }
+    /** Arm the still-working line again after a kept heads-up (start() skips a turn that said something). */
+    rearmNoticeAfter(saidCount) {
+        if (this.buffer || this.finished || this.noticeTimer !== null || this.workingNoticeMs <= 0)
+            return;
+        this.noticeTimer = this.setTimer(() => {
+            this.noticeTimer = null;
+            if (this.finished || this.noticeSent || this.said.length !== saidCount)
+                return;
+            this.noticeSent = true;
+            this.enqueueWith(this.workingNoticeText, this.sendProgress);
+        }, this.workingNoticeMs);
+    }
     /** One finished assistant message from the model. */
     message(text) {
         const t = text.trim();
@@ -145,8 +178,21 @@ export class ProgressPoster {
     tool() {
         if (this.finished)
             return;
-        const dropped = this.candidates;
+        let dropped = this.candidates;
         this.candidates = [];
+        // The last thing said before the tool call, when it tells the person
+        // what is about to happen and how long, is for them: post it.
+        if (this.dropPreTool && !this.headsUpKept) {
+            const last = dropped.at(-1);
+            if (last !== undefined && isWaitHeadsUp(last)) {
+                this.headsUpKept = true;
+                dropped = dropped.slice(0, -1);
+                this.accept(last);
+                // The heads-up named a wait; if the work then outlives that silence
+                // budget with nothing more said, the still-working line goes out too.
+                this.rearmNoticeAfter(this.said.length);
+            }
+        }
         for (const t of dropped) {
             try {
                 this.onDropped(t);

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

@@ -15,8 +15,9 @@
  * - first start only: the intro DM, then (when bot.json has `kickoff`) ONE
  *   model turn on that prompt as if the owner sent it, answered in the DM, so
  *   a guided bot starts working without waiting for the owner to type
- * - job items (channel "job"): a run the cloud fired on an EventBridge
- *   schedule. Nothing is scheduled on this computer. The run is one model turn
+ * - job items (channel "job"): a scheduled run, fired by the bot's own loop
+ *   from its jobs.json (lib/bot/local-jobs.ts) or, for a hosted agent, by
+ *   the cloud. No system scheduler is used on this computer. The run is one model turn
  *   in its own session (one per jobId), reported in the owner's DM with a
  *   "scheduled job" header through the same split/recovery path as every other
  *   reply, and reported back to the cloud EXACTLY ONCE — nothing else clears
@@ -152,8 +153,20 @@ export interface BotRunDeps {
         company: string;
         catchUp: boolean;
         now: () => Date;
+        /** When the run was due (the fired item's `firedAt`); the catch-up reply names it. */
+        scheduledFor?: string;
+        /** The job's zone, for the times in the reply. */
+        timeZone?: string;
         /** The signals-failure alert to the owner, sent even when the job is quiet (US-012). */
         sendAlert: (text: string) => Promise<void>;
+        /** This run is the bot's automatic retry of a failed run. */
+        retry?: boolean;
+        /**
+         * Schedules one automatic retry of this run at `at` (the run record's
+         * nextRetryAt), in this process. Returns true when it is scheduled. Only
+         * offered for a local job's scheduled run, never for a retry.
+         */
+        scheduleRetry?: (at: string) => boolean;
     }) => Promise<{
         ok: boolean;
         text: string;
@@ -315,6 +328,46 @@ export declare function preflightCreds(dir: string, config: BotConfig): string |
 export declare function runBot(deps: BotRunDeps): Promise<BotHandle>;
 /** True for a setup note the desktop app sent, not words the person typed. */
 export declare function isAppSetupNote(text: string): boolean;
+/**
+ * True for the ONE note the desktop app sends when its visual first run
+ * closes: the handoff that names the assistant (`name` in `done`). Older
+ * builds sent partial notes (an import, a company) with no `name`; those
+ * fold in quietly (`APP_SETUP_NOTE_TURN_NOTE`).
+ */
+export declare function isFirstRunHandoffNote(text: string): boolean;
+/**
+ * Put ahead of the end-of-setup handoff note: it is the assistant's first
+ * turn, so it always answers, and in seconds: everything it needs is in the
+ * handoff, the Owner context block and the facts appended below it, so it
+ * runs no command and reads no file first. The shape of that first message
+ * is in the setup worker's instructions ("When the app hands you settled
+ * steps").
+ */
+export declare const FIRST_RUN_HANDOFF_TURN_NOTE: string;
+export interface FirstRunHandoffFacts {
+    /** Company folders under companies/ on this computer (slugs). */
+    companyFolders: string[];
+    /** The bot's setup-progress.md, or null when there is none yet. */
+    progressNote: string | null;
+}
+/**
+ * What the first-run turn would otherwise spend tool calls finding out: the
+ * company folders on this computer and the progress note. Read here, once,
+ * so the first reply needs no command. Never throws.
+ */
+export declare function firstRunHandoffFacts(hqRoot: string, memoryDir: string): FirstRunHandoffFacts;
+/** The whole first-run turn note: the fixed lead, then the facts. */
+export declare function firstRunHandoffTurnNote(facts: FirstRunHandoffFacts): string;
+/** The setup bot's "still working" line: plain words, no dash, nothing about mechanics. */
+export declare const SETUP_WORKING_NOTICE_TEXT = "Still working on it. I'll post here as soon as I'm done.";
+/**
+ * The setup bot's silence budget before that line. Half the general one:
+ * the person is new and watching. The bot is told to say what it is about
+ * to do and how long first (a wait heads-up, kept by the poster); the line
+ * goes out when it said nothing, or when the work outlives the heads-up by
+ * this much with nothing more said.
+ */
+export declare const SETUP_WORKING_NOTICE_MS = 30000;
 /** Put ahead of an app setup note: fold it in, and stay quiet unless it changes what to say. */
 export declare const APP_SETUP_NOTE_TURN_NOTE: string;
 //# sourceMappingURL=run.d.ts.map

package/dist/lib/bot/run.js

@@ -15,8 +15,9 @@
  * - first start only: the intro DM, then (when bot.json has `kickoff`) ONE
  *   model turn on that prompt as if the owner sent it, answered in the DM, so
  *   a guided bot starts working without waiting for the owner to type
- * - job items (channel "job"): a run the cloud fired on an EventBridge
- *   schedule. Nothing is scheduled on this computer. The run is one model turn
+ * - job items (channel "job"): a scheduled run, fired by the bot's own loop
+ *   from its jobs.json (lib/bot/local-jobs.ts) or, for a hosted agent, by
+ *   the cloud. No system scheduler is used on this computer. The run is one model turn
  *   in its own session (one per jobId), reported in the owner's DM with a
  *   "scheduled job" header through the same split/recovery path as every other
  *   reply, and reported back to the cloud EXACTLY ONCE — nothing else clears
@@ -84,6 +85,7 @@ import { resolveRoomMentionsForBot, roomPostHasMentionTokens, } from "./room-men
 import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOutput, machineTimeZone, planJobRuns, stripJobHeader, SUPERSEDED_DISPOSITION } from "./job-run.js";
 import { botJobQuietOptionEnabled } from "./job-quiet-flag.js";
 import { currentHotSignalSyncCompany, hotSignalSyncJobCompany, readActiveCompanySlug, removeStaleHotSignalSyncJobs } from "./jobs/hot-signal-sync.js";
+import { isLocalJobMessage, isLocalJobRetryMessage, localJobRetryMessageId, readLocalJobs } from "./local-jobs.js";
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
 import { SIGN_IN_CHECK_FRESH_MS, SIGN_IN_CHECK_MS, SIGN_IN_RETRY_MS, signInNeededText, signedOutExcerpt, } from "./runtime-sign-in.js";
 import { checkRuntimeSignIn } from "./runtime-sign-in-check.js";
@@ -1374,13 +1376,18 @@ export async function runBot(deps) {
         };
         const poster = new ProgressPoster({
             // The setup bot talks to someone new to HQ: its notes to itself never
-            // reach them, and it posts no "still working" notice either — the
-            // desktop app shows that the bot is working.
+            // reach them.
             ...(isSetupBot ? { dropPreToolMessages: true } : {}),
             // Short asides before a tool call never reach the person either (isPreToolAside).
             onDropped: (text) => log("debug", `dropped a pre-tool aside for ${messageId} (${text.length} chars): ${text}`),
+            // The setup bot talks to someone new to HQ, so its "still working" line
+            // is the plain one (no dash, no mechanics) and comes sooner. It used to
+            // post none at all because the desktop app shows the bot working; a
+            // first run on 2026-11-02 sat on that spinner for over three minutes
+            // with nothing said, so the line is back for it too.
+            ...(isSetupBot ? { workingNoticeText: SETUP_WORKING_NOTICE_TEXT, workingNoticeMs: SETUP_WORKING_NOTICE_MS } : {}),
             ...deps.progress,
-            ...(args.workingNotice === false || silenceable || isSetupBot ? { workingNoticeMs: 0 } : {}),
+            ...(args.workingNotice === false || silenceable ? { workingNoticeMs: 0 } : {}),
             ...(silenceable || args.suppressOutput ? { buffer: true } : {}),
             sendProgress: makeSendFn(args.sendProgress),
             sendToPerson: makeSendFn(args.sendToPerson),
@@ -1578,6 +1585,27 @@ export async function runBot(deps) {
     const handledJobFires = new Map();
     /** Runs an older fire of a job that a newer pending run supersedes. */
     const supersededJobRuns = new Set();
+    /**
+     * The automatic retry of a failed signals job run, per jobId: one synthetic
+     * local run, due at the run record's nextRetryAt. Kept in memory only, so a
+     * stop or restart drops it (the next scheduled fire, or "Try now", runs
+     * instead). The inbox loop enqueues it once it is due.
+     */
+    const signalsRetries = new Map();
+    const scheduleSignalsRetry = (item, jobId, at) => {
+        const dueMs = Date.parse(at);
+        if (!Number.isFinite(dueMs) || stopping || state !== "running")
+            return false;
+        const { requestId: _requestId, receivedAt: _receivedAt, ...rest } = item;
+        signalsRetries.set(jobId, {
+            ...rest,
+            messageId: localJobRetryMessageId(jobId, dueMs),
+            firedAt: new Date(dueMs).toISOString(),
+            staleAfter: new Date(dueMs + 10 * 60_000).toISOString(),
+        });
+        log("info", `signals job ${jobId}: the run failed; one automatic retry at ${new Date(dueMs).toISOString()}`);
+        return true;
+    };
     /**
      * Report one fired run as finished. This is the ONLY thing that clears the
      * job's in-progress flag in the cloud, so a failure is logged loudly and the
@@ -1887,8 +1915,9 @@ export async function runBot(deps) {
             tReceived,
             sendProgress,
             sendToPerson,
-            // The intro already said the bot is starting, and the app shows it thinking.
-            workingNotice: false,
+            // A kickoff turn that stays silent for a minute posts the "still
+            // working" line like any other turn: the app's thinking row alone
+            // left a first run looking stuck (2026-11-02).
         });
         await clearThinking();
         if (!outcome.ok && outcome.error instanceof CompanyBindingError) {
@@ -2107,8 +2136,23 @@ export async function runBot(deps) {
                 log("info", `hot-signal-sync job ${jobId} run ${id} skipped: company ${syncCompany} no longer served (current: ${currentCompany ?? "none"})`);
                 return;
             }
+            // Times in the reply are in the job's own zone (jobs.json), not this machine's.
+            const jobZone = readLocalJobs(dir).find((j) => j.jobId === jobId)?.timezone ?? timeZone;
+            const isRetryRun = isLocalJobRetryMessage(id);
             const result = deps.hotSignalSync
-                ? await deps.hotSignalSync({ company: syncCompany, catchUp, now, sendAlert: (text) => sendToPerson(text) })
+                ? await deps.hotSignalSync({
+                    company: syncCompany,
+                    catchUp,
+                    now,
+                    ...(job.firedAt ? { scheduledFor: job.firedAt } : {}),
+                    timeZone: jobZone,
+                    sendAlert: (text) => sendToPerson(text),
+                    ...(isRetryRun ? { retry: true } : {}),
+                    // One in-process retry per failed scheduled run of a local job.
+                    ...(isLocalJobMessage(id) && !isRetryRun
+                        ? { scheduleRetry: (at) => scheduleSignalsRetry(item, jobId, at) }
+                        : {}),
+                })
                 : { ok: false, text: `This bot cannot run the hot-channel sync for ${syncCompany}.` };
             markProcessed(dir, id, now().toISOString());
             const status = result.ok ? "succeeded" : "failed";
@@ -2542,8 +2586,13 @@ export async function runBot(deps) {
         // answering every note re-posted that question (three times in a row on
         // 2026-10-12). Such a turn may stay quiet.
         const appSetupNote = isSetupBot && ownerDm && isAppSetupNote(messageText);
+        // The one note the app sends when its visual setup closes is different:
+        // the assistant was created without a kickoff, so this note is its first
+        // turn and the person is in the chat waiting for its first message. It
+        // never stays quiet.
+        const firstRunHandoff = appSetupNote && isFirstRunHandoffNote(messageText);
         const ownerTurnText = decisionTurn.note ? `${decisionTurn.note}\n\n${ownerText}` : ownerText;
-        const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? (appSetupNote ? `${APP_SETUP_NOTE_TURN_NOTE}\n\n${ownerTurnText}` : ownerTurnText) :
+        const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? (firstRunHandoff ? `${firstRunHandoffTurnNote(firstRunHandoffFacts(config.hqRoot, resolveBotMemoryDir(config)))}\n\n${ownerTurnText}` : appSetupNote ? `${APP_SETUP_NOTE_TURN_NOTE}\n\n${ownerTurnText}` : ownerTurnText) :
             `[HQ DM sender: ${target.peerUid}; owner: ${config.ownerUid}; sender is not the owner.]\n\n${text}`;
         const markerTarget = target.kind === "dm" ? { kind: "dm", peerUid: target.peerUid } : { kind: "room", channelId: target.channelId };
         const { sendProgress, sendToPerson, saved } = trackingSend(markerTarget, item.rootEventId);
@@ -2559,7 +2608,7 @@ export async function runBot(deps) {
             tReceived,
             sendProgress,
             sendToPerson,
-            silenceable: (target.kind === "room" && !target.mentioned) || appSetupNote,
+            silenceable: (target.kind === "room" && !target.mentioned) || (appSetupNote && !firstRunHandoff),
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "dm" ? { historyEventId: item.eventId ?? id } : {}),
             ...(target.kind === "room"
@@ -2814,6 +2863,27 @@ export async function runBot(deps) {
         else
             lanes.set(lane, [item]);
     };
+    /** Hands a due signals retry to its job lane, unless the job was removed meanwhile. */
+    const enqueueDueSignalsRetries = () => {
+        if (signalsRetries.size === 0)
+            return;
+        const t = now().getTime();
+        let added = false;
+        for (const [jobId, retryItem] of signalsRetries) {
+            if (Date.parse(retryItem.firedAt ?? "") > t)
+                continue;
+            signalsRetries.delete(jobId);
+            if (!readLocalJobs(dir).some((j) => j.jobId === jobId)) {
+                log("info", `signals job ${jobId} was removed; its automatic retry is dropped`);
+                continue;
+            }
+            log("info", `signals job ${jobId}: running the automatic retry`);
+            enqueue(retryItem);
+            added = true;
+        }
+        if (added)
+            pump();
+    };
     const inboxLoop = (async () => {
         // Turns cut off by the last restart are reported before anything new runs.
         for (const leftover of leftovers) {
@@ -2838,6 +2908,8 @@ export async function runBot(deps) {
             // the work), alongside the poll rather than in front of it. Also during
             // a hold: a report owed to the cloud has nothing to do with the model.
             kickCompletionRetries();
+            // A failed signals run's automatic retry, once due (no model turn).
+            enqueueDueSignalsRetries();
             // Holding after repeated model failures: no inbox pulls until the
             // cooldown is over (the update watcher above keeps running meanwhile).
             if (modelHoldUntil > now().getTime()) {
@@ -2942,6 +3014,8 @@ export async function runBot(deps) {
         // An owner stop or a promotion while an update restart drains wins: the
         // bot then exits 0 and stays down instead of being restarted.
         cliUpdatePending = null;
+        // A pending signals retry is in-process only: a stop cancels it.
+        signalsRetries.clear();
         if (stopping) {
             // Already stopping (an earlier stop, a startup signal, or an update
             // restart): still wait for the loops and finish, so this call ends the
@@ -2993,6 +3067,114 @@ const APP_SETUP_NOTE_PREFIX = "Setup note from the HQ desktop app:";
 export function isAppSetupNote(text) {
     return text.trimStart().startsWith(APP_SETUP_NOTE_PREFIX);
 }
+/**
+ * True for the ONE note the desktop app sends when its visual first run
+ * closes: the handoff that names the assistant (`name` in `done`). Older
+ * builds sent partial notes (an import, a company) with no `name`; those
+ * fold in quietly (`APP_SETUP_NOTE_TURN_NOTE`).
+ */
+export function isFirstRunHandoffNote(text) {
+    if (!isAppSetupNote(text))
+        return false;
+    const m = /Handoff from the app:\s*(\{.*\})/.exec(text);
+    if (!m)
+        return false;
+    // The JSON ends at the `}` that closes the object; the note's own
+    // sentences follow it on the same line. Braces inside string values (a
+    // company name, a report path) do not count.
+    let depth = 0;
+    let end = -1;
+    let inString = false;
+    for (let i = 0; i < m[1].length; i += 1) {
+        const ch = m[1][i];
+        if (inString) {
+            if (ch === "\\")
+                i += 1;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "{")
+            depth += 1;
+        else if (ch === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+    }
+    if (end < 0)
+        return false;
+    try {
+        const handoff = JSON.parse(m[1].slice(0, end));
+        return handoff.from === "desktop-visual-first-run" && Array.isArray(handoff.done) && handoff.done.includes("name");
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Put ahead of the end-of-setup handoff note: it is the assistant's first
+ * turn, so it always answers, and in seconds: everything it needs is in the
+ * handoff, the Owner context block and the facts appended below it, so it
+ * runs no command and reads no file first. The shape of that first message
+ * is in the setup worker's instructions ("When the app hands you settled
+ * steps").
+ */
+export const FIRST_RUN_HANDOFF_TURN_NOTE = "[This message is the HQ desktop app's end-of-setup handoff, not words from the person. The person has just left the app's setup screens " +
+    "and is in this chat now, waiting for your first message, so always reply; never answer with {\"action\":\"no_reply\"}. " +
+    "Reply now, from this message alone: the handoff, the Owner context block above, and the facts from this HQ listed below. " +
+    "Run no command and read no file before this reply. Do not install, repair or check tools; that comes after they answer, and you will say first how long it takes. " +
+    "Write the first message your instructions describe for this handoff: who you are and what you can help with, " +
+    "then exactly what setup is left (or that none is) and one question.";
+/** Longest progress note quoted into the first-run handoff turn. */
+const FIRST_RUN_NOTE_MAX_CHARS = 4_000;
+/**
+ * What the first-run turn would otherwise spend tool calls finding out: the
+ * company folders on this computer and the progress note. Read here, once,
+ * so the first reply needs no command. Never throws.
+ */
+export function firstRunHandoffFacts(hqRoot, memoryDir) {
+    let companyFolders;
+    try {
+        companyFolders = fs
+            .readdirSync(path.join(hqRoot, "companies"), { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        companyFolders = [];
+    }
+    let progressNote;
+    try {
+        const note = fs.readFileSync(path.join(memoryDir, "setup-progress.md"), "utf8").trim();
+        progressNote = note ? note.slice(0, FIRST_RUN_NOTE_MAX_CHARS) : null;
+    }
+    catch {
+        progressNote = null;
+    }
+    return { companyFolders, progressNote };
+}
+/** The whole first-run turn note: the fixed lead, then the facts. */
+export function firstRunHandoffTurnNote(facts) {
+    const folders = facts.companyFolders.length ? facts.companyFolders.join(", ") : "none yet";
+    const note = facts.progressNote ? `\n---\n${facts.progressNote}\n---` : " none (this is a new setup).";
+    return `${FIRST_RUN_HANDOFF_TURN_NOTE} Facts from this HQ: company folders on this computer: ${folders}. Your progress note:${note}]`;
+}
+/** The setup bot's "still working" line: plain words, no dash, nothing about mechanics. */
+export const SETUP_WORKING_NOTICE_TEXT = "Still working on it. I'll post here as soon as I'm done.";
+/**
+ * The setup bot's silence budget before that line. Half the general one:
+ * the person is new and watching. The bot is told to say what it is about
+ * to do and how long first (a wait heads-up, kept by the poster); the line
+ * goes out when it said nothing, or when the work outlives the heads-up by
+ * this much with nothing more said.
+ */
+export const SETUP_WORKING_NOTICE_MS = 30_000;
 /** Put ahead of an app setup note: fold it in, and stay quiet unless it changes what to say. */
 export const APP_SETUP_NOTE_TURN_NOTE = "[This message is a setup note from the HQ desktop app, not words from the person. Record what it settles. " +
     "If you already asked the person something that is still unanswered and this note does not change it, reply with exactly " +

package/dist/lib/bot/setup-tool-offer.d.ts

@@ -47,4 +47,5 @@ export declare function setupOfferAnsweredInWordsNote(tool: CodingTool): string;
 export type SetupToolOfferAnswer = "kept_here" | "wrote";
 /** How the person answered a pending offer: the button, or anything else. */
 export declare function setupToolOfferAnswer(text: string, attachments: number): SetupToolOfferAnswer;
+export declare function setupToolOfferPendingSection(tool: CodingTool, kickoff: string): string;
 //# sourceMappingURL=setup-tool-offer.d.ts.map

package/dist/lib/bot/setup-tool-offer.js

@@ -88,4 +88,20 @@ export function setupOfferAnsweredInWordsNote(tool) {
 export function setupToolOfferAnswer(text, attachments) {
     return text === KEEP_GOING_HERE_REPLY && attachments === 0 ? "kept_here" : "wrote";
 }
+export function setupToolOfferPendingSection(tool, kickoff) {
+    const app = CODING_TOOL_NAMES[tool];
+    return [
+        "## The app offer waiting for an answer",
+        "",
+        `Your first message, sent by the HQ app, offered to continue setup in the ${app} app, because the person uses that app a lot on this computer. ` +
+            `It showed a button that opens the ${app} app in their HQ folder and a "${KEEP_GOING_HERE_REPLY}" button. Setup has not started and no first task has run.`,
+        "",
+        `- If the person replies exactly "${KEEP_GOING_HERE_REPLY}", setup happens here. Do not mention the offer; carry out this first task now:`,
+        "",
+        kickoff.trim(),
+        "",
+        `- If they write anything else and want to continue in the ${app} app, tell them in plain words to click the button above to open it. ` +
+            "Otherwise begin setup here as your instructions say for a first message.",
+    ].join("\n");
+}
 //# sourceMappingURL=setup-tool-offer.js.map

package/dist/lib/bot/signals-engine-flag.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Default-off rollout gate for the signals engine in the bot's built-in
+ * hot-signal-sync job (hq-cli #2306, hot-signal-sync US-006).
+ *
+ * Off (the default): a fired job runs the hot-channel sync alone, as before
+ * #2306. On: the job runs the full signals engine (`runSignals`) and replies in
+ * the storyboarded format. Turn it on for a company in the flag registry, or on
+ * one computer with `HQ_FLAG_CLI_BOT_SIGNALS_ENGINE_JOB=true` in the bot's
+ * environment.
+ */
+export declare const BOT_SIGNALS_ENGINE_JOB_FLAG = "cli.bot-signals-engine-job";
+export declare function botSignalsEngineJobEnabled(): Promise<boolean>;
+/**
+ * The engine a fired hot-signal-sync job gets: `engine` when the flag is on,
+ * otherwise undefined, so `runHotSignalSyncJob` takes its sync-only path.
+ */
+export declare function signalsEngineForJob<T>(engine: T, enabled?: () => Promise<boolean>): Promise<T | undefined>;
+//# sourceMappingURL=signals-engine-flag.d.ts.map

package/dist/lib/bot/signals-engine-flag.js

@@ -0,0 +1,30 @@
+/**
+ * Default-off rollout gate for the signals engine in the bot's built-in
+ * hot-signal-sync job (hq-cli #2306, hot-signal-sync US-006).
+ *
+ * Off (the default): a fired job runs the hot-channel sync alone, as before
+ * #2306. On: the job runs the full signals engine (`runSignals`) and replies in
+ * the storyboarded format. Turn it on for a company in the flag registry, or on
+ * one computer with `HQ_FLAG_CLI_BOT_SIGNALS_ENGINE_JOB=true` in the bot's
+ * environment.
+ */
+export const BOT_SIGNALS_ENGINE_JOB_FLAG = "cli.bot-signals-engine-job";
+export async function botSignalsEngineJobEnabled() {
+    try {
+        const { resolveProcessFlagGate } = await import("../flag-registry.js");
+        return resolveProcessFlagGate(BOT_SIGNALS_ENGINE_JOB_FLAG, { fallback: false }, () => false);
+    }
+    catch (error) {
+        const errorClass = error instanceof Error ? error.name : "unknown";
+        console.warn(`hq: Could not resolve ${BOT_SIGNALS_ENGINE_JOB_FLAG} (${errorClass}); the bot's signals job runs the sync only.`);
+        return false;
+    }
+}
+/**
+ * The engine a fired hot-signal-sync job gets: `engine` when the flag is on,
+ * otherwise undefined, so `runHotSignalSyncJob` takes its sync-only path.
+ */
+export async function signalsEngineForJob(engine, enabled = botSignalsEngineJobEnabled) {
+    return (await enabled()) ? engine : undefined;
+}
+//# sourceMappingURL=signals-engine-flag.js.map

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

@@ -92,6 +92,9 @@ export interface SyncCoreRunning {
     personal: boolean;
     companies: ReadonlySet<string>;
 }
+export declare const FLEET_BOTS_UPDATE_UNIT = "fleet-bots-update";
+export declare const FLEET_BOTS_UPDATE_INTERVAL_SEC: number;
+export declare const FLEET_BOTS_UPDATE_INITIAL_DELAY_SEC = 120;
 export declare const SYNC_CORE_RECONCILE_UNIT = "sync-core";
 export declare const SYNC_CORE_RECONCILE_INTERVAL_SEC = 600;
 export declare const SYNC_CORE_MANIFEST_UNIT = "sync-core-manifest";
@@ -148,6 +151,7 @@ export interface PlanContext {
     /** ~/.hq-agent/kit.json exists. */
     kitConfigured: boolean;
     bots: readonly string[];
+    fleetBots?: readonly string[];
     /** Name of a pre-daemon unit that still runs this unit id, or null. */
     legacyOwner: (unitId: string) => string | null;
     /** This CLI is a global install the updater can replace (not a project dependency). */

package/dist/lib/daemon/catalog.js

@@ -92,6 +92,9 @@ export function enabledServices(machineType, overrides) {
     };
     return SERVICE_NAMES.filter((s) => wanted(s) || implied(s));
 }
+export const FLEET_BOTS_UPDATE_UNIT = "fleet-bots-update";
+export const FLEET_BOTS_UPDATE_INTERVAL_SEC = 30 * 60;
+export const FLEET_BOTS_UPDATE_INITIAL_DELAY_SEC = 120;
 export const SYNC_CORE_RECONCILE_UNIT = "sync-core";
 export const SYNC_CORE_RECONCILE_INTERVAL_SEC = 600;
 export const SYNC_CORE_MANIFEST_UNIT = "sync-core-manifest";
@@ -322,17 +325,34 @@ function planService(service, ctx) {
             ];
         }
         case "bots": {
+            const fleetWatch = (ctx.fleetBots ?? []).length > 0
+                ? [
+                    base(service, {
+                        id: FLEET_BOTS_UPDATE_UNIT,
+                        description: "moves HQ Fleet bots to the current runtime release while they are idle",
+                        kind: "scheduled",
+                        intervalSec: FLEET_BOTS_UPDATE_INTERVAL_SEC,
+                        initialDelaySec: FLEET_BOTS_UPDATE_INITIAL_DELAY_SEC,
+                        command: { type: "hq", args: ["daemon", "service", "fleet-bots-update"] },
+                        env: { HQ_NO_UPDATE_CHECK: "1" },
+                        blocked: firstBlock([[!ctx.signedIn, NOT_SIGNED_IN]]),
+                    }),
+                ]
+                : [];
             if (ctx.bots.length === 0) {
-                return [base(service, { blocked: { state: "waiting", reason: "no local bots" } })];
+                return fleetWatch.length > 0 ? fleetWatch : [base(service, { blocked: { state: "waiting", reason: "no local bots" } })];
             }
-            return ctx.bots.map((name) => base(service, {
-                id: `bots:${name}`,
-                description: `runs the local bot ${name}`,
-                restart: "on-failure",
-                command: { type: "hq", args: ["bot", "run", name] },
-                // A bot drains on SIGUSR2: running turns finish, then it exits.
-                drainSignal: "SIGUSR2",
-            }));
+            return [
+                ...ctx.bots.map((name) => base(service, {
+                    id: `bots:${name}`,
+                    description: `runs the local bot ${name}`,
+                    restart: "on-failure",
+                    command: { type: "hq", args: ["bot", "run", name] },
+                    // A bot drains on SIGUSR2: running turns finish, then it exits.
+                    drainSignal: "SIGUSR2",
+                })),
+                ...fleetWatch,
+            ];
         }
         case "session-host":
             return [

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

@@ -32,6 +32,12 @@ export interface LegacyProbeDeps {
     launchdJobLoaded: (label: string) => boolean;
     /** Whether the task exists and runs as the current user. Another user's task is never taken over. */
     windowsTaskOwner: (taskName: string) => WindowsTaskOwner;
+    /**
+     * Mesh task name `hq mesh daemon install` recorded for this user. It is a
+     * per-user name (`ai.getindigo.hq-mesh-daemon.<user>`) when the shared name
+     * belonged to another account.
+     */
+    windowsRecordedMeshTask?: () => string;
 }
 export declare function describeLegacyUnit(unit: LegacyUnit): string;
 export declare function findLegacyUnits(deps: LegacyProbeDeps): LegacyUnit[];

package/dist/lib/daemon/legacy.js

@@ -100,16 +100,22 @@ function linuxUnits(deps) {
     return units;
 }
 function windowsUnits(deps) {
-    const task = "ai.getindigo.hq-mesh-daemon";
-    const owner = deps.windowsTaskOwner(task);
-    if (owner === "none")
-        return [];
-    const unit = { unitId: "mesh", service: "mesh", kind: "schtasks", name: task, migratable: owner === "mine" };
-    if (owner === "other")
-        unit.notMineReason = "it belongs to another Windows user";
-    if (owner === "unreadable")
-        unit.notMineReason = "HQ could not read which Windows user it belongs to";
-    return [unit];
+    const shared = "ai.getindigo.hq-mesh-daemon";
+    const recorded = deps.windowsRecordedMeshTask?.();
+    const tasks = recorded && recorded !== shared ? [recorded, shared] : [shared];
+    const units = [];
+    for (const task of tasks) {
+        const owner = deps.windowsTaskOwner(task);
+        if (owner === "none")
+            continue;
+        const unit = { unitId: "mesh", service: "mesh", kind: "schtasks", name: task, migratable: owner === "mine" };
+        if (owner === "other")
+            unit.notMineReason = "it belongs to another Windows user";
+        if (owner === "unreadable")
+            unit.notMineReason = "HQ could not read which Windows user it belongs to";
+        units.push(unit);
+    }
+    return units;
 }
 export function findLegacyUnits(deps) {
     if (deps.platform === "darwin")