sigrank 0.0.178 → 0.0.179

package/tools/tokenpull-submit.mjs

@@ -0,0 +1,234 @@
+/**
+ * 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";
+
+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: "2026-07-21",
+          privacy_version: "2026-07-21",
+          ...stamp,
+        }),
+      });
+      let ack;
+      try {
+        ack = await res.json();
+      } catch {
+        ack = { status: "parse_error", httpStatus: res.status };
+      }
+      const ranked = ack?.ranked ?? ack?.accepted ?? false;
+      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: "2026-07-21",
+        privacy_version: "2026-07-21",
+        ...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 = !!(
+      res.ok &&
+      ack.verification_tier === "verified" &&
+      ack.persisted === true
+    );
+    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,
+  };
+}

package/tools/tokscale-breakdown.mjs

@@ -0,0 +1,159 @@
+/**
+ * tools/tokscale-breakdown.mjs — tokscale_breakdown tool.
+ */
+
+import { execFileAsync } from "./_helpers.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const TOOL_DEF = {
+  name: "tokscale_breakdown",
+  description:
+    "Show a per-model breakdown of your token usage across all platforms detected by tokscale. Models under the threshold (default 1%) are lumped into 'other' to keep the display clean. Useful for seeing which models you actually use per platform (e.g. claude-opus-4-8 76%, claude-sonnet-4-6 11%, other 0.3%). Returns { platform: [{ model, input, output, cacheRead, cacheCreate, pct }] }.",
+  annotations: {
+    title: "Model breakdown",
+    ...ANNOTATIONS.readOnlyHint,
+    ...ANNOTATIONS.openWorldHint,
+  },
+  inputSchema: {
+    type: "object",
+    properties: {
+      threshold: {
+        type: "number",
+        description:
+          "Models below this fraction of their platform's total tokens are lumped into 'other'. Default 0.01 (1%). Set 0 to see every model.",
+        default: 0.01,
+      },
+    },
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      platforms: {
+        type: "object",
+        description: "Map of platform name → array of { model, input, output, cacheRead, cacheCreate, pct }",
+      },
+    },
+  },
+};
+
+const TOKSCALE_CLIENT_MAP = {
+  claude: "claude",
+  codex: "codex",
+  "devin-cli": "devin",
+  "devin-desktop": "devin",
+  gemini: "gemini",
+  amp: "amp",
+  kimi: "kimi",
+  qwen: "qwen",
+  goose: "goose",
+  kilo: "kilo",
+  kilocode: "kilo",
+  hermes: "hermes",
+  droid: "droid",
+  codebuff: "codebuff",
+  copilot: "copilot",
+  opencode: "opencode",
+  openclaw: "openclaw",
+  pi: "pi",
+  cursor: "other",
+  roocode: "other",
+  mux: "other",
+  crush: "other",
+  antigravity: "other",
+  "antigravity-cli": "other",
+  zed: "other",
+  kiro: "other",
+  trae: "other",
+  warp: "other",
+  cline: "other",
+  gjc: "other",
+  grok: "other",
+  jcode: "other",
+  commandcode: "other",
+  micode: "other",
+  junie: "other",
+  zcode: "other",
+  opencodereview: "other",
+  codebuddy: "other",
+  workbuddy: "other",
+  synthetic: null,
+};
+
+/**
+ * Run `tokscale models --json` and return a model-level breakdown per platform.
+ * Models under `threshold` (default 1%) of their platform's total are lumped
+ * into "other" to keep the display clean.
+ *
+ * Returns: { platform: [{ model, input, output, cacheRead, cacheCreate, pct }] }
+ */
+export async function tokscaleModelBreakdown(threshold = 0.01) {
+  const raw = await execFileAsync("tokscale", ["models", "--json"], 60000);
+  const data = JSON.parse(raw);
+  const entries = Array.isArray(data?.entries)
+    ? data.entries
+    : Array.isArray(data)
+      ? data
+      : [];
+  if (!entries.length) return {};
+
+  // Group entries by our platform name
+  const byPlatform = {};
+  for (const e of entries) {
+    if (!e || !e.client) continue;
+    if (e.model === "<synthetic>" || e.model === "unknown") continue;
+    const input = Number(e.input) || 0;
+    const output = Number(e.output) || 0;
+    if (input + output === 0) continue;
+    const platform = TOKSCALE_CLIENT_MAP[e.client];
+    if (platform === null) continue;
+    const p = platform || "other";
+    if (!byPlatform[p]) byPlatform[p] = [];
+    byPlatform[p].push({
+      model: e.model,
+      input,
+      output,
+      cacheRead: Number(e.cacheRead) || 0,
+      cacheCreate: Number(e.cacheWrite) || 0,
+    });
+  }
+
+  // For each platform: sort by total tokens desc, lump small models into "other"
+  const result = {};
+  for (const [platform, models] of Object.entries(byPlatform)) {
+    const total = models.reduce(
+      (s, m) => s + m.input + m.output + m.cacheRead + m.cacheCreate,
+      0,
+    );
+    if (total === 0) continue;
+    const sorted = models.sort(
+      (a, b) =>
+        b.input + b.output + b.cacheRead + b.cacheCreate -
+        (a.input + a.output + a.cacheRead + a.cacheCreate),
+    );
+    const big = [];
+    const small = { model: "other", input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+    for (const m of sorted) {
+      const t = m.input + m.output + m.cacheRead + m.cacheCreate;
+      if (t / total < threshold) {
+        small.input += m.input;
+        small.output += m.output;
+        small.cacheRead += m.cacheRead;
+        small.cacheCreate += m.cacheCreate;
+      } else {
+        big.push({ ...m, pct: t / total });
+      }
+    }
+    if (small.input + small.output + small.cacheRead + small.cacheCreate > 0) {
+      const t = small.input + small.output + small.cacheRead + small.cacheCreate;
+      big.push({ ...small, pct: t / total });
+    }
+    result[platform] = big;
+  }
+  return result;
+}
+
+export async function handleTokscaleBreakdown(args) {
+  const threshold = Number(args?.threshold ?? 0.01);
+  const platforms = await tokscaleModelBreakdown(threshold);
+  return { platforms };
+}

package/tools/tokscale-competitive-intel.mjs

@@ -0,0 +1,45 @@
+/**
+ * tools/tokscale-competitive-intel.mjs — tokscale_competitive_intel tool.
+ */
+
+import { tokscaleCompetitiveIntel } from "../tokscale_analytics.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const TOOL_DEF = {
+  name: "tokscale_competitive_intel",
+  description:
+    "Competitive intelligence for any AI tool company. Pass a target tool (by tokscale client slug like 'claude', 'codex', 'devin-cli' or canonical platform name like 'devin', 'other') and get: the target's rank by tokens among all detected tools, its full profile (tokens, cost, model mix, cache_read_pct, cost_per_million_tokens, market share), and a head-to-head comparison against every competitor (each competitor's tokens, cost, model_count, share, cost_per_million_tokens). Returns market_totals for context. If the target is not found, lists all detected clients. Use this to benchmark one AI tool against its competitors on this machine. All data is local — this is your own usage, not aggregate market data.",
+  annotations: { title: "Competitive intelligence", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {
+      target: {
+        type: "string",
+        description:
+          "The AI tool to analyze. Accepts a tokscale client slug (e.g. 'claude', 'codex', 'devin-cli', 'copilot') or a canonical platform name (e.g. 'devin', 'claude', 'other'). Case-insensitive. To discover valid slugs, call tokscale_market_share first.",
+      },
+    },
+    required: ["target"],
+    description: "Requires the target tool name. No other parameters accepted.",
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      target: { type: "string", description: "The resolved target slug(s)" },
+      found: { type: "boolean", description: "Whether the target was found in local data" },
+      rank_by_tokens: { type: "integer", description: "Target's rank among all detected tools by token volume" },
+      target_profile: { type: "object", description: "Target's full usage profile with model mix and market share" },
+      competitors: { type: "array", description: "All other detected tools with comparison metrics" },
+      market_totals: { type: "object", description: "Aggregate market context: { tokens, cost, messages, tool_count }" },
+      error: { type: "string", description: "Present if tokscale is unavailable or target is empty" },
+    },
+  },
+};
+
+export async function handleTokscaleCompetitiveIntel(args) {
+  const target = String(args?.target || "").trim();
+  if (!target) {
+    throw new Error("tokscale_competitive_intel requires a non-empty `target` argument (a tokscale client slug like 'claude' or 'codex').");
+  }
+  return await tokscaleCompetitiveIntel(target);
+}

