@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/mesh/live/daemon/state.d.ts

@@ -1,9 +1,11 @@
 /**
  * Daemon state.json under ~/.hq/work-mesh/daemon/ (0600, metadata-only).
  */
+import * as fs from "node:fs";
 import type { MqttConnectionState } from "./presence.js";
 import type { FlushSummary } from "../flush.js";
-export interface PresenceRefusalState {
+import type { DroppedPresenceCompany } from "./credentials.js";
+interface PresenceRefusalState {
     code: string;
     status: number;
     nextRetryAt: string;
@@ -14,6 +16,8 @@ export interface DaemonStateFile {
     startedAt: string;
     mqttState: MqttConnectionState;
     companiesOnline: string[];
+    /** Companies omitted from the current presence credential bundle. */
+    presenceDroppedCompanies?: DroppedPresenceCompany[];
     actorUid?: string;
     lastFlushAt?: string;
     lastFlushResult?: FlushSummary & {
@@ -24,10 +28,23 @@ export interface DaemonStateFile {
     presenceRefusal?: PresenceRefusalState | null;
     /** Daemon emit mode: "legacy" (spool/flush) or "direct" (receive-only). */
     emitMode?: "legacy" | "direct";
+    /** Authoritative membership denials for device-default-derived tenant I/O. */
+    deviceDefaultAuthorizationDenials?: number;
+    /** Transient device-default membership refresh failures; the next cycle retries. */
+    deviceDefaultMembershipLookupFailures?: number;
+    /** CLI version this daemon process was started with. */
+    cliVersion?: string;
+    /** realpath of the CLI entry this daemon process was started with. */
+    cliEntry?: string;
     updatedAt: string;
 }
 export declare function defaultDaemonState(pid: number, now?: () => Date): DaemonStateFile;
 export declare function readDaemonState(dir: string): DaemonStateFile | null;
-export declare function writeDaemonState(dir: string, state: DaemonStateFile): void;
+interface WriteDaemonStateOptions {
+    renameSync?: typeof fs.renameSync;
+    sleepSync?: (ms: number) => void;
+}
+export declare function writeDaemonState(dir: string, state: DaemonStateFile, options?: WriteDaemonStateOptions): void;
 export declare function patchDaemonState(dir: string, patch: Partial<DaemonStateFile>, now?: () => Date): DaemonStateFile;
+export {};
 //# sourceMappingURL=state.d.ts.map

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

@@ -29,13 +29,45 @@ export function readDaemonState(dir) {
         return null;
     }
 }
-export function writeDaemonState(dir, state) {
+const DAEMON_STATE_RENAME_RETRY_DELAYS_MS = [20, 50, 100];
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), 0, 0, ms);
+}
+function isTransientRenameContention(err) {
+    return err !== null && typeof err === "object" && "code" in err &&
+        (err.code === "EPERM" || err.code === "EBUSY");
+}
+export function writeDaemonState(dir, state, options = {}) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     const dest = daemonStatePath(dir);
     const tmp = path.join(dir, `.state.tmp.${process.pid}.${Date.now()}`);
     const body = `${JSON.stringify(state, null, 2)}\n`;
     fs.writeFileSync(tmp, body, { mode: 0o600 });
-    fs.renameSync(tmp, dest);
+    const renameSync = options.renameSync ?? fs.renameSync;
+    const waitSync = options.sleepSync ?? sleepSync;
+    try {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                renameSync(tmp, dest);
+                break;
+            }
+            catch (err) {
+                const delay = DAEMON_STATE_RENAME_RETRY_DELAYS_MS[attempt];
+                if (!isTransientRenameContention(err) || delay === undefined)
+                    throw err;
+                waitSync(delay);
+            }
+        }
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* Preserve the rename failure; the destination remains the prior complete state. */
+        }
+        throw err;
+    }
     try {
         fs.chmodSync(dest, 0o600);
     }

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

@@ -24,6 +24,19 @@
  * 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 — hooks own
