selftune 0.2.9 → 0.2.12

package/cli/selftune/localdb/queries.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+
 import type {
   OrchestrateRunReport,
   OverviewPayload,
@@ -578,6 +579,58 @@ export function queryImprovementSignals(
   }));
 }
 
+// -- Grading results query ----------------------------------------------------
+
+/**
+ * Read grading results from SQLite for upload staging.
+ */
+export function queryGradingResults(db: Database): Array<{
+  grading_id: string;
+  session_id: string;
+  skill_name: string;
+  transcript_path: string | null;
+  graded_at: string;
+  pass_rate: number | null;
+  mean_score: number | null;
+  score_std_dev: number | null;
+  passed_count: number | null;
+  failed_count: number | null;
+  total_count: number | null;
+  expectations_json: string | null;
+  claims_json: string | null;
+  eval_feedback_json: string | null;
+  failure_feedback_json: string | null;
+  execution_metrics_json: string | null;
+}> {
+  return db
+    .query(
+      `SELECT grading_id, session_id, skill_name, transcript_path, graded_at,
+              pass_rate, mean_score, score_std_dev, passed_count, failed_count, total_count,
+              expectations_json, claims_json, eval_feedback_json, failure_feedback_json,
+              execution_metrics_json
+       FROM grading_results
+       ORDER BY graded_at DESC`,
+    )
+    .all() as Array<{
+    grading_id: string;
+    session_id: string;
+    skill_name: string;
+    transcript_path: string | null;
+    graded_at: string;
+    pass_rate: number | null;
+    mean_score: number | null;
+    score_std_dev: number | null;
+    passed_count: number | null;
+    failed_count: number | null;
+    total_count: number | null;
+    expectations_json: string | null;
+    claims_json: string | null;
+    eval_feedback_json: string | null;
+    failure_feedback_json: string | null;
+    execution_metrics_json: string | null;
+  }>;
+}
+
 // -- Canonical record staging query -------------------------------------------
 
 /**

package/cli/selftune/localdb/schema.ts

@@ -188,6 +188,28 @@ CREATE TABLE IF NOT EXISTS queries (
   source      TEXT
 )`;
 
+// -- Grading results table (from grade-session output) -----------------------
+
+export const CREATE_GRADING_RESULTS = `
+CREATE TABLE IF NOT EXISTS grading_results (
+  grading_id              TEXT PRIMARY KEY,
+  session_id              TEXT NOT NULL,
+  skill_name              TEXT NOT NULL,
+  transcript_path         TEXT,
+  graded_at               TEXT NOT NULL,
+  pass_rate               REAL,
+  mean_score              REAL,
+  score_std_dev           REAL,
+  passed_count            INTEGER,
+  failed_count            INTEGER,
+  total_count             INTEGER,
+  expectations_json       TEXT,
+  claims_json             TEXT,
+  eval_feedback_json      TEXT,
+  failure_feedback_json   TEXT,
+  execution_metrics_json  TEXT
+)`;
+
 // -- Improvement signal table (from signal_log.jsonl) ------------------------
 
 export const CREATE_IMPROVEMENT_SIGNALS = `
@@ -278,6 +300,11 @@ export const CREATE_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)`,
+  // -- Grading results indexes -------------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_grading_session ON grading_results(session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_grading_skill ON grading_results(skill_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_grading_ts ON grading_results(graded_at)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_grading_dedup ON grading_results(session_id, skill_name, graded_at)`,
   // -- 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)`,
@@ -347,6 +374,7 @@ export const ALL_DDL = [
   CREATE_SKILL_USAGE,
   CREATE_ORCHESTRATE_RUNS,
   CREATE_QUERIES,
+  CREATE_GRADING_RESULTS,
   CREATE_IMPROVEMENT_SIGNALS,
   CREATE_UPLOAD_QUEUE,
   CREATE_UPLOAD_WATERMARKS,

package/cli/selftune/normalization.ts

@@ -24,6 +24,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { basename, dirname } from "node:path";
+
 import { CANONICAL_LOG, canonicalSessionStatePath } from "./constants.js";
 import { writeCanonicalBatchToDb, writeCanonicalToDb } from "./localdb/direct-write.js";
 import {

package/cli/selftune/observability.ts

@@ -11,6 +11,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+
 import { getAlphaGuidance } from "./agent-guidance.js";
 import { getAlphaLinkState, readAlphaIdentity } from "./alpha-identity.js";
 import { LOG_DIR, REQUIRED_FIELDS, SELFTUNE_CONFIG_PATH } from "./constants.js";

package/cli/selftune/repair/skill-usage.ts

@@ -3,6 +3,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { parseArgs } from "node:util";
+
 import {
   CLAUDE_CODE_PROJECTS_DIR,
   QUERY_LOG,

package/cli/selftune/routes/orchestrate-runs.ts

@@ -5,6 +5,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+
 import { getOrchestrateRuns } from "../localdb/queries.js";
 
 export function handleOrchestrateRuns(db: Database, limit: number): Response {

package/cli/selftune/routes/overview.ts

@@ -5,6 +5,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+
 import { getOverviewPayload, getSkillsList } from "../localdb/queries.js";
 
 export function handleOverview(db: Database, version: string): Response {

package/cli/selftune/routes/report.ts

@@ -180,7 +180,7 @@ function buildReportHTML(
       <tr><th>Metric</th><th>Value</th></tr>
       <tr><td>Total Skills</td><td>${statusResult.skills.length}</td></tr>
       <tr><td>Unmatched Queries</td><td>${statusResult.unmatchedQueries}</td></tr>
-      <tr><td>Pending Proposals</td><td>${statusResult.pendingProposals}</td></tr>
+      <tr><td>Undeployed Proposals</td><td>${statusResult.pendingProposals}</td></tr>
       <tr><td>Last Session</td><td>${escapeHtml(statusResult.lastSession ?? "\u2014")}</td></tr>
     </table>
   </div>

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

@@ -1,12 +1,13 @@
 /**
  * Route handler: GET /api/v2/skills/:name
  *
- * Returns SQLite-backed per-skill report with evolution audit, pending proposals,
+ * Returns SQLite-backed per-skill report with evolution audit, undeployed proposals,
  * invocation details, duration stats, selftune resource usage, prompt samples,
  * and session metadata.
  */
 
 import type { Database } from "bun:sqlite";
