selftune 0.2.6 → 0.2.8

package/cli/selftune/localdb/queries.ts

@@ -45,13 +45,13 @@ export function getOverviewPayload(db: Database): OverviewPayload {
   // Skill usage (bounded to most recent 2000)
   const skillRows = db
     .query(
-      `SELECT timestamp, session_id, skill_name, skill_path, query, triggered, source
-       FROM skill_usage
-       ORDER BY timestamp DESC
+      `SELECT occurred_at, session_id, skill_name, skill_path, query, triggered, source
+       FROM skill_invocations
+       ORDER BY occurred_at DESC
        LIMIT 2000`,
     )
     .all() as Array<{
-    timestamp: string;
+    occurred_at: string;
     session_id: string;
     skill_name: string;
     skill_path: string;
@@ -61,7 +61,7 @@ export function getOverviewPayload(db: Database): OverviewPayload {
   }>;
 
   const skills = skillRows.map((row) => ({
-    timestamp: row.timestamp,
+    timestamp: row.occurred_at,
     session_id: row.session_id,
     skill_name: row.skill_name,
     skill_path: row.skill_path,
@@ -73,7 +73,7 @@ export function getOverviewPayload(db: Database): OverviewPayload {
   // Evolution audit (bounded to most recent 500)
   const evolution = db
     .query(
-      `SELECT timestamp, proposal_id, action, details
+      `SELECT timestamp, proposal_id, skill_name, action, details
        FROM evolution_audit
        ORDER BY timestamp DESC
        LIMIT 500`,
@@ -81,6 +81,7 @@ export function getOverviewPayload(db: Database): OverviewPayload {
     .all() as Array<{
     timestamp: string;
     proposal_id: string;
+    skill_name: string | null;
     action: string;
     details: string;
   }>;
@@ -90,7 +91,7 @@ export function getOverviewPayload(db: Database): OverviewPayload {
     .query(
       `SELECT
          (SELECT COUNT(*) FROM session_telemetry) as telemetry,
-         (SELECT COUNT(*) FROM skill_usage) as skills,
+         (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,
@@ -105,18 +106,18 @@ export function getOverviewPayload(db: Database): OverviewPayload {
     prompts: number;
   };
 
-  // Unmatched queries: skill_usage entries where triggered = 0 and no other
+  // Unmatched queries: skill_invocations entries where triggered = 0 and no other
   // record for the same query text triggered
   const unmatchedRows = db
     .query(
-      `SELECT su.timestamp, su.session_id, su.query
-       FROM skill_usage su
-       WHERE su.triggered = 0
+      `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_usage su2
-           WHERE su2.query = su.query AND su2.triggered = 1
+           SELECT 1 FROM skill_invocations si2
+           WHERE si2.query = si.query AND si2.triggered = 1
          )
-       ORDER BY su.timestamp DESC
+       ORDER BY si.occurred_at DESC
        LIMIT 500`,
     )
     .all() as Array<{ timestamp: string; session_id: string; query: string }>;
@@ -144,7 +145,7 @@ export function getSkillReportPayload(db: Database, skillName: string): SkillRep
       `SELECT
          COUNT(*) as total_checks,
          SUM(CASE WHEN triggered = 1 THEN 1 ELSE 0 END) as triggered_count
-       FROM skill_usage
+       FROM skill_invocations
        WHERE skill_name = ?`,
     )
     .get(skillName) as { total_checks: number; triggered_count: number };
@@ -156,14 +157,14 @@ export function getSkillReportPayload(db: Database, skillName: string): SkillRep
   // Recent invocations (last 100)
   const invocationRows = db
     .query(
-      `SELECT timestamp, session_id, query, triggered, source
-       FROM skill_usage
+      `SELECT occurred_at, session_id, query, triggered, source
+       FROM skill_invocations
        WHERE skill_name = ?
-       ORDER BY timestamp DESC
+       ORDER BY occurred_at DESC
        LIMIT 100`,
     )
     .all(skillName) as Array<{
-    timestamp: string;
+    occurred_at: string;
     session_id: string;
     query: string;
     triggered: number;
@@ -171,7 +172,7 @@ export function getSkillReportPayload(db: Database, skillName: string): SkillRep
   }>;
 
   const recent_invocations = invocationRows.map((row) => ({
-    timestamp: row.timestamp,
+    timestamp: row.occurred_at,
     session_id: row.session_id,
     query: row.query,
     triggered: row.triggered === 1,
@@ -218,7 +219,7 @@ export function getSkillReportPayload(db: Database, skillName: string): SkillRep
 
   // Unique sessions count
   const sessionsRow = db
-    .query(`SELECT COUNT(DISTINCT session_id) as c FROM skill_usage WHERE skill_name = ?`)
+    .query(`SELECT COUNT(DISTINCT session_id) as c FROM skill_invocations WHERE skill_name = ?`)
     .get(skillName) as { c: number };
 
   return {
@@ -241,16 +242,21 @@ export function getSkillsList(db: Database): SkillSummary[] {
   const rows = db
     .query(
       `SELECT
-         su.skill_name,
-         (SELECT s2.skill_scope FROM skill_usage s2
-          WHERE s2.skill_name = su.skill_name AND s2.skill_scope IS NOT NULL
-          ORDER BY s2.timestamp DESC LIMIT 1) as skill_scope,
+         si.skill_name,
+         COALESCE(
+           (SELECT s2.skill_scope FROM skill_invocations s2
+            WHERE s2.skill_name = si.skill_name AND s2.skill_scope IS NOT NULL
+            ORDER BY s2.occurred_at DESC LIMIT 1),
+           (SELECT su.skill_scope FROM skill_usage su
+            WHERE su.skill_name = si.skill_name AND su.skill_scope IS NOT NULL
+            ORDER BY su.timestamp DESC LIMIT 1)
+         ) as skill_scope,
          COUNT(*) as total_checks,
-         SUM(CASE WHEN su.triggered = 1 THEN 1 ELSE 0 END) as triggered_count,
-         COUNT(DISTINCT su.session_id) as unique_sessions,
-         MAX(su.timestamp) as last_seen
-       FROM skill_usage su
-       GROUP BY su.skill_name
+         SUM(CASE WHEN si.triggered = 1 THEN 1 ELSE 0 END) as triggered_count,
+         COUNT(DISTINCT si.session_id) as unique_sessions,
+         MAX(si.occurred_at) as last_seen
+       FROM skill_invocations si
+       GROUP BY si.skill_name
        ORDER BY total_checks DESC`,
     )
     .all() as Array<{
@@ -354,9 +360,296 @@ export function getOrchestrateRuns(db: Database, limit = 20): OrchestrateRunRepo
   }));
 }
 
+// -- Generic read queries (Phase 3: replace readJsonl calls) ------------------
+
+/**
+ * Read all session telemetry records from SQLite.
+ * Replaces: readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG)
+ */
+export function querySessionTelemetry(db: Database): Array<{
+  timestamp: string;
+  session_id: string;
+  cwd: string;
+  transcript_path: string;
+  tool_calls: Record<string, number>;
+  total_tool_calls: number;
+  bash_commands: string[];
+  skills_triggered: string[];
+  skills_invoked?: string[];
+  assistant_turns: number;
+  errors_encountered: number;
+  transcript_chars: number;
+  last_user_query: string;
+  source?: string;
+  input_tokens?: number;
+  output_tokens?: number;
+}> {
+  const rows = db.query(`SELECT * FROM session_telemetry ORDER BY timestamp DESC`).all() as Array<
+    Record<string, unknown>
+  >;
+  return rows.map((r) => ({
+    timestamp: r.timestamp as string,
+    session_id: r.session_id as string,
+    cwd: r.cwd as string,
+    transcript_path: r.transcript_path as string,
+    tool_calls: (safeParseJson(r.tool_calls_json as string) as Record<string, number>) ?? {},
+    total_tool_calls: r.total_tool_calls as number,
+    bash_commands: safeParseJsonArray<string>(r.bash_commands_json as string),
+    skills_triggered: safeParseJsonArray<string>(r.skills_triggered_json as string),
+    skills_invoked: r.skills_invoked_json
+      ? safeParseJsonArray<string>(r.skills_invoked_json as string)
+      : undefined,
+    assistant_turns: r.assistant_turns as number,
+    errors_encountered: r.errors_encountered as number,
+    transcript_chars: (r.transcript_chars as number) ?? 0,
+    last_user_query: (r.last_user_query as string) ?? "",
+    source: r.source as string | undefined,
+    input_tokens: r.input_tokens as number | undefined,
+    output_tokens: r.output_tokens as number | undefined,
+  }));
+}
+
+/**
+ * Read all skill invocation records from SQLite.
+ * Replaces: readEffectiveSkillUsageRecords()
+ */
+export function querySkillRecords(db: Database): Array<{
+  timestamp: string;
+  session_id: string;
+  skill_name: string;
+  skill_path: string;
+  skill_scope?: string;
+  query: string;
+  triggered: boolean;
+  source?: string;
+}> {
+  const rows = db
+    .query(
+      `SELECT occurred_at, session_id, skill_name, skill_path, skill_scope, query, triggered, source
+     FROM skill_invocations ORDER BY occurred_at DESC`,
+    )
+    .all() as Array<Record<string, unknown>>;
+  return rows.map((r) => ({
+    timestamp: r.occurred_at as string,
+    session_id: r.session_id as string,
+    skill_name: r.skill_name as string,
+    skill_path: r.skill_path as string,
+    skill_scope: r.skill_scope as string | undefined,
+    query: r.query as string,
+    triggered: (r.triggered as number) === 1,
+    source: r.source as string | undefined,
+  }));
+}
+
+/** @deprecated Use querySkillRecords instead. Kept for backward compatibility. */
+export const querySkillUsageRecords = querySkillRecords;
+
+/**
+ * Read all query log records from SQLite.
+ * Replaces: readJsonl<QueryLogRecord>(QUERY_LOG)
+ */
+export function queryQueryLog(db: Database): Array<{
+  timestamp: string;
+  session_id: string;
+  query: string;
+  source?: string;
+}> {
+  return db
+    .query(`SELECT timestamp, session_id, query, source FROM queries ORDER BY timestamp DESC`)
+    .all() as Array<{ timestamp: string; session_id: string; query: string; source?: string }>;
+}
+
+/**
+ * Read all evolution audit entries from SQLite.
+ * Replaces: readJsonl<EvolutionAuditEntry>(EVOLUTION_AUDIT_LOG)
+ */
+export function queryEvolutionAudit(
+  db: Database,
+  skillName?: string,
+): Array<{
+  timestamp: string;
+  proposal_id: string;
+  skill_name?: string;
+  action: string;
+  details: string;
+  eval_snapshot?: Record<string, unknown>;
+}> {
+  const sql = skillName
+    ? `SELECT * FROM evolution_audit
+       WHERE skill_name = ?
+          OR (skill_name IS NULL AND proposal_id LIKE 'evo-' || ? || '-%')
+       ORDER BY timestamp DESC`
+    : `SELECT * FROM evolution_audit ORDER BY timestamp DESC`;
+  const rows = (skillName ? db.query(sql).all(skillName, skillName) : db.query(sql).all()) as Array<
+    Record<string, unknown>
+  >;
+  return rows.map((r) => ({
+    timestamp: r.timestamp as string,
+    proposal_id: r.proposal_id as string,
+    skill_name: r.skill_name as string | undefined,
+    action: r.action as string,
+    details: r.details as string,
+    eval_snapshot: r.eval_snapshot_json
+      ? (safeParseJson(r.eval_snapshot_json as string) as Record<string, unknown>)
+      : undefined,
+  }));
+}
+
+/**
+ * Read all evolution evidence entries from SQLite.
+ * Replaces: readEvidenceTrail() / readJsonl<EvolutionEvidenceEntry>(EVOLUTION_EVIDENCE_LOG)
+ */
+export function queryEvolutionEvidence(
+  db: Database,
+  skillName?: string,
+): Array<{
+  timestamp: string;
+  proposal_id: string;
+  skill_name: string;
+  skill_path: string;
+  target: string;
+  stage: string;
+  rationale?: string;
+  confidence?: number;
+  details?: string;
+  original_text?: string;
+  proposed_text?: string;
+  eval_set?: Record<string, unknown>[];
+  validation?: Record<string, unknown>;
+}> {
+  const sql = skillName
+    ? `SELECT * FROM evolution_evidence WHERE skill_name = ? ORDER BY timestamp DESC`
+    : `SELECT * FROM evolution_evidence ORDER BY timestamp DESC`;
+  const rows = (skillName ? db.query(sql).all(skillName) : db.query(sql).all()) as Array<
+    Record<string, unknown>
+  >;
+  return rows.map((r) => ({
+    timestamp: r.timestamp as string,
+    proposal_id: r.proposal_id as string,
+    skill_name: r.skill_name as string,
+    skill_path: r.skill_path as string,
+    target: r.target as string,
+    stage: r.stage as string,
+    rationale: r.rationale as string | undefined,
+    confidence: r.confidence as number | undefined,
+    details: r.details as string | undefined,
+    original_text: r.original_text as string | undefined,
+    proposed_text: r.proposed_text as string | undefined,
+    eval_set: r.eval_set_json
+      ? safeParseJsonArray<Record<string, unknown>>(r.eval_set_json as string)
+      : undefined,
+    validation: r.validation_json
+      ? (safeParseJson(r.validation_json as string) as Record<string, unknown>)
+      : undefined,
+  }));
+}
+
+/**
+ * Read improvement signals from SQLite.
+ * Replaces: readJsonl<ImprovementSignalRecord>(SIGNAL_LOG)
+ */
+export function queryImprovementSignals(
+  db: Database,
+  consumedOnly?: boolean,
+): Array<{
+  timestamp: string;
+  session_id: string;
+  query: string;
+  signal_type: string;
+  mentioned_skill?: string;
+  consumed: boolean;
+  consumed_at?: string;
+  consumed_by_run?: string;
+}> {
+  const where =
+    consumedOnly === undefined ? "" : consumedOnly ? " WHERE consumed = 1" : " WHERE consumed = 0";
+  const rows = db
+    .query(`SELECT * FROM improvement_signals${where} ORDER BY timestamp DESC`)
+    .all() as Array<Record<string, unknown>>;
+  return rows.map((r) => ({
+    timestamp: r.timestamp as string,
+    session_id: r.session_id as string,
+    query: r.query as string,
+    signal_type: r.signal_type as string,
+    mentioned_skill: r.mentioned_skill as string | undefined,
+    consumed: (r.consumed as number) === 1,
+    consumed_at: r.consumed_at as string | undefined,
+    consumed_by_run: r.consumed_by_run as string | undefined,
+  }));
+}
+
+// -- Alpha upload query helpers -----------------------------------------------
+
+/**
+ * Get the most recent failed queue item's error and timestamp.
+ * Returns null if no failed items exist.
+ */
+export function getLastUploadError(
+  db: Database,
+): { last_error: string | null; updated_at: string } | null {
+  try {
+    const row = db
+      .query(
+        `SELECT last_error, updated_at
+         FROM upload_queue
+         WHERE status = 'failed'
+         ORDER BY updated_at DESC
+         LIMIT 1`,
+      )
+      .get() as { last_error: string | null; updated_at: string } | null;
+    return row ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the most recent sent queue item's timestamp.
+ * Returns null if no sent items exist.
+ */
+export function getLastUploadSuccess(db: Database): { updated_at: string } | null {
+  try {
+    const row = db
+      .query(
+        `SELECT updated_at
+         FROM upload_queue
+         WHERE status = 'sent'
+         ORDER BY updated_at DESC
+         LIMIT 1`,
+      )
+      .get() as { updated_at: string } | null;
+    return row ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the age in seconds of the oldest pending queue item.
+ * Returns null if no pending items exist.
+ */
+export function getOldestPendingAge(db: Database): number | null {
+  try {
+    const row = db
+      .query(
+        `SELECT created_at
+         FROM upload_queue
+         WHERE status = 'pending'
+         ORDER BY created_at ASC
+         LIMIT 1`,
+      )
+      .get() as { created_at: string } | null;
+    if (!row) return null;
+    const ageMs = Date.now() - new Date(row.created_at).getTime();
+    return Math.floor(ageMs / 1000);
+  } catch {
+    return null;
+  }
+}
+
 // -- Helpers ------------------------------------------------------------------
 
-function safeParseJsonArray<T = string>(json: string | null): T[] {
+export function safeParseJsonArray<T = string>(json: string | null): T[] {
   if (!json) return [];
   try {
     const parsed = JSON.parse(json);
@@ -366,7 +659,7 @@ function safeParseJsonArray<T = string>(json: string | null): T[] {
   }
 }
 
-function safeParseJson(json: string | null): Record<string, unknown> | null {
+export function safeParseJson(json: string | null): Record<string, unknown> | null {
   if (!json) return null;
   try {
     return JSON.parse(json);

package/cli/selftune/localdb/schema.ts

@@ -47,6 +47,11 @@ CREATE TABLE IF NOT EXISTS skill_invocations (
   confidence          REAL,
   tool_name           TEXT,
   matched_prompt_id   TEXT,
+  agent_type          TEXT,
+  query               TEXT,
+  skill_path          TEXT,
+  skill_scope         TEXT,
+  source              TEXT,
   FOREIGN KEY (session_id) REFERENCES sessions(session_id)
 )`;
 
@@ -151,6 +156,67 @@ CREATE TABLE IF NOT EXISTS orchestrate_runs (
   skill_actions_json TEXT NOT NULL
 )`;
 
+// -- Query log table (from all_queries_log.jsonl) ----------------------------
+
+export const CREATE_QUERIES = `
+CREATE TABLE IF NOT EXISTS queries (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp   TEXT NOT NULL,
+  session_id  TEXT NOT NULL,
+  query       TEXT NOT NULL,
+  source      TEXT
+)`;
+
+// -- Improvement signal table (from signal_log.jsonl) ------------------------
+
+export const CREATE_IMPROVEMENT_SIGNALS = `
+CREATE TABLE IF NOT EXISTS improvement_signals (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp       TEXT NOT NULL,
+  session_id      TEXT NOT NULL,
+  query           TEXT NOT NULL,
+  signal_type     TEXT NOT NULL,
+  mentioned_skill TEXT,
+  consumed        INTEGER NOT NULL DEFAULT 0,
+  consumed_at     TEXT,
+  consumed_by_run TEXT
+)`;
+
+// -- Alpha upload queue -------------------------------------------------------
+
+export const CREATE_UPLOAD_QUEUE = `
+CREATE TABLE IF NOT EXISTS upload_queue (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  payload_type  TEXT NOT NULL,
+  payload_json  TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'pending',
+  attempts      INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  last_error    TEXT
+)`;
+
+// -- Canonical upload staging -------------------------------------------------
+
+export const CREATE_CANONICAL_UPLOAD_STAGING = `
+CREATE TABLE IF NOT EXISTS canonical_upload_staging (
+  local_seq     INTEGER PRIMARY KEY AUTOINCREMENT,
+  record_kind   TEXT NOT NULL,
+  record_id     TEXT NOT NULL,
+  record_json   TEXT NOT NULL,
+  session_id    TEXT,
+  prompt_id     TEXT,
+  normalized_at TEXT,
+  staged_at     TEXT NOT NULL
+)`;
+
+export const CREATE_UPLOAD_WATERMARKS = `
+CREATE TABLE IF NOT EXISTS upload_watermarks (
+  payload_type     TEXT PRIMARY KEY,
+  last_uploaded_id INTEGER NOT NULL,
+  updated_at       TEXT NOT NULL
+)`;
+
 // -- Metadata table -----------------------------------------------------------
 
 export const CREATE_META = `
@@ -167,6 +233,7 @@ export const CREATE_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_prompts_occurred ON prompts(occurred_at)`,
   `CREATE INDEX IF NOT EXISTS idx_skill_inv_session ON skill_invocations(session_id)`,
   `CREATE INDEX IF NOT EXISTS idx_skill_inv_name ON skill_invocations(skill_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_skill_inv_ts ON skill_invocations(occurred_at)`,
   `CREATE INDEX IF NOT EXISTS idx_exec_facts_session ON execution_facts(session_id)`,
   `CREATE INDEX IF NOT EXISTS idx_evo_evidence_proposal ON evolution_evidence(proposal_id)`,
   `CREATE INDEX IF NOT EXISTS idx_evo_evidence_skill ON evolution_evidence(skill_name)`,
@@ -186,6 +253,43 @@ export const CREATE_INDEXES = [
   `CREATE UNIQUE INDEX IF NOT EXISTS idx_evo_evidence_dedup ON evolution_evidence(proposal_id, stage, timestamp)`,
   // -- Orchestrate run indexes -----------------------------------------------
   `CREATE INDEX IF NOT EXISTS idx_orchestrate_runs_ts ON orchestrate_runs(timestamp)`,
+  // -- Query log indexes ------------------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_queries_session ON queries(session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_queries_ts ON queries(timestamp)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_queries_dedup ON queries(session_id, query, timestamp)`,
+  // -- Improvement signal indexes ---------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_signals_session ON improvement_signals(session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_signals_consumed ON improvement_signals(consumed)`,
+  `CREATE INDEX IF NOT EXISTS idx_signals_ts ON improvement_signals(timestamp)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_signals_dedup ON improvement_signals(session_id, query, signal_type, timestamp)`,
+  // -- Alpha upload queue indexes ---------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_upload_queue_status ON upload_queue(status)`,
+  `CREATE INDEX IF NOT EXISTS idx_upload_queue_type_status ON upload_queue(payload_type, status)`,
+  // -- Canonical upload staging 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)`,
+];
+
+/**
+ * Schema migrations — ALTER TABLE statements for columns added after initial release.
+ * Each is safe to re-run: SQLite throws "duplicate column" which openDb() catches.
+ */
+export const MIGRATIONS = [
+  // skill_invocations consolidation (skill_usage columns merged in)
+  `ALTER TABLE skill_invocations ADD COLUMN query TEXT`,
+  `ALTER TABLE skill_invocations ADD COLUMN skill_path TEXT`,
+  `ALTER TABLE skill_invocations ADD COLUMN skill_scope TEXT`,
+  `ALTER TABLE skill_invocations ADD COLUMN source TEXT`,
+  // Track how many iteration loops each evolution run used
+  `ALTER TABLE evolution_audit ADD COLUMN iterations_used INTEGER`,
+];
+
+/** Indexes that depend on migration columns — must run AFTER MIGRATIONS. */
+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)`,
 ];
 
 /** All DDL statements in creation order. */
@@ -199,6 +303,11 @@ export const ALL_DDL = [
   CREATE_SESSION_TELEMETRY,
   CREATE_SKILL_USAGE,
   CREATE_ORCHESTRATE_RUNS,
+  CREATE_QUERIES,
+  CREATE_IMPROVEMENT_SIGNALS,
+  CREATE_UPLOAD_QUEUE,
+  CREATE_UPLOAD_WATERMARKS,
+  CREATE_CANONICAL_UPLOAD_STAGING,
   CREATE_META,
   ...CREATE_INDEXES,
 ];

package/cli/selftune/monitoring/watch.ts

@@ -11,6 +11,12 @@ import { parseArgs } from "node:util";
 import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
 import { classifyInvocation } from "../eval/hooks-to-evals.js";
 import { getLastDeployedProposal } from "../evolution/audit.js";
+import { getDb } from "../localdb/db.js";
+import {
+  queryQueryLog,
+  querySessionTelemetry,
+  querySkillUsageRecords,
+} from "../localdb/queries.js";
 import { updateContextAfterWatch } from "../memory/writer.js";
 import type { SyncResult } from "../sync.js";
 import type {
@@ -25,7 +31,6 @@ import {
   filterActionableQueryRecords,
   filterActionableSkillUsageRecords,
 } from "../utils/query-filter.js";
-import { readEffectiveSkillUsageRecords } from "../utils/skill-log.js";
 
 // ---------------------------------------------------------------------------
 // Public interfaces
@@ -207,13 +212,26 @@ export async function watch(options: WatchOptions): Promise<WatchResult> {
     );
   }
 
-  // 1. Read log files
-  const telemetry = readJsonl<SessionTelemetryRecord>(_telemetryLogPath);
-  const skillRecords =
-    _skillLogPath === SKILL_LOG
-      ? readEffectiveSkillUsageRecords()
-      : readJsonl<SkillUsageRecord>(_skillLogPath);
-  const queryRecords = readJsonl<QueryLogRecord>(_queryLogPath);
+  // 1. Read log files from SQLite (fall back to JSONL for custom paths)
+  let telemetry: SessionTelemetryRecord[];
+  let skillRecords: SkillUsageRecord[];
+  let queryRecords: QueryLogRecord[];
+  if (
+    _telemetryLogPath === TELEMETRY_LOG &&
+    _skillLogPath === SKILL_LOG &&
+    _queryLogPath === QUERY_LOG
+  ) {
+    const db = getDb();
+    telemetry = querySessionTelemetry(db) as SessionTelemetryRecord[];
+    // SQLite queries return DESC order; computeMonitoringSnapshot expects chronological (ASC)
+    telemetry.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    skillRecords = querySkillUsageRecords(db) as SkillUsageRecord[];
+    queryRecords = queryQueryLog(db) as QueryLogRecord[];
+  } else {
+    telemetry = readJsonl<SessionTelemetryRecord>(_telemetryLogPath);
+    skillRecords = readJsonl<SkillUsageRecord>(_skillLogPath);
+    queryRecords = readJsonl<QueryLogRecord>(_queryLogPath);
+  }
 
   // 2. Determine baseline pass rate from last deployed audit entry
   const lastDeployed = getLastDeployedProposal(skillName, _auditLogPath);