agent-skillboard 0.3.1 → 0.3.3

package/src/agent-integration-command.mjs

@@ -0,0 +1,38 @@
+import { isAbsolute, relative, resolve } from "node:path";
+
+export function commandPrefix(runtime) {
+  const entrypoint = runtime.entrypointPath ?? "";
+  const normalized = entrypoint.replace(/\\/g, "/");
+  if (normalized.includes("/_npx/")) {
+    const packageSpec = runtime.packageSpec ?? "agent-skillboard";
+    return `npx --yes --package ${shellQuote(packageSpec, runtime.platform)} skillboard`;
+  }
+  if (isSourceTreeEntrypoint(entrypoint)) {
+    return `node ${sourceTreeEntrypoint(entrypoint, runtime.cwd ?? process.cwd(), runtime.platform)}`;
+  }
+  return "skillboard";
+}
+
+function isSourceTreeEntrypoint(entrypoint) {
+  if (entrypoint === "") return false;
+  const normalized = entrypoint.replace(/\\/g, "/");
+  return (normalized === "bin/skillboard.mjs" || normalized.endsWith("/bin/skillboard.mjs"))
+    && !normalized.includes("/node_modules/")
+    && !normalized.includes("/_npx/")
+    && !normalized.includes("/.npm/");
+}
+
+function sourceTreeEntrypoint(entrypoint, cwd, platform) {
+  const absoluteEntrypoint = isAbsolute(entrypoint) ? entrypoint : resolve(cwd, entrypoint);
+  const relativeEntrypoint = relative(cwd, absoluteEntrypoint).replace(/\\/g, "/");
+  if (!relativeEntrypoint.startsWith("../") && relativeEntrypoint !== ".." && !isAbsolute(relativeEntrypoint)) {
+    return shellQuote(relativeEntrypoint, platform);
+  }
+  return shellQuote(absoluteEntrypoint, platform);
+}
+
+export function shellQuote(value, platform = process.platform) {
+  if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+  if (platform === "win32") return `"${value.replace(/"/g, '""')}"`;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/agent-integration-content.mjs

@@ -25,7 +25,7 @@ Use this skill to let SkillBoard guide skill selection above individual projects
 - For ordinary user requests, work normally; invoke SkillBoard only when skill choice is ambiguous, skills overlap, or the user asks for a SkillBoard or skill decision.
 - If the user explicitly asks for a specific installed skill, honor that request when the guard allows it instead of rerouting away solely because other skills also match.
 - Do not ask for permission merely because you selected a skill.
-- When you use a skill, disclose it briefly at the start and completion. If SkillBoard says remembered or configured policy selected this skill while other allowed skills were available, mention that at completion.
+- When you use a skill, disclose it briefly at the start and completion. If a saved preference influenced the model's choice, mention that briefly at completion.
 
 ## Cross-Agent Skill Reuse
 
@@ -41,11 +41,11 @@ Use this skill to let SkillBoard guide skill selection above individual projects
 
 1. Start from the user's task, not from a pre-task inventory prompt.
 2. Identify candidate skills only when multiple installed skills plausibly match or a manual skill-control request is present.
-3. Prefer the skill whose explicit request, description, and local instructions most directly match the user's task.
-4. Use \`skillboard brief --agent ${agent} --intent <request> --json\` or \`skillboard route <intent> --agent ${agent} --json\` to break ties.
-5. Run \`skillboard guard use <skill-id> --agent ${agent} --json\` immediately before invoking the selected skill.
-6. If the best choice is still ambiguous or the choice would change persistent policy, ask the user which priority to remember.
-7. Continue with the selected skill; do not stop only because other candidate skills exist.
+3. Use \`skillboard brief --agent ${agent} --intent <request> --json\` or \`skillboard route <intent> --agent ${agent} --json\` to read eligible skill descriptions and raw saved preferences. SkillBoard does not interpret v2 request text.
+4. Make the semantic choice yourself from the full request, explicit user direction, descriptions, local instructions, and any saved preferences; use no skill when none fits.
+5. Run \`skillboard guard use <skill-id> --agent ${agent} --json\` immediately before invoking the model-selected skill.
+6. Continue with the selected skill; do not stop only because other candidate skills exist.
+7. If the choice remained ambiguous and remembering it would help, finish the work first, then ask whether to save that intent preference.
 
 ## Removal
 

package/src/brief-renderer.mjs

@@ -84,7 +84,7 @@ function emitIntentRoute(lines, brief) {
   if (route === undefined) {
     return;
   }
-  lines.push("## Suggested skill for this request", "");
+  lines.push("## Skill selection for this request", "");
   lines.push(...renderRouteSectionLines(route, {
     format: "brief",
     nextStep: brief.assistant_guidance?.recommended_next_step

package/src/cli.mjs

@@ -60,6 +60,7 @@ import { ApplyActionError, applyActionErrorPayload, applyAdvisorAction } from ".
 import { importAgentSkill, renderImportAgentSkill } from "./agent-skill-import.mjs";
 import { runBriefCommand } from "./brief-cli.mjs";
 import { renderSkillBrief } from "./brief-renderer.mjs";
+import { shellQuote } from "./agent-integration-command.mjs";
 import { planGuardHookInstall } from "./control.mjs";
 import { writeCheckedConfig } from "./control/config-write.mjs";
 import { runInitCommand, runSetupCommand, runUninstallCommand } from "./lifecycle-cli.mjs";
@@ -93,7 +94,7 @@ const COMMAND_USAGE = new Map([
   ["check", ["check --config <path> --skills <dir>"]],
   ["list", ["list [skills|workflows|harnesses|install-units] [--config <path>] [--skills <dir>] [--json]"]],
   ["explain", ["explain <skill-id> --config <path> --skills <dir> [--json]"]],
-  ["can-use", ["can-use <skill-id> --agent codex|claude|opencode|hermes [--json]"]],
+  ["can-use", ["can-use <skill-id> --agent <name> (v2 policy) | --workflow <name> (v1 policy) [--json]"]],
   ["audit", ["audit sources --config <path> --skills <dir> [--verify] [--json]"]],
   ["rollout", ["rollout [audit|plan|apply|rollback|report] [--dir <path>] [--config <path>] [--skills <dir>] [--transaction <id>] [--json]"]],
   ["hook", ["hook install --workflow <name> --config <path> --skills <dir> [--out <path>] [--skillboard-bin <path>] [--dry-run] [--json]"]],
@@ -580,15 +581,12 @@ async function route(argv, options, stdout) {
   const intent = positionalArgs(argv).join(" ").trim();
   const workflow = options.get("workflow");
   if (intent.length === 0) {
-    throw new Error("Usage: skillboard route <intent> [--agent <name>]");
+    throw new Error(selectorUsage("skillboard route <intent>"));
   }
   const config = configPath(options);
   const skills = skillsRoot(options);
   const workspace = await loadWorkspace({ configPath: config, skillsRoot: skills });
-  assertV2AgentOption(workspace, options, "skillboard route <intent> --agent <name>");
-  if (workspace.version === 1 && workflow === undefined) {
-    throw new Error("Usage: skillboard route <intent> --workflow <name>");
-  }
+  assertPolicySelectorOption(workspace, options, "skillboard route <intent>", config);
   const result = routeSkill(workspace, {
     intent,
     workflow,
@@ -605,13 +603,11 @@ async function canUse(argv, options, stdout) {
   const skillId = positionalArgs(argv)[0];
   const workflow = options.get("workflow");
   if (skillId === undefined) {
-    throw new Error("Usage: skillboard can-use <skill-id> [--agent <name>]");
-  }
-  const workspace = await loadWorkspace({ configPath: configPath(options), skillsRoot: skillsRoot(options) });
-  assertV2AgentOption(workspace, options, "skillboard can-use <skill-id> --agent <name>");
-  if (workspace.version === 1 && workflow === undefined) {
-    throw new Error("Usage: skillboard can-use <skill-id> --workflow <name>");
+    throw new Error(selectorUsage("skillboard can-use <skill-id>"));
   }
+  const config = configPath(options);
+  const workspace = await loadWorkspace({ configPath: config, skillsRoot: skillsRoot(options) });
+  assertPolicySelectorOption(workspace, options, "skillboard can-use <skill-id>", config);
   const result = canUseSkill(workspace, skillId, workflow, options.get("agent"));
   writeOutput(stdout, result, options, () => renderCanUse(result));
   return result.allowed ? 0 : 2;
@@ -623,9 +619,10 @@ async function guard(argv, options, stdout) {
   const skillId = args[0] === "use" ? args[1] : args[0];
   const workflow = options.get("workflow");
   if (skillId === undefined) {
-    throw new Error("Usage: skillboard guard use <skill-id> [--agent <name>]");
+    throw new Error(selectorUsage("skillboard guard use <skill-id>"));
   }
-  const workspace = await loadWorkspace({ configPath: configPath(options), skillsRoot: skillsRoot(options) });
+  const config = configPath(options);
+  const workspace = await loadWorkspace({ configPath: config, skillsRoot: skillsRoot(options) });
   const hookProjection = options.get("hook-projection-version") ?? process.env.SKILLBOARD_POLICY_PROJECTION_VERSION;
   if (args[0] !== "use" && hookProjection === undefined) {
     throw new Error("This pre-v2 policy projection is stale; regenerate the guard hook from version 2 policy.");
@@ -634,10 +631,7 @@ async function guard(argv, options, stdout) {
     throw new Error("This pre-v2 policy projection is stale; regenerate the guard hook from version 2 policy.");
   }
   assertCurrentProjectionVersion(hookProjection, workspace.version);
-  assertV2AgentOption(workspace, options, "skillboard guard use <skill-id> --agent <name>");
-  if (workspace.version === 1 && workflow === undefined) {
-    throw new Error("Usage: skillboard guard use <skill-id> --workflow <name>");
-  }
+  assertPolicySelectorOption(workspace, options, "skillboard guard use <skill-id>", config);
   const result = canUseSkill(workspace, skillId, workflow, options.get("agent"));
   if (options.get("json") === "true") {
     stdout.write(`${JSON.stringify(result, null, 2)}\n`);
@@ -1272,17 +1266,39 @@ function statePaths(options) {
   });
 }
 
-function assertV2AgentOption(workspace, options, usage) {
-  if (workspace.version !== 2) return;
+function assertPolicySelectorOption(workspace, options, command, config) {
   const agent = options.get("agent");
+  const workflow = options.get("workflow");
+  if (workspace.version === 1) {
+    if (agent !== undefined) {
+      throw new Error([
+        "This workspace uses a version 1 policy, which selects with --workflow <name>.",
+        `Either pass --workflow, or preview migration with: skillboard migrate v2 --config ${shellQuote(config)} --json`
+      ].join("\n"));
+    }
+    if (workflow === undefined) {
+      throw new Error(selectorUsage(command));
+    }
+    return;
+  }
+  if (workflow !== undefined) {
+    throw new Error([
+      "This workspace uses a version 2 policy, which selects with --agent <name>.",
+      "Pass --agent instead of --workflow."
+    ].join("\n"));
+  }
   if (agent === undefined) {
-    throw new Error(`Version 2 availability requires --agent. Usage: ${usage}`);
+    throw new Error(`Version 2 availability requires --agent. ${selectorUsage(command)}`);
   }
   if (!supportedAgentNames().includes(agent)) {
     throw new Error(`Unsupported agent: ${agent}. Expected one of: ${supportedAgentNames().join(", ")}.`);
   }
 }
 
+function selectorUsage(command) {
+  return `Usage: ${command} --agent <name> (v2 policy) | --workflow <name> (v1 policy)`;
+}
+
 const VALUE_OPTIONS = new Set([
   "actual-harnesses", "adapted-file", "adapted-for", "agent", "cache-dir", "capability", "category",
   "command", "config", "config-file", "dir", "exposure", "from", "harness", "harness-status",
@@ -1324,10 +1340,6 @@ function formatList(values) {
   return values.length === 0 ? "none" : values.map((value) => `\`${value}\``).join(", ");
 }
 
