agent-skillboard 0.3.1 → 0.3.3

package/src/route.mjs

@@ -4,15 +4,13 @@ import {
   guardCommand,
   overlapResolutionForRoute,
   policyMemoryForRoute,
-  policyMemoryForV2Route,
   postUsePolicySuggestionForCapabilityRoute,
-  postUsePolicySuggestionForV2Route,
   recommendationReason,
   routeCandidate,
   selectedRouteSkill,
   usageDisclosure
 } from "./route-advisory.mjs";
-import { confidenceFor, possibleWorkflowSkills, selectRoute, selectV2Route } from "./route-selection.mjs";
+import { confidenceFor, possibleWorkflowSkills, selectRoute } from "./route-selection.mjs";
 
 export function routeSkill(workspace, options) {
   const intent = options.intent.trim();
@@ -103,57 +101,42 @@ export function routeSkill(workspace, options) {
 }
 
 function routeV2Skill(workspace, options, intent) {
-  const { candidates, selected } = selectV2Route(workspace, intent, options.agent);
-  if (selected === undefined) {
-    return {
-      ok: true, intent, workflow: null, agent: options.agent ?? null,
-      matched_capability: null, matched_skill: null, match_source: "none", confidence: "none",
-      matched_terms: [], recommendation_reason: "No enabled skill installed for this agent matched this request.",
-      recommended_skill: null, fallback_skills: [], route_candidates: [], overlap_resolution: null,
-      policy_memory: null, guard_command: null, guard: null, usage_disclosure: null,
-      post_use_policy_suggestion: null, possible_skills: [], candidates: []
-    };
-  }
-  const routed = candidates.map((candidate) => ({
-    skill: candidate.skill.id,
-    role: candidate.explicit ? "matched" : "alternative",
-    guard: candidate.guard
-  }));
-  const matchedTerms = [...new Set([...selected.matchedIntents, ...selected.metadataMatches])];
-  const contextName = options.agent === undefined ? "the current agent" : `agent ${options.agent}`;
-  const recommended = routed[0];
-  const overlapResolution = overlapResolutionForRoute({
-    matchedCapability: intent,
-    recommended,
-    routedSkills: routed,
-    workflowName: contextName
-  });
-  const policyMemory = policyMemoryForV2Route({ intent, selected, candidates, workflowName: undefined });
-  const postUsePolicySuggestion = postUsePolicySuggestionForV2Route({
-    intent, selected, candidates, workflowName: undefined, options, policyMemory
-  });
+  const possibleSkills = workspace.skills
+    .filter((skill) => canUseSkill(workspace, skill.id, undefined, options.agent).allowed)
+    .map((skill) => v2ModelSkill(workspace, skill))
+    .sort((left, right) => left.id.localeCompare(right.id));
+  const modelSelectionRequired = possibleSkills.length > 0;
   return {
     ok: true, intent, workflow: null, agent: options.agent ?? null,
-    matched_capability: null,
-    matched_skill: selected.skill.id,
-    match_source: selected.explicit
-      ? "explicit-skill"
-      : selected.matchedIntents.length > 0
-        ? "skill-preference"
-        : "skill-metadata",
-    confidence: confidenceFor(selected.score),
-    matched_terms: matchedTerms,
-    recommendation_reason: `Recommended ${selected.skill.id} because it is enabled, installed for this agent, and best matches the request.`,
-    recommended_skill: selected.skill.id,
-    fallback_skills: candidates.slice(1).map((candidate) => candidate.skill.id),
-    route_candidates: routed.map((entry, index) => routeCandidate(entry, index === 0)),
-    overlap_resolution: overlapResolution, policy_memory: policyMemory,
-    guard_command: guardCommand(selected.skill.id, undefined, options),
-    guard: selected.guard,
-    usage_disclosure: usageDisclosure(selected.skill.id, policyMemory),
-    post_use_policy_suggestion: postUsePolicySuggestion,
-    possible_skills: routed.map((entry) => ({ id: entry.skill, allowed: true })),
-    candidates: candidates.map((candidate) => ({ skill_id: candidate.skill.id, score: candidate.score }))
+    selection_mode: "model",
+    model_selection_required: modelSelectionRequired,
+    matched_capability: null, matched_skill: null, match_source: "none",
+    confidence: "none", matched_terms: [],
+    recommendation_reason: modelSelectionRequired
+      ? "SkillBoard does not interpret v2 request text. The active model should choose from the eligible skill descriptions and saved preferences, or use no skill when none fits."
+      : "No enabled skill is installed for the selected agent.",
+    recommended_skill: null, fallback_skills: [], route_candidates: [],
+    overlap_resolution: null, policy_memory: null,
+    guard_command: null, guard: null, usage_disclosure: null,
+    post_use_policy_suggestion: null,
+    possible_skills: possibleSkills,
+    candidates: []
+  };
+}
+
+function v2ModelSkill(workspace, skill) {
+  const inventory = workspace.inventory?.skills?.find((candidate) => candidate.id === skill.id);
+  const installed = workspace.installedSkills.find((candidate) => (
+    candidate.id === skill.id
+    || (typeof skill.path === "string" && candidate.path === skill.path)
+  ));
+  return {
+    id: skill.id,
+    name: installed?.name ?? inventory?.name ?? skill.id,
+    description: installed?.description ?? inventory?.description ?? null,
+    path: installed?.path ?? inventory?.path ?? null,
+    preference: skill.preference ?? null,
+    allowed: true
   };
 }
 

package/src/setup-policy-migration.mjs

@@ -0,0 +1,43 @@
+import { dirname, join, resolve } from "node:path";
+import { canAutomaticallyMigrateV2 } from "./migration/automatic-v2.mjs";
+import { migrateV2 } from "./migration/v2-transaction.mjs";
+
+export async function upgradeLegacyUserPolicy(options) {
+  if (options.inventoryPath !== null) {
+    return { status: "current", inventoryPath: options.inventoryPath, artifacts: [] };
+  }
+
+  const inventoryPath = resolve(options.home, ".skillboard", "inventory.json");
+  const migrationOptions = {
+    configPath: options.configPath,
+    inventoryPath,
+    failpoint: options.failpoint
+  };
+  const preview = await migrateV2({ ...migrationOptions, apply: false });
+  const observed = new Set(options.observedSkillIds);
+  const unobservedSkillIds = preview.skills.map(({ id }) => id).filter((id) => !observed.has(id));
+  if (!canAutomaticallyMigrateV2(preview) || unobservedSkillIds.length > 0) {
+    return {
+      status: "decision-required",
+      inventoryPath: null,
+      artifacts: [],
+      preview,
+      unobservedSkillIds
+    };
+  }
+
+  const applied = await migrateV2({
+    ...migrationOptions,
+    apply: true,
+    expectedInputSha256: preview.input_sha256
+  });
+  const directory = dirname(options.configPath);
+  const artifactNames = [applied.backup, applied.manifest, applied.inventory_backup].filter(Boolean);
+  return {
+    status: "upgraded",
+    inventoryPath,
+    backupPath: join(directory, applied.backup),
+    artifacts: artifactNames.map((name) => join(directory, name)),
+    report: applied
+  };
+}