selftune 0.2.22 → 0.2.24

package/cli/selftune/init.ts

@@ -42,7 +42,17 @@ import {
   tryOpenUrl,
 } from "./auth/device-code.js";
 import { installAgentFiles } from "./claude-agents.js";
-import { CLAUDE_CODE_HOOK_KEYS, SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
+import {
+  CLAUDE_CODE_HOOK_KEYS,
+  CLAUDE_CODE_PROJECTS_DIR,
+  OPENCLAW_AGENTS_DIR,
+  PI_SESSIONS_DIR,
+  REPAIRED_SKILL_LOG,
+  REPAIRED_SKILL_SESSIONS_MARKER,
+  SELFTUNE_CONFIG_DIR,
+  SELFTUNE_CONFIG_PATH,
+  SKILL_LOG,
+} from "./constants.js";
 import type { AgentCommandGuidance, AlphaIdentity, SelftuneConfig } from "./types.js";
 import { CLIError, handleCLIError } from "./utils/cli-error.js";
 import { hookKeyHasSelftuneEntry, isSelftuneCommand } from "./utils/hooks.js";
@@ -75,13 +85,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 +103,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 +148,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";
 }
 
@@ -990,19 +1010,33 @@ export async function cliMain(): Promise<void> {
     try {
       const { syncSources } = await import("./sync.js");
       const syncResult = syncSources({
+        projectsDir: CLAUDE_CODE_PROJECTS_DIR,
+        codexHome: join(homedir(), ".codex"),
+        opencodeDataDir: join(
+          process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"),
+          "opencode",
+        ),
+        openclawAgentsDir: OPENCLAW_AGENTS_DIR,
+        piSessionsDir: PI_SESSIONS_DIR,
+        skillLogPath: SKILL_LOG,
+        repairedSkillLogPath: REPAIRED_SKILL_LOG,
+        repairedSessionsPath: REPAIRED_SKILL_SESSIONS_MARKER,
         syncClaude: true,
         syncCodex: true,
         syncOpenCode: true,
         syncOpenClaw: true,
+        syncPi: true,
         rebuildSkillUsage: true,
         dryRun: false,
+        force: false,
       });
 
       const totalSynced =
         (syncResult.sources.claude?.synced ?? 0) +
         (syncResult.sources.codex?.synced ?? 0) +
         (syncResult.sources.opencode?.synced ?? 0) +
-        (syncResult.sources.openclaw?.synced ?? 0);
+        (syncResult.sources.openclaw?.synced ?? 0) +
+        (syncResult.sources.pi?.synced ?? 0);
 
       console.log(
         JSON.stringify({
@@ -1115,7 +1149,7 @@ export function checkAlphaReadiness(configPath: string): {
 
 // Guard: only run when invoked directly
 const isMain =
-  (import.meta as Record<string, unknown>).main === true ||
+  (import.meta as unknown as Record<string, unknown>).main === true ||
   process.argv[1] === fileURLToPath(import.meta.url);
 
 if (isMain) {

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

@@ -469,7 +469,7 @@ export function updateSignalConsumed(
     `,
     ).run(new Date().toISOString(), runId, sessionId, query, signalType),
   );
-  return result?.changes > 0;
+  return (result?.changes ?? 0) > 0;
 }
 
 export function writeCommitTracking(record: {
@@ -500,6 +500,125 @@ export function writeCommitTracking(record: {
   });
 }
 
+// -- Grading baseline writer ---------------------------------------------------
+
+export interface GradingBaselineInput {
+  skill_name: string;
+  proposal_id: string | null;
+  measured_at: string;
+  pass_rate: number;
+  mean_score: number | null;
+  sample_size: number;
+  grading_results_json: string | null;
+}
+
+export function writeGradingBaseline(baseline: GradingBaselineInput): boolean {
+  return safeWrite("grading-baseline", (db) => {
+    getStmt(
+      db,
+      "grading-baseline",
+      `
+      INSERT INTO grading_baselines
+        (skill_name, proposal_id, measured_at, pass_rate, mean_score, sample_size, grading_results_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `,
+    ).run(
+      baseline.skill_name,
+      baseline.proposal_id ?? null,
+      baseline.measured_at,
+      baseline.pass_rate,
+      baseline.mean_score ?? null,
+      baseline.sample_size,
+      baseline.grading_results_json ?? null,
+    );
+  });
+}
+
+// -- 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/cron.ts

@@ -0,0 +1,34 @@
+import type { Database } from "bun:sqlite";
+
+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[];
+}