selftune 0.2.31 → 0.2.32

package/cli/selftune/improve.ts

@@ -0,0 +1,206 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+import { selectAcceptedPackageFrontierCandidate } from "./create/package-candidate-state.js";
+import { readCanonicalPackageEvaluationArtifact } from "./testing-readiness.js";
+import { PUBLIC_COMMAND_SURFACES, renderCommandHelp } from "./command-surface.js";
+import { CLIError, handleCLIError } from "./utils/cli-error.js";
+
+type ImproveScope = "auto" | "description" | "routing" | "body" | "package";
+
+export interface ImproveDeps {
+  evolveCliMain?: () => Promise<void>;
+  evolveBodyCliMain?: () => Promise<void>;
+  searchRunCliMain?: () => Promise<void>;
+}
+
+function readOptionValue(args: readonly string[], flag: string): string | undefined {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === flag) {
+      const next = args[index + 1];
+      return next && !next.startsWith("-") ? next : undefined;
+    }
+    if (arg.startsWith(`${flag}=`)) {
+      return arg.slice(flag.length + 1);
+    }
+  }
+  return undefined;
+}
+
+function stripOption(args: readonly string[], flag: string): string[] {
+  const result: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === flag) {
+      const next = args[index + 1];
+      if (next && !next.startsWith("-")) {
+        index += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) {
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+
+function hasOption(args: readonly string[], flag: string): boolean {
+  return args.includes(flag) || args.some((arg) => arg.startsWith(`${flag}=`));
+}
+
+function replaceOption(args: readonly string[], sourceFlag: string, targetFlag: string): string[] {
+  const value = readOptionValue(args, sourceFlag);
+  if (value == null) {
+    return stripOption(args, sourceFlag);
+  }
+  const result = stripOption(args, sourceFlag);
+  result.push(targetFlag, value);
+  return result;
+}
+
+function resolveScope(rawScope: string | undefined): ImproveScope {
+  const scope = (rawScope ?? "auto") as ImproveScope;
+  if (!["auto", "description", "routing", "body", "package"].includes(scope)) {
+    throw new CLIError(
+      `Invalid --scope value: ${rawScope}`,
+      "INVALID_FLAG",
+      "Use one of: auto, description, routing, body, package",
+    );
+  }
+  return scope;
+}
+
+function inferSkillNameFromArgs(args: readonly string[]): string | null {
+  const explicitSkill = readOptionValue(args, "--skill");
+  if (explicitSkill) return explicitSkill;
+
+  const skillPath = readOptionValue(args, "--skill-path");
+  if (!skillPath) return null;
+  return basename(dirname(skillPath));
+}
+
+function shouldAutoSelectPackageScope(args: readonly string[]): boolean {
+  const skillPath = readOptionValue(args, "--skill-path");
+  if (!skillPath) return false;
+
+  if (existsSync(join(dirname(skillPath), "selftune.create.json"))) {
+    return true;
+  }
+
+  const skillName = inferSkillNameFromArgs(args);
+  if (!skillName) return false;
+
+  return (
+    selectAcceptedPackageFrontierCandidate(skillName) != null ||
+    readCanonicalPackageEvaluationArtifact(skillName) != null
+  );
+}
+
+export async function runImprove(
+  rawArgs: readonly string[],
+  deps: ImproveDeps = {},
+): Promise<void> {
+  const { evolveCliMain, evolveBodyCliMain, searchRunCliMain } = deps;
+
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    console.log(renderCommandHelp(PUBLIC_COMMAND_SURFACES.improve));
+    process.exit(0);
+  }
+
+  const requestedScope = readOptionValue(rawArgs, "--scope");
+  if (rawArgs.includes("--scope") && requestedScope == null) {
+    throw new CLIError(
+      "--scope requires a value.",
+      "MISSING_FLAG",
+      "Use one of: auto, description, routing, body, package",
+    );
+  }
+
+  const scope = resolveScope(requestedScope);
+  const effectiveScope =
+    scope === "auto" && shouldAutoSelectPackageScope(rawArgs) ? "package" : scope;
+  let delegatedArgs = stripOption(rawArgs, "--scope");
+
+  if (hasOption(delegatedArgs, "--target")) {
+    throw new CLIError(
+      "Use --scope on selftune improve instead of passing --target directly.",
+      "INVALID_FLAG",
+      "selftune improve --skill <name> --skill-path <path> --scope routing|body",
+    );
+  }
+
+  if (effectiveScope === "package") {
+    const dryRunRequested = hasOption(delegatedArgs, "--dry-run");
+    const validationMode = readOptionValue(delegatedArgs, "--validation-mode");
+    if (hasOption(delegatedArgs, "--validation-mode")) {
+      if (validationMode == null) {
+        throw new CLIError(
+          "--validation-mode requires a value.",
+          "MISSING_FLAG",
+          "Use one of: auto, replay",
+        );
+      }
+      if (!["auto", "replay"].includes(validationMode)) {
+        throw new CLIError(
+          "Package search uses replay-backed package evaluation and does not support judge-only validation.",
+          "INVALID_FLAG",
+          "Use selftune improve --scope package without --validation-mode, or set --validation-mode replay",
+        );
+      }
+      delegatedArgs = stripOption(delegatedArgs, "--validation-mode");
+    }
+
+    delegatedArgs = stripOption(delegatedArgs, "--dry-run");
+
+    if (hasOption(delegatedArgs, "--candidates") && !hasOption(delegatedArgs, "--max-candidates")) {
+      delegatedArgs = replaceOption(delegatedArgs, "--candidates", "--max-candidates");
+    }
+    if (!dryRunRequested && !hasOption(delegatedArgs, "--apply-winner")) {
+      delegatedArgs.push("--apply-winner");
+    }
+
+    process.argv = [process.argv[0], process.argv[1], ...delegatedArgs];
+    const { cliMain: delegatedCliMain } = searchRunCliMain
+      ? { cliMain: searchRunCliMain }
+      : await import("./search-run.js");
+    await delegatedCliMain();
+    return;
+  }
+
+  if (effectiveScope === "routing" || effectiveScope === "body") {
+    const delegatedAgent = readOptionValue(delegatedArgs, "--agent");
+    if (
+      delegatedAgent &&
+      !hasOption(delegatedArgs, "--teacher-agent") &&
+      !hasOption(delegatedArgs, "--student-agent")
+    ) {
+      delegatedArgs = stripOption(delegatedArgs, "--agent");
+      delegatedArgs.push("--teacher-agent", delegatedAgent, "--student-agent", delegatedAgent);
+    }
+
+    delegatedArgs.push("--target", effectiveScope);
+    process.argv = [process.argv[0], process.argv[1], ...delegatedArgs];
+    const { cliMain: delegatedCliMain } = evolveBodyCliMain
+      ? { cliMain: evolveBodyCliMain }
+      : await import("./evolution/evolve-body.js");
+    await delegatedCliMain();
+    return;
+  }
+
+  process.argv = [process.argv[0], process.argv[1], ...delegatedArgs];
+  const { cliMain: delegatedCliMain } = evolveCliMain
+    ? { cliMain: evolveCliMain }
+    : await import("./evolution/evolve.js");
+  await delegatedCliMain();
+}
+
+export async function cliMain(): Promise<void> {
+  await runImprove(process.argv.slice(2));
+}
+
+if (import.meta.main) {
+  cliMain().catch(handleCLIError);
+}

package/cli/selftune/index.ts

@@ -6,9 +6,15 @@
  *   selftune ingest <agent>     — Ingest agent sessions (claude, codex, opencode, openclaw, pi, wrap-codex)
  *   selftune grade [mode]       — Grade skill sessions (auto, baseline)
  *   selftune evolve [target]    — Evolve skill descriptions (body, rollback)
+ *   selftune improve            — Simplified alias for evolve / evolve body / search-run
+ *   selftune search-run         — Run bounded package search over routing/body variants
  *   selftune eval <action>      — Evaluation tools (generate, unit-test, import, composability, family-overlap)
+ *   selftune create <sub>       — Draft full skill packages
+ *   selftune verify             — Verify a draft skill package
+ *   selftune publish            — Publish a verified draft package
  *   selftune sync               — Sync source-truth telemetry across supported agents
  *   selftune orchestrate        — Run autonomous core loop (sync → status → evolve → watch)
+ *   selftune run                — Simplified alias for orchestrate
  *   selftune init               — Initialize agent identity and config
  *   selftune uninstall          — Clean removal of all selftune data and config
  *   selftune status             — Show skill health summary
@@ -52,19 +58,27 @@ if (command === "--help" || command === "-h") {
 Usage:
   selftune <command> [options]
 
-Commands:
-  ingest <agent>     Ingest agent sessions (claude, codex, opencode, openclaw, pi, wrap-codex)
-  grade [mode]       Grade skill sessions (auto, baseline)
+Primary Lifecycle:
+  status             Show skill health summary
+  verify             Verify a draft skill package
+  publish            Publish a verified draft package
+  improve            Improve skills with measured evidence
+  run                Run autonomous improvement loop
+  create <sub>       Draft full skill packages
+  dashboard          Open visual data dashboard
+
+Advanced / Stage Commands:
   evolve [target]    Evolve skill descriptions (body, rollback)
+  search-run         Run bounded package search over routing/body variants
   eval <action>      Evaluation tools (generate, unit-test, import, composability, family-overlap)
+  grade [mode]       Grade skill sessions (auto, baseline)
+  watch              Monitor post-deploy skill health
   sync               Sync source-truth telemetry across supported agents
   orchestrate        Run autonomous core loop (sync → status → evolve → watch)
+  ingest <agent>     Ingest agent sessions (claude, codex, opencode, openclaw, pi, wrap-codex)
   init               Initialize agent identity and config
   uninstall          Clean removal of all selftune data and config
-  status             Show skill health summary
-  watch              Monitor post-deploy skill health
   doctor             Run health checks
-  dashboard          Open visual data dashboard
   last               Show last session details
   cron               Scheduling & automation (setup, list, remove)
   badge              Generate skill health badges for READMEs
@@ -276,6 +290,18 @@ Run 'selftune evolve <subcommand> --help' for subcommand-specific options.`);
     break;
   }
 
+  case "improve": {
+    const { cliMain } = await import("./improve.js");
+    await cliMain();
+    break;
+  }
+
+  case "search-run": {
+    const { cliMain } = await import("./search-run.js");
+    await cliMain();
+    break;
+  }
+
   case "eval": {
     const sub = process.argv[2];
     if (!sub || sub === "--help" || sub === "-h") {
@@ -417,6 +443,91 @@ Run 'selftune eval <action> --help' for action-specific options.`);
     break;
   }
 
