@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

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

@@ -1,11 +1,9 @@
 /**
  * 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";
-import type { DroppedPresenceCompany } from "./credentials.js";
-interface PresenceRefusalState {
+export interface PresenceRefusalState {
     code: string;
     status: number;
     nextRetryAt: string;
@@ -16,8 +14,6 @@ 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 & {
@@ -28,23 +24,10 @@ 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;
-interface WriteDaemonStateOptions {
-    renameSync?: typeof fs.renameSync;
-    sleepSync?: (ms: number) => void;
-}
-export declare function writeDaemonState(dir: string, state: DaemonStateFile, options?: WriteDaemonStateOptions): void;
+export declare function writeDaemonState(dir: string, state: DaemonStateFile): 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,45 +29,13 @@ export function readDaemonState(dir) {
         return null;
     }
 }
-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 = {}) {
+export function writeDaemonState(dir, state) {
     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 });
-    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;
-    }
+    fs.renameSync(tmp, dest);
     try {
         fs.chmodSync(dest, 0o600);
     }

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

@@ -24,19 +24,6 @@
  * 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";
@@ -51,6 +38,8 @@ 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
@@ -60,14 +49,10 @@ 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;
-/**
- * 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;
+/** Ignore cold transcripts whose mtime is older than this on first sight. */
+export declare const TRANSCRIPT_FRESH_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. */
@@ -83,7 +68,7 @@ export interface TranscriptFs {
     existsSync: (p: string) => boolean;
 }
 export declare const defaultTranscriptFs: TranscriptFs;
-type TranscriptKind = "claude" | "codex";
+export type TranscriptKind = "claude" | "codex";
 export interface DiscoveredTranscript {
     path: string;
     sessionId: string;
@@ -108,11 +93,6 @@ 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). */
@@ -139,8 +119,6 @@ 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;
@@ -158,7 +136,7 @@ export interface TranscriptWatchTickResult {
     skippedConcurrent: boolean;
 }
 /** Per-directory mtime + child cache for incremental discovery. */
-interface TranscriptDirCacheEntry {
+export interface TranscriptDirCacheEntry {
     mtimeMs: number;
     files: DiscoveredTranscript[];
     subdirs: string[];
@@ -168,7 +146,7 @@ interface TranscriptDirCacheEntry {
 export interface TranscriptDiscoverCache {
     dirs: Map<string, TranscriptDirCacheEntry>;
 }
-interface DiscoverScanMeta {
+export interface DiscoverScanMeta {
     entriesExamined: number;
     dirsListed: number;
     dirsSkipped: number;
@@ -257,7 +235,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;
-}, lastHookTurnEndAt?: Map<string, number>): string[];
+}): string[];
 export declare class TranscriptWatcher {
     private readonly tracked;
     private readonly deps;
@@ -279,14 +257,6 @@ 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.
      */
@@ -296,11 +266,6 @@ 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;
 }
 /**
@@ -310,5 +275,4 @@ 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,19 +24,6 @@
  * 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";
@@ -49,7 +36,6 @@ 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;
@@ -58,7 +44,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. */
-const TRANSCRIPT_WATCH_ENTRY_CAP = 20_000;
+export 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
@@ -68,20 +54,10 @@ 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. */
-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_FRESH_MS = TRANSCRIPT_SESSION_END_MS;
 export const TRANSCRIPT_MARKER = "from transcript";
-const TRANSCRIPT_ADAPTER_VERSION = CLI_VERSION;
+export const TRANSCRIPT_ADAPTER_VERSION = CLI_VERSION;
 /** Network `source` stamped on every synthesized event (AMEND-001). */
 export const TRANSCRIPT_EVENT_SOURCE = "transcript";
 export const defaultTranscriptFs = {
@@ -518,7 +494,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, lastHookTurnEndAt) {
+export function noteHookSessionsFromSpoolFile(spoolPath, lastHookEventAt, atMs, tfs = defaultTranscriptFs) {
     if (!tfs.existsSync(spoolPath))
         return [];
     const readFile = tfs.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
@@ -534,30 +510,13 @@ export function noteHookSessionsFromSpoolFile(spoolPath, lastHookEventAt, atMs,
         if (!line.trim())
             continue;
         try {
-            const raw = JSON.parse(line);
-            const ev = raw.event && typeof raw.event === "object" ? raw.event : raw;
+            const ev = JSON.parse(line);
             if (typeof ev.sessionId !== "string" || !ev.sessionId)
                 continue;
             // Synthesized transcript events carry source=transcript — not hooks.
             if (ev.source === TRANSCRIPT_EVENT_SOURCE)
                 continue;
-            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);
-                }
-            }
+            lastHookEventAt.set(ev.sessionId, atMs);
             noted.push(ev.sessionId);
         }
         catch {
@@ -611,7 +570,6 @@ export class TranscriptWatcher {
             ended: 0,
             skippedHookCovered: 0,
             skippedStale: 0,
-            endedSessionIds: [],
             entriesExamined: 0,
             durationMs: 0,
             capped: false,
@@ -637,7 +595,6 @@ export class TranscriptWatcher {
                 ended: 0,
                 skippedHookCovered: 0,
                 skippedStale: 0,
-                endedSessionIds: [],
                 entriesExamined: 0,
                 durationMs: 0,
                 capped: false,
@@ -672,7 +629,8 @@ export class TranscriptWatcher {
                     lastHookEventAt: this.deps.lastHookEventAt,
                     readState: this.readState,
                 })) {
-                    this.tickHookCoveredQuietEnd(d, nowMs, result);
+                    result.skippedHookCovered += 1;
+                    this.tracked.delete(d.path);
                     continue;
                 }
                 let track = this.tracked.get(d.path);
@@ -694,8 +652,6 @@ 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);
@@ -705,14 +661,6 @@ 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;
@@ -722,20 +670,16 @@ export class TranscriptWatcher {
                 }
                 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;
-                    }
+                    this.emitKind(track, "turn_end", 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);
-                    }
+                    this.emitKind(track, "session_end", nowMs);
+                    track.ended = true;
+                    result.ended += 1;
                 }
             }
             // Sessions that disappeared from disk: end if still open. Skip when the
