@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/domains/providers/types/knowledge-base.ts

@@ -2,6 +2,7 @@ import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 
+import { warnLegacyNaming } from "../../../core/naming-compat.js";
 import type { CapabilityFlags } from "./capability-flags.js";
 
 export interface KnowledgeBaseEntry {
@@ -9,6 +10,8 @@ export interface KnowledgeBaseEntry {
 	matchPatterns: ReadonlyArray<string>;
 	capabilities: Partial<CapabilityFlags>;
 	quirks?: Record<string, unknown>;
+	/** Product-owned catalog metadata, normalized from either YAML spelling. */
+	clioCoder?: Record<string, unknown>;
 }
 
 export type MatchKind = "family" | "alias";
@@ -152,5 +155,15 @@ function normalizeEntry(raw: unknown, file: string): KnowledgeBaseEntry {
 		}
 		entry.quirks = candidate.quirks as Record<string, unknown>;
 	}
+	const canonicalMetadata = candidate["clio-coder"];
+	const legacyMetadata = candidate.clio;
+	if (legacyMetadata !== undefined) warnLegacyNaming("clio: model metadata", "clio-coder: model metadata");
+	const metadata = canonicalMetadata ?? legacyMetadata;
+	if (metadata !== undefined) {
+		if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+			throw new Error(`knowledge base file ${file}: entry '${family}' clio-coder metadata must be an object`);
+		}
+		entry.clioCoder = metadata as Record<string, unknown>;
+	}
 	return entry;
 }

package/src/domains/providers/types/local-model-quirks.ts

@@ -3,7 +3,7 @@
  * keeps free-form `quirks` (gpu tiers, runtime preferences, serving notes), so
  * `KnowledgeBaseEntry.quirks` stays `Record<string, unknown>`. This module
  * narrows the slice the engine consumes (KV cache layout, per-mode sampling)
- * into a typed shape that flows through `model.clio.quirks` at synth time.
+ * into a typed shape that flows through `model.clioCoder.quirks` at synth time.
  *
  * Field naming follows the Hugging Face / model-card terminology so the YAML
  * can be authored against the source-of-truth card. The OpenAI adapter
