sigrank 0.19.0 → 1.0.2

package/tools/suggest-improvements.mjs

@@ -0,0 +1,168 @@
+/**
+ * tools/suggest-improvements.mjs — suggest_improvements tool.
+ */
+
+import { cascade, parsePillars } from "../analytics/cascade.mjs";
+import { SUGGEST_OUTPUT, ANNOTATIONS } from "./_schemas.mjs";
+import { MAX_INPUT, withParseWarnings } from "./_helpers.mjs";
+
+export const TOOL_DEF = {
+  name: "suggest_improvements",
+  description:
+    "Generates ranked, simulated improvement suggestions for your token cascade. Takes your 4 pillars, tests multiple improvement strategies (increase cache reads, reduce fresh input, increase output, optimize cache creation), simulates each with the canonical cascade engine, and returns them ranked by Υ yield impact. Each suggestion includes: the action, which pillar to change, how much to change it, the projected Υ after the change, the yield delta, the projected class tier, and a rationale. Also returns the single highest-impact change (best_single_change). Pure local math — no network, no submission. Use this after diagnose_cascade to get actionable next steps, then use simulate_change to fine-tune before committing. Accepts the same input formats as rank_paste.",
+  annotations: {
+    title: "Suggest improvements",
+    ...ANNOTATIONS.readOnlyHint,
+    ...ANNOTATIONS.idempotentHint,
+    ...ANNOTATIONS.openWorldHint,
+  },
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description:
+          'Token pillars — ccusage JSON or "input output cacheCreate cacheRead" (same format as rank_paste).',
+      },
+    },
+    required: ["text"],
+  },
+  outputSchema: SUGGEST_OUTPUT,
+};
+
+export async function handleSuggestImprovements(args) {
+  if (!args?.text)
+    throw new Error(
+      "suggest_improvements requires a non-empty `text` argument (token pillars).",
+    );
+  if (typeof args.text === "string" && args.text.length > MAX_INPUT) {
+    return {
+      status: "error",
+      reason: "input_too_large",
+      detail: `text exceeds ${MAX_INPUT} chars.`,
+    };
+  }
+
+  const p = parsePillars(args.text);
+  const current = withParseWarnings(p, cascade(p));
+  const { input: i, output: o, cacheCreate: cw, cacheRead: cr } = p;
+
+  // Generate candidate improvements, simulate each, rank by Υ impact
+  const candidates = [];
+
+  // Strategy 1: Increase cache reads (the #1 lever)
+  const crBoosts = cr > 0 ? [1.5, 2, 3, 5] : [];
+  for (const mult of crBoosts) {
+    const sim = cascade({ ...p, cacheRead: Math.round(cr * mult) });
+    if (sim.yield !== null) {
+      candidates.push({
+        action: `Increase cache reads by ${Math.round((mult - 1) * 100)}%`,
+        pillar: "cacheRead",
+        delta: `+${Math.round(cr * (mult - 1)).toLocaleString()}`,
+        simulated_yield: sim.yield,
+        yield_delta: Number((sim.yield - (current.yield ?? 0)).toFixed(2)),
+        class_after: sim.class,
+        rationale:
+          "Cache reads are the strongest Υ multiplier. More reuse = higher leverage = higher yield.",
+      });
+    }
+  }
+  // For zero-cache operators, suggest enabling caching with a starter amount
+  if (cr === 0 && cw === 0) {
+    const starterAmounts = [
+      Math.round(i * 10),
+      Math.round(i * 50),
+      Math.round(i * 100),
+    ];
+    for (const amt of starterAmounts) {
+      const sim = cascade({
+        ...p,
+        cacheCreate: Math.round(amt * 0.5),
+        cacheRead: amt,
+      });
+      if (sim.yield !== null && sim.yield > 0) {
+        candidates.push({
+          action: `Enable caching with ${amt.toLocaleString()} cache reads`,
+          pillar: "cacheRead",
+          delta: `+${amt.toLocaleString()}`,
+          simulated_yield: sim.yield,
+          yield_delta: Number((sim.yield - (current.yield ?? 0)).toFixed(2)),
+          class_after: sim.class,
+          rationale:
+            "You have no cache — enabling it unlocks the cascade. Start by reusing prior context.",
+        });
+      }
+    }
+  }
+
+  // Strategy 2: Reduce fresh input (Υ = Cr·O/I² — input is squared in the denominator)
+  const inputReductions = [0.9, 0.75, 0.5];
+  for (const mult of inputReductions) {
+    const newInput = Math.round(i * mult);
+    if (newInput < 1) continue;
+    const sim = cascade({ ...p, input: newInput });
+    if (sim.yield !== null) {
+      candidates.push({
+        action: `Reduce fresh input by ${Math.round((1 - mult) * 100)}%`,
+        pillar: "input",
+        delta: `-${Math.round(i * (1 - mult)).toLocaleString()}`,
+        simulated_yield: sim.yield,
+        yield_delta: Number((sim.yield - (current.yield ?? 0)).toFixed(2)),
+        class_after: sim.class,
+        rationale:
+          "Input is squared in the Υ denominator (Υ = Cr·O/I²). Reducing input has a quadratic payoff.",
+      });
+    }
+  }
+
+  // Strategy 3: Increase output
+  const outputBoosts = [1.25, 1.5, 2];
+  for (const mult of outputBoosts) {
+    const sim = cascade({ ...p, output: Math.round(o * mult) });
+    if (sim.yield !== null) {
+      candidates.push({
+        action: `Increase output by ${Math.round((mult - 1) * 100)}%`,
+        pillar: "output",
+        delta: `+${Math.round(o * (mult - 1)).toLocaleString()}`,
+        simulated_yield: sim.yield,
+        yield_delta: Number((sim.yield - (current.yield ?? 0)).toFixed(2)),
+        class_after: sim.class,
+        rationale:
+          "Output is a linear multiplier in Υ. More output per session = higher yield.",
+      });
+    }
+  }
+
+  // Strategy 4: Optimize cache creation (reduce if over-committing)
+  if (cw > o * 10) {
+    const sim = cascade({ ...p, cacheCreate: Math.round(o * 5) });
+    if (sim.yield !== null) {
+      candidates.push({
+        action: "Reduce cache creation to 5× output",
+        pillar: "cacheCreate",
+        delta: `-${Math.round(cw - o * 5).toLocaleString()}`,
+        simulated_yield: sim.yield,
+        yield_delta: Number((sim.yield - (current.yield ?? 0)).toFixed(2)),
+        class_after: sim.class,
+        rationale:
+          "You're over-committing cache (cw >> output). Trimming to a healthy ratio reduces cost without hurting yield.",
+      });
+    }
+  }
+
+  // Sort by yield_delta descending, take top 8
+  candidates.sort((a, b) => b.yield_delta - a.yield_delta);
+  const top = candidates
+    .slice(0, 8)
+    .map((c, idx) => ({ rank: idx + 1, ...c }));
+
+  const best = top[0];
+  return {
+    suggestions: top,
+    current_yield: current.yield,
+    current_class: current.class,
+    best_single_change: best
+      ? `${best.action} (Υ ${current.yield} → ${best.simulated_yield}, +${best.yield_delta} yield, class ${best.class_after})`
+      : "No improvements found — your cascade is already optimized.",
+  };
+}

