selftune 0.2.30 → 0.2.32

package/cli/selftune/registry/install.ts

@@ -8,6 +8,7 @@ import { hostname } from "node:os";
 import { join } from "node:path";
 
 import { registryRequest } from "./client.js";
+import { installFromGithubTarget, parseGithubRegistryInstallTarget } from "./github-install.js";
 
 export async function cliMain() {
   const args = process.argv.slice(2);
@@ -17,13 +18,45 @@ export async function cliMain() {
   if (!name) {
     console.error(
       JSON.stringify({
-        error: "Usage: selftune registry install <name>",
+        error: "Usage: selftune registry install <name|github:owner/repo[@ref][//path]>",
         guidance: { next_command: "selftune registry list" },
       }),
     );
     process.exit(1);
   }
 
+  let githubTarget = null;
+  try {
+    githubTarget = parseGithubRegistryInstallTarget(name);
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        error: error instanceof Error ? error.message : "Invalid GitHub install target",
+        guidance: {
+          next_command: "selftune registry install github:owner/repo//path",
+        },
+      }),
+    );
+    process.exit(1);
+  }
+
+  if (githubTarget) {
+    try {
+      await installFromGithubTarget(name, globalFlag);
+      return;
+    } catch (error) {
+      console.error(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : "GitHub install failed",
+          guidance: {
+            next_command: "selftune registry install github:owner/repo//path",
+          },
+        }),
+      );
+      process.exit(1);
+    }
+  }
+
   // Find entry by name
   const listResult = await registryRequest<{
     entries: Array<{
@@ -49,7 +82,12 @@ export async function cliMain() {
   // Get detail with versions
   const detailResult = await registryRequest<{
     entry: { id: string; name: string };
-    versions: Array<{ id: string; version: string; content_hash: string; is_current: boolean }>;
+    versions: Array<{
+      id: string;
+      version: string;
+      content_hash: string;
+      is_current: boolean;
+    }>;
   }>("GET", `/${entryId}`);
 
   if (!detailResult.success) {
@@ -71,7 +109,9 @@ export async function cliMain() {
       latest_content_hash: string;
     }>;
   }>("POST", "/sync", {
-    body: { installations: [{ entry_id: entryId, current_version_hash: "none" }] },
+    body: {
+      installations: [{ entry_id: entryId, current_version_hash: "none" }],
+    },
   });
 
   const downloadUrl = syncResult.data?.entries?.[0]?.download_url;
@@ -82,7 +122,9 @@ export async function cliMain() {
 
   // Download archive
   console.log(`Installing ${name} v${currentVersion.version}...`);
-  const response = await fetch(downloadUrl, { signal: AbortSignal.timeout(60_000) });
+  const response = await fetch(downloadUrl, {
+    signal: AbortSignal.timeout(60_000),
+  });
   if (!response.ok) {
     console.error(JSON.stringify({ error: `Download failed: HTTP ${response.status}` }));
     process.exit(1);
@@ -119,13 +161,22 @@ export async function cliMain() {
 
   // Update local state
   const statePath = join(process.env.HOME || "~", ".selftune", "registry-state.json");
-  let state: Array<{ entryId: string; name: string; versionHash: string; installPath: string }> =
-    [];
+  let state: Array<{
+    entryId: string;
+    name: string;
+    versionHash: string;
+    installPath: string;
+  }> = [];
   try {
     state = JSON.parse(readFileSync(statePath, "utf-8"));
   } catch {}
   state = state.filter((s) => s.entryId !== entryId);
-  state.push({ entryId, name, versionHash: currentVersion.content_hash, installPath: targetDir });
+  state.push({
+    entryId,
+    name,
+    versionHash: currentVersion.content_hash,
+    installPath: targetDir,
+  });
   await mkdir(join(process.env.HOME || "~", ".selftune"), { recursive: true });
   await writeFile(statePath, JSON.stringify(state, null, 2));
 

package/cli/selftune/routes/actions.ts

@@ -1,5 +1,5 @@
 /**
- * Route handler: POST /api/actions/{watch,evolve,rollback,watchlist}
+ * Route handler: POST /api/actions/{create-check,report-package,search-run,watch,evolve,rollback,watchlist}
  *
  * Triggers selftune CLI commands as child processes and returns the result.
  */
@@ -13,6 +13,7 @@ import {
 } from "../dashboard-action-events.js";
 import { resolveDashboardActionOutcome } from "../dashboard-action-result.js";
 import type { DashboardActionEvent, DashboardActionName } from "../dashboard-contract.js";
+import { isCreateSkillDraft } from "../create/readiness.js";
 import { getCanonicalEvalSetPath, getUnitTestPath } from "../testing-readiness.js";
 import { saveWatchedSkills } from "../watchlist.js";
 
@@ -91,7 +92,10 @@ export async function runAction(
       stdoutPromise,
       stderrPromise,
     ]);
-    const action = command === "evolve" && args.includes("--dry-run") ? "replay-dry-run" : null;
+    const action =
+      (command === "evolve" || command === "improve") && args.includes("--dry-run")
+        ? "replay-dry-run"
+        : null;
     const outcome = action
       ? resolveDashboardActionOutcome({
           action,
@@ -136,6 +140,7 @@ function buildActionExecution(
   const skillInput = requireSkillInput(body);
   if (skillInput instanceof Response) return skillInput;
   const { skill, skillPath } = skillInput;
+  const isDraftPackage = isCreateSkillDraft(skillPath);
 
   if (action === "generate-evals") {
     const args = [
@@ -171,7 +176,24 @@ function buildActionExecution(
     };
   }
 
+  if (action === "create-check") {
+    return {
+      command: "create",
+      args: ["check", "--skill-path", skillPath],
+      skill,
+      skillPath,
+    };
+  }
+
   if (action === "replay-dry-run") {
+    if (isDraftPackage) {
+      return {
+        command: "create",
+        args: ["replay", "--skill-path", skillPath, "--mode", "package"],
+        skill,
+        skillPath,
+      };
+    }
     return {
       command: "evolve",
       args: [
@@ -190,6 +212,14 @@ function buildActionExecution(
   }
 
   if (action === "measure-baseline") {
+    if (isDraftPackage) {
+      return {
+        command: "create",
+        args: ["baseline", "--skill-path", skillPath, "--mode", "package"],
+        skill,
+        skillPath,
+      };
+    }
     return {
       command: "grade",
       args: ["baseline", "--skill", skill, "--skill-path", skillPath],
@@ -198,9 +228,35 @@ function buildActionExecution(
     };
   }
 
+  if (action === "report-package") {
+    return {
+      command: "create",
+      args: ["report", "--skill-path", skillPath],
+      skill,
+      skillPath,
+    };
+  }
+
+  if (action === "search-run") {
+    return {
+      command: "search-run",
+      args: ["--skill", skill, "--skill-path", skillPath],
+      skill,
+      skillPath,
+    };
+  }
+
   if (action === "deploy-candidate") {
+    if (isDraftPackage) {
+      return {
+        command: "publish",
+        args: ["--skill-path", skillPath, "--no-watch"],
+        skill,
+        skillPath,
+      };
+    }
     return {
-      command: "evolve",
+      command: "improve",
       args: ["--skill", skill, "--skill-path", skillPath, "--sync-first"],
       skill,
       skillPath,
@@ -208,6 +264,14 @@ function buildActionExecution(
   }
 
   if (action === "watch") {
+    if (isDraftPackage) {
+      return {
+        command: "publish",
+        args: ["--skill-path", skillPath],
+        skill,
+        skillPath,
+      };
+    }
     return {
       command: "watch",
       args: ["--skill", skill, "--skill-path", skillPath, "--sync-first"],
@@ -316,6 +380,12 @@ export async function handleAction(
       });
     },
   });
+  const outcome = resolveDashboardActionOutcome({
+    action: normalizedAction as DashboardActionName,
+    stdout: result.output,
+    stderr: result.error,
+    exitCode: result.exitCode ?? 0,
+  });
 
   emitEvent?.({
     event_id: eventId,
@@ -324,19 +394,15 @@ export async function handleAction(
     skill_name: executable.skill,
     skill_path: executable.skillPath,
     ts: Date.now(),
-    success: result.success,
+    success: outcome.success,
     exit_code: result.exitCode,
-    error: result.error,
-    summary:
-      executable.command === "evolve" && executable.args.includes("--dry-run")
-        ? resolveDashboardActionOutcome({
-            action: "replay-dry-run",
-            stdout: result.output,
-            stderr: result.error,
-            exitCode: result.exitCode ?? 0,
-          }).summary
-        : null,
+    error: outcome.error,
+    summary: outcome.summary,
   });
 
-  return Response.json(result);
+  return Response.json({
+    ...result,
+    success: outcome.success,
+    error: outcome.error,
+  });
 }

package/cli/selftune/routes/overview.ts

@@ -42,7 +42,7 @@ export function handleOverview(
   const pendingReviews = attentionQueue.filter((a) => a.category === "needs_review").length;
 
   const trustWatchlist = buildTrustWatchlist(trustSummaries);
-  const creatorTesting = buildCreatorTestingOverview(testingReadiness);
+  const creatorTesting = buildCreatorTestingOverview(skills);
   const autonomyStatus = buildAutonomyStatus(
     db,
     attentionQueue,

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

@@ -9,6 +9,12 @@
 import type { Database } from "bun:sqlite";
 
 import { parseCursorParam } from "../dashboard-contract.js";
+import {
+  listAcceptedPackageFrontierCandidates,
+  listPackageCandidates,
+} from "../create/package-candidate-state.js";
+import { readSearchRuns } from "../create/package-search.js";
+import { computeCreateDashboardReadiness, isCreateSkillDraft } from "../create/readiness.js";
 import { scoreDescription } from "../evolution/description-quality.js";
 import {
   getExecutionMetrics,
@@ -17,7 +23,129 @@ import {
   getSkillReportPayload,
   safeParseJson,
 } from "../localdb/queries.js";
-import { getSkillTestingReadiness } from "../testing-readiness.js";
+import { computeWatchTrustScore } from "../monitoring/watch.js";
+import type { WatchResult } from "../monitoring/watch.js";
+import {
+  getSkillTestingReadiness,
+  readCanonicalPackageEvaluationArtifact,
+} from "../testing-readiness.js";
+import type { CreatePackageEvaluationWatchSummary } from "../types.js";
+
+function readMeasuredDelta(summary: {
+  candidate_acceptance?: {
+    replay_pass_rate_delta: number | null;
+    routing_pass_rate_delta: number | null;
+    baseline_lift_delta: number | null;
+    body_quality_delta: number | null;
+    unit_test_pass_rate_delta: number | null;
+  };
+}): number | null {
+  const acceptance = summary.candidate_acceptance;
+  if (!acceptance) return null;
+
+  const deltas = [
+    acceptance.replay_pass_rate_delta,
+    acceptance.routing_pass_rate_delta,
+    acceptance.baseline_lift_delta,
+    acceptance.body_quality_delta,
+    acceptance.unit_test_pass_rate_delta,
+  ];
+  return deltas.find((delta) => delta != null) ?? null;
+}
+
+function isWatchDemoted(summary: {
+  watch?: {
+    rolled_back?: boolean | null;
+    alert?: string | null;
+    grade_regression?: boolean | null;
+    efficiency_regression?: boolean | null;
+  };
+}): boolean {
+  const watch = summary.watch;
+  return Boolean(
+    watch?.rolled_back || watch?.alert || watch?.grade_regression || watch?.efficiency_regression,
+  );
+}
+
+function buildFrontierState(db: Database, skillName: string) {
+  const candidates = listPackageCandidates(skillName, db);
+  if (candidates.length === 0) return null;
+
+  const acceptedFrontier = listAcceptedPackageFrontierCandidates(skillName, db);
+  const evidenceRanks = new Map(
+    acceptedFrontier.map((candidate, index) => [candidate.candidate_id, index + 1]),
+  );
+
+  const members = candidates.map((candidate) => ({
+    candidate_id: candidate.candidate_id,
+    skill_name: candidate.skill_name,
+    fingerprint: candidate.package_fingerprint,
+    decision:
+      candidate.latest_acceptance_decision === "root" ||
+      candidate.latest_acceptance_decision === "accepted"
+        ? "accepted"
+        : candidate.latest_acceptance_decision === "rejected"
+          ? "rejected"
+          : "pending",
+    measured_delta: readMeasuredDelta(candidate.summary),
+    created_at: candidate.first_evaluated_at,
+    parent_candidate_id: candidate.parent_candidate_id,
+    watch_demoted: isWatchDemoted(candidate.summary),
+    evidence_rank: evidenceRanks.get(candidate.candidate_id) ?? null,
+  }));
+
+  const latestSearchRun = readSearchRuns(db, skillName)[0] ?? null;
+
+  return {
+    skill_name: skillName,
+    accepted_count: members.filter((member) => member.decision === "accepted").length,
+    rejected_count: members.filter((member) => member.decision === "rejected").length,
+    pending_count: members.filter((member) => member.decision === "pending").length,
+    members,
+    latest_search_run: latestSearchRun,
+  };
+}
+
+function hydrateWatchResult(summary: CreatePackageEvaluationWatchSummary): WatchResult {
+  return {
+    snapshot: summary.snapshot,
+    alert: summary.alert,
+    rolledBack: summary.rolled_back,
+    recommendation: summary.recommendation,
+    recommended_command: summary.recommended_command,
+    gradeAlert: summary.grade_alert,
+    gradeRegression: summary.grade_regression,
+    ...(summary.efficiency_alert || summary.efficiency_regression
+      ? {
+          efficiencyAlert: summary.efficiency_alert ?? null,
+          efficiencyRegression: summary.efficiency_regression ?? null,
+        }
+      : {}),
+  };
+}
+
+function readWatchTrustScore(db: Database, skillName: string): number | null {
+  const row = db
+    .query(
+      `SELECT summary_json
+       FROM package_evaluation_reports
+       WHERE skill_name = ?`,
+    )
+    .get(skillName) as { summary_json: string } | null;
+
+  const parsedSummary = row?.summary_json ? safeParseJson(row.summary_json) : null;
+  const summaryWatch = parsedSummary?.watch as CreatePackageEvaluationWatchSummary | undefined;
+  if (summaryWatch?.snapshot) {
+    return computeWatchTrustScore(hydrateWatchResult(summaryWatch));
+  }
+
+  const artifactWatch = readCanonicalPackageEvaluationArtifact(skillName)?.summary.watch;
+  if (artifactWatch?.snapshot) {
+    return computeWatchTrustScore(hydrateWatchResult(artifactWatch));
+  }
+
+  return null;
+}
 
 export function handleSkillReport(
   db: Database,
@@ -26,6 +154,18 @@ export function handleSkillReport(
 ): Response {
   const report = getSkillReportPayload(db, skillName);
   const testing_readiness = getSkillTestingReadiness(db, skillName);
+  const frontier_state = buildFrontierState(db, skillName);
+  const watch_trust_score = readWatchTrustScore(db, skillName);
+  let create_readiness = null;
+  if (testing_readiness?.skill_path && isCreateSkillDraft(testing_readiness.skill_path)) {
+    try {
+      create_readiness = computeCreateDashboardReadiness(testing_readiness.skill_path, {
+        getTestingReadiness: () => testing_readiness,
+      });
+    } catch {
+      create_readiness = null;
+    }
+  }
 
   // 1. Evolution audit with eval_snapshot
   const evolution = db
@@ -187,7 +327,9 @@ export function handleSkillReport(
       testing_readiness?.unit_test_cases ||
       testing_readiness?.replay_check_count ||
       testing_readiness?.baseline_sample_size,
-    );
+    ) ||
+    Boolean(create_readiness) ||
+    Boolean(frontier_state);
   if (!hasData) {
     return Response.json({ error: "Skill not found" }, { status: 404 });
   }
@@ -892,5 +1034,8 @@ export function handleSkillReport(
     data_hygiene,
     examples,
     testing_readiness,
+    create_readiness,
+    watch_trust_score,
+    frontier_state,
   });
 }

package/cli/selftune/run.ts

@@ -0,0 +1,18 @@
+import { PUBLIC_COMMAND_SURFACES, renderCommandHelp } from "./command-surface.js";
+import { cliMain as orchestrateCliMain } from "./orchestrate.js";
+import { handleCLIError } from "./utils/cli-error.js";
+
+export async function cliMain(): Promise<void> {
+  const rawArgs = process.argv.slice(2);
+
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    console.log(renderCommandHelp(PUBLIC_COMMAND_SURFACES.run));
+    process.exit(0);
+  }
+
+  await orchestrateCliMain();
+}
+
+if (import.meta.main) {
+  cliMain().catch(handleCLIError);
+}

package/cli/selftune/schedule.ts

@@ -58,7 +58,7 @@ function commandForJob(jobName: string): string {
     case "selftune-status":
       return "selftune sync && selftune status";
     case "selftune-orchestrate":
-      return "selftune orchestrate --max-skills 3";
+      return "selftune run --max-skills 3";
     default:
       return `selftune ${jobName.replace("selftune-", "")}`;
   }
@@ -162,8 +162,8 @@ export function generateCrontab(): string {
   const lines = [
     "# selftune automation — add to your crontab with: crontab -e",
     "#",
-    "# The core loop: sync → orchestrate",
-    "# status remains a reporting job; orchestrate handles sync, candidate",
+    "# The core loop: sync → run",
+    "# status remains a reporting job; run handles sync, candidate",
     "# selection, low-risk description evolution, and watch/rollback follow-up.",
     "#",
     `PATH=${home}/.bun/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin`,