selftune 0.2.16 → 0.2.18

package/cli/selftune/localdb/queries.ts

@@ -8,12 +8,21 @@
 import type { Database } from "bun:sqlite";
 
 import type {
+  CommitRecord,
+  CommitSummary,
+  ExecutionMetrics,
   OrchestrateRunReport,
+  OverviewPaginatedPayload,
   OverviewPayload,
+  PaginatedResult,
+  PaginationCursor,
   PendingProposal,
   RecentActivityItem,
+  SkillReportPaginatedPayload,
   SkillReportPayload,
   SkillSummary,
+  SkillUsageRecord,
+  TelemetryRecord,
 } from "../dashboard-contract.js";
 
 /**
@@ -243,6 +252,386 @@ export function getSkillReportPayload(db: Database, skillName: string): SkillRep
   };
 }
 
+// -- Cursor-based paginated queries -------------------------------------------
+
+export interface OverviewPaginationOptions {
+  telemetry_cursor?: PaginationCursor | null;
+  telemetry_limit?: number;
+  skills_cursor?: PaginationCursor | null;
+  skills_limit?: number;
+}
+
+export interface SkillReportPaginationOptions {
+  invocations_cursor?: PaginationCursor | null;
+  invocations_limit?: number;
+}
+
+/**
+ * Build a paginated overview payload from SQLite.
+ *
+ * Uses (timestamp, session_id) composite cursors for stable backward pagination.
+ * When no cursor is provided, returns the first page starting from most recent.
+ */
+export function getOverviewPayloadPaginated(
+  db: Database,
+  opts: OverviewPaginationOptions = {},
+): OverviewPaginatedPayload {
+  const telemetryLimit = opts.telemetry_limit ?? 1000;
+  const skillsLimit = opts.skills_limit ?? 2000;
+
+  // Paginated telemetry
+  const telemetry_page = paginateTelemetry(db, telemetryLimit, opts.telemetry_cursor ?? null);
+
+  // Paginated skill invocations
+  const skills_page = paginateSkillInvocations(db, skillsLimit, opts.skills_cursor ?? null);
+
+  // Non-paginated parts reuse existing logic
+  const evolution = db
+    .query(
+      `SELECT timestamp, proposal_id, skill_name, action, details
+       FROM evolution_audit
+       ORDER BY timestamp DESC
+       LIMIT 500`,
+    )
+    .all() as Array<{
+    timestamp: string;
+    proposal_id: string;
+    skill_name: string | null;
+    action: string;
+    details: string;
+  }>;
+
+  const counts = db
+    .query(
+      `SELECT
+         (SELECT COUNT(*) FROM session_telemetry) as telemetry,
+         (SELECT COUNT(*) FROM skill_invocations) as skills,
+         (SELECT COUNT(*) FROM evolution_audit) as evolution,
+         (SELECT COUNT(*) FROM evolution_evidence) as evidence,
+         (SELECT COUNT(*) FROM sessions) as sessions,
+         (SELECT COUNT(*) FROM prompts) as prompts`,
+    )
+    .get() as {
+    telemetry: number;
+    skills: number;
+    evolution: number;
+    evidence: number;
+    sessions: number;
+    prompts: number;
+  };
+
+  const unmatchedRows = db
+    .query(
+      `SELECT si.occurred_at AS timestamp, si.session_id, si.query
+       FROM skill_invocations si
+       WHERE si.triggered = 0
+         AND NOT EXISTS (
+           SELECT 1 FROM skill_invocations si2
+           WHERE si2.query = si.query AND si2.triggered = 1
+         )
+       ORDER BY si.occurred_at DESC
+       LIMIT 500`,
+    )
+    .all() as Array<{ timestamp: string; session_id: string; query: string }>;
+
+  const pending_proposals = getPendingProposals(db);
+  const active_sessions = getActiveSessionCount(db);
+  const recent_activity = getRecentActivity(db);
+
+  return {
+    telemetry_page,
+    skills_page,
+    evolution,
+    counts,
+    unmatched_queries: unmatchedRows,
+    pending_proposals,
+    active_sessions,
+    recent_activity,
+  };
+}
+
+/**
+ * Build a paginated skill report payload for a specific skill.
+ *
+ * Uses (occurred_at, skill_invocation_id) composite cursor for the recent
+ * invocations sub-query. Non-paginated fields (usage stats, evidence, sessions)
+ * are returned in full.
+ */
+export function getSkillReportPayloadPaginated(
+  db: Database,
+  skillName: string,
+  opts: SkillReportPaginationOptions = {},
+): SkillReportPaginatedPayload {
+  const invocationsLimit = opts.invocations_limit ?? 100;
+
+  // Usage stats (unchanged)
+  const usageRow = db
+    .query(
+      `SELECT
+         COUNT(*) as total_checks,
+         SUM(CASE WHEN triggered = 1 THEN 1 ELSE 0 END) as triggered_count
+       FROM skill_invocations
+       WHERE skill_name = ?`,
+    )
+    .get(skillName) as { total_checks: number; triggered_count: number };
+
+  const total = usageRow.total_checks;
+  const triggered = usageRow.triggered_count;
+  const passRate = total > 0 ? triggered / total : 0;
+
+  // Paginated invocations
+  const invocations_page = paginateSkillReportInvocations(
+    db,
+    skillName,
+    invocationsLimit,
+    opts.invocations_cursor ?? null,
+  );
+
+  // Evidence (unchanged)
+  const evidenceRows = db
+    .query(
+      `SELECT proposal_id, target, stage, timestamp, rationale, confidence,
+              original_text, proposed_text, validation_json, details, eval_set_json
+       FROM evolution_evidence
+       WHERE skill_name = ?
+       ORDER BY timestamp DESC
+       LIMIT 200`,
+    )
+    .all(skillName) as Array<{
+    proposal_id: string;
+    target: string;
+    stage: string;
+    timestamp: string;
+    rationale: string | null;
+    confidence: number | null;
+    original_text: string | null;
+    proposed_text: string | null;
+    validation_json: string | null;
+    details: string | null;
+    eval_set_json: string | null;
+  }>;
+
+  const evidence = evidenceRows.map((row) => ({
+    proposal_id: row.proposal_id,
+    target: row.target,
+    stage: row.stage,
+    timestamp: row.timestamp,
+    rationale: row.rationale,
+    confidence: row.confidence,
+    original_text: row.original_text,
+    proposed_text: row.proposed_text,
+    validation: safeParseJson(row.validation_json),
+    details: row.details,
+    eval_set: safeParseJsonArray<Record<string, unknown>>(row.eval_set_json),
+  }));
+
+  const sessionsRow = db
+    .query(`SELECT COUNT(DISTINCT session_id) as c FROM skill_invocations WHERE skill_name = ?`)
+    .get(skillName) as { c: number };
+
+  return {
+    skill_name: skillName,
+    usage: {
+      total_checks: total,
+      triggered_count: triggered,
+      pass_rate: passRate,
+    },
+    invocations_page,
+    evidence,
+    sessions_with_skill: sessionsRow.c,
+  };
+}
+
+// -- Internal pagination helpers ------------------------------------------------
+
+function paginateTelemetry(
+  db: Database,
+  limit: number,
+  cursor: PaginationCursor | null,
+): PaginatedResult<TelemetryRecord> {
+  // Fetch one extra to detect has_more
+  const fetchLimit = limit + 1;
+
+  let rows: Array<{
+    timestamp: string;
+    session_id: string;
+    skills_triggered_json: string | null;
+    errors_encountered: number;
+    total_tool_calls: number;
+  }>;
+
+  if (cursor) {
+    rows = db
+      .query(
+        `SELECT timestamp, session_id, skills_triggered_json, errors_encountered, total_tool_calls
+         FROM session_telemetry
+         WHERE (timestamp < ? OR (timestamp = ? AND session_id < ?))
+         ORDER BY timestamp DESC, session_id DESC
+         LIMIT ?`,
+      )
+      .all(cursor.timestamp, cursor.timestamp, String(cursor.id), fetchLimit) as typeof rows;
+  } else {
+    rows = db
+      .query(
+        `SELECT timestamp, session_id, skills_triggered_json, errors_encountered, total_tool_calls
+         FROM session_telemetry
+         ORDER BY timestamp DESC, session_id DESC
+         LIMIT ?`,
+      )
+      .all(fetchLimit) as typeof rows;
+  }
+
+  const hasMore = rows.length > limit;
+  const pageRows = hasMore ? rows.slice(0, limit) : rows;
+
+  const items: TelemetryRecord[] = pageRows.map((row) => ({
+    timestamp: row.timestamp,
+    session_id: row.session_id,
+    skills_triggered: safeParseJsonArray<string>(row.skills_triggered_json),
+    errors_encountered: row.errors_encountered,
+    total_tool_calls: row.total_tool_calls,
+  }));
+
+  const lastItem = pageRows[pageRows.length - 1];
+  const next_cursor: PaginationCursor | null =
+    hasMore && lastItem ? { timestamp: lastItem.timestamp, id: lastItem.session_id } : null;
+
+  return { items, next_cursor, has_more: hasMore };
+}
+
+function paginateSkillInvocations(
+  db: Database,
+  limit: number,
+  cursor: PaginationCursor | null,
+): PaginatedResult<SkillUsageRecord> {
+  const fetchLimit = limit + 1;
+
+  let rows: Array<{
+    occurred_at: string;
+    session_id: string;
+    skill_name: string;
+    skill_path: string;
+    query: string;
+    triggered: number;
+    source: string | null;
+    skill_invocation_id: string;
+  }>;
+
+  if (cursor) {
+    rows = db
+      .query(
+        `SELECT occurred_at, session_id, skill_name, skill_path, query, triggered, source, skill_invocation_id
+         FROM skill_invocations
+         WHERE (occurred_at < ? OR (occurred_at = ? AND skill_invocation_id < ?))
+         ORDER BY occurred_at DESC, skill_invocation_id DESC
+         LIMIT ?`,
+      )
+      .all(cursor.timestamp, cursor.timestamp, String(cursor.id), fetchLimit) as typeof rows;
+  } else {
+    rows = db
+      .query(
+        `SELECT occurred_at, session_id, skill_name, skill_path, query, triggered, source, skill_invocation_id
+         FROM skill_invocations
+         ORDER BY occurred_at DESC, skill_invocation_id DESC
+         LIMIT ?`,
+      )
+      .all(fetchLimit) as typeof rows;
+  }
+
+  const hasMore = rows.length > limit;
+  const pageRows = hasMore ? rows.slice(0, limit) : rows;
+
+  const items: SkillUsageRecord[] = pageRows.map((row) => ({
+    timestamp: row.occurred_at,
+    session_id: row.session_id,
+    skill_name: row.skill_name,
+    skill_path: row.skill_path,
+    query: row.query,
+    triggered: row.triggered === 1,
+    source: row.source,
+  }));
+
+  const lastRow = pageRows[pageRows.length - 1];
+  const next_cursor: PaginationCursor | null =
+    hasMore && lastRow ? { timestamp: lastRow.occurred_at, id: lastRow.skill_invocation_id } : null;
+
+  return { items, next_cursor, has_more: hasMore };
+}
+
+function paginateSkillReportInvocations(
+  db: Database,
+  skillName: string,
+  limit: number,
+  cursor: PaginationCursor | null,
+): PaginatedResult<{
+  timestamp: string;
+  session_id: string;
+  query: string;
+  triggered: boolean;
+  source: string | null;
+}> {
+  const fetchLimit = limit + 1;
+
+  let rows: Array<{
+    occurred_at: string;
+    session_id: string;
+    query: string;
+    triggered: number;
+    source: string | null;
+    skill_invocation_id: string;
+  }>;
+
+  if (cursor) {
+    rows = db
+      .query(
+        `SELECT si.occurred_at, si.session_id, COALESCE(si.query, p.prompt_text) as query,
+                si.triggered, 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,
+        cursor.timestamp,
+        cursor.timestamp,
+        String(cursor.id),
+        fetchLimit,
+      ) as typeof rows;
+  } else {
+    rows = db
+      .query(
+        `SELECT si.occurred_at, si.session_id, COALESCE(si.query, p.prompt_text) as query,
+                si.triggered, 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, fetchLimit) as typeof rows;
+  }
+
+  const hasMore = rows.length > limit;
+  const pageRows = hasMore ? rows.slice(0, limit) : rows;
+
+  const items = pageRows.map((row) => ({
+    timestamp: row.occurred_at,
+    session_id: row.session_id,
+    query: row.query ?? "",
+    triggered: row.triggered === 1,
+    source: row.source,
+  }));
+
+  const lastRow = pageRows[pageRows.length - 1];
+  const next_cursor: PaginationCursor | null =
+    hasMore && lastRow ? { timestamp: lastRow.occurred_at, id: lastRow.skill_invocation_id } : null;
+
+  return { items, next_cursor, has_more: hasMore };
+}
+
 /**
  * Get a summary list of all skills with aggregated stats.
  */