@@ -745,12 +689,9 @@ export class TranscriptWatcher {
                     if (seenPaths.has(p))
                         continue;
                     if (track.started && !track.ended) {
-                        if (this.emitKind(track, "session_end", nowMs)) {
-                            track.ended = true;
-                            track.endedAtMs = nowMs;
-                            result.ended += 1;
-                            result.endedSessionIds.push(track.sessionId);
-                        }
+                        this.emitKind(track, "session_end", nowMs);
+                        track.ended = true;
+                        result.ended += 1;
                     }
                     this.tracked.delete(p);
                 }
@@ -765,81 +706,6 @@ 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.
      */
@@ -871,105 +737,43 @@ export class TranscriptWatcher {
             hqRoot: this.deps.hqRoot,
             source: "transcript",
         };
-        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;
-        }
+        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,
+        });
         // 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;
         }
-        if (!this.emitKind(track, "session_start", nowMs))
-            return false;
+        this.emitKind(track, "session_start", nowMs);
         track.started = true;
-        track.startRetryAttempts = 0;
-        track.nextStartRetryAtMs = 0;
         return true;
     }
-    /**
-     * 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;
+    emitKind(track, kind, nowMs) {
+        track.seq += 1;
         const opts = {
             kind,
             sessionId: track.sessionId,
             harness: track.harness,
             adapterVersion: TRANSCRIPT_ADAPTER_VERSION,
             source: TRANSCRIPT_EVENT_SOURCE,
-            at: new Date(eventAtMs).toISOString(),
-            seq,
+            at: new Date(nowMs).toISOString(),
+            seq: track.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 } : {}),
         };
-        try {
-            this.enqueueFn(opts);
-            track.lastSentAtMs = eventAtMs;
-            return true;
-        }
-        catch {
-            return false;
-        }
+        this.enqueueFn(opts);
     }
 }
-/**
- * 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/emit-client.d.ts

@@ -23,8 +23,6 @@ export interface EmitEventResult {
     status: EmitEventStatus;
     /** Present when status != accepted (no_company_evidence | not_a_member | …). */
     reason?: string;
-    /** Server rejection code when status is rejected (`code`, else `reason`). */
-    code?: string;
     /** Resolved company (accepted, or unassigned-into-single-company). */
     companyUid?: string;
 }
@@ -74,9 +72,6 @@ export interface MeshEmitEvent {
     status?: "queued" | "in_progress" | "review" | "done";
     reason?: string;
     summary?: string;
-    repo?: string;
-    gitBranch?: string;
-    prUrls?: string[];
     evidence?: EmitEvidence;
 }
 export interface BuildMeshEmitEventInput {
@@ -93,9 +88,6 @@ export interface BuildMeshEmitEventInput {
     status?: "queued" | "in_progress" | "review" | "done";
     reason?: string;
     summary?: string;
-    repo?: string;
-    gitBranch?: string;
-    prUrls?: string[];
     evidence?: EmitEvidence;
 }
 /**