@wrongstack/core 0.277.1 → 0.280.0

package/dist/hq/index.js

@@ -96,7 +96,8 @@ function parseHqFrame(raw) {
           clientId: obj.clientId,
           projectId: obj.projectId,
           commandId: obj.commandId,
-          status: obj.status
+          status: obj.status,
+          ...typeof obj.message === "string" ? { message: obj.message } : {}
         }
       };
     default: {
@@ -110,7 +111,14 @@ var KNOWN_HQ_EVENT_PAYLOAD_TYPES = /* @__PURE__ */ new Set([
   "mailbox.event",
   "session.snapshot",
   "session.transcript",
-  "session.ended"
+  "session.ended",
+  "fleet.snapshot",
+  "fleet.event",
+  "brain.event",
+  "worktree.event",
+  "tool.started",
+  "tool.completed",
+  "session.usage"
 ]);
 function isHqMailboxMessageSummary(x) {
   if (typeof x !== "object" || x === null) return false;
@@ -147,7 +155,8 @@ var HQ_MAILBOX_EVENT_ACTIONS = /* @__PURE__ */ new Set([
   "message.updated",
   "agent.registered",
   "agent.heartbeat",
-  "agent.offline"
+  "agent.offline",
+  "agent.deregistered"
 ]);
 function isHqMailboxEventPayload(x) {
   if (typeof x !== "object" || x === null) return false;
@@ -204,6 +213,79 @@ function isHqSessionEndedPayload(x) {
   const v = x;
   return typeof v.sessionId === "string" && typeof v.endedAt === "string";
 }
+var HQ_FLEET_SUBAGENT_STATUS = /* @__PURE__ */ new Set([
+  "pending",
+  "running",
+  "idle",
+  "completed",
+  "failed",
+  "stopped"
+]);
+function isHqSubagentSummary(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.subagentId === "string" && typeof v.status === "string" && HQ_FLEET_SUBAGENT_STATUS.has(v.status);
+}
+function isHqFleetSnapshotPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.runId !== "string" || typeof v.activeSubagents !== "number" || typeof v.queuedTasks !== "number" || typeof v.completedTasks !== "number" || typeof v.failedTasks !== "number" || !Array.isArray(v.subagents)) {
+    return false;
+  }
+  for (const s of v.subagents) {
+    if (!isHqSubagentSummary(s)) return false;
+  }
+  return true;
+}
+function isHqFleetEventPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.runId === "string" && typeof v.event === "string";
+}
+var HQ_BRAIN_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "decision_requested",
+  "decision_answered",
+  "decision_ask_human",
+  "human_answered",
+  "decision_denied",
+  "intervention"
+]);
+function isHqBrainEventPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.kind !== "string" || !HQ_BRAIN_EVENT_KINDS.has(v.kind)) return false;
+  if (typeof v.at !== "number") return false;
+  return true;
+}
+var HQ_WORKTREE_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "allocated",
+  "committed",
+  "merged",
+  "conflict",
+  "released",
+  "failed"
+]);
+function isHqWorktreeEventPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.kind !== "string" || !HQ_WORKTREE_EVENT_KINDS.has(v.kind)) return false;
+  if (typeof v.handleId !== "string" || typeof v.ownerId !== "string") return false;
+  return true;
+}
+function isHqToolStartedPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.toolName === "string";
+}
+function isHqToolCompletedPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.toolName === "string" && typeof v.status === "string" && typeof v.durationMs === "number";
+}
+function isHqUsagePayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  return !Array.isArray(x);
+}
 function parseHqEventPayload(eventType, payload) {
   if (!KNOWN_HQ_EVENT_PAYLOAD_TYPES.has(eventType)) {
     return { ok: true, payload };
@@ -219,6 +301,20 @@ function parseHqEventPayload(eventType, payload) {
       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" };
+    case "fleet.snapshot":
+      return isHqFleetSnapshotPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "fleet.event":
+      return isHqFleetEventPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "brain.event":
+      return isHqBrainEventPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "worktree.event":
+      return isHqWorktreeEventPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "tool.started":
+      return isHqToolStartedPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "tool.completed":
+      return isHqToolCompletedPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.usage":
+      return isHqUsagePayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
     default: {
       const _exhaustive = eventType;
       return _exhaustive;
@@ -723,6 +819,7 @@ function createMailboxEventPayload(input) {
 var OPEN_STATE = 1;
 var DEFAULT_RECONNECT_BASE_MS = 1e3;
 var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var DEFAULT_DISCOVERY_POLL_MS = 5e3;
 var DEFAULT_MAX_QUEUED_MESSAGES = 2e3;
 var DEFAULT_COMMAND_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_COMMAND_POLL_LIMIT = 25;
@@ -760,7 +857,7 @@ var HqPublisher = class {
     this.socketFactory = options.socketFactory ?? defaultSocketFactory;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
     this.idFactory = options.idFactory ?? randomUUID;
-    this.capabilities = options.capabilities ?? ["telemetry.publish", "mailbox.summary"];
+    this.capabilities = options.capabilities ?? ["telemetry.publish", "mailbox.summary", "fleet.summary", "session.summary"];
     this.reconnect = options.reconnect ?? true;
     this.reconnectBaseMs = options.reconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
     this.reconnectMaxMs = options.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
@@ -785,10 +882,22 @@ var HqPublisher = class {
   lastCommandId;
   connect() {
     if (this.socket !== null || this.stopped) return;
+    if (this.reconnectTimer !== null) return;
+    let url = this.options.url;
+    let token = this.options.token;
+    if (this.options.resolveEndpoint !== void 0) {
+      const endpoint = this.options.resolveEndpoint();
+      if (endpoint === void 0) {
+        this.scheduleDiscoveryPoll();
+        return;
+      }
+      url = endpoint.url;
+      token = endpoint.token ?? token;
+    }
     let socket;
     try {
-      socket = this.socketFactory(toClientUrl(this.options.url, this.options.token), {
-        ...this.options.token !== void 0 ? { token: this.options.token } : {}
+      socket = this.socketFactory(toClientUrl(url, token), {
+        ...token !== void 0 ? { token } : {}
       });
     } catch {
       this.scheduleReconnect();
@@ -913,6 +1022,16 @@ var HqPublisher = class {
       ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
     });
   }
+  /** Publish a fleet (multi-agent coordinator) snapshot. */
+  publishFleetSnapshot(payload, opts) {
+    return this.publishEvent({
+      type: "fleet.snapshot",
+      payload,
+      runId: payload.runId,
+      ...opts?.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
   pollCommands() {
     this.sendFrame({
       type: "client.command_poll",
@@ -1028,6 +1147,21 @@ var HqPublisher = class {
     }, delay);
     this.reconnectTimer.unref?.();
   }
+  /**
+   * Dormant re-check while no HQ endpoint is discoverable. Uses a FIXED
+   * interval (not the exponential reconnect backoff): the check is a cheap
+   * local file read, and backing off would delay attaching to an HQ the
+   * user just started — the whole point of auto-discovery.
+   */
+  scheduleDiscoveryPoll() {
+    if (this.stopped || !this.reconnect || this.reconnectTimer !== null) return;
+    this.reconnectAttempt = 0;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.options.discoveryPollMs ?? DEFAULT_DISCOVERY_POLL_MS);
+    this.reconnectTimer.unref?.();
+  }
 };
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
@@ -1066,16 +1200,20 @@ function wstackGlobalRoot() {
 }
 function resolveWstackPaths(opts) {
   const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const homeDir = opts.userHome ?? os.homedir();
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
   const projectDir = path2.join(globalRoot, "projects", slug);
   return {
     globalRoot,
+    projectRoot: opts.projectRoot,
+    homeDir,
     configDir: globalRoot,
     globalConfig: path2.join(globalRoot, "config.json"),
     secretsKey: path2.join(globalRoot, ".key"),
     globalMemory: path2.join(globalRoot, "memory.md"),
     globalSkills: path2.join(globalRoot, "skills"),
+    globalClaudeSkills: path2.join(homeDir, ".claude", "skills"),
     globalDesignKits: path2.join(globalRoot, "design-kits"),
     globalPrompts: path2.join(globalRoot, "prompts"),
     globalInstructions: path2.join(globalRoot, "instructions"),
@@ -1095,6 +1233,7 @@ function resolveWstackPaths(opts) {
     inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
     inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
     inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path2.join(opts.projectRoot, ".claude", "skills"),
     inProjectPrompts: path2.join(opts.projectRoot, ".wrongstack", "prompts"),
     inProjectInstructions: path2.join(opts.projectRoot, ".wrongstack", "instructions"),
     inProjectDesignKits: path2.join(opts.projectRoot, ".wrongstack", "design-kits"),
@@ -1294,6 +1433,7 @@ function normalizeRecipient(to) {
 var MAILBOX_FILE = "_mailbox.jsonl";
 var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
 var AGENT_STALE_MS = 6e4;
+var AGENT_PURGE_MS = 864e5;
 var CLIENT_STALE_MS = 6e4;
 var HEARTBEAT_THROTTLE_MS = 5e3;
 var REGISTRY_CACHE_TTL_MS = 2e3;
@@ -1399,7 +1539,11 @@ var GlobalMailbox = class {
       await fsp.appendFile(this.messagePath, line, "utf8");
       this._pushToCache(msg);
     });
-    this.publishHqMailboxEvent({ mailboxId: this.hqMailboxId, action: "message.sent", message: msg });
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "message.sent",
+      message: msg
+    });
     this.publishHqMailboxSnapshot();
     return msg;
   }
@@ -1420,6 +1564,7 @@ var GlobalMailbox = class {
         continue;
       }
       if (q.since !== void 0 && m.timestamp <= q.since) continue;
+      if (!q.includeDeleted && m.deletedAt !== void 0) continue;
       out.push(m);
     }
     out.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
@@ -1488,6 +1633,63 @@ var GlobalMailbox = class {
     }
     return count;
   }
+  async softDelete(mailId, by) {
+    let updated = null;
+    let cacheSnapshot = null;
+    await withFileLock(this.messagePath, async () => {
+      const all = await this._readMessagesFresh();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const m of all) {
+        if (m.id !== mailId) continue;
+        if (m.deletedAt !== void 0) {
+          updated = m;
+          continue;
+        }
+        m.deletedAt = now;
+        m.deletedBy = by;
+        updated = m;
+      }
+      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+      await fsp.writeFile(this.messagePath, serialized, "utf8");
+      cacheSnapshot = all;
+    });
+    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
+    if (updated !== null) {
+      this.publishHqMailboxEvent({
+        mailboxId: this.hqMailboxId,
+        action: "message.updated",
+        message: updated
+      });
+      this.publishHqMailboxSnapshot();
+    }
+    return updated;
+  }
+  async restore(mailId) {
+    let updated = null;
+    let cacheSnapshot = null;
+    await withFileLock(this.messagePath, async () => {
+      const all = await this._readMessagesFresh();
+      for (const m of all) {
+        if (m.id !== mailId) continue;
+        delete m.deletedAt;
+        delete m.deletedBy;
+        updated = m;
+      }
+      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+      await fsp.writeFile(this.messagePath, serialized, "utf8");
+      cacheSnapshot = all;
+    });
+    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
+    if (updated !== null) {
+      this.publishHqMailboxEvent({
+        mailboxId: this.hqMailboxId,
+        action: "message.updated",
+        message: updated
+      });
+      this.publishHqMailboxSnapshot();
+    }
+    return updated;
+  }
   // ── Agent registry ──────────────────────────────────────────────────────
   async registerAgent(input) {
     await this._ensureRegistry();
@@ -1542,6 +1744,43 @@ var GlobalMailbox = class {
     });
     this.publishHqMailboxSnapshot();
   }
+  async deregisterAgent(agentId) {
+    await this._ensureRegistry();
+    let removed;
+    await withFileLock(this.registryPath, async () => {
+      const registry = await this._readRegistry({ fresh: true });
+      this._pruneStaleInPlace(registry);
+      removed = registry.get(agentId);
+      registry.delete(agentId);
+      this._registryCache = registry;
+      this._registryCacheAt = Date.now();
+      await this._writeRegistry(registry);
+    });
+    this._events?.emitCustom("mailbox.agent_deregistered", {
+      agentId
+    });
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "agent.deregistered",
+      agent: {
+        agentId,
+        name: removed?.name ?? agentId,
+        ...removed?.role !== void 0 ? { role: removed.role } : {},
+        sessionId: removed?.sessionId ?? "",
+        status: "offline",
+        ...removed?.currentTool !== void 0 ? { currentTool: removed.currentTool } : {},
+        ...removed?.currentTask !== void 0 ? { currentTask: removed.currentTask } : {},
+        iterations: removed?.iterations ?? 0,
+        toolCalls: removed?.toolCalls ?? 0,
+        lastActivityAt: removed?.lastSeenAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        lastSeenAt: removed?.lastSeenAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        online: false,
+        pid: removed?.pid ?? 0,
+        ...removed?.source !== void 0 ? { source: removed.source } : {}
+      }
+    });
+    this.publishHqMailboxSnapshot();
+  }
   async heartbeat(input) {
     const last = this._lastHeartbeat.get(input.agentId) ?? 0;
     const now = Date.now();
@@ -1920,12 +2159,22 @@ var GlobalMailbox = class {
     }
   }
   _pruneStaleInPlace(registry) {
-    const cutoff = Date.now() - AGENT_STALE_MS;
-    for (const agent of registry.values()) {
-      if (new Date(agent.lastSeenAt).getTime() < cutoff) {
+    const staleCutoff = Date.now() - AGENT_STALE_MS;
+    const purgeCutoff = Date.now() - AGENT_PURGE_MS;
+    const toDelete = [];
+    for (const [id, agent] of registry) {
+      const lastSeen = new Date(agent.lastSeenAt).getTime();
+      if (lastSeen < purgeCutoff) {
+        toDelete.push(id);
+        continue;
+      }
+      if (lastSeen < staleCutoff) {
         agent.status = "idle";
       }
     }
+    for (const id of toDelete) {
+      registry.delete(id);
+    }
   }
   async _writeRegistry(registry) {
     const obj = {};
@@ -1991,6 +2240,11 @@ function resolveHqDataDir(override, env = process.env) {
   if (!raw) return defaultHqDataDir();
   return path2.isAbsolute(raw) ? path2.resolve(raw) : path2.resolve(process.cwd(), raw);
 }
+function tokenHasCapability(token, capability) {
+  if (token === void 0) return false;
+  if (token.capabilities === void 0) return true;
+  return token.capabilities.includes(capability);
+}
 function emptyHqAuthFile() {
   return {
     version: HQ_AUTH_FILE_VERSION,
@@ -2155,6 +2409,13 @@ function watchHqAuthFile(dataDir, onChange, opts = {}) {
 }
 
 // src/hq/factory.ts
+function discoverLocalHqEndpoint(options = {}) {
+  const dataDir = resolveHqDataDir(options.dataDir, options.env ?? process.env);
+  const runtime = readHqRuntimeFileSync(dataDir);
+  if (runtime === void 0) return void 0;
+  const token = readFirstClientTokenFromAuthFile(dataDir);
+  return { url: runtime.url, ...token ? { token } : {} };
+}
 function readFirstClientTokenFromAuthFile(dataDir) {
   try {
     const raw = syncFs.readFileSync(hqAuthFilePath(dataDir), "utf8");
@@ -2182,14 +2443,13 @@ function resolveHqConfig(options = {}) {
   const url = envUrl || configUrl;
   if (!url) {
     if (enabled === false) return void 0;
-    if (enabled === true || token || runtimeUrl) {
-      return {
-        url: runtimeUrl || "http://127.0.0.1:3499",
-        enabled: true,
-        ...token ? { token } : {}
-      };
-    }
-    return void 0;
+    return {
+      url: runtimeUrl || "http://127.0.0.1:3499",
+      enabled: true,
+      discover: true,
+      dataDir,
+      ...token ? { token } : {}
+    };
   }
   const rawContentEnv = env["WRONGSTACK_HQ_RAW_CONTENT"]?.trim();
   const projectAliasEnv = env["WRONGSTACK_HQ_PROJECT_ALIAS"]?.trim();
@@ -2232,13 +2492,20 @@ function createHqPublisherFromEnv(options) {
     ...config.rawContent !== void 0 ? { rawContent: config.rawContent } : {},
     ...options.redactionPolicy ?? {}
   } : void 0;
+  const discoveryDataDir = config.dataDir;
   return new HqPublisher({
     url: config.url,
     ...config.token ? { token: config.token } : {},
     client,
     project,
     ...options.socketFactory ? { socketFactory: options.socketFactory } : {},
-    ...redactionPolicy !== void 0 ? { redactionPolicy } : {}
+    ...redactionPolicy !== void 0 ? { redactionPolicy } : {},
+    ...options.capabilities !== void 0 ? { capabilities: options.capabilities } : {},
+    ...options.onCommand !== void 0 ? { onCommand: options.onCommand } : {},
+    // Auto-discovery: re-read the local HQ runtime marker + client token on
+    // every connect attempt so late-started/restarted HQs are picked up.
+    ...config.discover ? { resolveEndpoint: () => discoverLocalHqEndpoint({ dataDir: discoveryDataDir }) } : {},
+    ...options.discoveryPollMs !== void 0 ? { discoveryPollMs: options.discoveryPollMs } : {}
   });
 }
 function createGlobalMailbox(options) {
@@ -2620,6 +2887,788 @@ function startSessionTelemetryBridge(opts) {
   };
 }
 
-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 };
+// src/hq/fleet-bridge.ts
+function startFleetTelemetryBridge(opts) {
+  const { events, publisher, runId } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  let lastHash = "";
+  function buildPayload(stats) {
+    const subagents = stats.subagentStatuses.map((s) => ({
+      subagentId: s.subagentId,
+      ...s.taskId ? { task: s.taskId } : {},
+      status: normalizeSubagentStatus(s.status)
+    }));
+    return {
+      runId,
+      activeSubagents: stats.running + stats.idle,
+      queuedTasks: stats.pending,
+      completedTasks: stats.completed,
+      failedTasks: stats.stopped,
+      subagents
+    };
+  }
+  const off = events.on("coordinator.stats", (stats) => {
+    try {
+      const payload = buildPayload(stats);
+      const hash = JSON.stringify(payload);
+      if (hash === lastHash) return;
+      lastHash = hash;
+      publisher.publishFleetSnapshot(payload, {
+        ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+        timestamp: now()
+      });
+    } catch {
+    }
+  });
+  return () => {
+    off();
+  };
+}
+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, publisher } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  function publish(kind, payload, at) {
+    try {
+      const full = { kind, at, ...payload };
+      publisher.publishEvent({
+        type: "brain.event",
+        payload: full,
+        ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+        timestamp: now()
+      });
+    } catch {
+    }
+  }
+  const offs = [];
+  offs.push(
+    events.on("brain.decision_requested", (p) => {
+      publish("decision_requested", extractRequestFields(p.request), p.at);
+    })
+  );
+  offs.push(
+    events.on("brain.decision_answered", (p) => {
+      publish("decision_answered", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  offs.push(
+    events.on("brain.decision_ask_human", (p) => {
+      publish("decision_ask_human", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  offs.push(
+    events.on("brain.decision_denied", (p) => {
+      publish("decision_denied", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision)
+      }, p.at);
+    })
+  );
+  offs.push(
+    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);
+    })
+  );
+  offs.push(
+    events.on("brain.intervention", (p) => {
+      publish("intervention", {
+        ...extractRequestFields(p.request),
+        ...extractDecisionFields(p.decision),
+        interventionKind: p.kind,
+        intervened: p.intervened
+      }, p.at);
+    })
+  );
+  return () => {
+    for (const off of offs) off();
+  };
+}
+
+// src/hq/worktree-bridge.ts
+function startWorktreeTelemetryBridge(opts) {
+  const { events, publisher } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  function publish(payload, sessionId) {
+    try {
+      publisher.publishEvent({
+        type: "worktree.event",
+        payload,
+        ...sessionId !== void 0 && sessionId !== "" ? { sessionId } : {},
+        ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+        timestamp: now()
+      });
+    } catch {
+    }
+  }
+  const offs = [];
+  offs.push(
+    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
+      );
+    })
+  );
+  offs.push(
+    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
+      );
+    })
+  );
+  offs.push(
+    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
+      );
+    })
+  );
+  offs.push(
+    events.on("worktree.conflict", (p) => {
+      publish(
+        {
+          kind: "conflict",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          conflictFiles: p.conflictFiles
+        },
+        p.sessionId
+      );
+    })
+  );
+  offs.push(
+    events.on("worktree.released", (p) => {
+      publish(
+        {
+          kind: "released",
+          handleId: p.handleId,
+          ownerId: p.ownerId,
+          branch: p.branch,
+          kept: p.kept
+        },
+        p.sessionId
+      );
+    })
+  );
+  offs.push(
+    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 () => {
+    for (const off of offs) off();
+  };
+}
+
+// src/hq/tool-bridge.ts
+function startToolTelemetryBridge(opts) {
+  const { events, publisher } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const inFlight = /* @__PURE__ */ new Map();
+  function sessionIdTag(sessionId) {
+    const tag = sessionId ?? opts.sessionId;
+    return tag !== void 0 ? { sessionId: tag } : {};
+  }
+  const offStarted = events.on("tool.started", (p) => {
+    inFlight.set(p.id, { name: p.name, startedAt: Date.now() });
+    try {
+      const payload = {
+        toolName: p.name,
+        ...p.input !== void 0 ? {
+          inputSummary: summarizeHqToolArgs(p.input, {
+            ...opts.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {}
+          })
+        } : {}
+      };
+      publisher.publishEvent({
+        type: "tool.started",
+        payload,
+        ...sessionIdTag(p.sessionId),
+        timestamp: now()
+      });
+    } catch {
+    }
+  });
+  const offExecuted = events.on("tool.executed", (p) => {
+    const id = p.id;
+    if (id !== void 0) inFlight.delete(id);
+    try {
+      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.publishEvent({
+        type: "tool.completed",
+        payload,
+        ...sessionIdTag(p.sessionId),
+        timestamp: now()
+      });
+    } catch {
+    }
+  });
+  return () => {
+    offStarted();
+    offExecuted();
+    inFlight.clear();
+  };
+}
+function truncateForSummary(output, max = 280) {
+  if (output.length <= max) return output;
+  return `${output.slice(0, max)}\u2026[truncated:${output.length - max}]`;
+}
+
+// src/hq/cost-bridge.ts
+function startCostTelemetryBridge(opts) {
+  const { events, publisher } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const off = events.on("token.accounted", (p) => {
+    try {
+      const payload = {
+        inputTokens: p.usage.input,
+        outputTokens: p.usage.output,
+        totalTokens: p.usage.input + p.usage.output,
+        costUsd: p.cost.total
+      };
+      const sessionId = opts.sessionId ?? p.sessionId;
+      publisher.publishEvent({
+        type: "session.usage",
+        payload,
+        ...sessionId !== void 0 ? { sessionId } : {},
+        timestamp: now()
+      });
+    } catch {
+    }
+  });
+  return () => {
+    off();
+  };
+}
+var DEFAULT_EVENT_LOG_MAX_LINES = 5e4;
+var DEFAULT_EVENT_LOG_ROTATE_KEEP = 2e4;
+var HqEventLog = class {
+  filePath;
+  maxLines;
+  rotateKeep;
+  writeChain = Promise.resolve();
+  lineCount = 0;
+  counted = false;
+  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;
+  }
+  /** Append an event envelope as one JSON line. Best-effort, never rejects. */
+  append(event) {
+    this.writeChain = this.writeChain.then(() => this.appendInternal(event)).catch(() => {
+    });
+  }
+  /** Resolves once all queued appends have settled. For tests. */
+  async drain() {
+    await this.writeChain.catch(() => {
+    });
+  }
+  async appendInternal(event) {
+    if (!this.counted) {
+      this.lineCount = await this.countLines();
+      this.counted = true;
+    }
+    const line = JSON.stringify(event) + "\n";
+    await fsp.appendFile(this.filePath, line, { encoding: "utf8" });
+    this.lineCount += 1;
+    if (this.lineCount >= this.maxLines) {
+      await this.rotate();
+    }
+  }
+  async rotate() {
+    await withFileLock(this.filePath, async () => {
+      try {
+        const content = await fsp.readFile(this.filePath, "utf8");
+        const lines = content.split("\n").filter((l) => l.length > 0);
+        if (lines.length <= this.rotateKeep) {
+          this.lineCount = lines.length;
+          return;
+        }
+        const kept = lines.slice(lines.length - this.rotateKeep);
+        await atomicWrite(this.filePath, kept.join("\n") + "\n");
+        this.lineCount = kept.length;
+      } catch {
+      }
+    });
+  }
+  async countLines() {
+    try {
+      const content = await fsp.readFile(this.filePath, "utf8");
+      return content.split("\n").filter((l) => l.length > 0).length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Read the most recent `limit` events, optionally filtered by envelope
+   * `type`. Newest first. Returns `[]` if the file doesn't exist yet.
+   */
+  async recent(limit, typeFilter) {
+    let content;
+    try {
+      content = await fsp.readFile(this.filePath, "utf8");
+    } catch {
+      return [];
+    }
+    const lines = content.split("\n").filter((l) => l.length > 0);
+    const out = [];
+    for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+      try {
+        const env = JSON.parse(lines[i]);
+        if (typeFilter === void 0 || env.type === typeFilter) {
+          out.push(env);
+        }
+      } catch {
+      }
+    }
+    return out;
+  }
+  /** Initialize the line count cache from disk (call once at boot). */
+  async hydrate() {
+    this.lineCount = await this.countLines();
+    this.counted = true;
+  }
+};
+var HqSnapshotStore = class {
+  filePath;
+  writeChain = Promise.resolve();
+  constructor(opts) {
+    this.filePath = path2.join(opts.dataDir, "snapshot.json");
+  }
+  /** Persist a snapshot. Best-effort, never rejects. */
+  save(snapshot) {
+    this.writeChain = this.writeChain.then(() => atomicWrite(this.filePath, JSON.stringify(snapshot), { mode: 384 })).catch(() => {
+    });
+  }
+  /** Resolves once all queued saves have settled. For tests. */
+  async drain() {
+    await this.writeChain.catch(() => {
+    });
+  }
+  /** Read the last persisted snapshot, or `null` if none. */
+  async load() {
+    try {
+      const content = await fsp.readFile(this.filePath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+};
+var HqTimeseriesStore = class {
+  filePath;
+  bucketMs;
+  maxBuckets;
+  buckets = /* @__PURE__ */ new Map();
+  flushChain = Promise.resolve();
+  constructor(opts) {
+    this.filePath = path2.join(opts.dataDir, "timeseries.jsonl");
+    this.bucketMs = opts.bucketMs ?? 5 * 60 * 1e3;
+    this.maxBuckets = opts.maxBuckets ?? 2016;
+  }
+  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 (this.buckets.size > this.maxBuckets) {
+      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);
+      }
+    }
+  }
+  /** Persist accumulated buckets to disk (append under lock), prune to maxBuckets. */
+  flush() {
+    const snapshot = Array.from(this.buckets.values()).sort((a, b) => a.ts - b.ts);
+    if (snapshot.length === 0) return;
+    this.flushChain = this.flushChain.then(() => this.flushInternal(snapshot)).catch(() => {
+    });
+  }
+  /** Resolves once all queued flushes have settled. For tests. */
+  async drain() {
+    await this.flushChain.catch(() => {
+    });
+  }
+  async flushInternal(toWrite) {
+    const lines = toWrite.map((b) => JSON.stringify(b)).join("\n") + "\n";
+    await withFileLock(this.filePath, async () => {
+      await fsp.appendFile(this.filePath, lines, { encoding: "utf8" });
+    });
+    const sorted = Array.from(this.buckets.keys()).sort((a, b) => a - b);
+    while (this.buckets.size > this.maxBuckets) {
+      const oldest = sorted.shift();
+      if (oldest === void 0) break;
+      this.buckets.delete(oldest);
+    }
+  }
+  /** Read buckets within `[since, now]`, oldest-first. */
+  async read(sinceMs) {
+    if (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() {
+    let content;
+    try {
+      content = await fsp.readFile(this.filePath, "utf8");
+    } catch {
+      return;
+    }
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const sample = JSON.parse(trimmed);
+        this.buckets.set(sample.ts, sample);
+      } catch {
+      }
+    }
+    const sorted = Array.from(this.buckets.keys()).sort((a, b) => a - b);
+    while (this.buckets.size > this.maxBuckets) {
+      const oldest = sorted.shift();
+      if (oldest === void 0) break;
+      this.buckets.delete(oldest);
+    }
+  }
+};
+function createHqPersistence(dataDir) {
+  return {
+    eventLog: new HqEventLog({ dataDir }),
+    snapshotStore: new HqSnapshotStore({ dataDir }),
+    timeseries: new HqTimeseriesStore({ dataDir })
+  };
+}
+
+// src/hq/commands.ts
+var HQ_COMMAND_TYPES = [
+  "steer",
+  "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 "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;
+  constructor(max = 1e3) {
+    this.max = max;
+  }
+  record(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.max) {
+      this.entries.splice(0, this.entries.length - this.max);
+    }
+  }
+  update(commandId, patch) {
+    const entry = this.entries.find((e) => e.commandId === commandId);
+    if (entry) Object.assign(entry, patch);
+  }
+  recent(limit = 200) {
+    return this.entries.slice(-limit);
+  }
+};
+
+// src/hq/alerts.ts
+var DEFAULT_CONFIG = {
+  costThresholdUsd: 50,
+  staleMachineSeconds: 120,
+  maxAgents: 0
+};
+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;
+    }
+  }
+];
+var HqAlertEngine = class {
+  active = /* @__PURE__ */ new Map();
+  history = [];
+  maxHistory;
+  timer = null;
+  onAlert;
+  constructor(opts) {
+    this.onAlert = opts.onAlert;
+    this.maxHistory = opts.maxHistory ?? 500;
+  }
+  /**
+   * 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);
+        } 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);
+  }
+  /**
+   * 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()
+  };
+}
+
+export { DEFAULT_HQ_REDACTION_POLICY, HQ_AUTH_FILE_VERSION, HQ_COMMAND_TYPES, HQ_PROTOCOL_VERSION, HqAlertEngine, HqCommandAuditLog, HqEventLog, HqPublisher, HqSnapshotStore, HqTimeseriesStore, buildTranscriptFromEvents, createGlobalMailbox, createHqEventEnvelope, createHqPersistence, createHqPublisherFromEnv, createMailboxEventPayload, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, defaultHqDataDir, discoverLocalHqEndpoint, emptyHqAuthFile, ensureHqFirstRunAuthFile, hqAuthFilePath, hqRuntimeFilePath, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mapSessionEventToEntries, mergeToolResults, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, parseHqEventPayload, parseHqFrame, readHqAuthFile, readHqRuntimeFileSync, redactHqEvent, redactHqValue, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, scrubAndTruncateHqPreview, startAgentMonitorEventBridge, startBrainTelemetryBridge, startCostTelemetryBridge, startFleetTelemetryBridge, startSessionTelemetryBridge, startToolTelemetryBridge, startWorktreeTelemetryBridge, summarizeHqToolArgs, toAlertMessage, tokenHasCapability, validateHqCommand, watchHqAuthFile, writeHqAuthFile, writeHqRuntimeFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map