@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-2KKODIQU.js

@@ -0,0 +1,2256 @@
+import {
+  resolveHqRedactionPolicy,
+  scrubAndTruncateHqPreview,
+  summarizeHqToolArgs
+} from "./chunk-ZYU2YOJ6.js";
+import {
+  HQ_TRANSCRIPT_TEXT_CAP,
+  isHqKanbanSnapshotPayload
+} from "./chunk-Z2IJUO45.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-H5E77KUJ.js";
+import {
+  effectiveInputTokens
+} from "./chunk-NFAYHPRH.js";
+import {
+  CHAT_MARKER_SOURCES,
+  sessionEventToMarker
+} from "./chunk-KSJ5UTP7.js";
+import {
+  sessionScopedPath
+} from "./chunk-AD7ZFZCS.js";
+import {
+  atomicReplaceWithWriter,
+  atomicWrite,
+  withFileLock
+} from "./chunk-7ZHZE5EO.js";
+import {
+  resolveWstackPaths
+} from "./chunk-YNCVSFGF.js";
+
+// src/hq/session-bridge.ts
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+
+// src/hq/transcript-mapper.ts
+function blocksToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(
+      (b) => !!b && typeof b === "object" && b.type === "text" && typeof b.text === "string"
+    ).map((b) => b.text).join("\n");
+  }
+  return "";
+}
+function asString(v) {
+  if (typeof v === "string") return v;
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}
+function argsEntry(ts, name, input, id) {
+  return {
+    ts,
+    role: "tool",
+    tool: String(name ?? "tool"),
+    toolInput: input !== void 0 && input !== null ? asString(input) : "{}",
+    text: "",
+    ...typeof id === "string" ? { toolUseId: id } : {}
+  };
+}
+function mapSessionEventToEntries(ev) {
+  const ts = typeof ev["ts"] === "string" ? ev["ts"] : "";
+  const make = (role, text, extra) => ({
+    ts,
+    role,
+    text,
+    ...extra
+  });
+  switch (ev["type"]) {
+    case "user_input": {
+      const t = blocksToText(ev["content"]);
+      return t.trim() ? [make("user", t)] : [];
+    }
+    case "llm_response": {
+      const out = [];
+      const content = ev["content"];
+      if (Array.isArray(content)) {
+        const thinking = content.filter(
+          (b) => !!b && typeof b === "object" && b.type === "thinking" && typeof b.thinking === "string"
+        ).map((b) => b.thinking).join("\n");
+        if (thinking.trim()) out.push(make("thinking", thinking));
+      }
+      const t = blocksToText(content);
+      if (t.trim()) out.push(make("assistant", t));
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (b && typeof b === "object" && b.type === "tool_use") {
+            const block = b;
+            out.push(argsEntry(ts, block.name, block.input, block.id));
+          }
+        }
+      }
+      return out;
+    }
+    case "tool_use":
+      return [argsEntry(ts, ev["name"], ev["input"], ev["id"])];
+    case "tool_call_start":
+      return [argsEntry(ts, ev["name"], ev["input"] ?? ev["args"], ev["id"])];
+    case "tool_result": {
+      const isError = ev["isError"] === true;
+      const content = ev["content"] ?? ev["output"];
+      const outStr = content !== void 0 && content !== null ? asString(content) : "";
+      return [
+        make(isError ? "error" : "tool", outStr, {
+          tool: "\u21B3 result",
+          ...isError ? { isError: true } : {},
+          ...typeof ev["id"] === "string" ? { toolUseId: ev["id"] } : {}
+        })
+      ];
+    }
+    case "tool_call_end": {
+      const isError = ev["isError"] === true;
+      const content = ev["output"] ?? ev["content"];
+      const outStr = content !== void 0 && content !== null ? asString(content) : "";
+      if (!outStr.trim() && !isError && typeof ev["durationMs"] !== "number") return [];
+      return [
+        make(isError ? "error" : "tool", outStr, {
+          tool: typeof ev["name"] === "string" ? String(ev["name"]) : "\u21B3 result",
+          ...typeof ev["durationMs"] === "number" ? { durationMs: ev["durationMs"] } : {},
+          ...isError ? { isError: true } : {},
+          ...typeof ev["id"] === "string" ? { toolUseId: ev["id"] } : {}
+        })
+      ];
+    }
+    case "task_completed":
+      return [make("system", `task done: ${String(ev["title"] ?? "")}`)];
+    case "task_failed":
+      return [make("system", `task failed: ${String(ev["title"] ?? "")}`)];
+    default: {
+      if (!CHAT_MARKER_SOURCES.has(ev["type"])) return [];
+      const marker = sessionEventToMarker(ev);
+      if (!marker) return [];
+      return [
+        make(marker.level === "error" ? "error" : "system", marker.text, {
+          ...marker.level === "error" ? { isError: true } : {},
+          ...marker.agentId !== void 0 ? { agentId: marker.agentId } : {}
+        })
+      ];
+    }
+  }
+}
+function isResultEntry(e) {
+  return (e.role === "tool" || e.role === "error") && e.toolUseId !== void 0 && e.toolInput === void 0;
+}
+function mergeToolResults(flat) {
+  const out = [];
+  const argsById = /* @__PURE__ */ new Map();
+  for (const src of flat) {
+    const e = { ...src };
+    if (isResultEntry(e) && e.toolUseId !== void 0) {
+      const tgt = argsById.get(e.toolUseId);
+      if (tgt) {
+        tgt.text = e.text || "";
+        if (e.durationMs !== void 0) tgt.durationMs = e.durationMs;
+        if (e.isError) {
+          tgt.role = "error";
+          tgt.isError = true;
+        }
+        continue;
+      }
+    }
+    out.push(e);
+    if (e.role === "tool" && e.toolUseId !== void 0 && e.toolInput !== void 0) {
+      argsById.set(e.toolUseId, e);
+    }
+  }
+  return out;
+}
+function buildTranscriptFromEvents(events) {
+  const flat = [];
+  for (const ev of events) {
+    for (const e of mapSessionEventToEntries(ev)) flat.push(e);
+  }
+  return mergeToolResults(flat);
+}
+
+// src/hq/session-bridge.ts
+var VALID_AGENT_STATUS = /* @__PURE__ */ new Set([
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error"
+]);
+var MAX_TRANSCRIPT_BATCH_ENTRIES = 32;
+var MAX_TRANSCRIPT_BATCH_BYTES = 512 * 1024;
+var HQ_STALE_SNAPSHOT_WINDOW_MS = 5 * 6e4;
+var KEEPALIVE_REPUBLISH_MS = Math.floor(HQ_STALE_SNAPSHOT_WINDOW_MS * 0.8);
+function toAgentSummary(a) {
+  const status = VALID_AGENT_STATUS.has(a.status) ? a.status : "idle";
+  return {
+    id: a.id,
+    name: a.name,
+    status,
+    iterations: a.iterations,
+    toolCalls: a.toolCalls,
+    lastActivityAt: a.lastActivityAt,
+    ...a.startedAt !== void 0 ? { startedAt: a.startedAt } : {},
+    ...a.currentTool !== void 0 ? { currentTool: a.currentTool } : {},
+    ...a.costUsd !== void 0 ? { costUsd: a.costUsd } : {},
+    ...a.tokensIn !== void 0 ? { tokensIn: a.tokensIn } : {},
+    ...a.tokensOut !== void 0 ? { tokensOut: a.tokensOut } : {},
+    ...a.ctxPct !== void 0 ? { ctxPct: a.ctxPct } : {},
+    ...a.model !== void 0 ? { model: a.model } : {},
+    ...a.partialText !== void 0 ? { partialText: a.partialText } : {}
+  };
+}
+function deriveSessionStatus(agents) {
+  return agents.some(
+    (a) => a.status === "running" || a.status === "streaming" || a.status === "waiting_user"
+  ) ? "active" : "idle";
+}
+function downgradeStaleAgentStatuses(agents, nowMs) {
+  const cutoff = nowMs - HQ_STALE_SNAPSHOT_WINDOW_MS;
+  return agents.map((agent) => {
+    if (agent.status !== "running" && agent.status !== "streaming") return agent;
+    const lastActivityAt = Date.parse(agent.lastActivityAt);
+    if (!Number.isFinite(lastActivityAt) || lastActivityAt >= cutoff) return agent;
+    return { ...agent, status: "idle" };
+  });
+}
+function startSessionTelemetryBridge(opts) {
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const publisher = opts.publisher;
+  const identity = publisher.identity;
+  const project = publisher.project;
+  const startedAt = opts.startedAt ?? now();
+  const wpaths = resolveWstackPaths({
+    projectRoot: opts.projectRoot,
+    ...opts.globalRoot !== void 0 ? { globalRoot: opts.globalRoot } : {}
+  });
+  const sessionFile = sessionScopedPath(wpaths.projectSessions, opts.sessionId, ".jsonl");
+  let agents = (opts.initialAgents ?? []).map(toAgentSummary);
+  let lastActivityAt = agents.reduce(
+    (latest, agent) => agent.lastActivityAt > latest ? agent.lastActivityAt : latest,
+    startedAt
+  );
+  let lastSnapshotHash = "";
+  let lastPublishedAtMs = Date.now();
+  let disposed = false;
+  function buildSnapshot() {
+    const effectiveAgents = downgradeStaleAgentStatuses(agents, Date.parse(now()));
+    return {
+      sessionId: opts.sessionId,
+      clientKind: identity.kind,
+      machineId: identity.machineId,
+      projectId: project.projectId,
+      projectName: opts.projectName ?? project.projectName,
+      projectRoot: opts.projectRoot,
+      status: deriveSessionStatus(effectiveAgents),
+      startedAt,
+      lastActivityAt,
+      agentCount: effectiveAgents.length,
+      agents: effectiveAgents,
+      ...identity.hostname !== void 0 ? { hostname: identity.hostname } : {},
+      ...identity.pid !== void 0 ? { pid: identity.pid } : {},
+      ...opts.gitBranch !== void 0 ? { gitBranch: opts.gitBranch } : {}
+    };
+  }
+  function publishSnapshot(force = false) {
+    if (disposed) return;
+    const snap = buildSnapshot();
+    const hash = JSON.stringify({ ...snap, lastActivityAt: "" });
+    if (!force && hash === lastSnapshotHash) return;
+    lastSnapshotHash = hash;
+    try {
+      publisher.publishSessionSnapshot(snap);
+      lastPublishedAtMs = Date.now();
+    } catch {
+    }
+  }
+  function publishTranscriptEntries(entries) {
+    let batch = [];
+    let batchFromSeq = seqEmitted;
+    const publishBatch = () => {
+      if (batch.length === 0) return;
+      try {
+        publisher.publishTranscriptAppend({
+          sessionId: opts.sessionId,
+          fromSeq: batchFromSeq,
+          entries: batch
+        });
+      } catch {
+      }
+      seqEmitted += batch.length;
+      batch = [];
+      batchFromSeq = seqEmitted;
+    };
+    for (const entry of entries) {
+      const candidate = [...batch, entry];
+      const candidatePayload = {
+        sessionId: opts.sessionId,
+        fromSeq: batchFromSeq,
+        entries: candidate
+      };
+      const tooManyEntries = candidate.length > MAX_TRANSCRIPT_BATCH_ENTRIES;
+      const tooLarge = batch.length > 0 && Buffer.byteLength(JSON.stringify(candidatePayload), "utf8") > MAX_TRANSCRIPT_BATCH_BYTES;
+      if (tooManyEntries || tooLarge) publishBatch();
+      batch.push(entry);
+    }
+    publishBatch();
+  }
+  const offAgents = opts.events?.on("session.agents_updated", (payload) => {
+    agents = payload.agents.map(toAgentSummary);
+    lastActivityAt = now();
+    publishSnapshot();
+  });
+  publishSnapshot(true);
+  let prevOnAppend;
+  if (opts.writer?.setOnAppend) {
+    prevOnAppend = opts.writer.onAppend;
+    opts.writer.setOnAppend((event) => {
+      if (disposed) return;
+      try {
+        prevOnAppend?.(event);
+      } catch {
+      }
+      try {
+        const entries = mapSessionEventToEntries(event);
+        if (entries.length > 0) {
+          publishTranscriptEntries(entries);
+          lastActivityAt = now();
+        }
+      } catch {
+      }
+    });
+  }
+  let seqEmitted = 0;
+  let watcher = null;
+  let tailTimer = null;
+  const snapshotTimer = setInterval(() => {
+    publishSnapshot(Date.now() - lastPublishedAtMs >= KEEPALIVE_REPUBLISH_MS);
+  }, opts.snapshotIntervalMs ?? 2500);
+  snapshotTimer.unref?.();
+  if (!opts.writer?.setOnAppend) {
+    let setupWatcher2 = function() {
+      if (disposed || watcher) return;
+      try {
+        const nextWatcher = fs.watch(sessionFile, () => {
+          if (watchPending || disposed) return;
+          watchPending = true;
+          setTimeout(() => {
+            watchPending = false;
+            void tail();
+          }, 25);
+        });
+        nextWatcher.on("error", () => {
+          try {
+            nextWatcher.close();
+          } catch {
+          }
+          if (watcher === nextWatcher) watcher = null;
+        });
+        watcher = nextWatcher;
+      } catch {
+        watcher = null;
+      }
+    }, scheduleTail2 = function() {
+      if (disposed) return;
+      tailTimer = setTimeout(
+        () => {
+          void tail().finally(scheduleTail2);
+        },
+        watcher ? relaxedTailMs : fastTailMs
+      );
+      tailTimer.unref?.();
+    };
+    var setupWatcher = setupWatcher2, scheduleTail = scheduleTail2;
+    let offset = 0;
+    let partial = "";
+    let tailing = false;
+    let watchPending = false;
+    async function tail() {
+      if (disposed || tailing) return;
+      tailing = true;
+      try {
+        const stat3 = await fsp.stat(sessionFile).catch(() => null);
+        if (disposed) return;
+        if (!stat3) return;
+        setupWatcher2();
+        if (stat3.size <= offset) return;
+        const fd = await fsp.open(sessionFile, "r");
+        try {
+          if (disposed) return;
+          const len = stat3.size - offset;
+          const buf = Buffer.allocUnsafe(len);
+          const { bytesRead } = await fd.read(buf, 0, len, offset);
+          const actualBuf = bytesRead < len ? buf.subarray(0, bytesRead) : buf;
+          offset += bytesRead;
+          partial += actualBuf.toString("utf8");
+          const lines = partial.split("\n");
+          partial = lines.pop() ?? "";
+          const entries = [];
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            let obj;
+            try {
+              obj = JSON.parse(trimmed);
+            } catch {
+              continue;
+            }
+            for (const entry of mapSessionEventToEntries(obj)) entries.push(entry);
+          }
+          if (entries.length > 0) {
+            publishTranscriptEntries(entries);
+            lastActivityAt = now();
+          }
+        } finally {
+          await fd.close();
+        }
+      } catch {
+      } finally {
+        tailing = false;
+      }
+    }
+    const fastTailMs = opts.transcriptIntervalMs ?? 500;
+    const relaxedTailMs = opts.transcriptFallbackIntervalMs ?? (opts.transcriptIntervalMs !== void 0 ? opts.transcriptIntervalMs : 5e3);
+    void tail().finally(scheduleTail2);
+  }
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    if (opts.writer?.setOnAppend) {
+      try {
+        opts.writer.setOnAppend(prevOnAppend);
+      } catch {
+      }
+    }
+    offAgents?.();
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    clearInterval(snapshotTimer);
+    if (tailTimer) {
+      clearTimeout(tailTimer);
+      tailTimer = null;
+    }
+    try {
+      publisher.publishSessionEnded({ sessionId: opts.sessionId, endedAt: now() });
+    } catch {
+    }
+  };
+}
+
+// src/hq/bridge-context.ts
+function createBridgeContext(options) {
+  const publisher = options.publisher;
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const bridgeSessionId = options.sessionId;
+  const offs = [];
+  function sessionIdTag(eventSessionId) {
+    const tag = eventSessionId ?? bridgeSessionId;
+    return tag !== void 0 && tag.length > 0 ? { sessionId: tag } : {};
+  }
+  function safePublish(publishOptions) {
+    try {
+      publisher.publishEvent(publishOptions);
+    } catch {
+    }
+  }
+  function track(off) {
+    offs.push(off);
+  }
+  function dispose() {
+    for (const off of offs) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    offs.length = 0;
+  }
+  return { now, sessionIdTag, safePublish, track, dispose };
+}
+
+// src/hq/fleet-bridge.ts
+function startFleetTelemetryBridge(opts) {
+  const { events, publisher, runId } = opts;
+  const ctx = createBridgeContext(opts);
+  let lastHash = "";
+  function buildPayload(stats) {
+    const subagents = stats.subagentStatuses.map((s) => ({
+      subagentId: s.subagentId,
+      ...s.taskId ? { task: s.taskId } : {},
+      status: normalizeSubagentStatus(s.status),
+      ...s.model !== void 0 ? { model: s.model } : {},
+      ...s.costUsd !== void 0 ? { costUsd: s.costUsd } : {},
+      ...s.runtimeMs !== void 0 ? { runtimeMs: s.runtimeMs } : {},
+      ...s.lastActivityAt !== void 0 ? { lastActivityAt: s.lastActivityAt } : {}
+    }));
+    return {
+      runId,
+      activeSubagents: stats.running + stats.idle,
+      queuedTasks: stats.pending,
+      completedTasks: stats.completed,
+      failedTasks: stats.stopped,
+      ...stats.totalCostUsd !== void 0 ? { totalCostUsd: stats.totalCostUsd } : {},
+      subagents,
+      ...stats.maxConcurrent !== void 0 ? { maxConcurrent: stats.maxConcurrent } : {},
+      ...stats.maxSpawns !== void 0 ? { maxSpawns: stats.maxSpawns } : {},
+      ...stats.usedSpawns !== void 0 ? { usedSpawns: stats.usedSpawns } : {},
+      ...stats.remainingSpawns !== void 0 ? { remainingSpawns: stats.remainingSpawns } : {},
+      ...stats.effectiveSource !== void 0 ? { effectiveSource: stats.effectiveSource } : {},
+      ...stats.checkpointMaxSpawns !== void 0 ? { checkpointMaxSpawns: stats.checkpointMaxSpawns } : {},
+      ...stats.ceilingMismatch ? { ceilingMismatch: true } : {}
+    };
+  }
+  const off = events.on("coordinator.stats", (stats) => {
+    const payload = buildPayload(stats);
+    const hash = JSON.stringify(payload);
+    if (hash === lastHash) return;
+    lastHash = hash;
+    try {
+      publisher.publishFleetSnapshot(payload, {
+        ...ctx.sessionIdTag(),
+        timestamp: ctx.now()
+      });
+    } catch {
+    }
+  });
+  ctx.track(off);
+  return ctx.dispose;
+}
+var FLEET_STATUS_MAP = {
+  running: "running",
+  idle: "idle",
+  pending: "pending",
+  completed: "completed",
+  failed: "failed",
+  stopped: "stopped",
+  timeout: "stopped",
+  budget_exhausted: "stopped"
+};
+function normalizeSubagentStatus(raw) {
+  return FLEET_STATUS_MAP[raw] ?? "idle";
+}
+
+// src/hq/brain-bridge.ts
+function extractRequestFields(req) {
+  if (req === void 0) return {};
+  const out = {};
+  if (typeof req.id === "string") out.requestId = req.id;
+  if (typeof req.question === "string") out.question = req.question;
+  if (typeof req.source === "string") out.source = req.source;
+  if (typeof req.risk === "string") out.risk = req.risk;
+  return out;
+}
+function extractDecisionFields(dec) {
+  if (dec === void 0) return {};
+  const out = {};
+  out.decision = dec.type;
+  if (dec.type === "answer") {
+    out.detail = dec.text;
+  } else if (dec.type === "ask_human") {
+    out.detail = dec.prompt;
+  } else if (dec.type === "deny") {
+    out.detail = dec.reason;
+  }
+  return out;
+}
+function startBrainTelemetryBridge(opts) {
+  const { events } = opts;
+  const ctx = createBridgeContext(opts);
+  function publish(kind, payload, at) {
+    ctx.safePublish({
+      type: "brain.event",
+      payload: { kind, at, ...payload },
+      ...ctx.sessionIdTag(),
+      timestamp: ctx.now()
+    });
+  }
+  ctx.track(
+    events.on("brain.decision_requested", (p) => {
+      publish("decision_requested", extractRequestFields(p.request), p.at);
+    })
+  );
+  ctx.track(
+    events.on("brain.decision_answered", (p) => {
+      publish("decision_answered", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  ctx.track(
+    events.on("brain.decision_ask_human", (p) => {
+      publish("decision_ask_human", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  ctx.track(
+    events.on("brain.decision_denied", (p) => {
+      publish("decision_denied", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  ctx.track(
+    events.on("brain.human_answered", (p) => {
+      const detail = typeof p.text === "string" ? p.text : p.optionId;
+      publish("human_answered", {
+        requestId: p.id,
+        ...detail !== void 0 ? { detail } : {},
+        ...p.deny === true ? { decision: "deny" } : {}
+      }, p.at);
+    })
+  );
+  ctx.track(
+    events.on("brain.intervention", (p) => {
+      publish("intervention", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision),
+        interventionKind: p.kind,
+        intervened: p.intervened
+      }, p.at);
+    })
+  );
+  return ctx.dispose;
+}
+
+// src/hq/worktree-bridge.ts
+function startWorktreeTelemetryBridge(opts) {
+  const { events } = opts;
+  const ctx = createBridgeContext(opts);
+  function publish(payload, eventSessionId) {
+    ctx.safePublish({
+      type: "worktree.event",
+      payload,
+      ...ctx.sessionIdTag(eventSessionId),
+      timestamp: ctx.now()
+    });
+  }
+  ctx.track(
+    events.on("worktree.allocated", (p) => {
+      publish(
+        {
+          kind: "allocated",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          ownerLabel: p.ownerLabel,
+          slug: p.slug,
+          branch: p.branch,
+          baseBranch: p.baseBranch
+        },
+        p.sessionId
+      );
+    })
+  );
+  ctx.track(
+    events.on("worktree.committed", (p) => {
+      publish(
+        {
+          kind: "committed",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          insertions: p.insertions,
+          deletions: p.deletions,
+          files: p.files,
+          ...p.sha !== void 0 ? { sha: p.sha } : {}
+        },
+        p.sessionId
+      );
+    })
+  );
+  ctx.track(
+    events.on("worktree.merged", (p) => {
+      publish(
+        {
+          kind: "merged",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          baseBranch: p.baseBranch,
+          squash: p.squash
+        },
+        p.sessionId
+      );
+    })
+  );
+  ctx.track(
+    events.on("worktree.conflict", (p) => {
+      publish(
+        {
+          kind: "conflict",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          conflictFiles: p.conflictFiles
+        },
+        p.sessionId
+      );
+    })
+  );
+  ctx.track(
+    events.on("worktree.released", (p) => {
+      publish(
+        {
+          kind: "released",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          kept: p.kept
+        },
+        p.sessionId
+      );
+    })
+  );
+  ctx.track(
+    events.on("worktree.failed", (p) => {
+      publish(
+        {
+          kind: "failed",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          ...p.branch !== void 0 ? { branch: p.branch } : {},
+          error: p.error
+        },
+        p.sessionId
+      );
+    })
+  );
+  return ctx.dispose;
+}
+
+// src/hq/tool-bridge.ts
+function startToolTelemetryBridge(opts) {
+  const { events, publisher } = opts;
+  const ctx = createBridgeContext(opts);
+  const inFlight = /* @__PURE__ */ new Map();
+  const offStarted = events.on("tool.started", (p) => {
+    inFlight.set(p.id, { name: p.name, startedAt: Date.now() });
+    const payload = {
+      toolName: p.name,
+      ...p.input !== void 0 ? {
+        inputSummary: summarizeHqToolArgs(p.input, {
+          policy: publisher.redactionPolicy,
+          ...opts.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {}
+        })
+      } : {}
+    };
+    ctx.safePublish({
+      type: "tool.started",
+      payload,
+      ...ctx.sessionIdTag(p.sessionId),
+      timestamp: ctx.now()
+    });
+  });
+  const offExecuted = events.on("tool.executed", (p) => {
+    const id = p.id;
+    if (id !== void 0) inFlight.delete(id);
+    const payload = {
+      toolName: p.name,
+      status: p.ok ? "success" : "error",
+      durationMs: p.durationMs,
+      ...p.output !== void 0 && p.output.length > 0 ? { outputSummary: truncateForSummary(p.output, publisher.redactionPolicy) } : {}
+    };
+    ctx.safePublish({
+      type: "tool.completed",
+      payload,
+      ...ctx.sessionIdTag(p.sessionId),
+      timestamp: ctx.now()
+    });
+  });
+  ctx.track(offStarted);
+  ctx.track(offExecuted);
+  return () => {
+    ctx.dispose();
+    inFlight.clear();
+  };
+}
+function truncateForSummary(output, policy, max = 280) {
+  const resolved = resolveHqRedactionPolicy(policy);
+  const limit = resolved.rawContent ? Math.max(max, HQ_TRANSCRIPT_TEXT_CAP) : max;
+  return scrubAndTruncateHqPreview(output, limit) ?? "";
+}
+
+// src/hq/cost-bridge.ts
+function startCostTelemetryBridge(opts) {
+  const { events } = opts;
+  const ctx = createBridgeContext(opts);
+  const off = events.on("token.accounted", (p) => {
+    const usage = p.deltaUsage ?? p.usage;
+    const totalPromptTokens = effectiveInputTokens(usage);
+    const payload = {
+      inputTokens: totalPromptTokens,
+      outputTokens: usage.output,
+      totalTokens: totalPromptTokens + usage.output,
+      costUsd: p.cost.total
+    };
+    if (p.provider !== void 0) payload.provider = p.provider;
+    if (p.model !== void 0) payload.model = p.model;
+    if (usage.cacheRead !== void 0) payload.cacheRead = usage.cacheRead;
+    if (usage.cacheWrite !== void 0) payload.cacheWrite = usage.cacheWrite;
+    const sessionId = opts.sessionId ?? p.sessionId;
+    ctx.safePublish({
+      type: "session.usage",
+      payload,
+      ...sessionId !== void 0 ? { sessionId } : {},
+      timestamp: ctx.now()
+    });
+  });
+  ctx.track(off);
+  return ctx.dispose;
+}
+
+// src/hq/kanban-store.ts
+import { createHash } from "node:crypto";
+import * as fs2 from "node:fs/promises";
+import * as path from "node:path";
+
+// src/hq/write-queues.ts
+var BestEffortBatchQueue = class _BestEffortBatchQueue {
+  constructor(writeBatch) {
+    this.writeBatch = writeBatch;
+  }
+  writeBatch;
+  pending = [];
+  activeWrite = null;
+  drainScheduled = false;
+  static MAX_PENDING = 1e4;
+  enqueue(item) {
+    if (this.pending.length >= _BestEffortBatchQueue.MAX_PENDING) this.pending.shift();
+    this.pending.push(item);
+    if (this.drainScheduled) return;
+    this.drainScheduled = true;
+    queueMicrotask(() => this.flushPending());
+  }
+  async drain() {
+    for (; ; ) {
+      this.flushPending();
+      const observed = this.activeWrite;
+      if (observed) await observed;
+      if (!this.activeWrite && this.pending.length === 0) return;
+    }
+  }
+  flushPending() {
+    this.drainScheduled = false;
+    if (this.activeWrite || this.pending.length === 0) return;
+    const batch = this.pending.splice(0);
+    const active = this.writeBatch(batch).catch((err) => {
+      console.error(
+        `[BestEffortBatchQueue] failed to write batch of ${batch.length} item(s):`,
+        err
+      );
+    }).finally(() => {
+      if (this.activeWrite === active) this.activeWrite = null;
+      if (this.pending.length > 0) this.flushPending();
+    });
+    this.activeWrite = active;
+  }
+};
+var BestEffortLatestQueue = class {
+  constructor(writeLatest) {
+    this.writeLatest = writeLatest;
+  }
+  writeLatest;
+  pending;
+  activeWrite = null;
+  drainScheduled = false;
+  enqueue(value) {
+    this.pending = value;
+    if (this.drainScheduled) return;
+    this.drainScheduled = true;
+    queueMicrotask(() => this.flushPending());
+  }
+  async drain() {
+    for (; ; ) {
+      this.flushPending();
+      const observed = this.activeWrite;
+      if (observed) await observed;
+      if (!this.activeWrite && this.pending === void 0) return;
+    }
+  }
+  flushPending() {
+    this.drainScheduled = false;
+    if (this.activeWrite || this.pending === void 0) return;
+    const latest = this.pending;
+    this.pending = void 0;
+    const active = this.writeLatest(latest).catch((err) => {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "hq.persistence_latest_write_failed",
+          message: err instanceof Error ? err.message : String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }).finally(() => {
+      if (this.activeWrite === active) this.activeWrite = null;
+      if (this.pending !== void 0) this.flushPending();
+    });
+    this.activeWrite = active;
+  }
+};
+
+// src/hq/kanban-store.ts
+var MAX_HQ_KANBAN_CACHE_PROJECTS = 32;
+var HqKanbanStore = class {
+  dirPath;
+  cache = /* @__PURE__ */ new Map();
+  writers = /* @__PURE__ */ new Map();
+  mergeChains = /* @__PURE__ */ new Map();
+  constructor(dataDir) {
+    this.dirPath = path.join(dataDir, "kanban");
+  }
+  async load(projectId) {
+    const cached = this.cache.get(projectId);
+    if (cached !== void 0) {
+      this.cache.delete(projectId);
+      this.cache.set(projectId, cached);
+      return structuredClone(cached);
+    }
+    try {
+      const content = await fs2.readFile(this.filePath(projectId), "utf8");
+      const snapshot = JSON.parse(content);
+      if (!isHqKanbanSnapshotPayload(snapshot) || snapshot.projectId !== projectId) {
+        return emptyKanbanSnapshot(projectId);
+      }
+      this.setCached(projectId, snapshot);
+      return structuredClone(snapshot);
+    } catch {
+      return emptyKanbanSnapshot(projectId);
+    }
+  }
+  /** Merge by revision, then timestamp. HQ never lets a stale writer win. */
+  merge(incoming) {
+    const previous = this.mergeChains.get(incoming.projectId) ?? Promise.resolve(emptyKanbanSnapshot(incoming.projectId));
+    const next = previous.catch(() => emptyKanbanSnapshot(incoming.projectId)).then(() => this.mergeNow(incoming));
+    this.mergeChains.set(incoming.projectId, next);
+    void next.then(
+      () => {
+        if (this.mergeChains.get(incoming.projectId) === next) {
+          this.mergeChains.delete(incoming.projectId);
+          this.trimCache();
+        }
+      },
+      () => {
+        if (this.mergeChains.get(incoming.projectId) === next) {
+          this.mergeChains.delete(incoming.projectId);
+          this.trimCache();
+        }
+      }
+    );
+    return next;
+  }
+  async mergeNow(incoming) {
+    const current = await this.load(incoming.projectId);
+    const records = /* @__PURE__ */ new Map();
+    for (const record of [...current.boards, ...current.tombstones])
+      records.set(record.boardId, record);
+    for (const record of [...incoming.boards, ...incoming.tombstones]) {
+      const existing = records.get(record.boardId);
+      if (existing === void 0 || compareKanbanRecord(record, existing) > 0) {
+        records.set(record.boardId, record);
+      }
+    }
+    const merged = {
+      projectId: incoming.projectId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      boards: [],
+      tombstones: []
+    };
+    for (const record of records.values()) {
+      if ("board" in record) merged.boards.push(record);
+      else merged.tombstones.push(record);
+    }
+    merged.boards.sort((a, b) => a.boardId.localeCompare(b.boardId));
+    merged.tombstones.sort((a, b) => a.boardId.localeCompare(b.boardId));
+    this.setCached(incoming.projectId, merged);
+    const writer = this.writer(incoming.projectId);
+    writer.enqueue(merged);
+    void writer.drain().then(() => {
+      if (this.writers.get(incoming.projectId) === writer) {
+        this.writers.delete(incoming.projectId);
+        this.trimCache();
+      }
+    });
+    return structuredClone(merged);
+  }
+  async drain() {
+    await Promise.allSettled(this.mergeChains.values());
+    await Promise.all([...this.writers.values()].map((writer) => writer.drain()));
+  }
+  writer(projectId) {
+    let writer = this.writers.get(projectId);
+    if (writer === void 0) {
+      writer = new BestEffortLatestQueue(async (snapshot) => {
+        await fs2.mkdir(this.dirPath, { recursive: true });
+        await atomicWrite(this.filePath(projectId), JSON.stringify(snapshot), { mode: 384 });
+      });
+      this.writers.set(projectId, writer);
+    }
+    return writer;
+  }
+  setCached(projectId, snapshot) {
+    this.cache.delete(projectId);
+    this.cache.set(projectId, snapshot);
+    this.trimCache(projectId);
+  }
+  trimCache(protectedProjectId) {
+    if (this.cache.size <= MAX_HQ_KANBAN_CACHE_PROJECTS) return;
+    for (const projectId of this.cache.keys()) {
+      if (this.cache.size <= MAX_HQ_KANBAN_CACHE_PROJECTS) break;
+      if (projectId === protectedProjectId || this.writers.has(projectId) || this.mergeChains.has(projectId)) {
+        continue;
+      }
+      this.cache.delete(projectId);
+    }
+  }
+  filePath(projectId) {
+    const safe = createHash("sha256").update(projectId).digest("hex");
+    return path.join(this.dirPath, `${safe}.json`);
+  }
+};
+function emptyKanbanSnapshot(projectId) {
+  return { projectId, generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), boards: [], tombstones: [] };
+}
+function compareKanbanRecord(a, b) {
+  if (a.revision !== b.revision) return a.revision - b.revision;
+  const aTime = "board" in a ? a.updatedAt : a.deletedAt;
+  const bTime = "board" in b ? b.updatedAt : b.deletedAt;
+  if (aTime !== bTime) return aTime.localeCompare(bTime);
+  if ("board" in a === "board" in b) return 0;
+  return "board" in a ? -1 : 1;
+}
+
+// src/hq/persistence/event-log.ts
+import * as fs4 from "node:fs/promises";
+import * as path2 from "node:path";
+
+// src/hq/persistence/jsonl-io.ts
+import * as fs3 from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+var RECENT_READ_CHUNK_BYTES = 64 * 1024;
+var LINE_COUNT_CHUNK_BYTES = 256 * 1024;
+async function readTailNonEmptyLines(filePath, limit, estimatedLineCount) {
+  if (!(limit > 0)) return [];
+  const handle = await fs3.open(filePath, "r");
+  try {
+    const size = (await handle.stat()).size;
+    let position = size;
+    const chunks = [];
+    let totalNewlines = 0;
+    let nextReadBytes = Math.min(
+      size,
+      Math.max(
+        RECENT_READ_CHUNK_BYTES,
+        estimatedLineCount > 0 ? Math.ceil(size * limit * 1.1 / estimatedLineCount) + RECENT_READ_CHUNK_BYTES : Math.ceil(limit * 512) + RECENT_READ_CHUNK_BYTES
+      )
+    );
+    while (position > 0) {
+      const length = Math.min(nextReadBytes, position);
+      position -= length;
+      const buffer = Buffer.allocUnsafe(length);
+      let bytesRead = 0;
+      while (bytesRead < length) {
+        const result = await handle.read(
+          buffer,
+          bytesRead,
+          length - bytesRead,
+          position + bytesRead
+        );
+        if (result.bytesRead === 0) break;
+        bytesRead += result.bytesRead;
+      }
+      if (bytesRead === 0) break;
+      const chunk = bytesRead === length ? buffer : buffer.subarray(0, bytesRead);
+      chunks.unshift(chunk);
+      for (let index = 0; index < chunk.length; index++) {
+        if (chunk[index] === 10) totalNewlines++;
+      }
+      if (position === 0 || totalNewlines >= limit) {
+        const lines = Buffer.concat(chunks).toString("utf8").split("\n").filter((line) => line.length > 0);
+        return lines.slice(-limit).reverse();
+      }
+      nextReadBytes = Math.min(position, nextReadBytes * 2);
+    }
+    return [];
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function findTailStartOffset(filePath, keepLines, maxBytes) {
+  const handle = await fs3.open(filePath, "r");
+  try {
+    const size = (await handle.stat()).size;
+    if (size === 0) return { offset: 0, size };
+    const tailByte = Buffer.allocUnsafe(1);
+    await handle.read(tailByte, 0, 1, size - 1);
+    const target = keepLines + (tailByte[0] === 10 ? 1 : 0);
+    if (target <= 0) return { offset: size, size };
+    const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
+    let position = size;
+    let seen = 0;
+    let boundary = size;
+    while (position > 0) {
+      const length = Math.min(LINE_COUNT_CHUNK_BYTES, position);
+      position -= length;
+      let read = 0;
+      while (read < length) {
+        const result = await handle.read(buffer, read, length - read, position + read);
+        if (result.bytesRead === 0) break;
+        read += result.bytesRead;
+      }
+      if (read === 0) break;
+      for (let index = read - 1; index >= 0; index--) {
+        if (buffer[index] !== 10) continue;
+        const candidate = position + index + 1;
+        if (size - candidate > maxBytes) {
+          return { offset: boundary < size ? boundary : candidate, size };
+        }
+        boundary = candidate;
+        seen++;
+        if (seen >= target) return { offset: boundary, size };
+      }
+    }
+    return { offset: 0, size };
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function copyTailToHandle(sourcePath, offset, destination) {
+  const handle = await fs3.open(sourcePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
+    let position = offset;
+    let bytes = 0;
+    let lines = 0;
+    let lineHasBytes = false;
+    for (; ; ) {
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      const chunk = buffer.subarray(0, bytesRead);
+      for (let index = 0; index < bytesRead; index++) {
+        if (chunk[index] === 10) {
+          if (lineHasBytes) lines++;
+          lineHasBytes = false;
+        } else {
+          lineHasBytes = true;
+        }
+      }
+      await destination.write(chunk);
+      bytes += bytesRead;
+    }
+    return { bytes, lines: lines + (lineHasBytes ? 1 : 0) };
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function* readJsonlLines(filePath) {
+  const handle = await fs3.open(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
+    const decoder = new StringDecoder("utf8");
+    let position = 0;
+    let carry = "";
+    for (; ; ) {
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      const text = carry + decoder.write(buffer.subarray(0, bytesRead));
+      let start = 0;
+      for (; ; ) {
+        const newline = text.indexOf("\n", start);
+        if (newline === -1) break;
+        const line = text.slice(start, newline).trim();
+        start = newline + 1;
+        if (line) yield line;
+      }
+      carry = text.slice(start);
+    }
+    const last = (carry + decoder.end()).trim();
+    if (last) yield last;
+  } finally {
+    await handle.close();
+  }
+}
+async function countNonEmptyLines(filePath) {
+  let handle;
+  try {
+    handle = await fs3.open(filePath, "r");
+  } catch {
+    return 0;
+  }
+  try {
+    const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
+    let count = 0;
+    let position = 0;
+    let lineHasBytes = false;
+    for (; ; ) {
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      let start = 0;
+      for (; ; ) {
+        const newline = buffer.indexOf(10, start);
+        if (newline < 0 || newline >= bytesRead) {
+          if (start < bytesRead) lineHasBytes = true;
+          break;
+        }
+        if (lineHasBytes || newline > start) count++;
+        lineHasBytes = false;
+        start = newline + 1;
+      }
+    }
+    return count + (lineHasBytes ? 1 : 0);
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+
+// src/hq/persistence/event-log.ts
+var DEFAULT_EVENT_LOG_MAX_LINES = 5e4;
+var DEFAULT_EVENT_LOG_ROTATE_KEEP = 2e4;
+var DEFAULT_EVENT_LOG_MAX_BYTES = 32 * 1024 * 1024;
+var DEFAULT_EVENT_LOG_ROTATE_KEEP_BYTES = 16 * 1024 * 1024;
+var RECENT_TAIL_SCAN_BYTES = 1024 * 1024;
+var FILTERED_RECENT_TAIL_SCAN_BYTES = 256 * 1024;
+var BULK_PREFIX_READ_CAP = 8 * 1024 * 1024;
+var HQ_EVENT_LOG_PRESETS = Object.freeze({
+  vps8: { maxBytes: 8 * 1024 * 1024, rotateKeepBytes: 2 * 1024 * 1024 },
+  vps32: { maxBytes: 32 * 1024 * 1024, rotateKeepBytes: 16 * 1024 * 1024 },
+  desktop: { maxBytes: 64 * 1024 * 1024, rotateKeepBytes: 24 * 1024 * 1024 }
+});
+function hqEventLogPresetFields(preset) {
+  const fields = HQ_EVENT_LOG_PRESETS[preset];
+  if (fields === void 0) {
+    throw new Error(
+      `Unknown HqEventLogPreset: ${String(preset)}. Allowed: ${Object.keys(HQ_EVENT_LOG_PRESETS).join(", ")}.`
+    );
+  }
+  return fields;
+}
+var HqEventLog = class {
+  filePath;
+  maxLines;
+  rotateKeep;
+  writer;
+  maxBytes;
+  rotateKeepBytes;
+  lineCount = 0;
+  byteCount = 0;
+  counted = false;
+  hydration;
+  constructor(opts) {
+    this.filePath = path2.join(opts.dataDir, "events.jsonl");
+    this.maxLines = opts.maxLines ?? DEFAULT_EVENT_LOG_MAX_LINES;
+    this.rotateKeep = opts.rotateKeep ?? DEFAULT_EVENT_LOG_ROTATE_KEEP;
+    this.maxBytes = opts.maxBytes ?? DEFAULT_EVENT_LOG_MAX_BYTES;
+    this.rotateKeepBytes = opts.rotateKeepBytes ?? DEFAULT_EVENT_LOG_ROTATE_KEEP_BYTES;
+    this.writer = new BestEffortBatchQueue((events) => this.appendInternal(events));
+  }
+  /** Append an event envelope as one JSON line. Best-effort, never rejects. */
+  append(event) {
+    this.writer.enqueue(event);
+  }
+  /** Resolves once all queued appends have settled. For tests. */
+  async drain() {
+    await this.writer.drain();
+  }
+  async appendInternal(events) {
+    await this.ensureLineCount();
+    const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
+    await fs4.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+    this.lineCount += events.length;
+    this.byteCount += Buffer.byteLength(lines, "utf8");
+    if (this.lineCount >= this.maxLines || this.byteCount >= this.maxBytes) {
+      await this.rotate();
+    }
+  }
+  /**
+   * Compact the log down to its most recent lines.
+   *
+   * Streams the retained tail straight from the old file into the replacement
+   * rather than materializing it. The previous implementation read the tail
+   * into a `string[]`, `join`ed it, and handed the result to `atomicWrite` —
+   * at the observed 14.5 KB average line that is ~277 MB of UTF-8 inflated to
+   * ~555 MB of JS strings, plus another ~555 MB for the join, all allocated
+   * inside the file lock. Rotation is now O(one chunk) no matter how much is
+   * retained, so the operation that exists to *reclaim* space stops being the
+   * largest allocation the process ever makes.
+   */
+  async rotate() {
+    await withFileLock(this.filePath, async () => {
+      try {
+        const retainCount = Math.max(0, Math.floor(this.rotateKeep));
+        const { offset, size } = await findTailStartOffset(
+          this.filePath,
+          retainCount,
+          this.rotateKeepBytes
+        );
+        if (offset === 0) {
+          this.byteCount = size;
+          this.lineCount = await this.countLines();
+          return;
+        }
+        const copied = await atomicReplaceWithWriter(
+          this.filePath,
+          (handle) => copyTailToHandle(this.filePath, offset, handle)
+        );
+        this.lineCount = copied.lines;
+        this.byteCount = copied.bytes;
+      } catch {
+      }
+    });
+  }
+  async countLines() {
+    let handle;
+    try {
+      handle = await fs4.open(this.filePath, "r");
+    } catch {
+      return 0;
+    }
+    try {
+      const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
+      let count = 0;
+      let position = 0;
+      let lineHasBytes = false;
+      for (; ; ) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+        if (bytesRead === 0) break;
+        position += bytesRead;
+        let start = 0;
+        for (; ; ) {
+          const newline = buffer.indexOf(10, start);
+          if (newline < 0 || newline >= bytesRead) {
+            for (let index = start; index < bytesRead; index++) {
+              if (buffer[index] !== 10) {
+                lineHasBytes = true;
+                break;
+              }
+            }
+            break;
+          }
+          if (lineHasBytes || newline > start) count++;
+          lineHasBytes = false;
+          start = newline + 1;
+        }
+      }
+      return count + (lineHasBytes ? 1 : 0);
+    } catch {
+      return 0;
+    } finally {
+      await handle.close().catch(() => {
+      });
+    }
+  }
+  async ensureLineCount() {
+    if (this.counted) return;
+    this.hydration ??= Promise.all([
+      this.countLines(),
+      fs4.stat(this.filePath).then(
+        (stat3) => stat3.size,
+        () => 0
+      )
+    ]).then(([count, size]) => {
+      this.lineCount = count;
+      this.byteCount = size;
+      this.counted = true;
+    });
+    try {
+      await this.hydration;
+    } catch {
+      this.hydration = void 0;
+      throw new Error("ensureLineCount hydration rejected; cache cleared");
+    }
+  }
+  /**
+   * Read the most recent `limit` events, optionally filtered by envelope
+   * `type`. Newest first. Returns `[]` if the file doesn't exist yet.
+   *
+   * Reads are best-effort against a concurrent appender: the file size is
+   * sampled once at entry and may return one duplicate or miss one tail
+   * line if another process appends during the scan. When a `typeFilter`
+   * is set and matches are sparse, the scan walks the whole file in
+   * bounded windows but is still guaranteed to reach every line.
+   */
+  async recent(limit, typeFilter) {
+    return readRecentEvents(this.filePath, limit, typeFilter);
+  }
+  /** Initialize the line count cache from disk (call once at boot). */
+  async hydrate() {
+    await this.ensureLineCount();
+  }
+};
+async function readRecentEvents(filePath, limit, typeFilter) {
+  if (!(limit > 0)) return [];
+  let handle;
+  try {
+    handle = await fs4.open(filePath, "r");
+  } catch {
+    return [];
+  }
+  const out = [];
+  const acceptText = (raw) => {
+    const line = raw.trim();
+    if (!line) return false;
+    try {
+      const event = JSON.parse(line);
+      if (typeFilter === void 0 || event.type === typeFilter) out.push(event);
+    } catch {
+    }
+    return out.length >= limit;
+  };
+  const acceptLine = (parts) => acceptText(Buffer.concat(parts).toString("utf8"));
+  try {
+    let position = (await handle.stat()).size;
+    let carry = [];
+    let tailBytesRead = 0;
+    const tailScanLimit = typeFilter === void 0 ? RECENT_TAIL_SCAN_BYTES : FILTERED_RECENT_TAIL_SCAN_BYTES;
+    while (position > 0) {
+      const length = Math.min(RECENT_READ_CHUNK_BYTES, position);
+      position -= length;
+      const buffer = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, position);
+      if (bytesRead === 0) break;
+      tailBytesRead += bytesRead;
+      const chunk = bytesRead === length ? buffer : buffer.subarray(0, bytesRead);
+      let lineEnd = chunk.length;
+      for (let index = chunk.length - 1; index >= 0; index--) {
+        if (chunk[index] !== 10) continue;
+        if (acceptLine([chunk.subarray(index + 1, lineEnd), ...carry])) return out;
+        carry = [];
+        lineEnd = index;
+      }
+      if (lineEnd > 0) carry.unshift(chunk.subarray(0, lineEnd));
+      if (position > 0 && tailBytesRead >= tailScanLimit) {
+        let sliceEnd = position;
+        let priorSeam = "";
+        while (sliceEnd > 0) {
+          const readLen = Math.min(sliceEnd, BULK_PREFIX_READ_CAP);
+          const readOffset = sliceEnd - readLen;
+          const prefix = Buffer.allocUnsafe(readLen);
+          let offset = 0;
+          while (offset < readLen) {
+            const result = await handle.read(prefix, offset, readLen - offset, readOffset + offset);
+            if (result.bytesRead === 0) break;
+            offset += result.bytesRead;
+          }
+          const prefixRead = offset === prefix.length ? prefix : prefix.subarray(0, offset);
+          const text = Buffer.concat([prefixRead, ...carry]).toString("utf8");
+          carry = [];
+          const lines = text.split("\n");
+          for (let index = lines.length - 1; index >= 1; index--) {
+            const line = lines[index];
+            if (line === void 0) continue;
+            if (acceptText(line)) return out;
+          }
+          const boundary = lines[0] ?? "";
+          if (boundary !== priorSeam && acceptText(boundary)) return out;
+          if (readOffset === 0) break;
+          carry = [Buffer.from(boundary, "utf8")];
+          priorSeam = boundary;
+          sliceEnd = readOffset;
+        }
+        return out;
+      }
+    }
+    if (carry.length > 0) acceptLine(carry);
+    return out;
+  } catch {
+    return [];
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+
+// src/hq/persistence/simple-log.ts
+import * as fs5 from "node:fs/promises";
+import * as path3 from "node:path";
+var HqSimpleLog = class {
+  filePath;
+  maxLines;
+  rotateKeep;
+  readLimit;
+  writer;
+  lineCount = 0;
+  counted = false;
+  hydration;
+  constructor(opts) {
+    this.filePath = path3.join(opts.dataDir, opts.filename);
+    this.maxLines = opts.maxLines ?? Infinity;
+    this.rotateKeep = opts.rotateKeep ?? this.maxLines;
+    this.readLimit = opts.readLimit ?? Infinity;
+    this.writer = new BestEffortBatchQueue((records) => this.appendInternal(records));
+  }
+  /** Append one record as a JSON line. Best-effort, never rejects. */
+  append(record) {
+    this.writer.enqueue(record);
+  }
+  /** Resolves once all queued appends have settled. For tests. */
+  async drain() {
+    await this.writer.drain();
+  }
+  async appendInternal(records) {
+    if (Number.isFinite(this.maxLines)) await this.ensureLineCount();
+    await fs5.appendFile(
+      this.filePath,
+      records.map((record) => JSON.stringify(record)).join("\n") + "\n",
+      { encoding: "utf8" }
+    );
+    this.lineCount += records.length;
+    if (this.lineCount < this.maxLines) return;
+    await withFileLock(this.filePath, async () => {
+      const retainCount = Math.max(0, Math.floor(this.rotateKeep));
+      const newest = await readTailNonEmptyLines(this.filePath, retainCount + 1, this.lineCount);
+      if (newest.length <= retainCount) {
+        this.lineCount = newest.length;
+        return;
+      }
+      const kept = newest.slice(0, retainCount).reverse();
+      await atomicWrite(this.filePath, kept.join("\n") + "\n", { mode: 384 });
+      this.lineCount = kept.length;
+    });
+  }
+  async ensureLineCount() {
+    if (this.counted) return;
+    this.hydration ??= countNonEmptyLines(this.filePath).catch(() => 0).then((count) => {
+      this.lineCount = count;
+      this.counted = true;
+    });
+    await this.hydration;
+  }
+  /** Read all records oldest-first. Returns `[]` if the file doesn't exist. */
+  async readAll() {
+    let lines;
+    try {
+      lines = (await readTailNonEmptyLines(
+        this.filePath,
+        this.readLimit,
+        this.counted ? this.lineCount : 0
+      )).reverse();
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        out.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return out;
+  }
+};
+
+// src/hq/persistence/snapshot-store.ts
+import * as fs6 from "node:fs/promises";
+import * as path4 from "node:path";
+var HqSnapshotStore = class {
+  filePath;
+  writer;
+  constructor(opts) {
+    this.filePath = path4.join(opts.dataDir, "snapshot.json");
+    this.writer = new BestEffortLatestQueue(
+      (snapshot) => atomicWrite(this.filePath, JSON.stringify(snapshot), { mode: 384 })
+    );
+  }
+  /** Persist a snapshot. Best-effort, never rejects. */
+  save(snapshot) {
+    this.writer.enqueue(snapshot);
+  }
+  /** Resolves once all queued saves have settled. For tests. */
+  async drain() {
+    await this.writer.drain();
+  }
+  /** Read the last persisted snapshot, or `null` if none. */
+  async load() {
+    try {
+      const content = await fs6.readFile(this.filePath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/hq/persistence/timeseries-store.ts
+import * as fs7 from "node:fs/promises";
+import * as path5 from "node:path";
+var HqTimeseriesStore = class {
+  filePath;
+  bucketMs;
+  maxBuckets;
+  buckets = /* @__PURE__ */ new Map();
+  dirtyVersions = /* @__PURE__ */ new Map();
+  writer;
+  nextDirtyVersion = 0;
+  diskLineCount;
+  loaded = false;
+  loadPromise;
+  constructor(opts) {
+    this.filePath = path5.join(opts.dataDir, "timeseries.jsonl");
+    this.bucketMs = opts.bucketMs ?? 5 * 60 * 1e3;
+    this.maxBuckets = opts.maxBuckets ?? 2016;
+    this.writer = new BestEffortLatestQueue((snapshot) => this.flushInternal(snapshot));
+  }
+  bucketStart(ts) {
+    return Math.floor(ts / this.bucketMs) * this.bucketMs;
+  }
+  /** Fold a cost/tool signal into the current bucket. Best-effort. */
+  record(signal) {
+    const start = this.bucketStart(signal.ts ?? Date.now());
+    let bucket = this.buckets.get(start);
+    if (!bucket) {
+      bucket = { ts: start, costUsd: 0, inputTokens: 0, outputTokens: 0, toolCalls: 0 };
+      this.buckets.set(start, bucket);
+    }
+    if (signal.costUsd !== void 0) bucket.costUsd += signal.costUsd;
+    if (signal.inputTokens !== void 0) bucket.inputTokens += signal.inputTokens;
+    if (signal.outputTokens !== void 0) bucket.outputTokens += signal.outputTokens;
+    if (signal.toolCalls !== void 0) bucket.toolCalls += signal.toolCalls;
+    if (signal.activeAgents !== void 0) bucket.activeAgents = signal.activeAgents;
+    if (signal.model !== void 0 || signal.provider !== void 0) {
+      const entry = {
+        costUsd: signal.costUsd ?? 0,
+        inputTokens: signal.inputTokens ?? 0,
+        outputTokens: signal.outputTokens ?? 0,
+        ...signal.cacheRead !== void 0 ? { cacheRead: signal.cacheRead } : {},
+        ...signal.cacheWrite !== void 0 ? { cacheWrite: signal.cacheWrite } : {}
+      };
+      if (signal.model !== void 0) {
+        bucket.byModel = foldBreakdown(bucket.byModel, signal.model, entry);
+      }
+      if (signal.provider !== void 0) {
+        bucket.byProvider = foldBreakdown(bucket.byProvider, signal.provider, entry);
+      }
+    }
+    this.dirtyVersions.set(start, ++this.nextDirtyVersion);
+    this.pruneBuckets({ dropDirty: true });
+  }
+  /**
+   * Drop the oldest buckets beyond `maxBuckets`.
+   *
+   * `dropDirty` also forgets the pending flush version for an evicted bucket —
+   * correct when the eviction happens on the record path (the bucket is gone,
+   * so there is nothing left to write). The load path leaves `dirtyVersions`
+   * alone because it has not produced any.
+   */
+  pruneBuckets(opts = {}) {
+    if (this.buckets.size <= this.maxBuckets) return;
+    const sorted = Array.from(this.buckets.keys()).sort((a, b) => a - b);
+    while (this.buckets.size > this.maxBuckets && sorted.length > 0) {
+      const oldest = sorted.shift();
+      if (oldest === void 0) break;
+      this.buckets.delete(oldest);
+      if (opts.dropDirty) this.dirtyVersions.delete(oldest);
+    }
+  }
+  /**
+   * Persist accumulated buckets to disk (append under lock), prune to maxBuckets.
+   *
+   * Note: this dispatcher coalesces — if `flush()` is called multiple times
+   * before the previous flush settles, only the most-recent snapshot is
+   * written. The dropped snapshots came from the same in-memory `buckets`
+   * map, so their data is folded into the surviving snapshot rather than
+   * lost. Callers that need every intermediate window on disk should use a
+   * BestEffortBatchQueue instead of BestEffortLatestQueue here.
+   */
+  flush() {
+    if (this.dirtyVersions.size === 0) return;
+    const versions = new Map(this.dirtyVersions);
+    for (const [timestamp, version] of versions) {
+      if (this.buckets.has(timestamp)) continue;
+      versions.delete(timestamp);
+      if (this.dirtyVersions.get(timestamp) === version) this.dirtyVersions.delete(timestamp);
+    }
+    const samples = Array.from(versions.keys()).map((timestamp) => this.buckets.get(timestamp)).filter((sample) => sample !== void 0).map(cloneTimeseriesSample).sort((a, b) => a.ts - b.ts);
+    if (samples.length === 0) return;
+    this.writer.enqueue({ samples, versions });
+  }
+  /** Resolves once all queued flushes have settled. For tests. */
+  async drain() {
+    await this.writer.drain();
+  }
+  async flushInternal(snapshot) {
+    const lines = snapshot.samples.map((bucket) => JSON.stringify(bucket)).join("\n") + "\n";
+    await withFileLock(this.filePath, async () => {
+      this.diskLineCount ??= await countNonEmptyLines(this.filePath);
+      await fs7.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      this.diskLineCount += snapshot.samples.length;
+      const compactAt = Math.max(this.maxBuckets + 1, this.maxBuckets * 4);
+      if (this.diskLineCount >= compactAt) {
+        const retained = Array.from(this.buckets.values()).map(cloneTimeseriesSample).sort((a, b) => a.ts - b.ts);
+        await atomicWrite(
+          this.filePath,
+          retained.map((bucket) => JSON.stringify(bucket)).join("\n") + "\n",
+          { mode: 384 }
+        );
+        this.diskLineCount = retained.length;
+      }
+    });
+    for (const [timestamp, version] of snapshot.versions) {
+      if (this.dirtyVersions.get(timestamp) === version) this.dirtyVersions.delete(timestamp);
+    }
+    this.pruneBuckets();
+  }
+  /** Read buckets within `[since, now]`, oldest-first. */
+  async read(sinceMs) {
+    if (!this.loaded && this.buckets.size === 0) await this.load();
+    const since = sinceMs ?? 0;
+    return Array.from(this.buckets.values()).filter((b) => b.ts >= since).sort((a, b) => a.ts - b.ts);
+  }
+  /** Rehydrate buckets from disk (deduped, latest-per-bucket wins). */
+  async load() {
+    if (this.loaded) return;
+    this.loadPromise ??= this.loadInternal();
+    await this.loadPromise;
+  }
+  async loadInternal() {
+    let lineCount = 0;
+    try {
+      for await (const line of readJsonlLines(this.filePath)) {
+        lineCount++;
+        try {
+          const sample = JSON.parse(line);
+          this.buckets.set(sample.ts, sample);
+        } catch {
+        }
+        if (this.buckets.size > this.maxBuckets * 2) this.pruneBuckets();
+      }
+    } catch {
+      this.diskLineCount = lineCount;
+      this.loaded = true;
+      return;
+    }
+    this.diskLineCount = lineCount;
+    this.loaded = true;
+    this.pruneBuckets();
+  }
+};
+function cloneTimeseriesSample(sample) {
+  return {
+    ...sample,
+    ...sample.byModel ? {
+      byModel: Object.fromEntries(
+        Object.entries(sample.byModel).map(([key, value]) => [key, { ...value }])
+      )
+    } : {},
+    ...sample.byProvider ? {
+      byProvider: Object.fromEntries(
+        Object.entries(sample.byProvider).map(([key, value]) => [key, { ...value }])
+      )
+    } : {}
+  };
+}
+function foldBreakdown(map, key, entry) {
+  const next = { ...map };
+  const existing = next[key];
+  if (existing === void 0) {
+    next[key] = { ...entry };
+  } else {
+    next[key] = {
+      costUsd: existing.costUsd + entry.costUsd,
+      inputTokens: existing.inputTokens + entry.inputTokens,
+      outputTokens: existing.outputTokens + entry.outputTokens,
+      cacheRead: existing.cacheRead !== void 0 || entry.cacheRead !== void 0 ? (existing.cacheRead ?? 0) + (entry.cacheRead ?? 0) : void 0,
+      cacheWrite: existing.cacheWrite !== void 0 || entry.cacheWrite !== void 0 ? (existing.cacheWrite ?? 0) + (entry.cacheWrite ?? 0) : void 0
+    };
+  }
+  return next;
+}
+
+// src/hq/persistence.ts
+function createHqPersistence(dataDir) {
+  return {
+    eventLog: new HqEventLog({ dataDir }),
+    snapshotStore: new HqSnapshotStore({ dataDir }),
+    timeseries: new HqTimeseriesStore({ dataDir }),
+    kanban: new HqKanbanStore(dataDir),
+    commandLog: new HqSimpleLog({
+      dataDir,
+      filename: "commands.jsonl",
+      maxLines: 8e3,
+      rotateKeep: 4e3,
+      readLimit: 4e3
+    }),
+    alertLog: new HqSimpleLog({
+      dataDir,
+      filename: "alerts.jsonl",
+      maxLines: 2e3,
+      rotateKeep: 1e3,
+      readLimit: 1e3
+    })
+  };
+}
+
+// src/hq/commands.ts
+var HQ_COMMAND_TYPES = [
+  "steer",
+  "btw",
+  "queue",
+  "abort",
+  "spawn",
+  "broadcast",
+  "run-command"
+];
+var HQ_COMMAND_TYPE_SET = new Set(HQ_COMMAND_TYPES);
+function validateHqCommand(queued) {
+  if (!HQ_COMMAND_TYPE_SET.has(queued.type)) return null;
+  const p = queued.payload;
+  if (p === null || typeof p !== "object") return null;
+  switch (queued.type) {
+    case "steer": {
+      if (typeof p["to"] !== "string" || typeof p["subject"] !== "string" || typeof p["body"] !== "string") {
+        return null;
+      }
+      const result = { type: "steer", to: p["to"], subject: p["subject"], body: p["body"] };
+      if (p["priority"] === "low" || p["priority"] === "normal" || p["priority"] === "high") {
+        result.priority = p["priority"];
+      }
+      return result;
+    }
+    case "btw": {
+      if (typeof p["to"] !== "string" || typeof p["subject"] !== "string" || typeof p["body"] !== "string") {
+        return null;
+      }
+      const result = { type: "btw", to: p["to"], subject: p["subject"], body: p["body"] };
+      if (p["priority"] === "low" || p["priority"] === "normal" || p["priority"] === "high") {
+        result.priority = p["priority"];
+      }
+      return result;
+    }
+    case "queue": {
+      if (typeof p["to"] !== "string" || typeof p["subject"] !== "string" || typeof p["body"] !== "string") {
+        return null;
+      }
+      const result = { type: "queue", to: p["to"], subject: p["subject"], body: p["body"] };
+      if (p["priority"] === "low" || p["priority"] === "normal" || p["priority"] === "high") {
+        result.priority = p["priority"];
+      }
+      return result;
+    }
+    case "abort":
+      if (typeof p["target"] !== "string") return null;
+      return { type: "abort", target: p["target"] };
+    case "spawn": {
+      if (typeof p["role"] !== "string") return null;
+      const result = { type: "spawn", role: p["role"] };
+      if (typeof p["task"] === "string") result.task = p["task"];
+      if (typeof p["maxIterations"] === "number") result.maxIterations = p["maxIterations"];
+      return result;
+    }
+    case "broadcast": {
+      if (typeof p["subject"] !== "string" || typeof p["body"] !== "string") return null;
+      const result = { type: "broadcast", subject: p["subject"], body: p["body"] };
+      if (p["priority"] === "low" || p["priority"] === "normal" || p["priority"] === "high") {
+        result.priority = p["priority"];
+      }
+      return result;
+    }
+    case "run-command": {
+      if (typeof p["command"] !== "string") return null;
+      const result = { type: "run-command", command: p["command"] };
+      if (typeof p["cwd"] === "string") result.cwd = p["cwd"];
+      return result;
+    }
+    default:
+      return null;
+  }
+}
+var HqCommandAuditLog = class {
+  entries = [];
+  max;
+  onPersist;
+  constructor(max = 1e3, onPersist) {
+    this.max = max;
+    this.onPersist = onPersist;
+  }
+  record(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.max) {
+      this.entries.splice(0, this.entries.length - this.max);
+    }
+    this.onPersist?.(entry);
+  }
+  update(commandId, patch) {
+    const entry = this.entries.find((e) => e.commandId === commandId);
+    if (entry) {
+      Object.assign(entry, patch);
+      this.onPersist?.(entry);
+    }
+  }
+  get(commandId) {
+    return this.entries.find((entry) => entry.commandId === commandId);
+  }
+  /** Update only when the command belongs to the authenticated client. */
+  updateForClient(commandId, clientId, patch) {
+    const entry = this.entries.find(
+      (candidate) => candidate.commandId === commandId && candidate.clientId === clientId
+    );
+    if (!entry) return false;
+    Object.assign(entry, patch);
+    this.onPersist?.(entry);
+    return true;
+  }
+  /** Seed the ring from a durable store on boot (no persist callback fired). */
+  seed(entries) {
+    for (const entry of entries) {
+      this.entries.push(entry);
+    }
+    if (this.entries.length > this.max) {
+      this.entries.splice(0, this.entries.length - this.max);
+    }
+  }
+  recent(limit = 200) {
+    return this.entries.slice(-limit);
+  }
+};
+
+// src/hq/alerts.ts
+var DEFAULT_CONFIG = {
+  costThresholdUsd: 50,
+  staleMachineSeconds: 120,
+  maxAgents: 0,
+  tokenExpiryWarningHours: 24
+};
+function resolveConfig(config) {
+  return { ...DEFAULT_CONFIG, ...config ?? {} };
+}
+var RULES = [
+  {
+    id: "fleet-cost-threshold",
+    severity: "warn",
+    evaluate: (snapshot, config) => {
+      if (snapshot === null) return null;
+      const cost = snapshot.totals.totalCostUsd ?? 0;
+      if (cost >= config.costThresholdUsd) {
+        return `Fleet cost $${cost.toFixed(2)} exceeded threshold $${config.costThresholdUsd.toFixed(2)}`;
+      }
+      return null;
+    }
+  },
+  {
+    id: "all-machines-stale",
+    severity: "warn",
+    evaluate: (snapshot, config, now) => {
+      if (snapshot === null) return null;
+      const machines = snapshot.machines ?? [];
+      if (machines.length === 0) return null;
+      const cutoff = now - config.staleMachineSeconds * 1e3;
+      const stale = machines.filter((m) => Date.parse(m.lastActivityAt) < cutoff);
+      if (stale.length === machines.length) {
+        return `All ${machines.length} machine(s) silent for ${config.staleMachineSeconds}s`;
+      }
+      return null;
+    }
+  },
+  {
+    id: "high-concurrency",
+    severity: "info",
+    evaluate: (snapshot, config) => {
+      if (snapshot === null || config.maxAgents <= 0) return null;
+      const agents = snapshot.totals.activeAgents ?? 0;
+      if (agents >= config.maxAgents) {
+        return `High fleet concurrency: ${agents} active agents (limit ${config.maxAgents})`;
+      }
+      return null;
+    }
+  },
+  {
+    id: "fleet-failure-spike",
+    severity: "warn",
+    evaluate: (snapshot) => {
+      if (snapshot === null) return null;
+      const fleets = snapshot.fleets ?? [];
+      const failed = fleets.reduce((sum, f) => sum + f.failedTasks, 0);
+      if (failed >= 5) {
+        return `${failed} failed task(s) across the fleet`;
+      }
+      return null;
+    }
+  },
+  {
+    id: "token-expired-present",
+    severity: "error",
+    evaluate: (snapshot) => {
+      if (snapshot === null) return null;
+      const stats = snapshot.totals.tokenStats;
+      if (stats === void 0 || stats.expired <= 0) return null;
+      return `${stats.expired} expired token(s) filtered from live auth \u2014 rotate or revoke them`;
+    }
+  },
+  {
+    id: "token-expiry-imminent",
+    severity: "warn",
+    evaluate: (snapshot, config) => {
+      if (snapshot === null) return null;
+      if (config.tokenExpiryWarningHours <= 0) return null;
+      const stats = snapshot.totals.tokenStats;
+      if (stats === void 0 || stats.expiringSoon <= 0) return null;
+      return `${stats.expiringSoon} token(s) expire within ${config.tokenExpiryWarningHours}h \u2014 mint replacements before they lapse`;
+    }
+  }
+];
+var HqAlertEngine = class {
+  active = /* @__PURE__ */ new Map();
+  history = [];
+  maxHistory;
+  timer = null;
+  onAlert;
+  onPersist;
+  constructor(opts) {
+    this.onAlert = opts.onAlert;
+    this.maxHistory = opts.maxHistory ?? 500;
+    this.onPersist = opts.onPersist;
+  }
+  /**
+   * Evaluate all rules against the snapshot. Emits (via the `onAlert`
+   * callback) only for rules that newly transition to firing. Clears rules
+   * that are no longer firing. Returns the list of newly-fired alerts.
+   */
+  evaluate(snapshot, config, now = Date.now()) {
+    const resolved = resolveConfig(config);
+    const fired = [];
+    const firingIds = /* @__PURE__ */ new Set();
+    for (const rule of RULES) {
+      const message = rule.evaluate(snapshot, resolved, now);
+      if (message !== null) {
+        firingIds.add(rule.id);
+        const existing = this.active.get(rule.id);
+        if (existing === void 0) {
+          const alert = {
+            id: `${rule.id}-${now}`,
+            ruleId: rule.id,
+            severity: rule.severity,
+            message,
+            firstFiredAt: now,
+            lastFiredAt: now
+          };
+          this.active.set(rule.id, alert);
+          this.history.push(alert);
+          if (this.history.length > this.maxHistory) this.history.splice(0, this.history.length - this.maxHistory);
+          fired.push(alert);
+          this.onAlert(alert);
+          this.onPersist?.(alert);
+        } else {
+          existing.lastFiredAt = now;
+        }
+      }
+    }
+    for (const id of Array.from(this.active.keys())) {
+      if (!firingIds.has(id)) {
+        this.active.delete(id);
+      }
+    }
+    return fired;
+  }
+  /** Currently-active (firing) alerts. */
+  activeAlerts() {
+    return Array.from(this.active.values());
+  }
+  /** Historical alerts (newest-last), capped at maxHistory. */
+  recentAlerts(limit = 100) {
+    return this.history.slice(-limit);
+  }
+  /** Seed the history from a durable store on boot (no alert callbacks fired). */
+  seed(alerts) {
+    for (const alert of alerts) {
+      this.history.push(alert);
+    }
+    if (this.history.length > this.maxHistory) {
+      this.history.splice(0, this.history.length - this.maxHistory);
+    }
+  }
+  /**
+   * Start periodic evaluation against a snapshot getter. The timer is
+   * unref'd so it never keeps the process alive. Returns a disposer.
+   */
+  startPeriodic(getSnapshot, config, intervalMs = 15e3) {
+    if (this.timer !== null) return () => void 0;
+    const tick = () => {
+      try {
+        const cfg = typeof config === "function" ? config() : config;
+        this.evaluate(getSnapshot(), cfg);
+      } catch {
+      }
+    };
+    this.timer = setInterval(tick, intervalMs);
+    this.timer.unref?.();
+    return () => {
+      if (this.timer !== null) {
+        clearInterval(this.timer);
+        this.timer = null;
+      }
+    };
+  }
+};
+function toAlertMessage(alert) {
+  return {
+    type: "hq.alert",
+    severity: alert.severity,
+    message: `[${alert.ruleId}] ${alert.message}`,
+    timestamp: new Date(alert.lastFiredAt).toISOString()
+  };
+}
+
+// src/hq/bootstrap-store.ts
+import { randomBytes, timingSafeEqual } from "node:crypto";
+var MAX_PENDING_CODES = 32;
+var BOOTSTRAP_CODE_TTL_MS = 12e4;
+var HqBootstrapCodeStore = class {
+  entries = /* @__PURE__ */ new Map();
+  /** Mint a new one-time bootstrap code for the given token. */
+  issue(source) {
+    this.sweepExpired();
+    while (this.entries.size >= MAX_PENDING_CODES) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === void 0) break;
+      this.entries.delete(oldest);
+    }
+    const code = randomBytes(32).toString("base64url");
+    this.entries.set(code, {
+      code,
+      expiresAt: Date.now() + BOOTSTRAP_CODE_TTL_MS,
+      tokenId: source.tokenId,
+      ...source.capabilities !== void 0 ? { capabilities: source.capabilities } : {}
+    });
+    return code;
+  }
+  /**
+   * Atomically consume a code. Returns the entry on match (and deletes it
+   * so it can never be reused), or `undefined` if the code is unknown,
+   * already consumed, or expired.
+   */
+  consume(supplied) {
+    this.sweepExpired();
+    for (const [key, entry] of this.entries) {
+      const a = Buffer.from(key);
+      const b = Buffer.from(supplied);
+      if (a.length === b.length && timingSafeEqual(a, b)) {
+        this.entries.delete(key);
+        return Date.now() < entry.expiresAt ? entry : void 0;
+      }
+    }
+    return void 0;
+  }
+  /** Remove all codes (called on server shutdown). */
+  clear() {
+    this.entries.clear();
+  }
+  /** Current number of pending (not-yet-consumed) codes. */
+  get size() {
+    return this.entries.size;
+  }
+  sweepExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.entries) {
+      if (now >= entry.expiresAt) this.entries.delete(key);
+    }
+  }
+};
+
+// src/hq/exposure.ts
+import { isIP } from "node:net";
+var HQ_CLI_DEFAULT_HOST = "0.0.0.0";
+var HqInsecureExposureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HqInsecureExposureError";
+  }
+};
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+  if (normalized === "localhost") return true;
+  const family = isIP(normalized);
+  if (family === 4) {
+    return normalized.startsWith("127.");
+  }
+  if (family === 6) {
+    return normalized === "::1" || /^::ffff:127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(normalized);
+  }
+  return false;
+}
+function isOpenMode(input) {
+  return !input.hasBrowserTokens && !input.hasPassword;
+}
+function assessHqExposure(input) {
+  if (isLoopbackHost(input.host)) return { kind: "ok" };
+  if (isOpenMode(input)) {
+    const detail = `HQ is configured in open mode (no browser tokens and no password), so every request \u2014 including POST /api/command, which runs commands in your live sessions \u2014 is served unauthenticated. Binding that to ${input.host} exposes it to every peer on the network.`;
+    if (input.allowInsecure) {
+      return {
+        kind: "warn",
+        message: `${detail} Continuing because --insecure-open was passed.`
+      };
+    }
+    return {
+      kind: "refuse",
+      message: `${detail}
+
+Fix one of these, then retry:
+  \u2022 bind locally:        wstack hq --host 127.0.0.1
+  \u2022 mint a token:        wstack hq token create
+  \u2022 set a password:      wstack hq --password <value>
+  \u2022 accept the risk:     wstack hq --insecure-open`
+    };
+  }
+  return {
+    kind: "warn",
+    message: `HQ is bound to ${input.host} (all interfaces) without TLS. Access tokens travel in cleartext and appear in the URL query. Prefer --host 127.0.0.1 unless you intend HQ to be reachable from other machines.`
+  };
+}
+
+export {
+  mapSessionEventToEntries,
+  mergeToolResults,
+  buildTranscriptFromEvents,
+  startSessionTelemetryBridge,
+  createBridgeContext,
+  startFleetTelemetryBridge,
+  startBrainTelemetryBridge,
+  startWorktreeTelemetryBridge,
+  startToolTelemetryBridge,
+  startCostTelemetryBridge,
+  HqKanbanStore,
+  HQ_EVENT_LOG_PRESETS,
+  hqEventLogPresetFields,
+  HqEventLog,
+  HqSimpleLog,
+  HqSnapshotStore,
+  HqTimeseriesStore,
+  createHqPersistence,
+  HQ_COMMAND_TYPES,
+  validateHqCommand,
+  HqCommandAuditLog,
+  HqAlertEngine,
+  toAlertMessage,
+  HqBootstrapCodeStore,
+  HQ_CLI_DEFAULT_HOST,
+  HqInsecureExposureError,
+  isLoopbackHost,
+  isOpenMode,
+  assessHqExposure
+};
+//# sourceMappingURL=chunk-2KKODIQU.js.map