world-model-optimizer 0.2.0__py3-none-any.whl

wmo/harness/vendor/pi-agent/test/harness/session.test.ts

@@ -0,0 +1,156 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { NodeExecutionEnv } from "../../src/harness/env/nodejs.ts";
+import { JsonlSessionStorage } from "../../src/harness/session/jsonl-storage.ts";
+import { InMemorySessionStorage } from "../../src/harness/session/memory-storage.ts";
+import { Session } from "../../src/harness/session/session.ts";
+import type { SessionStorage } from "../../src/harness/types.ts";
+import { createAssistantMessage, createTempDir, createUserMessage, getLatestTempDir } from "./session-test-utils.ts";
+
+async function runSessionSuite(
+	name: string,
+	createStorage: () => SessionStorage | Promise<SessionStorage>,
+	inspect?: () => void,
+) {
+	describe(name, () => {
+		it("appends messages and builds context in order", async () => {
+			const session = new Session(await createStorage());
+			await session.appendMessage(createUserMessage("one"));
+			await session.appendMessage(createAssistantMessage("two"));
+			const context = await session.buildContext();
+			expect(context.messages.map((message) => message.role)).toEqual(["user", "assistant"]);
+		});
+
+		it("tracks model and thinking level changes", async () => {
+			const session = new Session(await createStorage());
+			await session.appendMessage(createUserMessage("one"));
+			await session.appendModelChange("openai", "gpt-4.1");
+			await session.appendThinkingLevelChange("high");
+			const context = await session.buildContext();
+			expect(context.thinkingLevel).toBe("high");
+			expect(context.model).toEqual({ provider: "openai", modelId: "gpt-4.1" });
+		});
+
+		it("supports branching by moving the leaf and appending a new branch", async () => {
+			const session = new Session(await createStorage());
+			const user1 = await session.appendMessage(createUserMessage("one"));
+			const assistant1 = await session.appendMessage(createAssistantMessage("two"));
+			await session.appendMessage(createUserMessage("three"));
+			await session.moveTo(user1);
+			await session.appendMessage(createAssistantMessage("branched"));
+			const branch = await session.getBranch();
+			expect(branch.map((entry) => entry.id)).toContain(user1);
+			expect(branch.map((entry) => entry.id)).not.toContain(assistant1);
+			const context = await session.buildContext();
+			expect(context.messages.map((message) => message.role)).toEqual(["user", "assistant"]);
+		});
+
+		it("supports moving the leaf to root", async () => {
+			const session = new Session(await createStorage());
+			await session.appendMessage(createUserMessage("one"));
+			await session.moveTo(null);
+			expect(await session.getLeafId()).toBeNull();
+			expect((await session.buildContext()).messages).toEqual([]);
+		});
+
+		it("reconstructs compaction summaries in context", async () => {
+			const session = new Session(await createStorage());
+			await session.appendMessage(createUserMessage("one"));
+			await session.appendMessage(createAssistantMessage("two"));
+			const user2 = await session.appendMessage(createUserMessage("three"));
+			await session.appendMessage(createAssistantMessage("four"));
+			await session.appendCompaction("summary", user2, 1234);
+			await session.appendMessage(createUserMessage("five"));
+			const context = await session.buildContext();
+			expect(context.messages[0]?.role).toBe("compactionSummary");
+			expect(context.messages).toHaveLength(4);
+		});
+
+		it("supports moving with branch summary entries in context", async () => {
+			const session = new Session(await createStorage());
+			const user1 = await session.appendMessage(createUserMessage("one"));
+			const summaryId = await session.moveTo(user1, { summary: "summary text" });
+			expect(summaryId).toBeTruthy();
+			const summaryEntry = await session.getEntry(summaryId!);
+			expect(summaryEntry).toMatchObject({ type: "branch_summary", parentId: user1, fromId: user1 });
+			const context = await session.buildContext();
+			expect(context.messages[1]?.role).toBe("branchSummary");
+		});
+
+		it("supports custom message entries in context", async () => {
+			const session = new Session(await createStorage());
+			await session.appendMessage(createUserMessage("one"));
+			await session.appendCustomMessageEntry("custom", "hello", true, { ok: true });
+			const context = await session.buildContext();
+			expect(context.messages[1]?.role).toBe("custom");
+		});
+
+		it("normalizes session names", async () => {
+			const session = new Session(await createStorage());
+			await session.appendSessionName(" hello\nworld\r\nagain ");
+			expect(await session.getSessionName()).toBe("hello world again");
+		});
+
+		it("supports labels and session info entries without affecting context", async () => {
+			const session = new Session(await createStorage());
+			const user1 = await session.appendMessage(createUserMessage("one"));
+			await session.appendLabel(user1, "checkpoint");
+			await session.appendSessionName("name");
+			const entries = await session.getEntries();
+			expect(entries.some((entry) => entry.type === "label")).toBe(true);
+			expect(entries.some((entry) => entry.type === "session_info")).toBe(true);
+			expect(await session.getLabel(user1)).toBe("checkpoint");
+			expect(await session.getSessionName()).toBe("name");
+			expect((await session.buildContext()).messages).toHaveLength(1);
+		});
+
+		it("rejects labels for missing entries", async () => {
+			const session = new Session(await createStorage());
+			await expect(session.appendLabel("missing", "checkpoint")).rejects.toThrow("Entry missing not found");
+		});
+
+		it("persists leaf changes and appended entries via storage", async () => {
+			const storage = await createStorage();
+			const session = new Session(storage);
+			const user1 = await session.appendMessage(createUserMessage("one"));
+			await session.appendMessage(createAssistantMessage("two"));
+			await session.appendLabel(user1, "checkpoint");
+			await session.appendSessionName("name");
+			await session.moveTo(user1);
+			await session.appendMessage(createAssistantMessage("branched"));
+			const session2 = new Session(storage);
+			const context = await session2.buildContext();
+			expect(context.messages.map((message) => message.role)).toEqual(["user", "assistant"]);
+			expect(await session2.getLabel(user1)).toBe("checkpoint");
+			expect(await session2.getSessionName()).toBe("name");
+			inspect?.();
+		});
+	});
+}
+
+runSessionSuite("Session with in-memory storage", () => new InMemorySessionStorage());
+
+runSessionSuite(
+	"Session with JSONL storage",
+	async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		return await JsonlSessionStorage.create(env, join(dir, "session.jsonl"), { cwd: dir, sessionId: "session-1" });
+	},
+	() => {
+		const dir = getLatestTempDir();
+		const filePath = join(dir, "session.jsonl");
+		const lines = readFileSync(filePath, "utf8").trim().split("\n");
+		expect(lines.length).toBeGreaterThan(1);
+		const header = JSON.parse(lines[0]!);
+		expect(header.type).toBe("session");
+		expect(header.version).toBe(3);
+		const entries = lines.slice(1).map((line) => JSON.parse(line));
+		expect(entries.some((entry) => entry.type === "leaf")).toBe(true);
+		for (const entry of entries) {
+			expect(entry.type).not.toBe("entry");
+			expect(typeof entry.id).toBe("string");
+		}
+	},
+);

