selftune 0.2.21 → 0.2.23

package/cli/selftune/init.ts

@@ -75,13 +75,16 @@ class InitCliError extends Error {
  *   1. Claude Code — ~/.claude/ directory exists AND (`which claude` OR env signals)
  *   2. Codex — $CODEX_HOME set OR `which codex`
  *   3. OpenCode — ~/.local/share/opencode/opencode.db exists OR `which opencode`
- *   4. "unknown" fallback
+ *   4. OpenClaw — ~/.openclaw/agents/ exists OR `which openclaw`
+ *   5. Pi — ~/.pi/agent/ exists OR `which pi`
+ *   6. "unknown" fallback
  */
 const VALID_AGENT_TYPES: SelftuneConfig["agent_type"][] = [
   "claude_code",
   "codex",
   "opencode",
   "openclaw",
+  "pi",
   "unknown",
 ];
 
@@ -90,6 +93,7 @@ const AGENT_TYPE_CLI_MAP: Record<string, string> = {
   codex: "codex",
   opencode: "opencode",
   openclaw: "openclaw",
+  pi: "pi",
 };
 
 function agentTypeToCli(agentType: string): string | null {
@@ -134,6 +138,12 @@ export function detectAgentType(
     return "openclaw";
   }
 
+  // Pi: .pi directory or binary
+  const piDir = join(home, ".pi", "agent");
+  if (existsSync(piDir) || Bun.which("pi")) {
+    return "pi";
+  }
+
   return "unknown";
 }
 

package/cli/selftune/localdb/direct-write.ts

@@ -500,6 +500,91 @@ export function writeCommitTracking(record: {
   });
 }
 