@@ -201,7 +201,7 @@ function extractThinkingQuirks(raw: unknown): ThinkingQuirks | undefined {
 /**
  * Pull the engine-visible quirks slice out of a free-form catalog quirks
  * record. Returns `undefined` when nothing engine-relevant is configured so
- * `model.clio.quirks` only gets attached when it carries information.
+ * `model.clioCoder.quirks` only gets attached when it carries information.
  */
 export function extractLocalModelQuirks(raw: unknown): LocalModelQuirks | undefined {
 	if (!isRecord(raw)) return undefined;

package/src/domains/providers/types/target-descriptor.ts

@@ -14,9 +14,9 @@ export interface TargetPricing {
 	cacheWrite?: number;
 }
 
-// "clio-managed" is a settings.yaml enum value, not an artifact name; it stays
-// unrenamed by rebrand decision so existing `lifecycle:` lines keep working.
-export type TargetLifecycle = "user-managed" | "clio-managed";
+// Canonical persisted lifecycle name. Readers temporarily normalize the
+// released `clio-managed` spelling at the settings boundary.
+export type TargetLifecycle = "user-managed" | "clio-coder-managed";
 
 export interface LmStudioLoadSettings {
 	contextLength?: number;

package/src/domains/resources/extension.ts

@@ -12,7 +12,7 @@ export function createResourcesBundle(
 		...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
 		...(options.reservedPromptNames !== undefined ? { reservedPromptNames: options.reservedPromptNames } : {}),
 		skills: () => ({
-			...skillOptions(config()?.get().skills.trustProjectCompatRoots === true, options),
+			...skillOptions(config()?.get().integrations.projectResources.trustProjectImports === true, options),
 		}),
 	});
 	const extension: DomainExtension = {

package/src/domains/resources/index.ts

@@ -68,11 +68,14 @@ export {
 	parsePendingSkillRequests,
 	parseSkillCommand,
 	type Skill,
+	type SkillCatalogInvalidReason,
+	type SkillCatalogValidity,
 	type SkillExpansion,
 	type SkillList,
 	type SkillProvenance,
 	type SkillRoot,
 	type SkillSource,
+	skillCatalogValidity,
 } from "./skills/loader.js";
 export {
 	type DiscoverMarketplaceOptions,

package/src/domains/resources/library.ts

@@ -37,7 +37,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function catalogPath(): string {
-	const configured = readSettings().library.catalog;
+	const configured = readSettings().integrations.library.catalog;
 	return path.resolve(configured ?? path.join(clioConfigDir(), "library.yaml"));
 }
 
@@ -283,17 +283,17 @@ export function installLibraryPlan(plan: LibraryInstallPlan): void {
 }
 
 function confirmedRemote(): string {
-	const settings = readSettings().library;
+	const settings = readSettings().integrations.library;
 	if (!settings.remote || settings.remote !== settings.confirmedRemote) throw new Error("library_remote_unconfirmed");
 	return settings.remote;
 }
 
 export function confirmLibraryRemote(url: string): void {
-	const current = readSettings().library.remote;
+	const current = readSettings().integrations.library.remote;
 	if (current !== null && current !== url) throw new Error("library_remote_mismatch");
 	updateSettings((settings) => {
-		if (settings.library.remote === null) settings.library.remote = url;
-		settings.library.confirmedRemote = url;
+		if (settings.integrations.library.remote === null) settings.integrations.library.remote = url;
+		settings.integrations.library.confirmedRemote = url;
 	});
 }
 
@@ -307,7 +307,7 @@ export async function syncLibrary(
 	direction: "sync" | "push",
 	runner: LibraryCommandRunner = runCommandVector,
 ): Promise<void> {
-	const settings = readSettings().library;
+	const settings = readSettings().integrations.library;
 	if (!settings.sync) throw new Error("library_sync_disabled");
 	const remote = confirmedRemote();
 	const cwd = path.dirname(catalogPath());

package/src/domains/resources/prompts/loader.ts

@@ -393,7 +393,7 @@ export function expandPromptTemplateInput(input: string, templates: PromptTempla
 		};
 	}
 	if (!template.trusted) {
-		const message = `prompt template ${template.name} comes from an untrusted project root; set skills.trustProjectCompatRoots to use it`;
+		const message = `prompt template ${template.name} comes from an untrusted project root; set integrations.projectResources.trustProjectImports to use it`;
 		return {
 			expanded: false,
 			text: input,

package/src/domains/resources/skills/content-hash.ts

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 
 /**
  * Frontmatter keys owned by the install lifecycle, recognized both at the top
- * level (legacy flat form) and nested under the reserved `clio:` block.
+ * level (legacy flat form) and nested under the reserved `clio-coder:` or
+ * released `clio:` block.
  * Stripped before hashing so upstream and installed copies compare on
  * content, not on when or how a copy was installed. Registry identity
  * (`registry-id`, `registry-url`) is deliberately NOT here: it names which
@@ -64,7 +65,7 @@ export function frontmatterRegion(rawText: string): FrontmatterRegion | null {
 export function stripProvenanceLines(lines: ReadonlyArray<string>): string[] {
 	const kept: string[] = [];
 	let dropIndent: number | null = null;
-	let inClioBlock = false;
+	let inProductBlock = false;
 	for (const line of lines) {
 		const indent = line.length - line.trimStart().length;
 		if (dropIndent !== null && line.trim().length > 0 && indent > dropIndent) continue;
@@ -72,19 +73,19 @@ export function stripProvenanceLines(lines: ReadonlyArray<string>): string[] {
 		const keyMatch = line.match(/^([ \t]*)([A-Za-z][A-Za-z0-9-]*):/);
 		const key = keyMatch?.[2];
 		if (key !== undefined) {
-			if (indent === 0) inClioBlock = key === "clio";
-			if (PROVENANCE_KEYS.has(key) && (indent === 0 || inClioBlock)) {
+			if (indent === 0) inProductBlock = key === "clio-coder" || key === "clio";
+			if (PROVENANCE_KEYS.has(key) && (indent === 0 || inProductBlock)) {
 				dropIndent = indent;
 				continue;
 			}
 		}
 		kept.push(line);
 	}
-	// A `clio:` mapping whose children were all lifecycle keys is now empty;
+	// A product mapping whose children were all lifecycle keys is now empty;
 	// keep it and a source that never had the block reads as drifted from its
 	// own installed copy. Drop the dangling key line.
 	return kept.filter((line, index) => {
-		if (!/^clio:\s*$/.test(line)) return true;
+		if (!/^(?:clio-coder|clio):\s*$/.test(line)) return true;
 		for (let next = index + 1; next < kept.length; next += 1) {
 			const candidate = kept[next] as string;
 			if (candidate.trim().length === 0) continue;

package/src/domains/resources/skills/evals.ts

@@ -29,7 +29,7 @@ export interface SkillEvalParseResult {
 
 // Tolerates ASCII dash/colon and the en/em dashes older evals.md files used.
 // The canonical prefix is S ("## S1 - title"); discipline skills use other
-// letters (clio-dev's D1), so any single capital letter is accepted.
+// letters (clio-coder-dev's D1), so any single capital letter is accepted.
 const SCENARIO_HEADING = /^##\s+([A-Z])(\d+)\s*[-:–—]\s*(.+?)\s*$/;
 
 export function parseSkillEvals(markdown: string): SkillEvalParseResult {

package/src/domains/resources/skills/install.ts

@@ -140,14 +140,33 @@ interface ProvenanceFields {
 	installedBy?: "worker";
 }
 
+function canonicalizeProductMetadataBlock(lines: ReadonlyArray<string>): string[] {
+	const hasCanonical = lines.some((line) => /^clio-coder:/.test(line));
+	const canonical: string[] = [];
+	let dropLegacyChildren = false;
+	for (const line of lines) {
+		if (/^clio:/.test(line)) {
+			dropLegacyChildren = hasCanonical;
+			if (!hasCanonical) canonical.push(line.replace(/^clio:/, "clio-coder:"));
+			continue;
+		}
+		if (dropLegacyChildren) {
+			if (line.trim().length === 0 || /^[ \t]/.test(line)) continue;
+			dropLegacyChildren = false;
+		}
+		canonical.push(line);
+	}
+	return canonical;
+}
+
 /**
  * Replace install-lifecycle frontmatter with the recorded fields, written
- * nested under the reserved `clio:` block (merged into an existing block-style
- * `clio:` mapping when the skill carries one). Registry identity lines
+ * nested under the reserved `clio-coder:` block (merged into an existing block-style
+ * `clio-coder:` mapping when the skill carries one). Registry identity lines
  * (`registry-id`, `registry-url`) are content, not lifecycle, so they survive
  * the install and keep pinned drift checks working on the installed copy.
  *
- * A flow-style `clio: {...}` value cannot take appended block lines, so that
+ * A flow-style `clio-coder: {...}` value cannot take appended block lines, so that
  * rare shape falls back to the legacy flat stamps, which the hash and loader
  * still understand.
  */
@@ -166,21 +185,24 @@ function injectProvenanceFrontmatter(rawText: string, fields: ProvenanceFields):
 		"audit: unknown",
 		...(fields.installedBy ? [`installed-by: ${yamlQuote(fields.installedBy)}`] : []),
 	];
-	const clioIndex = kept.findIndex((line) => /^clio:/.test(line));
-	if (clioIndex >= 0 && !/^clio:\s*$/.test(kept[clioIndex] as string)) {
-		return `${region.head}${[...kept, ...stamps].join("\n")}${region.tail}`;
+	const canonicalKept = canonicalizeProductMetadataBlock(kept);
+	const clioIndex = canonicalKept.findIndex((line) => /^clio-coder:/.test(line));
+	if (clioIndex >= 0 && !/^clio-coder:\s*$/.test(canonicalKept[clioIndex] as string)) {
+		return `${region.head}${[...canonicalKept, ...stamps].join("\n")}${region.tail}`;
 	}
 	const nested = stamps.map((line) => `  ${line}`);
 	if (clioIndex < 0) {
-		return `${region.head}${[...kept, "clio:", ...nested].join("\n")}${region.tail}`;
+		return `${region.head}${[...canonicalKept, "clio-coder:", ...nested].join("\n")}${region.tail}`;
 	}
 	let blockEnd = clioIndex + 1;
-	while (blockEnd < kept.length) {
-		const line = kept[blockEnd] as string;
+	while (blockEnd < canonicalKept.length) {
+		const line = canonicalKept[blockEnd] as string;
 		if (line.trim().length > 0 && !/^[ \t]/.test(line)) break;
 		blockEnd += 1;
 	}
-	return `${region.head}${[...kept.slice(0, blockEnd), ...nested, ...kept.slice(blockEnd)].join("\n")}${region.tail}`;
+	return `${region.head}${[...canonicalKept.slice(0, blockEnd), ...nested, ...canonicalKept.slice(blockEnd)].join(
+		"\n",
+	)}${region.tail}`;
 }
 
 function resolveSkillDir(target: string): string {
@@ -205,7 +227,7 @@ function fetchSource(spec: SkillSourceSpec): FetchedSource {
 	if (spec.kind === "local") {
 		return { skillDir: resolveSkillDir(spec.path), cleanup: () => {} };
 	}
-	const tmp = mkdtempSync(path.join(tmpdir(), "clio-skill-"));
+	const tmp = mkdtempSync(path.join(tmpdir(), "clio-coder-skill-"));
 	const cleanup = (): void => rmSync(tmp, { recursive: true, force: true });
 	try {
 		execFileSync("git", ["clone", "--depth", "1", "--branch", spec.branch, spec.cloneUrl, tmp], {
@@ -358,7 +380,9 @@ export function installSkillFromSource(input: InstallSkillInput): InstallSkillRe
 function managedSkills(cwd: string, configDir?: string): Skill[] {
 	const list = loadSkills({ cwd, ...(configDir ? { configDir } : {}) });
 	// Only Clio-managed roots are update targets; compat roots belong to other harnesses.
-	return list.items.filter((skill) => skill.source === "clio" && (skill.scope === "user" || skill.scope === "project"));
+	return list.items.filter(
+		(skill) => skill.source === "clio-coder" && (skill.scope === "user" || skill.scope === "project"),
+	);
 }
 
 function updateOne(skill: Skill, force: boolean): SkillUpdateReport {

package/src/domains/resources/skills/loader.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { type Dirent, existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
+import { warnLegacyNaming } from "../../../core/naming-compat.js";
 import type { PendingSkillRequest } from "../../../core/skill-activation.js";
 import { type ToolName, ToolNames } from "../../../core/tool-names.js";
 import { clioConfigDir } from "../../../core/xdg.js";
@@ -47,7 +48,7 @@ const CORE_FRONTMATTER_KEYS = new Set([
  * only encodes collision precedence tiers shared across resource kinds.
  */
 export type SkillSource =
-	| "clio"
+	| "clio-coder"
 	| "agents"
 	| "claude"
 	| "codex"
@@ -216,9 +217,20 @@ function defaultPrecedenceForScope(scope: ResourceScope): number {
  * this gate with skills: both substitute another agent's project file into
  * Clio's context, so one opt-in covers both.
  */
+let warnedLegacyProjectTrustEnv = false;
+
 export function projectCompatTrusted(explicit?: boolean): boolean {
 	if (explicit === true) return true;
-	return process.env.CLIO_CODER_TRUST_PROJECT_SKILLS === "1";
+	if (process.env.CLIO_CODER_TRUST_PROJECT_RESOURCES === "1") return true;
+	if (process.env.CLIO_CODER_TRUST_PROJECT_SKILLS !== "1") return false;
+	if (!warnedLegacyProjectTrustEnv) {
+		warnedLegacyProjectTrustEnv = true;
+		process.emitWarning("CLIO_CODER_TRUST_PROJECT_SKILLS is deprecated; use CLIO_CODER_TRUST_PROJECT_RESOURCES instead", {
+			code: "CLIO_CODER_DEPRECATED_ENV",
+			type: "DeprecationWarning",
+		});
+	}
+	return true;
 }
 
 /**
@@ -268,7 +280,7 @@ export function defaultSkillRoots(input: LoadSkillsInput = {}): SkillRoot[] {
 		roots.push({
 			path: path.join(configDir, "skills"),
 			scope: "user",
-			source: "clio",
+			source: "clio-coder",
 			origin: "config",
 			precedence: SKILL_PRECEDENCE.user,
 			trusted: true,
@@ -292,7 +304,7 @@ export function defaultSkillRoots(input: LoadSkillsInput = {}): SkillRoot[] {
 	roots.push({
 		path: path.join(cwd, ".clio-coder", "skills"),
 		scope: "project",
-		source: "clio",
+		source: "clio-coder",
 		origin: "project",
 		precedence: SKILL_PRECEDENCE.project,
 		trusted: true,
@@ -445,24 +457,36 @@ function extractMetadata(frontmatter: Record<string, unknown>): Record<string, u
 	const metadata: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(frontmatter)) {
 		if (CORE_FRONTMATTER_KEYS.has(key)) continue;
+		if (key === "clio-coder") {
+			metadata.clioCoder = value;
+			continue;
+		}
+		if (key === "clio") {
+			warnLegacyNaming("clio: skill metadata", "clio-coder: skill metadata");
+			if (!("clio-coder" in frontmatter)) metadata.clioCoder = value;
+			continue;
+		}
 		metadata[key] = value;
 	}
 	return metadata;
 }
 
 function extractProvenance(frontmatter: Record<string, unknown>): SkillProvenance | undefined {
-	// Provenance lives nested under the reserved `clio:` block; the flat
+	// Provenance lives nested under the reserved `clio-coder:` block; the flat
 	// top-level keys remain readable for already-installed copies stamped
 	// before the nested form existed.
-	const clioRaw = frontmatter.clio;
-	const clio =
-		clioRaw !== null && typeof clioRaw === "object" && !Array.isArray(clioRaw)
-			? (clioRaw as Record<string, unknown>)
+	const canonicalRaw = frontmatter["clio-coder"];
+	const legacyRaw = frontmatter.clio;
+	if (legacyRaw !== undefined) warnLegacyNaming("clio: skill metadata", "clio-coder: skill metadata");
+	const clioCoderRaw = canonicalRaw ?? legacyRaw;
+	const clioCoder =
+		clioCoderRaw !== null && typeof clioCoderRaw === "object" && !Array.isArray(clioCoderRaw)
+			? (clioCoderRaw as Record<string, unknown>)
 			: undefined;
 	const field = (...keys: string[]): string | null => {
 		for (const key of keys) {
-			if (clio) {
-				const nested = stringField(clio, key);
+			if (clioCoder) {
+				const nested = stringField(clioCoder, key);
 				if (nested !== null) return nested;
 			}
 		}
@@ -621,7 +645,9 @@ function loadSkillFile(
 
 	const pathSubject = validationSubject(filePath);
 	const frontmatterName = stringField(parsed.frontmatter, "name");
-	const name = frontmatterName ?? pathSubject;
+	const rawName = frontmatterName ?? pathSubject;
+	const name = rawName === "clio-dev" ? "clio-coder-dev" : rawName === "clio-test" ? "clio-coder-test" : rawName;
+	if (name !== rawName) warnLegacyNaming(rawName, name);
 	const description = stringField(parsed.frontmatter, "description");
 
 	for (const message of validateDescription(description)) diagnostics.push({ type: "warning", message, path: filePath });
@@ -658,7 +684,7 @@ function loadSkillFile(
 		disableModelInvocation: booleanField(parsed.frontmatter, "disable-model-invocation"),
 		...(allowedTools ? { allowedTools } : {}),
 		...(disallowedTools ? { disallowedTools } : {}),
-		source: root.source ?? "clio",
+		source: root.source ?? "clio-coder",
 		scope,
 		hash: sha256(raw),
 		normalizedHash: normalizedSkillHash(raw),
@@ -893,6 +919,39 @@ export function modelVisibleSkills(skills: ReadonlyArray<Skill>): Skill[] {
 	return skills.filter((skill) => skill.trusted && !skill.disableModelInvocation);
 }
 
+/** Why a loaded skill catalog is not valid. Ordered by which failure to report first. */
+export type SkillCatalogInvalidReason = "load-error" | "collision" | "unloadable-file" | "no-skills";
+
+export interface SkillCatalogValidity {
+	ok: boolean;
+	reason: SkillCatalogInvalidReason | null;
+}
+
+/**
+ * The rule `clio-coder skills validate` applies, in one place.
+ *
+ * A scanned file that produced no loaded skill is malformed, and a collision
+ * drops a skill: both make the catalog invalid, as does any hard error. Benign
+ * warnings (name/path mismatch, name format, description length) attach to a
+ * file that still loaded, so their path is among the loaded skills and they do
+ * not fail validation.
+ *
+ * Lives here rather than in the CLI because two callers now need the same
+ * answer, and a verdict that drifts between the terminal and a GUI is worse
+ * than no verdict at all.
+ */
+export function skillCatalogValidity(list: SkillList): SkillCatalogValidity {
+	if (list.diagnostics.some((diag) => diag.type === "error")) return { ok: false, reason: "load-error" };
+	if (list.diagnostics.some((diag) => diag.type === "collision")) return { ok: false, reason: "collision" };
+	const loadedPaths = new Set(list.items.map((skill) => skill.filePath));
+	const unloadable = list.diagnostics.some(
+		(diag) => diag.type === "warning" && diag.path !== undefined && !loadedPaths.has(diag.path),
+	);
+	if (unloadable) return { ok: false, reason: "unloadable-file" };
+	if (list.items.length === 0) return { ok: false, reason: "no-skills" };
+	return { ok: true, reason: null };
+}
+
 export function parseSkillCommand(input: string): { name: string; args: string } | null {
 	const trimmed = input.trim();
 	if (!trimmed.startsWith("/skill ")) return null;

package/src/domains/resources/skills/marketplace.ts

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { warnLegacyNaming } from "../../../core/naming-compat.js";
 import { resolvePackageRoot } from "../../../core/package-root.js";
 import { clioConfigDir } from "../../../core/xdg.js";
 import {
@@ -55,6 +56,8 @@ export interface MarketplaceSkill {
 	audit?: "pass" | "warn" | "fail" | "unknown";
 	/** Catalog grouping ("git", "research", ...); absent in a flat catalog. */
 	category?: string;
+	/** Trigger phrases from the skill's frontmatter, for local promotion matching. */
+	triggers?: string[];
 	origin: MarketplaceSkillOrigin;
 	requires?: LibraryRequirementRef[];
 }
@@ -131,6 +134,16 @@ function optionalString(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
+/** Non-empty trimmed trigger phrases, or undefined when the field is absent or unusable. */
+function optionalTriggerList(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const triggers = value
+		.filter((entry): entry is string => typeof entry === "string")
+		.map((entry) => entry.trim())
+		.filter((entry) => entry.length > 0);
+	return triggers.length > 0 ? triggers : undefined;
+}
+
 function indexAudit(value: unknown): MarketplaceSkill["audit"] {
 	return value === "pass" || value === "warn" || value === "fail" || value === "unknown" ? value : undefined;
 }
@@ -151,6 +164,7 @@ function parseMarketplaceIndex(indexPath: string, diagnostics: string[] = []): M
 			const version = optionalString(record.version);
 			const audit = indexAudit(record.audit);
 			const category = optionalString(record.category);
+			const triggers = optionalTriggerList(record.triggers);
 			if (record.kind !== undefined && !["skill", "agent", "prompt", "fleet"].includes(String(record.kind))) {
 				diagnostics.push(`skill marketplace index entry has unsupported kind: ${skill.name}`);
 				return [];
@@ -176,6 +190,7 @@ function parseMarketplaceIndex(indexPath: string, diagnostics: string[] = []): M
 					...(version ? { version } : {}),
 					...(audit ? { audit } : {}),
 					...(category ? { category } : {}),
+					...(triggers ? { triggers } : {}),
 					...(requires ? { requires } : {}),
 					origin: "index" as const,
 				},
@@ -242,6 +257,7 @@ function catalogCategory(catalogDir: string, baseDir: string): string | undefine
 function catalogEntry(skill: Skill, catalogDir: string): MarketplaceSkill {
 	const version = typeof skill.metadata.version === "string" ? skill.metadata.version : undefined;
 	const category = catalogCategory(catalogDir, skill.baseDir);
+	const triggers = optionalTriggerList(skill.metadata.triggers);
 	return {
 		name: skill.name,
 		description: skill.description,
@@ -249,6 +265,7 @@ function catalogEntry(skill: Skill, catalogDir: string): MarketplaceSkill {
 		...(version ? { version } : {}),
 		...(skill.provenance?.audit ? { audit: skill.provenance.audit } : {}),
 		...(category ? { category } : {}),
+		...(triggers ? { triggers } : {}),
 		origin: "catalog",
 		kind: "skill",
 	};
@@ -311,7 +328,9 @@ export function getMarketplaceSkills(options: DiscoverMarketplaceOptions = {}):
  * an existing install always requires an explicit `force: true`.
  */
 export function installSkill(input: InstallSkillInput): InstallSkillResult {
-	const source = input.source.trim();
+	const requested = input.source.trim();
+	const source = requested === "clio-dev" ? "clio-coder-dev" : requested === "clio-test" ? "clio-coder-test" : requested;
+	if (source !== requested) warnLegacyNaming(requested, source);
 	const spec = parseSkillSourceSpec(source);
 	if (spec?.kind === "local" && isSkillName(source) && !existsSync(spec.path)) {
 		const skill = getMarketplaceSkills({ ...(input.cwd ? { cwd: input.cwd } : {}) }).find(
@@ -322,5 +341,5 @@ export function installSkill(input: InstallSkillInput): InstallSkillResult {
 		}
 		return installSkillFromSource({ ...input, source: skill.sourceUrl });
 	}
-	return installSkillFromSource(input);
+	return installSkillFromSource({ ...input, source });
 }