+  case "verify": {
+    const { cliMain } = await import("./verify.js");
+    await cliMain();
+    break;
+  }
+
+  case "publish": {
+    const { cliMain } = await import("./publish.js");
+    await cliMain();
+    break;
+  }
+
+  case "create": {
+    const sub = process.argv[2];
+    if (!sub || sub === "--help" || sub === "-h") {
+      console.log(`selftune create — Draft full skill packages
+
+Usage:
+  selftune create <subcommand> [options]
+
+Subcommands:
+  init          Initialize a new skill package scaffold
+  status        Show current draft-package readiness
+  scaffold      Scaffold a package from an observed workflow
+  check         Validate package readiness and recommend the next step
+  replay        Run replay validation for the current draft package
+  baseline      Measure with-skill vs no-skill lift for the draft package
+  report        Render a benchmark-style report for the current draft package
+  publish       Publish a validated draft package and optionally start watch
+
+Run 'selftune create <subcommand> --help' for subcommand-specific options.`);
+      process.exit(0);
+    }
+    process.argv = [process.argv[0], process.argv[1], ...process.argv.slice(3)];
+    switch (sub) {
+      case "init": {
+        const { cliMain } = await import("./create/init.js");
+        await cliMain();
+        break;
+      }
+      case "status": {
+        const { cliMain } = await import("./create/status.js");
+        await cliMain();
+        break;
+      }
+      case "scaffold": {
+        const { cliMain } = await import("./create/scaffold.js");
+        await cliMain();
+        break;
+      }
+      case "check": {
+        const { cliMain } = await import("./create/check.js");
+        await cliMain();
+        break;
+      }
+      case "replay": {
+        const { cliMain } = await import("./create/replay.js");
+        await cliMain();
+        break;
+      }
+      case "baseline": {
+        const { cliMain } = await import("./create/baseline.js");
+        await cliMain();
+        break;
+      }
+      case "report": {
+        const { cliMain } = await import("./create/report.js");
+        await cliMain();
+        break;
+      }
+      case "publish": {
+        const { cliMain } = await import("./create/publish.js");
+        await cliMain();
+        break;
+      }
+      default:
+        throw new CLIError(
+          `Unknown create subcommand: ${sub}`,
+          "UNKNOWN_COMMAND",
+          "selftune create --help",
+        );
+    }
+    break;
+  }
+
   // ── Unchanged commands ────────────────────────────────────────────────
 
   case "init": {
@@ -659,6 +770,12 @@ Options:
     await cliMain();
     break;
   }
