pi-roundtable 0.22.1 → 0.22.2

package/CHANGELOG.md

@@ -5,6 +5,12 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.22.2] - 2026-10-21
+
+### Fixed
+
+- A skill linked while another was removed no longer vanishes from the registry (`pi-roundtable`). `skill_unlink` reloaded the whole skill cache from the database after its delete, so a `skill_link` running at the same time, as two tool calls of one model message do, could commit its row after the reload had read the table and then be dropped from memory: the skill was missing from `skill_list`, unknown to `agent_skills` and `skill_group_set`, and could be neither unlinked nor linked again until a restart. The skill store now updates its memory from what each write committed and runs its writes one at a time, and a link that meets an existing row says "Already registered" instead of PostgreSQL's duplicate-key error. The agent store's seeding no longer reloads its cache either, and its agent and group writes also run one at a time, so an agent archived while its group is updated cannot come back as a member.
+
 ## [0.22.1] - 2026-10-21
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.22.1",
+	"version": "0.22.2",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/agents/agent-store.ts

@@ -58,6 +58,8 @@ export class PgAgentStore implements AgentDirectory {
 	readonly #sql: SQL;
 	readonly #agents = new Map<string, Agent>();
 	readonly #groups = new Map<string, AgentGroup>();
+	/** The tail of the agent and group writes, which run one at a time so none reads a map another is about to change. */
+	#queue: Promise<unknown> = Promise.resolve();
 
 	readonly #guild: string;
 	readonly #messages: GroupMessages;
@@ -97,18 +99,27 @@ export class PgAgentStore implements AgentDirectory {
 
 	/** Inserts seed agents that do not exist yet; existing rows, edited or not, are left alone. */
 	async seed(seeds: readonly AgentSeed[]): Promise<string[]> {
-		const added: string[] = [];
-		for (const seed of seeds) {
-			const rows: unknown[] = await this.#sql`
+		return this.#serial(async () => {
+			const added: string[] = [];
+			for (const seed of seeds) {
+				const rows: AgentRow[] = await this.#sql`
 				INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id)
 				VALUES (${this.#guild}, ${seed.name}, ${seed.displayName}, ${seed.prompt}, ${seed.avatarPrompt},
 					${seed.channelId ?? null})
 				ON CONFLICT DO NOTHING
-				RETURNING name`;
-			if (rows.length > 0) added.push(seed.name);
-		}
-		await this.#reload();
-		return added;
+				RETURNING *`;
+				// Only the inserted rows join the map: reloading it whole would drop a write that
+				// committed after its SELECT.
+				if (rows[0]) added.push(this.#keepAgent(rows[0]).name);
+			}
+			return added;
+		});
+	}
+
+	#serial<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#queue.then(write);
+		this.#queue = run.catch(() => undefined);
+		return run;
 	}
 
 	agents(): Agent[] {
@@ -178,18 +189,20 @@ export class PgAgentStore implements AgentDirectory {
 		avatarPrompt: string;
 		channelId: string;
 	}): Promise<Agent> {
-		checkAgentName(agent.name);
-		checkDisplayName(agent.displayName);
-		checkPrompt(agent.prompt);
-		// An agent of a host without an image provider has no avatar prompt.
-		if (agent.avatarPrompt !== "") checkAvatarPrompt(agent.avatarPrompt);
-		this.#checkFree(agent.name);
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			checkAgentName(agent.name);
+			checkDisplayName(agent.displayName);
+			checkPrompt(agent.prompt);
+			// An agent of a host without an image provider has no avatar prompt.
+			if (agent.avatarPrompt !== "") checkAvatarPrompt(agent.avatarPrompt);
+			this.#checkFree(agent.name);
+			const rows: AgentRow[] = await this.#sql`
 			INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id)
 			VALUES (${this.#guild}, ${agent.name}, ${agent.displayName.trim()}, ${agent.prompt}, ${agent.avatarPrompt},
 				${agent.channelId})
 			RETURNING *`;
-		return this.#keepAgent(rows[0]);
+			return this.#keepAgent(rows[0]);
+		});
 	}
 
 	/** A name that createAgent would accept, checked before its channel is made. */
@@ -211,20 +224,22 @@ export class PgAgentStore implements AgentDirectory {
 			thinking?: ThinkingLevel | null;
 		},
 	): Promise<Agent> {
-		const current = this.activeAgent(name);
-		if (change.displayName !== undefined) checkDisplayName(change.displayName);
-		if (change.prompt !== undefined) checkPrompt(change.prompt);
-		if (change.avatarPrompt !== undefined)
-			checkAvatarPrompt(change.avatarPrompt);
-		if (change.model) checkModelRef(change.model);
-		if (change.thinking) checkThinking(change.thinking);
-		const model =
-			change.model === undefined ? (current.model ?? null) : change.model;
-		const thinking =
-			change.thinking === undefined
-				? (current.thinking ?? null)
-				: change.thinking;
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			const current = this.activeAgent(name);
+			if (change.displayName !== undefined)
+				checkDisplayName(change.displayName);
+			if (change.prompt !== undefined) checkPrompt(change.prompt);
+			if (change.avatarPrompt !== undefined)
+				checkAvatarPrompt(change.avatarPrompt);
+			if (change.model) checkModelRef(change.model);
+			if (change.thinking) checkThinking(change.thinking);
+			const model =
+				change.model === undefined ? (current.model ?? null) : change.model;
+			const thinking =
+				change.thinking === undefined
+					? (current.thinking ?? null)
+					: change.thinking;
+			const rows: AgentRow[] = await this.#sql`
 			UPDATE agents SET
 				display_name = ${change.displayName?.trim() ?? current.displayName},
 				prompt = ${change.prompt ?? current.prompt},
@@ -236,29 +251,33 @@ export class PgAgentStore implements AgentDirectory {
 				updated_at = now()
 			WHERE guild_id = ${this.#guild} AND name = ${name}
 			RETURNING *`;
-		return this.#keepAgent(rows[0]);
+			return this.#keepAgent(rows[0]);
+		});
 	}
 
 	/** Archives an agent and takes it out of every group; says which groups it left. */
 	async archiveAgent(name: string): Promise<AgentGroup[]> {
-		const rows: AgentRow[] = await this.#sql`
+		return this.#serial(async () => {
+			const rows: AgentRow[] = await this.#sql`
 			UPDATE agents SET status = 'archived', updated_at = now()
 			WHERE guild_id = ${this.#guild} AND name = ${name} RETURNING *`;
-		this.#keepAgent(rows[0]);
-		const left: AgentGroup[] = [];
-		for (const group of this.groups()) {
-			if (group.status !== "active" || !group.members.includes(name)) continue;
-			const members = group.members.filter((m) => m !== name);
-			const host = group.host === name ? (members[0] ?? name) : group.host;
-			left.push(
-				await this.#writeGroup(group.name, {
-					members,
-					host,
-					status: members.length < MIN_GROUP_MEMBERS ? "archived" : "active",
-				}),
-			);
-		}
-		return left;
+			this.#keepAgent(rows[0]);
+			const left: AgentGroup[] = [];
+			for (const group of this.groups()) {
+				if (group.status !== "active" || !group.members.includes(name))
+					continue;
+				const members = group.members.filter((m) => m !== name);
+				const host = group.host === name ? (members[0] ?? name) : group.host;
+				left.push(
+					await this.#writeGroup(group.name, {
+						members,
+						host,
+						status: members.length < MIN_GROUP_MEMBERS ? "archived" : "active",
+					}),
+				);
+			}
+			return left;
+		});
 	}
 
 	#keepAgent(row: AgentRow | undefined): Agent {