package/tools/tokscale-cost-analysis.mjs

@@ -0,0 +1,31 @@
+/**
+ * tools/tokscale-cost-analysis.mjs — tokscale_cost_analysis tool.
+ */
+
+import { tokscaleCostAnalysis } from "../tokscale_analytics.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const TOOL_DEF = {
+  name: "tokscale_cost_analysis",
+  description:
+    "Cost analysis per developer per model from your local tokscale data. Returns a per-client × per-model cost breakdown with cost_per_million_tokens, cost_per_message, and share_cost. Includes a per-client cost rollup and totals: total_cost, total_tokens, avg_cost_per_million_tokens, most_expensive_model, cheapest_per_token. Use this to see exactly where your AI spend goes — which tools and models cost the most and which give the best value per token. Do NOT use this for market share — use tokscale_market_share for that.",
+  annotations: { title: "Cost analysis per model", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {},
+    description: "No parameters. Derives cost breakdown from tokscale models data.",
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      entries: { type: "array", description: "Per-client×per-model cost rows sorted by cost desc" },
+      client_rollup: { type: "array", description: "Per-client cost summary with share_cost and cost_per_million_tokens" },
+      totals: { type: "object", description: "Aggregate cost totals and extremes" },
+      error: { type: "string", description: "Present if tokscale is unavailable" },
+    },
+  },
+};
+
+export async function handleTokscaleCostAnalysis() {
+  return await tokscaleCostAnalysis();
+}

