@indigoai-us/hq-cli 5.178.0 → 5.179.1

package/CHANGELOG.md

@@ -2,10 +2,28 @@
 
 ## [Unreleased]
 
+## [5.179.1] — 2026-09-24
+
+### Added
+
+- `hq dm send` now takes `--audience <human|agent|both>` so a bot or operator
+  can declare who a DM is for, and the `hq_dm_send` bot tool accepts the same
+  optional field. Local bot turns tag in-between progress messages as `agent`
+  and the final reply as `human` by default, so status chatter stays out of a
+  person's inbox while the answer they need still reaches them. `hq dm inbox`
+  and `hq dm thread` mark agent-audience messages with an `[agent]` tag.
+
+## [5.179.0] — 2026-09-24
+
+### Fixed
+
+- `hq integrations connect --client-id` with a Google OAuth client (`*.apps.googleusercontent.com`) now warns that the client must be of type "Web application" and prints the redirect URI to register. A "Desktop app" client cannot accept HQ's hosted callback, and Google reports that only after the browser is open.
+
 ## [5.178.0] — 2026-09-24
 
 ### Fixed
 
+- Work Mesh transcript-watch still tracks hook-covered sessions (interactive Claude/Codex) and enqueues `session_end` after 10 minutes of quiet. Hooks keep owning start/turn events; the quiet `session_end` is the channel work-report trigger those sessions were missing. Resume (transcript mtime or a later hook event) resets the timer. A SessionEnd hook within 60s of that emit is not treated as resume, so `/exit` does not double-fire.
 - Reloading a macOS LaunchAgent (`hq mesh daemon install`, including `--if-stale` and the post-update restart, `hq daemon install`, `hq agent kit` services, and bot agents) now waits for `launchctl bootout` to finish before bootstrapping. Before, bootstrap could race the old job's teardown, fail with "Bootstrap failed: 5: Input/output error", and leave the service unloaded with nothing running. Bootstrap now polls `launchctl print` for up to 10 seconds, retries EIO with backoff (0.5s to 8s), and on final failure either restarts the still-loaded previous job or reports that the service is NOT loaded with the `launchctl bootstrap` command to fix it.
 
 ## [5.177.0] — 2026-09-24
@@ -17,7 +35,6 @@
   show include grant and alive-child counts. Terminal child resume, message, and
   account-move paths recheck occupancy and remaining grant allocation. The
   backfill defaults to dry-run.
-
 - When `lanes.hire-grants` is enabled, `hq lanes list` and `hq lanes show` use counts
   from the owning Outpost for active remote lanes. If the Outpost does not return
   counts, both commands show local counts and a warning.
