sigrank 0.0.188 → 0.0.189

package/README.md

@@ -342,6 +342,7 @@ All adapters are token-only (no message content, no cost fields, no credentials)
 | Amp                | ✅ `~/.local/share/amp/threads`                | Native 4-pillar; per-message                                                                                      |
 | Kimi               | ✅ `~/.kimi/sessions`                          | Native 4-pillar; `StatusUpdate` lines only                                                                        |
 | pi-agent           | ✅ `~/.pi/agent/sessions`                      | Native 4-pillar; per-message JSONL                                                                                |
+| oh-my-pi (`omp`)   | ✅ `~/.omp/agent/sessions` (recursive, incl. nested subagent transcripts) | Native 4-pillar from `.message.usage` on `type:"message"` entries (`cacheWrite`→`cacheCreate`); **`reasoningTokens` is already inside `output`** — never added, or it double-counts; `usage.cost` reuses the same four key names for USD floats and is dropped; dedup by (session header `id`, entry `id`). Separate harness from pi-agent |
 | OpenClaw           | ✅ `~/.openclaw`                               | Native 4-pillar; per-message JSONL                                                                                |
 | Droid              | ✅ `~/.factory/sessions/*.settings.json`       | Native 4-pillar; `thinking_tokens`→output                                                                         |
 | Codebuff           | ✅ `~/.config/manicode`                        | Native 4-pillar; `chat-messages.json`                                                                             |
@@ -382,19 +383,19 @@ All adapters are token-only (no message content, no cost fields, no credentials)
 ## Dev / test
 
 ```bash
-node test.mjs          # 13 test groups, 200 assertions (no network, no fs writes)
+node test.mjs          # 14 test groups, 313 assertions (no network; fs writes confined to OS-tmpdir fixtures)
 node sign.test.mjs     # ed25519 signing + canon parity
 node index.mjs         # stdio MCP server directly (pipe to MCP client)
 ```
 
-Tests verify (13 groups, 200 assertions):
+Tests verify (14 groups, 313 assertions):
 
 - `rank_paste` canon: MO§ES `(1251211, 11296121, 128196310, 2555179769)` → Υ 18436.98 · TRANSMITTER
 - `submit_paste` preview (no codename) + POST shape (injected fetch, no live writes)
 - `tokenpull` dedup, window slicing, 4-window pillars (mock adapter)
 - `tokenpull_submit` all 4 windows POST, sha256 hash, ddmmyy stamp
 - `tokenpullCodex` io_ratio conversion per-window
-- Adapter registry (15 platforms) + per-adapter shape contracts
+- Adapter registry (16 platforms) + per-adapter shape contracts
 - `rank_windows` 4-window paste scoring, partial input, no-network
 - `watch_tokenpull` cascade snapshot, interval_s, submit path
 - `enroll` posts identity (public key only), maps 201 enrolled + 410 code_invalid
@@ -414,7 +415,7 @@ Tests verify (13 groups, 200 assertions):
 | `tui.mjs`       | Full tabbed TUI: Dashboard / Trends / Compare / Board / Watch / Connect |
 | `cascade.mjs`   | Pure cascade math (Υ, SNR, leverage, velocity, 10xDEV, class)           |
 | `tokenpull.mjs` | On-device log scanner — Claude, Codex, multi-platform                   |
-| `adapters.mjs`  | Platform adapter registry (15+ platforms)                               |
+| `adapters.mjs`  | Platform adapter registry (16+ platforms)                               |
 | `tools.mjs`     | MCP tool table + dispatcher                                             |
 | `connect.mjs`   | Connect-code enrollment + device identity                               |
 | `keystore.mjs`  | Local key management (paste-keys, not API keys)                         |

package/adapters/index.mjs

@@ -24,6 +24,7 @@
  *      tokenpullCodex(); adapters that yield native 4-pillar via messages() go through
  *      tokenpull() directly. The split happens at the tokenpullAny() routing layer.)
  *   - Reasoning / thinking tokens → folded into `output` (they are output-side spend)