package/tools/tokenpull-compare.mjs

@@ -0,0 +1,123 @@
+/**
+ * tools/tokenpull-compare.mjs — tokenpull_compare tool.
+ */
+
+import { cascade } from "../analytics/cascade.mjs";
+import { ALL_PLATFORMS } from "../adapters/index.mjs";
+import { COMPARE_OUTPUT, ANNOTATIONS } from "./_schemas.mjs";
+import { pullByPlatform } from "./_helpers.mjs";
+import { _ccusagePillars, _tokenDashPillars, _tokscalePillars } from "./_verifiers.mjs";
+
+export const TOOL_DEF = {
+  name: "tokenpull_compare",
+  description:
+    "Pull token usage from ALL four local sources in parallel — tokenpull (JSONL canon), ccusage CLI, token-dashboard SQLite, and tokscale report — and return them side-by-side with delta % vs tokenpull as the baseline. Also computes the cascade (Υ, SNR, Leverage, class) for each source so you can see how each verifier scores. Useful for validating your numbers before submitting, or understanding discrepancies between tools. Claude only for token-dash; codex and others use tokenpull + ccusage + tokscale. Token-only, on-device.",
+  annotations: { title: "Compare token sources", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {
+      platform: {
+        type: "string",
+        enum: ALL_PLATFORMS,
+        description:
+          "platform to compare (default: claude). token-dash and App only available for claude.",
+      },
+    },
+  },
+  outputSchema: COMPARE_OUTPUT,
+};
+
+export async function handleTokenpullCompare(args, ctx) {
+  const platform = args?.platform || "claude";
+  const WINS = ["7d", "30d", "90d", "all"];
+
+  // Pull all four sources in parallel (verifiers are now async via execFile)
+  const [tpResult, ccPillars, tdPillars, tsPillars] = await Promise.all([
+    pullByPlatform(platform, ctx.opts).catch(() => null),
+    _ccusagePillars(platform).catch(() => null),
+    (platform === "claude"
+      ? _tokenDashPillars()
+      : Promise.resolve(null)
+    ).catch(() => null),
+    _tokscalePillars(platform).catch(() => null),
+  ]);
+
+  // Build tokenpull window lookup
+  const tpByWin = {};
+  for (const w of tpResult?.windows ?? []) tpByWin[w.window] = w.pillars;
+
+  // Helper: delta % vs tokenpull baseline
+  const delta = (val, base) =>
+    base > 0 ? +(((val - base) / base) * 100).toFixed(1) : null;
+
+  // Build per-source per-window comparison
+  const SOURCES = [
+    {
+      source: "tokenpull",
+      note: "JSONL deduped by msg id — canon source",
+      byWin: tpByWin,
+    },
+    {
+      source: "ccusage",
+      note: "ccusage CLI — monthly only",
+      byWin: ccPillars ?? {},
+    },
+    {
+      source: "token-dash",
+      note: "token-dashboard SQLite — all-time only",
+      byWin: tdPillars ?? {},
+    },
+    {
+      source: "tokscale",
+      note: "tokscale_report.json — all-time only",
+      byWin: tsPillars ?? {},
+    },
+  ];
+
+  const comparison = {};
+  for (const win of WINS) {
+    const baseP = tpByWin[win];
+    comparison[win] = SOURCES.filter((s) => s.byWin[win] != null).map((s) => {
+      const p = s.byWin[win];
+      const cas = cascade(p);
+      const entry = {
+        source: s.source,
+        note: s.note,
+        pillars: p,
+        cascade: {
+          yield: cas.yield,
+          snr: cas.snr,
+          leverage: cas.leverage,
+          velocity: cas.velocity,
+          dev10x: cas.dev10x,
+          class: cas.class,
+        },
+      };
+      if (s.source !== "tokenpull" && baseP) {
+        entry.delta_vs_tokenpull = {
+          input: delta(p.input, baseP.input),
+          output: delta(p.output, baseP.output),
+          cacheCreate: delta(p.cacheCreate, baseP.cacheCreate),
+          cacheRead: delta(p.cacheRead, baseP.cacheRead),
+        };
+      }
+      return entry;
+    });
+  }
+
+  // Sources available summary
+  const available = SOURCES.filter(
+    (s) => Object.keys(s.byWin).length > 0,
+  ).map((s) => s.source);
+
+  return {
+    platform,
+    estimated: tpResult?.estimated ?? false,
+    generatedAt: tpResult?.generatedAt ?? new Date().toISOString(),
+    sources_available: available,
+    sources_missing: SOURCES.map((s) => s.source).filter(
+      (s) => !available.includes(s),
+    ),
+    comparison,
+  };
+}