+
+  case "run": {
+    const { cliMain } = await import("./run.js");
+    await cliMain();
+    break;
+  }
   case "registry": {
     const { cliMain } = await import("./registry/index.js");
     await cliMain();

package/cli/selftune/init.ts

@@ -959,7 +959,7 @@ export async function cliMain(): Promise<void> {
         level: "info",
         code: "alpha_upload_ready",
         message:
-          "Alpha enrollment complete. Uploads will run automatically during 'selftune orchestrate'. To enable scheduled background sync (includes evolve + watch + upload), run: selftune cron setup",
+          "Alpha enrollment complete. Uploads will run automatically during 'selftune run'. To enable scheduled background sync (includes evolve + watch + upload), run: selftune cron setup",
         next_command: "selftune alpha upload",
         optional_autonomy: "selftune cron setup",
       }),

package/cli/selftune/localdb/queries/dashboard.ts

@@ -14,6 +14,7 @@ import type {
   SkillUsageRecord,
   TelemetryRecord,
 } from "../../dashboard-contract.js";
+import { computeCreateDashboardReadiness, isCreateSkillDraft } from "../../create/readiness.js";
 import { queryEvolutionEvidence, getPendingProposals } from "./evolution.js";
 import { safeParseJsonArray } from "./json.js";
 import { queryTrustedSkillObservationRows } from "./trust.js";