+// -- Cron run audit writer -----------------------------------------------------
+
+export function writeCronRunToDb(
+  db: Database,
+  entry: {
+    jobName: string;
+    startedAt: string;
+    elapsedMs: number;
+    status: "success" | "error";
+    metrics?: Record<string, unknown>;
+    error?: string;
+  },
+): void {
+  try {
+    getStmt(
+      db,
+      "cron-run",
+      `
+      INSERT OR IGNORE INTO cron_runs
+        (job_name, started_at, elapsed_ms, status, metrics_json, error)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `,
+    ).run(
+      entry.jobName,
+      entry.startedAt,
+      entry.elapsedMs,
+      entry.status,
+      entry.metrics ? JSON.stringify(entry.metrics) : null,
+      entry.error ?? null,
+    );
+  } catch {
+    /* fail-open: never throw from audit logging */
+  }
+}
+
+// -- Replay entry results writer -----------------------------------------------
+
+export interface ReplayEntryResultInput {
+  proposal_id: string;
+  skill_name: string;
+  validation_mode: string;
+  phase: string;
+  query: string;
+  should_trigger: boolean;
+  triggered: boolean;
+  passed: boolean;
+  evidence?: string;
+}
+
+export function writeReplayEntryResultsToDb(results: ReplayEntryResultInput[]): boolean {
+  if (results.length === 0) return true;
+  return safeWrite("replay-entry-results", (db) => {
+    db.run("BEGIN TRANSACTION");
+    try {
+      const stmt = getStmt(
+        db,
+        "replay-entry-result",
+        `
+        INSERT INTO replay_entry_results
+          (proposal_id, skill_name, validation_mode, phase, query,
+           should_trigger, triggered, passed, evidence)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      );
+      for (const r of results) {
+        stmt.run(
+          r.proposal_id,
+          r.skill_name,
+          r.validation_mode,
+          r.phase,
+          r.query,
+          r.should_trigger ? 1 : 0,
+          r.triggered ? 1 : 0,
+          r.passed ? 1 : 0,
+          r.evidence ?? null,
+        );
+      }
+      db.run("COMMIT");
+    } catch (err) {
+      db.run("ROLLBACK");
+      throw err;
+    }
+  });
+}
+
 // -- Internal insert helpers (used by cached statements) ----------------------
 
 function insertSession(db: Database, s: CanonicalSessionRecord): void {

package/cli/selftune/localdb/materialize.ts

@@ -1,18 +1,17 @@
 /**
- * Materializer: reads JSONL source-of-truth logs and inserts structured
+ * Materializer: reads legacy/exported JSONL files and inserts structured
  * records into the local SQLite database.
  *
+ * IMPORTANT: SQLite is the sole write target (Phase 3 complete). JSONL files
+ * on disk contain only pre-cutover history. This materializer is ONLY used for:
+ *   1. Recovery from selftune export JSONL snapshots
+ *   2. Backfill of pre-cutover JSONL data into a fresh SQLite DB
+ *
  * Supports two modes:
  *  - Full rebuild: drops all data and re-inserts from scratch
  *  - Incremental: only inserts records newer than last materialization
  */
 
-// NOTE: With dual-write active (Phase 1+), hooks insert directly into SQLite.
-// The materializer is only needed for:
-//   1. Initial startup (to catch pre-existing JSONL data from before dual-write)
-//   2. Manual recovery after exporting JSONL and recreating the DB file
-//   3. Backfill from batch ingestors that don't yet dual-write
-
 import type { Database } from "bun:sqlite";
 
 import {

package/cli/selftune/localdb/queries.ts

@@ -2142,6 +2142,132 @@ export function getRecentDecisions(db: Database, limit = 20): AutonomousDecision
 
 // -- Helpers ------------------------------------------------------------------
 
+// -- Replay entry result queries -----------------------------------------------
+
+export function queryReplayEntryResults(
+  db: Database,
+  proposalId: string,
+  phase?: string,
+): Array<{
+  id: number;
+  proposal_id: string;
+  skill_name: string;
+  validation_mode: string;
+  phase: string;
+  query: string;
+  should_trigger: boolean;
+  triggered: boolean;
+  passed: boolean;
+  evidence: string | null;
+}> {
+  const sql = phase
+    ? `SELECT id, proposal_id, skill_name, validation_mode, phase, query,
+              should_trigger, triggered, passed, evidence
+       FROM replay_entry_results
+       WHERE proposal_id = ? AND phase = ?
+       ORDER BY id`
+    : `SELECT id, proposal_id, skill_name, validation_mode, phase, query,
+              should_trigger, triggered, passed, evidence
+       FROM replay_entry_results
+       WHERE proposal_id = ?
+       ORDER BY id`;
+
+  const rows = phase
+    ? (db.query(sql).all(proposalId, phase) as Array<Record<string, unknown>>)
+    : (db.query(sql).all(proposalId) as Array<Record<string, unknown>>);
+
+  return rows.map((r) => ({
+    id: r.id as number,
+    proposal_id: r.proposal_id as string,
+    skill_name: r.skill_name as string,
+    validation_mode: r.validation_mode as string,
+    phase: r.phase as string,
+    query: r.query as string,
+    should_trigger: (r.should_trigger as number) === 1,
+    triggered: (r.triggered as number) === 1,
+    passed: (r.passed as number) === 1,
+    evidence: r.evidence as string | null,
+  }));
+}
+
+/**
+ * Find regressions: entries that passed in the "before" phase but failed in the "after" phase.
+ */
+export function queryReplayRegressions(
+  db: Database,
+  proposalId: string,
+): Array<{
+  query: string;
+  skill_name: string;
+  before_passed: boolean;
+  after_passed: boolean;
+}> {
+  const rows = db
+    .query(
+      `SELECT b.query, b.skill_name,
+              b.passed AS before_passed,
+              a.passed AS after_passed
+       FROM replay_entry_results b
+       JOIN replay_entry_results a
+         ON b.proposal_id = a.proposal_id
+         AND b.query = a.query
+         AND b.skill_name = a.skill_name
+       WHERE b.proposal_id = ?
+         AND b.phase = 'before'
+         AND a.phase = 'after'
+         AND b.passed = 1
+         AND a.passed = 0
+       ORDER BY b.query`,
+    )
+    .all(proposalId) as Array<Record<string, unknown>>;
+
+  return rows.map((r) => ({
+    query: r.query as string,
+    skill_name: r.skill_name as string,
+    before_passed: (r.before_passed as number) === 1,
+    after_passed: (r.after_passed as number) === 1,
+  }));
+}
+
+// -- JSON parse helpers -------------------------------------------------------
+
+// -- Cron run queries ---------------------------------------------------------
+
+export interface CronRun {
+  id: number;
+  job_name: string;
+  started_at: string;
+  elapsed_ms: number;
+  status: string;
+  metrics_json: string | null;
+  error: string | null;
+}
+
+export function getRecentCronRuns(db: Database, limit = 50): CronRun[] {
+  return db
+    .query(
+      `SELECT id, job_name, started_at, elapsed_ms, status, metrics_json, error
+       FROM cron_runs
+       ORDER BY started_at DESC
+       LIMIT ?`,
+    )
+    .all(limit) as CronRun[];
+}
+
+export function getCronRunsByJob(db: Database, jobName: string, limit = 50): CronRun[] {
+  return db
+    .query(
+      `SELECT id, job_name, started_at, elapsed_ms, status, metrics_json, error
+       FROM cron_runs
+       WHERE job_name = ?
+       ORDER BY started_at DESC
+       LIMIT ?`,
+    )
+    .all(jobName, limit) as CronRun[];
+}
+
+// -- JSON parsing helpers -----------------------------------------------------
+
 export function safeParseJsonArray<T = string>(json: string | null): T[] {
   if (!json) return [];
   try {

package/cli/selftune/localdb/schema.ts

@@ -129,6 +129,22 @@ CREATE TABLE IF NOT EXISTS evolution_audit (
   validation_evidence_ref TEXT
 )`;
 
+// -- Replay entry results (per-entry validation outcomes) ---------------------
+
+export const CREATE_REPLAY_ENTRY_RESULTS = `
+CREATE TABLE IF NOT EXISTS replay_entry_results (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  proposal_id     TEXT NOT NULL,
+  skill_name      TEXT NOT NULL,
+  validation_mode TEXT NOT NULL,
+  phase           TEXT NOT NULL,
+  query           TEXT NOT NULL,
+  should_trigger  INTEGER NOT NULL,
+  triggered       INTEGER NOT NULL,
+  passed          INTEGER NOT NULL,
+  evidence        TEXT
+)`;
+
 // -- Local telemetry tables (from JSONL logs) ---------------------------------
 
 export const CREATE_SESSION_TELEMETRY = `
@@ -294,6 +310,20 @@ CREATE TABLE IF NOT EXISTS commit_tracking (
   created_at    TEXT NOT NULL DEFAULT (datetime('now'))
 )`;
 
+// -- Cron run audit log -------------------------------------------------------
+
+export const CREATE_CRON_RUNS = `
+CREATE TABLE IF NOT EXISTS cron_runs (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  job_name   TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  elapsed_ms INTEGER NOT NULL,
+  status     TEXT NOT NULL,
+  metrics_json TEXT,
+  error      TEXT,
+  UNIQUE(job_name, started_at)
+)`;
+
 // -- Metadata table -----------------------------------------------------------
 
 export const CREATE_META = `
@@ -355,11 +385,17 @@ 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)`,
+  // -- Replay entry result indexes ---------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_replay_entry_proposal ON replay_entry_results(proposal_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_replay_entry_skill ON replay_entry_results(skill_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_replay_entry_passed ON replay_entry_results(passed)`,
   // -- 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)`,
+  // -- Cron run indexes -------------------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_cron_runs_job_ts ON cron_runs(job_name, started_at)`,
 ];
 
 /**
@@ -443,6 +479,7 @@ export const ALL_DDL = [
   CREATE_EXECUTION_FACTS,
   CREATE_EVOLUTION_EVIDENCE,
   CREATE_EVOLUTION_AUDIT,
+  CREATE_REPLAY_ENTRY_RESULTS,
   CREATE_SESSION_TELEMETRY,
   CREATE_SKILL_USAGE,
   CREATE_ORCHESTRATE_RUNS,
@@ -454,6 +491,7 @@ export const ALL_DDL = [
   CREATE_UPLOAD_WATERMARKS,
   CREATE_CANONICAL_UPLOAD_STAGING,
   CREATE_COMMIT_TRACKING,
+  CREATE_CRON_RUNS,
   CREATE_META,
   ...CREATE_INDEXES,
 ];

package/cli/selftune/observability.ts

@@ -26,7 +26,14 @@ import type {
 } from "./types.js";
 import { missingClaudeCodeHookKeys } from "./utils/hooks.js";
 
-const VALID_AGENT_TYPES = new Set(["claude_code", "codex", "opencode", "openclaw", "unknown"]);
+const VALID_AGENT_TYPES = new Set([
+  "claude_code",
+  "codex",
+  "opencode",
+  "openclaw",
+  "pi",
+  "unknown",
+]);
 const VALID_LLM_MODES = new Set(["agent"]);
 
 const LOG_FILES: Record<string, string> = {

package/cli/selftune/orchestrate.ts

@@ -29,6 +29,7 @@ import { readGradingResultsForSkill } from "./grading/results.js";
 import { getDb } from "./localdb/db.js";
 import {
   updateSignalConsumed,
+  writeCronRunToDb,
   writeGradingResultToDb,
   writeOrchestrateRunToDb,
 } from "./localdb/direct-write.js";
@@ -1183,6 +1184,33 @@ export async function orchestrate(
       /* fail-open */
     }
 
+    // Also log to unified cron_runs timeline
+    const totalLlmCalls = candidates.reduce(
+      (sum, c) => sum + (c.evolveResult?.llmCallCount ?? 0),
+      0,
+    );
+    try {
+      writeCronRunToDb(getDb(), {
+        jobName: "orchestrate",
+        startedAt: runReport.timestamp,
+        elapsedMs: runReport.elapsed_ms,
+        status: "success",
+        metrics: {
+          total_skills: finalTotals.totalSkills,
+          evaluated: finalTotals.evaluated,
+          evolved: finalTotals.evolved,
+          deployed: finalTotals.deployed,
+          watched: finalTotals.watched,
+          skipped: finalTotals.skipped,
+          dry_run: result.summary.dryRun,
+          total_llm_calls: totalLlmCalls,
+          auto_graded: finalTotals.autoGraded,
+        },
+      });
+    } catch {
+      /* fail-open */
+    }
+
     // -------------------------------------------------------------------------
     // Step 9: Alpha upload (fail-open — never blocks the orchestrate loop)
     // -------------------------------------------------------------------------
@@ -1211,6 +1239,21 @@ export async function orchestrate(
     }
 
     return result;
+  } catch (err) {
+    // Log failed orchestrate run to unified cron_runs timeline
+    const elapsedMs = Date.now() - startTime;
+    try {
+      writeCronRunToDb(getDb(), {
+        jobName: "orchestrate",
+        startedAt: new Date(startTime).toISOString(),
+        elapsedMs,
+        status: "error",
+        error: err instanceof Error ? err.message : String(err),
+      });
+    } catch {
+      /* fail-open */
+    }
+    throw err;
   } finally {
     releaseLock();
   }

package/cli/selftune/registry/client.ts

@@ -0,0 +1,74 @@
+/**
+ * Registry HTTP client. Never throws — returns typed results.
+ */
+
+import { getSelftuneVersion } from "../utils/selftune-meta.js";
+
+export interface RegistryResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  status?: number;
+}
+
+function getConfig(): { apiUrl: string; apiKey: string } | null {
+  try {
+    const configPath = `${process.env.HOME}/.selftune/config.json`;
+    const raw = require("fs").readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const apiUrl = config?.alpha?.cloud_api_url || "https://api.selftune.dev";
+    const apiKey = config?.alpha?.api_key;
+    if (!apiKey) return null;
+    return { apiUrl, apiKey };
+  } catch {
+    return null;
+  }
+}
+
+export async function registryRequest<T>(
+  method: string,
+  path: string,
+  opts?: { body?: unknown; formData?: FormData },
+): Promise<RegistryResult<T>> {
+  const config = getConfig();
+  if (!config) {
+    return { success: false, error: "Not authenticated. Run 'selftune alpha upload' to set up." };
+  }
+
+  try {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${config.apiKey}`,
+      "User-Agent": `selftune/${getSelftuneVersion()}`,
+    };
+
+    let fetchBody: BodyInit | undefined;
+    if (opts?.formData) {
+      fetchBody = opts.formData;
+      // Don't set Content-Type — fetch sets multipart boundary automatically
+    } else if (opts?.body) {
+      headers["Content-Type"] = "application/json";
+      fetchBody = JSON.stringify(opts.body);
+    }
+
+    const response = await fetch(`${config.apiUrl}/api/v1/registry${path}`, {
+      method,
+      headers,
+      body: fetchBody,
+      signal: AbortSignal.timeout(60_000),
+    });
+
+    const text = await response.text();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${text.slice(0, 300)}`,
+        status: response.status,
+      };
+    }
+
+    const data = text ? JSON.parse(text) : {};
+    return { success: true, data: data as T, status: response.status };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}