package/tools/tokenpull-submit.mjs

@@ -0,0 +1,235 @@
+/**
+ * tools/tokenpull-submit.mjs — tokenpull_submit tool.
+ */
+
+import { cascade } from "../analytics/cascade.mjs";
+import { narrate } from "../presentation/narrate.mjs";
+import { ALL_PLATFORMS } from "../adapters/index.mjs";
+import { SUBMIT_OUTPUT, ANNOTATIONS } from "./_schemas.mjs";
+import {
+  MAX_INPUT,
+  pullByPlatform,
+  uploadStamp,
+  WINDOW_TYPE,
+} from "./_helpers.mjs";
+import { TERMS_VERSION, PRIVACY_VERSION, isRankedAck } from "../lib/constants.mjs";
+
+export const TOOL_DEF = {
+  name: "tokenpull_submit",
+  description:
+    "Pull your LOCAL token usage from session logs AND publish it to the SigRank board in one call — the zero-paste flow. Reads the four canonical pillars (input, output, cacheCreate, cacheRead) per window from your local logs, computes the cascade, and submits each window to the board where it is re-scored server-side and tagged with the source platform. Requires a codename to publish; omit for a local preview only. Token-only — no prompt content is read or transmitted.",
+  annotations: {
+    title: "Pull and submit tokens",
+    ...ANNOTATIONS.destructiveHint,
+    ...ANNOTATIONS.idempotentHint,
+    ...ANNOTATIONS.openWorldHint,
+  },
+  inputSchema: {
+    type: "object",
+    properties: {
+      codename: {
+        type: "string",
+        description:
+          'Operator codename to publish under on the leaderboard (e.g. "Iron Lotus"). Required to submit — omit for local preview only.',
+      },
+      window: {
+        type: "string",
+        enum: ["7d", "30d", "90d", "all"],
+        description:
+          'Submit only this time window (default: all 4 windows). Use "7d" for recent activity or "all" for all-time ranking.',
+      },
+      platform: {
+        type: "string",
+        enum: [...ALL_PLATFORMS, "multi"],
+        description: `Source platform to pull from (default: claude). Supported: ${ALL_PLATFORMS.join(", ")}, multi. 'multi' = combined cascade summed across all locally-detected platforms (needs 2+ active). 'devin' reads from ~/.local/share/devin/cli/sessions.db (SQLite, all windows). 'other' reads from a user-supplied JSON file (set SIGRANK_OTHER_PATH). Each platform reads its own session logs locally.`,
+      },
+    },
+  },
+  outputSchema: SUBMIT_OUTPUT,
+};
+
+export async function handleTokenpullSubmit(args, ctx) {
+  // Pull local usage, then publish each window's CANONICAL pillars to the board
+  // (server re-scores). The board stays platform-agnostic via the 4 pillars; the
+  // source platform rides along as a tag. Conversion already happened in the adapter.
+  const codename = String(args?.codename || "").trim();
+  const platform = args?.platform || "claude";
+
+  // MULTI: same combined cross-platform cascade as submit_verified. Includes Devin
+  // (cloud, via tokscale). Aggregate every locally-detected platform's pillars per
+  // window and publish as platform='multi'.
+  if (platform === "multi") {
+    const detected = [];
+    for (const p of ALL_PLATFORMS) {
+      const r = await pullByPlatform(p, ctx.opts).catch(() => null);
+      const live =
+        r &&
+        (r.windows || []).some(
+          (w) =>
+            w.pillars.input +
+              w.pillars.output +
+              w.pillars.cacheCreate +
+              w.pillars.cacheRead >
+            0,
+        );
+      if (live) detected.push(r);
+    }
+    if (detected.length < 2) {
+      return {
+        platform: "multi",
+        codename: codename || undefined,
+        status: "skipped",
+        reason: "need_2_platforms",
+        detail: `multi needs 2+ active platforms; found ${detected.length} (${detected.map((d) => d.platform).join(", ") || "none"}).`,
+        windows: [],
+      };
+    }
+    const winKeys = args?.window ? [args.window] : ["7d", "30d", "90d", "all"];
+    const out = [];
+    for (const wk of winKeys) {
+      const sum = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+      let msgs = 0;
+      for (const d of detected) {
+        const w = (d.windows || []).find((x) => x.window === wk);
+        if (!w) continue;
+        sum.input += w.pillars.input || 0;
+        sum.output += w.pillars.output || 0;
+        sum.cacheCreate += w.pillars.cacheCreate || 0;
+        sum.cacheRead += w.pillars.cacheRead || 0;
+        msgs += w.messages || 0;
+      }
+      if (sum.input + sum.output + sum.cacheCreate + sum.cacheRead <= 0)
+        continue;
+      const c = cascade(sum);
+      const card = narrate(c, `${wk} multi`);
+      if (!codename) {
+        out.push({
+          window: wk,
+          pillars: sum,
+          cascade: c,
+          card,
+          submission: { status: "not_submitted", reason: "codename_required" },
+        });
+        continue;
+      }
+      const rawPaste = `${sum.input} ${sum.output} ${sum.cacheCreate} ${sum.cacheRead}`;
+      const windowType = WINDOW_TYPE[wk] || wk;
+      const stamp = uploadStamp({
+        codename,
+        window: windowType,
+        pillars: sum,
+        platform: "multi",
+      });
+      const res = await ctx.doFetch(`${ctx.apiBase}/api/v1/ingest-paste`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json",
+        },
+        body: JSON.stringify({
+          codename,
+          raw_paste: rawPaste,
+          window_type: windowType,
+          telemetry: { platform: { primary: "multi" } },
+          consent_acknowledged: true,
+          terms_version: TERMS_VERSION,
+          privacy_version: PRIVACY_VERSION,
+          ...stamp,
+        }),
+      });
+      let ack;
+      try {
+        ack = await res.json();
+      } catch {
+        ack = { status: "parse_error", httpStatus: res.status };
+      }
+      // Fix 4: was `ack?.ranked ?? ack?.accepted ?? false` — a looser predicate
+      // than the single-platform branch below, which would mark a non-persisted
+      // 202 as ranked. Now both branches use the shared isRankedAck() so every
+      // submit path agrees on what "ranked" means.
+      const ranked = isRankedAck(res, ack);
+      out.push({
+        window: wk,
+        pillars: sum,
+        cascade: c,
+        card,
+        submission: { ...stamp, httpStatus: res.status, ranked, ...ack },
+      });
+    }
+    return {
+      platform: "multi",
+      codename: codename || undefined,
+      sources: detected.map((d) => d.platform),
+      windows: out,
+    };
+  }
+
+  const pulled = await pullByPlatform(platform, ctx.opts);
+  const targets = args?.window
+    ? pulled.windows.filter((w) => w.window === args.window)
+    : pulled.windows;
+  const out = [];
+  for (const w of targets) {
+    const c = cascade(w.pillars);
+    const card = narrate(c, `${w.window} window`);
+    if (!codename) {
+      out.push({
+        window: w.window,
+        pillars: w.pillars,
+        cascade: c,
+        card,
+        submission: { status: "not_submitted", reason: "codename_required" },
+      });
+      continue;
+    }
+    // canonical pillars → "input output cacheCreate cacheRead" (the parser's 4-bare-number form)
+    const rawPaste = `${w.pillars.input} ${w.pillars.output} ${w.pillars.cacheCreate} ${w.pillars.cacheRead}`;
+    const windowType = WINDOW_TYPE[w.window] || w.window;
+    const stamp = uploadStamp({
+      codename,
+      window: windowType,
+      pillars: w.pillars,
+      platform: pulled.platform,
+    });
+    const res = await ctx.doFetch(`${ctx.apiBase}/api/v1/ingest-paste`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json",
+      },
+      body: JSON.stringify({
+        codename,
+        raw_paste: rawPaste,
+        window_type: windowType,
+        telemetry: { platform: { primary: pulled.platform } },
+        consent_acknowledged: true,
+        terms_version: TERMS_VERSION,
+        privacy_version: PRIVACY_VERSION,
+        ...stamp,
+      }),
+    });
+    let ack;
+    try {
+      ack = await res.json();
+    } catch {
+      ack = { status: "error", detail: `HTTP ${res.status} (non-JSON)` };
+    }
+    // ranked = actually on the board (verified + persisted), not just received — parity
+    // with submit_verified (submit/index.mjs). An unenrolled/revoked device gets 202 but is NEVER ranked.
+    const ranked = isRankedAck(res, ack);
+    out.push({
+      window: w.window,
+      pillars: w.pillars,
+      cascade: c,
+      card,
+      ranked,
+      submission: { ...stamp, httpStatus: res.status, ranked, ...ack },
+    });
+  }
+  return {
+    platform: pulled.platform,
+    codename: codename || null,
+    generatedAt: pulled.generatedAt,
+    windows: out,
+  };
+}