+ * that. The watcher still tracks last activity (transcript mtime or hook
+ * events). It enqueues turn_end when hooks never did (Stop often never fires
+ * for a live Claude Code session sitting at the prompt; server turnCount
+ * stays 0) and session_end after TRANSCRIPT_SESSION_END_MS of quiet so the
+ * channel work report has a trigger (US-050b / US-051c). Both events take
+ * seq from the shared ~/.hq/work-mesh/seq/<sid> file the hooks use; an
+ * in-memory counter restarting at 1 is dropped by the server as a duplicate
+ * of session_start. 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";
@@ -38,8 +51,6 @@ export declare const TRANSCRIPT_WATCH_INTERVAL_MAX_MS = 120000;
 export declare const TRANSCRIPT_WATCH_BACKOFF_ENTRIES = 2000;
 /** Double the interval when a tick takes longer than this many ms. */
 export declare const TRANSCRIPT_WATCH_BACKOFF_DURATION_MS = 500;
-/** Hard cap on entries examined (dir stats, readdir children, file stats) per tick. */
-export declare const TRANSCRIPT_WATCH_ENTRY_CAP = 20000;
 /**
  * Even when a directory mtime matches the cache, force a full relist (readdir +
  * re-stat) after this many ms so content appends and coarse mtime granularity
@@ -49,10 +60,14 @@ export declare const TRANSCRIPT_WATCH_REVALIDATE_MS: number;
 export declare const TRANSCRIPT_TURN_QUIET_MS = 5000;
 export declare const TRANSCRIPT_SESSION_END_MS: number;
 export declare const TRANSCRIPT_HOOK_COVER_MS = 60000;
-/** Ignore cold transcripts whose mtime is older than this on first sight. */
-export declare const TRANSCRIPT_FRESH_MS: number;
+/**
+ * Hook-covered sessions skipped as "stale" on first sight never got a quiet
+ * session_end (live: skippedHook=411, ended=0). Adopt them for this long after
+ * last activity so a 10–120 min quiet window still reports after a daemon
+ * restart or a missed track. Older than this stays silent (the 6h reaper).
+ */
+export declare const TRANSCRIPT_HOOK_QUIET_ADOPT_MS: number;
 export declare const TRANSCRIPT_MARKER: "from transcript";
-export declare const TRANSCRIPT_ADAPTER_VERSION: string;
 /** Network `source` stamped on every synthesized event (AMEND-001). */
 export declare const TRANSCRIPT_EVENT_SOURCE: "transcript";
 /** Fs surface used by the watcher — intentionally no open/readFile. */
@@ -68,7 +83,7 @@ export interface TranscriptFs {
     existsSync: (p: string) => boolean;
 }
 export declare const defaultTranscriptFs: TranscriptFs;