wmo/harness/vendor/pi-agent/test/harness/skills.test.ts

@@ -0,0 +1,116 @@
+import { symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { NodeExecutionEnv } from "../../src/harness/env/nodejs.ts";
+import { loadSkills, loadSourcedSkills } from "../../src/harness/skills.ts";
+import { createTempDir } from "./session-test-utils.ts";
+
+describe("loadSkills", () => {
+	it("loads SKILL.md files through the execution environment", async () => {
+		const root = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: root });
+		await env.createDir(".agents/skills/example", { recursive: true });
+		await env.writeFile(
+			".agents/skills/example/SKILL.md",
+			`---
+name: example
+description: Example skill
+disable-model-invocation: true
+---
+Use this skill.
+`,
+		);
+
+		const { skills, diagnostics } = await loadSkills(env, ".agents/skills");
+
+		expect(diagnostics).toEqual([]);
+		expect(skills).toEqual([
+			{
+				name: "example",
+				description: "Example skill",
+				content: "Use this skill.",
+				filePath: join(root, ".agents/skills/example/SKILL.md"),
+				disableModelInvocation: true,
+			},
+		]);
+	});
+
+	it("loads skills through symlinked directories", async () => {
+		const root = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: root });
+		await env.createDir("actual/example", { recursive: true });
+		await env.writeFile(
+			"actual/example/SKILL.md",
+			"---\nname: example\ndescription: Example skill\n---\nUse this skill.",
+		);
+		await symlink(join(root, "actual"), join(root, "skills-link"));
+
+		const { skills } = await loadSkills(env, "skills-link");
+
+		expect(skills.map((skill) => skill.name)).toEqual(["example"]);
+		expect(skills[0]?.filePath).toBe(join(root, "skills-link/example/SKILL.md"));
+	});
+
+	it("preserves source info for sourced skills", async () => {
+		const root = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: root });
+		await env.createDir("user/example", { recursive: true });
+		await env.writeFile(
+			"user/example/SKILL.md",
+			"---\nname: example\ndescription: Example skill\n---\nUse this skill.",
+		);
+
+		const { skills, diagnostics } = await loadSourcedSkills(env, [
+			{ path: "user", source: { type: "user" as const } },
+		]);
+
+		expect(diagnostics).toEqual([]);
+		expect(skills).toEqual([
+			{
+				skill: {
+					name: "example",
+					description: "Example skill",
+					content: "Use this skill.",
+					filePath: join(root, "user/example/SKILL.md"),
+					disableModelInvocation: false,
+				},
+				source: { type: "user" },
+			},
+		]);
+	});
+
+	it("attaches source info to diagnostics", async () => {
+		const root = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: root });
+		await env.createDir("user/broken", { recursive: true });
+		await env.writeFile("user/broken/SKILL.md", "---\nname: broken\n---\nMissing description.");
+
+		const { skills, diagnostics } = await loadSourcedSkills(env, [
+			{ path: "user", source: { type: "user" as const } },
+		]);
+
+		expect(skills).toEqual([]);
+		expect(diagnostics).toEqual([
+			{
+				type: "warning",
+				code: "invalid_metadata",
+				message: "description is required",
+				path: join(root, "user/broken/SKILL.md"),
+				source: { type: "user" },
+			},
+		]);
+	});
+
+	it("loads direct markdown children only from the root directory", async () => {
+		const root = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: root });
+		await env.createDir("skills/nested", { recursive: true });
+		await env.writeFile("skills/root.md", "---\ndescription: Root skill\n---\nRoot content");
+		await env.writeFile("skills/nested/ignored.md", "---\ndescription: Ignored\n---\nIgnored content");
+
+		const { skills } = await loadSkills(env, "skills");
+
+		expect(skills.map((skill) => skill.name)).toEqual(["skills"]);
+		expect(skills[0]?.content).toBe("Root content");
+	});
+});

