tokentracker-cli 1.4.9 → 1.4.11

package/src/lib/session-analytics.js

@@ -38,6 +38,7 @@ const { readCursorStateSummary } = require("./cursor-store");
 const { USD_TICKS_PER_USD, normalizeGrokUsage } = require("./grok-usage");
 const wsl = require("./wsl-probe");
 const { discoverKimiWireFiles, kimiSessionDependencies, readKimiSessions } = require("./kimi-session");
+const { discoverOmpSessionFiles, ompSessionDependencies, readOmpSessions } = require("./omp-session");
 const {
   appendUniqueDirs,
   dedupeDirsByRealpath,
@@ -89,7 +90,8 @@ const {
 // v25 adds Kimi wire sessions, including official/legacy migration dedup.
 // v26 retains Codex Ultrafast (service_tier ultrafast) subset columns so
 // date-filtered session views and cached sidecars keep the 6x premium.
-const SIDECAR_VERSION = 26;
+// v27 adds oh-my-pi (omp) sessions from ~/.omp/agent/sessions/**/*.jsonl.
+const SIDECAR_VERSION = 27;
 const EDIT_TOOLS = new Set([
   "apply_patch",
   "edit",
@@ -1948,6 +1950,26 @@ async function scanKimiSessions(filePaths) {
   }));
 }
 
+async function scanOmpSessions(filePaths) {
+  // Batch the whole OMP inventory so fork copies that reuse entry ids are
+  // counted once across sessions (same contract as the hourly seenIds set).
+  const rows = await readOmpSessions(Array.isArray(filePaths) ? filePaths : [filePaths]);
+  return rows.map(({ identity, files, title, ...row }) => finalizeRecord({
+    ...row,
+    title: cleanSessionTitle(title),
+    version: SIDECAR_VERSION,
+    source: "omp",
+    session_hash: sessionHash("omp", identity),
+    project_key: projectKey(row.project_ref, files[0]),
+    ...sessionStorageUsage(files),
+  }));
+}
+
+async function scanOmpSession(filePath) {
+  const rows = await scanOmpSessions([filePath]);
+  return rows[0] || null;
+}
+
 async function discoverSessionFiles(home, env = process.env, deps = {}) {
   const grokHome = resolveGrokHome(home);
   // config.scanRoots (#657): read from the tracker config unless the caller
@@ -2040,7 +2062,12 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
     return roots;
   });
   const kimi = discoverKimiWireFiles(dedupeDirsByRealpath(kimiRoots), incomplete);
-  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, kimi, incomplete };
+  const usingMachineHome = path.resolve(home) === path.resolve((deps.homedir || os.homedir)());
+  const ompEnv = usingMachineHome
+    ? { ...env, HOME: home }
+    : { HOME: home, OMP_HOME: path.join(home, ".omp") };
+  const omp = discoverOmpSessionFiles(ompEnv, incomplete);
+  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, kimi, omp, incomplete };
 }
 
 // Warn once per unreadable directory per process: the dashboard polls this
