agent-skillboard 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## Unreleased
 
+## 0.3.4 — 2026-07-21
+
+### Fixed
+
+- Separated generated-inventory integrity failures from sorted stale
+  removed-skill policy observations. Valid inventory now keeps doctor, status,
+  brief, strict health, and observed-skill routing healthy while absent skills
+  remain guard-denied and available for explicit, confirmation-required policy
+  forget actions.
+
+## 0.3.3 — 2026-07-15
+
+### Added
+
+- Added deterministic Unicode intent tokenization with whole-run and character
+  bigram matching for legacy v1 compatibility routing.
+
+### Changed
+
+- Removed v2 request tokenization, metadata scoring, ranked hints, and
+  deterministic recommendations. Route and brief now return raw eligible skill
+  descriptions and saved preferences for the active model to interpret.
+- Made route, can-use, and guard errors explain whether the detected policy
+  expects v2 `--agent` or v1 `--workflow`, including the v1 migration preview.
+
+### Fixed
+
+- Preserved legacy v1 explicit skill-id selection when an ASCII id is
+  immediately followed by a Hangul or CJK particle, without allowing Latin
+  prefix matches.
+
 ## 0.3.2 — 2026-07-14
 
 ### Changed

package/README.md

@@ -6,10 +6,11 @@ SkillBoard gives AI agents one small user-level policy for installed skills:
 2. Keep an enabled skill agent-local or shared across agents.
 
 Valid installed skills default to enabled and agent-local. Sharing is opt-in per
-skill. Optional preference ranks enabled skills installed for the current agent
-and never changes availability or copies files.
+skill. The model makes semantic skill choices from the request, eligible skill
+descriptions, and raw saved preferences. SkillBoard does not tokenize, score,
+match, or recommend from v2 request text.
 
-Status: public alpha. Package 0.3.2 writes policy schema v2.
+Status: public alpha. Package 0.3.4 writes policy schema v2.
 
 <p align="center">
   <img src="https://raw.githubusercontent.com/NyXXiR/skillboard/main/skillboard.png" alt="SkillBoard architecture diagram" width="100%">
@@ -128,8 +129,9 @@ destructive actions, and secrets.
 From any working directory, an agent can:
 
 1. Read `skillboard brief --intent <request> --agent <agent> --json`.
-2. Select an enabled skill installed for that agent, using preference only to
-   rank matches.
+2. Select the best eligible skill from the full request, descriptions, local
+   instructions, and raw saved preferences, or use no skill. The model itself
+   interprets explicit user direction and preference semantics.
 3. Run `skillboard guard use <skill-id> --agent <agent> --json` before use.
 4. Work without another approval when the guard allows use.
 5. Ask after completion only if remembering a preference would help.
