selftune 0.2.9 → 0.2.12

package/cli/selftune/hooks/session-stop.ts

@@ -9,9 +9,9 @@
  */
 
 import { execSync } from "node:child_process";
-import { closeSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { CANONICAL_LOG, ORCHESTRATE_LOCK, TELEMETRY_LOG } from "../constants.js";
+import { readFileSync } from "node:fs";
 
+import { CANONICAL_LOG, ORCHESTRATE_LOCK, TELEMETRY_LOG } from "../constants.js";
 import {
   appendCanonicalRecords,
   buildCanonicalExecutionFact,
@@ -25,6 +25,22 @@ import { parseTranscript } from "../utils/transcript.js";
 
 const LOCK_STALE_MS = 30 * 60 * 1000;
 
+interface ReactiveSpawnDeps {
+  spawnOrchestrate?: () => boolean;
+}
+
+function hasFreshOrchestrateLock(lockPath: string): boolean {
+  try {
+    const lockContent = readFileSync(lockPath, "utf8");
+    const lock = JSON.parse(lockContent) as { timestamp?: string };
+    if (typeof lock.timestamp !== "string") return false;
+    const lockAge = Date.now() - new Date(lock.timestamp).getTime();
+    return Number.isFinite(lockAge) && lockAge < LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Check for pending improvement signals and spawn a focused orchestrate run
  * in the background if warranted. Fire-and-forget — the hook exits immediately.
@@ -33,6 +49,7 @@ const LOCK_STALE_MS = 30 * 60 * 1000;
  */
 export async function maybeSpawnReactiveOrchestrate(
   lockPath: string = ORCHESTRATE_LOCK,
+  deps: ReactiveSpawnDeps = {},
 ): Promise<boolean> {
   try {
     // Read pending signals from SQLite (dynamic import to reduce hook startup cost)
@@ -42,48 +59,25 @@ export async function maybeSpawnReactiveOrchestrate(
     const pending = queryImprovementSignals(db, false);
     if (pending.length === 0) return false;
 
-    // Atomically claim the lock — openSync with "wx" fails if file exists
-    let fd: number;
-    try {
-      fd = openSync(lockPath, "wx");
-      writeFileSync(fd, JSON.stringify({ timestamp: new Date().toISOString(), pid: process.pid }));
-      closeSync(fd);
-    } catch (lockErr: unknown) {
-      // Lock exists — check if stale
-      if ((lockErr as NodeJS.ErrnoException).code === "EEXIST") {
-        try {
-          const lockContent = readFileSync(lockPath, "utf8");
-          const lock = JSON.parse(lockContent);
-          const lockAge = Date.now() - new Date(lock.timestamp).getTime();
-          if (lockAge < LOCK_STALE_MS) return false; // Active lock, skip
-          // Stale lock — override
-          writeFileSync(
-            lockPath,
-            JSON.stringify({ timestamp: new Date().toISOString(), pid: process.pid }),
-          );
-        } catch {
-          return false; // Can't read lock, skip
-        }
-      } else {
-        return false;
-      }
-    }
+    // Do not pre-claim the orchestrate lock here. The spawned process must
+    // acquire its own lock or it will immediately self-block on startup.
+    if (hasFreshOrchestrateLock(lockPath)) return false;
 
     // Spawn orchestrate in background (fire-and-forget)
     try {
-      const proc = Bun.spawn(["selftune", "orchestrate", "--max-skills", "2"], {
-        stdout: "ignore",
-        stderr: "ignore",
-        stdin: "ignore",
-      });
-      proc.unref();
+      const spawnOrchestrate =
+        deps.spawnOrchestrate ??
+        (() => {
+          const proc = Bun.spawn(["selftune", "orchestrate", "--max-skills", "2"], {
+            stdout: "ignore",
+            stderr: "ignore",
+            stdin: "ignore",
+          });
+          proc.unref();
+          return true;
+        });
+      if (!spawnOrchestrate()) return false;
     } catch {
-      // Spawn failed — release our lock
-      try {
-        unlinkSync(lockPath);
-      } catch {
-        /* ignore */
-      }
       return false;
     }
 

package/cli/selftune/hooks/skill-change-guard.ts

@@ -12,6 +12,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
+
 import { SESSION_STATE_DIR } from "../constants.js";
 import type { PreToolUsePayload } from "../types.js";
 

package/cli/selftune/hooks/skill-eval.ts

@@ -13,6 +13,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
+
 import { CANONICAL_LOG, SKILL_LOG } from "../constants.js";
 import {
   appendCanonicalRecord,
@@ -24,7 +25,6 @@ import {
   getLatestPromptIdentity,
 } from "../normalization.js";
 import type { PostToolUsePayload, SkillUsageRecord } from "../types.js";
-
 import { classifySkillPath } from "../utils/skill-discovery.js";
 import { getLastUserMessage } from "../utils/transcript.js";
 

package/cli/selftune/index.ts

@@ -10,6 +10,7 @@
  *   selftune sync               — Sync source-truth telemetry across supported agents
  *   selftune orchestrate        — Run autonomous core loop (sync → status → evolve → watch)
  *   selftune init               — Initialize agent identity and config
+ *   selftune uninstall          — Clean removal of all selftune data and config
  *   selftune status             — Show skill health summary
  *   selftune watch              — Monitor post-deploy skill health
  *   selftune doctor             — Run health checks
@@ -44,6 +45,7 @@ Commands:
   sync               Sync source-truth telemetry across supported agents
   orchestrate        Run autonomous core loop (sync → status → evolve → watch)
   init               Initialize agent identity and config
+  uninstall          Clean removal of all selftune data and config
   status             Show skill health summary
   watch              Monitor post-deploy skill health
   doctor             Run health checks
@@ -338,6 +340,11 @@ Run 'selftune eval <action> --help' for action-specific options.`);
     await cliMain();
     break;
   }
+  case "uninstall": {
+    const { cliMain } = await import("./uninstall.js");
+    await cliMain();
+    break;
+  }
   case "contribute": {
     const { cliMain } = await import("./contribute/contribute.js");
     await cliMain();
@@ -464,7 +471,7 @@ Run 'selftune cron <subcommand> --help' for subcommand-specific options.`);
   }
   case "sync": {
     const { cliMain } = await import("./sync.js");
-    cliMain();
+    await cliMain();
     break;
   }
   case "workflows": {
@@ -606,9 +613,8 @@ Output:
         const { readAlphaIdentity } = await import("./alpha-identity.js");
         const { getDb } = await import("./localdb/db.js");
         const { runUploadCycle } = await import("./alpha-upload/index.js");
-        const { getSelftuneVersion, readConfiguredAgentType } = await import(
-          "./utils/selftune-meta.js"
-        );
+        const { getSelftuneVersion, readConfiguredAgentType } =
+          await import("./utils/selftune-meta.js");
 
         const identity = readAlphaIdentity(SELFTUNE_CONFIG_PATH);
         if (!identity?.enrolled) {
@@ -670,36 +676,39 @@ Output:
       }
       case "relink": {
         const { SELFTUNE_CONFIG_PATH } = await import("./constants.js");
-        const { readAlphaIdentity, writeAlphaIdentity, generateUserId } = await import(
-          "./alpha-identity.js"
-        );
-        const { requestDeviceCode, pollDeviceCode } = await import("./auth/device-code.js");
+        const { readAlphaIdentity, writeAlphaIdentity, generateUserId } =
+          await import("./alpha-identity.js");
+        const { buildVerificationUrl, pollDeviceCode, requestDeviceCode, tryOpenUrl } =
+          await import("./auth/device-code.js");
         const { chmodSync } = await import("node:fs");
 
         const existingIdentity = readAlphaIdentity(SELFTUNE_CONFIG_PATH);
         process.stderr.write("[alpha relink] Starting device-code authentication flow...\n");
 
         const grant = await requestDeviceCode();
+        const verificationUrlWithCode = buildVerificationUrl(
+          grant.verification_url,
+          grant.user_code,
+        );
 
         console.log(
           JSON.stringify({
             level: "info",
             code: "device_code_issued",
             verification_url: grant.verification_url,
+            verification_url_with_code: verificationUrlWithCode,
             user_code: grant.user_code,
             expires_in: grant.expires_in,
-            message: `Open ${grant.verification_url} and enter code: ${grant.user_code}`,
+            message: `Open ${verificationUrlWithCode} to approve.`,
           }),
         );
 
         // Try to open browser
-        try {
-          const url = `${grant.verification_url}?code=${grant.user_code}`;
-          Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore" });
+        if (tryOpenUrl(verificationUrlWithCode)) {
           process.stderr.write("[alpha relink] Browser opened. Waiting for approval...\n");
-        } catch {
+        } else {
           process.stderr.write(
-            "[alpha relink] Could not open browser. Visit the URL above manually.\n",
+            `[alpha relink] Could not open browser. Visit ${verificationUrlWithCode} manually.\n`,
           );
         }
 

package/cli/selftune/ingestors/claude-replay.ts

@@ -24,6 +24,7 @@
 import { statSync } from "node:fs";
 import { basename } from "node:path";
 import { parseArgs } from "node:util";
+
 import {
   CANONICAL_LOG,
   CLAUDE_CODE_MARKER,

package/cli/selftune/ingestors/codex-rollout.ts

@@ -25,6 +25,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { parseArgs } from "node:util";
+
 import { CANONICAL_LOG, QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
 import {
   appendCanonicalRecords,

package/cli/selftune/ingestors/codex-wrapper.ts

@@ -19,6 +19,7 @@
 
 import { homedir } from "node:os";
 import { join } from "node:path";
+
 import { CANONICAL_LOG, QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
 import {
   appendCanonicalRecords,

package/cli/selftune/ingestors/openclaw-ingest.ts

@@ -25,6 +25,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { parseArgs } from "node:util";
+
 import {
   CANONICAL_LOG,
   OPENCLAW_AGENTS_DIR,

package/cli/selftune/ingestors/opencode-ingest.ts

@@ -25,6 +25,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { parseArgs } from "node:util";
+
 import { CANONICAL_LOG, QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
 import {
   appendCanonicalRecords,

package/cli/selftune/init.ts

@@ -8,7 +8,7 @@
  *
  * Usage:
  *   selftune init [--agent <type>] [--cli-path <path>] [--force]
- *   selftune init --enable-autonomy [--schedule-format cron|launchd|systemd]
+ *   selftune init [--no-sync] [--no-autonomy] [--schedule-format cron|launchd|systemd]
  */
 
 import {
@@ -35,12 +35,20 @@ import {
   readAlphaIdentity,
 } from "./alpha-identity.js";
 import { TELEMETRY_NOTICE } from "./analytics.js";
-import { pollDeviceCode, requestDeviceCode } from "./auth/device-code.js";
+import {
+  buildVerificationUrl,
+  pollDeviceCode,
+  requestDeviceCode,
+  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 type { AgentCommandGuidance, AlphaIdentity, SelftuneConfig } from "./types.js";
 import { hookKeyHasSelftuneEntry } from "./utils/hooks.js";
 import { detectAgent } from "./utils/llm-call.js";
 
+export { installAgentFiles } from "./claude-agents.js";
+
 interface InitCliErrorPayload extends AgentCommandGuidance {
   error: string;
 }
@@ -309,19 +317,6 @@ export function installClaudeCodeHooks(options?: {
   return addedKeys;
 }
 
-// ---------------------------------------------------------------------------
-// Agent file installation
-// ---------------------------------------------------------------------------
-
-/**
- * @deprecated Agent files are now bundled in skill/agents/ and read directly
- * by the consuming agent via progressive disclosure. No installation needed.
- * Kept as a no-op for backwards compatibility with callers.
- */
-export function installAgentFiles(_options?: { homeDir?: string; force?: boolean }): string[] {
-  return [];
-}
-
 // ---------------------------------------------------------------------------
 // Workspace type detection
 // ---------------------------------------------------------------------------
@@ -508,7 +503,11 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
   if (!force && !hasAlphaMutation && existsSync(configPath)) {
     const raw = readFileSync(configPath, "utf-8");
     try {
-      return JSON.parse(raw) as SelftuneConfig;
+      const existingConfig = JSON.parse(raw) as SelftuneConfig;
+      if (existingConfig.agent_type === "claude_code") {
+        installAgentFiles({ homeDir: opts.homeDir });
+      }
+      return existingConfig;
     } catch (err) {
       throw new Error(
         `Config file at ${configPath} contains invalid JSON. Delete it or use --force to reinitialize. Cause: ${err instanceof Error ? err.message : String(err)}`,
@@ -548,6 +547,7 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
     process.stderr.write("[alpha] Starting device-code authentication flow...\n");
 
     const grant = await requestDeviceCode();
+    const verificationUrlWithCode = buildVerificationUrl(grant.verification_url, grant.user_code);
 
     // Emit structured JSON for the agent to parse
     console.log(
@@ -555,25 +555,24 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
         level: "info",
         code: "device_code_issued",
         verification_url: grant.verification_url,
+        verification_url_with_code: verificationUrlWithCode,
         user_code: grant.user_code,
         expires_in: grant.expires_in,
-        message: `Open ${grant.verification_url} and enter code: ${grant.user_code}`,
+        message: `Open ${verificationUrlWithCode} to approve.`,
       }),
     );
 
     // Try to open browser (skip in test environments)
     if (!process.env.BUN_ENV?.includes("test") && !process.env.SELFTUNE_NO_BROWSER) {
-      try {
-        const url = `${grant.verification_url}?code=${grant.user_code}`;
-        Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore" });
+      if (tryOpenUrl(verificationUrlWithCode)) {
         process.stderr.write(`[alpha] Browser opened. Waiting for approval...\n`);
-      } catch {
-        process.stderr.write(`[alpha] Could not open browser. Visit the URL above manually.\n`);
+      } else {
+        process.stderr.write(
+          `[alpha] Could not open browser. Visit ${verificationUrlWithCode} manually.\n`,
+        );
       }
     } else {
-      process.stderr.write(
-        `[alpha] Visit ${grant.verification_url}?code=${grant.user_code} to approve.\n`,
-      );
+      process.stderr.write(`[alpha] Visit ${verificationUrlWithCode} to approve.\n`);
     }
 
     process.stderr.write("[alpha] Polling");
@@ -606,11 +605,15 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
   mkdirSync(configDir, { recursive: true });
   writeSelftuneConfig(configPath, config);
 
-  // Agent files are bundled in skill/agents/ and read directly by the
-  // consuming agent — no installation step needed.
-
   // Auto-install hooks into ~/.claude/settings.json (Claude Code only)
   if (agentType === "claude_code") {
+    const syncedAgentFiles = installAgentFiles({ homeDir: home });
+    if (syncedAgentFiles.length > 0) {
+      console.error(
+        `[INFO] Synced ${syncedAgentFiles.length} selftune agent file(s) into ${join(home, ".claude", "agents")}: ${syncedAgentFiles.join(", ")}`,
+      );
+    }
+
     const addedHookKeys = installClaudeCodeHooks({
       settingsPath,
       cliPath,
@@ -668,6 +671,8 @@ export async function cliMain(): Promise<void> {
       "cli-path": { type: "string" },
       force: { type: "boolean", default: false },
       "enable-autonomy": { type: "boolean", default: false },
+      "no-sync": { type: "boolean", default: false },
+      "no-autonomy": { type: "boolean", default: false },
       "schedule-format": { type: "string" },
       alpha: { type: "boolean", default: false },
       "no-alpha": { type: "boolean", default: false },
@@ -680,7 +685,10 @@ export async function cliMain(): Promise<void> {
   const configDir = SELFTUNE_CONFIG_DIR;
   const configPath = SELFTUNE_CONFIG_PATH;
   const force = values.force ?? false;
-  const enableAutonomy = values["enable-autonomy"] ?? false;
+  // Sync and autonomy are on by default; opt out with --no-sync / --no-autonomy
+  const enableSync = !(values["no-sync"] ?? false);
+  // --enable-autonomy is a backward-compatible alias (now default behavior)
+  const enableAutonomy = !values["no-autonomy"];
   try {
     validateAlphaMetadataFlags(values.alpha, values["alpha-email"], values["alpha-name"]);
   } catch (error) {
@@ -695,6 +703,7 @@ export async function cliMain(): Promise<void> {
     values["alpha-email"] ||
     values["alpha-name"]
   );
+  let existingConfigDetected = false;
   if (!force && !enableAutonomy && !hasAlphaMutation && existsSync(configPath)) {
     try {
       const raw = readFileSync(configPath, "utf-8");
@@ -708,6 +717,14 @@ export async function cliMain(): Promise<void> {
       );
     }
   }
+  if (!force && !hasAlphaMutation && existsSync(configPath)) {
+    try {
+      JSON.parse(readFileSync(configPath, "utf-8")) as SelftuneConfig;
+      existingConfigDetected = true;
+    } catch {
+      existingConfigDetected = false;
+    }
+  }
 
   const config = await runInit({
     configDir,
@@ -727,6 +744,9 @@ export async function cliMain(): Promise<void> {
     safeConfig.alpha.api_key = "<redacted>";
   }
   console.log(JSON.stringify(safeConfig, null, 2));
+  if (existingConfigDetected) {
+    console.error("Already initialized. Use --force to reinitialize.");
+  }
 
   // Alpha enrollment output
   if (values.alpha) {
@@ -790,6 +810,78 @@ export async function cliMain(): Promise<void> {
     }),
   );
 
+  // Backfill historical transcripts into SQLite
+  if (enableSync) {
+    try {
+      const { syncSources } = await import("./sync.js");
+      const syncResult = syncSources({
+        syncClaude: true,
+        syncCodex: true,
+        syncOpenCode: true,
+        syncOpenClaw: true,
+        rebuildSkillUsage: true,
+        dryRun: false,
+      });
+
+      const totalSynced =
+        (syncResult.sources.claude?.synced ?? 0) +
+        (syncResult.sources.codex?.synced ?? 0) +
+        (syncResult.sources.opencode?.synced ?? 0) +
+        (syncResult.sources.openclaw?.synced ?? 0);
+
+      console.log(
+        JSON.stringify({
+          level: "info",
+          code: "sync_complete",
+          sessions_synced: totalSynced,
+          repaired_records: syncResult.repair.repaired_records,
+          elapsed_ms: syncResult.total_elapsed_ms,
+        }),
+      );
+    } catch (err) {
+      // Fail-open: sync failure should not block init completion
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          code: "sync_failed",
+          error: err instanceof Error ? err.message : String(err),
+        }),
+      );
+    }
+  }
+
+  // Trigger initial alpha upload if enrolled — push synced data immediately
+  if (config.alpha?.enrolled && config.alpha?.api_key) {
+    try {
+      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: config.alpha.user_id,
+        apiKey: config.alpha.api_key,
+      });
+      console.log(
+        JSON.stringify({
+          level: "info",
+          code: "init_upload_complete",
+          prepared: uploadSummary.prepared,
+          sent: uploadSummary.sent,
+          failed: uploadSummary.failed,
+        }),
+      );
+    } catch (err) {
+      // Fail-open: upload failure should not block init
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          code: "init_upload_failed",
+          error: err instanceof Error ? err.message : String(err),
+        }),
+      );
+    }
+  }
+
   if (enableAutonomy) {
     try {
       const { installSchedule } = await import("./schedule.js");

package/cli/selftune/localdb/db.ts

@@ -11,6 +11,7 @@
 import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
+
 import { SELFTUNE_CONFIG_DIR } from "../constants.js";
 import { ALL_DDL, MIGRATIONS, POST_MIGRATION_INDEXES } from "./schema.js";
 

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

@@ -10,6 +10,8 @@
  */
 
 import type { Database } from "bun:sqlite";
+import { createHash } from "node:crypto";
+
 import type {
   CanonicalExecutionFactRecord,
   CanonicalPromptRecord,
@@ -17,10 +19,12 @@ import type {
   CanonicalSessionRecord,
   CanonicalSkillInvocationRecord,
 } from "@selftune/telemetry-contract";
+
 import type { OrchestrateRunReport } from "../dashboard-contract.js";
 import type {
   EvolutionAuditEntry,
   EvolutionEvidenceEntry,
+  GradingResult,
   SessionTelemetryRecord,
   SkillUsageRecord,
 } from "../types.js";
@@ -353,6 +357,41 @@ export function writeQueryToDb(record: {
   });
 }
 
+export function writeGradingResultToDb(result: GradingResult): boolean {
+  const gradingId = `gr_${createHash("sha256").update(`${result.session_id}:${result.skill_name}:${result.graded_at}`).digest("hex").slice(0, 16)}`;
+  return safeWrite("grading-result", (db) => {
+    getStmt(
+      db,
+      "grading-result",
+      `
+      INSERT OR IGNORE INTO grading_results
+        (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)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    ).run(
+      gradingId,
+      result.session_id,
+      result.skill_name,
+      result.transcript_path,
+      result.graded_at,
+      result.summary.pass_rate,
+      result.summary.mean_score ?? null,
+      result.summary.score_std_dev ?? null,
+      result.summary.passed,
+      result.summary.failed,
+      result.summary.total,
+      JSON.stringify(result.expectations),
+      JSON.stringify(result.claims),
+      JSON.stringify(result.eval_feedback),
+      result.failure_feedback ? JSON.stringify(result.failure_feedback) : null,
+      JSON.stringify(result.execution_metrics),
+    );
+  });
+}
+
 export function writeImprovementSignalToDb(record: {
   timestamp: string;
   session_id: string;

package/cli/selftune/localdb/materialize.ts

@@ -14,6 +14,7 @@
 //   3. Backfill from batch ingestors that don't yet dual-write
 
 import type { Database } from "bun:sqlite";
+
 import {
   type CanonicalExecutionFactRecord,
   type CanonicalPromptRecord,
@@ -22,6 +23,7 @@ import {
   type CanonicalSkillInvocationRecord,
   isCanonicalRecord,
 } from "@selftune/telemetry-contract";
+
 import {
   CANONICAL_LOG,
   EVOLUTION_AUDIT_LOG,