@iowarp/clio-coder 0.4.0 → 0.4.2

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/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"
@@ -217,8 +218,7 @@ function defaultPrecedenceForScope(scope: ResourceScope): number {
  * Clio's context, so one opt-in covers both.
  */
 export function projectCompatTrusted(explicit?: boolean): boolean {
-	if (explicit === true) return true;
-	return process.env.CLIO_CODER_TRUST_PROJECT_SKILLS === "1";
+	return explicit === true;
 }
 
 /**
@@ -268,7 +268,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 +292,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,
@@ -441,28 +441,49 @@ function validateDescription(description: string | null): string[] {
 	return [];
 }
 
-function extractMetadata(frontmatter: Record<string, unknown>): Record<string, unknown> {
+/**
+ * The deprecation names the file: a bare "clio: skill metadata" warning at
+ * boot left the operator hunting across five compatibility roots for the
+ * SKILL.md that carried the key, and `doctor` scanned only two of them.
+ */
+function warnLegacySkillMetadata(filePath: string): void {
+	warnLegacyNaming(`clio: skill metadata in ${filePath}`, "clio-coder: skill metadata");
+}
+
+function extractMetadata(frontmatter: Record<string, unknown>, filePath: string): Record<string, unknown> {
 	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") {
+			warnLegacySkillMetadata(filePath);
+			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
+function extractProvenance(frontmatter: Record<string, unknown>, filePath: string): SkillProvenance | undefined {
+	// 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) warnLegacySkillMetadata(filePath);
+	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 +642,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 });
@@ -645,7 +668,7 @@ function loadSkillFile(
 		scope,
 		...(root.origin ? { source: root.origin } : {}),
 	};
-	const provenance = extractProvenance(parsed.frontmatter);
+	const provenance = extractProvenance(parsed.frontmatter, filePath);
 	const allowedTools = declaredToolSurface(parsed.frontmatter, "allowed-tools", filePath, diagnostics);
 	const disallowedTools = declaredToolSurface(parsed.frontmatter, "disallowed-tools", filePath, diagnostics);
 	const skill: Skill = {
@@ -658,14 +681,14 @@ 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),
 		pathSubject,
 		trusted: root.trusted ?? true,
 		precedence: root.precedence ?? defaultPrecedenceForScope(scope),
-		metadata: extractMetadata(parsed.frontmatter),
+		metadata: extractMetadata(parsed.frontmatter, filePath),
 		diagnostics,
 		...(provenance ? { provenance } : {}),
 	};

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

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