@@ -151,8 +153,8 @@ current action, runs `skillboard apply-action <action-id> --agent <agent> --yes
 rereads the returned post-apply brief.
 
 This is the distinction from a pure distribution tool: skills stay local by
-default, users promote only selected skills to shared use, and routing preference
-can be remembered without changing installation or availability.
+default, users promote only selected skills to shared use, and a model-facing
+preference can be remembered without changing installation or availability.
 
 ## Migrate version 1
 
@@ -190,6 +192,15 @@ skillboard skill forget <skill-id>
 `forget` never deletes skill files. It refuses skills that are still observed or
 shared, so shared skills must be unshared first.
 
+A valid generated inventory remains healthy when it no longer observes an
+unshared policy entry. Doctor/status expose sorted entries as
+`inventory.stalePolicySkills`; brief exposes the same observation as
+`health.inventory.stale_policy_skills`. Stale removed-skill policy does not fail
+strict health, change passed mode, or block other observed skills. The absent
+skill itself remains unavailable to route and guard. SkillBoard never deletes
+these entries automatically: review one current forget action, confirm it, and
+then reread the returned brief.
+
 Before removing the SkillBoard package, preview and apply the complete
 user-level cleanup:
 

package/docs/ai-skill-routing-goal.md

@@ -7,16 +7,23 @@ cross-agent sharing, and overlap routing. It asks only two policy questions:
 2. Should SkillBoard share this skill with other supported agents?
 
 Installed, valid skills default to enabled and agent-local. A user may disable
-a skill or opt that individual skill into sharing. An optional preference ranks
-enabled candidates that are actually installed for the current agent;
-preference never changes availability or copies files.
+a skill or opt that individual skill into sharing. An optional preference is
+returned as raw context beside eligible skills; it never changes availability
+or copies files.
+
+The active model owns all v2 semantic skill selection. SkillBoard returns the
+request unchanged with enabled skills installed for the current agent, their
+descriptions, and raw saved preferences. It does not tokenize, normalize,
+score, match, or recommend from v2 request text. The model interprets Korean,
+explicit user direction, and preferences directly, and may choose no skill.
 
 ## Product loop
 
 Preserve `observe → route → work → explain briefly → ask after → remember`.
 Ordinary work must not stop for source review or pre-task configuration. Read
-the current brief when skills overlap, run the guard before use, and ask
-once only before a persistent policy change.
+the current brief when skills overlap, make the semantic choice in the active
+model, run the guard before use, and ask once only before a persistent policy
+change.
 
 ## Boundaries
 
@@ -55,8 +62,8 @@ unknown future ambiguity unchanged for an explicit decision.
 Every route, brief, guard, dashboard, generated bridge, and policy mutation must
 project the same v2 meaning. Normal commands use one home control plane from any
 working directory; project initialization is not part of the v2 flow. Never
-reintroduce source reputation, workflow scope, or legacy state fields as hidden
-authorization checks.
+reintroduce source reputation, workflow scope, v2 tokenizers or metadata scores,
+or legacy state fields as hidden authorization or semantic-selection checks.
 
 Version 1 is migration input only. It has a one-release read-only window in the
 v0.3 release and is removed in v0.4.0.

package/docs/policy-model.md

@@ -24,7 +24,7 @@ compatible copies for other supported agents.
 
 ## Optional routing preference
 
-Preference ranks enabled skills installed for the current agent. It never
+Preference is raw context shown to the model for an eligible skill. It never
 changes availability and never shares files.
 
 ```yaml