@@ -296,39 +315,44 @@ export class PgAgentStore implements AgentDirectory {
 		members: string[];
 		host: string;
 	}): Promise<AgentGroup> {
-		this.checkNewGroup(group.name, group.members, group.host);
-		checkDisplayName(group.displayName);
-		const rows: GroupRow[] = await this.#sql`
+		return this.#serial(async () => {
+			this.checkNewGroup(group.name, group.members, group.host);
+			checkDisplayName(group.displayName);
+			const rows: GroupRow[] = await this.#sql`
 			INSERT INTO agent_groups (guild_id, name, display_name, channel_id, members, host)
 			VALUES (${this.#guild}, ${group.name}, ${group.displayName.trim()}, ${group.channelId},
 				${group.members.join(",")}, ${group.host})
 			RETURNING *`;
-		return this.#keepGroup(rows[0]);
+			return this.#keepGroup(rows[0]);
+		});
 	}
 
 	async updateGroup(
 		name: string,
 		change: { displayName?: string; members?: string[]; host?: string },
 	): Promise<AgentGroup> {
-		const current = this.#groups.get(name);
-		if (current?.status !== "active")
-			throw new AgentError(`There is no active group "${name}".`);
-		if (change.displayName !== undefined) checkDisplayName(change.displayName);
-		const members = change.members ?? current.members;
-		const host =
-			change.host ??
-			(members.includes(current.host) ? current.host : (members[0] ?? ""));
-		this.#checkMembers(members, host);
-		return this.#writeGroup(name, {
-			displayName: change.displayName?.trim() ?? current.displayName,
-			members,
-			host,
-			status: "active",
+		return this.#serial(async () => {
+			const current = this.#groups.get(name);
+			if (current?.status !== "active")
+				throw new AgentError(`There is no active group "${name}".`);
+			if (change.displayName !== undefined)
+				checkDisplayName(change.displayName);
+			const members = change.members ?? current.members;
+			const host =
+				change.host ??
+				(members.includes(current.host) ? current.host : (members[0] ?? ""));
+			this.#checkMembers(members, host);
+			return this.#writeGroup(name, {
+				displayName: change.displayName?.trim() ?? current.displayName,
+				members,
+				host,
+				status: "active",
+			});
 		});
 	}
 
 	async archiveGroup(name: string): Promise<AgentGroup> {
-		return this.#writeGroup(name, { status: "archived" });
+		return this.#serial(() => this.#writeGroup(name, { status: "archived" }));
 	}
 
 	async #writeGroup(

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

@@ -70,6 +70,11 @@ export class SkillStore {
 	readonly #skills = new Map<string, SkillEntry>();
 	readonly #groups = new Map<string, SkillGroup>();
 	readonly #carried = new Map<string, string[]>();
+	/**
+	 * The tail of the mutations, which run one at a time: each checks the maps, writes, then
+	 * updates the maps from what it committed, and none may interleave with another.
+	 */
+	#queue: Promise<unknown> = Promise.resolve();
 
 	readonly #guild: string;
 
@@ -152,6 +157,12 @@ export class SkillStore {
 			]);
 	}
 
+	#serial<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#queue.then(write);
+		this.#queue = run.catch(() => undefined);
+		return run;
+	}
+
 	skills(): SkillEntry[] {
 		return [...this.#skills.values()].sort((a, b) =>
 			a.name.localeCompare(b.name),
@@ -189,19 +200,29 @@ export class SkillStore {
 	async addLinked(
 		entries: readonly { name: string; repo: string; path: string }[],
 	): Promise<void> {
-		const taken = entries.filter((entry) => this.#skills.has(entry.name));
-		if (taken.length > 0)
-			throw new AgentError(
-				`Already registered: ${taken.map((entry) => entry.name).join(", ")}. Nothing was linked.`,
-			);
-		await this.#sql.begin(async (tx) => {
+		return this.#serial(async () => {
+			const taken = entries.filter((entry) => this.#skills.has(entry.name));
+			const refuse = (names: string[]) =>
+				new AgentError(
+					`Already registered: ${names.join(", ")}. Nothing was linked.`,
+				);
+			if (taken.length > 0) throw refuse(taken.map((entry) => entry.name));
+			try {
+				await this.#sql.begin(async (tx) => {
+					for (const entry of entries)
+						await tx`
+							INSERT INTO skills (name, kind, repo, path)
+							VALUES (${entry.name}, 'linked', ${entry.repo}, ${entry.path})`;
+				});
+			} catch (error) {
+				// A row the maps do not hold, such as a duplicate within `entries`.
+				if (isUniqueViolation(error))
+					throw refuse(entries.map((entry) => entry.name));
+				throw error;
+			}
 			for (const entry of entries)
-				await tx`
-					INSERT INTO skills (name, kind, repo, path)
-					VALUES (${entry.name}, 'linked', ${entry.repo}, ${entry.path})`;
+				this.#skills.set(entry.name, { kind: "linked", ...entry });
 		});
-		for (const entry of entries)
-			this.#skills.set(entry.name, { kind: "linked", ...entry });
 	}
 
 	async addWritten(skill: {
@@ -209,12 +230,14 @@ export class SkillStore {
 		description: string;
 		body: string;
 	}): Promise<void> {
-		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})`;
-		this.#skills.set(skill.name, { kind: "written", ...skill });
+		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})`;
+			this.#skills.set(skill.name, { kind: "written", ...skill });
+		});
 	}
 
 	async updateWritten(skill: {
@@ -222,54 +245,84 @@ export class SkillStore {
 		description: string;
 		body: string;
 	}): Promise<void> {
-		await this.#sql`
-			UPDATE skills SET description = ${skill.description}, body = ${skill.body},
-				updated_at = now()
-			WHERE name = ${skill.name} AND kind = 'written'`;
-		this.#skills.set(skill.name, { kind: "written", ...skill });
+		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'`;
+			this.#skills.set(skill.name, { kind: "written", ...skill });
+		});
 	}
 
 	/** Removes a skill and detaches it from every agent and group. */
 	async remove(name: string): Promise<Detached> {
-		const agents = this.carriers(name);
-		const groups = this.groups().filter((group) => group.skills.includes(name));
-		await this.#sql.begin(async (tx) => {
-			await tx`DELETE FROM skills WHERE name = ${name}`;
-			await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND skill = ${name}`;
+		return this.#serial(async () => {
+			const agents = this.carriers(name);
+			const groups = this.groups().filter((group) =>
+				group.skills.includes(name),
+			);
+			await this.#sql.begin(async (tx) => {
+				await tx`DELETE FROM skills WHERE name = ${name}`;
+				await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND skill = ${name}`;
+				for (const group of groups)
+					await tx`
+						UPDATE skill_groups
+						SET skills = ${group.skills.filter((s) => s !== name).join(",")}
+						WHERE name = ${group.name}`;
+			});
+			// The maps follow the transaction; reloading them all here would drop a write that
+			// committed after its SELECT.
+			this.#skills.delete(name);
+			for (const agent of agents) {
+				const left = this.carriedBy(agent).filter((s) => s !== name);
+				if (left.length > 0) this.#carried.set(agent, left);
+				else this.#carried.delete(agent);
+			}
 			for (const group of groups)