@@ -52,7 +69,6 @@
 - Bot LaunchAgents and systemd units, the Work Mesh daemon unit, the `hq daemon` unit, and the lanes and agent-kit units now name node by its upgrade-stable path (`/opt/homebrew/bin/node` or `/opt/homebrew/opt/<formula>/bin/node`, or nvm's `current` link) instead of the versioned `/opt/homebrew/Cellar/node/<version>/bin/node`. Before, `brew upgrade node` deleted that path and launchd could no longer start the bots. The stable path is used only when it resolves to the same node binary; otherwise the unit keeps the resolved path as before.
 - Installed bot LaunchAgents that still name a versioned or missing node are repaired: `hq bot start` rewrites and reloads the agent, a bot started by launchd rewrites its own agent and reloads it from a detached shell before it takes any message, and `hq doctor` reports it (`bots.<name>.daemon-node`), with `hq doctor --fix` rewriting only the plist file and not reloading launchd. `hq bot list` and `hq bot status` flag a missing node binary. `hq mesh daemon install --if-stale` also reinstalls a same-version unit whose node path is missing or versioned.
 
-
 ## [5.172.0] — 2026-09-24
 
 ### Changed
@@ -89,7 +105,6 @@
 
 - Switching the HQ session company (including `hq-session.sh set company_slug`) clears the Work Mesh project and task, posts `session_end` to the previous company, and holds a personal target as `needs_company`.
 
-
 ## [5.169.0] — 2026-09-24
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -2255,6 +2255,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--in <duration>";
             readonly description: "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)";
+        }, {
+            readonly flags: "--audience <human|agent|both>";
+            readonly description: "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)";
         }];
         readonly subcommands: readonly [];
     }, {

package/dist/command-catalog.generated.js

@@ -2896,6 +2896,10 @@ export const COMMAND_CATALOG = [
                     {
                         "flags": "--in <duration>",
                         "description": "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)"
+                    },
+                    {
+                        "flags": "--audience <human|agent|both>",
+                        "description": "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)"
                     }
                 ],
                 "subcommands": []

package/dist/commands/dm.d.ts

@@ -133,6 +133,7 @@ export declare function resolveMentions(tokens: string[], members: ChannelMember
  * Returns null on anything that doesn't match. Pure → unit-testable.
  */
 export declare function parseDuration(input: string): number | null;
+export type DmAudience = "human" | "agent" | "both";
 export interface DmSendBody {
     toEmail?: string;
     toPersonUid?: string;
@@ -140,6 +141,7 @@ export interface DmSendBody {
     prompt?: string;
     details?: string;
     deliverAt?: string;
+    audience?: DmAudience;
 }
 /**
  * Build the POST /v1/notify/dm request body from CLI inputs. Pure (no I/O,
@@ -156,6 +158,7 @@ export declare function buildDmBody(args: {
     at?: string;
     inDelay?: string;
     now: number;
+    audience?: string;
 }): DmSendBody;
 /** A pending incoming connection request, as returned by the backend. */
 export interface ConnectionRequest {
@@ -204,6 +207,7 @@ export interface DmInboxEvent {
     details?: string;
     prompt?: string;
     acknowledgedAt?: string;
+    audience?: DmAudience;
     /** US-007 file references. Singular `attachment` is the legacy form. */
     attachments?: DmAttachment[];
     attachment?: DmAttachment;
@@ -219,6 +223,7 @@ export interface DmThreadMessage {
     direction: "in" | "out";
     details?: string;
     prompt?: string;
+    audience?: DmAudience;
     attachments?: DmAttachment[];
     attachment?: DmAttachment;
 }

package/dist/commands/dm.js

@@ -276,6 +276,7 @@ export function parseDuration(input) {
     };
     return n * mult[m[2]];
 }
+const DM_AUDIENCE_VALUES = ["human", "agent", "both"];
 /**
  * Build the POST /v1/notify/dm request body from CLI inputs. Pure (no I/O,
  * no clock) so the option-resolution logic is unit-testable; the caller
@@ -312,12 +313,20 @@ export function buildDmBody(args) {
     }
     const prompt = args.prompt?.trim();
     const details = args.details?.trim();
+    let audience;
+    if (args.audience !== undefined && args.audience !== "") {
+        if (!DM_AUDIENCE_VALUES.includes(args.audience)) {
+            throw new Error(`Invalid --audience '${args.audience}': must be human, agent, or both.`);
+        }
+        audience = args.audience;
+    }
     return {
         ...rcpt,
         body,
         ...(prompt ? { prompt } : {}),
         ...(details ? { details } : {}),
         ...(deliverAt ? { deliverAt } : {}),
+        ...(audience ? { audience } : {}),
     };
 }
 function friendlyDmError(status, code, fallback) {
@@ -670,6 +679,7 @@ async function runDmSend(recipient, message, opts) {
             at: opts.at,
             inDelay: opts.in,
             now: Date.now(),
+            audience: opts.audience,
         });
         const token = await ensureCognitoToken();
         const res = await vaultApiFetch({
@@ -831,14 +841,16 @@ export function formatInboxEvent(e, nowMs) {
     const when = chalk.dim(formatRelativeTime(e.createdAt, nowMs));
     const who = chalk.bold(senderLabel(e));
     const email = e.fromEmail && e.fromDisplayName ? chalk.dim(` <${e.fromEmail}>`) : "";
-    return `${marker} ${when}  ${who}${email}\n    ${firstLine(e.body)}${formatAttachments(e)}`;
+    const audienceTag = e.audience === "agent" ? chalk.dim(" [agent]") : "";
+    return `${marker} ${when}  ${who}${email}${audienceTag}\n    ${firstLine(e.body)}${formatAttachments(e)}`;
 }
 /** Render one 1:1 thread line, tagged by direction. */
 export function formatThreadMessage(m, nowMs) {
     const arrow = m.direction === "out" ? chalk.dim("→") : chalk.cyan("←");
     const who = m.direction === "out" ? "you" : senderLabel(m);
     const when = chalk.dim(formatRelativeTime(m.createdAt, nowMs));
-    return `${arrow} ${chalk.bold(who)} ${when}\n    ${firstLine(m.body)}${formatAttachments(m)}`;
+    const audienceTag = m.audience === "agent" ? chalk.dim(" [agent]") : "";
+    return `${arrow} ${chalk.bold(who)} ${when}${audienceTag}\n    ${firstLine(m.body)}${formatAttachments(m)}`;
 }
 /** Render one channel/group message line. */
 export function formatChannelMessage(m, nowMs, opts = {}) {
@@ -1280,6 +1292,7 @@ export function registerDmCommand(program) {
         .option("--details-file <path>", "Read the details from a file (1:1 DMs only)")
         .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time; 1:1 DMs only)")
         .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)")
+        .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)")
         .action(async (recipient, message, opts) => {
         await runDmSend(recipient, message, opts);
     });

package/dist/commands/integrations-connect.d.ts

@@ -47,6 +47,15 @@ export declare function consoleOrigin(vaultApiUrl?: string): string | undefined;
  * by slug), or undefined when the console for this control plane is unknown.
  */
 export declare function consoleIntegrationsUrl(companySlug: string | undefined, origin: string | undefined): string | undefined;
+/**
+ * Google issues "Desktop app" and "Web application" OAuth clients with the
+ * same client-id shape, but only a Web application client accepts HQ's hosted
+ * https callback. A Desktop client fails at Google with `redirect_uri_mismatch`
+ * after the user has already opened the browser, so say it up front
+ * (Undrdog, 2026-09-24). The callback is read from the authorize URL hq-pro
+ * built, so the hint always names the URL Google will actually be sent.
+ */
+export declare function googleClientTypeHint(clientId: string, authorizationUrl: string): string | null;
 export declare function findAlreadyConnected(connections: readonly AdminConnection[], app: string): AdminConnection | undefined;
 export declare function registerConnectCommands(integrations: Command): void;
 //# sourceMappingURL=integrations-connect.d.ts.map

package/dist/commands/integrations-connect.js

@@ -851,12 +851,36 @@ async function userClientSignIn(token, companyUid, target, opts, client, request
     });
     console.error(`Open this URL to sign in to ${started.displayName || target.label}:`);
     console.error(`  ${started.authorizationUrl}`);
+    const googleHint = googleClientTypeHint(client.clientId, started.authorizationUrl);
+    if (googleHint)
+        console.error(chalk.yellow(googleHint));
     if (opts.browser !== false)
         await open(started.authorizationUrl).catch(() => { });
     console.error(chalk.dim("The browser finishes on the HQ console. When it says connected, " +
         "run `hq integrations list` to confirm."));
     return null;
 }
