selftune 0.2.23 → 0.2.25

package/cli/selftune/contribution-preferences.ts

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { CONTRIBUTION_PREFERENCES_PATH, SELFTUNE_CONFIG_DIR } from "./constants.js";
+import type { ContributionSignal } from "./contribution-signals.js";
+
+export type ContributionGlobalDefault = "ask" | "always" | "never";
+export type ContributionSkillStatus = "opted_in" | "opted_out";
+
+export interface ContributionSkillPreference {
+  status: ContributionSkillStatus;
+  opted_in_at?: string;
+  opted_out_at?: string;
+  creator_id?: string;
+  signals?: ContributionSignal[];
+}
+
+export interface ContributionPreferences {
+  version: 1;
+  global_default: ContributionGlobalDefault;
+  skills: Record<string, ContributionSkillPreference>;
+}
+
+const DEFAULT_PREFERENCES: ContributionPreferences = {
+  version: 1,
+  global_default: "ask",
+  skills: {},
+};
+
+let cachedPreferences: ContributionPreferences | undefined;
+
+function getSelftuneConfigDir(): string {
+  return process.env.SELFTUNE_CONFIG_DIR || SELFTUNE_CONFIG_DIR;
+}
+
+function getContributionPreferencesPath(): string {
+  return process.env.SELFTUNE_CONFIG_DIR
+    ? join(process.env.SELFTUNE_CONFIG_DIR, "contribution-preferences.json")
+    : CONTRIBUTION_PREFERENCES_PATH;
+}
+
+export function cloneDefaultContributionPreferences(): ContributionPreferences {
+  return {
+    version: 1,
+    global_default: "ask",
+    skills: {},
+  };
+}
+
+export function isValidGlobalDefault(value: unknown): value is ContributionGlobalDefault {
+  return value === "ask" || value === "always" || value === "never";
+}
+
+function normalizePreferences(raw: unknown): ContributionPreferences {
+  if (!raw || typeof raw !== "object") return cloneDefaultContributionPreferences();
+  const candidate = raw as Partial<ContributionPreferences>;
+  const globalDefault = isValidGlobalDefault(candidate.global_default)
+    ? candidate.global_default
+    : DEFAULT_PREFERENCES.global_default;
+  const skills: Record<string, ContributionSkillPreference> = {};
+
+  if (candidate.skills && typeof candidate.skills === "object") {
+    for (const [skill, pref] of Object.entries(candidate.skills)) {
+      if (!pref || typeof pref !== "object") continue;
+      const status = (pref as Partial<ContributionSkillPreference>).status;
+      if (status !== "opted_in" && status !== "opted_out") continue;
+      skills[skill] = {
+        status,
+        opted_in_at: (pref as Partial<ContributionSkillPreference>).opted_in_at,
+        opted_out_at: (pref as Partial<ContributionSkillPreference>).opted_out_at,
+        creator_id:
+          typeof (pref as Partial<ContributionSkillPreference>).creator_id === "string"
+            ? (pref as Partial<ContributionSkillPreference>).creator_id
+            : undefined,
+        signals: Array.isArray((pref as Partial<ContributionSkillPreference>).signals)
+          ? (pref as Partial<ContributionSkillPreference>).signals?.filter(
+              (signal): signal is ContributionSignal =>
+                signal === "trigger" || signal === "grade" || signal === "miss_category",
+            )
+          : undefined,
+      };
+    }
+  }
+
+  return {
+    version: 1,
+    global_default: globalDefault,
+    skills,
+  };
+}
+
+export function loadContributionPreferences(): ContributionPreferences {
+  if (cachedPreferences) return cachedPreferences;
+  const preferencesPath = getContributionPreferencesPath();
+  try {
+    if (!existsSync(preferencesPath)) {
+      cachedPreferences = cloneDefaultContributionPreferences();
+      return cachedPreferences;
+    }
+    const parsed = JSON.parse(readFileSync(preferencesPath, "utf-8")) as unknown;
+    cachedPreferences = normalizePreferences(parsed);
+    return cachedPreferences;
+  } catch {
+    cachedPreferences = cloneDefaultContributionPreferences();
+    return cachedPreferences;
+  }
+}
+
+export function saveContributionPreferences(preferences: ContributionPreferences): void {
+  mkdirSync(getSelftuneConfigDir(), { recursive: true });
+  writeFileSync(getContributionPreferencesPath(), JSON.stringify(preferences, null, 2), "utf-8");
+  cachedPreferences = preferences;
+}
+
+export function resetContributionPreferencesState(): void {
+  cachedPreferences = undefined;
+}