@@ -38,8 +38,10 @@ changes availability and never shares files.
       priority: 100
 ```
 
-An explicit user selection wins when the guard allows it. A high priority cannot
-enable a disabled skill or make a skill appear on an agent where it is absent.
+The model interprets explicit user selection and saved preference semantics from
+the full request. SkillBoard does not match the `intents` strings or use
+`priority` as a score in v2. A high priority cannot enable a disabled skill or
+make a skill appear on an agent where it is absent.
 
 ## Generated inventory
 
@@ -52,6 +54,15 @@ optional audit metadata and never determine availability. Runtime and action
 authorization are outside SkillBoard's scope and remain with the agent or
 harness.
 
+Generated-inventory integrity is separate from stale removed-skill policy.
+Missing, malformed, unsupported, duplicate, or internally inconsistent
+inventory remains a hard health failure. When inventory is valid, policy ids it
+does not observe are reported as sorted stale-policy observations without
+failing strict health, changing passed mode, or blocking other observed skills.
+The absent skill remains unavailable to route and guard. Stale policy is retained
+until an explicit, confirmation-required forget action removes only that policy
+entry; SkillBoard never auto-deletes it.
+
 ## Installation default
 
 A newly discovered valid skill receives `enabled: true` and `shared: false`.

package/docs/positioning.md

@@ -8,8 +8,10 @@ Its durable policy answers two questions:
 1. Is this skill enabled?
 2. Should this one skill remain agent-local or be shared across agents?
 
-Optional preference ranks enabled skills installed for the current agent and
-never changes availability.
+The active model chooses the best enabled skill installed for the current
+agent, or no skill, from raw descriptions and optional saved preferences.
+SkillBoard does not tokenize, score, or match v2 request text. Preference never
+changes availability.
 
 ## Difference from distribution tools
 

package/docs/reference.md

@@ -16,9 +16,9 @@ Source tree: replace `skillboard ` with `node bin/skillboard.mjs `.
 skillboard setup [--yes] [--agent codex[,claude,opencode,hermes]] [--skill-root <path>]
 skillboard inventory refresh [--config <path>] [--dry-run] [--json]
 skillboard brief [--agent codex|claude|opencode|hermes] [--intent <request>] [--include-actions] [--json]
-skillboard route <intent> --agent codex|claude|opencode|hermes [--json]
-skillboard can-use <skill-id> --agent codex|claude|opencode|hermes [--json]
-skillboard guard use <skill-id> --agent codex|claude|opencode|hermes [--json]
+skillboard route <intent> --agent <name> (v2 policy) | --workflow <name> (v1 policy) [--json]
+skillboard can-use <skill-id> --agent <name> (v2 policy) | --workflow <name> (v1 policy) [--json]
+skillboard guard use <skill-id> --agent <name> (v2 policy) | --workflow <name> (v1 policy) [--json]
 skillboard skill enable <skill-id> [--dry-run] [--json]
 skillboard skill disable <skill-id> [--dry-run] [--json]
 skillboard skill share <skill-id> [--dry-run] [--json]
@@ -50,12 +50,18 @@ non-symlinked path inside the invoking user's home, and persists the mapping in
 not authorization or policy. One root cannot be registered to two agents.
 
 Guard requires a valid inventory record, `enabled: true`, and the selected agent
-in `installed_on`. Optional preference ranks candidates but never changes
-availability.
+in `installed_on`. For v2 routing, SkillBoard returns the request plus raw
+eligible skill descriptions and saved preferences. It does not tokenize, score,
+match, or recommend from request text. The active model interprets explicit
+direction and preferences, chooses a skill or no skill, then runs guard.
+Preference never changes availability.
 
 Version 2 route, can-use, and guard require `--agent`; generated agent guidance
 passes it automatically. This prevents one agent from selecting another
 agent's local-only skill without adding a user prompt to the normal flow.
+Version 1 compatibility policy uses `--workflow` instead. Passing the selector
+for the other policy version exits with guidance for the detected version and,
+for v1, the exact `migrate v2` preview command.
 
 ## Config schema v2
 
@@ -79,8 +85,8 @@ skills:
 - `enabled` and `shared` are required Booleans.
 - `shared: false` means agent-local; `shared: true` enables managed cross-agent
   copies while preserving the original.
-- `preference` is optional and ranks enabled skills installed for the current
-  agent only.
+- `preference` is optional raw context for model selection when the skill is
+  enabled and installed for the current agent. SkillBoard does not score it.
 - Unknown policy keys are rejected.
 - Skill ids use letters, numbers, `.`, `_`, `:`, and `-`; path-like ids are rejected.
 - A valid newly discovered skill defaults to enabled and agent-local.
@@ -97,6 +103,17 @@ provenance, digests, aliases, install units, and runtime-component observations.
 Only `installed_on` participates in the presence check. Other observations are
 optional audit metadata and never determine availability.
 
+Missing, invalid JSON, unsupported flags or format, duplicate records, and
+malformed records are generated-inventory integrity failures. With an otherwise
+valid inventory, policy ids absent from inventory are instead sorted,
+non-blocking stale-policy observations. Doctor/status return them in
+`inventory.stalePolicySkills`; brief returns them in
+`health.inventory.stale_policy_skills`. They do not fail strict health or stop
+observed skills from routing and guard, while the specifically absent skill
+remains unavailable. No command automatically removes stale policy. A current
+`v2:forget-skill:<skill-id>` action requires explicit confirmation, refuses
+installed or shared skills, and changes policy only.
+
 Runtime and action authorization are outside SkillBoard's scope. The active
 agent or harness owns permission checks for hooks, MCP servers, commands,
 network access, external writes, destructive operations, and secrets.

package/docs/routing.md

@@ -4,16 +4,22 @@ Routing chooses among skills already available to the current agent. Guard
 decides availability from valid generated inventory, `enabled`, and
 `installed_on`; routing cannot override that verdict.
 
-## Resolution order
+## v2 resolution order
 
 1. Remove skills missing valid inventory records.
 2. Remove disabled skills.
 3. Remove skills not installed for the selected agent.
-4. Honor an explicit user-selected skill if it remains eligible.
-5. Rank intent matches by optional preference and priority.
-6. Return one recommendation and ordered fallbacks.
-
-Preference ranks only and never changes availability.
+4. Return every remaining skill's id, name, description, path, and raw optional
+   preference beside the request.
+5. Let the active model interpret the full request, explicit user direction,
+   descriptions, instructions, and preferences and choose a skill or no skill.
+6. Guard the model-selected skill immediately before use.
+
+V2 has no intent tokenizer, metadata score, request matcher, ranked candidates,
+or deterministic recommendation. Korean and other languages are handled by the
+foundation model. Preference is raw model context and never changes
+availability. Version 1 compatibility routing retains its deterministic
+tokenizer until the v1 reader is removed in v0.4.0.
 
 ```bash
 skillboard brief --intent "write tests" --agent codex --json
