selftune 0.2.22 → 0.2.24

package/cli/selftune/registry/sync.ts

@@ -0,0 +1,125 @@
+/**
+ * selftune registry sync — Check for updates and pull latest versions.
+ */
+
+import { writeFile, readFile, mkdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+
+import { registryRequest } from "./client.js";
+
+interface LocalState {
+  entryId: string;
+  name: string;
+  versionHash: string;
+  installPath: string;
+}
+
+function getStatePath(): string {
+  return join(process.env.HOME || "~", ".selftune", "registry-state.json");
+}
+
+async function loadState(): Promise<LocalState[]> {
+  try {
+    const raw = await readFile(getStatePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+async function saveState(state: LocalState[]): Promise<void> {
+  await mkdir(join(process.env.HOME || "~", ".selftune"), { recursive: true });
+  await writeFile(getStatePath(), JSON.stringify(state, null, 2));
+}
+
+export async function cliMain() {
+  const state = await loadState();
+  if (state.length === 0) {
+    console.log(
+      JSON.stringify({
+        message: "No registry installations found. Use 'selftune registry install <name>' first.",
+      }),
+    );
+    return;
+  }
+
+  // Check for updates
+  const syncResult = await registryRequest<{
+    entries: Array<{
+      entry_id: string;
+      name: string;
+      has_update: boolean;
+      latest_version: string;
+      latest_content_hash: string;
+      download_url?: string;
+    }>;
+  }>("POST", "/sync", {
+    body: {
+      installations: state.map((s) => ({
+        entry_id: s.entryId,
+        current_version_hash: s.versionHash,
+      })),
+    },
+  });
+
+  if (!syncResult.success) {
+    console.error(JSON.stringify({ error: syncResult.error }));
+    process.exit(1);
+  }
+
+  const updates = syncResult.data?.entries?.filter((e) => e.has_update) || [];
+  if (updates.length === 0) {
+    console.log(JSON.stringify({ message: "All installations up to date", count: state.length }));
+    return;
+  }
+
+  console.log(`Found ${updates.length} update(s)...`);
+  let synced = 0;
+  let failed = 0;
+
+  for (const update of updates) {
+    if (!update.download_url) {
+      failed++;
+      continue;
+    }
+
+    const localEntry = state.find((s) => s.entryId === update.entry_id);
+    if (!localEntry) {
+      failed++;
+      continue;
+    }
+
+    try {
+      const response = await fetch(update.download_url, { signal: AbortSignal.timeout(60_000) });
+      if (!response.ok) {
+        failed++;
+        continue;
+      }
+
+      const archiveBuffer = Buffer.from(await response.arrayBuffer());
+      const archivePath = `/tmp/selftune-sync-${Date.now()}.tar.gz`;
+      await writeFile(archivePath, archiveBuffer);
+
+      // Extract to existing install path
+      const proc = Bun.spawn(["tar", "xzf", archivePath, "-C", localEntry.installPath], {
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+      await proc.exited;
+      await unlink(archivePath).catch(() => {});
+
+      if (proc.exitCode === 0) {
+        localEntry.versionHash = update.latest_content_hash;
+        synced++;
+        console.log(`  updated: ${update.name} -> v${update.latest_version}`);
+      } else {
+        failed++;
+      }
+    } catch {
+      failed++;
+    }
+  }
+
+  await saveState(state);
+  console.log(JSON.stringify({ synced, failed, total: state.length }));
+}

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

@@ -31,6 +31,7 @@ import {
   findInstalledSkillPath,
   findRepositoryClaudeSkillDirs,
   findRepositorySkillDirs,
+  isTestFixturePath,
 } from "../utils/skill-discovery.js";
 import { writeRepairedSkillUsageRecords } from "../utils/skill-log.js";
 
@@ -299,8 +300,11 @@ function extractSessionSkillUsage(
 
     const msg = (entry.message as Record<string, unknown>) ?? entry;
     const role = (msg.role as string) ?? (entry.role as string) ?? "";
-    const timestamp =
-      (entry.timestamp as string) ?? (msg.timestamp as string) ?? lastUserMessage?.timestamp ?? "";
+    const timestamp: string =
+      optionalString(entry.timestamp) ??
+      optionalString(msg.timestamp) ??
+      lastUserMessage?.timestamp ??
+      "";
     sessionCwd =
       optionalString(entry.cwd) ??
       optionalString(msg.cwd) ??
@@ -380,7 +384,7 @@ function extractSessionSkillUsage(
 
       if (toolName === "Read") {
         const filePath = (input.file_path as string) ?? "";
-        if (filePath.endsWith("SKILL.md")) {
+        if (filePath.endsWith("SKILL.md") && !isTestFixturePath(filePath)) {
           const inferredSkillName = basename(dirname(filePath)).trim();
           if (inferredSkillName && !skillPathLookup.has(inferredSkillName)) {
             skillPathLookup.set(inferredSkillName.toLowerCase(), filePath);
@@ -421,6 +425,8 @@ function extractSessionSkillUsage(
         ? { skillPath: knownSkillPath, resolutionSource: "raw_log" as const }
         : resolveClaudeSkillPath(skillName, sessionCwd, homeDir, codexHome);
 
+      if (isTestFixturePath(skillPath)) continue;
+
       const recordIndex =
         repaired.push({
           timestamp: timestamp || lastUserMessage.timestamp || fallbackTimestamp,

package/cli/selftune/routes/overview.ts

@@ -24,6 +24,7 @@ import {
   getSkillTrustSummaries,
   getSkillsList,
 } from "../localdb/queries.js";
+import { buildCreatorTestingOverview, listSkillTestingReadiness } from "../testing-readiness.js";
 import { buildTrustWatchlist } from "../trust-model.js";
 import { loadWatchedSkills } from "../watchlist.js";
 
@@ -32,15 +33,16 @@ export function handleOverview(
   version: string,
   searchParams?: URLSearchParams,
 ): Response {
-  const skills = getSkillsList(db);
-
   // -- Autonomy-first enrichment fields ----------------------------------------
   const attentionQueue = getAttentionQueue(db);
   const recentDecisions = getRecentDecisions(db);
   const trustSummaries = getSkillTrustSummaries(db);
+  const testingReadiness = listSkillTestingReadiness(db);
+  const skills = getSkillsList(db, testingReadiness);
   const pendingReviews = attentionQueue.filter((a) => a.category === "needs_review").length;
 
   const trustWatchlist = buildTrustWatchlist(trustSummaries);
+  const creatorTesting = buildCreatorTestingOverview(testingReadiness);
   const autonomyStatus = buildAutonomyStatus(
     db,
     attentionQueue,
@@ -55,6 +57,7 @@ export function handleOverview(
     attention_queue: attentionQueue,
     trust_watchlist: trustWatchlist,
     recent_decisions: recentDecisions,
+    creator_testing: creatorTesting,
   };
 
   // -- Standard overview payload -----------------------------------------------

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

@@ -17,6 +17,7 @@ import {
   getSkillReportPayload,
   safeParseJson,
 } from "../localdb/queries.js";
+import { getSkillTestingReadiness } from "../testing-readiness.js";
 
 export function handleSkillReport(
   db: Database,
@@ -24,6 +25,7 @@ export function handleSkillReport(
   searchParams?: URLSearchParams,
 ): Response {
   const report = getSkillReportPayload(db, skillName);
+  const testing_readiness = getSkillTestingReadiness(db, skillName);
 
   // 1. Evolution audit with eval_snapshot
   const evolution = db
@@ -178,7 +180,14 @@ export function handleSkillReport(
     report.evidence.length > 0 ||
     evolution.length > 0 ||
     pending_proposals.length > 0 ||
-    invPageRows.length > 0;
+    invPageRows.length > 0 ||
+    Boolean(
+      testing_readiness?.skill_path ||
+      testing_readiness?.eval_set_entries ||
+      testing_readiness?.unit_test_cases ||
+      testing_readiness?.replay_check_count ||
+      testing_readiness?.baseline_sample_size,
+    );
   if (!hasData) {
     return Response.json({ error: "Skill not found" }, { status: 404 });
   }
@@ -784,7 +793,10 @@ export function handleSkillReport(
 
   if (coverage.checks < 5) {
     trustState = "low_sample";
-    trustSummary = `Too few operational observations to assess trust — only ${coverage.checks} checks recorded.`;
+    trustSummary =
+      coverage.checks === 0 && testing_readiness
+        ? `No runtime observations yet. Use the creator test loop to bootstrap this skill before trusting live routing.`
+        : `Too few operational observations to assess trust — only ${coverage.checks} checks recorded.`;
   } else if (latestAuditRow?.action === "rolled_back") {
     trustState = "rolled_back";
     trustSummary = "Recent evolution was rolled back — review evidence before re-deploying.";
@@ -879,5 +891,6 @@ export function handleSkillReport(
     evolution_state,
     data_hygiene,
     examples,
+    testing_readiness,
   });
 }

package/cli/selftune/schedule.ts

@@ -376,7 +376,7 @@ export function buildInstallPlan(
   }
 
   const systemdDir = join(homeDir, ".config", "systemd", "user");
-  const definitions = SCHEDULE_ENTRIES.map(buildSystemdDefinition);
+  const definitions = SCHEDULE_ENTRIES.map((entry) => buildSystemdDefinition(entry));
   return {
     artifacts: definitions.flatMap((definition) => [
       { path: join(systemdDir, `${definition.baseName}.timer`), content: definition.timerContent },
@@ -531,7 +531,7 @@ export function cliMain(): void {
 
   if (values["apply-cron-artifact"]) {
     try {
-      applyCronArtifact(values["apply-cron-artifact"]);
+      applyCronArtifact(values["apply-cron-artifact"] as string);
       return;
     } catch (err) {
       throw new CLIError(
@@ -567,8 +567,8 @@ For OpenClaw-specific scheduling, see: selftune cron`);
   if (values.install) {
     try {
       const result = installSchedule({
-        format: values.format,
-        dryRun: values["dry-run"] ?? false,
+        format: typeof values.format === "string" ? values.format : undefined,
+        dryRun: values["dry-run"] === true,
       });
       if (!result.dryRun && !result.activated) {
         throw new CLIError(
@@ -601,7 +601,7 @@ For OpenClaw-specific scheduling, see: selftune cron`);
     }
   }
 
-  const result = formatOutput(values.format);
+  const result = formatOutput(typeof values.format === "string" ? values.format : undefined);
   if (!result.ok) {
     throw new CLIError(
       result.error ?? "Invalid schedule format",

package/cli/selftune/status.ts

@@ -16,7 +16,9 @@ import { getAlphaLinkState, readAlphaIdentity } from "./alpha-identity.js";
 import { getQueueStats } from "./alpha-upload/queue.js";
 import { getBaseUrl } from "./auth/device-code.js";
 import { SELFTUNE_CONFIG_PATH } from "./constants.js";
+import type { SkillTestingReadiness } from "./dashboard-contract.js";
 import { getDb } from "./localdb/db.js";
+import { writeCronRunToDb } from "./localdb/direct-write.js";
 import {
   getLastUploadError,
   getLastUploadSuccess,
@@ -30,6 +32,7 @@ import {
 import { computeMonitoringSnapshot, MIN_MONITORING_SKILL_CHECKS } from "./monitoring/watch.js";
 import { doctor } from "./observability.js";
 import { deriveTrustBucket, deriveTrustBucketReason } from "./trust-model.js";
+import { buildCreatorTestingOverview, listSkillTestingReadiness } from "./testing-readiness.js";
 import type {
   AgentCommandGuidance,
   AlphaLinkState,
@@ -313,7 +316,35 @@ function formatTrustHighlights(trustSummaries: SkillTrustSummary[] | undefined):
   return lines;
 }
 
-export function formatStatus(result: StatusResult, trustSummaries?: SkillTrustSummary[]): string {
+function formatCreatorLoopLines(readinessRows: SkillTestingReadiness[] | undefined): string[] {
+  if (!readinessRows || readinessRows.length === 0) return [];
+
+  const overview = buildCreatorTestingOverview(readinessRows);
+  const lines = ["Creator loop"];
+  lines.push(`  ${overview.summary}`);
+
+  const counts = overview.counts;
+  lines.push(
+    `  Generate evals: ${counts.generate_evals} | Unit tests: ${counts.run_unit_tests} | Replay dry-run: ${counts.run_replay_dry_run} | Baseline: ${counts.measure_baseline} | Deploy: ${counts.deploy_candidate} | Watching: ${counts.watch_deployment}`,
+  );
+
+  if (overview.priorities.length > 0) {
+    lines.push("  Next:");
+    for (const priority of overview.priorities.slice(0, 3)) {
+      lines.push(
+        `    ${priority.skill_name}: ${priority.next_step.replaceAll("_", " ")} — ${priority.recommended_command}`,
+      );
+    }
+  }
+
+  return lines;
+}
+
+export function formatStatus(
+  result: StatusResult,
+  trustSummaries?: SkillTrustSummary[],
+  testingReadiness?: SkillTestingReadiness[],
+): string {
   const noColor = !!process.env.NO_COLOR;
 
   const green = noColor ? (s: string) => s : (s: string) => colorize(s, "#788c5d");
@@ -333,6 +364,12 @@ export function formatStatus(result: StatusResult, trustSummaries?: SkillTrustSu
     lines.push("");
   }
 
+  const creatorLoopLines = formatCreatorLoopLines(testingReadiness);
+  if (creatorLoopLines.length > 0) {
+    lines.push(...creatorLoopLines);
+    lines.push("");
+  }
+
   // Skills table
   const skillCount = result.skills.length;
   lines.push(
@@ -576,6 +613,8 @@ export function formatAlphaStatus(info: AlphaStatusInfo | null): string {
 
 export async function cliMain(): Promise<void> {
   const db = getDb();
+  const statusStartedAt = new Date();
+  const statusStart = performance.now();
   try {
     const telemetry = querySessionTelemetry(db) as SessionTelemetryRecord[];
     const skillRecords = querySkillUsageRecords(db) as SkillUsageRecord[];
@@ -585,7 +624,8 @@ export async function cliMain(): Promise<void> {
 
     const result = computeStatus(telemetry, skillRecords, queryRecords, auditEntries, doctorResult);
     const trustSummaries = getSkillTrustSummaries(db);
-    const output = formatStatus(result, trustSummaries);
+    const testingReadiness = listSkillTestingReadiness(db);
+    const output = formatStatus(result, trustSummaries, testingReadiness);
     console.log(output);
 
     // Alpha upload status section
@@ -610,9 +650,37 @@ export async function cliMain(): Promise<void> {
     }
     console.log(formatAlphaStatus(alphaInfo));
 
+    // Log cron run for unified timeline visibility
+    const statusElapsed = Math.round(performance.now() - statusStart);
+    writeCronRunToDb(db, {
+      jobName: "status",
+      startedAt: statusStartedAt.toISOString(),
+      elapsedMs: statusElapsed,
+      status: "success",
+      metrics: {
+        total_skills: result.skills.length,
+        healthy: result.skills.filter((s) => s.status === "HEALTHY").length,
+        warning: result.skills.filter((s) => s.status === "WARNING").length,
+        critical: result.skills.filter((s) => s.status === "CRITICAL").length,
+        system_healthy: result.system.healthy,
+        unmatched_queries: result.unmatchedQueries,
+        pending_proposals: result.pendingProposals,
+      },
+    });
+
     process.exit(0);
   } catch (err) {
+    // Log failed status run
+    const statusElapsed = Math.round(performance.now() - statusStart);
     const message = err instanceof Error ? err.message : String(err);
+    writeCronRunToDb(db, {
+      jobName: "status",
+      startedAt: statusStartedAt.toISOString(),
+      elapsedMs: statusElapsed,
+      status: "error",
+      error: message,
+    });
+
     console.error(`selftune status failed: ${message}`);
     process.exit(1);
   }