@anteros/core 0.0.42 → 0.0.44

package/tests/agent-working-memory.test.ts

@@ -36,7 +36,7 @@ function makeAgent(overrides: Record<string, any> = {}, provider: Record<string,
         provider: {
             model: "test-model",
             apiKey: "test-key",
-            compatible: "openai",
+            protocol: "openai",
             options: { retries: 0 },
             ...provider,
         },
@@ -385,7 +385,7 @@ describe("working memory — Anthropic", () => {
         const provider = track(fakeProvider(() => anthropicText("ok")));
         const agent = makeAgent(
             { memory: new InMemoryAgentMemory(), workingMemory: { template: "# Memo\n- x:" } },
-            { compatible: "anthropic", baseUrl: provider.url },
+            { protocol: "anthropic", baseUrl: provider.url },
         );
 
         await agent.generate("hi", { thread: "t1", resource: "u1" });
@@ -397,6 +397,8 @@ describe("working memory — Anthropic", () => {
 
 describe("working memory — the registry exposes nothing new by accident", () => {
     it("keeps `agents.memory` as the only store factory", () => {
-        expect(Object.keys(agents.memory).sort()).toEqual(["InMemory", "Mongo", "Redis"]);
+        // `summarize` is the one deliberate addition: a **processor** factory (it needs
+        // your model and your prompt), not a store
+        expect(Object.keys(agents.memory).sort()).toEqual(["InMemory", "Mongo", "Redis", "summarize"]);
     });
 });

package/tests/agent.test.ts

@@ -63,7 +63,7 @@ function makeAgent(
         provider: {
             model: "test-model",
             apiKey: "test-key",
-            compatible: "openai",
+            protocol: "openai",
             // Deterministic by default: a test must not wait on the retry backoff
             options: { retries: 0, ...options },
             ...provider,
@@ -81,7 +81,7 @@ describe("agent … files", () => {
             provider: {
                 model: "test-model",
                 apiKey: "test-key",
-                compatible: "openai",
+                protocol: "openai",
                 options: { retries: 0 },
                 ...providerOverrides,
             },
@@ -228,7 +228,7 @@ describe("agent … tools & thinking options", () => {
             provider: {
                 model: "test-model",
                 apiKey: "test-key",
-                compatible: "openai",
+                protocol: "openai",
                 options: { retries: 0 },
                 ...providerOverrides,
             },
@@ -307,7 +307,7 @@ describe("agent … tools & thinking options", () => {
         expect(request(provider, 1).body.tool_choice).toBe("auto");
 
         const anthropic = track(fakeProvider(() => anthropicText("ok")));
-        const forced = toolAgent({ compatible: "anthropic", baseUrl: anthropic.url }, { toolChoice: { name: "forecast" } });
+        const forced = toolAgent({ protocol: "anthropic", baseUrl: anthropic.url }, { toolChoice: { name: "forecast" } });
         await forced.generate("hi");
         expect(request(anthropic, 0).body.tool_choice).toEqual({ type: "tool", name: "forecast" });
         await forced.generate("hi", { toolChoice: "auto" });
@@ -347,7 +347,7 @@ describe("agent … tools & thinking options", () => {
     it("maps `thinking` to a real budget on Anthropic, and raises max_tokens above it", async () => {
         const provider = track(fakeProvider(() => anthropicText("ok")));
         const agent = toolAgent(
-            { compatible: "anthropic", baseUrl: provider.url, options: { retries: 0, maxTokens: 2000, temperature: 0.5 } },
+            { protocol: "anthropic", baseUrl: provider.url, options: { retries: 0, maxTokens: 2000, temperature: 0.5 } },
         );
 
         await agent.generate("hi", { thinking: true });
@@ -377,7 +377,7 @@ describe("agent … tools & thinking options", () => {
             stop_reason: "tool_use",
             usage: A_USAGE,
         })));
-        const agent = toolAgent({ compatible: "anthropic", baseUrl: provider.url });
+        const agent = toolAgent({ protocol: "anthropic", baseUrl: provider.url });
 
         await agent.generate("Weather?", { thinking: 'medium' });
 
@@ -409,7 +409,7 @@ describe("agent … tools & thinking options", () => {
                 stop_reason: "end_turn",
                 usage: A_USAGE,
             })));
-        const agent = toolAgent({ compatible: "anthropic", baseUrl: provider.url });
+        const agent = toolAgent({ protocol: "anthropic", baseUrl: provider.url });
 
         const result = await agent.generate("go", { thinking: true });
 
@@ -430,7 +430,7 @@ describe("agent … tools & thinking options", () => {
             JSON.stringify({ type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "Answer" } }),
             JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 3 } }),
         ])));
-        const agent = toolAgent({ compatible: "anthropic", baseUrl: provider.url });
+        const agent = toolAgent({ protocol: "anthropic", baseUrl: provider.url });
 
         const stream = agent.stream("hi", { thinking: true });
         const kinds: string[] = [];
@@ -621,7 +621,7 @@ describe("Agent", () => {
         const agent = makeAgent({}, {}, { temperature: 0.2, maxTokens: 1000 });
         const declared = {
             model: "test-model",
-            compatible: "openai" as const,
+            protocol: "openai" as const,
             options: { retries: 0, temperature: 0.2, maxTokens: 1000 },
         };
 
@@ -831,7 +831,7 @@ describe("agent.generate", () => {
         delete Bun.env.ANTHROPIC_API_KEY;
 
         try {
-            const agent = makeAgent({}, { compatible: "anthropic", apiKey: undefined, baseUrl: provider.url });
+            const agent = makeAgent({}, { protocol: "anthropic", apiKey: undefined, baseUrl: provider.url });
             await expect(agent.generate("hi")).rejects.toMatchObject({ code: "AGENT_PROVIDER_NO_API_KEY" });
 
             Bun.env.ANTHROPIC_API_KEY = "from-env";
@@ -849,10 +849,10 @@ describe("agent.generate", () => {
 
 // ─── Anthropic ───────────────────────────────────────────────────────────
 
-describe("agent with an Anthropic-compatible provider", () => {
+describe("agent speaking the Anthropic protocol", () => {
     it("puts the system prompt out of band and returns the text", async () => {
         const provider = track(fakeProvider(() => anthropicText("Bonjour")));
-        const agent = makeAgent({}, { compatible: "anthropic", baseUrl: provider.url });
+        const agent = makeAgent({}, { protocol: "anthropic", baseUrl: provider.url });
 
         const result = await agent.generate("salut");
 
@@ -869,7 +869,7 @@ describe("agent with an Anthropic-compatible provider", () => {
         const provider = track(fakeProvider((_body, _req, hits) =>
             hits === 1 ? anthropicTool("forecast", { city: "Lyon" }) : anthropicText("Lyon: 21°C")));
 
-        const agent = makeAgent({ tools: { forecast: forecastTool() } }, { compatible: "anthropic", baseUrl: provider.url });
+        const agent = makeAgent({ tools: { forecast: forecastTool() } }, { protocol: "anthropic", baseUrl: provider.url });
         const result = await agent.generate("Weather in Lyon?");
 
         expect(result.text).toBe("Lyon: 21°C");
@@ -888,7 +888,7 @@ describe("agent with an Anthropic-compatible provider", () => {
 
     it("streams text deltas and merges the partial usage", async () => {
         const provider = track(fakeProvider(() => anthropicStream(["Bon", "jour"])));
-        const agent = makeAgent({}, { compatible: "anthropic", baseUrl: provider.url });
+        const agent = makeAgent({}, { protocol: "anthropic", baseUrl: provider.url });
 
         const stream = agent.stream("salut");
         let text = "";
@@ -1116,9 +1116,11 @@ describe("agent structured output", () => {
         const object = await agent.generateObject("Weather?", { schema });
 
         expect(object).toEqual({ city: "Paris", celsius: 21 });
-        // The schema was injected in the prompt and asked for a JSON object
+        // The schema travels twice: in the prompt, and in the field the gateway really
+        // validates against (`response_format.json_schema`, see `agent-provider.test.ts`)
         expect(request(provider, 0).body.messages[0].content).toContain("JSON Schema");
-        expect(request(provider, 0).body.response_format).toEqual({ type: "json_object" });
+        expect(request(provider, 0).body.response_format.type).toBe("json_schema");
+        expect(request(provider, 0).body.response_format.json_schema.schema).toBeDefined();
     });
 
     it("repairs an invalid answer with one extra turn", async () => {

package/tests/agents-api.test.ts

@@ -180,7 +180,7 @@ describe("agents HTTP API — actions", () => {
         expect(res.body.agent.id).toBe("assistant");
         expect(res.body.agent.tools).toEqual(["echo"]);
         expect(res.body.agent.provider.model).toBe("test-model");
-        expect(res.body.agent.provider.compatible).toBe("openai");
+        expect(res.body.agent.provider.protocol).toBe("openai");
         expect(res.body.agent.maxSteps).toBe(3);
         expect(res.body.agent.memory).toBe(true);
         expect(JSON.stringify(res.body)).not.toContain("test-key");

package/tests/api-private-fields.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { createApp } from "../server/hono";
+import { formatConfig, cfg } from "../server/config";
+import { syncTenants } from "../database/tenant";
+import { useRest } from "../database/rest";
+
+/**
+ * `api.privateFields` on a **collection reached through a join**.
+ *
+ * `func.omit` walks the whole response, but only with the matchers of the
+ * collection that was queried: an `$include`d document carries the *included*
+ * collection's fields, so that collection's `privateFields` must be applied too
+ * — at the path the join put it, and nowhere else. Same story for a `$lookup`
+ * inside an `aggregate` pipeline.
+ */
+
+const TENANT = "private-fields";
+const DB = "mongodb://localhost:27017/_API_PRIVATE_FIELDS_TEST";
+
+let url = "";
+let server: any;
+let rest: InstanceType<typeof useRest>;
+let internal: InstanceType<typeof useRest>;
+
+async function call(collection: string, action: string, body?: any) {
+    const res = await fetch(`${url}/api/${TENANT}/collections/${collection}/${action}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return { status: res.status, body: (await res.json()) as any };
+}
+
+beforeAll(async () => {
+    formatConfig({
+        server: { port: 4000 },
+        tenants: [{ id: TENANT, dir: "src", database: { uri: DB } }],
+    });
+    await syncTenants();
+
+    (cfg as any).collections = [
+        {
+            _tenant_: TENANT,
+            slug: "authors",
+            fields: [
+                { name: "name", type: "string" },
+                { name: "password", type: "string" },
+                { name: "secret_token", type: "string" },
+            ],
+            api: { access: { "*": true }, privateFields: ["password", /^secret_/] },
+        },
+        {
+            _tenant_: TENANT,
+            slug: "posts",
+            fields: [
+                { name: "title", type: "string" },
+                // A public field that happens to match the *included* collection's
+                // matcher — it must survive: only the joined document is masked.
+                { name: "secret_note", type: "string" },
+                { name: "author", type: "relationship", relation: { to: "authors" } },
+                { name: "reviewers", type: "relationship", relation: { to: "authors", hasMany: true } },
+            ],
+            // The collection being queried declares no private field of its own:
+            // only the included one does.
+            api: { access: { "*": true } },
+        },
+    ];
+
+    rest = new useRest({ internal: false, tenant_id: TENANT });
+    internal = new useRest({ internal: true, tenant_id: TENANT });
+
+    const app = createApp();
+    server = Bun.serve({ port: 0, fetch: app.fetch });
+    url = server.url.href.replace(/\/$/, "");
+});
+
+afterAll(async () => {
+    for (const name of ["authors", "posts", "_locks_", "_audit_"]) {
+        try { await rest.db.collection(name).drop(); } catch (_) { /* first run */ }
+    }
+    server?.stop(true);
+});
+
+async function seed() {
+    await rest.db.collection("authors").deleteMany({});
+    await rest.db.collection("posts").deleteMany({});
+    const author = await rest.insertOne("authors", {
+        name: "Ada",
+        password: "s3cret-hash",
+        secret_token: "tok_live_123",
+    });
+    const post = await rest.insertOne("posts", {
+        title: "Hello",
+        secret_note: "public-note",
+        author: author._id,
+        reviewers: [author._id],
+    });
+    return { author, post };
+}
+
+describe("api.privateFields across a join", () => {
+    it("masks the included collection's private fields on `find`", async () => {
+        const { post } = await seed();
+
+        const res = await call("posts", "find", { params: { $match: { _id: post._id }, $include: ["author"] } });
+
+        expect(res.status).toBe(200);
+        const doc = res.body[0];
+        expect(doc.author.name).toBe("Ada");
+        expect(doc.author.password).toBeUndefined();
+        expect(doc.author.secret_token).toBeUndefined();
+    });
+
+    it("masks them on `findOne` too", async () => {
+        const { post } = await seed();
+
+        const res = await call("posts", "findOne", { id: post._id, params: { $include: ["author"] } });
+
+        expect(res.status).toBe(200);
+        expect(res.body.author.name).toBe("Ada");
+        expect(res.body.author.password).toBeUndefined();
+        expect(res.body.author.secret_token).toBeUndefined();
+    });
+
+    it("masks every element of a `hasMany` include", async () => {
+        const { post } = await seed();
+
+        const res = await call("posts", "find", { params: { $match: { _id: post._id }, $include: ["reviewers"] } });
+
+        expect(res.status).toBe(200);
+        const reviewers = res.body[0].reviewers;
+        expect(Array.isArray(reviewers)).toBe(true);
+        expect(reviewers[0].name).toBe("Ada");
+        expect(reviewers[0].password).toBeUndefined();
+        expect(reviewers[0].secret_token).toBeUndefined();
+    });
+
+    it("masks them on a `$lookup` of an `aggregate` pipeline", async () => {
+        const { post } = await seed();
+
+        const res = await call("posts", "aggregate", {
+            pipeline: [
+                { $match: { _id: post._id } },
+                { $lookup: { from: "authors", localField: "author", foreignField: "_id", as: "author" } },
+                { $unwind: "$author" },
+            ],
+        });
+
+        expect(res.status).toBe(200);
+        const doc = res.body[0];
+        expect(doc.author.name).toBe("Ada");
+        expect(doc.author.password).toBeUndefined();
+        expect(doc.author.secret_token).toBeUndefined();
+    });
+
+    it("still masks the queried collection's own private fields", async () => {
+        await seed();
+
+        const res = await call("authors", "find", {});
+
+        expect(res.status).toBe(200);
+        expect(res.body[0].name).toBe("Ada");
+        expect(res.body[0].password).toBeUndefined();
+        expect(res.body[0].secret_token).toBeUndefined();
+    });
+
+    it("masks the join only — the queried collection's own matching field survives", async () => {
+        const { post } = await seed();
+
+        const res = await call("posts", "find", { params: { $match: { _id: post._id }, $include: ["author"] } });
+
+        expect(res.status).toBe(200);
+        expect(res.body[0].secret_note).toBe("public-note");
+    });
+});
+
+describe("api.privateFields and the DB query cache", () => {
+    it("does not mutate the cached result (an internal read still sees every field)", async () => {
+        const { post } = await seed();
+        const params = { $match: { _id: post._id }, $include: ["author"] };
+
+        const viaHttp = await call("posts", "find", { params, options: { useCache: true } });
+        expect(viaHttp.body[0].author.password).toBeUndefined();
+
+        // Same query, same (warm) cache entry, but through the trusted internal API:
+        // the masked fields must still be there — masking is a response concern.
+        const viaRest: any = await internal.find("posts", params, { useCache: true });
+        expect(viaRest[0].author.password).toBe("s3cret-hash");
+        expect(viaRest[0].author.secret_token).toBe("tok_live_123");
+
+        // And the HTTP layer stays consistent on the second, cached response.
+        const again = await call("posts", "find", { params, options: { useCache: true } });
+        expect(again.body[0].author.name).toBe("Ada");
+        expect(again.body[0].author.password).toBeUndefined();
+    });
+});

package/tests/file-collection-replication.test.ts

@@ -21,6 +21,8 @@ beforeAll(async () => {
             dir: "src",
             database: { uri: SRC_DB },
             replication: {
+                // These cases exercise the scan engine (file collections)
+                mode: "scan",
                 runOnBoot: false,
                 schedule: { interval: "1h" },
                 destinations: [{ id: "backup", uri: DEST_DB }],

package/tests/fixtures/agent-tenant/agents/support.agent.ts

@@ -5,5 +5,5 @@ export default define.Agent({
     id: "support",
     description: "Answers support questions.",
     instructions: "You are a support agent.",
-    provider: { model: "claude-test", compatible: "anthropic", apiKey: "fixture-key" },
+    provider: { model: "claude-test", protocol: "anthropic", apiKey: "fixture-key" },
 });

package/tests/fixtures/agent-tenant/agents/weather.agent.ts

@@ -9,7 +9,7 @@ export default define.Agent({
     name: "Weather Agent",
     description: "Answers weather questions with a tool call",
     instructions: "You are a concise weather assistant.",
-    provider: { model: "test-model", compatible: "openai", apiKey: "fixture-key" },
+    provider: { model: "test-model", protocol: "openai", apiKey: "fixture-key" },
     tools: {
         forecast: define.Tool({
             id: "forecast",

package/tests/fixtures/agents-api/agents/assistant.agent.ts

@@ -13,7 +13,7 @@ export default define.Agent({
     instructions: "You are a fixture agent.",
     provider: {
         model: "test-model",
-        compatible: "openai",
+        protocol: "openai",
         apiKey: "test-key",
         baseUrl: Bun.env.AGENT_API_TEST_URL ?? "http://127.0.0.1:1",
         options: { retries: 0 },

package/tests/fixtures/agents-api/agents/plain.agent.ts

@@ -10,7 +10,7 @@ export default define.Agent({
     instructions: "You are a plain agent.",
     provider: {
         model: "test-model",
-        compatible: "openai",
+        protocol: "openai",
         apiKey: "test-key",
         baseUrl: Bun.env.AGENT_API_TEST_URL ?? "http://127.0.0.1:1",
         options: { retries: 0 },

package/tests/fixtures/agents-api/agents/private.agent.ts

@@ -7,7 +7,7 @@ export default define.Agent({
     instructions: "You are a private agent.",
     provider: {
         model: "test-model",
-        compatible: "openai",
+        protocol: "openai",
         apiKey: "test-key",
         baseUrl: Bun.env.AGENT_API_TEST_URL ?? "http://127.0.0.1:1",
         options: { retries: 0 },

package/tests/fixtures/repl-only/app.ts

@@ -18,6 +18,9 @@ await bootApp({
         database: { uri: Bun.env.RO_SRC ?? "mongodb://localhost:27017/_RO_SRC" },
         replication: {
             enabled: true,
+            // Boot capabilities are under test here, not the replication engine:
+            // the scan mode keeps the assertions deterministic
+            mode: "scan",
             runOnBoot: true,
             schedule: { interval: "1h" },
             destinations: [{ id: "backup", uri: Bun.env.RO_DST ?? "mongodb://localhost:27017/_RO_DST" }],

package/tests/fixtures/replication-meta/agents/chat.agent.ts

@@ -11,6 +11,6 @@ export default define.Agent({
     id: "chat",
     description: "Fixture agent whose memory lives in a tenant-named collection.",
     instructions: "Fixture agent — no model call is ever made in these tests.",
-    provider: { model: "test-model", compatible: "openai", apiKey: "fixture" },
+    provider: { model: "test-model", protocol: "openai", apiKey: "fixture" },
     memory: new agents.memory.Mongo({ collection: AGENT_THREADS }),
 });

package/tests/fixtures/skills-tenant/agents/docs.agent.ts

@@ -0,0 +1,23 @@
+import { define } from "../../../../index";
+
+/**
+ * Fixture — an agent whose system prompt carries skills, declared every way a
+ * source can be: a glob of a folder, one file, a regex over the tenant, and the
+ * `SKILL.md` directory layout.
+ *
+ * The last two patterns overlap on purpose (`./docs/*.md` and the `docs` regex):
+ * a file matched twice is one skill.
+ */
+export default define.Agent({
+    id: "docs",
+    description: "Answers from the tenant's own documentation.",
+    instructions: "Answer from the documentation you were given.",
+    provider: { model: "claude-test", protocol: "anthropic", apiKey: "fixture-key" },
+    skills: [
+        "./docs/*.md",
+        "./guide/ml.md",
+        /^docs\/.*\.md$/,
+        /^runbooks\/.*$/,
+        "./guides/**/SKILL.md",
+    ],
+});

package/tests/fixtures/skills-tenant/agents/incomplete.agent.ts

@@ -0,0 +1,14 @@
+import { define } from "../../../../index";
+
+/**
+ * Fixture — an agent whose skill is malformed (`broken/no-name.md` has no `name`).
+ *
+ * A broken skill refuses **this agent** at load, and must not hide the others.
+ */
+export default define.Agent({
+    id: "incomplete",
+    description: "Carries a skill that does not follow the format.",
+    instructions: "Nothing to see here.",
+    provider: { model: "claude-test", protocol: "anthropic", apiKey: "fixture-key" },
+    skills: ["./broken/no-name.md"],
+});

package/tests/fixtures/skills-tenant/broken/bad-name.md

@@ -0,0 +1,6 @@
+---
+name: Bad Name
+description: The name is not kebab-case.
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/dup-a.md

@@ -0,0 +1,6 @@
+---
+name: same-name
+description: Two files of one agent cannot share a name — this is the first.
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/dup-b.md

@@ -0,0 +1,6 @@
+---
+name: same-name
+description: Two files of one agent cannot share a name — this is the second.
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/empty-body.md

@@ -0,0 +1,4 @@
+---
+name: empty-body
+description: Frontmatter only — nothing for the model to read.
+---

package/tests/fixtures/skills-tenant/broken/long-compat.md

@@ -0,0 +1,7 @@
+---
+name: long-compat
+description: A skill whose compatibility line is too long.
+compatibility: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/long-description.md

@@ -0,0 +1,6 @@
+---
+name: long-description
+description: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/mismatch/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: other-name
+description: The parent directory is 'mismatch' — a SKILL.md must be named after it.
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/no-description.md

@@ -0,0 +1,5 @@
+---
+name: no-description
+---
+
+A skill without a description — the model would never know when to read it.

package/tests/fixtures/skills-tenant/broken/no-name.md

@@ -0,0 +1,5 @@
+---
+description: A skill without a name — the frontmatter is incomplete.
+---
+
+Body.

package/tests/fixtures/skills-tenant/broken/plain.md

@@ -0,0 +1,4 @@
+# No frontmatter at all
+
+A plain markdown file is refused: without a name and a description it cannot be
+injected (the model would not know what it is).

package/tests/fixtures/skills-tenant/broken/unknown-key.md

@@ -0,0 +1,9 @@
+---
+name: unknown-keys
+description: Extra frontmatter keys are kept out of the prompt, not refused.
+version: 3
+author: platform
+metadata: { owner: platform }
+---
+
+Body.

package/tests/fixtures/skills-tenant/docs/pdf-forms.md

@@ -0,0 +1,18 @@
+---
+name: pdf-forms
+description: Fill, flatten and merge PDF forms. Use it for any AcroForm work.
+license: MIT
+compatibility: Needs the `pdftk` binary on the host.
+metadata:
+  owner: platform
+  reviewed: 2026-09-24
+allowed-tools: read_pdf write_pdf
+---
+
+# Filling a form
+
+1. Dump the fields: `pdftk form.pdf dump_data_fields`.
+2. Build the FDF, then fill it: `pdftk form.pdf fill_form data.fdf output out.pdf`.
+3. Flatten: `pdftk out.pdf output flat.pdf flatten`.
+
+Never flatten before the signature step — it makes the form read-only.

package/tests/fixtures/skills-tenant/guide/ml.md

@@ -0,0 +1,9 @@
+---
+name: ml-conventions
+description: The tenant's ML conventions — feature naming, training splits, review gates.
+---
+
+# Conventions
+
+- Features are `snake_case`, prefixed by their source (`crm_`, `billing_`).
+- A model only ships with a held-out split and a written evaluation.

package/tests/fixtures/skills-tenant/guides/pdf/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: pdf
+description: Everything about the tenant's PDF pipeline, from templating to archiving.
+---
+
+# PDF pipeline
+
+The `name` matches the parent directory, which is what the `SKILL.md` layout
+requires.

package/tests/fixtures/skills-tenant/runbooks/incident.md

@@ -0,0 +1,9 @@
+---
+name: incident-response
+description: What to do when production breaks — paging, comms, post-mortem.
+---
+
+# Incident response
+
+1. Acknowledge the page within five minutes.
+2. Open a channel, name an incident commander, keep a timeline.

package/tests/fixtures/skills-tenant/runbooks/notes.txt

@@ -0,0 +1,2 @@
+This file is not markdown — a regex that walks the tenant picks it up, and the
+loader must skip it (logged) instead of taking the agent down.