selftune 0.2.16 → 0.2.19

package/cli/selftune/status.ts

@@ -20,13 +20,16 @@ import { getDb } from "./localdb/db.js";
 import {
   getLastUploadError,
   getLastUploadSuccess,
+  getSkillTrustSummaries,
   queryEvolutionAudit,
   queryQueryLog,
   querySessionTelemetry,
   querySkillUsageRecords,
+  type SkillTrustSummary,
 } from "./localdb/queries.js";
 import { computeMonitoringSnapshot, MIN_MONITORING_SKILL_CHECKS } from "./monitoring/watch.js";
 import { doctor } from "./observability.js";
+import { deriveTrustBucket, deriveTrustBucketReason } from "./trust-model.js";
 import type {
   AgentCommandGuidance,
   AlphaLinkState,
@@ -273,7 +276,44 @@ const TREND_SYMBOLS: Record<string, string> = {
   unknown: "?",
 };
 
-export function formatStatus(result: StatusResult): string {
+function formatTrustHighlights(trustSummaries: SkillTrustSummary[] | undefined): string[] {
+  if (!trustSummaries || trustSummaries.length === 0) return [];
+
+  const recentSort = (a: SkillTrustSummary, b: SkillTrustSummary) =>
+    (b.last_seen ?? "").localeCompare(a.last_seen ?? "");
+  const attention = [...trustSummaries]
+    .filter((summary) => deriveTrustBucket(summary) === "at_risk")
+    .sort(recentSort)
+    .slice(0, 3);
+  const improving = [...trustSummaries]
+    .filter((summary) => deriveTrustBucket(summary) === "improving")
+    .sort(recentSort)
+    .slice(0, 3);
+
+  if (attention.length === 0 && improving.length === 0) return [];
+
+  const lines = ["Highlights"];
+  if (attention.length > 0) {
+    lines.push(
+      `  Attention: ${attention
+        .map((summary) => `${summary.skill_name} (${deriveTrustBucketReason("at_risk", summary)})`)
+        .join("; ")}`,
+    );
+  }
+  if (improving.length > 0) {
+    lines.push(
+      `  Improving: ${improving
+        .map(
+          (summary) => `${summary.skill_name} (${deriveTrustBucketReason("improving", summary)})`,
+        )
+        .join("; ")}`,
+    );
+  }
+
+  return lines;
+}
+
+export function formatStatus(result: StatusResult, trustSummaries?: SkillTrustSummary[]): string {
   const noColor = !!process.env.NO_COLOR;
 
   const green = noColor ? (s: string) => s : (s: string) => colorize(s, "#788c5d");
@@ -284,6 +324,14 @@ export function formatStatus(result: StatusResult): string {
   lines.push("selftune status");
   lines.push("\u2550".repeat(15));
   lines.push("");
+  lines.push(formatStatusSummary(result, trustSummaries));
+  lines.push("");
+
+  const highlightLines = formatTrustHighlights(trustSummaries);
+  if (highlightLines.length > 0) {
+    lines.push(...highlightLines);
+    lines.push("");
+  }
 
   // Skills table
   const skillCount = result.skills.length;
@@ -351,6 +399,36 @@ export function formatStatus(result: StatusResult): string {
   return lines.join("\n");
 }
 
+export function formatStatusSummary(
+  result: StatusResult,
+  trustSummaries?: SkillTrustSummary[],
+): string {
+  const watched = trustSummaries?.length ?? result.skills.length;
+  const improving =
+    trustSummaries?.filter((summary) => deriveTrustBucket(summary) === "improving").length ??
+    result.skills.filter((skill) => skill.trend === "up").length;
+  const needsAttention =
+    trustSummaries?.filter((summary) => deriveTrustBucket(summary) === "at_risk").length ??
+    result.skills.filter((skill) => skill.status === "WARNING" || skill.status === "CRITICAL")
+      .length;
+
+  const watchedText = `${watched} ${watched === 1 ? "skill" : "skills"} watched`;
+  const improvingText =
+    improving > 0
+      ? `${improving} improving`
+      : result.lastSession
+        ? "no recent lift"
+        : "no recent data";
+  const attentionText =
+    needsAttention > 0
+      ? `${needsAttention} needing attention`
+      : watched > 0
+        ? "nothing urgent"
+        : "nothing tracked yet";
+
+  return `${watchedText} | ${improvingText} | ${attentionText}`;
+}
+
 // ---------------------------------------------------------------------------
 // Terminal color helper using ANSI escapes
 // ---------------------------------------------------------------------------
@@ -506,7 +584,8 @@ export async function cliMain(): Promise<void> {
     const doctorResult = await doctor();
 
     const result = computeStatus(telemetry, skillRecords, queryRecords, auditEntries, doctorResult);
-    const output = formatStatus(result);
+    const trustSummaries = getSkillTrustSummaries(db);
+    const output = formatStatus(result, trustSummaries);
     console.log(output);
 
     // Alpha upload status section

package/cli/selftune/sync.ts

@@ -31,6 +31,7 @@ import {
   SKILL_LOG,
   TELEMETRY_LOG,
 } from "./constants.js";
+import { stageCreatorContributionSignals } from "./contribution-staging.js";
 import {
   findTranscriptFiles,
   parseSession,
@@ -58,6 +59,7 @@ import {
 import { getDb } from "./localdb/db.js";
 import { querySkillUsageRecords } from "./localdb/queries.js";
 import {
+  persistRepairedSkillUsageToDb,
   rebuildSkillUsageFromCodexRollouts,
   rebuildSkillUsageFromTranscripts,
 } from "./repair/skill-usage.js";
@@ -96,6 +98,12 @@ export interface SyncResult {
     repaired_records: number;
     codex_repaired_records: number;
   };
+  creator_contributions: {
+    ran: boolean;
+    eligible_skills: number;
+    built_signals: number;
+    staged_signals: number;
+  };
   timings: SyncPhaseTiming[];
   total_elapsed_ms: number;
 }
@@ -130,6 +138,14 @@ export interface SyncDeps {
     repairedRecords: number;
     codexRepairedRecords: number;
   };
+  stageCreatorContributions?: (
+    db: ReturnType<typeof getDb>,
+    options: { dryRun: boolean },
+  ) => {
+    eligible_skills: number;
+    built_signals: number;
+    staged_signals: number;
+  };
 }
 
 export function createDefaultSyncOptions(overrides: Partial<SyncOptions> = {}): SyncOptions {
@@ -344,6 +360,7 @@ function rebuildSkillUsageOverlay(
   options: SyncOptions,
   onProgress?: SyncProgressCallback,
   cache?: FileListCache,
+  db: ReturnType<typeof getDb> = getDb(),
 ): {
   repairedSessions: number;
   repairedRecords: number;
@@ -363,7 +380,6 @@ function rebuildSkillUsageOverlay(
   let rawSkillRecords: SkillUsageRecord[];
   if (options.skillLogPath === SKILL_LOG) {
     try {
-      const db = getDb();
       rawSkillRecords = querySkillUsageRecords(db) as SkillUsageRecord[];
     } catch {
       rawSkillRecords = readJsonl<SkillUsageRecord>(options.skillLogPath);
@@ -389,6 +405,7 @@ function rebuildSkillUsageOverlay(
   repairedRecords.push(...codexRecords);
 
   if (!options.dryRun) {
+    persistRepairedSkillUsageToDb(db, repairedRecords);
     writeRepairedSkillUsageRecords(
       repairedRecords,
       repairedSessionIds,
@@ -429,6 +446,8 @@ export function syncSources(
   const runOpenCode = deps.syncOpenCode;
   const runOpenClaw = deps.syncOpenClaw;
   const runRepair = deps.rebuildSkillUsage;
+  const runCreatorContributions = deps.stageCreatorContributions;
+  const db = getDb();
 
   const disabledStep: SyncStepResult = { available: false, scanned: 0, synced: 0, skipped: 0 };
 
@@ -470,11 +489,27 @@ export function syncSources(
     ? timePhase(
         "repair",
         () =>
-          runRepair ? runRepair(options) : rebuildSkillUsageOverlay(options, onProgress, cache),
+          runRepair ? runRepair(options) : rebuildSkillUsageOverlay(options, onProgress, cache, db),
         timings,
       )
     : { repairedSessions: 0, repairedRecords: 0, codexRepairedRecords: 0 };
 
+  const creatorContributions = timePhase(
+    "creator_contributions",
+    () => {
+      const staged = runCreatorContributions
+        ? runCreatorContributions(db, { dryRun: options.dryRun })
+        : stageCreatorContributionSignals(db, { dryRun: options.dryRun });
+      return {
+        ran: true,
+        eligible_skills: staged.eligible_skills,
+        built_signals: staged.built_signals,
+        staged_signals: staged.staged_signals,
+      };
+    },
+    timings,
+  );
+
   const totalElapsed = Math.round(performance.now() - totalStart);
 
   return {
@@ -487,6 +522,7 @@ export function syncSources(
       repaired_records: repair.repairedRecords,
       codex_repaired_records: repair.codexRepairedRecords,
     },
+    creator_contributions: creatorContributions,
     timings,
     total_elapsed_ms: totalElapsed,
   };
@@ -636,6 +672,24 @@ Options:
       );
     }
 
+    if (
+      result.creator_contributions.eligible_skills > 0 ||
+      result.creator_contributions.built_signals > 0
+    ) {
+      const contributionTiming = timingMap.get("creator_contributions");
+      const contributionTime = contributionTiming
+        ? ` (${formatMs(contributionTiming.elapsed_ms)})`
+        : "";
+      process.stderr.write(
+        `Creator contributions: ${result.creator_contributions.built_signals} signals from ` +
+          `${result.creator_contributions.eligible_skills} skills` +
+          (result.dry_run
+            ? " ready to stage"
+            : ` staged=${result.creator_contributions.staged_signals}`) +
+          `${contributionTime}\n`,
+      );
+    }
+
     process.stderr.write(`\nDone in ${formatMs(result.total_elapsed_ms)}\n`);
   }
 

package/cli/selftune/trust-model.ts

@@ -0,0 +1,66 @@
+import type { TrustBucket, TrustState, TrustWatchlistEntry } from "./dashboard-contract.js";
+import type { SkillTrustSummary } from "./localdb/queries.js";
+
+const AT_RISK_MISS_RATE_THRESHOLD = 0.15;
+const UNCERTAIN_MIN_CHECKS = 10;
+
+function formatPercent(value: number): string {
+  return `${(value * 100).toFixed(1).replace(/\.0$/, "")}%`;
+}
+
+export function deriveTrustState(summary: SkillTrustSummary): TrustState {
+  if (summary.latest_action === "rolled_back") return "rolled_back";
+  if (summary.latest_action === "deployed") return "deployed";
+  if (summary.latest_action === "validated") return "validated";
+  if (summary.latest_action === "watch") return "watch";
+  if (summary.total_checks < 5) return "low_sample";
+  return "observed";
+}
+
+export function deriveTrustBucket(summary: SkillTrustSummary): TrustBucket {
+  if (summary.latest_action === "rolled_back" || summary.miss_rate > AT_RISK_MISS_RATE_THRESHOLD) {
+    return "at_risk";
+  }
+  if (
+    summary.latest_action === "validated" ||
+    summary.latest_action === "created" ||
+    summary.latest_action === "proposed"
+  ) {
+    return "improving";
+  }
+  if (summary.total_checks < UNCERTAIN_MIN_CHECKS || summary.latest_action === "watch") {
+    return "uncertain";
+  }
+  return "stable";
+}
+
+export function deriveTrustBucketReason(bucket: TrustBucket, summary: SkillTrustSummary): string {
+  switch (bucket) {
+    case "at_risk":
+      if (summary.latest_action === "rolled_back") return "Recently rolled back";
+      return `High miss rate (${formatPercent(summary.miss_rate)})`;
+    case "improving":
+      if (summary.latest_action === "validated") return "Proposal validated, pending deploy";
+      return "Has pending evolution proposal";
+    case "uncertain":
+      if (summary.total_checks < 10) return `Low sample size (${summary.total_checks} checks)`;
+      return "Under active observation";
+    case "stable":
+      return "Routing healthy, no issues detected";
+  }
+}
+
+export function buildTrustWatchlist(summaries: SkillTrustSummary[]): TrustWatchlistEntry[] {
+  return summaries.map((summary) => {
+    const bucket = deriveTrustBucket(summary);
+    return {
+      skill_name: summary.skill_name,
+      bucket,
+      trust_state: deriveTrustState(summary),
+      reason: deriveTrustBucketReason(bucket, summary),
+      pass_rate: summary.pass_rate,
+      checks: summary.total_checks,
+      last_seen: summary.last_seen,
+    };
+  });
+}

package/cli/selftune/types.ts

@@ -93,6 +93,17 @@ export interface SessionTelemetryRecord {
   source?: string;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: SessionType;
   agent_summary?: string;
   rollout_path?: string;
 }
@@ -140,6 +151,13 @@ export {
   CANONICAL_SOURCE_SESSION_KINDS,
 } from "@selftune/telemetry-contract/types";
 
+// ---------------------------------------------------------------------------
+// Session classification
+// ---------------------------------------------------------------------------
+
+/** Inferred session type based on tool distribution. */
+export type SessionType = "dev" | "research" | "content" | "mixed";
+
 // ---------------------------------------------------------------------------
 // Transcript parsing
 // ---------------------------------------------------------------------------
@@ -156,6 +174,17 @@ export interface TranscriptMetrics {
   last_user_query: string;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  /** Count of output-producing tool calls (Write, Edit, WebFetch, WebSearch, Skill, Agent). */
+  artifact_count?: number;
+  /** Inferred session type based on tool distribution. */
+  session_type?: SessionType;
   duration_ms?: number;
   model?: string;
   started_at?: string;
@@ -290,6 +319,8 @@ export interface ExecutionMetrics {
   errors_encountered: number;
   skills_triggered: string[];
   transcript_chars: number;
+  artifact_count?: number;
+  session_type?: SessionType;
 }
 
 // ---------------------------------------------------------------------------
@@ -823,6 +854,55 @@ export interface ComposabilityReportV2 extends ComposabilityReport {
   synergy_count: number;
 }
 
+// ---------------------------------------------------------------------------
+// Skill family overlap / consolidation types
+// ---------------------------------------------------------------------------
+
+export interface SkillFamilyOverlapMember {
+  skill_name: string;
+  skill_path?: string;
+  positive_query_count: number;
+}
+
+export interface SkillFamilyOverlapPair {
+  skill_a: string;
+  skill_b: string;
+  overlap_pct: number;
+  shared_query_count: number;
+  shared_queries: string[];
+  consolidation_pressure: "low" | "medium" | "high";
+}
+
+export interface SkillFamilyRefactorWorkflow {
+  workflow_name: string;
+  source_skill: string;
+  suggested_path: string;
+}
+
+export interface SkillFamilyRefactorProposal {
+  parent_skill_name: string;
+  family_prefix?: string;
+  internal_workflows: SkillFamilyRefactorWorkflow[];
+  compatibility_aliases: Array<{ skill_name: string; target_workflow: string }>;
+  migration_notes: string[];
+}
+
+export interface SkillFamilyOverlapReport {
+  family_prefix?: string;
+  analyzed_skills: string[];
+  members: SkillFamilyOverlapMember[];
+  pairs: SkillFamilyOverlapPair[];
+  total_pairs_analyzed: number;
+  overlap_count: number;
+  overlap_density: number;
+  average_overlap_pct: number;
+  consolidation_candidate: boolean;
+  recommendation: string;
+  rationale: string[];
+  refactor_proposal?: SkillFamilyRefactorProposal;
+  generated_at: string;
+}
+
 // ---------------------------------------------------------------------------
 // Workflow Support types
 // ---------------------------------------------------------------------------

package/cli/selftune/utils/skill-detection.ts

@@ -0,0 +1,43 @@
+export function normalizeSkillName(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+export function getInternalPromptTargetSkill(
+  text: string,
+  knownSkillNames: Iterable<string>,
+): string | null {
+  if (!text) return null;
+  const isInternalSkillPrompt =
+    text.includes("You are a skill description optimizer") ||
+    text.includes("You are an evaluation assistant") ||
+    text.includes("Given this skill description");
+  if (!isInternalSkillPrompt) return null;
+
+  const candidates = [
+    /Skill Name:\s*([^\n]+)/i,
+    /Propose an improved description for the "([^"]+)" skill/i,
+    /would each query trigger the "([^"]+)" skill/i,
+  ];
+  for (const pattern of candidates) {
+    const match = text.match(pattern);
+    const rawSkillName = match?.[1]?.trim();
+    if (!rawSkillName) continue;
+    const normalizedTarget = normalizeSkillName(rawSkillName);
+    for (const skillName of knownSkillNames) {
+      if (normalizeSkillName(skillName) === normalizedTarget) {
+        return skillName;
+      }
+    }
+    return rawSkillName;
+  }
+  return null;
+}
+
+export function isWrappedNonUserPart(text: string): boolean {
+  const trimmed = text.trimStart();
+  return (
+    trimmed.startsWith("# AGENTS.md instructions for ") ||
+    trimmed.startsWith("<environment_context>") ||
+    trimmed.startsWith("<INSTRUCTIONS>")
+  );
+}