wmo/harness/vendor/pi-agent/test/harness/storage.test.ts

@@ -0,0 +1,299 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { NodeExecutionEnv } from "../../src/harness/env/nodejs.ts";
+import { JsonlSessionStorage, loadJsonlSessionMetadata } from "../../src/harness/session/jsonl-storage.ts";
+import { InMemorySessionStorage } from "../../src/harness/session/memory-storage.ts";
+import { type MessageEntry, ok, type SessionMetadata } from "../../src/harness/types.ts";
+import { createAssistantMessage, createTempDir, createUserMessage } from "./session-test-utils.ts";
+
+describe("InMemorySessionStorage", () => {
+	it("returns configured session metadata", async () => {
+		const metadata: SessionMetadata = { id: "session-1", createdAt: "2026-01-01T00:00:00.000Z" };
+		const storage = new InMemorySessionStorage({ metadata });
+		expect(await storage.getMetadata()).toEqual(metadata);
+	});
+
+	it("copies initial entries and persists leaf changes", async () => {
+		const entry: MessageEntry = {
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		};
+		const initialEntries = [entry];
+		const storage = new InMemorySessionStorage({ entries: initialEntries });
+		initialEntries.push({ ...entry, id: "entry-2" });
+		expect((await storage.getEntries()).map((storedEntry) => storedEntry.id)).toEqual(["entry-1"]);
+		expect(await storage.getLeafId()).toBe("entry-1");
+		await storage.setLeafId(null);
+		expect(await storage.getLeafId()).toBeNull();
+		expect((await storage.getEntries()).at(-1)).toMatchObject({ type: "leaf", targetId: null });
+	});
+
+	it("rejects invalid leaf ids", async () => {
+		const storage = new InMemorySessionStorage();
+		await expect(storage.setLeafId("missing")).rejects.toThrow("Entry missing not found");
+	});
+
+	it("finds entries by type", async () => {
+		const entry: MessageEntry = {
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		};
+		const storage = new InMemorySessionStorage({ entries: [entry] });
+		expect((await storage.findEntries("message")).map((found) => found.id)).toEqual(["entry-1"]);
+		expect(await storage.findEntries("session_info")).toEqual([]);
+	});
+
+	it("maintains label lookup", async () => {
+		const entry: MessageEntry = {
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		};
+		const storage = new InMemorySessionStorage({ entries: [entry] });
+		expect(await storage.getLabel("entry-1")).toBeUndefined();
+		await storage.appendEntry({
+			type: "label",
+			id: "label-1",
+			parentId: "entry-1",
+			timestamp: "2026-01-01T00:00:01.000Z",
+			targetId: "entry-1",
+			label: "checkpoint",
+		});
+		expect(await storage.getLabel("entry-1")).toBe("checkpoint");
+		await storage.appendEntry({
+			type: "label",
+			id: "label-2",
+			parentId: "label-1",
+			timestamp: "2026-01-01T00:00:02.000Z",
+			targetId: "entry-1",
+			label: undefined,
+		});
+		expect(await storage.getLabel("entry-1")).toBeUndefined();
+	});
+
+	it("walks paths to root", async () => {
+		const root: MessageEntry = {
+			type: "message",
+			id: "root",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("root"),
+		};
+		const child: MessageEntry = {
+			...root,
+			id: "child",
+			parentId: "root",
+			message: createAssistantMessage("child"),
+		};
+		const storage = new InMemorySessionStorage({ entries: [root, child] });
+		expect((await storage.getPathToRoot("child")).map((entry) => entry.id)).toEqual(["root", "child"]);
+		expect(await storage.getPathToRoot(null)).toEqual([]);
+	});
+});
+
+describe("JsonlSessionStorage", () => {
+	it("throws for missing files when opening", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		await expect(JsonlSessionStorage.open(env, filePath)).rejects.toMatchObject({ code: "not_found" });
+	});
+
+	it("writes the header on create", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const storage = await JsonlSessionStorage.create(env, filePath, { cwd: dir, sessionId: "session-1" });
+		expect(existsSync(filePath)).toBe(true);
+		expect(readFileSync(filePath, "utf8").trim().split("\n")).toHaveLength(1);
+		expect(await storage.getLeafId()).toBeNull();
+		expect(await storage.getEntries()).toEqual([]);
+		await storage.appendEntry({
+			type: "message",
+			id: "user-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		});
+		const lines = readFileSync(filePath, "utf8").trim().split("\n");
+		expect(JSON.parse(lines[0]!).type).toBe("session");
+		expect(JSON.parse(lines[1]!).id).toBe("user-1");
+		expect(lines).toHaveLength(2);
+	});
+
+	it("throws for malformed session headers", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		writeFileSync(filePath, "not json\n");
+		await expect(JsonlSessionStorage.open(env, filePath)).rejects.toThrow("first line is not a valid session header");
+	});
+
+	it("throws for malformed entry lines", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const header = {
+			type: "session",
+			version: 3,
+			id: "session-1",
+			timestamp: "2026-01-01T00:00:00.000Z",
+			cwd: dir,
+		};
+		const entry: MessageEntry = {
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		};
+		writeFileSync(filePath, `${JSON.stringify(header)}\nnot json\n${JSON.stringify(entry)}\n`);
+		await expect(JsonlSessionStorage.open(env, filePath)).rejects.toMatchObject({ code: "invalid_entry" });
+	});
+
+	it("creates and reads session metadata from the header", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const storage = await JsonlSessionStorage.create(env, filePath, {
+			cwd: dir,
+			sessionId: "session-1",
+			parentSessionPath: "/tmp/parent.jsonl",
+		});
+		const metadata = await storage.getMetadata();
+		expect(metadata).toMatchObject({
+			id: "session-1",
+			cwd: dir,
+			path: filePath,
+			parentSessionPath: "/tmp/parent.jsonl",
+		});
+		await storage.appendEntry({
+			type: "message",
+			id: "user-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		});
+		expect(await loadJsonlSessionMetadata(env, filePath)).toEqual(metadata);
+	});
+
+	it("loads existing entries and reconstructs leaf", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const storage = await JsonlSessionStorage.create(env, filePath, { cwd: dir, sessionId: "session-1" });
+		const root: MessageEntry = {
+			type: "message",
+			id: "root",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("root"),
+		};
+		const child: MessageEntry = {
+			...root,
+			id: "child",
+			parentId: "root",
+			message: createAssistantMessage("child"),
+		};
+		await storage.appendEntry(root);
+		await storage.appendEntry(child);
+		const loaded = await JsonlSessionStorage.open(env, filePath);
+		expect(await loaded.getLeafId()).toBe("child");
+		expect((await loaded.getEntries()).map((entry) => entry.id)).toEqual(["root", "child"]);
+		await loaded.setLeafId("root");
+		const reloaded = await JsonlSessionStorage.open(env, filePath);
+		expect(await reloaded.getLeafId()).toBe("root");
+		expect((await reloaded.getEntries()).at(-1)).toMatchObject({ type: "leaf", targetId: "root" });
+		expect((await loaded.getPathToRoot("child")).map((entry) => entry.id)).toEqual(["root", "child"]);
+	});
+
+	it("finds entries by type", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const storage = await JsonlSessionStorage.create(env, filePath, { cwd: dir, sessionId: "session-1" });
+		await storage.appendEntry({
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		});
+		expect((await storage.findEntries("message")).map((found) => found.id)).toEqual(["entry-1"]);
+		expect(await storage.findEntries("session_info")).toEqual([]);
+	});
+
+	it("maintains label lookup", async () => {
+		const dir = createTempDir();
+		const env = new NodeExecutionEnv({ cwd: dir });
+		const filePath = join(dir, "session.jsonl");
+		const storage = await JsonlSessionStorage.create(env, filePath, { cwd: dir, sessionId: "session-1" });
+		await storage.appendEntry({
+			type: "message",
+			id: "entry-1",
+			parentId: null,
+			timestamp: "2026-01-01T00:00:00.000Z",
+			message: createUserMessage("one"),
+		});
+		expect(await storage.getLabel("entry-1")).toBeUndefined();
+		await storage.appendEntry({
+			type: "label",
+			id: "label-1",
+			parentId: "entry-1",
+			timestamp: "2026-01-01T00:00:01.000Z",
+			targetId: "entry-1",
+			label: "checkpoint",
+		});
+		expect(await storage.getLabel("entry-1")).toBe("checkpoint");
+		await storage.appendEntry({
+			type: "label",
+			id: "label-2",
+			parentId: "label-1",
+			timestamp: "2026-01-01T00:00:02.000Z",
+			targetId: "entry-1",
+			label: undefined,
+		});
+		expect(await storage.getLabel("entry-1")).toBeUndefined();
+		const loaded = await JsonlSessionStorage.open(env, filePath);
+		expect(await loaded.getLabel("entry-1")).toBeUndefined();
+	});
+
+	it("reads session metadata through the line-reading filesystem operation", async () => {
+		const dir = createTempDir();
+		const filePath = join(dir, "session.jsonl");
+		const header = {
+			type: "session",
+			version: 3,
+			id: "session-1",
+			timestamp: "2026-01-01T00:00:00.000Z",
+			cwd: dir,
+		};
+		const metadata = await loadJsonlSessionMetadata(
+			{
+				readTextLines: async () => ok([JSON.stringify(header)]),
+				readTextFile: async () => {
+					throw new Error("readTextFile should not be called for metadata");
+				},
+				writeFile: async () => ok(undefined),
+				appendFile: async () => ok(undefined),
+			},
+			filePath,
+		);
+		expect(metadata).toEqual({
+			id: "session-1",
+			createdAt: "2026-01-01T00:00:00.000Z",
+			cwd: dir,
+			path: filePath,
+			parentSessionPath: undefined,
+		});
+	});
+});

