selftune 0.2.16 → 0.2.18

package/cli/selftune/orchestrate.ts

@@ -16,9 +16,9 @@ import { parseArgs } from "node:util";
 
 import { readAlphaIdentity } from "./alpha-identity.js";
 import type { UploadCycleSummary } from "./alpha-upload/index.js";
-import { ORCHESTRATE_LOCK, SELFTUNE_CONFIG_PATH } from "./constants.js";
+import { getOrchestrateLockPath, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { OrchestrateRunReport, OrchestrateRunSkillAction } from "./dashboard-contract.js";
-import type { EvolveResult } from "./evolution/evolve.js";
+import type { EvolveOptions, EvolveResult } from "./evolution/evolve.js";
 import {
   buildDefaultGradingOutputPath,
   deriveExpectationsFromSkill,
@@ -74,7 +74,7 @@ interface LockInfo {
 
 const LOCK_STALE_MS = 30 * 60 * 1000; // 30 minutes
 
-export function acquireLock(lockPath: string = ORCHESTRATE_LOCK): boolean {
+export function acquireLock(lockPath: string = getOrchestrateLockPath()): boolean {
   try {
     if (existsSync(lockPath)) {
       try {
@@ -98,7 +98,7 @@ export function acquireLock(lockPath: string = ORCHESTRATE_LOCK): boolean {
   }
 }
 
-export function releaseLock(lockPath: string = ORCHESTRATE_LOCK): void {
+export function releaseLock(lockPath: string = getOrchestrateLockPath()): void {
   try {
     unlinkSync(lockPath);
   } catch {
@@ -377,6 +377,33 @@ export const MIN_CANDIDATE_EVIDENCE = 3;
 /** Default cooldown hours after a deploy before re-evolving the same skill. */
 export const DEFAULT_COOLDOWN_HOURS = 24;
 
+type AutonomousEvolveDefaults = Pick<
+  EvolveOptions,
+  | "paretoEnabled"
+  | "candidateCount"
+  | "tokenEfficiencyEnabled"
+  | "withBaseline"
+  | "validationModel"
+  | "cheapLoop"
+  | "gateModel"
+  | "adaptiveGate"
+  | "proposalModel"
+>;
+
+// Keep the autonomous loop aligned with the evolve CLI defaults so scheduled
+// runs stay cheap by default and still get a stronger gate before deploy.
+const AUTONOMOUS_EVOLVE_DEFAULTS: AutonomousEvolveDefaults = {
+  paretoEnabled: true,
+  candidateCount: 3,
+  tokenEfficiencyEnabled: false,
+  withBaseline: false,
+  validationModel: "haiku",
+  cheapLoop: true,
+  gateModel: "sonnet",
+  adaptiveGate: true,
+  proposalModel: "haiku",
+};
+
 function candidatePriority(skill: SkillStatus, signalCount = 0): number {
   const statusWeight = skill.status === "CRITICAL" ? 300 : skill.status === "WARNING" ? 200 : 100;
   const missedWeight = Math.min(skill.missedQueries, 50);
@@ -1012,6 +1039,7 @@ export async function orchestrate(
           maxIterations: 3,
           gradingResults: _readGradingResults(candidate.skill),
           syncFirst: false, // We already synced
+          ...AUTONOMOUS_EVOLVE_DEFAULTS,
         });
 
         candidate.evolveResult = evolveResult;

package/cli/selftune/routes/overview.ts

@@ -2,14 +2,52 @@
  * Route handler: GET /api/v2/overview
  *
  * Returns SQLite-backed overview payload with skill listing and version info.
+ * Supports optional cursor-based pagination via query params:
+ *   ?telemetry_cursor=<json>&telemetry_limit=N&skills_cursor=<json>&skills_limit=N
  */
 
 import type { Database } from "bun:sqlite";
 
-import { getOverviewPayload, getSkillsList } from "../localdb/queries.js";
+import { parseCursorParam, parseIntParam } from "../dashboard-contract.js";
+import {
+  getOverviewPayload,
+  getOverviewPayloadPaginated,
+  getSkillsList,
+} from "../localdb/queries.js";
 
-export function handleOverview(db: Database, version: string): Response {
-  const overview = getOverviewPayload(db);
+export function handleOverview(
+  db: Database,
+  version: string,
+  searchParams?: URLSearchParams,
+): Response {
   const skills = getSkillsList(db);
+
+  // Check if any pagination params are provided
+  const hasPaginationParams =
+    searchParams &&
+    (searchParams.has("telemetry_cursor") ||
+      searchParams.has("telemetry_limit") ||
+      searchParams.has("skills_cursor") ||
+      searchParams.has("skills_limit"));
+
+  if (!hasPaginationParams) {
+    // Backward-compatible: return the unpaginated overview
+    const overview = getOverviewPayload(db);
+    return Response.json({ overview, skills, version });
+  }
+
+  // Parse pagination params
+  const telemetryCursor = parseCursorParam(searchParams.get("telemetry_cursor"));
+  const telemetryLimit = parseIntParam(searchParams.get("telemetry_limit"), 1000);
+  const skillsCursor = parseCursorParam(searchParams.get("skills_cursor"));
+  const skillsLimit = parseIntParam(searchParams.get("skills_limit"), 2000);
+
+  const overview = getOverviewPayloadPaginated(db, {
+    telemetry_cursor: telemetryCursor,
+    telemetry_limit: telemetryLimit,
+    skills_cursor: skillsCursor,
+    skills_limit: skillsLimit,
+  });
+
   return Response.json({ overview, skills, version });
 }

package/cli/selftune/routes/skill-report.ts

@@ -8,10 +8,21 @@
 
 import type { Database } from "bun:sqlite";
 
+import { parseCursorParam } from "../dashboard-contract.js";
 import { scoreDescription } from "../evolution/description-quality.js";
-import { getPendingProposals, getSkillReportPayload, safeParseJson } from "../localdb/queries.js";
+import {
+  getExecutionMetrics,
+  getPendingProposals,
+  getSkillCommitSummary,
+  getSkillReportPayload,
+  safeParseJson,
+} from "../localdb/queries.js";
 
-export function handleSkillReport(db: Database, skillName: string): Response {
+export function handleSkillReport(
+  db: Database,
+  skillName: string,
+  searchParams?: URLSearchParams,
+): Response {
   const report = getSkillReportPayload(db, skillName);
 
   // 1. Evolution audit with eval_snapshot
@@ -87,21 +98,17 @@ export function handleSkillReport(db: Database, skillName: string): Response {
     run_count: selftuneRunCount,
   };
 
-  // 4. Skill invocations — single source of truth
+  // 4. Skill invocations — single source of truth (with optional cursor pagination)
   // JOIN prompts to recover query text when si.query is null (canonical records
   // don't carry query; it's only populated via the direct-write hook path).
-  const invocationsWithConfidence = db
-    .query(
-      `SELECT si.occurred_at as timestamp, si.session_id, si.skill_name,
-              si.invocation_mode, si.triggered, si.confidence, si.tool_name,
-              si.agent_type, COALESCE(si.query, p.prompt_text) as query, si.source
-       FROM skill_invocations si
-       LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
-       WHERE si.skill_name = ?
-       ORDER BY si.occurred_at DESC
-       LIMIT 100`,
-    )
-    .all(skillName) as Array<{
+  const invCursor = parseCursorParam(searchParams?.get("invocations_cursor") ?? null);
+  const invLimitParam = searchParams?.get("invocations_limit");
+  const invLimit = invLimitParam
+    ? Math.max(1, Math.min(Number.parseInt(invLimitParam, 10) || 100, 10000))
+    : 100;
+  const invFetchLimit = invLimit + 1;
+
+  let invocationsWithConfidence: Array<{
     timestamp: string;
     session_id: string;
     skill_name: string;
@@ -112,8 +119,56 @@ export function handleSkillReport(db: Database, skillName: string): Response {
     agent_type: string | null;
     query: string | null;
     source: string | null;
+    skill_invocation_id: string;
   }>;
 
+  if (invCursor) {
+    invocationsWithConfidence = db
+      .query(
+        `SELECT si.occurred_at as timestamp, si.session_id, si.skill_name,
+                si.invocation_mode, si.triggered, si.confidence, si.tool_name,
+                si.agent_type, COALESCE(si.query, p.prompt_text) as query, si.source,
+                si.skill_invocation_id
+         FROM skill_invocations si
+         LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
+         WHERE si.skill_name = ?
+           AND (si.occurred_at < ? OR (si.occurred_at = ? AND si.skill_invocation_id < ?))
+         ORDER BY si.occurred_at DESC, si.skill_invocation_id DESC
+         LIMIT ?`,
+      )
+      .all(
+        skillName,
+        invCursor.timestamp,
+        invCursor.timestamp,
+        String(invCursor.id),
+        invFetchLimit,
+      ) as typeof invocationsWithConfidence;
+  } else {
+    invocationsWithConfidence = db
+      .query(
+        `SELECT si.occurred_at as timestamp, si.session_id, si.skill_name,
+                si.invocation_mode, si.triggered, si.confidence, si.tool_name,
+                si.agent_type, COALESCE(si.query, p.prompt_text) as query, si.source,
+                si.skill_invocation_id
+         FROM skill_invocations si
+         LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
+         WHERE si.skill_name = ?
+         ORDER BY si.occurred_at DESC, si.skill_invocation_id DESC
+         LIMIT ?`,
+      )
+      .all(skillName, invFetchLimit) as typeof invocationsWithConfidence;
+  }
+
+  const invHasMore = invocationsWithConfidence.length > invLimit;
+  const invPageRows = invHasMore
+    ? invocationsWithConfidence.slice(0, invLimit)
+    : invocationsWithConfidence;
+  const invLastRow = invPageRows[invPageRows.length - 1];
+  const invNextCursor =
+    invHasMore && invLastRow
+      ? { timestamp: invLastRow.timestamp, id: invLastRow.skill_invocation_id }
+      : null;
+
   // Not-found check — after all enrichment queries so evidence-only skills aren't 404'd
   const hasData =
     report.usage.total_checks > 0 ||
@@ -121,7 +176,7 @@ export function handleSkillReport(db: Database, skillName: string): Response {
     report.evidence.length > 0 ||
     evolution.length > 0 ||
     pending_proposals.length > 0 ||
-    invocationsWithConfidence.length > 0;
+    invPageRows.length > 0;
   if (!hasData) {
     return Response.json({ error: "Skill not found" }, { status: 404 });
   }
@@ -156,6 +211,18 @@ export function handleSkillReport(db: Database, skillName: string): Response {
     )
     .get(skillName) as { missed_triggers: number } | null;
 
+  // 5b. Execution metrics (enrichment columns from execution_facts)
+  const skillSessionIds = db
+    .query(`SELECT DISTINCT session_id FROM skill_invocations WHERE skill_name = ?`)
+    .all(skillName) as Array<{ session_id: string }>;
+  const executionMetrics = getExecutionMetrics(
+    db,
+    skillSessionIds.map((r) => r.session_id),
+  );
+
+  // 5c. Commit summary (from commit_tracking via session join)
+  const commitSummary = getSkillCommitSummary(db, skillName);
+
   // 6. Prompt texts — prefer matched prompts (the prompt that invoked the skill),
   //    fall back to all prompts from sessions that used the skill.
   const promptSamples = db
@@ -227,16 +294,20 @@ export function handleSkillReport(db: Database, skillName: string): Response {
       total_input_tokens: executionRow?.total_input_tokens ?? 0,
       total_output_tokens: executionRow?.total_output_tokens ?? 0,
     },
-    canonical_invocations: invocationsWithConfidence.map((i) => ({
+    canonical_invocations: invPageRows.map((i) => ({
       ...i,
       triggered: i.triggered === 1,
     })),
+    invocations_pagination:
+      invNextCursor || invCursor ? { next_cursor: invNextCursor, has_more: invHasMore } : undefined,
     duration_stats: {
       avg_duration_ms: executionRow?.avg_duration_ms ?? 0,
       total_duration_ms: executionRow?.total_duration_ms ?? 0,
       execution_count: executionRow?.execution_count ?? 0,
       missed_triggers: missedRow?.missed_triggers ?? 0,
     },
+    execution_metrics: executionMetrics,
+    commit_summary: commitSummary.total_commits > 0 ? commitSummary : null,
     selftune_stats: selftuneStats,
     prompt_samples: promptSamples.map((p) => ({
       ...p,

package/cli/selftune/types.ts

@@ -93,6 +93,17 @@ export interface SessionTelemetryRecord {
   source?: string;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: SessionType;
   agent_summary?: string;
   rollout_path?: string;
 }
@@ -140,6 +151,13 @@ export {
   CANONICAL_SOURCE_SESSION_KINDS,
 } from "@selftune/telemetry-contract/types";
 
+// ---------------------------------------------------------------------------
+// Session classification
+// ---------------------------------------------------------------------------
+
+/** Inferred session type based on tool distribution. */
+export type SessionType = "dev" | "research" | "content" | "mixed";
+
 // ---------------------------------------------------------------------------
 // Transcript parsing
 // ---------------------------------------------------------------------------
@@ -156,6 +174,17 @@ export interface TranscriptMetrics {
   last_user_query: string;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: SessionType;
   duration_ms?: number;
   model?: string;
   started_at?: string;
@@ -290,6 +319,8 @@ export interface ExecutionMetrics {
   errors_encountered: number;
   skills_triggered: string[];
   transcript_chars: number;
+  artifact_count?: number;
+  session_type?: SessionType;
 }
 
 // ---------------------------------------------------------------------------

package/cli/selftune/utils/transcript.ts

@@ -6,9 +6,15 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname } from "node:path";
 
 import { CLAUDE_CODE_PROJECTS_DIR } from "../constants.js";
-import type { SessionTelemetryRecord, TranscriptMetrics } from "../types.js";
+import type { SessionTelemetryRecord, SessionType, TranscriptMetrics } from "../types.js";
 import { isActionableQueryText } from "./query-filter.js";
 
+/** Tools that produce durable output artifacts (not reads or exploration). */
+const ARTIFACT_TOOLS = new Set(["Write", "Edit", "WebFetch", "WebSearch", "Skill", "Agent"]);
+
+/** Matches any bash command containing a git invocation. */
+const GIT_CMD_RE = /\bgit\b/;
+
 /**
  * Parse a Claude Code transcript JSONL and extract process metrics.
  *
@@ -32,10 +38,18 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
   let lastUserQuery = "";
   let inputTokens = 0;
   let outputTokens = 0;
+  let cachedInputTokens = 0;
+  let reasoningOutputTokens = 0;
   let firstTimestamp: string | null = null;
   let lastTimestamp: string | null = null;
   let model: string | undefined;
 
+  // File change tracking (Win 2)
+  const changedFiles = new Set<string>();
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  let linesModified = 0;
+
   for (const raw of lines) {
     const line = raw.trim();
     if (!line) continue;
@@ -61,6 +75,14 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
     if (usage && typeof usage === "object") {
       if (typeof usage.input_tokens === "number") inputTokens += usage.input_tokens;
       if (typeof usage.output_tokens === "number") outputTokens += usage.output_tokens;
+      // Win 3: Token granularity — cached input tokens
+      if (typeof usage.cache_read_input_tokens === "number")
+        cachedInputTokens += usage.cache_read_input_tokens;
+      if (typeof usage.cache_creation_input_tokens === "number")
+        cachedInputTokens += usage.cache_creation_input_tokens;
+      // Win 3: Reasoning output tokens
+      if (typeof usage.reasoning_output_tokens === "number")
+        reasoningOutputTokens += usage.reasoning_output_tokens;
     }
 
     // Normalise: unwrap nested message if present
@@ -119,6 +141,26 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
             const cmd = ((inp.command as string) ?? "").trim();
             if (cmd) bashCommands.push(cmd);
           }
+
+          // Win 2: Track file changes from Write and Edit tools
+          if (toolName === "Write" || toolName === "Edit") {
+            const fp = (inp.file_path as string) ?? "";
+            if (fp) changedFiles.add(fp);
+          }
+          if (toolName === "Write" && typeof inp.content === "string") {
+            linesAdded += inp.content.split("\n").length;
+          }
+          if (toolName === "Edit") {
+            const oldStr = inp.old_string;
+            const newStr = inp.new_string;
+            if (typeof oldStr === "string" && typeof newStr === "string") {
+              const oldLines = oldStr.split("\n").length;
+              const newLines = newStr.split("\n").length;
+              linesModified += Math.min(oldLines, newLines);
+              linesAdded += Math.max(0, newLines - oldLines);
+              linesRemoved += Math.max(0, oldLines - newLines);
+            }
+          }
         }
       }
     }
@@ -143,6 +185,12 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
     }
   }
 
+  // Compute artifact count: output-producing tool calls
+  let artifactCount = 0;
+  for (const [tool, count] of Object.entries(toolCalls)) {
+    if (ARTIFACT_TOOLS.has(tool)) artifactCount += count;
+  }
+
   // Compute duration from first to last timestamp
   let durationMs: number | undefined;
   if (firstTimestamp && lastTimestamp && firstTimestamp !== lastTimestamp) {
@@ -153,6 +201,12 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
     }
   }
 
+  // Win 3: Calculate cost from model and token counts
+  const costUsd = calculateCost(model, inputTokens, outputTokens);
+
+  // Infer session type from tool distribution
+  const sessionType = inferSessionType(toolCalls, bashCommands);
+
   return {
     tool_calls: toolCalls,
     total_tool_calls: Object.values(toolCalls).reduce((a, b) => a + b, 0),
@@ -163,8 +217,18 @@ export function parseTranscript(transcriptPath: string): TranscriptMetrics {
     errors_encountered: errors,
     transcript_chars: totalChars,
     last_user_query: lastUserQuery,
+    // Win 2: File change metrics
+    files_changed: changedFiles.size,
+    lines_added: linesAdded,
+    lines_removed: linesRemoved,
+    lines_modified: linesModified,
+    artifact_count: artifactCount,
+    session_type: sessionType,
     ...(inputTokens > 0 ? { input_tokens: inputTokens } : {}),
     ...(outputTokens > 0 ? { output_tokens: outputTokens } : {}),
+    ...(cachedInputTokens > 0 ? { cached_input_tokens: cachedInputTokens } : {}),
+    ...(reasoningOutputTokens > 0 ? { reasoning_output_tokens: reasoningOutputTokens } : {}),
+    ...(costUsd !== undefined ? { cost_usd: costUsd } : {}),
     ...(durationMs !== undefined ? { duration_ms: durationMs } : {}),
     ...(model ? { model } : {}),
     ...(firstTimestamp ? { started_at: firstTimestamp } : {}),
@@ -307,6 +371,16 @@ export function buildTelemetryFromTranscript(
     source,
     input_tokens: metrics.input_tokens,
     output_tokens: metrics.output_tokens,
+    cached_input_tokens: metrics.cached_input_tokens,
+    reasoning_output_tokens: metrics.reasoning_output_tokens,
+    cost_usd: metrics.cost_usd,
+    files_changed: metrics.files_changed,
+    lines_added: metrics.lines_added,
+    lines_removed: metrics.lines_removed,
+    lines_modified: metrics.lines_modified,
+    artifact_count: metrics.artifact_count,
+    session_type: metrics.session_type,
+    agent_summary: generateSessionSummary(metrics),
   };
 }
 
@@ -518,6 +592,141 @@ export function extractTokenUsage(transcriptPath: string): { input: number; outp
   return { input, output };
 }
 
+// ---------------------------------------------------------------------------
+// Win 3: Model cost lookup (USD per million tokens)
+// ---------------------------------------------------------------------------
+
+const MODEL_COSTS: Record<string, { input: number; output: number }> = {
+  "claude-sonnet-4-20250514": { input: 3.0, output: 15.0 },
+  "claude-opus-4-20250514": { input: 15.0, output: 75.0 },
+  "claude-haiku-3-5-20241022": { input: 0.8, output: 4.0 },
+  "claude-3-5-sonnet-20241022": { input: 3.0, output: 15.0 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4.0 },
+  "claude-3-opus-20240229": { input: 15.0, output: 75.0 },
+  "claude-3-sonnet-20240229": { input: 3.0, output: 15.0 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+};
+
+/**
+ * Calculate estimated cost in USD from model name and token counts.
+ * Returns undefined if the model is unknown or not provided.
+ */
+export function calculateCost(
+  model: string | undefined,
+  inputTokens: number,
+  outputTokens: number,
+): number | undefined {
+  if (!model) return undefined;
+  const costs =
+    MODEL_COSTS[model] ??
+    Object.entries(MODEL_COSTS).find(([k]) =>
+      model.startsWith(k.split("-").slice(0, -1).join("-")),
+    )?.[1];
+  if (!costs) return undefined;
+  return (inputTokens * costs.input + outputTokens * costs.output) / 1_000_000;
+}
+
+/**
+ * Infer session type from tool call distribution.
+ *
+ * - "dev": majority of output tools are Write/Edit/Bash with git commands
+ * - "research": majority are WebFetch/WebSearch/Read
+ * - "content": majority are Write/Edit but no git commands
+ * - "mixed": no clear majority
+ */
+export function inferSessionType(
+  toolCalls: Record<string, number>,
+  bashCommands: string[],
+): "dev" | "research" | "content" | "mixed" {
+  const total = Object.values(toolCalls).reduce((a, b) => a + b, 0);
+  if (total === 0) return "mixed";
+
+  const writeEdit = (toolCalls.Write ?? 0) + (toolCalls.Edit ?? 0);
+  const research = (toolCalls.WebFetch ?? 0) + (toolCalls.WebSearch ?? 0);
+  const bash = toolCalls.Bash ?? 0;
+  const read = toolCalls.Read ?? 0;
+  const hasGit = bashCommands.some((cmd) => GIT_CMD_RE.test(cmd));
+
+  // Dev: file mutations + git commands OR bash-heavy with git
+  if (hasGit && (writeEdit + bash) / total > 0.3) return "dev";
+
+  // Research: web tools + read-heavy, low file mutations
+  if (research > 0 && research / total > 0.2 && writeEdit / total < 0.15) return "research";
+  if (read / total > 0.5 && writeEdit / total < 0.1) return "research";
+
+  // Content: file mutations but no git
+  if (writeEdit / total > 0.2 && !hasGit) return "content";
+
+  return "mixed";
+}
+
+/**
+ * Generate a short heuristic session summary from transcript metrics.
+ * No LLM call — pure template-based approach. Kept under 120 chars.
+ */
+export function generateSessionSummary(metrics: TranscriptMetrics): string {
+  const MAX_LEN = 120;
+  const sessionType: SessionType = metrics.session_type ?? "mixed";
+  const lastQuery = truncateQuery(metrics.last_user_query, 60);
+
+  if (metrics.total_tool_calls === 0 && !lastQuery) {
+    return "Empty session — no tool calls or queries";
+  }
+
+  const topTools = getTopTools(metrics.tool_calls, 2);
+
+  let summary: string;
+  switch (sessionType) {
+    case "dev": {
+      const filesChanged = metrics.files_changed ?? 0;
+      const toolStr = topTools.length > 0 ? ` via ${topTools.join(", ")}` : "";
+      const queryStr = lastQuery ? ` — ${lastQuery}` : "";
+      summary = `${filesChanged} files changed${toolStr}${queryStr}`;
+      break;
+    }
+    case "research": {
+      const searches = (metrics.tool_calls.WebSearch ?? 0) + (metrics.tool_calls.WebFetch ?? 0);
+      const reads = metrics.tool_calls.Read ?? 0;
+      const queryStr = lastQuery ? ` — ${lastQuery}` : "";
+      summary = `${searches} searches + ${reads} reads${queryStr}`;
+      break;
+    }
+    case "content": {
+      const filesChanged = metrics.files_changed ?? 0;
+      const queryStr = lastQuery ? ` — ${lastQuery}` : "";
+      summary = `${filesChanged} files created/edited${queryStr}`;
+      break;
+    }
+    default: {
+      const toolCount = Object.keys(metrics.tool_calls).length;
+      const queryStr = lastQuery ? ` — ${lastQuery}` : "";
+      summary = `${metrics.total_tool_calls} tool calls across ${toolCount} tools${queryStr}`;
+      break;
+    }
+  }
+
+  if (summary.length > MAX_LEN) {
+    return `${summary.slice(0, MAX_LEN - 3)}...`;
+  }
+  return summary;
+}
+
+/** Get the top N tools by call count. */
+function getTopTools(toolCalls: Record<string, number>, n: number): string[] {
+  return Object.entries(toolCalls)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, n)
+    .map(([name]) => name);
+}
+
+/** Truncate a query string to maxLen, adding ellipsis if needed. */
+function truncateQuery(query: string, maxLen: number): string {
+  const trimmed = query.trim();
+  if (!trimmed) return "";
+  if (trimmed.length <= maxLen) return trimmed;
+  return `${trimmed.slice(0, maxLen - 3)}...`;
+}
+
 function emptyMetrics(): TranscriptMetrics {
   return {
     tool_calls: {},

package/node_modules/@selftune/telemetry-contract/src/types.ts

@@ -143,7 +143,18 @@ export interface CanonicalExecutionFactRecord extends CanonicalSessionRecordBase
   errors_encountered: number;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
   duration_ms?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: "dev" | "research" | "content" | "mixed";
   completion_status?: CanonicalCompletionStatus;
   end_reason?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selftune",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Self-improving skills CLI for AI agents",
   "keywords": [
     "agent",

package/packages/telemetry-contract/src/types.ts

@@ -143,7 +143,18 @@ export interface CanonicalExecutionFactRecord extends CanonicalSessionRecordBase
   errors_encountered: number;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
   duration_ms?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: "dev" | "research" | "content" | "mixed";
   completion_status?: CanonicalCompletionStatus;
   end_reason?: string;
 }