+
 import { getPendingProposals, getSkillReportPayload, safeParseJson } from "../localdb/queries.js";
 
 export function handleSkillReport(db: Database, skillName: string): Response {

package/cli/selftune/status.ts

@@ -324,7 +324,7 @@ export function formatStatus(result: StatusResult): string {
 
   // Summary stats
   lines.push(`Unmatched queries:  ${result.unmatchedQueries}`);
-  lines.push(`Pending proposals:  ${result.pendingProposals}`);
+  lines.push(`Undeployed proposals:  ${result.pendingProposals}`);
 
   // Last session
   if (result.lastSession) {

package/cli/selftune/sync.ts

@@ -17,6 +17,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
+
 import {
   CLAUDE_CODE_MARKER,
   CLAUDE_CODE_PROJECTS_DIR,
@@ -504,7 +505,7 @@ function formatStepLine(label: string, step: SyncStepResult, timing?: SyncPhaseT
   return `  ${label}: ${parts.join(", ")}${time}`;
 }
 
-export function cliMain(): void {
+export async function cliMain(): Promise<void> {
   const { values } = parseArgs({
     options: {
       "projects-dir": { type: "string", default: CLAUDE_CODE_PROJECTS_DIR },
@@ -633,6 +634,34 @@ Options:
 
     process.stderr.write(`\nDone in ${formatMs(result.total_elapsed_ms)}\n`);
   }
+
+  // Trigger alpha upload if enrolled — pushes freshly synced data to cloud
+  if (!result.dry_run) {
+    try {
+      const { readAlphaIdentity } = await import("./alpha-identity.js");
+      const { SELFTUNE_CONFIG_PATH } = await import("./constants.js");
+      const identity = readAlphaIdentity(SELFTUNE_CONFIG_PATH);
+      if (identity?.enrolled && identity.api_key) {
+        const { runUploadCycle } = await import("./alpha-upload/index.js");
+        const { getDb } = await import("./localdb/db.js");
+        const db = getDb();
+        const uploadSummary = await runUploadCycle(db, {
+          enrolled: true,
+          userId: identity.user_id,
+          apiKey: identity.api_key,
+        });
+        if (!jsonOutput) {
+          process.stderr.write(
+            `\nAlpha upload: prepared=${uploadSummary.prepared}, sent=${uploadSummary.sent}, failed=${uploadSummary.failed}\n`,
+          );
+        } else {
+          console.log(JSON.stringify({ code: "alpha_upload", ...uploadSummary }));
+        }
+      }
+    } catch {
+      // fail-open: upload failure should not break sync
+    }
+  }
 }
 
 if (import.meta.main) {

package/cli/selftune/uninstall.ts

@@ -0,0 +1,412 @@
+#!/usr/bin/env bun
+/**
+ * selftune uninstall — Clean removal of all selftune data and configuration.
+ *
+ * Removes:
+ *   1. Autonomy scheduling (launchd/cron/systemd + OpenClaw cron)
+ *   2. Selftune hooks from ~/.claude/settings.json (surgical — preserves user hooks)
+ *   3. Selftune-managed Claude subagents from ~/.claude/agents/
+ *   4. JSONL telemetry logs from ~/.claude/
+ *   5. Selftune config directory (~/.selftune/)
+ *   6. Ingest marker files
+ *   7. Optionally: `npm uninstall -g selftune`
+ *
+ * Usage:
+ *   selftune uninstall [--dry-run] [--keep-logs] [--npm-uninstall]
+ */
+
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+import { removeInstalledAgentFiles } from "./claude-agents.js";
+import {
+  CLAUDE_CODE_MARKER,
+  CLAUDE_SETTINGS_PATH,
+  CODEX_INGEST_MARKER,
+  EVOLUTION_AUDIT_LOG,
+  EVOLUTION_EVIDENCE_LOG,
+  OPENCODE_INGEST_MARKER,
+  OPENCLAW_INGEST_MARKER,
+  ORCHESTRATE_LOCK,
+  ORCHESTRATE_RUN_LOG,
+  QUERY_LOG,
+  REPAIRED_SKILL_LOG,
+  REPAIRED_SKILL_SESSIONS_MARKER,
+  SELFTUNE_CONFIG_DIR,
+  SIGNAL_LOG,
+  SKILL_LOG,
+  TELEMETRY_LOG,
+  CANONICAL_LOG,
+} from "./constants.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface UninstallResult {
+  dryRun: boolean;
+  schedule: { removed: boolean; details: string };
+  hooks: { removed: number; details: string };
+  agents: { removed: number; files: string[] };
+  logs: { removed: number; skipped: boolean; files: string[] };
+  config: { removed: boolean; path: string };
+  markers: { removed: number; files: string[] };
+  npm: { uninstalled: boolean; skipped: boolean };
+}
+
+// ---------------------------------------------------------------------------
+// Step 1: Remove autonomy scheduling
+// ---------------------------------------------------------------------------
+
+async function removeScheduling(dryRun: boolean): Promise<{ removed: boolean; details: string }> {
+  // Try launchd first (macOS)
+  const label = "dev.selftune.orchestrate";
+  const plistPath = join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+
+  if (existsSync(plistPath)) {
+    if (dryRun) {
+      return { removed: false, details: `Would remove launchd plist: ${plistPath}` };
+    }
+    try {
+      // Unload before removing
+      Bun.spawnSync(["launchctl", "unload", plistPath], { stderr: "pipe" });
+      unlinkSync(plistPath);
+      return { removed: true, details: `Removed launchd plist: ${plistPath}` };
+    } catch (err) {
+      return {
+        removed: false,
+        details: `Failed to remove launchd plist: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  }
+
+  // Try OpenClaw cron jobs
+  if (dryRun) {
+    return { removed: false, details: "Would remove cron jobs via selftune cron remove" };
+  }
+  try {
+    const proc = Bun.spawnSync(["selftune", "cron", "remove"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (proc.exitCode === 0) {
+      return { removed: true, details: "Removed cron jobs via selftune cron remove" };
+    }
+  } catch {
+    // selftune cron remove not available or failed — not critical
+  }
+
+  return { removed: false, details: "No scheduling artifacts found" };
+}
+
+// ---------------------------------------------------------------------------
+// Step 2: Remove selftune hooks from settings.json
+// ---------------------------------------------------------------------------
+
+/** Selftune hook scripts — used to identify which entries to remove. */
+const SELFTUNE_HOOK_SCRIPTS = [
+  "hooks/prompt-log.ts",
+  "hooks/auto-activate.ts",
+  "hooks/skill-change-guard.ts",
+  "hooks/evolution-guard.ts",
+  "hooks/skill-eval.ts",
+  "hooks/session-stop.ts",
+];
+
+function isSelfttuneHookEntry(entry: unknown): boolean {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry as Record<string, unknown>;
+
+  // Check direct command
+  if (typeof obj.command === "string") {
+    return SELFTUNE_HOOK_SCRIPTS.some((script) => obj.command?.includes(script));
+  }
+
+  // Check hooks array (the nested structure used in settings.json)
+  if (Array.isArray(obj.hooks)) {
+    return obj.hooks.some(
+      (h: unknown) =>
+        typeof h === "object" &&
+        h !== null &&
+        typeof (h as Record<string, unknown>).command === "string" &&
+        SELFTUNE_HOOK_SCRIPTS.some((script) =>
+          ((h as Record<string, unknown>).command as string).includes(script),
+        ),
+    );
+  }
+
+  return false;
+}
+
+function removeHooksFromSettings(
+  dryRun: boolean,
+  settingsPath?: string,
+): { removed: number; details: string } {
+  const path = settingsPath ?? CLAUDE_SETTINGS_PATH;
+  if (!existsSync(path)) {
+    return { removed: 0, details: "No settings.json found" };
+  }
+
+  let settings: Record<string, unknown>;
+  try {
+    settings = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return { removed: 0, details: "Failed to parse settings.json" };
+  }
+
+  const hooks = settings.hooks as Record<string, unknown[]> | undefined;
+  if (!hooks || typeof hooks !== "object") {
+    return { removed: 0, details: "No hooks section in settings.json" };
+  }
+
+  let totalRemoved = 0;
+
+  for (const key of Object.keys(hooks)) {
+    if (!Array.isArray(hooks[key])) continue;
+
+    const before = hooks[key].length;
+    hooks[key] = hooks[key].filter((entry) => !isSelfttuneHookEntry(entry));
+    const removed = before - hooks[key].length;
+    totalRemoved += removed;
+
+    // Clean up empty arrays
+    if (hooks[key].length === 0) {
+      delete hooks[key];
+    }
+  }
+
+  // Clean up empty hooks object
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (totalRemoved > 0 && !dryRun) {
+    writeFileSync(path, JSON.stringify(settings, null, 2), "utf-8");
+  }
+
+  return {
+    removed: totalRemoved,
+    details: dryRun
+      ? `Would remove ${totalRemoved} selftune hook entries from ${path}`
+      : `Removed ${totalRemoved} selftune hook entries from ${path}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Step 3: Remove bundled Claude subagents
+// ---------------------------------------------------------------------------
+
+function removeAgents(dryRun: boolean): { removed: number; files: string[] } {
+  return removeInstalledAgentFiles({ dryRun });
+}
+
+// ---------------------------------------------------------------------------
+// Step 4: Remove JSONL log files
+// ---------------------------------------------------------------------------
+
+const LOG_FILES = [
+  TELEMETRY_LOG,
+  SKILL_LOG,
+  REPAIRED_SKILL_LOG,
+  CANONICAL_LOG,
+  QUERY_LOG,
+  EVOLUTION_AUDIT_LOG,
+  EVOLUTION_EVIDENCE_LOG,
+  ORCHESTRATE_RUN_LOG,
+  SIGNAL_LOG,
+  ORCHESTRATE_LOCK,
+];
+
+function removeLogs(dryRun: boolean): { removed: number; files: string[] } {
+  const removed: string[] = [];
+
+  for (const logPath of LOG_FILES) {
+    if (existsSync(logPath)) {
+      if (!dryRun) {
+        try {
+          unlinkSync(logPath);
+          removed.push(logPath);
+        } catch {
+          // Skip files we can't remove
+        }
+      } else {
+        removed.push(logPath);
+      }
+    }
+  }
+
+  return { removed: removed.length, files: removed };
+}
+
+// ---------------------------------------------------------------------------
+// Step 5: Remove config directory
+// ---------------------------------------------------------------------------
+
+function removeConfig(dryRun: boolean): { removed: boolean; path: string } {
+  if (!existsSync(SELFTUNE_CONFIG_DIR)) {
+    return { removed: false, path: SELFTUNE_CONFIG_DIR };
+  }
+
+  if (!dryRun) {
+    try {
+      rmSync(SELFTUNE_CONFIG_DIR, { recursive: true, force: true });
+      return { removed: true, path: SELFTUNE_CONFIG_DIR };
+    } catch {
+      return { removed: false, path: SELFTUNE_CONFIG_DIR };
+    }
+  }
+
+  return { removed: false, path: SELFTUNE_CONFIG_DIR };
+}
+
+// ---------------------------------------------------------------------------
+// Step 6: Remove ingest marker files
+// ---------------------------------------------------------------------------
+
+const MARKER_FILES = [
+  CLAUDE_CODE_MARKER,
+  CODEX_INGEST_MARKER,
+  OPENCODE_INGEST_MARKER,
+  OPENCLAW_INGEST_MARKER,
+  REPAIRED_SKILL_SESSIONS_MARKER,
+];
+
+function removeMarkers(dryRun: boolean): { removed: number; files: string[] } {
+  const removed: string[] = [];
+
+  for (const markerPath of MARKER_FILES) {
+    if (existsSync(markerPath)) {
+      if (!dryRun) {
+        try {
+          unlinkSync(markerPath);
+          removed.push(markerPath);
+        } catch {
+          // Skip files we can't remove
+        }
+      } else {
+        removed.push(markerPath);
+      }
+    }
+  }
+
+  return { removed: removed.length, files: removed };
+}
+
+// ---------------------------------------------------------------------------
+// Step 7: npm uninstall
+// ---------------------------------------------------------------------------
+
+async function npmUninstall(dryRun: boolean): Promise<{ uninstalled: boolean }> {
+  if (dryRun) {
+    return { uninstalled: false };
+  }
+
+  try {
+    const proc = Bun.spawnSync(["npm", "uninstall", "-g", "selftune"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    return { uninstalled: proc.exitCode === 0 };
+  } catch {
+    return { uninstalled: false };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main orchestrator
+// ---------------------------------------------------------------------------
+
+export interface UninstallOptions {
+  dryRun: boolean;
+  keepLogs: boolean;
+  npmUninstall: boolean;
+  settingsPath?: string;
+}
+
+export async function uninstall(options: UninstallOptions): Promise<UninstallResult> {
+  const { dryRun, keepLogs, settingsPath } = options;
+
+  // Step 1: Remove scheduling
+  const schedule = await removeScheduling(dryRun);
+
+  // Step 2: Remove hooks
+  const hooks = removeHooksFromSettings(dryRun, settingsPath);
+
+  // Step 3: Remove bundled Claude subagents
+  const agents = removeAgents(dryRun);
+
+  // Step 4: Remove logs
+  const logs = keepLogs
+    ? { removed: 0, skipped: true, files: [] }
+    : { ...removeLogs(dryRun), skipped: false };
+
+  // Step 5: Remove config directory
+  const config = removeConfig(dryRun);
+
+  // Step 6: Remove ingest markers
+  const markers = removeMarkers(dryRun);
+
+  // Step 7: npm uninstall (optional)
+  const npm = options.npmUninstall
+    ? { ...(await npmUninstall(dryRun)), skipped: false }
+    : { uninstalled: false, skipped: true };
+
+  return { dryRun, schedule, hooks, agents, logs, config, markers, npm };
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+export async function cliMain(): Promise<void> {
+  const { values } = parseArgs({
+    options: {
+      "dry-run": { type: "boolean", default: false },
+      "keep-logs": { type: "boolean", default: false },
+      "npm-uninstall": { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+    },
+    strict: true,
+  });
+
+  if (values.help) {
+    console.log(`selftune uninstall — Clean removal of all selftune data and configuration
+
+Usage:
+  selftune uninstall [options]
+
+Options:
+  --dry-run        Preview what would be removed without deleting anything
+  --keep-logs      Preserve JSONL telemetry logs (remove everything else)
+  --npm-uninstall  Also run 'npm uninstall -g selftune'
+  --help           Show this help message
+
+Removes:
+  1. Autonomy scheduling (launchd/cron/systemd)
+  2. Selftune hooks from ~/.claude/settings.json (preserves user hooks)
+  3. Selftune-managed Claude subagents from ~/.claude/agents/
+  4. JSONL telemetry logs from ~/.claude/
+  5. Selftune config directory (~/.selftune/)
+  6. Ingest marker files
+  7. npm global package (with --npm-uninstall)`);
+    process.exit(0);
+  }
+
+  const result = await uninstall({
+    dryRun: values["dry-run"] ?? false,
+    keepLogs: values["keep-logs"] ?? false,
+    npmUninstall: values["npm-uninstall"] ?? false,
+  });
+
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+
+if (import.meta.main) {
+  cliMain().catch((err) => {
+    console.error(`[FATAL] ${err}`);
+    process.exit(1);
+  });
+}

package/cli/selftune/utils/canonical-log.ts

@@ -1,10 +1,12 @@
 import { existsSync, writeFileSync } from "node:fs";
+
 import {
   type CanonicalPlatform,
   type CanonicalRecord,
   type CanonicalRecordKind,
   isCanonicalRecord,
 } from "@selftune/telemetry-contract";
+
 import { CANONICAL_LOG } from "../constants.js";
 import { readJsonl } from "./jsonl.js";