@@ -26,8 +32,13 @@ These commands use `~/skillboard.config.yaml` and
 `--config` and `--skills` overrides remain available for migration, testing,
 and legacy workspaces.
 
-When guard allows use, continue without another approval. Ask after completion
-only when remembering a preference would reduce future ambiguity.
+When guard allows use, continue without another approval. If the model-selected
+choice was ambiguous, finish first and ask afterward only when remembering a
+preference would reduce future ambiguity.
+
+Version 1 compatibility routing remains workflow-driven and may return a
+deterministic capability route. It asks for clarification when no workflow
+route matches.
 
 Source and provenance findings are optional audit metadata and never determine
 availability. Runtime and action authorization are outside SkillBoard's scope.

package/docs/user-flow.md

@@ -41,8 +41,11 @@ skillboard guard use <skill-id> --agent codex --json
 ```
 
 The guard allows an enabled skill only when generated inventory records it on
-the selected agent. Preference ranks matching candidates and never changes
-availability. Allowed use does not require another confirmation.
+the selected agent. SkillBoard returns raw eligible descriptions and saved
+preferences without tokenizing, scoring, or matching the request. The model
+interprets the full request, explicit direction, and preferences and chooses a
+skill or no skill. Preference never changes availability. Allowed use does not
+require another confirmation.
 
 ## 3. Change one decision
 
@@ -65,9 +68,10 @@ returned post-apply brief. Cached action ids are not reused.
 
 ## 4. Ask after, then remember
 
-When a route was ambiguous, the agent finishes first. It may then ask whether to
-remember an intent preference. Preference affects ordering only; it does not
-share, enable, disable, install, or remove a skill.
+When a model-selected route was ambiguous, the agent finishes first. It may then
+ask whether to remember an intent preference. Preference becomes raw context
+for later model selection; it does not share, enable, disable, install, or
+remove a skill.
 
 ## 5. Audit separately
 

package/docs/value-proof.md

@@ -12,7 +12,11 @@ node --test test/v2-agent-sharing.test.mjs test/v2-onboarding-behavior.test.mjs
 - Valid discovered skills default to enabled and agent-local.
 - Disabled skills and skills absent from the selected agent are denied.
 - Share and unshare preserve agent-owned originals.
-- Optional preference changes ranking without changing availability.
+- V2 returns raw eligible descriptions and preferences without interpreting
+  request text or producing a recommendation.
+- Korean, explicit skill direction, and saved preference semantics remain owned
+  by the active model.
+- Optional preference never changes availability.
 - Source and provenance audits do not change guard results.
 - Commands produce the same result from different working directories.
 - Version 1 project policy remains read-only until explicit migration; setup

package/docs/variant-lifecycle.md

@@ -3,7 +3,8 @@
 A variant is a manual content adaptation with snapshot and digest history. The
 lifecycle does not authorize availability. A registered variant is usable only
 according to its ordinary v2 `enabled` entry and generated installation
-presence; optional preference ranks it and never changes availability.
+presence; optional preference is raw model context and never changes
+availability.
 
 ## Current v2 boundary
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-skillboard",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Keep agent skills broadly available while routing overlaps consistently.",
   "keywords": [
     "ai-agent",

package/src/advisor/guidance.mjs

@@ -3,7 +3,7 @@ import { command } from "./action-core.mjs";
 const GUARD_WHEN = "immediately before skill use";
 const GOAL_DOCUMENT = Object.freeze({
   path: "docs/ai-skill-routing-goal.md",
-  purpose: "Preserve SkillBoard v2 as a user-level control plane: enable or disable a skill, opt individual skills into cross-agent sharing, and use optional preference only to rank available overlaps.",
+  purpose: "Preserve SkillBoard v2 as a user-level control plane: enable or disable a skill, opt individual skills into cross-agent sharing, and expose optional preference as raw context for the active model.",
   loop: Object.freeze([
     "observe",
     "route",
@@ -140,14 +140,22 @@ function recommendedNextStep(status, brief, choices, route = null) {
   switch (status) {
     case "ready":
       if (route !== null) {
+        if (route.model_selection_required === true) {
+          return modelSelectionStep(route);
+        }
         return route.recommended_skill === null
-          ? "Ask a clarifying question; no workflow capability matched this request."
+          ? route.workflow === null
+            ? "No enabled skill is available for this request."
+            : "Ask a clarifying question; no workflow capability matched this request."
           : `Use ${route.recommended_skill} for this request after the guard check passes${postUsePolicyStep(route)}.`;
       }
       return availableSkillCount(brief) === 0
         ? "No policy change is required; valid installed skills default to enabled and agent-local."
         : "Run the guard check immediately before using any selected skill.";
     case "needs-decision":
+      if (route?.model_selection_required === true) {
+        return `${modelSelectionStep(route)} Handle pending review decisions after the task unless a policy-changing action is needed now.`;
+      }
       if (route?.recommended_skill !== null && route?.guard_allowed === true) {
         return route.post_use_policy_suggestion === null
           ? `Use ${route.recommended_skill} for this request after the guard check passes; handle pending review decisions after the task unless a policy-changing action is needed now.`
@@ -180,6 +188,10 @@ function recommendedNextStep(status, brief, choices, route = null) {
   }
 }
 
+function modelSelectionStep(route) {
+  return "Choose the best enabled, installed skill from the request's semantic context, skill descriptions, and raw saved preferences. Run its guard before use, or continue without a skill when none fits.";
+}
+
 function postUsePolicyStep(route) {
   return route.post_use_policy_suggestion === null
     ? ""
@@ -197,6 +209,8 @@ function routeGuidance(route) {
     matched_terms: route.matched_terms,
     recommendation_reason: route.recommendation_reason,
     recommended_skill: route.recommended_skill,
+    selection_mode: route.selection_mode ?? null,
+    model_selection_required: route.model_selection_required ?? false,
     fallback_skills: route.fallback_skills,
     route_candidates: (route.route_candidates ?? []).map((candidate) => ({
       skill: candidate.skill,
@@ -216,6 +230,10 @@ function routeGuidance(route) {
     guard_reasons: route.guard?.reasons ?? [],
     possible_skills: route.possible_skills.map((skill) => ({
       id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      path: skill.path,
+      preference: skill.preference,
       category: skill.category,
       allowed: skill.allowed
     }))

package/src/advisor/schema.mjs

@@ -93,7 +93,8 @@ export function healthFromDoctor(doctor, paths) {
       required: true,
       ok: doctor.inventory.ok,
       path: doctor.inventory.path,
-      errors: sortedStrings(doctor.inventory.errors)
+      errors: sortedStrings(doctor.inventory.errors),
+      stale_policy_skills: sortedStrings(doctor.inventory.stalePolicySkills ?? [])
     };
   }
   return health;

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

@@ -53,6 +53,7 @@ export function renderSkillBrief(brief, options = {}) {
   }
   emitIntentRoute(lines, brief);
   emitPolicyHealth(lines, brief);
+  emitStalePolicy(lines, brief);
   emitCategorySummary(lines, brief);
   emitNextAction(lines, brief, { verbose });
   emitAvailableNowSection(lines, brief, { verbose });
@@ -84,7 +85,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
@@ -109,6 +110,19 @@ function emitPolicyHealth(lines, brief) {
   lines.push("");
 }
 
+function emitStalePolicy(lines, brief) {
+  const skills = brief.health?.inventory?.stale_policy_skills ?? [];
+  if (skills.length === 0) {
+    return;
+  }
+  lines.push("## Stale removed-skill policy", "");
+  lines.push("These policy entries are retained for explicit review and do not block other installed skills.");
+  for (const skill of skills) {
+    lines.push(`- ${safeText(skill)}`);
+  }
+  lines.push("");
+}
+
 function emitPolicyDiagnostics(lines, label, diagnostics) {
   if (diagnostics.length === 0) {
     return;

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("");
@@ -1689,6 +1709,8 @@ function renderDoctorSummary(result) {
     `SkillBoard doctor: ${status}`,
     renderInstallation(result.installation),
     `Workspace: ${result.workspace.skills.declared} skills, ${result.workspace.workflows} workflows, ${result.workspace.harnesses} harnesses, ${result.workspace.installUnits.total} install units`,
+    `Inventory integrity: ${result.inventory.ok ? "passed" : "failed"} (${result.inventory.errors.length} errors)`,
+    `Stale removed-skill policy: ${result.inventory.stalePolicySkills.length}`,
     `Source audit: ${result.sources.ok ? "passed" : "failed"} (${result.sources.errors.length} errors, ${result.sources.warnings.length} warnings, ${result.sources.blockingWarnings.length} blocking)`,
     `Policy: ${result.policy.ok ? "passed" : "failed"} (${result.policy.errors.length} errors, ${result.policy.warnings.length} warnings)`
   ];
@@ -1726,6 +1748,8 @@ function renderDoctor(result) {
     `Config: ${result.config.exists ? result.config.valid ? `valid v${result.config.version}` : `invalid (${result.config.error})` : "missing"}`,
     `Bridge: ${bridges}`,
     `Workspace: ${result.workspace.skills.declared} declared skills, ${result.workspace.skills.installed} installed skills, ${result.workspace.workflows} workflows, ${result.workspace.harnesses} harnesses, ${result.workspace.installUnits.total} install units`,
+    `Inventory integrity: ${result.inventory.ok ? "passed" : "failed"} (${result.inventory.errors.length} errors)`,
+    `Stale removed-skill policy (${result.inventory.stalePolicySkills.length}): ${formatList(result.inventory.stalePolicySkills)}`,
     `Skill states: ${renderCounts(result.workspace.skills.byStatus)}`,
     `Invocations: ${renderCounts(result.workspace.skills.byInvocation)}`,
     `Source classes: ${renderCounts(result.workspace.installUnits.bySourceClass)}`,
@@ -1804,9 +1828,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 +1842,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 +2079,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 +2097,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 +2146,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 +2154,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/doctor.mjs

@@ -47,7 +47,7 @@ export async function doctorProject(options = {}) {
     bridges,
     installation,
     workspace: emptyWorkspaceSummary(),
-    inventory: { required: false, ok: true, path: null, errors: [] },
+    inventory: { required: false, ok: true, path: null, errors: [], stalePolicySkills: [] },
     policy: { ok: false, errors: [], warnings: [] },
     sources: { checked: false, verified: options.verifySources === true, ok: false, errors: [], warnings: [], blockingWarnings: [], units: [] },
     uninstall,
@@ -136,12 +136,9 @@ function doctorRecommendations(result) {
   const recommendations = [];
   if (!result.inventory.ok) {
     recommendations.push("run skillboard inventory refresh and fix generated inventory integrity errors");
-    for (const error of result.inventory.errors) {
-      const match = /^skill (?<skill>[^ ]+) is missing from generated inventory$/u.exec(error);
-      if (match?.groups?.skill !== undefined) {
-        recommendations.push(`reinstall ${match.groups.skill} or run skillboard skill forget ${match.groups.skill}`);
-      }
-    }
+  }
+  for (const skill of result.inventory.stalePolicySkills) {
+    recommendations.push(`reinstall ${skill} or run skillboard skill forget ${skill}`);
   }
   if (!result.bridges.some((bridge) => bridge.status === "installed")) {
     recommendations.push("legacy project bridge blocks are absent; run skillboard init only if maintaining deprecated project-local policy");
@@ -176,20 +173,22 @@ function doctorRecommendations(result) {
 
 function inventoryHealth(workspace) {
   if (workspace.version !== 2) {
-    return { required: false, ok: true, path: null, errors: [] };
+    return { required: false, ok: true, path: null, errors: [], stalePolicySkills: [] };
   }
   const errors = [...(workspace.inventory?.integrityErrors ?? ["generated inventory is unavailable"])];
   const observed = new Set(workspace.inventory?.skillIds ?? []);
-  for (const skill of workspace.skills) {
-    if (!observed.has(skill.id)) {
-      errors.push(`skill ${skill.id} is missing from generated inventory`);
-    }
-  }
+  const stalePolicySkills = errors.length === 0
+    ? workspace.skills
+      .map((skill) => skill.id)
+      .filter((skillId) => !observed.has(skillId))
+      .sort((left, right) => left.localeCompare(right))
+    : [];
   return {
     required: true,
     ok: errors.length === 0,
     path: workspace.inventory?.path ?? null,
-    errors
+    errors,
+    stalePolicySkills
   };
 }
 

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/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) {

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
   };
 }