@@ -0,0 +1,214 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { safeResourceWrite } from "../../../core/safe-resource-write.js";
+import { clioConfigDir } from "../../../core/xdg.js";
+import type { MarketplaceSkill } from "./marketplace.js";
+
+/**
+ * Marketplace self-promotion: local detection that an uninstalled marketplace
+ * skill serves the operator's current request, plus the two policy pieces the
+ * offer flow needs — the persistent "never offer this skill" store and the
+ * own-marketplace source gate that bounds what a promotion-flow install may
+ * ever fetch.
+ *
+ * Detection is a pure lexical match against the local catalog: no model call,
+ * no network, and no request text ever leaves the process. False positives
+ * cost operator trust, so the matcher is deliberately conservative — a
+ * trigger-phrase hit or a strong distinctive-token overlap fires; anything
+ * weaker stays silent and the broad paths (the first-turn reminder,
+ * context(scope="skills")) remain the fallback.
+ */
+
+export interface PromotionMatch {
+	entry: MarketplaceSkill;
+	score: number;
+	/** The trigger phrase that fired, when the match came from one. */
+	matchedTrigger?: string;
+}
+
+const TOKEN_STOPWORDS = new Set([
+	"the",
+	"a",
+	"an",
+	"and",
+	"or",
+	"for",
+	"with",
+	"this",
+	"that",
+	"when",
+	"what",
+	"how",
+	"into",
+	"from",
+	"use",
+	"used",
+	"using",
+	"one",
+	"not",
+	"skill",
+	"skills",
+	"clio",
+	"please",
+	"can",
+	"you",
+	"should",
+	"would",
+	"about",
+	"need",
+	"want",
+	"help",
+	"make",
+	"file",
+	"files",
+	"code",
+]);
+
+function normalize(text: string): string {
+	return text
+		.toLowerCase()
+		.replace(/[^\p{L}\p{N}\s]/gu, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/** Distinctive tokens: 4+ chars and outside the stopword set. */
+function distinctiveTokens(text: string): Set<string> {
+	return new Set(
+		normalize(text)
+			.split(" ")
+			.filter((token) => token.length >= 4 && !TOKEN_STOPWORDS.has(token)),
+	);
+}
+
+const TRIGGER_SCORE = 4;
+/** Distinct description/name token overlaps required to fire without a trigger. */
+const TOKEN_FIRE_THRESHOLD = 3;
+
+/**
+ * Score one marketplace entry against the operator's request text. A trigger
+ * phrase is a whole-phrase substring match on normalized text; token overlap
+ * is a fallback for skills whose triggers have not been authored yet.
+ */
+export function scorePromotionEntry(userText: string, entry: MarketplaceSkill): PromotionMatch | null {
+	const haystack = ` ${normalize(userText)} `;
+	if (haystack.trim().length === 0) return null;
+	for (const trigger of entry.triggers ?? []) {
+		const phrase = normalize(trigger);
+		if (phrase.length >= 4 && haystack.includes(` ${phrase} `)) {
+			return { entry, score: TRIGGER_SCORE, matchedTrigger: trigger };
+		}
+	}
+	const requestTokens = distinctiveTokens(userText);
+	if (requestTokens.size === 0) return null;
+	const entryTokens = distinctiveTokens(`${entry.name.replace(/-/g, " ")} ${entry.description}`);
+	let overlap = 0;
+	for (const token of requestTokens) if (entryTokens.has(token)) overlap += 1;
+	return overlap >= TOKEN_FIRE_THRESHOLD ? { entry, score: overlap } : null;
+}
+
+/**
+ * The uninstalled marketplace entries that match the request, best first.
+ * `excludedNames` carries installed skills plus every decline scope the
+ * caller tracks; the matcher itself is stateless.
+ */
+export function matchMarketplaceSkills(
+	userText: string,
+	entries: ReadonlyArray<MarketplaceSkill>,
+	excludedNames: ReadonlySet<string>,
+): PromotionMatch[] {
+	const matches: PromotionMatch[] = [];
+	for (const entry of entries) {
+		if (entry.kind !== "skill" || excludedNames.has(entry.name)) continue;
+		const match = scorePromotionEntry(userText, entry);
+		if (match) matches.push(match);
+	}
+	return matches.sort((a, b) => b.score - a.score || a.entry.name.localeCompare(b.entry.name));
+}
+
+/**
+ * The hard runtime gate on promotion-flow installs: only Clio's own
+ * marketplace is ever an acceptable source, whether the install runs on
+ * operator consent or autonomously at full-auto. A local path is the shipped
+ * package catalog (install copies files, no network); the one acceptable URL
+ * shape is this project's own repository tree. Public skill registries and
+ * arbitrary GitHub sources are rejected here, in code — a prompt instruction
+ * is not the enforcement mechanism.
+ *
+ * This gates the promotion flow only. Operator-driven installs through
+ * `clio-coder skills install <url>` keep their existing behavior.
+ */
+export const OWN_MARKETPLACE_URL_PREFIX = "https://github.com/iowarp/clio-coder/";
+
+export function isOwnMarketplaceSource(entry: Pick<MarketplaceSkill, "origin" | "sourceUrl">): boolean {
+	const source = entry.sourceUrl.trim();
+	if (/^(?:https?:\/\/|git@)/.test(source)) return source.startsWith(OWN_MARKETPLACE_URL_PREFIX);
+	// A non-URL source is a local filesystem path; only catalog discovery
+	// produces those, and it resolves them against the shipped package.
+	return entry.origin === "catalog" && path.isAbsolute(source);
+}
+
+export function assertPromotionInstallSource(entry: MarketplaceSkill): void {
+	if (isOwnMarketplaceSource(entry)) return;
+	throw new Error(
+		`skill promotion: refusing to install "${entry.name}" from ${entry.sourceUrl}; ` +
+			"promotion installs only from Clio's own marketplace (local catalog or " +
+			`${OWN_MARKETPLACE_URL_PREFIX}). Install manually with clio-coder skills install if intended.`,
+	);
+}
+
+/**
+ * Persistent "never offer this skill" store. Session-scoped declines live in
+ * the offer registration's memory and die with the session; this file holds
+ * only the explicit fourth option. It is a standalone JSON document in the
+ * config dir rather than a settings key because the settings-v2 manifest is
+ * owned elsewhere this sprint; the proposed key for a later migration is
+ * `skills.promotionDeclines`.
+ */
+export const PROMOTION_DECLINES_FILE = "skill-promotion-declines.json";
+
+export interface PromotionDeclineStore {
+	/** decline key (name@version) -> ISO timestamp of the operator's "never" answer. */
+	never: Record<string, string>;
+}
+
+/**
+ * The decline store key. A "never" answer is scoped to the catalog version the
+ * operator saw, so a later version of the same skill is offerable again while a
+ * re-published identical version stays declined. Absent version keys as
+ * `name@`, distinct from any real version, so it re-offers once a version
+ * appears.
+ */
+export function declineKey(name: string, version?: string): string {
+	return `${name}@${version ?? ""}`;
+}
+
+function declinesPath(configDir?: string): string {
+	return path.join(configDir ?? clioConfigDir(), PROMOTION_DECLINES_FILE);
+}
+
+export function readPromotionDeclines(configDir?: string): PromotionDeclineStore {
+	const file = declinesPath(configDir);
+	if (!existsSync(file)) return { never: {} };
+	try {
+		const parsed = JSON.parse(readFileSync(file, "utf8")) as unknown;
+		const never =
+			parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as { never?: unknown }).never : undefined;
+		if (never && typeof never === "object" && !Array.isArray(never)) {
+			const entries = Object.entries(never as Record<string, unknown>).filter(
+				(pair): pair is [string, string] => typeof pair[1] === "string",
+			);
+			return { never: Object.fromEntries(entries) };
+		}
+	} catch {
+		// An unreadable store means no recorded declines; the worst outcome is
+		// one extra offer, which the operator can re-decline.
+	}
+	return { never: {} };
+}
+
+export function recordPromotionNeverDecline(name: string, version?: string, configDir?: string): void {
+	const store = readPromotionDeclines(configDir);
+	store.never[declineKey(name, version)] = new Date().toISOString();
+	safeResourceWrite(declinesPath(configDir), `${JSON.stringify(store, null, 2)}\n`, { encoding: "utf8" });
+}

package/src/domains/safety/audit.ts

@@ -11,7 +11,7 @@ import type { SafetyPolicyDecision } from "./policy-engine.js";
  * rotation, and on a low-frequency background interval instead of once per
  * row, which kept blocking the admission hot path on disk latency. Write
  * errors never throw back to the caller because safety must not kill the hot
- * path; they are logged to stderr with a `[clio:audit]` prefix for
+ * path; they are logged to stderr with a `[clio-coder:audit]` prefix for
  * post-mortem review.
  *
  * Records are a discriminated union over `kind`:
@@ -404,7 +404,7 @@ interface OpenFile {
 function logAuditError(err: unknown, path?: string): void {
 	const msg = err instanceof Error ? err.message : String(err);
 	const where = path ? ` (${path})` : "";
-	process.stderr.write(`[clio:audit] ${msg}${where}\n`);
+	process.stderr.write(`[clio-coder:audit] ${msg}${where}\n`);
 }
 
 /** Cadence of the background safety flush that bounds how long rows can sit unfsynced. */

package/src/domains/safety/call-target.ts

@@ -168,7 +168,7 @@ const CALL_TARGET_FIELDS: Readonly<Record<string, ReadonlyArray<string>>> = {
 	grep: ["pattern", "path", "mode", "glob", "ignore_case", "literal", "context", "limit", "include_ignored"],
 	find: ["pattern", "path", "order", "limit", "include_ignored"],
 	ls: ["path", "limit"],
-	code_nav: ["mode", "query", "limit"],
+	code_nav: ["source", "mode", "query", "limit"],
 	context: ["scope", "query", "name", "limit", "ref", "include_tree"],
 	credential_present: ["name", "source", "file"],
 	write: ["path"],