wmo/harness/vendor/pi-agent/test/harness/system-prompt.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { formatSkillsForSystemPrompt } from "../../src/harness/system-prompt.ts";
+
+const visibleSkill = {
+	name: "visible",
+	description: "Use <this> & that",
+	content: "visible content",
+	filePath: "/skills/visible/SKILL.md",
+};
+
+const secondSkill = {
+	name: "second",
+	description: "Second skill",
+	content: "second content",
+	filePath: "/skills/second/SKILL.md",
+};
+
+const disabledSkill = {
+	name: "hidden",
+	description: "Hidden",
+	content: "hidden content",
+	filePath: "/skills/hidden/SKILL.md",
+	disableModelInvocation: true,
+};
+
+describe("formatSkillsForSystemPrompt", () => {
+	it("formats visible skills in order and skips model-disabled skills", () => {
+		expect(formatSkillsForSystemPrompt([visibleSkill, disabledSkill, secondSkill])).toBe(
+			`The following skills provide specialized instructions for specific tasks.
+Read the full skill file when the task matches its description.
+When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.
+
+<available_skills>
+  <skill>
+    <name>visible</name>
+    <description>Use &lt;this&gt; &amp; that</description>
+    <location>/skills/visible/SKILL.md</location>
+  </skill>
+  <skill>
+    <name>second</name>
+    <description>Second skill</description>
+    <location>/skills/second/SKILL.md</location>
+  </skill>
+</available_skills>`,
+		);
+	});
+
+	it("returns an empty string when no skills are model-visible", () => {
+		expect(formatSkillsForSystemPrompt([disabledSkill])).toBe("");
+	});
+
+	it("escapes XML in all model-visible skill fields", () => {
+		expect(
+			formatSkillsForSystemPrompt([
+				{
+					name: "a&b",
+					description: `Quote "double" and 'single'`,
+					content: "content",
+					filePath: '/skills/<bad>&"quote"/SKILL.md',
+				},
+			]),
+		).toContain(
+			"<name>a&amp;b</name>\n    <description>Quote &quot;double&quot; and &apos;single&apos;</description>\n    <location>/skills/&lt;bad&gt;&amp;&quot;quote&quot;/SKILL.md</location>",
+		);
+	});
+});