package/tools/tokenpull.mjs

@@ -0,0 +1,113 @@
+/**
+ * tools/tokenpull.mjs — tokenpull tool.
+ */
+
+import { cascade } from "../analytics/cascade.mjs";
+import { narrate } from "../presentation/narrate.mjs";
+import { ALL_PLATFORMS } from "../adapters/index.mjs";
+import { TOKENPULL_OUTPUT, ANNOTATIONS } from "./_schemas.mjs";
+import { pullByPlatform } from "./_helpers.mjs";
+
+export const TOOL_DEF = {
+  name: "tokenpull",
+  description:
+    "Pull your LOCAL token usage from the platform's session logs and rank it across the four windows (7d/30d/90d/all-time) with the cascade — zero paste. Token-only: reads usage counts not message content. The numbers stay on your machine unless you submit them. Some platforms may have partial data (estimated=true when cacheCreate isn't available) or a dataGap note when the log format doesn't expose raw token counts.",
+  annotations: { title: "Pull local token usage", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {
+      platform: {
+        type: "string",
+        enum: [...ALL_PLATFORMS, "multi"],
+        description: `source platform (default: claude). Supported: ${ALL_PLATFORMS.join(", ")}, multi. 'multi' = combined cascade summed across all locally-detected platforms (needs 2+ active). 'devin' reads from ~/.local/share/devin/cli/sessions.db (SQLite, all windows). 'codex' is estimated via io_ratio. 'other' reads from a user-supplied JSON file (set SIGRANK_OTHER_PATH). Some platforms need setup (e.g. copilot requires COPILOT_OTEL_ENABLED=true).`,
+      },
+    },
+  },
+  outputSchema: TOKENPULL_OUTPUT,
+};
+
+export async function handleTokenpull(args, ctx) {
+  // Local read → 4 windows of pillars → cascade each. Token-only, on-device.
+  const platform = args?.platform || "claude";
+
+  // MULTI: sum every locally-detected platform's pillars per window. Same logic as
+  // submit_verified's multi flow — Devin (cloud, via tokscale) is included.
+  if (platform === "multi") {
+    const detected = [];
+    for (const p of ALL_PLATFORMS) {
+      const r = await pullByPlatform(p, ctx.opts).catch(() => null);
+      const live =
+        r &&
+        (r.windows || []).some(
+          (w) =>
+            w.pillars.input +
+              w.pillars.output +
+              w.pillars.cacheCreate +
+              w.pillars.cacheRead >
+            0,
+        );
+      if (live) detected.push(r);
+    }
+    if (detected.length < 2) {
+      return {
+        platform: "multi",
+        status: "skipped",
+        reason: "need_2_platforms",
+        detail: `multi needs 2+ active platforms; found ${detected.length} (${detected.map((d) => d.platform).join(", ") || "none"}).`,
+        windows: [],
+      };
+    }
+    const winKeys = ["7d", "30d", "90d", "all"];
+    const windows = [];
+    for (const wk of winKeys) {
+      const sum = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+      let msgs = 0;
+      for (const d of detected) {
+        const w = (d.windows || []).find((x) => x.window === wk);
+        if (!w) continue;
+        sum.input += w.pillars.input || 0;
+        sum.output += w.pillars.output || 0;
+        sum.cacheCreate += w.pillars.cacheCreate || 0;
+        sum.cacheRead += w.pillars.cacheRead || 0;
+        msgs += w.messages || 0;
+      }
+      if (sum.input + sum.output + sum.cacheCreate + sum.cacheRead <= 0)
+        continue;
+      const c = cascade(sum);
+      windows.push({
+        window: wk,
+        messages: msgs,
+        pillars: sum,
+        cascade: c,
+        card: narrate(c, `${wk} multi`),
+      });
+    }
+    return {
+      platform: "multi",
+      estimated: true,
+      sources: detected.map((d) => d.platform),
+      windows,
+    };
+  }
+
+  const pulled = await pullByPlatform(platform, ctx.opts);
+  const windows = pulled.windows.map((w) => {
+    const c = cascade(w.pillars);
+    return {
+      window: w.window,
+      messages: w.messages,
+      pillars: w.pillars,
+      cascade: c,
+      card: narrate(c, `${w.window} ${platform}`),
+    };
+  });
+  return {
+    platform: pulled.platform,
+    estimated: pulled.estimated || false,
+    ...(pulled.ioRatio ? { ioRatio: pulled.ioRatio } : {}),
+    generatedAt: pulled.generatedAt,
+    files: pulled.files,
+    totalMessages: pulled.totalMessages,
+    windows,
+  };
+}