-				await tx`
-					UPDATE skill_groups
-					SET skills = ${group.skills.filter((s) => s !== name).join(",")}
-					WHERE name = ${group.name}`;
+				this.#groups.set(group.name, {
+					...group,
+					skills: group.skills.filter((s) => s !== name),
+				});
+			return { agents, groups: groups.map((group) => group.name) };
 		});
-		await this.#reload();
-		return { agents, groups: groups.map((group) => group.name) };
 	}
 
 	async setGroup(group: SkillGroup): Promise<void> {
-		await this.#sql`
-			INSERT INTO skill_groups (name, description, skills)
-			VALUES (${group.name}, ${group.description}, ${group.skills.join(",")})
-			ON CONFLICT (name) DO UPDATE
-			SET description = EXCLUDED.description, skills = EXCLUDED.skills`;
-		this.#groups.set(group.name, { ...group, skills: [...group.skills] });
+		return this.#serial(async () => {
+			await this.#sql`
+				INSERT INTO skill_groups (name, description, skills)
+				VALUES (${group.name}, ${group.description}, ${group.skills.join(",")})
+				ON CONFLICT (name) DO UPDATE
+				SET description = EXCLUDED.description, skills = EXCLUDED.skills`;
+			this.#groups.set(group.name, { ...group, skills: [...group.skills] });
+		});
 	}
 
 	async removeGroup(name: string): Promise<void> {
-		await this.#sql`DELETE FROM skill_groups WHERE name = ${name}`;
-		this.#groups.delete(name);
+		return this.#serial(async () => {
+			await this.#sql`DELETE FROM skill_groups WHERE name = ${name}`;
+			this.#groups.delete(name);
+		});
 	}
 
 	/** Replaces the registered skills an agent carries. */
 	async setCarried(agent: string, skills: readonly string[]): Promise<void> {
 		// pi-lens-ignore: no-sort-without-comparator — skill names sort by code unit, the same order on every machine
 		const sorted = [...new Set(skills)].sort();
-		await this.#sql.begin(async (tx) => {
-			await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND agent = ${agent}`;
-			for (const skill of sorted)
-				await tx`INSERT INTO agent_skills (guild_id, agent, skill) VALUES (${this.#guild}, ${agent}, ${skill})`;
+		return this.#serial(async () => {
+			await this.#sql.begin(async (tx) => {
+				await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND agent = ${agent}`;
+				for (const skill of sorted)
+					await tx`INSERT INTO agent_skills (guild_id, agent, skill) VALUES (${this.#guild}, ${agent}, ${skill})`;
+			});
+			if (sorted.length > 0) this.#carried.set(agent, sorted);
+			else this.#carried.delete(agent);
 		});
-		if (sorted.length > 0) this.#carried.set(agent, sorted);
-		else this.#carried.delete(agent);
 	}
 }
+
+/** PostgreSQL's unique_violation, as Bun's driver reports it. */
+function isUniqueViolation(error: unknown): boolean {
+	const fields = error as { errno?: unknown; code?: unknown } | null;
+	return fields?.errno === "23505" || fields?.code === "23505";
+}