package/cli/selftune/registry/history.ts

@@ -0,0 +1,54 @@
+/**
+ * selftune registry history — Show version timeline for a skill.
+ */
+
+import { registryRequest } from "./client.js";
+
+export async function cliMain() {
+  const args = process.argv.slice(2);
+  const name = args.find((a) => !a.startsWith("--"));
+
+  if (!name) {
+    console.error(JSON.stringify({ error: "Usage: selftune registry history <name>" }));
+    process.exit(1);
+  }
+
+  const listResult = await registryRequest<{ entries: Array<{ id: string }> }>(
+    "GET",
+    `?name=${encodeURIComponent(name)}`,
+  );
+  if (!listResult.success || !listResult.data?.entries?.length) {
+    console.error(JSON.stringify({ error: `Skill '${name}' not found in registry` }));
+    process.exit(1);
+  }
+
+  const entryId = listResult.data.entries[0].id;
+  const result = await registryRequest<{
+    versions: Array<{
+      version: string;
+      is_current: boolean;
+      rolled_back: boolean;
+      aggregate_pass_rate: number | null;
+      aggregate_sessions: number;
+      change_summary: string | null;
+      pushed_at: string;
+    }>;
+  }>("GET", `/${entryId}/versions`);
+
+  if (!result.success) {
+    console.error(JSON.stringify({ error: result.error }));
+    process.exit(1);
+  }
+
+  const versions = result.data?.versions || [];
+  const timeline = versions.map((v) => ({
+    version: v.version,
+    status: v.is_current ? "current" : v.rolled_back ? "rolled_back" : "previous",
+    pass_rate: v.aggregate_pass_rate,
+    sessions: v.aggregate_sessions,
+    summary: v.change_summary,
+    pushed_at: v.pushed_at,
+  }));
+
+  console.log(JSON.stringify({ name, versions: timeline }));
+}