-function shellQuote(value) {
-  return /^[A-Za-z0-9_./:=@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
-}
-
 function readCsv(value) {
   if (value === undefined || value.trim() === "") {
     return [];
@@ -1617,7 +1629,15 @@ function renderRoute(result) {
   if (result.matched_capability === null) {
     lines.push("Possible skills:");
     for (const skill of result.possible_skills.slice(0, 5)) {
-      lines.push(`- ${skill.id} (${skill.category ?? "uncategorized"}, allowed=${skill.allowed})`);
+      if (result.selection_mode === "model") {
+        const description = skill.description ?? "no description";
+        const preference = skill.preference === null || skill.preference === undefined
+          ? "no saved preference"
+          : `saved preference=${JSON.stringify(skill.preference)}`;
+        lines.push(`- ${skill.id}: ${description} (${preference}, allowed=${skill.allowed})`);
+      } else {
+        lines.push(`- ${skill.id} (${skill.category ?? "uncategorized"}, allowed=${skill.allowed})`);
+      }
     }
   }
   lines.push("");
@@ -1804,9 +1824,9 @@ function helpText() {
     "  check --config <path> --skills <dir>",
     "  list [skills|workflows|harnesses|install-units] [--config <path>] [--skills <dir>] [--json]",
     "  explain <skill-id> [--config <path>] [--skills <dir>] [--json]",
-    "  route <intent> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
-    "  can-use <skill-id> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
-    "  guard use <skill-id> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
+    "  route <intent> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
+    "  can-use <skill-id> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
+    "  guard use <skill-id> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
     "",
     "Advanced operator commands:",
     "  Import, audit, rollout, hook, lock, variant, reconcile, impact, dashboard, and v1 lifecycle commands remain available through command-specific help and docs/reference.md.",
@@ -1818,8 +1838,10 @@ function helpText() {
     "",
     "v2 AI/automation control loop:",
     "  Policy decides only enabled/disabled and per-skill opt-in sharing; see docs/ai-skill-routing-goal.md.",
-    "  Valid installed skills default to enabled and agent-local. Optional preference ranks only and never changes availability.",
-    "  Read brief --intent --agent <agent>, select an enabled installed skill, and run guard use automatically before use.",
+    "  Valid installed skills default to enabled and agent-local. Optional preference is raw model context and never changes availability.",
+    "  Read brief --intent --agent <agent>; the model selects from raw eligible skill descriptions and saved preferences, or uses no skill.",
+    "  SkillBoard does not tokenize, score, match, or recommend from v2 request text.",
+    "  Run guard use automatically before using the model-selected skill.",
     "  For an allowed skill, work without another approval; ask once only before a persistent policy change.",
     "  Source/provenance observations are audit metadata, never availability. Runtime/action authorization is outside SkillBoard.",
     "  Stale v1 policy is read-only: preview with skillboard migrate v2 --config <path> --json, apply with --yes --json, or restore with --rollback <backup> --json.",
@@ -2053,7 +2075,7 @@ function briefHelpText() {
     "",
     "Options:",
     "  --agent <name>        Evaluate actual installation for the current agent; required for v2 availability and routing.",
-    "  --intent <request>    Add a natural-language request so SkillBoard can suggest a skill.",
+    "  --intent <request>    Pass the request beside raw eligible descriptions and saved preferences; v2 does not score it.",
     "  --config <path>       Advanced policy override; defaults to ~/skillboard.config.yaml.",
     "  --skills <dir>        Use a specific skills directory.",
     "  --include-actions     Include current action ids in JSON output.",
@@ -2071,37 +2093,41 @@ function briefHelpText() {
 
 function routeHelpText() {
   return [
-    "Usage: skillboard route <intent> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
+    "Usage: skillboard route <intent> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
     "",
-    "Suggests the routed skill for a user request when several allowed skills may overlap.",
-    "Use it when the AI needs a skill recommendation without changing policy.",
+    "In v2, returns raw eligible skill descriptions and saved preferences without interpreting the request.",
+    "The model makes the semantic choice, including explicit requests and preferences, without changing policy.",
+    "Version 1 compatibility routing retains its legacy deterministic tokenizer and recommendation behavior.",
     "",
     "Options:",
     "  <intent>           Natural-language request, such as \"write tests first\".",
-    "  --agent <name>     Route among skills installed for this agent.",
+    "  --agent <name> (v2 policy) | --workflow <name> (v1 policy)",
+    "                     Route with the selector required by the detected policy version.",
     "  --config <path>    Use a specific skillboard.config.yaml.",
     "  --skills <dir>     Use a specific skills directory.",
     "  --json             Print an agent-readable payload.",
     "",
     "AI use:",
-    "  If a skill is recommended, run the guard automatically before invoking it.",
+    "  In v2, choose from the eligible skill descriptions and raw saved preferences, or use no skill.",
+    "  Run the guard automatically before invoking the model-selected skill.",
     "  If the guard allows use, disclose the skill at start and completion; do not ask for another approval.",
-    "  If policy memory would reduce ambiguity, ask after completion whether to remember the routed skill.",
-    "  If no skill matches, ask a clarifying question instead of guessing.",
+    "  If a saved preference would help later model selection, ask after completion whether to remember it.",
+    "  In v1 compatibility mode, ask a clarifying question when no workflow route matches.",
     ""
   ].join("\n");
 }
 
 function canUseHelpText() {
   return [
-    "Usage: skillboard can-use <skill-id> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
+    "Usage: skillboard can-use <skill-id> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
     "",
     "Checks whether one skill is enabled and installed for the selected agent without changing policy.",
     "Use it when the AI needs an availability answer for a named skill.",
     "",
     "Options:",
     "  <skill-id>         Skill id to check.",
-    "  --agent <name>     Agent that would use the skill.",
+    "  --agent <name> (v2 policy) | --workflow <name> (v1 policy)",
+    "                     Select the agent or legacy workflow that would use the skill.",
     "  --config <path>    Use a specific skillboard.config.yaml.",
     "  --skills <dir>     Use a specific skills directory.",
     "  --json             Print an agent-readable payload.",
@@ -2116,7 +2142,7 @@ function canUseHelpText() {
 
 function guardHelpText() {
   return [
-    "Usage: skillboard guard use <skill-id> --agent codex|claude|opencode|hermes [--config <path>] [--skills <dir>] [--json]",
+    "Usage: skillboard guard use <skill-id> --agent codex|claude|opencode|hermes (v2 policy) | --workflow <name> (v1 policy) [--config <path>] [--skills <dir>] [--json]",
     "",
     "Checks whether one skill may be used right now.",
     "Run this immediately before the AI invokes a skill.",
@@ -2124,7 +2150,8 @@ function guardHelpText() {
     "Options:",
     "  use                Guard a skill invocation.",
     "  <skill-id>         Skill id to check.",
-    "  --agent <name>     Agent that will use the skill.",
+    "  --agent <name> (v2 policy) | --workflow <name> (v1 policy)",
+    "                     Select the agent or legacy workflow that will use the skill.",
     "  --config <path>    Use a specific skillboard.config.yaml.",
     "  --skills <dir>     Use a specific skills directory.",
     "  --json             Print an agent-readable payload.",

package/src/inventory-refresh.mjs

@@ -85,6 +85,7 @@ async function refreshLocked(options) {
     bootstrappedV2,
     configPath: relativeArtifactPath(root, configPath),
     inventoryPath: generatedInventory === null ? null : relativeArtifactPath(root, inventoryPath),
+    observedSkillIds: inventory.skills.map(({ id }) => id).sort((left, right) => left.localeCompare(right)),
     inventoryChanged,
     changed: plan.changed,
     plan,

package/src/lifecycle-cli.mjs

@@ -140,7 +140,7 @@ function writeSafetyDefault(stdout, safety) {
   stdout.write("Skill selection default:\n");
   stdout.write("- Valid installed skills default to enabled and agent-local.\n");
   stdout.write("- Users may disable a skill or explicitly share that skill across agents.\n");
-  stdout.write("- Optional preference ranks candidates and never changes availability.\n");
+  stdout.write("- Optional preference is raw model context and never changes availability.\n");
   stdout.write("- Source and provenance are audit metadata, never availability.\n");
   stdout.write(`- ${safety.enabled} enabled skills\n`);
   stdout.write(`- ${safety.disabled} disabled skills\n`);

package/src/lifecycle-content.mjs

@@ -13,27 +13,29 @@ export function bridgeBlock() {
 
 SkillBoard keeps one user-level policy. A valid installed skill defaults to
 enabled and agent-local. Users may opt individual skills into cross-agent
-sharing. Optional preference ranks enabled skills installed for the current
-agent and never changes availability or copies files.
+sharing. Optional preference is raw context for the model and never changes
+availability or copies files.
 
 ## Route and use
 
 - Work normally unless skills overlap or the user asks
   for a skill decision.
 - Read \`skillboard brief --intent <request> --agent <agent> --json\`.
-- Use the recommended enabled, installed skill and ordered fallbacks. Honor an
-  explicit user choice when the guard allows it.
+- SkillBoard returns eligible skill descriptions and raw saved preferences. It
+  does not tokenize, score, match, or recommend from v2 request text.
+- The model makes the semantic choice, including explicit user requests and
+  saved preferences, or continues without a skill when none fits.
 - Run \`skillboard guard use <skill-id> --agent <agent> --json\` immediately
   before use.
 - Do not ask for another approval when guard allows use. Briefly disclose the
   selected skill as an audit trace.
-- If the routed brief suggests policy memory, finish the work first, then ask
+- If remembering the choice would help later model selection, finish the work first, then ask
   once whether to remember that intent preference. Do not prompt before use.
 
 ## Change policy
 
 - Policy changes only enable/disable a skill, share/unshare one skill, or
-  remember optional ranking preference.
+  remember optional model preference.
 - Read a fresh brief with \`--include-actions\`, choose one current action id, ask
   for one confirmation, then run \`skillboard apply-action <action-id> --yes
   --json\`.

package/src/migration/automatic-v2.mjs

@@ -0,0 +1,14 @@
+const SAFE_AMBIGUITY_KIND = "review_only_quarantine";
+
+export function canAutomaticallyMigrateV2(report) {
+  if (report?.mode !== "preview" || report.changed !== true || report.target_version !== 2) return false;
+  if (!Array.isArray(report.ambiguities)) return false;
+  return report.ambiguities.every((ambiguity) => (
+    ambiguity?.kind === SAFE_AMBIGUITY_KIND
+    && ambiguity.mapped_enabled === true
+    && ambiguity.requires_grouped_confirmation === true
+    && Array.isArray(ambiguity.skill_ids)
+    && ambiguity.skill_ids.length > 0
+    && ambiguity.skill_ids.every((skillId) => typeof skillId === "string" && skillId.length > 0)
+  ));
+}

package/src/migration/v2-projection.mjs

@@ -103,6 +103,7 @@ export function unchangedMigrationResult(inputBytes) {
     ambiguities: [],
     grouped_decision: null,
     backup: null,
-    manifest: null
+    manifest: null,
+    inventory_backup: null
   };
 }

package/src/migration/v2-transaction.mjs

@@ -46,6 +46,9 @@ export async function migrateV2(options) {
 
 async function migrateForward(configPath, inventoryPath, options) {
   const inputBytes = await readFile(configPath);
+  if (options.expectedInputSha256 !== undefined && sha256(inputBytes) !== options.expectedInputSha256) {
+    throw new Error("Config changed after migration preview; no files were changed.");
+  }
   const inputText = inputBytes.toString("utf8");
   const { document, parsed } = parseMigrationConfig(inputText);
   const version = parsed.version ?? 1;
@@ -85,6 +88,7 @@ async function migrateForward(configPath, inventoryPath, options) {
       changed: true,
       backup: basename(backup.configBackupPath),
       manifest: basename(backup.manifestPath),
+      inventory_backup: backup.inventoryBackupPath === null ? null : basename(backup.inventoryBackupPath),
       ...report
     };
   } catch (error) {

package/src/route-advisory.mjs

@@ -119,50 +119,6 @@ export function postUsePolicySuggestionForCapabilityRoute({ matchedCapability, r
   });
 }
 
-export function policyMemoryForV2Route({ intent, selected, candidates, workflowName }) {
-  if (selected.explicit || selected.matchedIntents.length === 0 || candidates.length < 2) {
-    return null;
-  }
-  const alternatives = candidates.slice(1).map((candidate) => candidate.skill.id);
-  const alternativeText = alternatives.join(", ");
-  const context = workflowName === undefined ? "for the current agent" : `in legacy workflow ${workflowName}`;
-  return {
-    status: "applied",
-    mode: "remembered-or-configured-preference",
-    selected_skill: selected.skill.id,
-    available_alternatives: alternatives,
-    summary: `Remembered or configured policy selected ${selected.skill.id} for ${intent} ${context}; other allowed skills were also available: ${alternativeText}.`,
-    finish_disclosure: `I used ${selected.skill.id} for this request because SkillBoard has a remembered or configured preference for it; other allowed skills were also available: ${alternativeText}.`
-  };
-}
-
-export function postUsePolicySuggestionForV2Route({ intent, selected, candidates, workflowName, options, policyMemory }) {
-  if (selected.explicit || policyMemory !== null || candidates.length < 2) {
-    return null;
-  }
-  const context = workflowName === undefined ? "" : ` in ${workflowName}`;
-  return {
-    timing: "after_use",
-    mode: "ask_after_use",
-    reason: `SkillBoard found multiple allowed skills for ${intent} and selected ${selected.skill.id}. After completing the task, ask whether to remember ${selected.skill.id} for similar requests${context}.`,
-    question: `Should I remember ${selected.skill.id} as the preferred skill for similar ${intent} requests${context}?`,
-    requires_confirmation: true,
-    suggested_policy: {
-      kind: "prefer-skill",
-      skill: selected.skill.id,
-      workflow: workflowName ?? null,
-      intent,
-      command_hint: command([
-        "skillboard", "skill", "preference", selected.skill.id,
-        "--intent", intent,
-        "--priority", "100",
-        "--config", routeConfigPath(options),
-        ...(options.skillsRoot === undefined ? [] : ["--skills", routeSkillsRoot(options)])
-      ]).display
-    }
-  };
-}
-
 function postUsePolicySuggestionForDeniedPreferredFallback({ matchedCapability, recommended, routedSkills, workflowName, options }) {
   if (recommended === null || recommended.role !== "fallback" || recommended.guard.allowed !== true) {
     return null;

package/src/route-renderer.mjs

@@ -30,7 +30,7 @@ export function renderRouteSectionLines(route, options = {}) {
   const lines = [];
   pushRouteMatchLines(lines, route, formatter, options);
   if (route.recommended_skill === null) {
-    pushNoRecommendationLines(lines, route, formatter);
+    pushNoRecommendationLines(lines, route, formatter, options);
     return lines;
   }
   pushRecommendationLines(lines, route, formatter, options);
@@ -50,11 +50,18 @@ function pushRouteMatchLines(lines, route, formatter, options) {
   lines.push(`${formatter.prefix}Matched terms: ${formatter.list(route.matched_terms)}`);
 }
 
-function pushNoRecommendationLines(lines, route, formatter) {
+function pushNoRecommendationLines(lines, route, formatter, options) {
   lines.push(`${formatter.prefix}Recommended skill: none`);
   if (formatter.includeFallbackWhenNoRecommendation) {
     lines.push(`${formatter.prefix}Fallback skills: ${formatter.list(route.fallback_skills)}`);
   }
+  if (route.model_selection_required === true) {
+    lines.push(`${formatter.prefix}Model selection: required - choose from eligible skill descriptions and raw saved preferences, or use no skill.`);
+    if (typeof options.nextStep === "string" && options.nextStep.length > 0) {
+      lines.push(`${formatter.prefix}Next step: ${safeText(options.nextStep, 360)}`);
+    }
+    return;
+  }
   if (formatter.noMatchNextStep !== null) {
     lines.push(`${formatter.prefix}Next step: ${formatter.noMatchNextStep}`);
   }

package/src/route-selection.mjs

@@ -3,6 +3,7 @@ import { canonicalRouteToken, phraseKey, tokensFor } from "./route-tokens.mjs";
 
 const HIGH_CONFIDENCE = 4;
 const MEDIUM_CONFIDENCE = 2;
+const CJK_SUFFIX = /^[\p{Script=Hangul}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]+$/u;
 
 export function selectRoute(workspace, workflow, intent) {
   const intentTokens = tokensFor(intent);
@@ -24,38 +25,6 @@ export function selectRoute(workspace, workflow, intent) {
   };
 }
 
-export function selectV2Route(workspace, intent, agentName) {
-  const intentKey = phraseKey(intent);
-  const intentTokens = tokensFor(intent);
-  const candidates = workspace.skills
-    .map((skill) => {
-      const guard = canUseSkill(workspace, skill.id, undefined, agentName);
-      const explicit = exactSkillIdMention(intentKey, skill.id);
-      const preference = skill.preference;
-      const matchedIntents = preference?.intents.filter((term) => matchesIntentTerm(intentTokens, term)) ?? [];
-      const installed = installedSkillFor(workspace, skill.id);
-      const metadataTokens = tokensFor(`${installed?.name ?? ""} ${installed?.description ?? ""}`);
-      const metadataMatches = [...metadataTokens].filter((token) => intentTokens.has(token));
-      const hasMatch = explicit || matchedIntents.length > 0 || metadataMatches.length > 0;
-      const preferenceScore = matchedIntents.length > 0 ? (preference?.priority ?? 0) : 0;
-      const rawScore = (explicit ? 1_000_000 : 0)
-          + matchedIntents.length * 100
-          + preferenceScore
-          + metadataMatches.length;
-      const score = hasMatch ? Math.max(1, rawScore) : 0;
-      return { skill, guard, explicit, score, matchedIntents, metadataMatches };
-    })
-    .filter((candidate) => candidate.guard.allowed)
-    .filter((candidate) => candidate.score > 0)
-    .sort((left, right) => right.score - left.score || left.skill.id.localeCompare(right.skill.id));
-  return { candidates, selected: candidates[0] };
-}
-
-function matchesIntentTerm(intentTokens, term) {
-  const termTokens = tokensFor(term);
-  return termTokens.size > 0 && [...termTokens].every((token) => intentTokens.has(token));
-}
-
 function explicitAllowedSkillRouteCandidate(intent, skillCandidates) {
   const intentKey = phraseKey(intent);
   return skillCandidates.find((candidate) => candidate.allowed && exactSkillIdMention(intentKey, candidate.skill_id));
@@ -66,7 +35,16 @@ function exactSkillIdMention(intentKey, skillId) {
   if (skillKey.length === 0) return false;
   const intentTokens = intentKey.split(" ");
   const skillTokens = skillKey.split(" ");
-  return intentTokens.some((_, index) => skillTokens.every((token, offset) => intentTokens[index + offset] === token));
+  const lastSkillToken = skillTokens.length - 1;
+  return intentTokens.some((_, index) => skillTokens.every((token, offset) => exactSkillTokenMatch(
+    intentTokens[index + offset], token, offset === lastSkillToken
+  )));
+}
+
+function exactSkillTokenMatch(intentToken, skillToken, allowCjkSuffix) {
+  if (intentToken === skillToken) return true;
+  if (!allowCjkSuffix || !intentToken?.startsWith(skillToken)) return false;
+  return CJK_SUFFIX.test(intentToken.slice(skillToken.length));
 }
 
 function capabilityRouteCandidates(workspace, workflow) {

package/src/route-tokens.mjs

@@ -32,24 +32,42 @@ const ROUTE_STOP_WORDS = new Set([
   "your"
 ]);
 
+const ASCII_ROUTE_TOKEN = /^[a-z0-9]+$/u;
+const CJK_ROUTE_TOKEN = /[\p{Script=Hangul}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
+
 export function tokensFor(value) {
   return new Set(String(value)
     .toLowerCase()
-    .split(/[^a-z0-9]+/u)
+    .split(/[^\p{L}\p{N}]+/u)
     .flatMap(tokenForms)
     .filter(isRouteToken));
 }
 
 function tokenForms(token) {
+  if (CJK_ROUTE_TOKEN.test(token)) {
+    return cjkTokenForms(token);
+  }
   const singular = singularRouteToken(token);
   return singular === token ? [token] : [token, singular];
 }
 
+function cjkTokenForms(token) {
+  const characters = [...token];
+  const forms = [token];
+  for (let index = 0; index < characters.length - 1; index += 1) {
+    forms.push(characters.slice(index, index + 2).join(""));
+  }
+  return forms;
+}
+
 export function canonicalRouteToken(token) {
   return singularRouteToken(token);
 }
 
 function singularRouteToken(token) {
+  if (!ASCII_ROUTE_TOKEN.test(token)) {
+    return token;
+  }
   if (token.length > 4 && token.endsWith("ies")) {
     return `${token.slice(0, -3)}y`;
   }
@@ -60,7 +78,7 @@ function singularRouteToken(token) {
 }
 
 function isRouteToken(token) {
-  return token.length > 1 && !ROUTE_STOP_WORDS.has(token);
+  return (token.length > 1 || CJK_ROUTE_TOKEN.test(token)) && !ROUTE_STOP_WORDS.has(token);
 }
 
 export function phraseKey(value) {