@@ -596,7 +597,29 @@ export function getSkillsList(
   const testingReadinessBySkill = new Map(
     testingReadiness.map((row) => [row.skill_name, row] as const),
   );
+  const createReadinessBySkill = new Map(
+    testingReadiness
+      .flatMap((row) => {
+        if (!row.skill_path || !isCreateSkillDraft(row.skill_path)) return [];
+        try {
+          return [
+            [
+              row.skill_name,
+              computeCreateDashboardReadiness(row.skill_path, {
+                getTestingReadiness: () => row,
+              }),
+            ] as const,
+          ];
+        } catch {
+          return [];
+        }
+      })
+      .filter(Boolean),
+  );
   const knownSkills = new Set<string>(bySkill.keys());
+  for (const skillName of createReadinessBySkill.keys()) {
+    knownSkills.add(skillName);
+  }
 
   return [...knownSkills]
     .map((skillName) => {
@@ -616,13 +639,19 @@ export function getSkillsList(
             withConfidence.length
           : null;
       const readiness = testingReadinessBySkill.get(skillName);
+      const createReadiness = createReadinessBySkill.get(skillName);
       const fallbackScope =
         readiness?.skill_path != null ? classifySkillPath(readiness.skill_path).skill_scope : null;
+      const createScope =
+        createReadiness?.skill_path != null
+          ? classifySkillPath(createReadiness.skill_path).skill_scope
+          : null;
 
       return {
         skill_name: skillName,
         skill_scope:
           scopeBySkill.get(skillName) ??
+          (createScope && createScope !== "unknown" ? createScope : null) ??
           (fallbackScope && fallbackScope !== "unknown" ? fallbackScope : null),
         total_checks: totalChecks,
         triggered_count: triggeredCount,
@@ -633,6 +662,7 @@ export function getSkillsList(
         routing_confidence: routingConfidence,
         confidence_coverage: totalChecks > 0 ? withConfidence.length / totalChecks : 0,
         testing_readiness: readiness,
+        create_readiness: createReadiness,
       };
     })
     .sort(

package/cli/selftune/localdb/schema.ts

@@ -272,6 +272,32 @@ CREATE TABLE IF NOT EXISTS unit_test_run_results (
   result_json  TEXT NOT NULL
 )`;
 
+export const CREATE_PACKAGE_EVALUATION_REPORTS = `
+CREATE TABLE IF NOT EXISTS package_evaluation_reports (
+  skill_name    TEXT PRIMARY KEY,
+  stored_at     TEXT NOT NULL,
+  summary_json  TEXT NOT NULL
+)`;
+
+export const CREATE_PACKAGE_CANDIDATES = `
+CREATE TABLE IF NOT EXISTS package_candidates (
+  candidate_id              TEXT PRIMARY KEY,
+  skill_name                TEXT NOT NULL,
+  skill_path                TEXT NOT NULL,
+  package_fingerprint       TEXT NOT NULL,
+  parent_candidate_id       TEXT,
+  candidate_generation      INTEGER NOT NULL DEFAULT 0,
+  evaluation_count          INTEGER NOT NULL DEFAULT 0,
+  first_evaluated_at        TEXT NOT NULL,
+  last_evaluated_at         TEXT NOT NULL,
+  latest_status             TEXT NOT NULL,
+  latest_evaluation_source  TEXT,
+  latest_acceptance_decision TEXT,
+  artifact_path             TEXT,
+  summary_json              TEXT NOT NULL,
+  UNIQUE(skill_name, package_fingerprint)
+)`;
+
 // -- Improvement signal table (from signal_log.jsonl) ------------------------
 
 export const CREATE_IMPROVEMENT_SIGNALS = `
@@ -365,6 +391,21 @@ CREATE TABLE IF NOT EXISTS cron_runs (
   UNIQUE(job_name, started_at)
 )`;
 
+// -- Package search run table ------------------------------------------------
+
+export const CREATE_PACKAGE_SEARCH_RUNS = `
+CREATE TABLE IF NOT EXISTS package_search_runs (
+  search_id            TEXT PRIMARY KEY,
+  skill_name           TEXT NOT NULL,
+  parent_candidate_id  TEXT,
+  winner_candidate_id  TEXT,
+  winner_rationale     TEXT,
+  candidates_evaluated INTEGER NOT NULL,
+  provenance_json      TEXT NOT NULL,
+  started_at           TEXT NOT NULL,
+  completed_at         TEXT NOT NULL
+)`;
+
 // -- Metadata table -----------------------------------------------------------
 
 export const CREATE_META = `
@@ -419,6 +460,9 @@ export const CREATE_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_canonical_eval_sets_stored_at ON canonical_eval_sets(stored_at)`,
   `CREATE INDEX IF NOT EXISTS idx_unit_test_files_stored_at ON unit_test_files(stored_at)`,
   `CREATE INDEX IF NOT EXISTS idx_unit_test_run_results_run_at ON unit_test_run_results(run_at)`,
+  `CREATE INDEX IF NOT EXISTS idx_package_evaluation_reports_stored_at ON package_evaluation_reports(stored_at)`,
+  `CREATE INDEX IF NOT EXISTS idx_package_candidates_skill_ts ON package_candidates(skill_name, last_evaluated_at)`,
+  `CREATE INDEX IF NOT EXISTS idx_package_candidates_parent ON package_candidates(parent_candidate_id)`,
   // -- Improvement signal indexes ---------------------------------------------
   `CREATE INDEX IF NOT EXISTS idx_signals_session ON improvement_signals(session_id)`,
   `CREATE INDEX IF NOT EXISTS idx_signals_consumed ON improvement_signals(consumed)`,
@@ -447,6 +491,9 @@ export const CREATE_INDEXES = [
   `CREATE UNIQUE INDEX IF NOT EXISTS idx_commit_dedup ON commit_tracking(session_id, commit_sha)`,
   // -- Cron run indexes -------------------------------------------------------
   `CREATE INDEX IF NOT EXISTS idx_cron_runs_job_ts ON cron_runs(job_name, started_at)`,
+  // -- Package search run indexes ---------------------------------------------
+  `CREATE INDEX IF NOT EXISTS idx_pkg_search_skill ON package_search_runs(skill_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_pkg_search_ts ON package_search_runs(started_at)`,
 ];
 
 /**
@@ -512,6 +559,8 @@ export const MIGRATIONS = [
   `ALTER TABLE session_telemetry ADD COLUMN agent_summary TEXT`,
   // -- SHA256 content hashing for upload dedup --
   `ALTER TABLE canonical_upload_staging ADD COLUMN content_sha256 TEXT`,
+  // -- Package candidate measured acceptance state --
+  `ALTER TABLE package_candidates ADD COLUMN latest_acceptance_decision TEXT`,
 ];
 
 /** Indexes that depend on migration columns — must run AFTER MIGRATIONS. */
@@ -540,6 +589,8 @@ export const ALL_DDL = [
   CREATE_CANONICAL_EVAL_SETS,
   CREATE_UNIT_TEST_FILES,
   CREATE_UNIT_TEST_RUN_RESULTS,
+  CREATE_PACKAGE_EVALUATION_REPORTS,
+  CREATE_PACKAGE_CANDIDATES,
   CREATE_IMPROVEMENT_SIGNALS,
   CREATE_UPLOAD_QUEUE,
   CREATE_CREATOR_CONTRIBUTION_STAGING,
@@ -547,6 +598,7 @@ export const ALL_DDL = [
   CREATE_CANONICAL_UPLOAD_STAGING,
   CREATE_COMMIT_TRACKING,
   CREATE_CRON_RUNS,
+  CREATE_PACKAGE_SEARCH_RUNS,
   CREATE_META,
   ...CREATE_INDEXES,
 ];