@kontextmind/kxm 0.7.144 → 0.7.146

package/plugins/kxm/dist/server.js

@@ -14958,6 +14958,7 @@ var MODES = Object.freeze(["headless", "interactive", "either"]);
 var MODEL_KEYS = Object.freeze([
   "schema",
   "id",
+  "aliases",
   "harness",
   "model",
   "vendor",
@@ -14996,8 +14997,51 @@ var FALLBACK_REVERT = Object.freeze(["next_run", "never"]);
 var ROSTER_ENTRY_KEYS = Object.freeze(["route", "effort", "mode"]);
 var CRITIC_PURPOSES = Object.freeze(["reviewer-arch", "reviewer-cli"]);
 
-// plugins/kxm/src/template.ts
+// plugins/kxm/src/workforce-names.mjs
 var import_yaml2 = __toESM(require_dist(), 1);
+var ROLE_IDS = Object.freeze([
+  "writer",
+  "planner",
+  "reviewer-arch",
+  "reviewer-cli",
+  "experiment"
+]);
+var ROUTE_RENAMES = Object.freeze([
+  ["grok-native", "grok-grok-4-7"],
+  ["qwen-openrouter-pi", "pi-qwen3-coder-plus-openrouter"],
+  ["gemini-agy", "agy-gemini-3-8-flash-high"],
+  ["fable-claude", "claude-fable"],
+  ["sol-codex", "codex-gpt-5-6-sol"],
+  ["grok-default", "grok-grok-4-6"],
+  ["fable-default", "claude-fable"]
+]);
+var AGENT_RENAMES = Object.freeze([
+  ["coordinator", "planner"],
+  ["implementer", "writer"],
+  ["critic-arch", "reviewer-arch"],
+  ["critic-cli", "reviewer-cli"]
+]);
+var WORKFLOW_RENAMES = Object.freeze([
+  ["implement-only", "writer-only"],
+  ["review-arch-only", "reviewer-arch-only"],
+  ["review-cli-only", "reviewer-cli-only"]
+]);
+var STEP_RENAMES = Object.freeze([
+  ["implement", "writer"],
+  ["critic-arch", "reviewer-arch"],
+  ["review-arch", "reviewer-arch"],
+  ["critic-cli", "reviewer-cli"],
+  ["review-cli", "reviewer-cli"]
+]);
+var RENAMES = Object.freeze({
+  route: ROUTE_RENAMES,
+  agent: AGENT_RENAMES,
+  workflow: WORKFLOW_RENAMES,
+  step: STEP_RENAMES
+});
+
+// plugins/kxm/src/template.ts
+var import_yaml3 = __toESM(require_dist(), 1);
 
 // plugins/kxm/src/repo-root.ts
 import { existsSync } from "node:fs";
@@ -18253,7 +18297,7 @@ function explainContextItem(id, pool) {
 }
 
 // plugins/kxm/src/memory.ts
-var import_yaml3 = __toESM(require_dist(), 1);
+var import_yaml4 = __toESM(require_dist(), 1);
 import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
 import { extname as extname2, join as join3, resolve as resolve2 } from "node:path";
 var MEMORY_SCHEMA = "kxm.memory.v1";
@@ -18285,7 +18329,7 @@ function parseFrontmatter(content) {
 }
 function parseMemoryRecord(raw, filename = "memory.md") {
   const { frontmatter, body } = parseFrontmatter(raw);
-  const data = (0, import_yaml3.parse)(frontmatter);
+  const data = (0, import_yaml4.parse)(frontmatter);
   if (!data || typeof data !== "object" || Array.isArray(data)) {
     throw new Error(`invalid YAML frontmatter in ${filename}`);
   }
@@ -18622,7 +18666,7 @@ function boundedRefs(value, field) {
 }
 
 // plugins/kxm/src/skills.ts
-var import_yaml4 = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, renameSync, rmSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname4, join as join4 } from "node:path";
@@ -18666,7 +18710,7 @@ function parseSkillFrontmatter(content) {
     return { frontmatter: null, body: content };
   }
   try {
-    const parsed = (0, import_yaml4.parse)(rawFm);
+    const parsed = (0, import_yaml5.parse)(rawFm);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return { frontmatter: parsed, body: rawBody };
     }

package/plugins/kxm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-plugin",
-  "version": "0.7.144",
+  "version": "0.7.146",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/skills/kxm-project-setup/SKILL.md

@@ -22,7 +22,7 @@ to run in their own terminal or in Claude Code.
    `ready`, `repair`, or `legacy`, and `issues` lists anything to fix first.
 2. `kxm init --name "<display name>"` prints
    `initialized KXM project at <root>`. It writes `.kxm/project.yaml`,
-   `.kxm/agents/coordinator.yaml`, `.kxm/agents/implementer.yaml`,
+   `.kxm/agents/planner.yaml`, `.kxm/agents/writer.yaml`,
    `.kxm/gates.yaml`, `.kxm/repo/repo.yaml`, `.kxm/template-provenance.yaml`,
    and `.kxm/workflows/default.yaml`. Outside Git it fails with
    `git_root_required`. In an existing project, plain `kxm init` validates,
@@ -44,7 +44,7 @@ After the user's commit:
 1. `kxm workflow add first --template spec-and-plan` prints
    `Added workflow 'first' to local (<root>/.kxm/workflows/first.yaml)`. Add
    `--dry-run` first to see the path without writing. The template has two
-   steps, `plan` then `review-arch`, both run by the `coordinator` agent with
+   steps, `plan` then `reviewer-arch`, both run by the `planner` agent with
    `repositories: control: read`. It writes nothing and runs no test command,
    and a failed review goes back to `plan` at most twice.
 2. `kxm init` validates it and prints `validated KXM project at <root>`.
@@ -71,7 +71,7 @@ After the user's commit:
 4. `kxm runs status <runId>` prints `created`.
 5. `kxm runs drive <runId> --simulated --wait --timeout-ms 60000` prints a
    `kxm.drive-receipt.v1` whose settlement is terminal `completed`, and exits 0.
-   The run moves from `plan` to `review-arch` to `completed`. Always pass
+   The run moves from `plan` to `reviewer-arch` to `completed`. Always pass
    `--simulated`; without it, drive calls live harnesses.
 6. `kxm runs status <runId>` prints `completed … (receipt verified)`.
 7. `kxm runs receipt <runId>` and `kxm runs list`. Cancel a stuck run with

package/plugins/kxm/src/cli/project.ts

@@ -11,6 +11,7 @@ import { runVisionGate } from "../vision-gate.ts";
 import {
   KxmConfigError,
   discoverKxmProjectRoot,
+  lookupKxmResource,
   type KxmInitializationPlan,
 } from "../project-config.ts";
 import { initializeKxmProject } from "../init.ts";
@@ -439,7 +440,7 @@ export function resolveKxmRunTarget(
   }
   const bundle = loadKxmProject(projectRoot, {});
   const workflowId = workflow ?? String(bundle.project.value.defaultWorkflow ?? "default");
-  if (!bundle.workflows.has(workflowId)) {
+  if (!lookupKxmResource(bundle.workflows.values(), workflowId, "workflow")) {
     print(runtime.io, runtime.json, { ok: false, command: "run", error: "run_workflow_unknown", workflow: workflowId, ...envelope }, `workflow ${workflowId} does not exist in this project`);
     return 1;
   }

package/plugins/kxm/src/cli/roles.ts

@@ -15,6 +15,7 @@ import {
   type KxmRoleDefinition,
 } from "../role.ts";
 import { discoverKxmProjectRoot, kxmRoleWriteIssues } from "../project-config.ts";
+import { findYamlBasename } from "../workforce-names.mjs";
 import { ensureKxmSupervisor, kxmRuntimeRequest } from "../runtime-supervisor.ts";
 import { projectRuntimeOwnsRun } from "../runtime-store.ts";
 import { resumeWorkflowFromRuling, type WorkflowRun } from "../workflow.ts";
@@ -185,8 +186,7 @@ export async function cmdRoleAdd(
   // after its roster is parsed, for both local and global scope.
   const projectRoot = discoverKxmProjectRoot(runtime.cwd) ?? runtime.cwd;
   const refuseMissingRoute = (routeId: string): boolean => {
-    const modelFile = join(projectRoot, ".kxm", "models", `${routeId}.yaml`);
-    if (existsSync(modelFile)) return false;
+    if (findYamlBasename(join(projectRoot, ".kxm", "models"), routeId, "route")) return false;
     runtime.io.stderr(`kxm: route '${routeId}' is not a file under .kxm/models/\n`);
     return true;
   };
@@ -398,8 +398,7 @@ export async function cmdRoleModify(
   if (options.addRoute) {
     const routeId = options.addRoute;
     const projectRoot = discoverKxmProjectRoot(runtime.cwd) ?? runtime.cwd;
-    const modelFile = join(projectRoot, ".kxm", "models", `${routeId}.yaml`);
-    if (!existsSync(modelFile)) {
+    if (!findYamlBasename(join(projectRoot, ".kxm", "models"), routeId, "route")) {
       runtime.io.stderr(`kxm: route '${routeId}' is not a file under .kxm/models/\n`);
       return 1;
     }

package/plugins/kxm/src/engine.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
 import { listRoleBindings, loadRoutePolicy } from "./routes.ts";
+import { findYamlBasename } from "./workforce-names.mjs";
 import { applyAuthoringWitness, captureWorktreeWitness } from "./worktree-witness.ts";
 import {
   buildFormalContextPacket,
@@ -101,7 +102,7 @@ import {
   type KxmRunRecord,
   type KxmRunStatus,
 } from "./runtime-store.ts";
-import { KxmConfigError, kxmCanonicalJson, type JsonValue, type KxmProjectBundle } from "./project-config.ts";
+import { KxmConfigError, kxmCanonicalJson, lookupKxmResource, type JsonValue, type KxmProjectBundle } from "./project-config.ts";
 import { evaluateArtifactsGate } from "./engine-artifacts.ts";
 import { createCommandObserver } from "./engine-command.ts";
 import {
@@ -277,7 +278,7 @@ export function pinKxmCompiledPlan(
     if (String(bundle.project.value.id) !== run.projectId) {
       throw runtimeError("run_owner_mismatch", runId, "bundle project does not match the run");
     }
-    const workflow = bundle.workflows.get(run.workflowId);
+    const workflow = lookupKxmResource(bundle.workflows.values(), run.workflowId, "workflow");
     if (!workflow) throw runtimeError("run_workflow_unknown", run.workflowId, `workflow ${run.workflowId} does not exist in this project`);
     const revisions = kxmPolicyRevisions(bundle, options);
     if (
@@ -1397,7 +1398,8 @@ function resolveProducerRoute(
       },
     };
   }
-  const agent = readYamlFile(join(projectRoot, ".kxm", "agents", `${agentId}.yaml`));
+  const agentFile = findYamlBasename(join(projectRoot, ".kxm", "agents"), agentId, "agent") ?? agentId;
+  const agent = readYamlFile(join(projectRoot, ".kxm", "agents", `${agentFile}.yaml`));
   const role = typeof agent?.role === "string" ? agent.role : "";
   if (!role) {
     return {
@@ -1424,7 +1426,8 @@ function resolveProducerRoute(
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
     const record = entry as { route?: unknown; effort?: unknown };
     if (typeof record.route !== "string" || record.route.length === 0) continue;
-    const modelPath = join(projectRoot, ".kxm", "models", `${record.route}.yaml`);
+    const routeFile = findYamlBasename(join(projectRoot, ".kxm", "models"), record.route, "route") ?? record.route;
+    const modelPath = join(projectRoot, ".kxm", "models", `${routeFile}.yaml`);
     const doc = readModelDocument(modelPath);
     if (!doc) {
       return {
@@ -1487,7 +1490,7 @@ function resolveProducerRoute(
       model: selector.slice(slash + 1),
       selector,
       harness,
-      routeId: record.route,
+      routeId: routeFile,
       role,
       permissions,
       ...(typeof record.effort === "string" ? { effort: record.effort } : {}),
@@ -2871,7 +2874,7 @@ export function kxmLiveRunPrerequisites(
   workflowId: string,
   projectRoot: string,
 ): KxmRunHandoff[] {
-  const workflow = bundle.workflows.get(workflowId);
+  const workflow = lookupKxmResource(bundle.workflows.values(), workflowId, "workflow");
   if (!workflow) throw runtimeError("run_workflow_unknown", workflowId, `workflow ${workflowId} does not exist in this project`);
   const plan = compileKxmWorkflow({ id: workflowId, value: workflow.value, logicalPath: workflow.logicalPath });
   const envelope = { plan, projectLimits: kxmProjectAdmissionLimits(bundle), gates: pinnedGatesForCompiledPlan(plan, bundle, projectRoot) };

package/plugins/kxm/src/mcp-server.ts

@@ -11,7 +11,7 @@ import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 import { sessionTokenFixHint } from "./session-token-hint.ts";
 
-const VERSION = "0.7.144";
+const VERSION = "0.7.146";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();

package/plugins/kxm/src/policy-draft.mjs

@@ -20,7 +20,7 @@ const TOKEN = /[\s\x00-\x1f]/u;
 const EFFORTS = Object.freeze(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODES = Object.freeze(["headless", "interactive", "either"]);
 const MODEL_KEYS = Object.freeze([
-  "schema", "id", "harness", "model", "vendor", "status", "permissions", "origin",
+  "schema", "id", "aliases", "harness", "model", "vendor", "status", "permissions", "origin",
   "thinking", "tags", "capabilities", "priority", "fallbacks", "limits",
 ]);
 const ROLE_KEYS = Object.freeze([
@@ -226,6 +226,9 @@ function validateModelShape(document, id, label, issues) {
   if (document.id !== undefined && document.id !== id) {
     issues.push(issue("schema", "identity_mismatch", label, `declared id ${String(document.id)} does not match ${id}`));
   }
+  if (document.aliases !== undefined && !identifierList(document.aliases)) {
+    issues.push(issue("schema", "schema_pattern", label, "aliases must be unique identifiers"));
+  }
   if (document.harness !== undefined && !identifier(document.harness)) {
     issues.push(issue("schema", "schema_pattern", label, "harness must be an identifier"));
   }
@@ -511,9 +514,12 @@ function validateRoleSemantics(role, id, label, models, options, issues) {
     const admitted = role.roster
       .map((entry) => models.get(entry.route))
       .filter((model) => model && admittedRoute(model));
-    if (admitted.length !== 1) {
-      issues.push(issue("semantic", "critic_route_count", label, "required critic purpose files must list exactly one admitted route"));
-    } else if (admitted[0].permissions.length !== 1 || admitted[0].permissions[0] !== "read-only" || role.permission !== "read-only") {
+    // The first roster entry is the required critic. Later entries are
+    // fallbacks so one provider outage does not stop the role. Every entry
+    // stays read-only; vendor independence uses the first entry only.
+    if (admitted.length < 1) {
+      issues.push(issue("semantic", "critic_route_count", label, "required critic purpose files must list at least one admitted route"));
+    } else if (role.permission !== "read-only" || admitted.some((model) => model.permissions.length !== 1 || model.permissions[0] !== "read-only")) {
       issues.push(issue("semantic", "permission_escalation", label, "critic purpose files must be read-only"));
     }
   }
@@ -549,7 +555,7 @@ function validateCriticVendors(roles, models, options, issues) {
     const admitted = (role.roster ?? [])
       .map((entry) => models.get(entry.route))
       .filter((model) => model && admittedRoute(model));
-    if (admitted.length === 1) critics.push({ purpose, vendor: canonicalVendor(admitted[0].vendor, aliases) });
+    if (admitted.length >= 1) critics.push({ purpose, vendor: canonicalVendor(admitted[0].vendor, aliases) });
   }
   if (critics.length === 2 && critics[0].vendor === critics[1].vendor) {
     issues.push(issue("semantic", "critic_vendor_collision", "roles/reviewer-arch", "required critics must have independent vendors"));

package/plugins/kxm/src/project-config.ts

@@ -11,6 +11,7 @@ import {
 } from "./restricted-yaml.mjs";
 import { pathToFileURL } from "node:url";
 import { validatePolicyDraft } from "./policy-draft.mjs";
+import { findYamlBasename, lintWorkforce, lookupById, noteDeprecatedId, STEP_RENAMES } from "./workforce-names.mjs";
 import { resolveKxmTemplateBaseline } from "./template.ts";
 import { findKxmRepoRoot } from "./repo-root.ts";
 import { BUILTIN_HARNESS_IDS, DEFAULT_HARNESS } from "./harness.ts";
@@ -590,6 +591,20 @@ function names(value: JsonValue | undefined): string[] {
   return Array.isArray(value) ? value.filter((candidate): candidate is string => typeof candidate === "string") : [];
 }
 
+/** Resolve an agent, workflow, or route, including a deprecated alias. */
+export function lookupKxmResource<T extends { id?: string; value: JsonObject }>(
+  resources: Iterable<T>,
+  requested: string,
+  kind: "agent" | "workflow" | "route",
+): T | undefined {
+  const records = [...resources].map((resource) => ({
+    id: resource.id,
+    aliases: names(resource.value.aliases),
+    resource,
+  }));
+  return lookupById(records, requested, kind)?.record.resource;
+}
+
 function mapResource(resource: KxmResource, map: Map<string, KxmResource>, issues: KxmConfigIssue[]): void {
   const id = resource.id;
   if (!id) return;
@@ -872,14 +887,31 @@ function validateWorkflow(
 ): void {
   const file = workflow.logicalPath;
   const coordinator = stringValue(workflow.value.coordinator) ?? "coordinator";
-  if (!agents.has(coordinator)) issues.push(issue("reference", "coordinator_unknown", file, `coordinator ${coordinator} does not exist`));
+  if (!lookupKxmResource(agents.values(), coordinator, "agent")) issues.push(issue("reference", "coordinator_unknown", file, `coordinator ${coordinator} does not exist`));
   const steps = valuesOf(workflow.value, "steps").map((candidate) => objectValue(candidate)).filter((candidate): candidate is JsonObject => Boolean(candidate));
   const stepIndex = new Map<string, number>();
+  const primarySteps = new Set<string>();
   for (const [index, step] of steps.entries()) {
     const id = stringValue(step.id);
     if (!id) continue;
     if (stepIndex.has(id)) issues.push(issue("semantic", "step_id_duplicate", file, `step ${id} is duplicated`));
-    else stepIndex.set(id, index);
+    else {
+      stepIndex.set(id, index);
+      primarySteps.add(id);
+    }
+  }
+  for (const [index, step] of steps.entries()) {
+    const id = stringValue(step.id);
+    if (!id) continue;
+    const aliases = new Set(names(step.aliases));
+    for (const [oldId, newId] of STEP_RENAMES) {
+      if (id === newId) aliases.add(oldId);
+      if (id === oldId) aliases.add(newId);
+    }
+    for (const alias of aliases) {
+      if (alias === id || primarySteps.has(alias) || stepIndex.has(alias)) continue;
+      stepIndex.set(alias, index);
+    }
   }
 
   for (const field of ["reproOracle", "planHash"] as const) {
@@ -910,7 +942,7 @@ function validateWorkflow(
     const kind = stringValue(step.kind);
     validateToolPolicy(workflow, objectValue(step.tools), `${stepId}.tools`, issues);
     const primaryAgentId = stringValue(step.agent);
-    if ((kind === "agent" || kind === "moa") && primaryAgentId && !agents.has(primaryAgentId)) {
+    if ((kind === "agent" || kind === "moa") && primaryAgentId && !lookupKxmResource(agents.values(), primaryAgentId, "agent")) {
       issues.push(issue("reference", "agent_unknown", file, `${stepId} references unknown agent ${primaryAgentId}`));
     }
     const gate = stringValue(step.gate);
@@ -938,7 +970,7 @@ function validateWorkflow(
     const declaredAgents = assignment ? names(assignment.allowedAgents) : [];
     const allowedAgents = declaredAgents.length > 0 ? declaredAgents : primaryAgentId ? [primaryAgentId] : [];
     for (const agentId of allowedAgents) {
-      const agent = agents.get(agentId);
+      const agent = lookupKxmResource(agents.values(), agentId, "agent");
       if (!agent) issues.push(issue("reference", "assignment_agent_unknown", file, `${stepId} allows unknown agent ${agentId}`));
       else {
         validateAgentScope(agent, step, repositories, file, stepId, issues);
@@ -1003,7 +1035,7 @@ function validateWorkflow(
       const producerMinimum = numberValue(policy.minimumProducers, 1);
       if (producerMinimum > target || producerMinimum > eligible.length) issues.push(issue("semantic", "producer_minimum_impossible", file, `${stepId}.${String(key)} producer minimum exceeds its eligible or target pool`));
       for (const agentId of eligible) {
-        if (!agents.has(agentId)) issues.push(issue("reference", "producer_agent_unknown", file, `${stepId}.${String(key)} references unknown producer ${agentId}`));
+        if (!lookupKxmResource(agents.values(), agentId, "agent")) issues.push(issue("reference", "producer_agent_unknown", file, `${stepId}.${String(key)} references unknown producer ${agentId}`));
         if (allowedAgents.length > 0 && !allowedAgents.includes(agentId)) issues.push(issue("semantic", "producer_agent_ineligible", file, `${stepId}.${String(key)} producer ${agentId} is outside allowedAgents`));
       }
       const degradation = objectValue(policy.degradation);
@@ -1026,6 +1058,10 @@ function validateWorkflow(
         if (parsed.terminalStatus === "completed") completedTerminalSources.add(index);
         continue;
       }
+      if (parsed.target && parsed.target !== "$terminal" && !primarySteps.has(parsed.target) && stepIndex.has(parsed.target)) {
+        const canonical = stringValue(steps[stepIndex.get(parsed.target) ?? -1]?.id);
+        if (canonical) noteDeprecatedId("step", parsed.target, canonical);
+      }
       const targetIndex = parsed.target === undefined ? undefined : stepIndex.get(parsed.target);
       if (targetIndex === undefined) {
         issues.push(issue("reference", "transition_target_unknown", file, `${stepId}.${outcome} references unknown target ${String(parsed.target)}`));
@@ -1195,7 +1231,7 @@ function validateBundle(
   validateModelReferences(models, issues);
 
   const defaultWorkflow = stringValue(project.value.defaultWorkflow) ?? "default";
-  if (!workflows.has(defaultWorkflow)) issues.push(issue("reference", "default_workflow_unknown", project.logicalPath, `default workflow ${defaultWorkflow} does not exist`));
+  if (!lookupKxmResource(workflows.values(), defaultWorkflow, "workflow")) issues.push(issue("reference", "default_workflow_unknown", project.logicalPath, `default workflow ${defaultWorkflow} does not exist`));
   for (const workflow of workflows.values()) validateWorkflow(workflow, agents, models, repositoryIds, gates, issues);
 
   // Developer policy is the role files under .kxm/roles/ (with the model
@@ -1220,8 +1256,9 @@ function rosterModelIssues(projectRoot: string, roles: ReadonlyMap<string, KxmRe
     for (const entry of valuesOf(role.value, "roster")) {
       const route = stringValue(objectValue(entry)?.route);
       if (!route) continue;
-      const logical = `.kxm/models/${route}.yaml`;
-      const file = join(projectRoot, ".kxm", "models", `${route}.yaml`);
+      const resolved = findYamlBasename(join(projectRoot, ".kxm", "models"), route, "route") ?? route;
+      const logical = `.kxm/models/${resolved}.yaml`;
+      const file = join(projectRoot, ".kxm", "models", `${resolved}.yaml`);
       let harness: string | undefined;
       try {
         if (existsSync(file)) harness = stringValue(parseRestrictedYaml(readFileSync(file, "utf8"), logical).harness);
@@ -1305,6 +1342,7 @@ function developerRolePolicyIssues(projectRoot: string): KxmConfigIssue[] {
   // is this package's developer policy, so it runs when the loaded project
   // is that package.
   if (resolve(projectRoot) !== findKxmRepoRoot(import.meta.url)) return [];
+  const lintIssues = lintWorkforce(projectRoot).errors.map((entry) => issue("semantic", entry.code, entry.file, entry.message));
   const rolesDir = join(projectRoot, ".kxm", "roles");
   const modelsDir = join(projectRoot, ".kxm", "models");
   const roles: Record<string, JsonObject> = {};
@@ -1340,7 +1378,7 @@ function developerRolePolicyIssues(projectRoot: string): KxmConfigIssue[] {
   }
   const ceilings = developerCeilings();
   if (!ceilings.ok) {
-    return [...parseIssues, issue("semantic", "developer_ceilings_unavailable", ".kxm/models", `developer ceilings could not be loaded: ${ceilings.detail}`)];
+    return [...parseIssues, ...lintIssues, issue("semantic", "developer_ceilings_unavailable", ".kxm/models", `developer ceilings could not be loaded: ${ceilings.detail}`)];
   }
   const result = validatePolicyDraft({ models, roles, evidence }, {
     ceilings: ceilings.ROUTES,
@@ -1349,8 +1387,8 @@ function developerRolePolicyIssues(projectRoot: string): KxmConfigIssue[] {
     piNativeVendorProviders: ceilings.PI_NATIVE_VENDOR_PROVIDERS,
     vendorAliases: { "x-ai": "xai", moonshotai: "moonshot", "google-ai": "google", qwen: "alibaba" },
   });
-  if (result.ok) return parseIssues;
-  return [...parseIssues, ...result.issues.map((entry) => issue(entry.phase, entry.code, entry.file, entry.message))];
+  if (result.ok) return [...parseIssues, ...lintIssues];
+  return [...parseIssues, ...lintIssues, ...result.issues.map((entry) => issue(entry.phase, entry.code, entry.file, entry.message))];
 }
 
 export function kxmCanonicalJson(value: JsonValue): string {

package/plugins/kxm/src/runtime-service.ts

@@ -5,6 +5,7 @@ import type { ContextItem } from "./context.ts";
 import {
   KxmConfigError,
   loadKxmProject,
+  lookupKxmResource,
   kxmCanonicalJson,
   type JsonObject,
   type JsonValue,
@@ -402,7 +403,7 @@ export function acceptKxmRun(
   const now = options.now ?? new Date().toISOString();
   const monotonicNs = options.monotonicNs ?? kxmMonotonicNs();
 
-  const workflow = bundle.workflows.get(request.workflowId);
+  const workflow = lookupKxmResource(bundle.workflows.values(), request.workflowId, "workflow");
   if (!workflow) {
     throw runtimeError("run_workflow_unknown", ".kxm/workflows", `workflow ${request.workflowId} does not exist in this project`);
   }

package/plugins/kxm/src/template.ts

@@ -175,35 +175,64 @@ function coreTemplate(projectId: string, projectName: string, variant: KxmTempla
   ]);
   if (variant === "v4-registry") {
     const coordinator = files.get(".kxm/agents/coordinator.yaml");
-    if (coordinator) files.set(".kxm/agents/coordinator.yaml", { ...coordinator, role: "planner" });
+    if (coordinator) {
+      files.delete(".kxm/agents/coordinator.yaml");
+      files.set(".kxm/agents/planner.yaml", { ...coordinator, role: "planner", aliases: ["coordinator"] });
+    }
     const implementer = files.get(".kxm/agents/implementer.yaml");
-    if (implementer) files.set(".kxm/agents/implementer.yaml", { ...implementer, role: "writer" });
+    if (implementer) {
+      files.delete(".kxm/agents/implementer.yaml");
+      files.set(".kxm/agents/writer.yaml", { ...implementer, role: "writer", aliases: ["implementer"] });
+    }
     const workflow = files.get(".kxm/workflows/default.yaml");
     if (workflow) {
       const limits = { ...(workflow.limits as JsonObject) };
       delete limits.maxAgentTimeMs;
-      files.set(".kxm/workflows/default.yaml", { ...workflow, limits });
+      const steps = (workflow.steps as JsonObject[]).map((step) => {
+        if (step.id === "plan") {
+          const on = { ...(step.on as JsonObject), passed: "writer" };
+          return { ...step, agent: "planner", on };
+        }
+        if (step.id === "implement") {
+          const assignments = { ...(step.assignments as JsonObject), allowedAgents: ["writer"] };
+          return { ...step, id: "writer", aliases: ["implement"], agent: "writer", assignments };
+        }
+        if (step.id === "verify") {
+          const on = { ...(step.on as JsonObject) };
+          const failure = on["implementation-failure"];
+          if (failure && typeof failure === "object" && !Array.isArray(failure)) {
+            on["implementation-failure"] = { ...(failure as JsonObject), target: "writer" };
+          }
+          return { ...step, on };
+        }
+        return step;
+      });
+      files.set(".kxm/workflows/default.yaml", { ...workflow, coordinator: "planner", limits, steps });
     }
     // The two models the template names, and nothing else. A fresh project can
     // be driven without falling through to an unadmitted default model.
+    // Route ids follow <harness>-<model-slug>. grok-default and fable-default
+    // remain aliases so an existing --route flag still resolves.
     files.set(".kxm/routes.yaml", {
       schema: "kxm.routes.v2",
-      updatedAt: "2026-09-23T00:00:00.000Z",
+      updatedAt: "2026-09-27T00:00:00.000Z",
       admitted: ["anthropic/fable", "xai/grok-4.6"],
       disabled: [],
     });
-    files.set(".kxm/models/grok-default.yaml", {
+    files.set(".kxm/models/grok-grok-4-6.yaml", {
       schema: "kxm.model.v2",
-      id: "grok-default",
+      id: "grok-grok-4-6",
+      aliases: ["grok-default"],
       harness: "grok",
       model: "grok-4.6",
       vendor: "xai",
       status: "admitted",
       permissions: ["edit"],
     });
-    files.set(".kxm/models/fable-default.yaml", {
+    files.set(".kxm/models/claude-fable.yaml", {
       schema: "kxm.model.v2",
-      id: "fable-default",
+      id: "claude-fable",
+      aliases: ["fable-default"],
       harness: "claude",
       model: "fable",
       vendor: "anthropic",
@@ -216,7 +245,7 @@ function coreTemplate(projectId: string, projectName: string, variant: KxmTempla
       purpose: "writer",
       permission: "edit",
       description: "Primary implementation agent.",
-      roster: [{ route: "grok-default" }],
+      roster: [{ route: "grok-grok-4-6", effort: "medium" }],
     });
     files.set(".kxm/roles/planner.yaml", {
       schema: "kxm.role.v2",
@@ -224,7 +253,7 @@ function coreTemplate(projectId: string, projectName: string, variant: KxmTempla
       purpose: "planner",
       permission: "read-only",
       description: "Plans the change before implementation.",
-      roster: [{ route: "fable-default" }],
+      roster: [{ route: "claude-fable", effort: "medium" }],
     });
     files.set(".kxm/gates.yaml", {
       schema: "kxm.gate-registry.v1",