-export type TranscriptKind = "claude" | "codex";
+type TranscriptKind = "claude" | "codex";
 export interface DiscoveredTranscript {
     path: string;
     sessionId: string;
@@ -93,6 +108,11 @@ export interface TranscriptWatchDeps {
      * TRANSCRIPT_HOOK_COVER_MS are not synthesized.
      */
     lastHookEventAt?: Map<string, number>;
+    /**
+     * Last hook-emitted turn_end per sessionId (epoch ms). Used so we do not
+     * synthesize a second turn_end when Stop already landed.
+     */
+    lastHookTurnEndAt?: Map<string, number>;
     /** Injectable enqueue (tests). */
     enqueue?: typeof enqueueSessionEvent;
     /** Injectable state read/write (tests). */
@@ -119,6 +139,8 @@ export interface TranscriptWatchTickResult {
     ended: number;
     skippedHookCovered: number;
     skippedStale: number;
+    /** sessionIds that received a synthesized session_end this tick (quiet path). */
+    endedSessionIds: string[];
     /** Dir stats + readdir children + file stats examined this tick. */
     entriesExamined: number;
     durationMs: number;
@@ -136,7 +158,7 @@ export interface TranscriptWatchTickResult {
     skippedConcurrent: boolean;
 }
 /** Per-directory mtime + child cache for incremental discovery. */
-export interface TranscriptDirCacheEntry {
+interface TranscriptDirCacheEntry {
     mtimeMs: number;
     files: DiscoveredTranscript[];
     subdirs: string[];
@@ -146,7 +168,7 @@ export interface TranscriptDirCacheEntry {
 export interface TranscriptDiscoverCache {
     dirs: Map<string, TranscriptDirCacheEntry>;
 }
-export interface DiscoverScanMeta {
+interface DiscoverScanMeta {
     entriesExamined: number;
     dirsListed: number;
     dirsSkipped: number;
@@ -235,7 +257,7 @@ export declare function resolveTranscriptRegistration(input: {
  */
 export declare function noteHookSessionsFromSpoolFile(spoolPath: string, lastHookEventAt: Map<string, number>, atMs: number, tfs?: Pick<TranscriptFs, "existsSync"> & {
     readFileSync?: (p: string, enc: "utf8") => string;
-}): string[];
+}, lastHookTurnEndAt?: Map<string, number>): string[];
 export declare class TranscriptWatcher {
     private readonly tracked;
     private readonly deps;
@@ -257,6 +279,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. Still track last activity,
+     * fill in turn_end when Stop never did, and enqueue session_end after
+     * TRANSCRIPT_SESSION_END_MS of quiet (US-050b / US-051c). 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.
      */
@@ -266,6 +296,11 @@ export declare class TranscriptWatcher {
      * enqueue session_start. Never overwrites a hook-written state.
      */
     private emitStart;
+    /**
+     * Seq comes from the shared per-session file hooks also write. Restarting
+     * at 1 here is dropped server-side as a duplicate of session_start (US-051c).
+     */
+    private seqEnv;
     private emitKind;
 }
 /**
@@ -275,4 +310,5 @@ export declare function nextTranscriptWatchIntervalMs(currentMs: number, opts: {
     entriesExamined: number;
     durationMs: number;
 }): number;
+export {};
 //# sourceMappingURL=transcript-watch.d.ts.map

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

@@ -24,6 +24,19 @@
  * 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 — hooks own
+ * that. The watcher still tracks last activity (transcript mtime or hook
+ * events). It enqueues turn_end when hooks never did (Stop often never fires
+ * for a live Claude Code session sitting at the prompt; server turnCount
+ * stays 0) and session_end after TRANSCRIPT_SESSION_END_MS of quiet so the
+ * channel work report has a trigger (US-050b / US-051c). Both events take
+ * seq from the shared ~/.hq/work-mesh/seq/<sid> file the hooks use; an
+ * in-memory counter restarting at 1 is dropped by the server as a duplicate
+ * of session_start. 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";
@@ -36,6 +49,7 @@ import { deriveRemoteOwnerSlug, deriveRepoIdentityKey, } from "../../../work-con
 import { isHookWrittenSessionState, readSessionState, writeSessionState, } from "../../../work-context/state.js";
 import { enqueueSessionEvent } from "../enqueue.js";
 import { isValidSessionId } from "../session-identity.js";
+import { reserveSessionSeq } from "../session-seq.js";
 export const TRANSCRIPT_WATCH_INTERVAL_MS = 30_000;
 /** Ceiling for adaptive backoff after heavy ticks. */
 export const TRANSCRIPT_WATCH_INTERVAL_MAX_MS = 120_000;
@@ -44,7 +58,7 @@ export const TRANSCRIPT_WATCH_BACKOFF_ENTRIES = 2_000;
 /** Double the interval when a tick takes longer than this many ms. */
 export const TRANSCRIPT_WATCH_BACKOFF_DURATION_MS = 500;
 /** Hard cap on entries examined (dir stats, readdir children, file stats) per tick. */
-export const TRANSCRIPT_WATCH_ENTRY_CAP = 20_000;
+const TRANSCRIPT_WATCH_ENTRY_CAP = 20_000;
 /**
  * Even when a directory mtime matches the cache, force a full relist (readdir +
  * re-stat) after this many ms so content appends and coarse mtime granularity
@@ -54,10 +68,20 @@ export const TRANSCRIPT_WATCH_REVALIDATE_MS = 5 * 60_000;
 export const TRANSCRIPT_TURN_QUIET_MS = 5_000;
 export const TRANSCRIPT_SESSION_END_MS = 10 * 60_000;
 export const TRANSCRIPT_HOOK_COVER_MS = 60_000;
+/** Retry unavailable transcript-start reconciliation without hot-looping. */
+const TRANSCRIPT_START_RETRY_BASE_MS = 30_000;
+const TRANSCRIPT_START_RETRY_MAX_MS = 120_000;
 /** Ignore cold transcripts whose mtime is older than this on first sight. */
-export const TRANSCRIPT_FRESH_MS = TRANSCRIPT_SESSION_END_MS;
+const TRANSCRIPT_FRESH_MS = TRANSCRIPT_SESSION_END_MS;
+/**
+ * Hook-covered sessions skipped as "stale" on first sight never got a quiet
+ * session_end (live: skippedHook=411, ended=0). Adopt them for this long after
+ * last activity so a 10–120 min quiet window still reports after a daemon
+ * restart or a missed track. Older than this stays silent (the 6h reaper).
+ */
+export const TRANSCRIPT_HOOK_QUIET_ADOPT_MS = 2 * 60 * 60 * 1000;
 export const TRANSCRIPT_MARKER = "from transcript";
-export const TRANSCRIPT_ADAPTER_VERSION = CLI_VERSION;
+const TRANSCRIPT_ADAPTER_VERSION = CLI_VERSION;
 /** Network `source` stamped on every synthesized event (AMEND-001). */
 export const TRANSCRIPT_EVENT_SOURCE = "transcript";
 export const defaultTranscriptFs = {
@@ -494,7 +518,7 @@ export function resolveTranscriptRegistration(input) {
  * Scan a spool/held jsonl for hook-emitted session ids (not transcript-watch).
  * Reads spool metadata only — never a transcript file.
  */
-export function noteHookSessionsFromSpoolFile(spoolPath, lastHookEventAt, atMs, tfs = defaultTranscriptFs) {
+export function noteHookSessionsFromSpoolFile(spoolPath, lastHookEventAt, atMs, tfs = defaultTranscriptFs, lastHookTurnEndAt) {
     if (!tfs.existsSync(spoolPath))
         return [];
     const readFile = tfs.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
@@ -510,13 +534,30 @@ export function noteHookSessionsFromSpoolFile(spoolPath, lastHookEventAt, atMs,
         if (!line.trim())
             continue;
         try {
-            const ev = JSON.parse(line);
+            const raw = JSON.parse(line);
+            const ev = raw.event && typeof raw.event === "object" ? raw.event : raw;
             if (typeof ev.sessionId !== "string" || !ev.sessionId)
                 continue;
             // Synthesized transcript events carry source=transcript — not hooks.
             if (ev.source === TRANSCRIPT_EVENT_SOURCE)
                 continue;
-            lastHookEventAt.set(ev.sessionId, atMs);
+            let eventAt = atMs;
+            const atRaw = typeof ev.at === "string" ? ev.at : undefined;
+            if (atRaw) {
+                const parsed = Date.parse(atRaw);
+                if (Number.isFinite(parsed))
+                    eventAt = parsed;
+            }
+            const prev = lastHookEventAt.get(ev.sessionId);
+            if (prev === undefined || eventAt > prev) {
+                lastHookEventAt.set(ev.sessionId, eventAt);
+            }
+            if (ev.kind === "turn_end" && lastHookTurnEndAt) {
+                const prevEnd = lastHookTurnEndAt.get(ev.sessionId);
+                if (prevEnd === undefined || eventAt > prevEnd) {
+                    lastHookTurnEndAt.set(ev.sessionId, eventAt);
+                }
+            }
             noted.push(ev.sessionId);
         }
         catch {
@@ -570,6 +611,7 @@ export class TranscriptWatcher {
             ended: 0,
             skippedHookCovered: 0,
             skippedStale: 0,
+            endedSessionIds: [],
             entriesExamined: 0,
             durationMs: 0,
             capped: false,
@@ -595,6 +637,7 @@ export class TranscriptWatcher {
                 ended: 0,
                 skippedHookCovered: 0,
                 skippedStale: 0,
+                endedSessionIds: [],
                 entriesExamined: 0,
                 durationMs: 0,
                 capped: false,
@@ -629,8 +672,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);
@@ -652,6 +694,8 @@ export class TranscriptWatcher {
                         ended: false,
                         pendingTurn: false,
                         seq: 0,
+                        startRetryAttempts: 0,
+                        nextStartRetryAtMs: 0,
                     };
                     this.tracked.set(d.path, track);
                     const started = await this.emitStart(track, nowMs);
@@ -661,6 +705,14 @@ export class TranscriptWatcher {
                 }
                 if (track.ended)
                     continue;
+                if (!track.started) {
+                    if (nowMs < track.nextStartRetryAtMs)
+                        continue;
+                    const started = await this.emitStart(track, nowMs);
+                    if (started)
+                        result.started += 1;
+                    continue;
+                }
                 if (d.mtimeMs > track.lastMtimeMs) {
                     track.lastMtimeMs = d.mtimeMs;
                     track.lastChangeAtMs = nowMs;
@@ -670,16 +722,20 @@ export class TranscriptWatcher {
                 }
                 if (track.pendingTurn &&
                     nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
-                    this.emitKind(track, "turn_end", nowMs);
-                    track.pendingTurn = false;
-                    result.turns += 1;
+                    if (this.emitKind(track, "turn_end", nowMs, transcriptTurnAtMs(track, nowMs))) {
+                        track.pendingTurn = false;
+                        result.turns += 1;
+                    }
                 }
                 if (track.started &&
                     !track.ended &&
                     nowMs - track.lastChangeAtMs >= TRANSCRIPT_SESSION_END_MS) {
-                    this.emitKind(track, "session_end", nowMs);
-                    track.ended = true;
-                    result.ended += 1;
+                    if (this.emitKind(track, "session_end", nowMs)) {
+                        track.ended = true;
+                        track.endedAtMs = nowMs;
+                        result.ended += 1;
+                        result.endedSessionIds.push(track.sessionId);
+                    }
                 }
             }
             // Sessions that disappeared from disk: end if still open. Skip when the
@@ -689,9 +745,12 @@ export class TranscriptWatcher {
                     if (seenPaths.has(p))
                         continue;
                     if (track.started && !track.ended) {
-                        this.emitKind(track, "session_end", nowMs);
-                        track.ended = true;
-                        result.ended += 1;
+                        if (this.emitKind(track, "session_end", nowMs)) {
+                            track.ended = true;
+                            track.endedAtMs = nowMs;
+                            result.ended += 1;
+                            result.endedSessionIds.push(track.sessionId);
+                        }
                     }
                     this.tracked.delete(p);
                 }
@@ -706,6 +765,81 @@ export class TranscriptWatcher {
             this.tickInFlight = false;
         }
     }
+    /**
+     * Hook-covered sessions already emit start. Still track last activity,
+     * fill in turn_end when Stop never did, and enqueue session_end after
+     * TRANSCRIPT_SESSION_END_MS of quiet (US-050b / US-051c). 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 hookTurnEndAt = this.deps.lastHookTurnEndAt?.get(d.sessionId);
+        const lastActivity = Math.max(d.mtimeMs, hookAt ?? 0);
+        const hookTurnCovers = (mtimeMs) => hookTurnEndAt !== undefined && hookTurnEndAt >= mtimeMs;
+        let track = this.tracked.get(d.path);
+        if (!track) {
+            // Cold transcripts stay silent. Hook-covered sessions that already sat
+            // quiet past TRANSCRIPT_SESSION_END_MS still need one session_end — the
+            // live skip path returned here and never tracked them (US-051).
+            if (nowMs - lastActivity > TRANSCRIPT_HOOK_QUIET_ADOPT_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: !hookTurnCovers(d.mtimeMs),
+                seq: 0,
+                startRetryAttempts: 0,
+                nextStartRetryAtMs: 0,
+            };
+            this.tracked.set(d.path, track);
+        }
+        if (d.mtimeMs > track.lastMtimeMs) {
+            track.lastMtimeMs = d.mtimeMs;
+            track.lastChangeAtMs = nowMs;
+            track.pendingTurn = !hookTurnCovers(d.mtimeMs);
+            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 (hookTurnCovers(track.lastMtimeMs)) {
+            track.pendingTurn = false;
+        }
+        if (track.pendingTurn &&
+            nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
+            if (this.emitKind(track, "turn_end", nowMs, transcriptTurnAtMs(track, nowMs))) {
+                track.pendingTurn = false;
+                result.turns += 1;
+            }
+        }
+        if (track.started &&
+            !track.ended &&
+            nowMs - track.lastChangeAtMs >= TRANSCRIPT_SESSION_END_MS) {
+            if (this.emitKind(track, "session_end", nowMs)) {
+                track.ended = true;
+                track.endedAtMs = nowMs;
+                result.ended += 1;
+                result.endedSessionIds.push(track.sessionId);
+            }
+        }
+    }
     /**
      * Heavy ticks double the poll interval up to MAX; a quiet tick resets to base.
      */
@@ -737,43 +871,105 @@ export class TranscriptWatcher {
             hqRoot: this.deps.hqRoot,
             source: "transcript",
         };
-        await this.reconcileFn(observation, {
-            root: this.deps.workContextRoot,
-            env: this.deps.env,
-            now: () => new Date(nowMs),
-            validateMembership: this.deps.validateMembership,
-            deliver: this.deps.deliver,
-            offline: !this.deps.deliver,
-        });
+        try {
+            await this.reconcileFn(observation, {
+                root: this.deps.workContextRoot,
+                env: this.deps.env,
+                now: () => new Date(nowMs),
+                validateMembership: this.deps.validateMembership,
+                deliver: this.deps.deliver,
+                offline: !this.deps.deliver,
+            });
+        }
+        catch {
+            track.startRetryAttempts += 1;
+            const delayMs = Math.min(TRANSCRIPT_START_RETRY_BASE_MS * 2 ** (track.startRetryAttempts - 1), TRANSCRIPT_START_RETRY_MAX_MS);
+            track.nextStartRetryAtMs = nowMs + delayMs;
+            return false;
+        }
         // Re-check: a hook may have raced us during reconcile.
         const after = this.readState(track.sessionId, this.deps.workContextRoot);
         if (isHookWrittenSessionState(after)) {
             track.ended = true;
             return false;
         }
-        this.emitKind(track, "session_start", nowMs);
+        if (!this.emitKind(track, "session_start", nowMs))
+            return false;
         track.started = true;
+        track.startRetryAttempts = 0;
+        track.nextStartRetryAtMs = 0;
         return true;
     }
-    emitKind(track, kind, nowMs) {
-        track.seq += 1;
+    /**
+     * Seq comes from the shared per-session file hooks also write. Restarting
+     * at 1 here is dropped server-side as a duplicate of session_start (US-051c).
+     */
+    seqEnv() {
+        const env = { ...(this.deps.env ?? {}) };
+        if (!env.WORK_MESH_SEQ_DIR?.trim()) {
+            const root = this.deps.workMeshRoot ??
+                (this.deps.home
+                    ? path.join(this.deps.home, ".hq", "work-mesh")
+                    : undefined);
+            if (root)
+                env.WORK_MESH_SEQ_DIR = path.join(root, "seq");
+        }
+        return env;
+    }
+    emitKind(track, kind, nowMs, 
+    /** Event time when it differs from detection time (turn_end). */
+    atMs = nowMs) {
+        let seq;
+        try {
+            seq = reserveSessionSeq(track.sessionId, 1, this.seqEnv());
+        }
+        catch {
+            return false;
+        }
+        track.seq = seq;
+        // `at` must not go backwards against seq: a transcript time older than the
+        // last event this watcher sent for the session is clamped to that event.
+        const eventAtMs = track.lastSentAtMs !== undefined && atMs < track.lastSentAtMs
+            ? track.lastSentAtMs
+            : atMs;
         const opts = {
             kind,
             sessionId: track.sessionId,
             harness: track.harness,
             adapterVersion: TRANSCRIPT_ADAPTER_VERSION,
             source: TRANSCRIPT_EVENT_SOURCE,
-            at: new Date(nowMs).toISOString(),
-            seq: track.seq,
+            at: new Date(eventAtMs).toISOString(),
+            seq,
             cwd: track.cwd,
             hqRoot: this.deps.hqRoot,
             root: this.deps.workMeshRoot,
             env: this.deps.env,
             now: () => new Date(nowMs),
+            ...(kind === "session_end" ? { transcriptPath: track.path } : {}),
         };
-        this.enqueueFn(opts);
+        try {
+            this.enqueueFn(opts);
+            track.lastSentAtMs = eventAtMs;
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
 }
+/**
+ * A transcript turn ended when the transcript last changed (file mtime), not
+ * when a backed-off or restarted poll noticed it. Never later than now. A
+ * catch-up turn_end sent in the same tick as session_end (restart adoption of
+ * an already quiet transcript) therefore carries the earlier transcript time,
+ * not the session_end time.
+ */
+function transcriptTurnAtMs(track, nowMs) {
+    const mtimeMs = track.lastMtimeMs;
+    if (!Number.isFinite(mtimeMs) || mtimeMs <= 0)
+        return nowMs;
+    return Math.min(mtimeMs, nowMs);
+}
 /**
  * Adaptive interval: busy ticks double up to MAX; quiet ticks return to base.
  */

package/dist/lib/mesh/live/daemon/version-drift.d.ts

@@ -0,0 +1,5 @@
+/** Version installed behind the entrypoint that launched this daemon. */
+export declare function readInstalledCliVersion(entry?: string): string | null;
+/** A missing/unreadable installed version is not proof of a safe restart. */
+export declare function hasCliVersionDrift(daemonVersion: string, installedVersion: string | null | undefined): installedVersion is string;
+//# sourceMappingURL=version-drift.d.ts.map

package/dist/lib/mesh/live/daemon/version-drift.js

@@ -0,0 +1,47 @@
+/**
+ * Read the version of the CLI package currently selected by the daemon's
+ * launch entrypoint. The daemon keeps the version it was loaded with in
+ * memory; an npm/pnpm upgrade can repoint this entrypoint without restarting
+ * that process.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+function packageVersionAtOrAbove(entry) {
+    let dir;
+    try {
+        dir = path.dirname(fs.realpathSync(entry));
+    }
+    catch {
+        return null;
+    }
+    // A CLI entrypoint is normally <package>/dist/index.js. Keep the walk
+    // bounded so a malformed entrypoint never traverses an entire filesystem.
+    for (let i = 0; i < 8; i += 1) {
+        const pkgPath = path.join(dir, "package.json");
+        try {
+            const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (parsed.name === "@indigoai-us/hq-cli" &&
+                typeof parsed.version === "string" &&
+                parsed.version.trim()) {
+                return parsed.version.trim();
+            }
+        }
+        catch {
+            // No package manifest at this level; continue walking upward.
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Version installed behind the entrypoint that launched this daemon. */
+export function readInstalledCliVersion(entry = process.argv[1]) {
+    return entry ? packageVersionAtOrAbove(entry) : null;
+}
+/** A missing/unreadable installed version is not proof of a safe restart. */
+export function hasCliVersionDrift(daemonVersion, installedVersion) {
+    return Boolean(installedVersion && installedVersion !== daemonVersion);
+}
+//# sourceMappingURL=version-drift.js.map