+ *     EXCEPTION: omp already reports reasoningTokens INSIDE output — see adapter #16
  *   - No cache-creation data available → cacheCreate: 0 + adapter sets `estimated: true`
  *   - Cost fields (USD) → NEVER used or forwarded (SigRank scores cost efficiency from
  *     token ratios, not from dollar amounts — cost efficiency is derived, not ingested)
@@ -875,6 +876,68 @@ export const otherAdapter = {
   },
 };
 
+// ── 16. oh-my-pi (omp) ───────────────────────────────────────────────────────
+// ~/.omp/agent/sessions/<bucket>/<timestamp>_<sessionId>/<name>.jsonl (recursive)
+// NOT pi-agent (#4): oh-my-pi forked from pi long ago and is a separate harness
+// with its own on-disk format. Line 1 is a fixed-width 256-byte {"type":"title"}
+// slot; line 2 is {"type":"session"} and carries the session `.id`. Neither line
+// holds usage. Other observed `.type` values (all usage-free): custom,
+// custom_message, model_change, thinking_level_change, session_init, credential_pin.
+// Usage lives at `.message.usage` on `.type === "message"` entries:
+//   { input, output, cacheRead, cacheWrite, totalTokens, reasoningTokens, cost:{…} }
+// Native 4-pillar (no estimation): input→input, output→output,
+// cacheWrite→cacheCreate, cacheRead→cacheRead.
+// TRAP 1 — reasoningTokens is ALREADY INSIDE output. Do NOT fold it in. Every other
+//   adapter here folds reasoning into output, so the reflex is wrong for omp; adding
+//   it double-counts. Proof: totalTokens === input+output+cacheRead+cacheWrite
+//   exactly, and reasoningTokens is always ≤ output.
+// TRAP 2 — usage.cost reuses the SAME four key names (input/output/cacheRead/
+//   cacheWrite, plus total) for USD floats. Read the four counts straight off
+//   `usage`; never descend into `cost`. Cost fields are never forwarded (file header).
+// Nested subagent transcripts (critic.jsonl beside critic/__advisor.jsonl) are real
+// operator work and ARE counted — same policy as Claude's `subagents/`.
+// Dedup key is (session header `.id`, entry top-level `.id`) — `.message` has no id.
+// File cap: a real omp tree runs to 20k+ transcripts, past walkFiles' 10_000 default,
+// which would silently drop half the operator's tokens — pass an explicit cap.
+const OMP_MAX_FILES = 500_000;
+export const ompAdapter = {
+  platform: "omp",
+  defaultRoot: () => join(homedir(), ".omp", "agent", "sessions"),
+  async *messages(root) {
+    for (const r of roots("OMP_DATA_DIR", root)) {
+      for await (const path of walkFiles(r, isJsonl, { n: 0 }, OMP_MAX_FILES)) {
+        const text = await readUtf8(path);
+        let sid = null;
+        for (const [ev] of parseJsonl(text, path)) {
+          if (!ev) continue;
+          if (ev.type === "session") {
+            sid = ev.id || null; // line-2 header: session half of the dedup key
+            continue;
+          }
+          if (ev.type !== "message") continue;
+          const u = ev.message && ev.message.usage;
+          if (!u) continue;
+          const input = Number(u.input || 0);
+          const output = Number(u.output || 0); // reasoningTokens ALREADY inside — TRAP 1
+          const cacheCreate = Number(u.cacheWrite || 0);
+          const cacheRead = Number(u.cacheRead || 0);
+          if (input + output + cacheCreate + cacheRead === 0) continue;
+          yield {
+            id: ev.id || null,
+            sid,
+            ts: ev.timestamp || null,
+            input,
+            output,
+            cacheCreate,
+            cacheRead,
+            file: path,
+          };
+        }
+      }
+    }
+  },
+};
+
 // ── Registry ──────────────────────────────────────────────────────────────────
 /** All non-Claude, non-Codex adapters keyed by platform ID. */
 export const ADAPTERS = {
@@ -893,6 +956,7 @@ export const ADAPTERS = {
   hermes: hermesAdapter,
   devin: devinAdapter,
   other: otherAdapter,
+  omp: ompAdapter,
 };
 
 export const ALL_PLATFORMS = Object.keys(ADAPTERS).concat(["claude", "codex"]);

package/lib/constants.mjs

@@ -62,6 +62,8 @@ export const TOKSCALE_CLIENT_MAP = {
   opencode: "opencode",
   openclaw: "openclaw",
   pi: "pi",
+  omp: "omp",
+  "oh-my-pi": "omp",
   cursor: "other",
   roocode: "other",
   mux: "other",
@@ -87,6 +89,23 @@ export const TOKSCALE_CLIENT_MAP = {
   synthetic: null,
 };
 
+/**
+ * Platforms whose local data tokscale CANNOT see, so `tokscale models --json`
+ * never lists them as an active client. pullActivePlatforms() auto-detect must
+ * probe these directly or their cascade row can never appear, even with GBs of
+ * native local telemetry (that was exactly the omp bug: tokscale reports
+ * claude/codex/copilot/gemini/grok/kimi/kiro/opencode/pi and nothing else, so
+ * a tokscale-detected machine silently dropped oh-my-pi entirely).
+ *
+ * The adapter pull itself filters out platforms with no data, so probing a
+ * platform the operator doesn't use costs one cheap missing-directory walk.
+ *
+ * As of 2026-08-08: oh-my-pi. Delete an entry once tokscale reports that client
+ * (TOKSCALE_CLIENT_MAP already maps the `omp` / `oh-my-pi` client names for
+ * when that happens).
+ */
+export const TOKSCALE_BLIND_PLATFORMS = ["omp"];
+
 /**
  * The "actually on the board" predicate. A submission is ranked only when the
  * server returns HTTP ok AND verification_tier === "verified" AND persisted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.0.188",
+  "version": "0.0.189",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",

package/presentation/cli.mjs

@@ -782,10 +782,17 @@ async function runCompare({ platform = "claude" } = {}) {
 const WATCH_WINDOWS = ["7d", "30d", "90d", "all"];
 
 // Detect which platforms have real local data (input+output > 0 in any window) via tokenpull.
-// Returns an array of pull results (the same shape tokenpullAny yields), one per active platform.
-async function detectActivePulls() {
-  // Unified: one loader for me / watch / the TUI Dashboard (was a separate tokenpullAny loop).
-  return pullActivePlatforms();
+// Returns an array of pull results (the same shape tokenpullAny yields), one per active
+// platform, through the shared loader used by `me` / `watch` / the TUI Dashboard.
+//
+// `platform` scopes the PULL, not just the render: the watcher re-pulls every `refresh`
+// seconds (default 30) and an unscoped auto-detect also probes the tokscale-blind ~10 GiB
+// oh-my-pi tree (~46s), so `watch --platform claude` used to scan everything and then
+// display one row — scan longer than refresh interval, permanently saturated.
+// null / '' / 'all' still mean "everything", keeping withTokscaleBlind's omp row.
+export async function detectActivePulls(platform, opts = {}) {
+  const scoped = platform && platform !== "all" ? [platform] : undefined;
+  return pullActivePlatforms({ platforms: scoped }, opts).catch(() => []);
 }
 
 async function runWatch({
@@ -815,9 +822,9 @@ async function runWatch({
   write(HIDE_CURSOR);
 
   const draw = async () => {
-    // Re-detect each tick so a platform that just started writing logs appears automatically.
-    let pulls = await detectActivePulls().catch(() => []);
-    if (platFilter) pulls = pulls.filter((d) => d.platform === platFilter);
+    // Re-pull each tick so a platform that just started writing logs appears automatically.
+    // Scoped by platFilter, so a focused watch never scans platforms it cannot display.
+    const pulls = await detectActivePulls(platFilter);
 
     if (lines > 0) write(CURSOR_UP(lines));
 
@@ -961,8 +968,11 @@ async function runSigRank() {
   writeln(`  ${gold("⊙ SigRank")}  ${bold("Operator Dashboard")}`);
   writeln(`  ${dim("reading local data…")}`);
 
+  // ../tokenpull.mjs — cli.mjs lives in presentation/, so "./tokenpull.mjs" resolved to
+  // presentation/tokenpull.mjs (nonexistent) and threw ERR_MODULE_NOT_FOUND, taking the
+  // whole dashboard read down. Matches the `../adapters.mjs` static import above.
   const { tokenpullAny, freshVerifierPillars } =
-    await import("./tokenpull.mjs");
+    await import("../tokenpull.mjs");
 
   // Local sources first (fast) — board fetch with 5s timeout runs in parallel
   const boardPromise = Promise.race([
@@ -971,7 +981,7 @@ async function runSigRank() {
   ]);
 
   // FIX A1-CLI (2026-06-27): verifiers (ccusage/tokscale/tokendash) are fetched
-  // ON-DEMAND for ACTIVE platforms only — not synchronously for all 15 platforms
+  // ON-DEMAND for ACTIVE platforms only — not synchronously for every ALL_PLATFORMS entry
   // upfront (which blocked Dashboard paint up to ~40s, same class of bug as TUI
   // FIX A1). The sync ccusagePillars()/tokscalePillars()/tokenDashPillars() loop
   // over ALL_PLATFORMS is replaced by parallel freshVerifierPillars() calls after

package/presentation/tui.mjs

@@ -644,8 +644,10 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
   emit(`  ${dim("·".repeat(Math.max(0, Math.min(w - 4, narrow ? 96 : 114))))}`);
 
   if (active.length === 0) {
+    // Count is derived from the registry — a hardcoded number drifts every time an
+    // adapter is added (it read "14 platforms" while ALL_PLATFORMS held 17).
     emit(
-      `  ${dim("  reading token logs… (14 platforms, ~5s · press [R] to refresh)")}`,
+      `  ${dim(`  reading token logs… (${ALL_PLATFORMS.length} platforms, ~5s · press [R] to refresh)`)}`,
     );
   }
 
@@ -1586,7 +1588,10 @@ function renderConnect(id, codeBuf = "", msg = "") {
 // null/'all'/'all-windows' means "everything". Each row is a (platform, window) cascade cell:
 // Υ Yield + SNR/Lev/Vel/class. Iterates active platforms (input+output > 0 in any window).
 async function renderWatch(platform = "all", win = "all-windows") {
-  const { tokenpullAny } = await import("./tokenpull.mjs");
+  // ../tokenpull.mjs — this file lives in presentation/, so "./tokenpull.mjs" resolved
+  // to presentation/tokenpull.mjs (nonexistent) and threw ERR_MODULE_NOT_FOUND for
+  // every row. Matches the static `../tokenpull.mjs` import at the top of this file.
+  const { tokenpullAny } = await import("../tokenpull.mjs");
   const ALL_PLATFORMS = [
     "claude",
     "codex",
@@ -1602,6 +1607,7 @@ async function renderWatch(platform = "all", win = "all-windows") {
     "copilot",
     "openclaw",
     "pi",
+    "omp",
   ];
   const platFilter = platform && platform !== "all" ? platform : null;
   const winFilter = win && win !== "all-windows" ? win : null;
@@ -2064,7 +2070,7 @@ export async function runTui({
     dashData = { active: [], _loading: true };
     await redraw();
     // FIX 0: progressive Dashboard load — claude first (fast), render it, THEN fill
-    // the other 13 platforms in the background + redraw. The user sees their cascade
+    // the remaining ALL_PLATFORMS entries in the background + redraw. The user sees their cascade
     // within ~1 read instead of a 7s blank "loading dashboard…".
     dashData = await loadDashboardData().catch((e) => {
       status = `dashboard error: ${e.message}`;
@@ -2481,6 +2487,7 @@ export async function runTui({
         "copilot",
         "openclaw",
         "pi",
+        "omp",
       ];
       if (k === "p" && (activeTab === 2 || activeTab === 4)) {
         if (activeTab === 2) {

package/submit/index.mjs

@@ -25,6 +25,7 @@ const PLATFORM_ENUM = new Set([
   "chatgpt",
   "gemini",
   "pi",
+  "omp",
   "codex",
   "multi",
   "other",

package/tools/index.mjs

@@ -9,7 +9,10 @@
 import { ALL_PLATFORMS } from "../adapters/index.mjs";
 import { execFileAsync } from "./_helpers.mjs";
 import { buildFetch, DEFAULT_API_BASE, DEFAULT_FETCH_TIMEOUT } from "./_helpers.mjs";
-import { TOKSCALE_CLIENT_MAP } from "../lib/constants.mjs";
+import {
+  TOKSCALE_CLIENT_MAP,
+  TOKSCALE_BLIND_PLATFORMS,
+} from "../lib/constants.mjs";
 
 import { TOOL_DEF as rankPasteTool, handleRankPaste } from "./rank-paste.mjs";
 import { TOOL_DEF as getLeaderboardTool, handleGetLeaderboard } from "./get-leaderboard.mjs";
@@ -98,10 +101,22 @@ async function _tokscaleDetectClients() {
   return [...clients];
 }
 
-/** Pull a specific set of platforms in parallel, filter to active ones. */
+/** Detection targets = what tokscale saw ∪ the platforms tokscale is blind to.
+ *  Without the union, an operator with GBs of oh-my-pi telemetry gets no omp row
+ *  on any machine where tokscale succeeds, because tokscale never names that
+ *  client. Pure + exported so the union is unit-testable without shelling out. */
+export function withTokscaleBlind(detected) {
+  return [...new Set([...(detected || []), ...TOKSCALE_BLIND_PLATFORMS])];
+}
+
+/** Pull a specific set of platforms in parallel, filter to active ones.
+ *  opts.callTool overrides the per-platform pull for tests (same opts-injection
+ *  convention as opts.adapter in pullByPlatform) so the target-set logic is
+ *  assertable without a real filesystem scan. */
 async function _pullExplicit(platforms, opts = {}) {
+  const pull = opts.callTool || callTool;
   const settled = await Promise.allSettled(
-    platforms.map((p) => callTool("tokenpull", { platform: p }, opts)),
+    platforms.map((p) => pull("tokenpull", { platform: p }, opts)),
   );
   const active = settled
     .filter((r) => r.status === "fulfilled" && r.value)
@@ -129,15 +144,17 @@ export async function pullActivePlatforms({ platforms } = {}, opts = {}) {
     return _pullExplicit(platforms, opts);
   }
   // Auto-detect: run tokscale once to discover all active clients, then pull
-  // only those. This is much faster than trying all 17 adapters (most fail
-  // silently on a machine that doesn't have that tool installed).
+  // only those (plus the tokscale-blind platforms). This is much faster than trying
+  // all adapters (most fail silently on a machine that doesn't have that tool).
   //
   // Flow: tokscale surfaces ALL clients → map to our platform names →
   // ccusage is primary for Claude (more accurate) → other platforms use
   // their adapters. Anything in tokscale NOT in ccusage gets included.
-  const detected = await _tokscaleDetectClients().catch(() => null);
+  // opts.detectClients overrides the tokscale probe for tests (no shelling out).
+  const detect = opts.detectClients || _tokscaleDetectClients;
+  const detected = await detect().catch(() => null);
   if (detected && detected.length > 0) {
-    return _pullExplicit(detected, opts);
+    return _pullExplicit(withTokscaleBlind(detected), opts);
   }
   // Fallback: tokscale not installed or failed → try all adapters (old behavior)
   return _pullExplicit(ALL_PLATFORMS, opts);