package/tools/tokscale-developer-profile.mjs

@@ -0,0 +1,36 @@
+/**
+ * tools/tokscale-developer-profile.mjs — tokscale_developer_profile tool.
+ */
+
+import { tokscaleDeveloperProfile } from "../tokscale_analytics.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const TOOL_DEF = {
+  name: "tokscale_developer_profile",
+  description:
+    "Per-developer usage profile across all 20+ AI tools detected by tokscale on this machine. For each tool: model mix (per-model tokens/cost/messages/performance), token pillars (input/output/cache_read/cache_write/reasoning), cache_read_pct, session count, scan path (redacted to ~), workspace breakdown, and headless support flag. Returns a summary with tool_count, total_cost, dominant_tool. All filesystem paths are redacted (home dir → ~). Use this to understand your full AI tool footprint — which tools you use, which models per tool, and how your usage is distributed. Do NOT use this for cost-only analysis — use tokscale_cost_analysis for that.",
+  annotations: { title: "Developer usage profile", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {},
+    description: "No parameters. Profiles all locally-detected AI tools via tokscale.",
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      tools: {
+        type: "array",
+        description: "Per-tool profile with model mix, token pillars, session counts, workspaces",
+      },
+      summary: {
+        type: "object",
+        description: "Aggregate summary: { tool_count, total_cost, total_tokens, total_messages, avg_cost_per_tool, dominant_tool }",
+      },
+      error: { type: "string", description: "Present if tokscale is unavailable" },
+    },
+  },
+};
+
+export async function handleTokscaleDeveloperProfile() {
+  return await tokscaleDeveloperProfile();
+}

package/tools/tokscale-device-profile.mjs

@@ -0,0 +1,35 @@
+/**
+ * tools/tokscale-device-profile.mjs — tokscale_device_profile tool.
+ */
+
+import { tokscaleDeviceProfile } from "../tokscale_analytics.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const TOOL_DEF = {
+  name: "tokscale_device_profile",
+  description:
+    "Device fingerprinting: profiles this machine's AI tool footprint — which AI tools are installed, where their session logs live (paths redacted to ~), how many sessions and messages each has, when the machine was active (daily activity + day-of-week distribution), session concurrency, and longest continuous session. Combines tokscale clients + graph data. All filesystem paths are redacted so no local username leaks. Use this to audit your own machine's AI tool installation and activity pattern. This is local-only — it profiles the current machine, not remote devices.",
+  annotations: { title: "Device profile", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+  inputSchema: {
+    type: "object",
+    properties: {},
+    description: "No parameters. Profiles the local machine via tokscale.",
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      installed_tools: { type: "array", description: "Detected AI tools with redacted session paths and message counts" },
+      installed_tool_count: { type: "integer" },
+      active_tool_count: { type: "integer", description: "Tools whose session path exists on disk" },
+      date_range: { type: "object", description: "{ start, end } of the activity data" },
+      activity: { type: "object", description: "Daily activity + day-of-week token distribution" },
+      sessions: { type: "object", description: "Session metrics: count, total/longest active time, max concurrent" },
+      summary: { type: "object", description: "Cost summary from graph: total_tokens, total_cost, avg_per_day, max_single_day" },
+      error: { type: "string", description: "Present if tokscale is unavailable" },
+    },
+  },
+};
+
+export async function handleTokscaleDeviceProfile() {
+  return await tokscaleDeviceProfile();
+}