@@ -390,13 +779,12 @@ export function getActiveSessionCount(db: Database): number {
  * session is still in progress (no session_telemetry row yet).
  */
 export function getRecentActivity(db: Database, limit = 20): RecentActivityItem[] {
+  // Step 1: Fetch recent invocations without JOIN (avoids materializing full JOIN before LIMIT)
   const rows = db
     .query(
-      `SELECT si.occurred_at, si.session_id, si.skill_name, si.query, si.triggered,
-              CASE WHEN st.session_id IS NULL THEN 1 ELSE 0 END as is_live
-       FROM skill_invocations si
-       LEFT JOIN session_telemetry st ON si.session_id = st.session_id
-       ORDER BY si.occurred_at DESC
+      `SELECT occurred_at, session_id, skill_name, query, triggered
+       FROM skill_invocations
+       ORDER BY occurred_at DESC
        LIMIT ?`,
     )
     .all(limit) as Array<{
@@ -405,16 +793,27 @@ export function getRecentActivity(db: Database, limit = 20): RecentActivityItem[
     skill_name: string;
     query: string;
     triggered: number;
-    is_live: number;
   }>;
 
+  if (rows.length === 0) return [];
+
+  // Step 2: Batch lookup which sessions have completed (have a telemetry row)
+  const uniqueSessionIds = [...new Set(rows.map((r) => r.session_id))];
+  const placeholders = uniqueSessionIds.map(() => "?").join(",");
+  const completedRows = db
+    .query(
+      `SELECT DISTINCT session_id FROM session_telemetry WHERE session_id IN (${placeholders})`,
+    )
+    .all(...uniqueSessionIds) as Array<{ session_id: string }>;
+  const completedSessions = new Set(completedRows.map((r) => r.session_id));
+
   return rows.map((row) => ({
     timestamp: row.occurred_at,
     session_id: row.session_id,
     skill_name: row.skill_name,
     query: row.query ?? "",
     triggered: row.triggered === 1,
-    is_live: row.is_live === 1,
+    is_live: !completedSessions.has(row.session_id),
   }));
 }
 
@@ -914,6 +1313,152 @@ export function getOldestPendingAge(db: Database): number | null {
   }
 }
 
+// -- Execution metrics & commit tracking queries ------------------------------
+
+/**
+ * Aggregate execution_facts enrichment columns for a set of session IDs.
+ *
+ * Returns file change stats, cost totals, token breakdowns, artifact counts,
+ * and session_type distribution across the provided sessions.
+ */
+export function getExecutionMetrics(db: Database, sessionIds: string[]): ExecutionMetrics {
+  const empty: ExecutionMetrics = {
+    avg_files_changed: 0,
+    total_lines_added: 0,
+    total_lines_removed: 0,
+    total_cost_usd: 0,
+    avg_cost_usd: 0,
+    cached_input_tokens_total: 0,
+    reasoning_output_tokens_total: 0,
+    artifact_count: 0,
+    session_type_distribution: {},
+  };
+  if (sessionIds.length === 0) return empty;
+
+  const placeholders = sessionIds.map(() => "?").join(",");
+  const row = db
+    .query(
+      `SELECT
+         COALESCE(AVG(files_changed), 0) AS avg_files_changed,
+         COALESCE(SUM(lines_added), 0) AS total_lines_added,
+         COALESCE(SUM(lines_removed), 0) AS total_lines_removed,
+         COALESCE(SUM(cost_usd), 0) AS total_cost_usd,
+         COALESCE(AVG(cost_usd), 0) AS avg_cost_usd,
+         COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens_total,
+         COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens_total,
+         COALESCE(SUM(artifact_count), 0) AS artifact_count
+       FROM execution_facts
+       WHERE session_id IN (${placeholders})`,
+    )
+    .get(...sessionIds) as {
+    avg_files_changed: number;
+    total_lines_added: number;
+    total_lines_removed: number;
+    total_cost_usd: number;
+    avg_cost_usd: number;
+    cached_input_tokens_total: number;
+    reasoning_output_tokens_total: number;
+    artifact_count: number;
+  } | null;
+
+  // Session type distribution
+  const typeRows = db
+    .query(
+      `SELECT session_type, COUNT(*) AS count
+       FROM execution_facts
+       WHERE session_id IN (${placeholders}) AND session_type IS NOT NULL
+       GROUP BY session_type`,
+    )
+    .all(...sessionIds) as Array<{ session_type: string; count: number }>;
+
+  const session_type_distribution: Record<string, number> = {};
+  for (const tr of typeRows) {
+    session_type_distribution[tr.session_type] = tr.count;
+  }
+
+  return {
+    avg_files_changed: row?.avg_files_changed ?? 0,
+    total_lines_added: row?.total_lines_added ?? 0,
+    total_lines_removed: row?.total_lines_removed ?? 0,
+    total_cost_usd: row?.total_cost_usd ?? 0,
+    avg_cost_usd: row?.avg_cost_usd ?? 0,
+    cached_input_tokens_total: row?.cached_input_tokens_total ?? 0,
+    reasoning_output_tokens_total: row?.reasoning_output_tokens_total ?? 0,
+    artifact_count: row?.artifact_count ?? 0,
+    session_type_distribution,
+  };
+}
+
+/**
+ * Get all commits tracked for a given session.
+ */
+export function getSessionCommits(db: Database, sessionId: string): CommitRecord[] {
+  return db
+    .query(
+      `SELECT commit_sha, commit_title, branch, repo_remote, timestamp
+       FROM commit_tracking
+       WHERE session_id = ?
+       ORDER BY timestamp DESC`,
+    )
+    .all(sessionId) as CommitRecord[];
+}
+
+/**
+ * Aggregate commit stats for a skill by joining commit_tracking to skill_invocations
+ * via shared session_id.
+ */
+export function getSkillCommitSummary(db: Database, skillName: string): CommitSummary {
+  const empty: CommitSummary = {
+    total_commits: 0,
+    unique_branches: 0,
+    recent_commits: [],
+  };
+
+  const statsRow = db
+    .query(
+      `WITH skill_sessions AS (
+         SELECT DISTINCT session_id FROM skill_invocations WHERE skill_name = ?
+       )
+       SELECT
+         COUNT(*) AS total_commits,
+         COUNT(DISTINCT ct.branch) AS unique_branches
+       FROM commit_tracking ct
+       WHERE ct.session_id IN (SELECT session_id FROM skill_sessions)`,
+    )
+    .get(skillName) as { total_commits: number; unique_branches: number } | null;
+
+  if (!statsRow || statsRow.total_commits === 0) return empty;
+
+  const recentRows = db
+    .query(
+      `WITH skill_sessions AS (
+         SELECT DISTINCT session_id FROM skill_invocations WHERE skill_name = ?
+       )
+       SELECT ct.commit_sha, ct.commit_title, ct.branch, ct.timestamp
+       FROM commit_tracking ct
+       WHERE ct.session_id IN (SELECT session_id FROM skill_sessions)
+       ORDER BY ct.timestamp DESC
+       LIMIT 20`,
+    )
+    .all(skillName) as Array<{
+    commit_sha: string;
+    commit_title: string | null;
+    branch: string | null;
+    timestamp: string;
+  }>;
+
+  return {
+    total_commits: statsRow.total_commits,
+    unique_branches: statsRow.unique_branches,
+    recent_commits: recentRows.map((r) => ({
+      sha: r.commit_sha,
+      title: r.commit_title ?? "",
+      branch: r.branch ?? "",
+      timestamp: r.timestamp,
+    })),
+  };
+}
+
 // -- Helpers ------------------------------------------------------------------
 
 export function safeParseJsonArray<T = string>(json: string | null): T[] {

package/cli/selftune/localdb/schema.ts

@@ -260,6 +260,20 @@ CREATE TABLE IF NOT EXISTS upload_watermarks (
   updated_at       TEXT NOT NULL
 )`;
 
+// -- Commit tracking table ----------------------------------------------------
+
+export const CREATE_COMMIT_TRACKING = `
+CREATE TABLE IF NOT EXISTS commit_tracking (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id    TEXT NOT NULL,
+  commit_sha    TEXT NOT NULL,
+  commit_title  TEXT,
+  branch        TEXT,
+  repo_remote   TEXT,
+  timestamp     TEXT NOT NULL,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
 // -- Metadata table -----------------------------------------------------------
 
 export const CREATE_META = `
@@ -317,6 +331,11 @@ export const CREATE_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_staging_kind ON canonical_upload_staging(record_kind)`,
   `CREATE INDEX IF NOT EXISTS idx_staging_session ON canonical_upload_staging(session_id)`,
   `CREATE UNIQUE INDEX IF NOT EXISTS idx_staging_dedup ON canonical_upload_staging(record_kind, record_id)`,
+  // -- Commit tracking indexes ------------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_commit_sha ON commit_tracking(commit_sha)`,
+  `CREATE INDEX IF NOT EXISTS idx_commit_session ON commit_tracking(session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_commit_ts ON commit_tracking(timestamp)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_commit_dedup ON commit_tracking(session_id, commit_sha)`,
 ];
 
 /**
@@ -353,6 +372,31 @@ export const MIGRATIONS = [
   `ALTER TABLE execution_facts ADD COLUMN normalizer_version TEXT`,
   `ALTER TABLE execution_facts ADD COLUMN capture_mode TEXT`,
   `ALTER TABLE execution_facts ADD COLUMN raw_source_ref TEXT`,
+  // -- Win 2+3: File change metrics + token granularity + cost (execution_facts) --
+  `ALTER TABLE execution_facts ADD COLUMN files_changed INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN lines_added INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN lines_removed INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN lines_modified INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN cached_input_tokens INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN reasoning_output_tokens INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN cost_usd REAL`,
+  // -- Win 2+3: File change metrics + token granularity + cost (session_telemetry) --
+  `ALTER TABLE session_telemetry ADD COLUMN files_changed INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN lines_added INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN lines_removed INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN lines_modified INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN cached_input_tokens INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN reasoning_output_tokens INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN cost_usd REAL`,
+  // -- Generalized metrics: artifact count + session type --
+  `ALTER TABLE execution_facts ADD COLUMN artifact_count INTEGER`,
+  `ALTER TABLE execution_facts ADD COLUMN session_type TEXT`,
+  `ALTER TABLE session_telemetry ADD COLUMN artifact_count INTEGER`,
+  `ALTER TABLE session_telemetry ADD COLUMN session_type TEXT`,
+  // -- Session summary (heuristic, no LLM) --
+  `ALTER TABLE session_telemetry ADD COLUMN agent_summary TEXT`,
+  // -- SHA256 content hashing for upload dedup --
+  `ALTER TABLE canonical_upload_staging ADD COLUMN content_sha256 TEXT`,
 ];
 
 /** Indexes that depend on migration columns — must run AFTER MIGRATIONS. */
@@ -360,6 +404,7 @@ export const POST_MIGRATION_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_skill_inv_query_triggered ON skill_invocations(query, triggered)`,
   `CREATE INDEX IF NOT EXISTS idx_skill_inv_scope ON skill_invocations(skill_name, skill_scope, occurred_at)`,
   `CREATE INDEX IF NOT EXISTS idx_skill_inv_dedup ON skill_invocations(session_id, skill_name, query, occurred_at, triggered)`,
+  `CREATE INDEX IF NOT EXISTS idx_staging_sha256 ON canonical_upload_staging(content_sha256)`,
 ];
 
 /** All DDL statements in creation order. */
@@ -379,6 +424,7 @@ export const ALL_DDL = [
   CREATE_UPLOAD_QUEUE,
   CREATE_UPLOAD_WATERMARKS,
   CREATE_CANONICAL_UPLOAD_STAGING,
+  CREATE_COMMIT_TRACKING,
   CREATE_META,
   ...CREATE_INDEXES,
 ];