+/**
+ * Google issues "Desktop app" and "Web application" OAuth clients with the
+ * same client-id shape, but only a Web application client accepts HQ's hosted
+ * https callback. A Desktop client fails at Google with `redirect_uri_mismatch`
+ * after the user has already opened the browser, so say it up front
+ * (Undrdog, 2026-09-24). The callback is read from the authorize URL hq-pro
+ * built, so the hint always names the URL Google will actually be sent.
+ */
+export function googleClientTypeHint(clientId, authorizationUrl) {
+    if (!clientId.toLowerCase().endsWith(".apps.googleusercontent.com"))
+        return null;
+    let redirectUri = null;
+    try {
+        redirectUri = new URL(authorizationUrl).searchParams.get("redirect_uri");
+    }
+    catch {
+        // An unparseable URL still gets the client-type half of the hint.
+    }
+    return ("This Google OAuth client must be of type \"Web application\" (a \"Desktop app\" client will not work)" +
+        (redirectUri ? `, with this authorized redirect URI:\n  ${redirectUri}` : "."));
+}
 /**
  * Second chance at a credential when the target's auth mode wasn't known up
  * front.

package/dist/lib/agent-kit/mcp/tools.js

@@ -213,12 +213,13 @@ export function buildAgentMcpTools(clients) {
         },
         {
             name: "hq_dm_send",
-            description: "Send an HQ direct message as this agent to a person (email or prs_…) or agent (agt_…).",
+            description: "Send an HQ direct message as this agent to a person (email or prs_…) or agent (agt_…). Use audience='agent' for progress/status messages that only agents need to see; audience='human' for messages a person must read; audience='both' when unsure.",
             inputSchema: {
                 type: "object",
                 properties: {
                     to: { type: "string", description: "Email, prs_… or agt_… uid" },
                     message: { type: "string" },
+                    audience: { type: "string", enum: ["human", "agent", "both"], description: "Who this message is for (default: human)" },
                 },
                 required: ["to", "message"],
                 additionalProperties: false,
@@ -226,6 +227,10 @@ export function buildAgentMcpTools(clients) {
             handler: async (args) => {
                 const to = str(args, "to", { required: true, max: 320 }).trim();
                 const message = str(args, "message", { required: true, max: 20_000 }).trim();
+                const audience = str(args, "audience");
+                if (audience !== undefined && !["human", "agent", "both"].includes(audience)) {
+                    throw new McpToolInputError('"audience" must be human, agent, or both');
+                }
                 const body = /^[^\s]+@[^\s]+$/.test(to)
                     ? { toEmail: to.toLowerCase(), body: message }
                     : isRecipientUid(to)
@@ -233,6 +238,8 @@ export function buildAgentMcpTools(clients) {
                         : (() => {
                             throw new McpToolInputError('"to" must be an email, prs_… or agt_… uid');
                         })();
+                if (audience)
+                    body.audience = audience;
                 const token = await clients.getToken();
                 const res = await clients.apiJson(token, "/v1/notify/dm", { method: "POST", body });
                 if (res.status < 200 || res.status >= 300) {

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

@@ -216,6 +216,7 @@ export declare class BotApi {
         toPersonUid: string;
         body: string;
         rootEventId?: string;
+        audience?: "human" | "agent" | "both";
     }): Promise<{
         eventId?: string;
         createdAt?: string;

package/dist/lib/bot/api.js

@@ -156,6 +156,8 @@ export class BotApi {
         const payload = { toPersonUid: recipient, body: input.body };
         if (input.rootEventId)
             payload.rootEventId = input.rootEventId;
+        if (input.audience)
+            payload.audience = input.audience;
         const { body } = await this.call("/v1/notify/dm", { method: "POST", body: payload });
         return body;
     }

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

@@ -30,6 +30,11 @@ export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here
 export interface ProgressPosterOptions {
     /** Post one message; resolve true when it was delivered. */
     send: (body: string) => Promise<boolean>;
