@wrongstack/core 0.270.0 → 0.272.1

package/dist/hq/index.js

@@ -2,7 +2,7 @@ import { randomUUID, randomBytes, createHash } from 'crypto';
 import * as syncFs from 'fs';
 import * as os from 'os';
 import { hostname } from 'os';
-import * as path3 from 'path';
+import * as path2 from 'path';
 import { basename } from 'path';
 import * as fsp from 'fs/promises';
 
@@ -105,7 +105,13 @@ function parseHqFrame(raw) {
     }
   }
 }
-var KNOWN_HQ_EVENT_PAYLOAD_TYPES = /* @__PURE__ */ new Set(["mailbox.snapshot", "mailbox.event"]);
+var KNOWN_HQ_EVENT_PAYLOAD_TYPES = /* @__PURE__ */ new Set([
+  "mailbox.snapshot",
+  "mailbox.event",
+  "session.snapshot",
+  "session.transcript",
+  "session.ended"
+]);
 function isHqMailboxMessageSummary(x) {
   if (typeof x !== "object" || x === null) return false;
   const v = x;
@@ -152,6 +158,52 @@ function isHqMailboxEventPayload(x) {
   if (v.agent !== void 0 && !isHqMailboxAgentSummary(v.agent)) return false;
   return true;
 }
+var HQ_SESSION_AGENT_STATUSES = /* @__PURE__ */ new Set([
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error"
+]);
+function isHqSessionAgentSummary(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.id === "string" && typeof v.name === "string" && typeof v.status === "string" && HQ_SESSION_AGENT_STATUSES.has(v.status) && typeof v.iterations === "number" && typeof v.toolCalls === "number" && typeof v.lastActivityAt === "string";
+}
+var HQ_SESSION_STATUSES = /* @__PURE__ */ new Set(["active", "idle", "closing", "stale"]);
+function isHqSessionSnapshotPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.sessionId !== "string" || typeof v.clientKind !== "string" || typeof v.machineId !== "string" || typeof v.projectId !== "string" || typeof v.projectName !== "string" || typeof v.projectRoot !== "string" || typeof v.status !== "string" || !HQ_SESSION_STATUSES.has(v.status) || typeof v.startedAt !== "string" || typeof v.lastActivityAt !== "string" || typeof v.agentCount !== "number" || !Array.isArray(v.agents)) {
+    return false;
+  }
+  for (const agent of v.agents) {
+    if (!isHqSessionAgentSummary(agent)) return false;
+  }
+  return true;
+}
+var HQ_TRANSCRIPT_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "error"]);
+function isHqTranscriptEntry(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.ts === "string" && typeof v.role === "string" && HQ_TRANSCRIPT_ROLES.has(v.role) && typeof v.text === "string";
+}
+function isHqTranscriptAppendPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.sessionId !== "string" || typeof v.fromSeq !== "number" || !Array.isArray(v.entries)) {
+    return false;
+  }
+  for (const entry of v.entries) {
+    if (!isHqTranscriptEntry(entry)) return false;
+  }
+  return true;
+}
+function isHqSessionEndedPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.sessionId === "string" && typeof v.endedAt === "string";
+}
 function parseHqEventPayload(eventType, payload) {
   if (!KNOWN_HQ_EVENT_PAYLOAD_TYPES.has(eventType)) {
     return { ok: true, payload };
@@ -161,6 +213,12 @@ function parseHqEventPayload(eventType, payload) {
       return isHqMailboxSnapshotPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
     case "mailbox.event":
       return isHqMailboxEventPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.snapshot":
+      return isHqSessionSnapshotPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.transcript":
+      return isHqTranscriptAppendPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.ended":
+      return isHqSessionEndedPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
     default: {
       const _exhaustive = eventType;
       return _exhaustive;
@@ -797,6 +855,41 @@ var HqPublisher = class {
       ...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
     });
   }
+  /** The client identity this publisher announced (clientId, kind, machineId, …). */
+  get identity() {
+    return this.options.client;
+  }
+  /** The project identity this publisher is bound to. */
+  get project() {
+    return this.options.project;
+  }
+  /** Publish a live session/terminal snapshot (state + agents). */
+  publishSessionSnapshot(payload, opts) {
+    return this.publishEvent({
+      type: "session.snapshot",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
+  /** Publish an incremental batch of transcript turns for a session. */
+  publishTranscriptAppend(payload, opts) {
+    return this.publishEvent({
+      type: "session.transcript",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
+  /** Mark a session/terminal as ended. */
+  publishSessionEnded(payload, opts) {
+    return this.publishEvent({
+      type: "session.ended",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
   pollCommands() {
     this.sendFrame({
       type: "client.command_poll",
@@ -914,9 +1007,9 @@ var HqPublisher = class {
   }
 };
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path3.dirname(targetPath);
+  const dir = path2.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
-  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -934,8 +1027,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat3 = await fsp.stat(targetPath);
-      mode = stat3.mode & 511;
+      const stat4 = await fsp.stat(targetPath);
+      mode = stat4.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -952,9 +1045,9 @@ async function atomicWrite(targetPath, content, opts = {}) {
   }
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path3.dirname(targetPath);
+  const dir = path2.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
-  const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
+  const lockPath = path2.join(dir, `.${path2.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
@@ -972,8 +1065,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat3 = await fsp.stat(lockPath);
-        if (Date.now() - stat3.mtimeMs > staleMs) {
+        const stat4 = await fsp.stat(lockPath);
+        if (Date.now() - stat4.mtimeMs > staleMs) {
           await fsp.unlink(lockPath);
           continue;
         }
@@ -1022,10 +1115,62 @@ async function renameWithRetry(from, to) {
   }
   throw lastErr;
 }
+function projectHash(absRoot) {
+  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
+}
+function projectSlug(absRoot) {
+  const base = slugify(path2.basename(absRoot));
+  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
-  return path3.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv);
+  return path2.join(os.homedir(), ".wrongstack");
+}
+function resolveWstackPaths(opts) {
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const hash = projectHash(opts.projectRoot);
+  const slug = projectSlug(opts.projectRoot);
+  const projectDir = path2.join(globalRoot, "projects", slug);
+  return {
+    globalRoot,
+    configDir: globalRoot,
+    globalConfig: path2.join(globalRoot, "config.json"),
+    secretsKey: path2.join(globalRoot, ".key"),
+    globalMemory: path2.join(globalRoot, "memory.md"),
+    globalSkills: path2.join(globalRoot, "skills"),
+    globalPrompts: path2.join(globalRoot, "prompts"),
+    cacheDir: path2.join(globalRoot, "cache"),
+    modelsCache: path2.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path2.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path2.join(globalRoot, "history"),
+    logFile: path2.join(globalRoot, "logs", "wrongstack.log"),
+    projectDir,
+    projectCodebaseIndex: path2.join(projectDir, "codebase-index"),
+    projectMemory: path2.join(projectDir, "memory.md"),
+    projectSessions: path2.join(projectDir, "sessions"),
+    projectTrust: path2.join(projectDir, "trust.json"),
+    projectMeta: path2.join(projectDir, "meta.json"),
+    projectLocalConfig: path2.join(projectDir, "config.local.json"),
+    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectHash: hash,
+    projectSlug: slug,
+    projectGoal: path2.join(projectDir, "goal.json"),
+    projectSpecs: path2.join(projectDir, "specs"),
+    projectTaskGraphs: path2.join(projectDir, "task-graphs"),
+    projectSddSession: path2.join(projectDir, "sdd-session.json"),
+    projectPlan: path2.join(projectDir, "plan.json"),
+    projectAutophase: path2.join(projectDir, "autophase"),
+    syncConfig: path2.join(globalRoot, "sync.json"),
+    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
+  };
 }
 
 // src/coordination/mailbox-types.ts
@@ -1090,27 +1235,31 @@ var GlobalMailbox = class {
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
-   * @param hqPublisher — optional HQ publisher for cross-project telemetry
+   * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
    */
   constructor(projectDir, events, hqPublisher) {
-    this.messagePath = path3.join(projectDir, MAILBOX_FILE);
-    this.registryPath = path3.join(projectDir, "_mailbox.registry.json");
-    this.clientRegistryPath = path3.join(projectDir, CLIENT_REGISTRY_FILE);
+    this.messagePath = path2.join(projectDir, MAILBOX_FILE);
+    this.registryPath = path2.join(projectDir, "_mailbox.registry.json");
+    this.clientRegistryPath = path2.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
     this._hqPublisher = hqPublisher;
   }
   get hqMailboxId() {
-    return `${path3.basename(path3.dirname(this.messagePath))}:mailbox`;
+    return `${path2.basename(path2.dirname(this.messagePath))}:mailbox`;
+  }
+  get hqPublisher() {
+    return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
   }
   publishHqMailboxEvent(input) {
     try {
-      this._hqPublisher?.publishMailboxEvent(input);
+      this.hqPublisher?.publishMailboxEvent(input);
     } catch {
     }
   }
   publishHqMailboxSnapshot() {
-    if (this._hqPublisher === void 0) return;
-    void this._hqPublisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
+    const publisher = this.hqPublisher;
+    if (publisher === void 0) return;
+    void publisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
     });
   }
   // ── Messages ────────────────────────────────────────────────────────────
@@ -1133,7 +1282,7 @@ var GlobalMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
-    await fsp.mkdir(path3.dirname(this.messagePath), { recursive: true });
+    await fsp.mkdir(path2.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
       await fsp.appendFile(this.messagePath, line, "utf8");
       this._pushToCache(msg);
@@ -1472,30 +1621,69 @@ var GlobalMailbox = class {
   async _readMessages() {
     try {
       const raw = await fsp.readFile(this.messagePath, "utf8");
-      const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
-      const messages = [];
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (!parsed["readBy"]) {
-            const readBy = {};
-            if (parsed["read"] && parsed["readAt"]) {
-              readBy[parsed["to"]] = parsed["readAt"];
-            }
-            parsed["readBy"] = readBy;
-            delete parsed["read"];
-            delete parsed["readAt"];
-          }
-          messages.push(parsed);
-        } catch {
-        }
-      }
-      return messages;
+      return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
   }
+  /**
+   * Read only newly-appended bytes from the file and append them to the
+   * in-memory cache. This avoids re-reading and re-parsing the entire file
+   * when another process appended messages since our last read.
+   *
+   * Only safe when the file grew in size (messages are append-only). When
+   * the file was rewritten (ack/purge changed existing content), callers
+   * must fall back to {@link _readMessages}.
+   *
+   * @returns The (now up-to-date) message cache.
+   */
+  async _readNewMessagesOnly(fd, oldSize, newSize) {
+    const tailLen = newSize - oldSize;
+    const buf = Buffer.alloc(tailLen);
+    await fd.read(buf, 0, tailLen, oldSize);
+    const tail = buf.toString("utf8");
+    for (const line of tail.split(LINE_SEPARATOR)) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"]] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        this._messageCache.push(parsed);
+      } catch {
+      }
+    }
+    return this._messageCache;
+  }
+  /** Parse a JSONL string into MailboxMessage[], including migration. */
+  _parseLines(raw) {
+    const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"]] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        messages.push(parsed);
+      } catch {
+      }
+    }
+    return messages;
+  }
   /**
    * Read messages, then adopt the result as the in-memory cache. Use this
    * from writers that just took the file lock — the read reflects the
@@ -1515,6 +1703,10 @@ var GlobalMailbox = class {
    * stat matches the cached mtime+size we return the cached array — no
    * file read and no JSON.parse — collapsing the per-iteration query
    * cost on the mailbox-loop hot path.
+   *
+   * When the file only grew (new messages appended by another process),
+   * we read and parse just the tail bytes instead of the entire file.
+   * This avoids re-parsing the full 10K-message history on every check.
    */
   async _readMessagesCached() {
     try {
@@ -1522,6 +1714,17 @@ var GlobalMailbox = class {
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
+      if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
+        const fd = await fsp.open(this.messagePath, "r");
+        try {
+          const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
+          this._messageCacheMtime = st.mtimeMs;
+          this._messageCacheSize = st.size;
+          return updated;
+        } finally {
+          await fd.close();
+        }
+      }
       const all = await this._readMessages();
       this._setMessageCache(all, st.mtimeMs, st.size);
       return all;
@@ -1574,7 +1777,7 @@ var GlobalMailbox = class {
     this._messageCache.push(msg);
   }
   async _ensureRegistry() {
-    await fsp.mkdir(path3.dirname(this.registryPath), { recursive: true });
+    await fsp.mkdir(path2.dirname(this.registryPath), { recursive: true });
   }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
@@ -1619,7 +1822,7 @@ var GlobalMailbox = class {
   }
   // ── Client registry internals ───────────────────────────────────────────
   async _ensureClientRegistry() {
-    await fsp.mkdir(path3.dirname(this.clientRegistryPath), { recursive: true });
+    await fsp.mkdir(path2.dirname(this.clientRegistryPath), { recursive: true });
   }
   async _readClientRegistry(opts) {
     if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
@@ -1665,12 +1868,12 @@ var GlobalMailbox = class {
 };
 var HQ_AUTH_FILE_VERSION = 1;
 function defaultHqDataDir() {
-  return path3.join(wstackGlobalRoot(), "hq");
+  return path2.join(wstackGlobalRoot(), "hq");
 }
 function resolveHqDataDir(override, env = process.env) {
   const raw = override ?? env["WRONGSTACK_HQ_DATA_DIR"]?.trim();
   if (!raw) return defaultHqDataDir();
-  return path3.isAbsolute(raw) ? path3.resolve(raw) : path3.resolve(process.cwd(), raw);
+  return path2.isAbsolute(raw) ? path2.resolve(raw) : path2.resolve(process.cwd(), raw);
 }
 function emptyHqAuthFile() {
   return {
@@ -1679,10 +1882,10 @@ function emptyHqAuthFile() {
   };
 }
 function hqAuthFilePath(dataDir) {
-  return path3.join(dataDir, "auth.json");
+  return path2.join(dataDir, "auth.json");
 }
 function hqRuntimeFilePath(dataDir) {
-  return path3.join(dataDir, "runtime.json");
+  return path2.join(dataDir, "runtime.json");
 }
 async function writeHqRuntimeFile(dataDir, file) {
   const payload = {
@@ -1794,7 +1997,7 @@ function watchHqAuthFile(dataDir, onChange, opts = {}) {
   let closed = false;
   let watcher;
   try {
-    watcher = syncFs.watch(path3.dirname(file), { recursive: false });
+    watcher = syncFs.watch(path2.dirname(file), { recursive: false });
   } catch (err) {
     opts.warn?.(`HQ auth watcher could not start: ${err.message}`);
     return { close: () => {
@@ -1818,7 +2021,7 @@ function watchHqAuthFile(dataDir, onChange, opts = {}) {
   watcher.on("change", (eventType, filename) => {
     const name = typeof filename === "string" ? filename : "";
     if (eventType === "rename" || eventType === "change") {
-      if (!name || name === "auth.json" || name === path3.basename(file)) {
+      if (!name || name === "auth.json" || name === path2.basename(file)) {
         trigger();
       }
     }
@@ -1883,7 +2086,7 @@ function resolveHqConfig(options = {}) {
   };
 }
 function stableMachineId() {
-  return createHash("sha256").update(`${hostname()}:${process.pid}`).digest("hex").slice(0, 12);
+  return createHash("sha256").update(hostname()).digest("hex").slice(0, 12);
 }
 function deriveProjectId(projectRoot) {
   return createHash("sha256").update(projectRoot).digest("hex").slice(0, 12);
@@ -1926,6 +2129,381 @@ function createGlobalMailbox(options) {
   return new GlobalMailbox(options.projectDir, options.events, options.hqPublisher);
 }
 
-export { DEFAULT_HQ_REDACTION_POLICY, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HqPublisher, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxEventPayload, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, defaultHqDataDir, emptyHqAuthFile, ensureHqFirstRunAuthFile, hqAuthFilePath, hqRuntimeFilePath, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, parseHqEventPayload, parseHqFrame, readHqAuthFile, readHqRuntimeFileSync, redactHqEvent, redactHqValue, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, scrubAndTruncateHqPreview, summarizeHqToolArgs, watchHqAuthFile, writeHqAuthFile, writeHqRuntimeFile };
+// src/hq/agent-bridge.ts
+function startAgentMonitorEventBridge(opts) {
+  const { events, clientId, projectId, publish } = opts;
+  const seq = { current: 0 };
+  function nextSeq() {
+    seq.current += 1;
+    return seq.current;
+  }
+  function buildEnvelope(type, payload) {
+    return createHqEventEnvelope({
+      id: `${Date.now().toString(36)}-${nextSeq()}`,
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      clientId,
+      projectId,
+      seq: nextSeq(),
+      payload
+    });
+  }
+  const offMessage = events.on("agent.timeline.message", (payload) => {
+    if (!publish) return;
+    const msgPayload = {
+      subagentId: payload.subagentId,
+      agentName: payload.agentName,
+      content: payload.content,
+      kind: payload.kind,
+      iteration: payload.iteration,
+      ts: payload.ts
+    };
+    if (payload.toolName !== void 0) msgPayload.toolName = payload.toolName;
+    if (payload.costUsd !== void 0) msgPayload.costUsd = payload.costUsd;
+    publish(buildEnvelope("agent.message", msgPayload));
+  });
+  const offStatus = events.on("agent.status_changed", (payload) => {
+    if (!publish) return;
+    const statusPayload = {
+      subagentId: payload.subagentId,
+      agentName: payload.agentName,
+      status: payload.status,
+      ts: payload.ts
+    };
+    if (payload.summary !== void 0) statusPayload.summary = payload.summary;
+    if (payload.task !== void 0) statusPayload.task = payload.task;
+    publish(buildEnvelope("agent.status", statusPayload));
+  });
+  return () => {
+    offMessage();
+    offStatus();
+  };
+}
+
+// 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 t = blocksToText(ev["content"]);
+      if (t.trim()) out.push(make("assistant", t));
+      const content = ev["content"];
+      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 "error":
+    case "provider_error":
+      return [make("error", String(ev["message"] ?? "error"))];
+    case "agent_spawned":
+      return [make("system", `spawned ${String(ev["role"] ?? "agent")}`)];
+    case "task_completed":
+      return [make("system", `task done: ${String(ev["title"] ?? "")}`)];
+    case "task_failed":
+      return [make("system", `task failed: ${String(ev["title"] ?? "")}`)];
+    default:
+      return [];
+  }
+}
+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"
+]);
+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 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 = path2.join(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 disposed = false;
+  function buildSnapshot() {
+    return {
+      sessionId: opts.sessionId,
+      clientKind: identity.kind,
+      machineId: identity.machineId,
+      projectId: project.projectId,
+      projectName: opts.projectName ?? project.projectName,
+      projectRoot: opts.projectRoot,
+      status: deriveSessionStatus(agents),
+      startedAt,
+      lastActivityAt,
+      agentCount: agents.length,
+      agents,
+      ...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);
+    } catch {
+    }
+  }
+  const offAgents = opts.events?.on("session.agents_updated", (payload) => {
+    agents = payload.agents.map(toAgentSummary);
+    lastActivityAt = now();
+    publishSnapshot();
+  });
+  publishSnapshot(true);
+  let offset = 0;
+  let partial = "";
+  let seqEmitted = 0;
+  let tailing = false;
+  let watcher = null;
+  let watchPending = false;
+  function setupWatcher() {
+    if (disposed || watcher) return;
+    try {
+      const nextWatcher = syncFs.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;
+    }
+  }
+  async function tail() {
+    if (disposed || tailing) return;
+    tailing = true;
+    try {
+      const stat4 = await fsp.stat(sessionFile).catch(() => null);
+      if (disposed) return;
+      if (!stat4) return;
+      setupWatcher();
+      if (stat4.size <= offset) return;
+      const fd = await fsp.open(sessionFile, "r");
+      try {
+        if (disposed) return;
+        const len = stat4.size - offset;
+        const buf = Buffer.allocUnsafe(len);
+        await fd.read(buf, 0, len, offset);
+        offset = stat4.size;
+        partial += buf.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) {
+          try {
+            publisher.publishTranscriptAppend({
+              sessionId: opts.sessionId,
+              fromSeq: seqEmitted,
+              entries
+            });
+          } catch {
+          }
+          seqEmitted += entries.length;
+          lastActivityAt = now();
+        }
+      } finally {
+        await fd.close();
+      }
+    } catch {
+    } finally {
+      tailing = false;
+    }
+  }
+  const snapshotTimer = setInterval(() => publishSnapshot(true), opts.snapshotIntervalMs ?? 2500);
+  const tailTimer = setInterval(() => void tail(), opts.transcriptIntervalMs ?? 500);
+  snapshotTimer.unref?.();
+  tailTimer.unref?.();
+  void tail();
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    offAgents?.();
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    clearInterval(snapshotTimer);
+    clearInterval(tailTimer);
+    try {
+      publisher.publishSessionEnded({ sessionId: opts.sessionId, endedAt: now() });
+    } catch {
+    }
+  };
+}
+
+export { DEFAULT_HQ_REDACTION_POLICY, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HqPublisher, buildTranscriptFromEvents, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxEventPayload, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, defaultHqDataDir, emptyHqAuthFile, ensureHqFirstRunAuthFile, hqAuthFilePath, hqRuntimeFilePath, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mapSessionEventToEntries, mergeToolResults, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, parseHqEventPayload, parseHqFrame, readHqAuthFile, readHqRuntimeFileSync, redactHqEvent, redactHqValue, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, scrubAndTruncateHqPreview, startAgentMonitorEventBridge, startSessionTelemetryBridge, summarizeHqToolArgs, watchHqAuthFile, writeHqAuthFile, writeHqRuntimeFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map