pi-roundtable 0.24.2 → 0.25.0

package/src/core/modules/prompts/prompt-history.ts

@@ -0,0 +1,103 @@
+import type { SQL } from "bun";
+import type { Migration } from "../../db/migrations.ts";
+
+/** What a history belongs to: a prompt document, or the prompt of one agent. */
+export type PromptKind = "document" | "agent";
+
+/** `set` put new text in force; `revert` took a document back to its file version. */
+export type PromptAction = "set" | "revert";
+
+/** One change of a prompt, as it was made. */
+export interface PromptVersion {
+	id: number;
+	action: PromptAction;
+	/** The text in force after the change; for a revert, the file version it went back to. */
+	text: string;
+	/** The text the change replaced. */
+	previous: string;
+	/** Who made it: the owner's name, or the agent that edited another agent's prompt. */
+	by: string;
+	at: Date;
+}
+
+/** The newest versions a prompt keeps; older ones are dropped as new ones come. */
+export const PROMPT_HISTORY_KEEP = 200;
+
+interface HistoryRow {
+	id: string | number;
+	action: PromptAction;
+	text: string;
+	previous: string;
+	by_name: string;
+	at: Date;
+}
+
+/** The history table, shared by the documents and the agents; both create it, whichever comes first. */
+export const promptHistoryMigration = (name: string): Migration => ({
+	name,
+	up: async (sql) => {
+		await sql`
+			CREATE TABLE IF NOT EXISTS prompt_history (
+				id bigserial PRIMARY KEY,
+				guild_id text NOT NULL,
+				kind text NOT NULL,
+				name text NOT NULL,
+				action text NOT NULL,
+				text text NOT NULL,
+				previous text NOT NULL,
+				by_name text NOT NULL,
+				at timestamptz NOT NULL DEFAULT now()
+			)`;
+		await sql`CREATE INDEX IF NOT EXISTS prompt_history_of ON prompt_history (guild_id, kind, name, id)`;
+	},
+});
+
+/** Every change of a prompt, in the database, newest first. */
+export class PromptHistory {
+	readonly #sql: SQL;
+	readonly #guild: string;
+
+	constructor(sql: SQL, guildId: string) {
+		this.#sql = sql;
+		this.#guild = guildId;
+	}
+
+	/** Writes one version; `db` is a transaction when the change itself is written in one. */
+	async record(
+		kind: PromptKind,
+		name: string,
+		entry: Omit<PromptVersion, "id" | "at">,
+		db: SQL = this.#sql,
+	): Promise<void> {
+		await db`
+			INSERT INTO prompt_history (guild_id, kind, name, action, text, previous, by_name)
+			VALUES (${this.#guild}, ${kind}, ${name}, ${entry.action}, ${entry.text}, ${entry.previous}, ${entry.by})`;
+		await db`
+			DELETE FROM prompt_history
+			WHERE guild_id = ${this.#guild} AND kind = ${kind} AND name = ${name}
+				AND id NOT IN (
+					SELECT id FROM prompt_history
+					WHERE guild_id = ${this.#guild} AND kind = ${kind} AND name = ${name}
+					ORDER BY id DESC LIMIT ${PROMPT_HISTORY_KEEP})`;
+	}
+
+	/** The newest versions first. */
+	async list(
+		kind: PromptKind,
+		name: string,
+		limit = PROMPT_HISTORY_KEEP,
+	): Promise<PromptVersion[]> {
+		const rows: HistoryRow[] = await this.#sql`
+			SELECT id, action, text, previous, by_name, at FROM prompt_history
+			WHERE guild_id = ${this.#guild} AND kind = ${kind} AND name = ${name}
+			ORDER BY id DESC LIMIT ${Math.min(Math.max(1, limit), PROMPT_HISTORY_KEEP)}`;
+		return rows.map((row) => ({
+			id: Number(row.id),
+			action: row.action,
+			text: row.text,
+			previous: row.previous,
+			by: row.by_name,
+			at: new Date(row.at),
+		}));
+	}
+}

package/src/core/modules/skills/skill-contract.ts

@@ -0,0 +1,52 @@
+import type {
+	SkillCatalogEntry,
+	SkillDocument,
+	SkillSet,
+	SkillVersion,
+} from "./skill-rules.ts";
+
+/** The skills agents carry: built in, linked from repositories, or written by an agent. */
+export interface SkillRegistry {
+	/** The built-in skills plus the named registered ones, resolved to their files. */
+	resolve(names: readonly string[]): SkillSet;
+	/** What an agent carries, built-in skills included. */
+	carried(agent: string): SkillSet;
+	/** The registered skills an agent carries, as the dashboard lists them. */
+	carriedNames(agent: string): string[];
+	/** An agent's skills as `agent_get` shows them. */
+	describeCarried(agent: string): string;
+	/** Every skill, built-in ones first. */
+	catalog(): SkillCatalogEntry[];
+	/** Every skill, or those of a group or matching a query, as the `skill_list` tool shows them. */
+	list(filter?: { group?: string; query?: string }): string;
+	/** The skills linked from a managed repository. */
+	linkedFrom(repo: string): string[];
+	/** Throws AgentError when a name is not registered; built-in names are carried already. */
+	checkRegistered(names: readonly string[]): void;
+	/** Links the skill at a repository path, or every child folder with a SKILL.md. */
+	link(repo: string, path: string): Promise<string>;
+	/** A skill's SKILL.md, whole, with its hash and whether it is editable (only an agent-written skill is). Throws AgentError for an unknown skill or one whose file cannot be read. */
+	document(name: string): Promise<SkillDocument>;
+	/**
+	 * Saves an agent-written skill's whole SKILL.md, edited from the one with hash `baseHash`; `by`
+	 * is kept with the version. The name cannot change, and the description and body are checked as
+	 * `skill_update` checks them. Throws `SkillConflictError` (with the current document) when the
+	 * skill changed meanwhile and AgentError for a read-only skill or a refused text.
+	 */
+	saveDocument(
+		name: string,
+		text: string,
+		baseHash: string,
+		by: string,
+	): Promise<SkillDocument>;
+	/** Makes a skill from a whole SKILL.md, as `skill_create` does; it is attached to no one. Throws AgentError for a taken or refused name or text. */
+	createDocument(text: string, by: string): Promise<SkillDocument>;
+	/** The saved versions of an agent-written skill, newest first; none for any other skill. */
+	documentHistory(name: string): Promise<SkillVersion[]>;
+	/** Adds and removes an agent's registered skills together, or changes nothing; returns what it carries after. */
+	attach(
+		agent: string,
+		add: readonly string[],
+		remove: readonly string[],
+	): Promise<string[]>;
+}

package/src/core/modules/skills/skill-document-files.ts

@@ -0,0 +1,66 @@
+import { readFileSync, statSync } from "node:fs";
+import { AgentError } from "../../domain/errors.ts";
+import {
+	hashOf,
+	MAX_DOCUMENT_BYTES,
+	type SkillDocument,
+	type SkillSource,
+	type SkillVersion,
+	skillFileContent,
+} from "./skill-rules.ts";
+import type { SkillEntry, StoredSkillVersion } from "./skill-store.ts";
+
+/** An agent-written skill as the owner edits it: its SKILL.md, with the hash a save is checked against. */
+export function writtenDocument(
+	entry: Extract<SkillEntry, { kind: "written" }>,
+): SkillDocument {
+	const text = skillFileContent(entry);
+	return {
+		name: entry.name,
+		source: { kind: "written" },
+		text,
+		hash: hashOf(text),
+		writable: true,
+	};
+}
+
+/** A skill the owner may read but not edit: its file as it is on disk, if it is small enough to show. */
+export function readSkillDocument(
+	name: string,
+	source: SkillSource,
+	file: string,
+): SkillDocument {
+	let size: number;
+	try {
+		size = statSync(file).size;
+	} catch {
+		throw new AgentError(`The file of the skill "${name}" cannot be read.`);
+	}
+	if (size > MAX_DOCUMENT_BYTES)
+		throw new AgentError(
+			`The file of the skill "${name}" is too large to show.`,
+		);
+	const text = readFileSync(file, "utf8");
+	return { name, source, text, hash: hashOf(text), writable: false };
+}
+
+/** The stored versions of a written skill as whole documents, in the order given. */
+export function skillVersions(
+	name: string,
+	rows: readonly StoredSkillVersion[],
+): SkillVersion[] {
+	return rows.map((version) => {
+		const text = skillFileContent({
+			name,
+			description: version.description,
+			body: version.body,
+		});
+		return {
+			id: version.id,
+			text,
+			hash: hashOf(text),
+			by: version.by,
+			at: version.at,
+		};
+	});
+}

package/src/core/modules/skills/skill-registry.ts

@@ -3,6 +3,11 @@ import { join } from "node:path";
 import { AgentError } from "../../domain/errors.ts";
 import { PluginError } from "../../errors.ts";
 import type { SkillRegistry } from "../../services.ts";
+import {
+	readSkillDocument,
+	skillVersions,
+	writtenDocument,
+} from "./skill-document-files.ts";
 import { planLinkedSkills } from "./skill-link.ts";
 import { skillCatalog, skillListText } from "./skill-listing.ts";
 import {
@@ -11,11 +16,16 @@ import {
 	checkDescription,
 	checkSkillName,
 	type PackageSkill,
+	parseSkillDocument,
 	type ResolvedSkill,
 	readSkillFile,
 	type SkillCatalogEntry,
+	SkillConflictError,
+	type SkillDocument,
 	type SkillRegistryOptions,
 	type SkillSet,
+	type SkillSource,
+	type SkillVersion,
 	skillFileContent,
 } from "./skill-rules.ts";
 import type { SkillEntry } from "./skill-store.ts";
@@ -27,15 +37,20 @@ export {
 	type PackageSkill,
 	type ResolvedSkill,
 	type SkillCatalogEntry,
+	SkillConflictError,
+	type SkillDocument,
 	type SkillRegistryOptions,
 	type SkillSet,
 	type SkillSource,
+	type SkillVersion,
 } from "./skill-rules.ts";
 
 /** The skill registry and what each agent carries. */
 export class StoredSkillRegistry implements SkillRegistry {
 	readonly #options: SkillRegistryOptions;
 	readonly #packageSkills = new Map<string, PackageSkill>();
+	/** The tail of the document writes, so a hash is checked and the skill written without another save between. */
+	#documents: Promise<unknown> = Promise.resolve();
 
 	/** Throws a PluginError when a package skill has the name of a linked or written one. */
 	constructor(options: SkillRegistryOptions) {
@@ -169,11 +184,29 @@ export class StoredSkillRegistry implements SkillRegistry {
 		return this.#removed(name, await this.#options.store.remove(name));
 	}
 
-	async create(skill: {
-		name: string;
-		description: string;
-		body: string;
-	}): Promise<string> {
+	/**
+	 * Writes a new skill. It takes its turn in the queue of the document writes, so it cannot
+	 * land between an owner's hash check and the write that follows it.
+	 */
+	create(
+		skill: {
+			name: string;
+			description: string;
+			body: string;
+		},
+		by = "agent",
+	): Promise<string> {
+		return this.#inDocuments(() => this.#create(skill, by));
+	}
+
+	async #create(
+		skill: {
+			name: string;
+			description: string;
+			body: string;
+		},
+		by: string,
+	): Promise<string> {
 		checkSkillName(skill.name);
 		this.#checkFreeName(skill.name);
 		checkDescription(skill.description);
@@ -183,14 +216,27 @@ export class StoredSkillRegistry implements SkillRegistry {
 			description: skill.description.trim(),
 			body: skill.body.trim(),
 		};
-		await this.#options.store.addWritten(entry);
+		await this.#options.store.addWritten(entry, by);
 		this.#write(entry);
 		return `Created skill ${skill.name}. Attach it with agent_skills; it loads from each carrier's next turn.`;
 	}
 
-	async update(
+	/**
+	 * Replaces an agent-written skill's description or body. It takes its turn in the queue of the
+	 * document writes, so an owner's save from a hash it passed can never overwrite it unseen.
+	 */
+	update(
 		name: string,
 		change: { description?: string; body?: string },
+		by = "agent",
+	): Promise<string> {
+		return this.#inDocuments(() => this.#update(name, change, by));
+	}
+
+	async #update(
+		name: string,
+		change: { description?: string; body?: string },
+		by: string,
 	): Promise<string> {
 		const entry = this.#writable(name);
 		if (change.description !== undefined) checkDescription(change.description);
@@ -200,11 +246,93 @@ export class StoredSkillRegistry implements SkillRegistry {
 			description: change.description?.trim() ?? entry.description,
 			body: change.body?.trim() ?? entry.body,
 		};
-		await this.#options.store.updateWritten(next);
+		await this.#options.store.updateWritten(next, by);
 		this.#write(next);
 		return `Updated skill ${name}; its carriers read the new version from their next turn.`;
 	}
 
+	// ── Documents: a SKILL.md as the owner edits it in the web app ─────────
+
+	/** A skill's SKILL.md; throws AgentError for an unknown skill or one whose file cannot be read. */
+	async document(name: string): Promise<SkillDocument> {
+		const source = this.#sourceOf(name);
+		const entry = this.#options.store.skill(name);
+		if (entry?.kind === "written") return writtenDocument(entry);
+		const file = this.#fileOf(name);
+		if (!source || !file) throw new AgentError(`There is no skill "${name}".`);
+		return readSkillDocument(name, source, file);
+	}
+
+	/**
+	 * Saves an agent-written skill's whole SKILL.md as edited from the one with hash `baseHash`.
+	 * The name cannot change; the description and body are checked as the skill tools check them.
+	 * Throws SkillConflictError, carrying the current document, when the skill is no longer the
+	 * one that was edited, and AgentError for a read-only skill or a refused text.
+	 */
+	saveDocument(
+		name: string,
+		text: string,
+		baseHash: string,
+		by: string,
+	): Promise<SkillDocument> {
+		return this.#inDocuments(async () => {
+			const entry = this.#writable(name);
+			const current = writtenDocument(entry);
+			if (current.hash !== baseHash) throw new SkillConflictError(current);
+			const next = parseSkillDocument(text);
+			if (next.name !== name)
+				throw new AgentError(
+					`The name of a skill cannot change (it is "${name}"). To use another name, create a new skill.`,
+				);
+			if (next.description === entry.description && next.body === entry.body)
+				return current;
+			await this.#update(
+				name,
+				{ description: next.description, body: next.body },
+				by,
+			);
+			return this.document(name);
+		});
+	}
+
+	/** Makes a skill from a whole SKILL.md; it is attached to no one. Throws AgentError for a taken or refused name or text. */
+	createDocument(text: string, by: string): Promise<SkillDocument> {
+		return this.#inDocuments(async () => {
+			const made = parseSkillDocument(text);
+			await this.#create(made, by);
+			return this.document(made.name);
+		});
+	}
+
+	/** The saved versions of an agent-written skill, newest first; none for any other skill. */
+	async documentHistory(name: string): Promise<SkillVersion[]> {
+		const entry = this.#options.store.skill(name);
+		if (entry?.kind !== "written") {
+			this.#sourceOf(name);
+			return [];
+		}
+		return skillVersions(name, await this.#options.store.versions(name));
+	}
+
+	#inDocuments<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#documents.then(write);
+		this.#documents = run.catch(() => undefined);
+		return run;
+	}
+
+	/** Where a skill comes from; throws AgentError for a name nobody registered. */
+	#sourceOf(name: string): SkillSource {
+		if ((BUILTIN_SKILLS as readonly string[]).includes(name))
+			return { kind: "builtin" };
+		const fromPackage = this.#packageSkills.get(name);
+		if (fromPackage) return { kind: "package", package: fromPackage.package };
+		const entry = this.#options.store.skill(name);
+		if (!entry) throw new AgentError(`There is no skill "${name}".`);
+		return entry.kind === "linked"
+			? { kind: "linked", repo: entry.repo, path: entry.path }
+			: { kind: "written" };
+	}
+
 	async delete(name: string): Promise<string> {
 		this.#writable(name);
 		const detached = await this.#options.store.remove(name);

package/src/core/modules/skills/skill-rules.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { AgentError } from "../../domain/errors.ts";
@@ -130,3 +131,96 @@ export const skillFileContent = (entry: {
 
 export const cut = (text: string, max: number) =>
 	text.length > max ? `${text.slice(0, max - 1)}…` : text;
+
+/** The most bytes of a SKILL.md the registry reads for the web app. */
+export const MAX_DOCUMENT_BYTES = 64 * 1024;
+
+/** A skill's SKILL.md as the owner reads and edits it. */
+export interface SkillDocument {
+	name: string;
+	source: SkillSource;
+	/** The whole file: frontmatter and body. */
+	text: string;
+	/** SHA-256 of `text`; a save names the hash it was edited from. */
+	hash: string;
+	/** An agent-written skill; the others are read-only here. */
+	writable: boolean;
+}
+
+/** One saved version of an agent-written skill's SKILL.md. */
+export interface SkillVersion {
+	id: number;
+	text: string;
+	hash: string;
+	/** Who saved it: the owner's name, or `agent` for a skill tool. */
+	by: string;
+	at: Date;
+}
+
+/** A save made from a SKILL.md that is no longer the current one; `current` is what is there now. */
+export class SkillConflictError extends Error {
+	override name = "SkillConflictError";
+	constructor(readonly current: SkillDocument) {
+		super(`The skill "${current.name}" changed while it was being edited.`);
+	}
+}
+
+export const hashOf = (text: string): string =>
+	createHash("sha256").update(text).digest("hex");
+
+/** The fields a SKILL.md holds when the registry writes it; any other frontmatter key is refused. */
+const FRONTMATTER_KEYS = ["name", "description"] as const;
+
+/**
+ * Reads a SKILL.md the owner wrote: frontmatter with a `name` and a `description`, then the body.
+ * The description and body are checked as the skill tools check them (`checkDescription`,
+ * `checkBody`), and a key besides the two is refused rather than dropped when the file is written
+ * again. Throws AgentError with the reason.
+ */
+export function parseSkillDocument(text: string): {
+	name: string;
+	description: string;
+	body: string;
+} {
+	const normalized = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+	if (!normalized.startsWith("---\n") || !normalized.includes("\n---", 3))
+		throw new AgentError(
+			"A SKILL.md starts with frontmatter between two --- lines, holding name and description.",
+		);
+	let parsed: { frontmatter: Record<string, unknown>; body: string };
+	try {
+		parsed = parseFrontmatter<Record<string, unknown>>(normalized);
+	} catch (error) {
+		throw new AgentError(
+			`The frontmatter is not valid YAML: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`,
+		);
+	}
+	const { frontmatter, body } = parsed;
+	if (
+		typeof frontmatter !== "object" ||
+		frontmatter === null ||
+		Array.isArray(frontmatter)
+	)
+		throw new AgentError(
+			"The frontmatter must be keys and values: name and description.",
+		);
+	const extra = Object.keys(frontmatter).filter(
+		(key) => !(FRONTMATTER_KEYS as readonly string[]).includes(key),
+	);
+	if (extra.length > 0)
+		throw new AgentError(
+			`The frontmatter has ${extra.map((key) => `"${key}"`).join(", ")}; only name and description are kept.`,
+		);
+	const { name, description } = frontmatter;
+	if (typeof name !== "string" || !name.trim())
+		throw new AgentError("The frontmatter needs a name.");
+	if (typeof description !== "string" || !description.trim())
+		throw new AgentError("The frontmatter needs a description.");
+	checkDescription(description);
+	checkBody(body);
+	return {
+		name: name.trim(),
+		description: description.trim(),
+		body: body.trim(),
+	};
+}

package/src/core/modules/skills/skill-store.ts

@@ -18,6 +18,18 @@ export interface SkillGroup {
 	skills: string[];
 }
 
+/** One saved version of a written skill. */
+export interface StoredSkillVersion {
+	id: number;
+	description: string;
+	body: string;
+	by: string;
+	at: Date;
+}
+
+/** The newest versions of a written skill the store keeps. */
+export const SKILL_VERSIONS_KEEP = 50;
+
 /** Who lost a removed skill. */
 export interface Detached {
 	agents: string[];
@@ -39,6 +51,14 @@ interface GroupRow {
 	skills: string;
 }
 
+interface VersionRow {
+	id: string | number;
+	description: string;
+	body: string;
+	by_name: string;
+	at: Date;
+}
+
 const toEntry = (row: SkillRow): SkillEntry =>
 	row.kind === "linked"
 		? {
@@ -121,6 +141,22 @@ export class SkillStore {
 	static migrations(guildId: string): Migration[] {
 		return [
 			SkillStore.migration,
+			// The versions of the written skills, kept for the web app's history.
+			{
+				name: "skill-versions",
+				up: async (sql) => {
+					await sql`
+						CREATE TABLE IF NOT EXISTS skill_versions (
+							id bigserial PRIMARY KEY,
+							name text NOT NULL,
+							description text NOT NULL,
+							body text NOT NULL,
+							by_name text NOT NULL,
+							at timestamptz NOT NULL DEFAULT now()
+						)`;
+					await sql`CREATE INDEX IF NOT EXISTS skill_versions_of ON skill_versions (name, id)`;
+				},
+			},
 			{
 				name: "skills-guild",
 				up: (sql) =>
@@ -225,35 +261,69 @@ export class SkillStore {
 		});
 	}
 
-	async addWritten(skill: {
-		name: string;
-		description: string;
-		body: string;
-	}): Promise<void> {
+	async addWritten(
+		skill: { name: string; description: string; body: string },
+		by = "agent",
+	): Promise<void> {
 		return this.#serial(async () => {
 			if (this.#skills.has(skill.name))
 				throw new AgentError(`A skill named "${skill.name}" already exists.`);
-			await this.#sql`
-				INSERT INTO skills (name, kind, description, body)
-				VALUES (${skill.name}, 'written', ${skill.description}, ${skill.body})`;
+			await this.#sql.begin(async (tx) => {
+				await tx`
+					INSERT INTO skills (name, kind, description, body)
+					VALUES (${skill.name}, 'written', ${skill.description}, ${skill.body})`;
+				await this.#keepVersion(tx, skill, by);
+			});
 			this.#skills.set(skill.name, { kind: "written", ...skill });
 		});
 	}
 
-	async updateWritten(skill: {
-		name: string;
-		description: string;
-		body: string;
-	}): Promise<void> {
+	async updateWritten(
+		skill: { name: string; description: string; body: string },
+		by = "agent",
+	): Promise<void> {
 		return this.#serial(async () => {
-			await this.#sql`
-				UPDATE skills SET description = ${skill.description}, body = ${skill.body},
-					updated_at = now()
-				WHERE name = ${skill.name} AND kind = 'written'`;
+			await this.#sql.begin(async (tx) => {
+				await tx`
+					UPDATE skills SET description = ${skill.description}, body = ${skill.body},
+						updated_at = now()
+					WHERE name = ${skill.name} AND kind = 'written'`;
+				await this.#keepVersion(tx, skill, by);
+			});
 			this.#skills.set(skill.name, { kind: "written", ...skill });
 		});
 	}
 
+	/** Writes a version of a skill and drops the ones beyond the newest `SKILL_VERSIONS_KEEP`. */
+	async #keepVersion(
+		tx: SQL,
+		skill: { name: string; description: string; body: string },
+		by: string,
+	): Promise<void> {
+		await tx`
+			INSERT INTO skill_versions (name, description, body, by_name)
+			VALUES (${skill.name}, ${skill.description}, ${skill.body}, ${by})`;
+		await tx`
+			DELETE FROM skill_versions
+			WHERE name = ${skill.name} AND id NOT IN (
+				SELECT id FROM skill_versions WHERE name = ${skill.name}
+				ORDER BY id DESC LIMIT ${SKILL_VERSIONS_KEEP})`;
+	}
+
+	/** The saved versions of a written skill, newest first. */
+	async versions(name: string): Promise<StoredSkillVersion[]> {
+		const rows: VersionRow[] = await this.#sql`
+			SELECT id, description, body, by_name, at FROM skill_versions
+			WHERE name = ${name} ORDER BY id DESC LIMIT ${SKILL_VERSIONS_KEEP}`;
+		return rows.map((row) => ({
+			id: Number(row.id),
+			description: row.description,
+			body: row.body,
+			by: row.by_name,
+			at: new Date(row.at),
+		}));
+	}
+
 	/** Removes a skill and detaches it from every agent and group. */
 	async remove(name: string): Promise<Detached> {
 		return this.#serial(async () => {
@@ -263,6 +333,7 @@ export class SkillStore {
 			);
 			await this.#sql.begin(async (tx) => {
 				await tx`DELETE FROM skills WHERE name = ${name}`;
+				await tx`DELETE FROM skill_versions WHERE name = ${name}`;
 				await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND skill = ${name}`;
 				for (const group of groups)
 					await tx`