@stigmer/mcp-server 3.34.0 → 3.36.0

package/src/domains/memory/memory.integration.test.ts

@@ -1,253 +0,0 @@
-// In-process integration test for the memory roster (the
-// channels.integration.test.ts pattern: real Connect backend with a
-// stubbed memory service, real MCP client over an in-memory transport).
-//
-// Verifies the DD-005 D1/D2 contract surface:
-//   - the memory-only roster is exactly remember with ONLY a fact
-//     argument (agent audience; org, subject, and provenance are never
-//     the model's to supply);
-//   - argument + capture-context → request mapping: fact → spec.content,
-//     context org → metadata.org, context triple → spec.provenance,
-//     subject never travels, tool_call_id stays empty (v1);
-//   - the answer is the chip contract: { outcome, memory } with the
-//     created record as verbatim proto JSON and the honest
-//     proposed-not-remembered outcome line;
-//   - the memory-own error mapper passes domain messages verbatim as
-//     {error, code, reason} JSON; transport errors delegate to the
-//     shared classifier.
-
-import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError, type ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { MemorySchema, type Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
-import { MemoryCommandController } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/command_pb";
-import { MemoryLifecycleState } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/enum_pb";
-import { MemorySpecSchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/spec_pb";
-import { MemoryStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/status_pb";
-import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../../logger";
-import { MEMORY_ROUTE, createMemoryServer } from "../../server";
-import { PROPOSED_OUTCOME } from "./calls";
-import {
-  MEMORY_AGENT_ID_ENV,
-  MEMORY_AGENT_ID_HEADER,
-  MEMORY_EXECUTION_ID_ENV,
-  MEMORY_EXECUTION_ID_HEADER,
-  MEMORY_ORG_ENV,
-  MEMORY_ORG_HEADER,
-  MEMORY_SESSION_ID_ENV,
-  MEMORY_SESSION_ID_HEADER,
-} from "./context";
-
-configureLogger({ level: "error", format: "text" });
-
-let backend: Http2Server;
-let client: Client;
-const openSessions = new Set<ServerHttp2Session>();
-
-/** The next stubbed created record; tests set this. */
-let createResponse: () => Memory;
-
-// Requests the stub captured. An array, deliberately: resetting an optional
-// property to undefined narrows its type to `undefined` for the rest of the
-// flow (tsc does not un-narrow across the intervening callTool call), which
-// makes every later `req?.x` a property access on `never` under
-// `npm run typecheck` — the job that, unlike tsconfig.build.json, includes
-// tests. Clearing and reading an array never narrows.
-const capturedCreates: Memory[] = [];
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function remember(args: Record<string, unknown>): Promise<ToolResult> {
-  return (await client.callTool({ name: "remember", arguments: args })) as ToolResult;
-}
-
-/** A plausible created record echoing the request's content. */
-function proposedRecord(content: string): Memory {
-  return create(MemorySchema, {
-    apiVersion: "agentic.stigmer.ai/v1",
-    kind: "Memory",
-    metadata: create(ApiResourceMetadataSchema, { id: "mem_01test", org: "acme" }),
-    spec: create(MemorySpecSchema, {
-      content,
-      subjectIdentityAccountId: "ida_subject",
-    }),
-    status: create(MemoryStatusSchema, {
-      lifecycleState: MemoryLifecycleState.lifecycle_state_proposed,
-    }),
-  });
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(MemoryCommandController, {
-      create: (req) => {
-        capturedCreates.push(req);
-        return createResponse();
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  // The stdio shape: the startup capture context stands in for the
-  // runner-set STIGMER_MEMORY_* environment.
-  const mcp = createMemoryServer(
-    { serverAddress: `127.0.0.1:${port}`, apiKey: "" },
-    { org: "acme", agentId: "agt_1", sessionId: "ses_1", agentExecutionId: "aex_1" },
-  );
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "memory-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("memory roster (DD-005 D1)", () => {
-  it("exposes exactly remember with only a fact argument", async () => {
-    const { tools } = await client.listTools();
-    expect(tools.map((t) => t.name)).toEqual(["remember"]);
-
-    // The agent audience supplies the fact and NOTHING else — org,
-    // subject, and provenance derive from the credential and the
-    // runner-threaded capture context, so no argument exists to forge
-    // them (the channels no-org rule, applied to attribution).
-    const properties = (tools[0].inputSchema as { properties?: Record<string, unknown> })
-      .properties;
-    expect(Object.keys(properties ?? {})).toEqual(["fact"]);
-  });
-
-  it("pins the cross-repo attachment strings (the TOOL_CALL_LIMIT precedent)", () => {
-    // The runner's memory-attachment.ts builds these independently; a
-    // drift strands every synthesized attachment on a 404 (route) or an
-    // attribution-less record (context keys).
-    expect(MEMORY_ROUTE).toBe("/memory");
-    expect(MEMORY_ORG_ENV).toBe("STIGMER_MEMORY_ORG");
-    expect(MEMORY_AGENT_ID_ENV).toBe("STIGMER_MEMORY_AGENT_ID");
-    expect(MEMORY_SESSION_ID_ENV).toBe("STIGMER_MEMORY_SESSION_ID");
-    expect(MEMORY_EXECUTION_ID_ENV).toBe("STIGMER_MEMORY_EXECUTION_ID");
-    expect(MEMORY_ORG_HEADER).toBe("x-stigmer-memory-org");
-    expect(MEMORY_AGENT_ID_HEADER).toBe("x-stigmer-memory-agent-id");
-    expect(MEMORY_SESSION_ID_HEADER).toBe("x-stigmer-memory-session-id");
-    expect(MEMORY_EXECUTION_ID_HEADER).toBe("x-stigmer-memory-execution-id");
-  });
-});
-
-describe("argument + capture context → request mapping (DD-005 D2)", () => {
-  it("maps the fact and the startup context; subject never travels", async () => {
-    createResponse = () => proposedRecord("Prefers concise answers.");
-    capturedCreates.length = 0;
-
-    const result = await remember({ fact: "Prefers concise answers." });
-
-    expect(result.isError).toBeFalsy();
-    const req = capturedCreates.at(-1);
-    expect(req?.metadata?.org).toBe("acme");
-    expect(req?.metadata?.name).toBe(""); // id-addressed; the server defaults the name
-    expect(req?.spec?.content).toBe("Prefers concise answers.");
-    // Subject is the server's to derive from the credential — the tool
-    // never supplies one, so forgery is structurally impossible.
-    expect(req?.spec?.subjectIdentityAccountId).toBe("");
-    expect(req?.spec?.provenance?.agentId).toBe("agt_1");
-    expect(req?.spec?.provenance?.sessionId).toBe("ses_1");
-    expect(req?.spec?.provenance?.agentExecutionId).toBe("aex_1");
-    // v1: MCP does not carry the harness's tool-call identity.
-    expect(req?.spec?.provenance?.toolCallId).toBe("");
-  });
-
-  it("answers with the chip contract: outcome line + created record as proto JSON", async () => {
-    createResponse = () => proposedRecord("Works primarily in Go.");
-
-    const result = await remember({ fact: "Works primarily in Go." });
-
-    expect(result.isError).toBeFalsy();
-    const body = JSON.parse(result.content[0]?.text ?? "{}") as {
-      outcome?: string;
-      memory?: Record<string, unknown>;
-    };
-    // The honest relay (DD-005 D2): proposed, the user decides.
-    expect(body.outcome).toBe(PROPOSED_OUTCOME);
-    // The record rides verbatim with proto (snake_case) field names —
-    // what the SDK's normalizeToolResult parses to render the chip.
-    const memory = body.memory as {
-      metadata?: { id?: string };
-      spec?: { content?: string };
-      status?: { lifecycle_state?: string };
-    };
-    expect(memory?.metadata?.id).toBe("mem_01test");
-    expect(memory?.spec?.content).toBe("Works primarily in Go.");
-    expect(memory?.status?.lifecycle_state).toBe("lifecycle_state_proposed");
-  });
-});
-
-describe("memory error mapper", () => {
-  it("passes the visible-full refusal through verbatim — never the shared rewrite", async () => {
-    createResponse = () => {
-      throw new ConnectError(
-        "memory is full — review and delete existing memories",
-        Code.FailedPrecondition,
-      );
-    };
-
-    const result = await remember({ fact: "One fact too many." });
-
-    expect(result.isError).toBe(true);
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual({
-      error: "memory is full — review and delete existing memories",
-      code: "FAILED_PRECONDITION",
-    });
-  });
-
-  it("passes the caller-gate refusal through verbatim", async () => {
-    createResponse = () => {
-      throw new ConnectError(
-        "memory capture is limited to first-party sessions",
-        Code.PermissionDenied,
-      );
-    };
-
-    const result = await remember({ fact: "A fact from the wrong caller." });
-
-    expect(result.isError).toBe(true);
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual({
-      error: "memory capture is limited to first-party sessions",
-      code: "PERMISSION_DENIED",
-    });
-  });
-
-  it("delegates transport codes to the shared classifier", async () => {
-    createResponse = () => {
-      throw new ConnectError("upstream down", Code.Unavailable);
-    };
-
-    const result = await remember({ fact: "Any fact." });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toBe(
-      "Stigmer server is unavailable. Ensure it is running and reachable.",
-    );
-  });
-});

package/src/domains/reads.integration.test.ts

@@ -1,163 +0,0 @@
-// In-process integration test for the read tools (get_mcp_server, get_skill,
-// get_workflow, get_environment). Stands up a real Connect
-// backend serving the query controllers, drives the MCP server through an
-// in-memory client, and asserts each tool returns the backend's protojson
-// verbatim (the parity contract) and that get_skill forwards its optional
-// version to the backend.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
-import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
-import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import { McpServerQueryController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/query_pb";
-import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
-import { SkillQueryController } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/query_pb";
-import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
-import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../logger";
-import { createServer } from "../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const knownMcpServer = create(McpServerSchema, {
-  apiVersion: "v1",
-  kind: "mcp_server",
-  metadata: { name: "GitHub", slug: "github", org: "acme", id: "mcp-1" },
-});
-
-const knownSkill = create(SkillSchema, {
-  apiVersion: "v1",
-  kind: "skill",
-  metadata: { name: "Code Review", slug: "code-review", org: "acme", id: "skl-1" },
-});
-
-const knownWorkflow = create(WorkflowSchema, {
-  apiVersion: "v1",
-  kind: "workflow",
-  metadata: { name: "Release", slug: "release", org: "acme", id: "wkf-1" },
-});
-
-// The backend redacts secret values before they leave the server; the tool
-// must pass that redaction through verbatim.
-const knownEnvironment = create(EnvironmentSchema, {
-  apiVersion: "v1",
-  kind: "environment",
-  metadata: { name: "GitHub Creds", slug: "github-creds", org: "acme", id: "env-1" },
-  spec: { data: { API_KEY: { value: "***REDACTED***", isSecret: true } } },
-});
-
-
-let backend: Http2Server;
-let client: Client;
-let lastSkillVersion: string | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
-  return (await client.callTool({ name, arguments: args })) as ToolResult;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(McpServerQueryController, { getByReference: () => knownMcpServer });
-    router.service(SkillQueryController, {
-      getByReference: (req) => {
-        lastSkillVersion = req.version;
-        return knownSkill;
-      },
-    });
-    router.service(WorkflowQueryController, { getByReference: () => knownWorkflow });
-    router.service(EnvironmentQueryController, { getByReference: () => knownEnvironment });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  // Force keep-alive sessions closed on teardown, else backend.close() blocks.
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "reads-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("read tools integration", () => {
-  it("advertises all read tools", async () => {
-    const { tools } = await client.listTools();
-    expect(tools.map((t) => t.name)).toEqual(
-      expect.arrayContaining([
-        "get_agent",
-        "get_mcp_server",
-        "get_skill",
-        "get_workflow",
-        "get_environment",
-      ]),
-    );
-  });
-
-  it("get_mcp_server returns the backend protojson", async () => {
-    const result = await callTool("get_mcp_server", { org: "acme", slug: "github" });
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(McpServerSchema, knownMcpServer, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_workflow returns the backend protojson", async () => {
-    const result = await callTool("get_workflow", { org: "acme", slug: "release" });
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(WorkflowSchema, knownWorkflow, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_skill returns the backend protojson and defaults version to latest", async () => {
-    const result = await callTool("get_skill", { org: "acme", slug: "code-review" });
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(SkillSchema, knownSkill, { useProtoFieldName: true }),
-    );
-    // Omitted version is forwarded as the empty string ("latest").
-    expect(lastSkillVersion).toBe("");
-  });
-
-  it("get_skill forwards an explicit version to the backend", async () => {
-    await callTool("get_skill", { org: "acme", slug: "code-review", version: "stable" });
-    expect(lastSkillVersion).toBe("stable");
-  });
-
-  it("get_environment passes the server's secret redaction through verbatim", async () => {
-    const result = await callTool("get_environment", { org: "acme", slug: "github-creds" });
-    expect(result.isError).toBeFalsy();
-    const body = JSON.parse(result.content[0]?.text ?? "{}") as Record<string, unknown>;
-    expect(body).toEqual(toJson(EnvironmentSchema, knownEnvironment, { useProtoFieldName: true }));
-    const data = (body.spec as { data: Record<string, { value: string }> }).data;
-    expect(data.API_KEY?.value).toBe("***REDACTED***");
-  });
-});

package/src/domains/resources.integration.test.ts

@@ -1,157 +0,0 @@
-// In-process integration test for the resource templates. Verifies template
-// discovery, that each read returns the backend protojson as a single
-// application/json entry, and that the skill templates resolve latest (empty
-// version) vs a pinned version.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import { AgentQueryController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/query_pb";
-import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
-import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
-import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import { McpServerQueryController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/query_pb";
-import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
-import { SkillQueryController } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/query_pb";
-import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
-import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../logger";
-import { createServer } from "../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const agent = create(AgentSchema, { apiVersion: "v1", kind: "agent", metadata: { slug: "a", org: "acme" } });
-const mcpServer = create(McpServerSchema, {
-  apiVersion: "v1",
-  kind: "mcp_server",
-  metadata: { slug: "m", org: "acme" },
-});
-const skill = create(SkillSchema, { apiVersion: "v1", kind: "skill", metadata: { slug: "s", org: "acme" } });
-const workflow = create(WorkflowSchema, {
-  apiVersion: "v1",
-  kind: "workflow",
-  metadata: { slug: "w", org: "acme" },
-});
-const environment = create(EnvironmentSchema, {
-  apiVersion: "v1",
-  kind: "environment",
-  metadata: { slug: "e", org: "acme" },
-});
-
-let backend: Http2Server;
-let client: Client;
-let lastSkillVersion: string | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ResourceResult {
-  contents: Array<{ uri: string; mimeType?: string; text?: string }>;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(AgentQueryController, { getByReference: () => agent });
-    router.service(McpServerQueryController, { getByReference: () => mcpServer });
-    router.service(SkillQueryController, {
-      getByReference: (req) => {
-        lastSkillVersion = req.version;
-        return skill;
-      },
-    });
-    router.service(WorkflowQueryController, { getByReference: () => workflow });
-    router.service(EnvironmentQueryController, { getByReference: () => environment });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "resources-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("resource templates integration", () => {
-  it("advertises every template", async () => {
-    const { resourceTemplates } = await client.listResourceTemplates();
-    expect(resourceTemplates.map((t) => t.name)).toEqual(
-      expect.arrayContaining([
-        "stigmer_agent",
-        "stigmer_mcp_server",
-        "stigmer_skill",
-        "stigmer_skill_version",
-        "stigmer_workflow",
-        "stigmer_environment",
-      ]),
-    );
-  });
-
-  it("reads an agent resource", async () => {
-    const result = (await client.readResource({ uri: "stigmer://agents/acme/a" })) as ResourceResult;
-    expect(result.contents[0]?.mimeType).toBe("application/json");
-    expect(JSON.parse(result.contents[0]?.text ?? "{}")).toEqual(
-      toJson(AgentSchema, agent, { useProtoFieldName: true }),
-    );
-  });
-
-  it("reads an mcp-server resource", async () => {
-    const result = (await client.readResource({
-      uri: "stigmer://mcp-servers/acme/m",
-    })) as ResourceResult;
-    expect(JSON.parse(result.contents[0]?.text ?? "{}")).toEqual(
-      toJson(McpServerSchema, mcpServer, { useProtoFieldName: true }),
-    );
-  });
-
-  it("reads a workflow resource", async () => {
-    const result = (await client.readResource({
-      uri: "stigmer://workflows/acme/w",
-    })) as ResourceResult;
-    expect(JSON.parse(result.contents[0]?.text ?? "{}")).toEqual(
-      toJson(WorkflowSchema, workflow, { useProtoFieldName: true }),
-    );
-  });
-
-  it("reads the latest skill (empty version)", async () => {
-    const result = (await client.readResource({ uri: "stigmer://skills/acme/s" })) as ResourceResult;
-    expect(JSON.parse(result.contents[0]?.text ?? "{}")).toEqual(
-      toJson(SkillSchema, skill, { useProtoFieldName: true }),
-    );
-    expect(lastSkillVersion).toBe("");
-  });
-
-  it("reads a pinned skill version", async () => {
-    await client.readResource({ uri: "stigmer://skills/acme/s/v2.0.0" });
-    expect(lastSkillVersion).toBe("v2.0.0");
-  });
-
-  it("reads an environment resource", async () => {
-    const result = (await client.readResource({
-      uri: "stigmer://environments/acme/e",
-    })) as ResourceResult;
-    expect(JSON.parse(result.contents[0]?.text ?? "{}")).toEqual(
-      toJson(EnvironmentSchema, environment, { useProtoFieldName: true }),
-    );
-  });
-});

package/src/domains/resourceuri.test.ts

@@ -1,104 +0,0 @@
-// Unit tests for stigmer:// resource URI parsing and construction.
-// Asserts parity with the Go server's behavior (scheme check, segment counts,
-// version handling, and the kind→authority round-trip).
-
-import { describe, expect, it } from "vitest";
-
-import {
-  buildResourceURI,
-  kindToAuthority,
-  parseResourceURI,
-  parseVersionedResourceURI,
-} from "./resourceuri";
-
-describe("parseResourceURI", () => {
-  it("extracts org and slug from a two-segment URI", () => {
-    expect(parseResourceURI("stigmer://agents/acme/code-reviewer")).toEqual({
-      org: "acme",
-      slug: "code-reviewer",
-    });
-  });
-
-  it("ignores the authority (kind) segment", () => {
-    // The authority differs but the org/slug are taken from the path only.
-    expect(parseResourceURI("stigmer://mcp-servers/acme/github")).toEqual({
-      org: "acme",
-      slug: "github",
-    });
-  });
-
-  it("rejects a non-stigmer scheme", () => {
-    expect(() => parseResourceURI("https://agents/acme/code-reviewer")).toThrow(/expected "stigmer"/);
-  });
-
-  it("rejects the wrong number of segments", () => {
-    expect(() => parseResourceURI("stigmer://agents/acme")).toThrow(/got 1/);
-    expect(() => parseResourceURI("stigmer://agents/acme/code-reviewer/v1")).toThrow(/got 3/);
-  });
-
-  it("rejects a malformed URI", () => {
-    expect(() => parseResourceURI("not a uri")).toThrow(/malformed resource URI/);
-  });
-});
-
-describe("parseVersionedResourceURI", () => {
-  it("treats two segments as latest (empty version)", () => {
-    expect(parseVersionedResourceURI("stigmer://skills/acme/my-skill")).toEqual({
-      org: "acme",
-      slug: "my-skill",
-      version: "",
-    });
-  });
-
-  it("extracts an explicit version from three segments", () => {
-    expect(parseVersionedResourceURI("stigmer://skills/acme/my-skill/v1.2.0")).toEqual({
-      org: "acme",
-      slug: "my-skill",
-      version: "v1.2.0",
-    });
-  });
-
-  it("rejects more than three segments", () => {
-    expect(() => parseVersionedResourceURI("stigmer://skills/acme/my-skill/v1/extra")).toThrow(
-      /got 4/,
-    );
-  });
-
-  it("rejects a single segment", () => {
-    expect(() => parseVersionedResourceURI("stigmer://skills/acme")).toThrow(/got 1/);
-  });
-});
-
-describe("buildResourceURI", () => {
-  it("builds a URI for every templated kind", () => {
-    expect(buildResourceURI("agent", "acme", "a")).toBe("stigmer://agents/acme/a");
-    expect(buildResourceURI("mcp_server", "acme", "m")).toBe("stigmer://mcp-servers/acme/m");
-    expect(buildResourceURI("skill", "acme", "s")).toBe("stigmer://skills/acme/s");
-    expect(buildResourceURI("workflow", "acme", "w")).toBe("stigmer://workflows/acme/w");
-    expect(buildResourceURI("environment", "acme", "e")).toBe("stigmer://environments/acme/e");
-  });
-
-  it("round-trips with parseResourceURI", () => {
-    const uri = buildResourceURI("agent", "acme", "code-reviewer");
-    expect(parseResourceURI(uri)).toEqual({ org: "acme", slug: "code-reviewer" });
-  });
-
-  it("returns empty string for an unknown kind", () => {
-    expect(buildResourceURI("organization", "acme", "x")).toBe("");
-  });
-
-  it("returns empty string when org or slug is empty", () => {
-    expect(buildResourceURI("agent", "", "x")).toBe("");
-    expect(buildResourceURI("agent", "acme", "")).toBe("");
-  });
-
-  it("covers exactly the templated kinds", () => {
-    expect(Object.keys(kindToAuthority).sort()).toEqual([
-      "agent",
-      "environment",
-      "mcp_server",
-      "skill",
-      "workflow",
-    ]);
-  });
-});