selftune 0.2.31 → 0.2.32

package/cli/selftune/orchestrate/finalize.ts

@@ -16,6 +16,8 @@ interface OrchestrateFinalTotals {
   watched: number;
   skipped: number;
   autoGraded: number;
+  packageSearched: number;
+  packageImproved: number;
   freshlyWatchedSkills: string[];
 }
 
@@ -27,6 +29,8 @@ export interface FinalizeOrchestrateRunInput {
   dryRun: boolean;
   approvalMode: "auto" | "review";
   autoGradedCount: number;
+  packageSearched: number;
+  packageImproved: number;
   freshlyWatchedSkills: string[];
   pendingSignals: ImprovementSignalRecord[];
   elapsedMs: number;
@@ -36,6 +40,8 @@ function buildFinalTotals(
   skills: SkillStatus[],
   candidates: SkillAction[],
   autoGradedCount: number,
+  packageSearched: number,
+  packageImproved: number,
   freshlyWatchedSkills: string[],
 ): OrchestrateFinalTotals {
   return {
@@ -50,6 +56,8 @@ function buildFinalTotals(
       freshlyWatchedSkills.length,
     skipped: candidates.filter((candidate) => candidate.action === "skip").length,
     autoGraded: autoGradedCount,
+    packageSearched,
+    packageImproved,
     freshlyWatchedSkills,
   };
 }
@@ -63,6 +71,8 @@ export function finalizeOrchestrateRun(input: FinalizeOrchestrateRunInput): Orch
     dryRun,
     approvalMode,
     autoGradedCount,
+    packageSearched,
+    packageImproved,
     freshlyWatchedSkills,
     pendingSignals,
     elapsedMs,
@@ -72,6 +82,8 @@ export function finalizeOrchestrateRun(input: FinalizeOrchestrateRunInput): Orch
     statusResult.skills,
     candidates,
     autoGradedCount,
+    packageSearched,
+    packageImproved,
     freshlyWatchedSkills,
   );
 
@@ -106,6 +118,8 @@ export function finalizeOrchestrateRun(input: FinalizeOrchestrateRunInput): Orch
     watched: finalTotals.watched,
     skipped: finalTotals.skipped,
     auto_graded: finalTotals.autoGraded,
+    package_searched: finalTotals.packageSearched,
+    package_improved: finalTotals.packageImproved,
     skill_actions: candidates.map(
       (candidate): OrchestrateRunSkillAction => ({
         skill: candidate.skill,

package/cli/selftune/orchestrate/plan.ts

@@ -2,6 +2,22 @@ import type { CandidateContext, SkillAction } from "../orchestrate.js";
 import type { SkillStatus } from "../status.js";
 import type { EvolutionAuditEntry } from "../types.js";
 
+/**
+ * Determines whether a skill should use package search instead of standard
+ * evolution. Returns true when the skill has package-level evidence:
+ * a frontier candidate exists or a canonical evaluation record is present.
+ *
+ * This gates the package-search path so only skills with sufficient
+ * package-level signal enter the bounded search flow.
+ */
+export function shouldSelectPackageSearch(skill: SkillStatus, context: CandidateContext): boolean {
+  // Package search requires that the candidate context carries a
+  // packageFrontierSkills set (populated from package-candidate-state).
+  // When present and the skill is listed, we route through package search.
+  if (!context.packageFrontierSkills) return false;
+  return context.packageFrontierSkills.has(skill.name);
+}
+
 /** Candidate selection criteria. */
 const CANDIDATE_STATUSES = new Set(["CRITICAL", "WARNING", "UNGRADED"]);
 
@@ -109,18 +125,19 @@ export function selectCandidates(skills: SkillStatus[], options: CandidateContex
       continue;
     }
 
+    const action = shouldSelectPackageSearch(skill, options) ? "package-search" : "evolve";
     actions.push({
       skill: skill.name,
-      action: "evolve",
+      action,
       reason: `status=${skill.status}, passRate=${skill.passRate !== null ? `${(skill.passRate * 100).toFixed(0)}%` : "—"}, missed=${skill.missedQueries}, trend=${skill.trend}`,
     });
   }
 
-  let evolveCount = 0;
+  let activeCount = 0;
   for (const action of actions) {
-    if (action.action === "evolve") {
-      evolveCount++;
-      if (evolveCount > options.maxSkills) {
+    if (action.action === "evolve" || action.action === "package-search") {
+      activeCount++;
+      if (activeCount > options.maxSkills) {
         action.action = "skip";
         action.reason = `capped by --max-skills ${options.maxSkills}`;
       }

package/cli/selftune/orchestrate/prepare.ts

@@ -1,5 +1,5 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 import {
   buildDefaultGradingOutputPath,
@@ -7,8 +7,11 @@ import {
   gradeSession,
   resolveLatestSessionForSkill,
 } from "../grading/grade-session.js";
+import { selectAcceptedPackageFrontierCandidate } from "../create/package-candidate-state.js";
 import { writeGradingResultToDb } from "../localdb/direct-write.js";
 import { createDefaultSyncOptions } from "../sync.js";
+import { getDb } from "../localdb/db.js";
+import { readCanonicalPackageEvaluationArtifact } from "../testing-readiness.js";
 import type {
   ImprovementSignalRecord,
   QueryLogRecord,
@@ -17,7 +20,7 @@ import type {
 } from "../types.js";
 import { readExcerpt } from "../utils/transcript.js";
 import type { OrchestrateOptions, SkillAction } from "../orchestrate.js";
-import { selectCandidates } from "./plan.js";
+import { MIN_CANDIDATE_EVIDENCE, selectCandidates } from "./plan.js";
 import { groupSignalsBySkill, readPendingSignals } from "./signals.js";
 import type { ResolvedOrchestrateRuntime } from "./runtime.js";
 
@@ -33,6 +36,50 @@ export interface PreparedOrchestrateRun {
   autoGradedCount: number;
 }
 
+export function collectPackageSearchEligibleSkills(
+  skillNames: string[],
+  options?: {
+    db?: import("bun:sqlite").Database;
+    resolveSkillPath?: (skillName: string) => string | undefined;
+  },
+): Set<string> {
+  const eligible = new Set<string>();
+
+  for (const skillName of skillNames) {
+    if (
+      selectAcceptedPackageFrontierCandidate(skillName) != null ||
+      readCanonicalPackageEvaluationArtifact(skillName) != null
+    ) {
+      eligible.add(skillName);
+      continue;
+    }
+
+    // Second tier: skills with a draft package and sufficient grading evidence
+    if (!options?.db || !options?.resolveSkillPath) continue;
+
+    const skillPath = options.resolveSkillPath(skillName);
+    if (!skillPath) continue;
+
+    const hasDraft = existsSync(join(dirname(skillPath), "selftune.create.json"));
+    if (!hasDraft) continue;
+
+    try {
+      const row = options.db
+        .query<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM grading_results WHERE skill_name = ?",
+        )
+        .get(skillName);
+      if (row && row.count >= MIN_CANDIDATE_EVIDENCE) {
+        eligible.add(skillName);
+      }
+    } catch {
+      // Fail-open: table may not exist yet
+    }
+  }
+
+  return eligible;
+}
+
 /**
  * Detects significant overlap between the positive eval sets of evolution
  * candidates. When two skills share >30% of their positive queries, it
@@ -270,6 +317,10 @@ export async function prepareOrchestrateRun(
 
   const pendingSignals = readPendingSignals(runtime.readSignals);
   const signaledSkills = groupSignalsBySkill(pendingSignals);
+  const packageFrontierSkills = collectPackageSearchEligibleSkills(
+    statusResult.skills.map((skill) => skill.name),
+    { db: getDb(), resolveSkillPath: runtime.resolveSkillPath },
+  );
   if (signaledSkills.size > 0) {
     console.error(
       `[orchestrate] Improvement signals: ${pendingSignals.length} pending for ${signaledSkills.size} skill(s)`,
@@ -281,12 +332,16 @@ export async function prepareOrchestrateRun(
     maxSkills: options.maxSkills,
     auditEntries,
     signaledSkills,
+    packageFrontierSkills,
   });
 
   const evolveCandidates = candidates.filter((candidate) => candidate.action === "evolve");
+  const packageSearchCount = candidates.filter(
+    (candidate) => candidate.action === "package-search",
+  ).length;
   const skipCount = candidates.filter((candidate) => candidate.action === "skip").length;
   console.error(
-    `[orchestrate] Candidates: ${evolveCandidates.length} to evolve, ${skipCount} skipped`,
+    `[orchestrate] Candidates: ${evolveCandidates.length} to evolve, ${packageSearchCount} to package-search, ${skipCount} skipped`,
   );
   for (const candidate of candidates) {
     console.error(

package/cli/selftune/orchestrate/report.ts

@@ -123,7 +123,7 @@ export function formatOrchestrateReport(result: OrchestrateResult): string {
   const lines: string[] = [];
 
   lines.push(separator);
-  lines.push("selftune orchestrate — decision report");
+  lines.push("selftune run — decision report");
   lines.push(separator);
   lines.push("");
 

package/cli/selftune/orchestrate.ts

@@ -24,8 +24,11 @@ import {
   autoGradeFreshDeploys,
   buildReplayValidationOptions,
   runEvolutionPhase,
+  runPackageSearchPhase,
   watchRecentDeploys,
 } from "./orchestrate/execute.js";
+export { runPackageSearchPhase } from "./orchestrate/execute.js";
+export type { RunPackageSearchPhaseInput } from "./orchestrate/execute.js";
 import { finalizeOrchestrateRun } from "./orchestrate/finalize.js";
 import { acquireLock, releaseLock } from "./orchestrate/locks.js";
 import { runPostOrchestrateSideEffects } from "./orchestrate/post-run.js";
@@ -67,6 +70,7 @@ export {
   DEFAULT_COOLDOWN_HOURS,
   MIN_CANDIDATE_EVIDENCE,
   selectCandidates,
+  shouldSelectPackageSearch,
 } from "./orchestrate/plan.js";
 export { autoGradeTopUngraded, detectCrossSkillOverlap } from "./orchestrate/prepare.js";
 export { formatOrchestrateReport } from "./orchestrate/report.js";
@@ -93,12 +97,20 @@ export interface OrchestrateOptions {
   maxAutoGrade: number;
 }
 
+export interface PackageSearchResult {
+  searched: boolean;
+  winnerApplied: boolean;
+  candidateCount: number;
+  winnerCandidateId?: string;
+}
+
 export interface SkillAction {
   skill: string;
-  action: "evolve" | "watch" | "skip";
+  action: "evolve" | "package-search" | "watch" | "skip";
   reason: string;
   evolveResult?: EvolveResult;
   watchResult?: WatchResult;
+  packageSearchResult?: PackageSearchResult;
 }
 
 /** Context for candidate selection beyond simple status checks. */
@@ -110,6 +122,8 @@ export interface CandidateContext {
   cooldownHours?: number;
   /** Skill name (lowercase) to improvement signal count. */
   signaledSkills?: Map<string, number>;
+  /** Skills with an accepted package frontier candidate (eligible for package search). */
+  packageFrontierSkills?: Set<string>;
 }
 
 export interface OrchestrateResult {
@@ -127,6 +141,8 @@ export interface OrchestrateResult {
     watched: number;
     skipped: number;
     autoGraded: number;
+    packageSearched: number;
+    packageImproved: number;
     freshlyWatchedSkills: string[];
     dryRun: boolean;
     approvalMode: "auto" | "review";
@@ -240,6 +256,8 @@ export async function orchestrate(
         watched: 0,
         skipped: 0,
         autoGraded: 0,
+        packageSearched: 0,
+        packageImproved: 0,
         freshlyWatchedSkills: [],
         dryRun: options.dryRun,
         approvalMode: options.approvalMode,
@@ -288,6 +306,19 @@ export async function orchestrate(
       readSkillRecords: runtime.readSkillRecords,
     });
 
+    // -------------------------------------------------------------------------
+    // Step 5c: Package search for candidates tagged with action "package-search"
+    // -------------------------------------------------------------------------
+    const packageSearchCandidates = candidates.filter(
+      (candidate) => candidate.action === "package-search",
+    );
+    const packageSearchImproved = await runPackageSearchPhase({
+      packageSearchCandidates,
+      dryRun: options.dryRun,
+      agent,
+      resolveSkillPath: runtime.resolveSkillPath,
+    });
+
     // -------------------------------------------------------------------------
     // Step 6: Watch recently evolved skills (including freshly deployed in this run)
     // -------------------------------------------------------------------------
@@ -336,6 +367,8 @@ export async function orchestrate(
       dryRun: options.dryRun,
       approvalMode: options.approvalMode,
       autoGradedCount,
+      packageSearched: packageSearchCandidates.length,
+      packageImproved: packageSearchImproved.length,
       freshlyWatchedSkills,
       pendingSignals,
       elapsedMs: Date.now() - startTime,

package/cli/selftune/publish.ts

@@ -0,0 +1,35 @@
+import { PUBLIC_COMMAND_SURFACES, renderCommandHelp } from "./command-surface.js";
+import { cliMain as createPublishCliMain } from "./create/publish.js";
+import { CLIError, 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.publish));
+    process.exit(0);
+  }
+
+  const hasWatch = rawArgs.includes("--watch") || rawArgs.some((arg) => arg.startsWith("--watch="));
+  const hasNoWatch = rawArgs.includes("--no-watch");
+
+  if (hasWatch && hasNoWatch) {
+    throw new CLIError(
+      "Use either --watch or --no-watch, not both.",
+      "INVALID_FLAG",
+      "selftune publish --skill-path <path> [--no-watch]",
+    );
+  }
+
+  const delegatedArgs = rawArgs.filter((arg) => arg !== "--no-watch");
+  if (!hasWatch && !hasNoWatch) {
+    delegatedArgs.push("--watch");
+  }
+
+  process.argv = [process.argv[0], process.argv[1], ...delegatedArgs];
+  await createPublishCliMain();
+}
+
+if (import.meta.main) {
+  cliMain().catch(handleCLIError);
+}

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,