package/cli/selftune/registry/index.ts

@@ -0,0 +1,90 @@
+/**
+ * selftune registry — Team skill distribution.
+ *
+ * Subcommands:
+ *   push       Push current skill folder as a new version
+ *   install    Download and install a skill from the registry
+ *   sync       Check for updates and pull latest versions
+ *   status     Show installed entries and version drift
+ *   rollback   Rollback a skill to a previous version
+ *   history    Show version timeline for a skill
+ *   list       Show all published entries in the org
+ */
+
+import { CLIError } from "../utils/cli-error.js";
+
+const sub = process.argv[2];
+
+export async function cliMain() {
+  if (!sub || sub === "--help" || sub === "-h") {
+    console.log(`selftune registry — Team skill distribution
+
+Usage:
+  selftune registry <subcommand> [options]
+
+Subcommands:
+  push [name]          Push current skill folder as a new version
+  install <name>       Download and install a skill from the registry
+  sync                 Check for updates and pull latest versions
+  status               Show installed entries and version drift
+  rollback <name>      Rollback to a previous version
+  history <name>       Show version timeline
+  list                 Show all published entries
+
+Options:
+  --version=<semver>   Set version explicitly (push)
+  --summary=<text>     Change summary (push)
+  --global             Install to ~/.claude/skills/ (install)
+  --to=<version>       Target version (rollback)
+  --reason=<text>      Rollback reason (rollback)
+`);
+    return;
+  }
+
+  // Strip 'registry' from argv so subcommands see the right args
+  process.argv = [process.argv[0], process.argv[1], ...process.argv.slice(3)];
+
+  switch (sub) {
+    case "push": {
+      const { cliMain } = await import("./push.js");
+      await cliMain();
+      break;
+    }
+    case "install": {
+      const { cliMain } = await import("./install.js");
+      await cliMain();
+      break;
+    }
+    case "sync": {
+      const { cliMain } = await import("./sync.js");
+      await cliMain();
+      break;
+    }
+    case "status": {
+      const { cliMain } = await import("./status.js");
+      await cliMain();
+      break;
+    }
+    case "rollback": {
+      const { cliMain } = await import("./rollback.js");
+      await cliMain();
+      break;
+    }
+    case "history": {
+      const { cliMain } = await import("./history.js");
+      await cliMain();
+      break;
+    }
+    case "list": {
+      const { cliMain } = await import("./list.js");
+      await cliMain();
+      break;
+    }
+    default:
+      throw new CLIError(
+        `Unknown registry subcommand: ${sub}`,
+        "UNKNOWN_COMMAND",
+        "selftune registry --help",
+      );
+  }
+}