@@ -2144,6 +2171,9 @@ function analyticsEntryStatKey(source, filePath) {
   if (source === "kimi") {
     return `${sessionStat}|metadata:${filesSignature(kimiSessionDependencies(filePaths))}`;
   }
+  if (source === "omp") {
+    return `${sessionStat}|metadata:${filesSignature(ompSessionDependencies([filePaths].flat()))}`;
+  }
   if (source === "grok") {
     const primary = filePaths[0];
     return `${sessionStat}|summary:${sessionFileStatKey(grokSummaryPathFor(primary)) || "missing"}|signals:${sessionFileStatKey(grokSignalsPathFor(primary)) || "missing"}`;
@@ -2185,13 +2215,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   const retryOpencodeScan = fs.existsSync(incompleteOpencodePath);
   const incompleteKimiPath = `${metaPath}.kimi-incomplete`;
   const retryKimiScan = fs.existsSync(incompleteKimiPath);
+  const incompleteOmpPath = `${metaPath}.omp-incomplete`;
+  const retryOmpScan = fs.existsSync(incompleteOmpPath);
   let previousMeta = null;
   if (!force) {
     try {
       previousMeta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
       const checkedAt = Date.parse(previousMeta.checked_at || previousMeta.generated_at || "");
       if (
-        !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta.version === SIDECAR_VERSION &&
+        !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && !retryOmpScan && previousMeta.version === SIDECAR_VERSION &&
         Number.isFinite(checkedAt) &&
         Date.now() - checkedAt < Math.max(0, Number(cacheTtlMs) || 0)
       ) {
@@ -2223,13 +2255,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...discovered.codex.flat().map(codexTitleIndexPathFor).filter(Boolean),
     ...discovered.kimi,
     ...kimiSessionDependencies(discovered.kimi),
+    ...discovered.omp,
+    ...ompSessionDependencies(discovered.omp),
     ...discovered.grok,
     ...discovered.grok.map(grokSummaryPathFor),
     ...discovered.grok.map(grokSignalsPathFor),
     // db + its WAL sidecars: the trio is one logical file for change detection.
     ...[...(discovered.zcode || []), ...(discovered.opencode || [])].flatMap((dbPath) => [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]),
   ]);
-  if (!force && !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
+  if (!force && !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && !retryOmpScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
     await writeAtomic(metaPath, `${JSON.stringify({ ...previousMeta, checked_at: new Date().toISOString() })}\n`);
     return readSidecar(sidecarPath);
   }
@@ -2252,6 +2286,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...(discovered.zcode.length ? [{ source: "zcode", filePath: discovered.zcode, scan: scanZcodeSessions }] : []),
     ...(discovered.opencode.length ? [{ source: "opencode", filePath: discovered.opencode, scan: scanOpencodeSessions }] : []),
     ...(discovered.kimi.length ? [{ source: "kimi", filePath: discovered.kimi, scan: scanKimiSessions }] : []),
+    ...(discovered.omp.length ? [{ source: "omp", filePath: discovered.omp, scan: scanOmpSessions }] : []),
   ];
   // Files we could not turn into a row (permission denied, half-written line,
   // vanished mid-scan). Swallowing these silently made sessions disappear with
@@ -2260,6 +2295,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   let incompleteZcodeScan = false;
   let incompleteOpencodeScan = false;
   let incompleteKimiScan = false;
+  let incompleteOmpScan = false;
   for (const entry of entries) {
     const cacheKey = sessionFileCacheKey(entry.source, entry.filePath);
     const statKey = analyticsEntryStatKey(entry.source, entry.filePath);
@@ -2268,11 +2304,12 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       if (entry.source === "zcode") incompleteZcodeScan = true;
       if (entry.source === "opencode") incompleteOpencodeScan = true;
       if (entry.source === "kimi") incompleteKimiScan = true;
+      if (entry.source === "omp") incompleteOmpScan = true;
       continue;
     }
     let rows = null;
-    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && !(entry.source === "kimi" && retryKimiScan) && previousFiles[cacheKey]?.stat_key === statKey) {
-      if (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") {
+    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && !(entry.source === "kimi" && retryKimiScan) && !(entry.source === "omp" && retryOmpScan) && previousFiles[cacheKey]?.stat_key === statKey) {
+      if (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi" || entry.source === "omp") {
         // One db scans to many cached rows; recover them all from the previous
         // pass. An empty recovery means the sidecar lost its rows — rescan.
         const cached = previousRows.filter((row) => row?.source === entry.source);
@@ -2293,6 +2330,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
         if (entry.source === "zcode") incompleteZcodeScan = true;
         if (entry.source === "opencode") incompleteOpencodeScan = true;
         if (entry.source === "kimi") incompleteKimiScan = true;
+        if (entry.source === "omp") incompleteOmpScan = true;
         if (!process.env.NODE_TEST_CONTEXT) {
           console.warn(`[session-analytics] skipped ${entry.source} session file: ${error?.message || error}`);
         }
@@ -2306,7 +2344,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       // so key each by the db path plus its session id; a bare session id as a
       // separate path element would be path.resolve()d against the process cwd
       // and never match across runs.
-      row._cache_key = (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") && (row.session_id || row.session_hash)
+      row._cache_key = (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi" || entry.source === "omp") && (row.session_id || row.session_hash)
         ? `${cacheKey}#${sessionHash(entry.source, row.session_id || row.session_hash)}`
         : cacheKey;
       sessions.push(row);
@@ -2330,10 +2368,14 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     await writeAtomic(incompleteKimiPath, "1\n");
     sessions.push(...readSidecar(sidecarPath).filter((row) => row.source === "kimi" && row.version === SIDECAR_VERSION));
   }
+  if (incompleteOmpScan) {
+    await writeAtomic(incompleteOmpPath, "1\n");
+    sessions.push(...readSidecar(sidecarPath).filter((row) => row.source === "omp" && row.version === SIDECAR_VERSION));
+  }
   sessions.sort((a, b) => String(b.ended_at || "").localeCompare(String(a.ended_at || "")));
   // A failed database scan is an incomplete inventory. Keep the last complete
   // snapshot and signature so an unchanged database is retried next build.
-  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan && !incompleteKimiScan) {
+  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan && !incompleteKimiScan && !incompleteOmpScan) {
     const content = sessions.map(serializeSessionRecord).join("\n") + (sessions.length ? "\n" : "");
     await writeAtomic(sidecarPath, content);
     const generatedAt = new Date().toISOString();
@@ -2347,6 +2389,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     await fsp.rm(incompleteZcodePath, { force: true });
     await fsp.rm(incompleteOpencodePath, { force: true });
     await fsp.rm(incompleteKimiPath, { force: true });
+    await fsp.rm(incompleteOmpPath, { force: true });
   }
   // Non-enumerable so the array still behaves exactly like a plain row list
   // for every existing caller (map/filter/JSON of the rows is unaffected).
@@ -2632,6 +2675,7 @@ function resumeCommandFor(source, sessionId) {
   // Grok Build: `grok --resume <session-id>` (also accepts a title). The
   // command must still be run from the session's project_ref cwd.
   if (source === "grok") return `grok --resume ${id}`;
+  if (source === "omp") return `omp --resume ${id}`;
   return null;
 }
 
@@ -2973,6 +3017,8 @@ module.exports = {
   scanZcodeSessions,
   scanOpencodeSessions,
   scanKimiSessions,
+  scanOmpSessions,
+  scanOmpSession,
   buildSessionAnalytics,
   summarizeSessions,
   listSessionsForBrowser,

package/src/lib/usage-limits.js

@@ -35,6 +35,7 @@ const { fetchDevinLimits } = require("./devin-limits");
 const { fetchQoderLimits, fetchQoderCnLimits } = require("./qoder-limits");
 const { fetchArkCodingPlanLimits } = require("./ark-coding-plan-limits");
 const { fetchArkAgentPlanLimits } = require("./ark-agent-plan-limits");
+const { fetchWorkbuddyLimits, fetchWorkbuddyAiLimits, selectWorkbuddyLimits } = require("./workbuddy-limits");
 const { fetchProviderServiceStatus } = require("./provider-status");
 const { resolveKimiProfile } = require("./kimi-profile");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
@@ -749,13 +750,12 @@ function normalizeCursorUsageSummary(body) {
 }
 
 /**
- * Cursor's Sand "Grok Bot" RPC reports the shared Super weekly pool (same
- * reset and about the same percent as Grok billing's creditUsagePercent).
- * Once the Grok card lists a Grok Bot product share, that Sand bar would
- * show the whole pool a second time under Cursor. Hide it only in that
- * case. A real separate Sand quota (different reset, or a percent more than
- * a point away from the pool) stays. Accounts with no Grok Bot product row
- * keep the Sand bar.
+ * Cursor's Sand RPC reports Grok Bot usage. grok.com shows that as a weekly
+ * Grok Bot limit of its own, separate from the SuperGrok pool and with its own
+ * reset, so the Sand bar normally stays. It is hidden only when it is
+ * indistinguishable from the Grok pool, so the same numbers are not drawn
+ * twice: Grok billing lists a GrokBot product share, and the two windows reset
+ * at the same instant and sit within a point of each other.
  */
 function cursorSandDuplicatesGrokPool(cursor, grok) {
   const sand = cursor?.quaternary_window;
@@ -4107,7 +4107,7 @@ async function fetchUsageLimitsUncached({
     : null;
 
   const providerFetch = withFetchTimeout(fetchImpl, providerTimeoutMs);
-  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode, opencodeGoRaw, qoder, qoderCn, codingPlan, agentPlan, commandCodeRaw, devinRaw, claudeServiceStatus] = await Promise.all([
+  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode, opencodeGoRaw, qoder, qoderCn, codingPlan, agentPlan, commandCodeRaw, devinRaw, workbuddy, workbuddyAi, claudeServiceStatus] = await Promise.all([
     claudeToken && !freshClaudeCache && !claudeRetryAtMs
       ? withProviderTimeout(fetchClaudeUsageLimits(claudeToken, { fetchImpl: providerFetch, maxAttempts: 1 }), "Claude", providerTimeoutMs).then(
           (value) => ({ status: "fulfilled", value }),
@@ -4232,6 +4232,13 @@ async function fetchUsageLimitsUncached({
         (value) => ({ status: "fulfilled", value }),
         (reason) => ({ status: "rejected", reason }),
       ),
+    // WorkBuddy CN and WorkBuddy AI are separate editions. Each one calls only
+    // its own local authenticated billing proxy. Abort closes the IPC socket
+    // when the provider budget expires. Reward credits are not a plan window.
+    withAbortableProviderTimeout((signal) => fetchWorkbuddyLimits({ home, env, fetchImpl: providerFetch, signal }), "WorkBuddy", providerTimeoutMs)
+      .catch((reason) => ({ configured: true, error: reason?.message || "Unknown error" })),
+    withAbortableProviderTimeout((signal) => fetchWorkbuddyAiLimits({ home, env, fetchImpl: providerFetch, signal }), "WorkBuddy AI", providerTimeoutMs)
+      .catch((reason) => ({ configured: true, error: reason?.message || "Unknown error" })),
     // Public status-page probe (fail-soft, own 5-min cache in provider-status.js).
     // Only probed for configured accounts — without a token the Claude section
     // never renders, so the reading would have nowhere to go.
@@ -4498,6 +4505,9 @@ async function fetchUsageLimitsUncached({
     qoderCn: withPlanLabel(qoderCn, qoderCn?.plan_label, "Qoder CN"),
     codingPlan: withPlanLabel(codingPlan, codingPlan?.plan_label, "Ark Coding Plan"),
     agentPlan: withPlanLabel(agentPlan, agentPlan?.plan_label, "Ark Agent Plan"),
+    // WorkBuddy preserves provider English names and official edition labels
+    // verbatim (including Free, STANDARD and Pro-Trial).
+    workbuddy: selectWorkbuddyLimits(workbuddy, workbuddyAi),
   };
 
   for (const [providerName, provider] of Object.entries(data)) {
@@ -4587,4 +4597,6 @@ module.exports = {
   fetchCommandcodeLimits,
   fetchQoderLimits,
   fetchQoderCnLimits,
+  fetchWorkbuddyLimits,
+  fetchWorkbuddyAiLimits,
 };

package/src/lib/workbuddy-ipc.js

@@ -0,0 +1,191 @@
+"use strict";
+
+// WorkBuddy's authenticated local proxy. The ticket proves both peers; the
+// desktop daemon adds its own access token to relative billing requests.
+const fs = require("node:fs");
+const path = require("node:path");
+const net = require("node:net");
+const crypto = require("node:crypto");
+
+const UNAVAILABLE = "Start WorkBuddy and sign in to read its subscription quota.";
+const MAX_FRAME_BYTES = 1024 * 1024;
+const BILLING_PATHS = new Set([
+  "/billing/meter/get-user-resource-summary",
+  "/billing/meter/get-user-resource-paid-packages",
+  "/billing/meter/get-user-resource-free-packages",
+]);
+
+function readWorkbuddyIpcDiscovery(workbuddyHome) {
+  if (!workbuddyHome) return null;
+  let fd;
+  try {
+    fd = fs.openSync(path.join(workbuddyHome, "wbipc", "endpoint.json"),
+      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > 16384 || (process.platform !== "win32"
+      && (stat.uid !== process.getuid() || (stat.mode & 0o077) !== 0))) {
+      throw new Error("Untrusted discovery file.");
+    }
+    const value = JSON.parse(fs.readFileSync(fd, "utf8"));
+    if (typeof value.ticket !== "string" || !/^[\w-]{43}$/.test(value.ticket)
+      || typeof value.endpoint !== "string") throw new Error("Invalid discovery file.");
+    if (process.platform === "win32") {
+      if (!/^\\\\\.\\pipe\\wbipc-[\w-]+$/.test(value.endpoint)) throw new Error("Invalid pipe.");
+    } else {
+      if (!path.isAbsolute(value.endpoint)) throw new Error("Invalid socket.");
+      const socket = fs.lstatSync(value.endpoint);
+      if (!socket.isSocket() || socket.uid !== process.getuid() || (socket.mode & 0o077) !== 0) {
+        throw new Error("Untrusted socket.");
+      }
+    }
+    return { endpoint: value.endpoint, ticket: value.ticket };
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
+    // Never expose discovery contents, tickets, paths or JSON parser excerpts.
+    throw new Error("WorkBuddy local connection information is unavailable.");
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+function computeProof(ticket, role, endpoint, clientNonce, serverNonce) {
+  const parts = [];
+  for (const field of [role === "server" ? "wbipc-s" : "wbipc-c", "1", endpoint, clientNonce, serverNonce]) {
+    const bytes = Buffer.from(field, "utf8");
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(bytes.length);
+    parts.push(length, bytes);
+  }
+  return crypto.createHmac("sha256", ticket).update(Buffer.concat(parts)).digest("base64url");
+}
+
+function openWorkbuddyIpc({ discovery, signal, timeoutMs = 12000, connectImpl = net.createConnection }) {
+  return new Promise((resolve, reject) => {
+    const { endpoint, ticket } = discovery;
+    const clientNonce = crypto.randomBytes(16).toString("base64url");
+    const pending = new Map();
+    let socket;
+    let phase = "challenge";
+    let channel;
+    let nextId = 1;
+    let buffer = Buffer.alloc(0);
+    let closed = false;
+    const timer = setTimeout(() => fail(new Error("WorkBuddy quota request timed out.")), timeoutMs);
+    const onAbort = () => fail(new Error("WorkBuddy quota request was cancelled."));
+
+    function fail(error) {
+      if (closed) return;
+      closed = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(error);
+      for (const handlers of pending.values()) handlers.reject(error);
+      pending.clear();
+      socket?.destroy();
+    }
+    function send(packet) {
+      socket.write(JSON.stringify(packet) + "\n");
+    }
+    function rpc(method, params, mode) {
+      if (closed) return Promise.reject(new Error(UNAVAILABLE));
+      return new Promise((resolve, reject) => {
+        const id = nextId++;
+        pending.set(id, { resolve, reject });
+        send({ jsonrpc: "2.0", id, method, params, ...(mode ? { mode } : {}) });
+      });
+    }
+    const client = {
+      close: () => fail(new Error("WorkBuddy local connection closed.")),
+      async postBilling(apiPath, body) {
+        if (!BILLING_PATHS.has(apiPath)) throw new Error("Unsupported WorkBuddy quota request.");
+        const response = await rpc(`${channel}/http.fetch`, {
+          method: "POST",
+          path: apiPath,
+          headers: { "content-type": "application/json", accept: "application/json" },
+          body_b64: Buffer.from(JSON.stringify(body)).toString("base64"),
+        }, "call");
+        if (response?.status === 401 || response?.status === 403) {
+          const error = new Error("WorkBuddy sign-in expired.");
+          error.code = "AUTH_EXPIRED";
+          throw error;
+        }
+        if (response?.status !== 200) throw new Error("WorkBuddy quota request failed.");
+        try {
+          if (typeof response.body_b64 !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(response.body_b64)) {
+            throw new Error("Invalid body.");
+          }
+          return JSON.parse(Buffer.from(response.body_b64, "base64").toString("utf8"));
+        } catch {
+          throw new Error("WorkBuddy quota response was malformed.");
+        }
+      },
+    };
+    function onPacket(packet) {
+      if (!packet || typeof packet !== "object") throw new Error("Invalid packet.");
+      if (phase === "challenge" && packet.type === "session_challenge" && packet.protocol === 1) {
+        if (typeof packet.server_nonce !== "string" || !/^[\w-]{16,128}$/.test(packet.server_nonce)
+          || typeof packet.server_proof !== "string") throw new Error("Invalid challenge.");
+        const expected = Buffer.from(computeProof(ticket, "server", endpoint, clientNonce, packet.server_nonce));
+        const actual = Buffer.from(packet.server_proof);
+        if (expected.length !== actual.length || !crypto.timingSafeEqual(expected, actual)) {
+          throw new Error("Invalid server proof.");
+        }
+        phase = "ack";
+        send({ type: "session_prove", client_proof: computeProof(ticket, "client", endpoint, clientNonce, packet.server_nonce) });
+      } else if (phase === "ack" && packet.type === "session_hello_ack" && packet.protocol === 1
+        && Array.isArray(packet.pipes) && packet.pipes.includes("wb.request")) {
+        phase = "ready";
+        rpc("broker/GetPipe", { pipe: "wb.request" }).then((result) => {
+          if (closed) return;
+          if (result?.channel !== "c:wb.request" || !Array.isArray(result.methods)
+            || !result.methods.includes("http.fetch")) {
+            fail(new Error("WorkBuddy billing proxy is unavailable."));
+            return;
+          }
+          channel = result.channel;
+          resolve(client);
+        }, () => fail(new Error(UNAVAILABLE)));
+      } else if (phase === "ready" && packet.jsonrpc === "2.0" && pending.has(packet.id)) {
+        const handlers = pending.get(packet.id);
+        pending.delete(packet.id);
+        if (packet.error) handlers.reject(new Error("WorkBuddy local quota request was rejected."));
+        else handlers.resolve(packet.result);
+      } else {
+        throw new Error("Unexpected packet.");
+      }
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) { onAbort(); return; }
+    try {
+      socket = connectImpl(endpoint);
+      socket.on("connect", () => send({
+        type: "session_hello", protocol_min: 1, protocol_max: 1,
+        client_nonce: clientNonce,
+        ticket_id: crypto.createHash("sha256").update(ticket, "utf8").digest("hex").slice(0, 16),
+        client: { kind: "tokentracker", id: "subscription-quota", version: "1" },
+      }));
+      socket.on("data", (chunk) => {
+        if (closed) return;
+        buffer = Buffer.concat([buffer, chunk]);
+        if (buffer.length > MAX_FRAME_BYTES) { fail(new Error("WorkBuddy quota response was too large.")); return; }
+        try {
+          let index;
+          while ((index = buffer.indexOf(10)) >= 0 && !closed) {
+            const line = buffer.subarray(0, index);
+            buffer = buffer.subarray(index + 1);
+            if (line.length) onPacket(JSON.parse(line.toString("utf8")));
+          }
+        } catch {
+          fail(new Error("WorkBuddy local connection authentication or protocol failed."));
+        }
+      });
+      socket.on("error", () => fail(new Error(UNAVAILABLE)));
+      socket.on("close", () => fail(new Error(UNAVAILABLE)));
+      socket.on("end", () => fail(new Error(UNAVAILABLE)));
+    } catch {
+      fail(new Error(UNAVAILABLE));
+    }
+  });
+}
+
+module.exports = { UNAVAILABLE, readWorkbuddyIpcDiscovery, openWorkbuddyIpc };