+    /**
+     * If provided, the final reply is sent through this instead of `send`.
+     * Use to tag the final reply differently from in-between progress messages.
+     */
+    sendFinal?: (body: string) => Promise<boolean>;
     now?: () => number;
     setTimer?: (fn: () => void, ms: number) => unknown;
     clearTimer?: (handle: unknown) => void;
@@ -42,6 +47,7 @@ export interface ProgressPosterOptions {
 export declare function normalizeForCompare(text: string): string;
 export declare class ProgressPoster {
     private readonly send;
+    private readonly sendFinalFn?;
     private readonly now;
     private readonly setTimer;
     private readonly clearTimer;
@@ -73,6 +79,9 @@ export declare class ProgressPoster {
     /**
      * The turn succeeded: post whatever is pending, then the final answer unless
      * it repeats what was already said. Resolves once everything is sent.
+     *
+     * When `sendFinal` was provided, progress items flush through `send` and the
+     * final reply goes through `sendFinal` — keeping their audience tags distinct.
      */
     finish(finalText: string): Promise<void>;
     /**
@@ -84,6 +93,7 @@ export declare class ProgressPoster {
     private scheduleFlush;
     private flushNow;
     private enqueue;
+    private enqueueWith;
     private cancelFlush;
     private cancelNotice;
 }

package/dist/lib/bot/progress.js

@@ -33,6 +33,7 @@ export function normalizeForCompare(text) {
 }
 export class ProgressPoster {
     send;
+    sendFinalFn;
     now;
     setTimer;
     clearTimer;
@@ -54,6 +55,7 @@ export class ProgressPoster {
     delivered = 0;
     constructor(opts) {
         this.send = opts.send;
+        this.sendFinalFn = opts.sendFinal;
         this.now = opts.now ?? Date.now;
         this.setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
         this.clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
@@ -99,6 +101,9 @@ export class ProgressPoster {
     /**
      * The turn succeeded: post whatever is pending, then the final answer unless
      * it repeats what was already said. Resolves once everything is sent.
+     *
+     * When `sendFinal` was provided, progress items flush through `send` and the
+     * final reply goes through `sendFinal` — keeping their audience tags distinct.
      */
     async finish(finalText) {
         if (this.finished)
@@ -109,13 +114,21 @@ export class ProgressPoster {
         const final = finalText.trim();
         const held = this.heldQuestions;
         this.heldQuestions = [];
-        if (final && !this.repeatsSaid(final))
-            this.pending.push(final);
-        else if (held.length > 0)
+        const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
+        if (!shouldAddFinal && held.length > 0)
             this.pending.push(...held);
-        if (this.pending.length === 0 && this.delivered === 0 && !final)
+        if (this.pending.length === 0 && this.delivered === 0 && !shouldAddFinal)
             this.pending.push("(no reply)");
-        this.flushNow();
+        if (this.sendFinalFn && shouldAddFinal) {
+            // Flush any remaining progress messages first, then the final reply separately.
+            this.flushNow();
+            this.enqueueWith(final, this.sendFinalFn);
+        }
+        else {
+            if (shouldAddFinal)
+                this.pending.push(final);
+            this.flushNow();
+        }
         return this.chain;
     }
     /**
@@ -158,10 +171,13 @@ export class ProgressPoster {
         this.enqueue(body);
     }
     enqueue(body) {
+        this.enqueueWith(body, this.send);
+    }
+    enqueueWith(body, sendFn) {
         this.lastPostAt = this.now();
         this.chain = this.chain.then(async () => {
             try {
-                if (await this.send(body))
+                if (await sendFn(body))
                     this.delivered += 1;
             }
             catch {

package/dist/lib/bot/prompt.js

@@ -337,6 +337,12 @@ export function buildSystemPrompt(input) {
         const blocks = input.sources.memory.map((m) => `### ${m.name}\n\n${m.body.trim()}`);
         parts.push(`## Memory (${memoryDir}/)\n\n${blocks.join("\n\n")}`);
     }
+    parts.push(`## Message audience\n\n` +
+        `When sending a DM, tag each message with the right audience using the \`audience\` field:\n` +
+        `- \`agent\`: status pings, tool handoffs, and in-progress notes that only another agent needs to read.\n` +
+        `- \`human\`: anything a person must read — answers, results, questions, summaries.\n` +
+        `- \`both\`: when the content is relevant to both a person and a downstream agent.\n` +
+        `When unsure, use \`human\`. Progress messages sent before the final answer should use \`agent\`; the final answer should use \`human\`.`);
     return `${parts.join("\n\n")}\n`;
 }
 /**

package/dist/lib/bot/run.js

@@ -646,23 +646,25 @@ export async function runBot(deps) {
         writeInflight(dir, { v: 1, ...args.marker, startedAt: now().toISOString() });
         let running = true;
         let posted = 0;
+        const makeSendFn = (fn) => async (body) => {
+            try {
+                await fn(body);
+            }
+            catch (err) {
+                log("warn", `post for ${messageId} failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+            posted += 1;
+            patchInflight(dir, messageId, { progressPosted: posted });
+            if (running && args.afterProgressPost)
+                await args.afterProgressPost().catch(() => undefined);
+            return true;
+        };
         const poster = new ProgressPoster({
             ...deps.progress,
             ...(args.workingNotice === false ? { workingNoticeMs: 0 } : {}),
-            send: async (body) => {
-                try {
-                    await args.send(body);
-                }
-                catch (err) {
-                    log("warn", `post for ${messageId} failed: ${err instanceof Error ? err.message : String(err)}`);
-                    return false;
-                }
-                posted += 1;
-                patchInflight(dir, messageId, { progressPosted: posted });
-                if (running && args.afterProgressPost)
-                    await args.afterProgressPost().catch(() => undefined);
-                return true;
-            },
+            send: makeSendFn(args.send),
+            ...(args.sendFinal ? { sendFinal: makeSendFn(args.sendFinal) } : {}),
         });
         const controller = new AbortController();
         currentTurns.add(controller);
@@ -693,10 +695,10 @@ export async function runBot(deps) {
         }
     };
     const failureReason = (outcome) => outcome.aborted ? STOPPED_BY_OWNER_REASON : `${runtime.id} stopped with an error: ${outcome.excerpt.slice(0, 160)}`;
-    const postOne = (target, body, rootEventId) => {
+    const postOne = (target, body, rootEventId, audience) => {
         const root = rootEventId ? { rootEventId } : {};
         return target.kind === "dm"
-            ? api.sendDm({ toPersonUid: target.peerUid, body, ...root })
+            ? api.sendDm({ toPersonUid: target.peerUid, body, ...root, ...(audience ? { audience } : {}) })
             : api.sendChannelMessage({ channelId: target.channelId, body, ...root });
     };
     /**
@@ -704,10 +706,10 @@ export async function runBot(deps) {
      * PartialPostError naming how many parts got through, so the caller can save
      * exactly the remainder.
      */
-    const sendParts = async (target, parts, from, rootEventId, onDelivered) => {
+    const sendParts = async (target, parts, from, rootEventId, onDelivered, audience) => {
         for (let i = Math.max(0, from); i < parts.length; i += 1) {
             try {
-                await postOne(target, parts[i], rootEventId);
+                await postOne(target, parts[i], rootEventId, audience);
             }
             catch (err) {
                 throw new PartialPostError(parts, i, err);
@@ -716,16 +718,16 @@ export async function runBot(deps) {
         }
     };
     /** Every outbound body goes through here, so nothing over the limit is ever posted whole. */
-    const sendToTarget = (target, body, rootEventId) => sendParts(target, splitBody(body), 0, rootEventId);
+    const sendToTarget = (target, body, rootEventId, audience) => sendParts(target, splitBody(body), 0, rootEventId, undefined, audience);
     /**
      * A `send` for one conversation that remembers how much of its last failed
      * body got through, so the in-flight marker can record the remainder.
      */
     const trackingSend = (target, rootEventId) => {
         const last = { value: null };
-        const send = async (body) => {
+        const makeSend = (audience) => async (body) => {
             try {
-                await sendToTarget(target, body, rootEventId);
+                await sendToTarget(target, body, rootEventId, audience);
                 last.value = null;
             }
             catch (err) {
@@ -733,13 +735,15 @@ export async function runBot(deps) {
                 throw err;
             }
         };
+        const send = makeSend(target.kind === "dm" ? "agent" : undefined);
+        const sendFinal = makeSend(target.kind === "dm" ? "human" : undefined);
         const saved = (reply) => {
             const parts = splitBody(reply);
             const partial = last.value;
             const sameBody = partial !== null && partial.parts.length === parts.length && partial.parts.every((p, i) => p === parts[i]);
             return { reply, replyParts: parts, replyPartsDelivered: sameBody ? partial.delivered : 0 };
         };
-        return { send, saved };
+        return { send, sendFinal, saved };
     };
     // ── Scheduled jobs ────────────────────────────────────────────────────────
     /** Newest pending run key already picked up, per jobId (one catch-up per wake). */
@@ -967,13 +971,14 @@ export async function runBot(deps) {
             }
         };
         const target = { kind: "dm", peerUid };
-        const { send, saved } = trackingSend(target);
+        const { send, sendFinal, saved } = trackingSend(target);
         const { outcome, poster } = await runTurnWithProgress({
             marker: { messageId: KICKOFF_MESSAGE_ID, target, ...(thinking && introEventId ? { reactionEventId: introEventId } : {}) },
             prompt,
             sessionScope: "dm",
             tReceived,
             send,
+            sendFinal,
             // The intro already said the bot is starting, and the app shows it thinking.
             workingNotice: false,
         });
@@ -1069,10 +1074,10 @@ export async function runBot(deps) {
         /** The body of the LAST send, when that send failed (the resume point). */
         let lastFailedBody = null;
         const withHeader = (body) => (headerOut ? body : `${header}${body}`);
-        const send = async (body) => {
+        const makeSend = (fn) => async (body) => {
             const full = withHeader(body);
             try {
-                await tracking.send(full);
+                await fn(full);
                 headerOut = true;
                 deliveredBodies.push(body);
                 lastFailedBody = null;
@@ -1085,6 +1090,8 @@ export async function runBot(deps) {
                 throw err;
             }
         };
+        const send = makeSend(tracking.send);
+        const sendFinal = makeSend(tracking.sendFinal);
         const normalize = (text) => text.replace(/\s+/g, " ").trim();
         /**
          * True only when the final report itself reached the chat in full. With no
@@ -1121,6 +1128,7 @@ export async function runBot(deps) {
             sessionScope: target.sessionScope,
             tReceived,
             send,
+            sendFinal,
             // A scheduled run has nobody waiting in a chat: no "working on it" filler.
             workingNotice: false,
         });
@@ -1312,7 +1320,7 @@ export async function runBot(deps) {
         const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? text :
             `[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 { send, saved } = trackingSend(markerTarget, item.rootEventId);
+        const { send, sendFinal, saved } = trackingSend(markerTarget, item.rootEventId);
         const { outcome, poster } = await runTurnWithProgress({
             marker: {
                 messageId: id,
@@ -1324,6 +1332,7 @@ export async function runBot(deps) {
             sessionScope,
             tReceived,
             send,
+            sendFinal,
             workingNotice: !isSetupBot,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"

package/dist/lib/mesh/live/daemon/transcript-watch.d.ts

@@ -24,6 +24,14 @@
  * Network: harness claude-desktop | codex, source "transcript" on every event.
  * Local state keeps transcriptMarker for channel-card / Atlas before network sync;
  * localHarness is no longer written (harness carries claude-desktop on the wire).
+ *
+ * Hook-covered sessions (durable hook-written state, or a hook event within
+ * TRANSCRIPT_HOOK_COVER_MS) do not get synthesized session_start / turn_end —
+ * hooks own those. The watcher still tracks last activity (transcript mtime or
+ * hook events) and enqueues session_end after TRANSCRIPT_SESSION_END_MS of
+ * quiet so the channel work report has a trigger (US-050b). Resume resets the
+ * timer. A hook event within TRANSCRIPT_HOOK_COVER_MS of our own emit is the
+ * SessionEnd hook catching up and is not treated as resume.
  */
 import * as fs from "node:fs";
 import type { MembershipValidationResult } from "../../../work-context/config.js";
@@ -260,6 +268,14 @@ export declare class TranscriptWatcher {
     /** Record that a hook path emitted an event for sessionId (daemon flush). */
     noteHookEvent(sessionId: string, atMs?: number): void;
     tick(): Promise<TranscriptWatchTickResult>;
+    /**
+     * Hook-covered sessions already emit start/turns. Still track last activity
+     * and enqueue session_end after TRANSCRIPT_SESSION_END_MS of quiet so the
+     * channel work report has a trigger (US-050b). Resume (mtime or a later hook
+     * event) resets the timer. A hook event shortly after our own emit is the
+     * SessionEnd hook catching up — do not treat it as resume.
+     */
+    private tickHookCoveredQuietEnd;
     /**
      * Heavy ticks double the poll interval up to MAX; a quiet tick resets to base.
      */

package/dist/lib/mesh/live/daemon/transcript-watch.js

@@ -24,6 +24,14 @@
  * Network: harness claude-desktop | codex, source "transcript" on every event.
  * Local state keeps transcriptMarker for channel-card / Atlas before network sync;
  * localHarness is no longer written (harness carries claude-desktop on the wire).
+ *
+ * Hook-covered sessions (durable hook-written state, or a hook event within
+ * TRANSCRIPT_HOOK_COVER_MS) do not get synthesized session_start / turn_end —
+ * hooks own those. The watcher still tracks last activity (transcript mtime or
+ * hook events) and enqueues session_end after TRANSCRIPT_SESSION_END_MS of
+ * quiet so the channel work report has a trigger (US-050b). Resume resets the
+ * timer. A hook event within TRANSCRIPT_HOOK_COVER_MS of our own emit is the
+ * SessionEnd hook catching up and is not treated as resume.
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -632,8 +640,7 @@ export class TranscriptWatcher {
                     lastHookEventAt: this.deps.lastHookEventAt,
                     readState: this.readState,
                 })) {
-                    result.skippedHookCovered += 1;
-                    this.tracked.delete(d.path);
+                    this.tickHookCoveredQuietEnd(d, nowMs, result);
                     continue;
                 }
                 let track = this.tracked.get(d.path);
@@ -719,6 +726,63 @@ export class TranscriptWatcher {
             this.tickInFlight = false;
         }
     }
+    /**
+     * Hook-covered sessions already emit start/turns. Still track last activity
+     * and enqueue session_end after TRANSCRIPT_SESSION_END_MS of quiet so the
+     * channel work report has a trigger (US-050b). Resume (mtime or a later hook
+     * event) resets the timer. A hook event shortly after our own emit is the
+     * SessionEnd hook catching up — do not treat it as resume.
+     */
+    tickHookCoveredQuietEnd(d, nowMs, result) {
+        result.skippedHookCovered += 1;
+        const hookAt = this.deps.lastHookEventAt?.get(d.sessionId);
+        const lastActivity = Math.max(d.mtimeMs, hookAt ?? 0);
+        let track = this.tracked.get(d.path);
+        if (!track) {
+            if (nowMs - lastActivity > TRANSCRIPT_FRESH_MS)
+                return;
+            track = {
+                path: d.path,
+                sessionId: d.sessionId,
+                kind: d.kind,
+                cwd: d.cwd,
+                harness: d.harness,
+                lastMtimeMs: d.mtimeMs,
+                lastChangeAtMs: lastActivity,
+                started: true,
+                ended: false,
+                pendingTurn: false,
+                seq: 0,
+                startRetryAttempts: 0,
+                nextStartRetryAtMs: 0,
+            };
+            this.tracked.set(d.path, track);
+        }
+        if (d.mtimeMs > track.lastMtimeMs) {
+            track.lastMtimeMs = d.mtimeMs;
+            track.lastChangeAtMs = nowMs;
+            if (track.ended)
+                track.ended = false;
+        }
+        if (hookAt !== undefined) {
+            const resumeFromHook = !track.ended ||
+                track.endedAtMs === undefined ||
+                hookAt - track.endedAtMs >= TRANSCRIPT_HOOK_COVER_MS;
+            if (resumeFromHook && hookAt > track.lastChangeAtMs) {
+                track.lastChangeAtMs = hookAt;
+                if (track.ended)
+                    track.ended = false;
+            }
+        }
+        if (track.started &&
+            !track.ended &&
+            nowMs - track.lastChangeAtMs >= TRANSCRIPT_SESSION_END_MS) {
+            this.emitKind(track, "session_end", nowMs);
+            track.ended = true;
+            track.endedAtMs = nowMs;
+            result.ended += 1;
+        }
+    }
     /**
      * Heavy ticks double the poll interval up to MAX; a quiet tick resets to base.
      */

package/package.json

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