selftune 0.2.18 → 0.2.20

package/cli/selftune/routes/actions.ts

@@ -1,11 +1,13 @@
 /**
- * Route handler: POST /api/actions/{watch,evolve,rollback}
+ * Route handler: POST /api/actions/{watch,evolve,rollback,watchlist}
  *
  * Triggers selftune CLI commands as child processes and returns the result.
  */
 
 import { join } from "node:path";
 
+import { saveWatchedSkills } from "../watchlist.js";
+
 export type ActionRunner = (
   command: string,
   args: string[],
@@ -41,6 +43,38 @@ export async function handleAction(
   body: Record<string, unknown>,
   executeAction: ActionRunner = runAction,
 ): Promise<Response> {
+  if (action === "watchlist") {
+    const skills = body.skills;
+    if (skills === undefined || skills === null) {
+      return Response.json(
+        { success: false, error: "Missing required field: skills[]" },
+        { status: 400 },
+      );
+    }
+    if (!Array.isArray(skills) || !skills.every((skill) => typeof skill === "string")) {
+      return Response.json(
+        {
+          success: false,
+          error: "Invalid type for skills: expected array of strings",
+        },
+        { status: 400 },
+      );
+    }
+    try {
+      const saved = saveWatchedSkills(skills);
+      return Response.json({ success: true, watched_skills: saved, error: null });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      return Response.json(
+        {
+          success: false,
+          error: `Failed to save watched skills. Check your selftune config directory and try again. ${message}`,
+        },
+        { status: 500 },
+      );
+    }
+  }
+
   if (action === "watch" || action === "evolve") {
     const skill = body.skill as string | undefined;
     const skillPath = body.skillPath as string | undefined;

package/cli/selftune/routes/analytics.ts

@@ -0,0 +1,14 @@
+/**
+ * Route handler: GET /api/v2/analytics
+ *
+ * Returns performance analytics payload from SQLite.
+ */
+
+import type { Database } from "bun:sqlite";
+
+import { getAnalyticsPayload } from "../localdb/queries.js";
+
+export function handleAnalytics(db: Database): Response {
+  const analytics = getAnalyticsPayload(db);
+  return Response.json(analytics);
+}

package/cli/selftune/routes/index.ts

@@ -6,6 +6,7 @@
 
 export type { ActionRunner } from "./actions.js";
 export { handleAction, runAction } from "./actions.js";
+export { handleAnalytics } from "./analytics.js";
 export { handleBadge } from "./badge.js";
 export { handleDoctor } from "./doctor.js";
 export { handleOrchestrateRuns } from "./orchestrate-runs.js";

package/cli/selftune/routes/overview.ts

@@ -8,12 +8,24 @@
 
 import type { Database } from "bun:sqlite";
 
+import type {
+  AttentionItem,
+  AutonomousDecision,
+  AutonomyStatus,
+  AutonomyStatusLevel,
+  OverviewResponse,
+} from "../dashboard-contract.js";
 import { parseCursorParam, parseIntParam } from "../dashboard-contract.js";
 import {
+  getAttentionQueue,
   getOverviewPayload,
   getOverviewPayloadPaginated,
+  getRecentDecisions,
+  getSkillTrustSummaries,
   getSkillsList,
 } from "../localdb/queries.js";
+import { buildTrustWatchlist } from "../trust-model.js";
+import { loadWatchedSkills } from "../watchlist.js";
 
 export function handleOverview(
   db: Database,
@@ -22,18 +34,43 @@ export function handleOverview(
 ): Response {
   const skills = getSkillsList(db);
 
-  // Check if any pagination params are provided
+  // -- Autonomy-first enrichment fields ----------------------------------------
+  const attentionQueue = getAttentionQueue(db);
+  const recentDecisions = getRecentDecisions(db);
+  const trustSummaries = getSkillTrustSummaries(db);
+  const pendingReviews = attentionQueue.filter((a) => a.category === "needs_review").length;
+
+  const trustWatchlist = buildTrustWatchlist(trustSummaries);
+  const autonomyStatus = buildAutonomyStatus(
+    db,
+    attentionQueue,
+    recentDecisions,
+    skills.length,
+    pendingReviews,
+  );
+
+  const enrichment = {
+    watched_skills: loadWatchedSkills(),
+    autonomy_status: autonomyStatus,
+    attention_queue: attentionQueue,
+    trust_watchlist: trustWatchlist,
+    recent_decisions: recentDecisions,
+  };
+
+  // -- Standard overview payload -----------------------------------------------
   const hasPaginationParams =
     searchParams &&
     (searchParams.has("telemetry_cursor") ||
       searchParams.has("telemetry_limit") ||
       searchParams.has("skills_cursor") ||
       searchParams.has("skills_limit"));
+  const hasSkillsPagination =
+    searchParams && (searchParams.has("skills_cursor") || searchParams.has("skills_limit"));
 
   if (!hasPaginationParams) {
-    // Backward-compatible: return the unpaginated overview
     const overview = getOverviewPayload(db);
-    return Response.json({ overview, skills, version });
+    const response: OverviewResponse = { overview, skills, version, ...enrichment };
+    return Response.json(response);
   }
 
   // Parse pagination params
@@ -49,5 +86,76 @@ export function handleOverview(
     skills_limit: skillsLimit,
   });
 
-  return Response.json({ overview, skills, version });
+  const paginatedSkillNames = new Set(overview.skills_page.items.map((row) => row.skill_name));
+  const paginatedSkills = hasSkillsPagination
+    ? skills.filter((skill) => paginatedSkillNames.has(skill.skill_name))
+    : skills;
+
+  return Response.json({ overview, skills: paginatedSkills, version, ...enrichment });
+}
+
+// -- Internal helpers ----------------------------------------------------------
+
+function buildAutonomyStatus(
+  db: Database,
+  attentionQueue: AttentionItem[],
+  recentDecisions: AutonomousDecision[],
+  skillsObserved: number,
+  pendingReviews: number,
+): AutonomyStatus {
+  let lastRun: string | null = null;
+  try {
+    const row = db
+      .query(`SELECT timestamp FROM orchestrate_runs ORDER BY timestamp DESC LIMIT 1`)
+      .get() as { timestamp: string } | null;
+    lastRun = row?.timestamp ?? null;
+  } catch {
+    // Table may not exist
+  }
+
+  const hasCritical = attentionQueue.some((a) => a.severity === "critical");
+
+  // "watching" means recent autonomous activity — last run within 24 hours
+  // or recent decisions within the 7-day freshness window
+  const hasRecentActivity =
+    (lastRun != null && Date.now() - new Date(lastRun).getTime() < 24 * 60 * 60 * 1000) ||
+    recentDecisions.length > 0;
+
+  let level: AutonomyStatusLevel;
+  if (hasCritical) {
+    level = "blocked";
+  } else if (pendingReviews > 0) {
+    level = "needs_review";
+  } else if (hasRecentActivity) {
+    level = "watching";
+  } else {
+    level = "healthy";
+  }
+
+  let summary: string;
+  switch (level) {
+    case "healthy":
+      summary = "No action needed. System is healthy.";
+      break;
+    case "blocked": {
+      const critCount = attentionQueue.filter((a) => a.severity === "critical").length;
+      summary = `${critCount} skill${critCount !== 1 ? "s" : ""} need${critCount === 1 ? "s" : ""} urgent attention after rollback.`;
+      break;
+    }
+    case "needs_review":
+      summary = `selftune is watching ${skillsObserved} skill${skillsObserved !== 1 ? "s" : ""} and needs review on ${pendingReviews} proposal${pendingReviews !== 1 ? "s" : ""}.`;
+      break;
+    case "watching":
+      summary = `selftune is actively watching ${skillsObserved} skill${skillsObserved !== 1 ? "s" : ""}. No action needed.`;
+      break;
+  }
+
+  return {
+    level,
+    summary,
+    last_run: lastRun,
+    skills_observed: skillsObserved,
+    pending_reviews: pendingReviews,
+    attention_required: attentionQueue.length,
+  };
 }