package/cli/selftune/contribution-signals.ts

@@ -12,6 +12,7 @@ export type ContributionSignal = "trigger" | "grade" | "miss_category";
 export interface CreatorContributionRelayPayload {
   version: 1;
   signal_type: "skill_session";
+  skill_name?: string;
   relay_destination: string;
   skill_hash: string;
   user_cohort: string;
@@ -114,11 +115,12 @@ export function buildCreatorDirectedContributionSignals(
   options: ContributionSignalBuildOptions = {},
 ): CreatorContributionSignalRecord[] {
   const bySkill = new Map(configs.map((config) => [config.skill_name, config]));
-  const gradingBySession = new Map<string, "A" | "B" | "C" | "F">();
+  const gradingBySkillSession = new Map<string, "A" | "B" | "C" | "F">();
   for (const row of queryGradingResults(db)) {
     const source = typeof row.mean_score === "number" ? row.mean_score : row.pass_rate;
-    if (typeof source === "number" && !gradingBySession.has(row.session_id)) {
-      gradingBySession.set(row.session_id, gradeBucket(source));
+    const key = `${row.skill_name}::${row.session_id}`;
+    if (typeof source === "number" && !gradingBySkillSession.has(key)) {
+      gradingBySkillSession.set(key, gradeBucket(source));
     }
   }
 
@@ -136,7 +138,7 @@ export function buildCreatorDirectedContributionSignals(
         signals.miss_detected = row.triggered === 0;
       }
       if (config.contribution.signals.includes("grade")) {
-        const grade = gradingBySession.get(row.session_id);
+        const grade = gradingBySkillSession.get(`${row.skill_name}::${row.session_id}`);
         if (grade) signals.execution_grade = grade;
       }
       if (config.contribution.signals.includes("miss_category")) {
@@ -162,6 +164,7 @@ export function buildCreatorDirectedContributionSignals(
         payload: {
           version: 1 as const,
           signal_type: "skill_session" as const,
+          skill_name: config.skill_name,
           relay_destination: config.creator_id,
           skill_hash: buildContributionSkillHash(config.skill_name),
           user_cohort: cohort,
@@ -206,6 +209,7 @@ export function buildContributionPreview(
     samplePayload: payloads[0]?.payload ?? {
       version: 1,
       signal_type: "skill_session",
+      skill_name: config.skill_name,
       relay_destination: config.creator_id,
       skill_hash: buildContributionSkillHash(config.skill_name),
       user_cohort: buildContributionUserCohort(options.now ?? new Date(), options.cohortSeed),

package/cli/selftune/contribution-staging.ts

@@ -1,9 +1,16 @@
 import type { Database } from "bun:sqlite";
 
 import type { CreatorContributionConfig } from "./contribution-config.js";
-import { discoverCreatorContributionConfigs } from "./contribution-config.js";
+import {
+  discoverCreatorContributionConfigs,
+  isSupportedContributionSignal,
+  isValidCreatorUUID,
+} from "./contribution-config.js";
+import {
+  loadContributionPreferences,
+  type ContributionPreferences,
+} from "./contribution-preferences.js";
 import { buildCreatorDirectedContributionSignals } from "./contribution-signals.js";
-import { loadContributionPreferences, type ContributionPreferences } from "./contributions.js";
 
 export interface CreatorContributionStagingResult {
   eligible_skills: number;
@@ -34,6 +41,10 @@ export function resolveEligibleContributionConfigs(
   configs: CreatorContributionConfig[] = discoverCreatorContributionConfigs(),
 ): CreatorContributionConfig[] {
   return configs.filter((config) => {
+    if (!isValidCreatorUUID(config.creator_id)) return false;
+    if (!config.contribution.signals.some((signal) => isSupportedContributionSignal(signal))) {
+      return false;
+    }
     const pref = preferences.skills[config.skill_name];
     if (pref?.status === "opted_out") return false;
     if (pref?.status === "opted_in") return true;

package/cli/selftune/contributions.ts

@@ -1,12 +1,20 @@
 #!/usr/bin/env bun
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 
-import { CONTRIBUTION_PREFERENCES_PATH, SELFTUNE_CONFIG_DIR } from "./constants.js";
 import {
   discoverCreatorContributionConfigs,
   findCreatorContributionConfig,
+  isSupportedContributionSignal,
+  isValidCreatorUUID,
 } from "./contribution-config.js";
+import {
+  cloneDefaultContributionPreferences,
+  isValidGlobalDefault,
+  loadContributionPreferences,
+  resetContributionPreferencesState,
+  saveContributionPreferences,
+  type ContributionPreferences,
+  type ContributionSkillStatus,
+} from "./contribution-preferences.js";
 import {
   flushCreatorContributionSignals,
   resolveContributionRelayEndpoint,
@@ -17,6 +25,7 @@ import {
   type ContributionSignalBuildOptions,
   type CreatorContributionRelayPayload,
 } from "./contribution-signals.js";
+import type { CreatorContributionConfig } from "./contribution-config.js";
 import { getDb } from "./localdb/db.js";
 import {
   getCreatorContributionRelayStats,
@@ -25,22 +34,16 @@ import {
 } from "./localdb/queries.js";
 import { CLIError } from "./utils/cli-error.js";
 
-export type ContributionGlobalDefault = "ask" | "always" | "never";
-export type ContributionSkillStatus = "opted_in" | "opted_out";
-
-export interface ContributionSkillPreference {
-  status: ContributionSkillStatus;
-  opted_in_at?: string;
-  opted_out_at?: string;
-  creator_id?: string;
-  signals?: ContributionSignal[];
-}
-
-export interface ContributionPreferences {
-  version: 1;
-  global_default: ContributionGlobalDefault;
-  skills: Record<string, ContributionSkillPreference>;
-}
+export {
+  cloneDefaultContributionPreferences,
+  loadContributionPreferences,
+  resetContributionPreferencesState,
+  saveContributionPreferences,
+  type ContributionGlobalDefault,
+  type ContributionPreferences,
+  type ContributionSkillPreference,
+  type ContributionSkillStatus,
+} from "./contribution-preferences.js";
 
 export interface ContributionPromptCandidate {
   skill_name: string;
@@ -48,101 +51,6 @@ export interface ContributionPromptCandidate {
   successful_triggers: number;
 }
 
-const DEFAULT_PREFERENCES: ContributionPreferences = {
-  version: 1,
-  global_default: "ask",
-  skills: {},
-};
-
-let cachedPreferences: ContributionPreferences | undefined;
-
-function getSelftuneConfigDir(): string {
-  return process.env.SELFTUNE_CONFIG_DIR || SELFTUNE_CONFIG_DIR;
-}
-
-function getContributionPreferencesPath(): string {
-  return process.env.SELFTUNE_CONFIG_DIR
-    ? join(process.env.SELFTUNE_CONFIG_DIR, "contribution-preferences.json")
-    : CONTRIBUTION_PREFERENCES_PATH;
-}
-
-function cloneDefaultPreferences(): ContributionPreferences {
-  return {
-    version: 1,
-    global_default: "ask",
-    skills: {},
-  };
-}
-
-function isValidGlobalDefault(value: unknown): value is ContributionGlobalDefault {
-  return value === "ask" || value === "always" || value === "never";
-}
-
-function normalizePreferences(raw: unknown): ContributionPreferences {
-  if (!raw || typeof raw !== "object") return cloneDefaultPreferences();
-  const candidate = raw as Partial<ContributionPreferences>;
-  const globalDefault = isValidGlobalDefault(candidate.global_default)
-    ? candidate.global_default
-    : DEFAULT_PREFERENCES.global_default;
-  const skills: Record<string, ContributionSkillPreference> = {};
-
-  if (candidate.skills && typeof candidate.skills === "object") {
-    for (const [skill, pref] of Object.entries(candidate.skills)) {
-      if (!pref || typeof pref !== "object") continue;
-      const status = (pref as Partial<ContributionSkillPreference>).status;
-      if (status !== "opted_in" && status !== "opted_out") continue;
-      skills[skill] = {
-        status,
-        opted_in_at: (pref as Partial<ContributionSkillPreference>).opted_in_at,
-        opted_out_at: (pref as Partial<ContributionSkillPreference>).opted_out_at,
-        creator_id:
-          typeof (pref as Partial<ContributionSkillPreference>).creator_id === "string"
-            ? (pref as Partial<ContributionSkillPreference>).creator_id
-            : undefined,
-        signals: Array.isArray((pref as Partial<ContributionSkillPreference>).signals)
-          ? (pref as Partial<ContributionSkillPreference>).signals?.filter(
-              (signal): signal is ContributionSignal =>
-                signal === "trigger" || signal === "grade" || signal === "miss_category",
-            )
-          : undefined,
-      };
-    }
-  }
-
-  return {
-    version: 1,
-    global_default: globalDefault,
-    skills,
-  };
-}
-
-export function loadContributionPreferences(): ContributionPreferences {
-  if (cachedPreferences) return cachedPreferences;
-  const preferencesPath = getContributionPreferencesPath();
-  try {
-    if (!existsSync(preferencesPath)) {
-      cachedPreferences = cloneDefaultPreferences();
-      return cachedPreferences;
-    }
-    const parsed = JSON.parse(readFileSync(preferencesPath, "utf-8")) as unknown;
-    cachedPreferences = normalizePreferences(parsed);
-    return cachedPreferences;
-  } catch {
-    cachedPreferences = cloneDefaultPreferences();
-    return cachedPreferences;
-  }
-}
-
-export function saveContributionPreferences(preferences: ContributionPreferences): void {
-  mkdirSync(getSelftuneConfigDir(), { recursive: true });
-  writeFileSync(getContributionPreferencesPath(), JSON.stringify(preferences, null, 2), "utf-8");
-  cachedPreferences = preferences;
-}
-
-export function resetContributionPreferencesState(): void {
-  cachedPreferences = undefined;
-}
-
 function printStatus(preferences: ContributionPreferences): void {
   const discovered = discoverCreatorContributionConfigs();
   const promptCandidates = listContributionPromptCandidates(preferences);
@@ -223,6 +131,11 @@ export function listContributionPromptCandidates(
 
   const bySkill = new Map(getSkillTrustSummaries(getDb()).map((row) => [row.skill_name, row]));
   return discoverCreatorContributionConfigs()
+    .filter(
+      (config) =>
+        isValidCreatorUUID(config.creator_id) &&
+        config.contribution.signals.some((signal) => isSupportedContributionSignal(signal)),
+    )
     .filter((config) => !preferences.skills[config.skill_name])
     .map((config) => {
       const summary = bySkill.get(config.skill_name);
@@ -247,19 +160,40 @@ function upsertSkillPreference(skill: string, status: ContributionSkillStatus):
   const preferences = loadContributionPreferences();
   const timestamp = new Date().toISOString();
   const discovered = findCreatorContributionConfig(normalizedSkill);
+  if (!discovered) {
+    throw new CLIError(
+      `No creator contribution request found for "${normalizedSkill}".`,
+      "FILE_NOT_FOUND",
+      "Run `selftune contributions` to see installed skill requests.",
+    );
+  }
+  if (!isValidCreatorUUID(discovered.creator_id)) {
+    throw new CLIError(
+      `Creator contribution request for "${normalizedSkill}" has an invalid creator_id.`,
+      "INVALID_FLAG",
+      "Ask the skill creator to ship a valid selftune.contribute.json or choose another skill.",
+    );
+  }
+  const validSignals = discovered.contribution.signals.filter(
+    (signal): signal is ContributionSignal => isSupportedContributionSignal(signal),
+  );
+  if (validSignals.length === 0) {
+    throw new CLIError(
+      `Creator contribution request for "${normalizedSkill}" does not declare any supported signals.`,
+      "INVALID_FLAG",
+      "Ask the skill creator to ship a valid selftune.contribute.json or choose another skill.",
+    );
+  }
   preferences.skills[normalizedSkill] =
     status === "opted_in"
       ? { status, opted_in_at: timestamp }
       : { status, opted_out_at: timestamp };
-  if (status === "opted_in" && discovered) {
+  if (status === "opted_in") {
     preferences.skills[normalizedSkill] = {
       status,
       opted_in_at: timestamp,
       creator_id: discovered.creator_id,
-      signals: discovered.contribution.signals.filter(
-        (signal): signal is ContributionSignal =>
-          signal === "trigger" || signal === "grade" || signal === "miss_category",
-      ),
+      signals: validSignals,
     };
   }
   saveContributionPreferences(preferences);
@@ -273,7 +207,7 @@ function buildPreviewPayload(
   skill: string,
   options: ContributionSignalBuildOptions = {},
 ): {
-  config: ReturnType<typeof findCreatorContributionConfig>;
+  config: CreatorContributionConfig;
   observedCount: number;
   triggerRate: number | null;
   missRate: number | null;
@@ -345,7 +279,7 @@ function setGlobalDefault(value: string | undefined): void {
 }
 
 function resetPreferences(): void {
-  saveContributionPreferences(cloneDefaultPreferences());
+  saveContributionPreferences(cloneDefaultContributionPreferences());
   console.log("Creator-directed contribution preferences reset to defaults.");
 }
 

package/cli/selftune/creator-contributions.ts

@@ -9,6 +9,8 @@ import {
   discoverCreatorContributionConfigs,
   findCreatorContributionConfig,
   getContributionConfigSearchRoots,
+  isValidCreatorUUID,
+  normalizeSupportedContributionSignals,
   removeCreatorContributionConfig,
   resolveContributionSkillPath,
   writeCreatorContributionConfig,
@@ -96,9 +98,16 @@ function enableCreatorContributionConfigs(options: {
   const creatorId = inferCreatorId(options.explicitCreatorId);
   if (!creatorId) {
     throw new CLIError(
-      "Creator ID is required.",
+      "Creator ID is required. Must be the creator's cloud user UUID.",
       "MISSING_FLAG",
-      "Pass --creator-id <id> or enroll alpha so cloud_user_id is available.",
+      "Pass --creator-id <uuid> or enroll alpha so cloud_user_id is available.",
+    );
+  }
+  if (!isValidCreatorUUID(creatorId)) {
+    throw new CLIError(
+      `Creator ID must be a cloud user UUID. Received "${creatorId}".`,
+      "INVALID_FLAG",
+      "Pass --creator-id <uuid> or enroll alpha so cloud_user_id is available.",
     );
   }
 
@@ -158,7 +167,7 @@ export async function cliMain(): Promise<void> {
   const rest = process.argv.slice(3);
 
   if (sub === "--help" || sub === "-h") {
-    console.log(`selftune creator-contributions — Manage creator-side contribution configs
+    console.log(`selftune creator-contributions — Manage creator sharing setup configs
 
 Usage:
   selftune creator-contributions
@@ -168,9 +177,11 @@ Usage:
   selftune creator-contributions disable --skill <name> [--skill-path <path>]
 
 Purpose:
-  Manage the local selftune.contribute.json file that a skill creator bundles
-  with a skill package. This is separate from:
-    selftune contributions  End-user sharing preferences
+  Manage the local selftune.contribute.json creator sharing setup file that
+  a skill creator bundles with a skill package. The --creator-id must be the
+  creator's cloud user UUID (the cloud_user_id from alpha enrollment).
+  This is separate from:
+    selftune contributions  Sharing preferences (end-user opt-in/out)
     selftune contribute     Community export bundle`);
     return;
   }
@@ -225,10 +236,18 @@ Purpose:
         );
       }
 
-      const signals = (values.signals ?? "trigger,grade,miss_category")
-        .split(",")
-        .map((signal) => signal.trim())
-        .filter(Boolean);
+      let signals: string[];
+      try {
+        signals = normalizeSupportedContributionSignals(
+          (values.signals ?? "trigger,grade,miss_category").split(","),
+        );
+      } catch (error) {
+        throw new CLIError(
+          error instanceof Error ? error.message : String(error),
+          "INVALID_FLAG",
+          "selftune creator-contributions enable --help",
+        );
+      }
       const outcome = enableCreatorContributionConfigs({
         skillName: values.skill?.trim(),
         all: values.all,

package/cli/selftune/cron/setup.ts

@@ -231,17 +231,21 @@ export async function cliMain(): Promise<void> {
   });
 
   // Get timezone: flag > env > system default
-  const tz = values.tz ?? process.env.TZ ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const tz =
+    (typeof values.tz === "string" ? values.tz : undefined) ??
+    process.env.TZ ??
+    Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const dryRun = values["dry-run"] === true;
 
   switch (subcommand) {
     case "setup":
-      await setupCronJobs(tz, values["dry-run"] ?? false);
+      await setupCronJobs(tz, dryRun);
       break;
     case "list":
       listCronJobs();
       break;
     case "remove":
-      await removeCronJobs(values["dry-run"] ?? false);
+      await removeCronJobs(dryRun);
       break;
     default:
       console.log(`selftune cron — OpenClaw cron integration

package/cli/selftune/dashboard-contract.ts

@@ -91,6 +91,16 @@ export interface EvalSnapshot {
   improved?: boolean;
   regressions?: Array<Record<string, unknown>>;
   new_passes?: Array<Record<string, unknown>>;
+  per_entry_results?: Array<Record<string, unknown>>;
+  before_entry_results?: Array<Record<string, unknown>>;
+  gates_passed?: number;
+  gates_total?: number;
+  gate_results?: Array<Record<string, unknown>>;
+  validation_mode?: string;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  validation_fallback_reason?: string;
+  validation_evidence_ref?: string;
 }
 
 export interface EvolutionEntry {
@@ -140,6 +150,7 @@ export interface SkillSummary {
   has_evidence: boolean;
   routing_confidence: number | null;
   confidence_coverage: number;
+  testing_readiness?: SkillTestingReadiness;
 }
 
 // -- Autonomy-first overview types -------------------------------------------
@@ -226,6 +237,7 @@ export interface OverviewResponse {
   attention_queue: AttentionItem[];
   trust_watchlist: TrustWatchlistEntry[];
   recent_decisions: AutonomousDecision[];
+  creator_testing?: CreatorTestingOverview;
 }
 
 export interface EvidenceEntry {
@@ -303,6 +315,62 @@ export interface SkillReportPayload {
   sessions_with_skill: number;
 }
 
+export type SkillEvalReadiness = "log_ready" | "cold_start_ready" | "telemetry_only";
+
+export type CreatorLoopNextStep =
+  | "generate_evals"
+  | "run_unit_tests"
+  | "run_replay_dry_run"
+  | "measure_baseline"
+  | "deploy_candidate"
+  | "watch_deployment";
+
+export type DeploymentReadiness = "blocked" | "ready_to_deploy" | "watching" | "rolled_back";
+
+export interface SkillTestingReadiness {
+  skill_name: string;
+  eval_readiness: SkillEvalReadiness;
+  next_step: CreatorLoopNextStep;
+  summary: string;
+  recommended_command: string;
+  skill_path: string | null;
+  trusted_trigger_count: number;
+  trusted_session_count: number;
+  eval_set_entries: number;
+  latest_eval_at: string | null;
+  unit_test_cases: number;
+  unit_test_pass_rate: number | null;
+  unit_test_ran_at: string | null;
+  replay_check_count: number;
+  latest_validation_mode: "structural_guard" | "host_replay" | "llm_judge" | null;
+  baseline_sample_size: number;
+  baseline_pass_rate: number | null;
+  latest_baseline_at: string | null;
+  deployment_readiness: DeploymentReadiness;
+  deployment_summary: string;
+  deployment_command: string | null;
+  latest_evolution_action: string | null;
+  latest_evolution_at: string | null;
+}
+
+export interface CreatorTestingOverview {
+  summary: string;
+  counts: {
+    generate_evals: number;
+    run_unit_tests: number;
+    run_replay_dry_run: number;
+    measure_baseline: number;
+    deploy_candidate: number;
+    watch_deployment: number;
+  };
+  priorities: Array<{
+    skill_name: string;
+    next_step: CreatorLoopNextStep;
+    summary: string;
+    recommended_command: string;
+  }>;
+}
+
 // -- Orchestrate run report types --------------------------------------------
 
 export interface OrchestrateRunSkillAction {
@@ -384,7 +452,11 @@ export interface HealthResponse {
   ok: boolean;
   service: string;
   version: string;
+  pid: number;
   spa: boolean;
+  spa_mode?: "dist" | "proxy" | "missing";
+  spa_build_id?: string | null;
+  spa_proxy_url?: string | null;
   v2_data_available: boolean;
   workspace_root: string;
   git_sha: string;
@@ -574,4 +646,5 @@ export interface SkillReportResponse extends SkillReportPayload, TrustFields {
       not_just_name: number;
     };
   } | null;
+  testing_readiness?: SkillTestingReadiness;
 }