io.github.usekaneo/kaneo

version 0.1.13

scanned 2026-10-16
source github.com/usekaneo/kaneo
commit 302e358cb1f4
transport stdio
files read 3477
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

55measured on 99% of this axis

scored on the declared repository, because the published package carries its code only as build output, which is not read as the server's own source; no tag matched this version, so the repository's default branch was read and the findings describe that code, not necessarily the release; 1 finding in test code is listed but not deducted; 13 vendored or minified paths were excluded before scanning; machine-generated bundles are not the server's own code; 3 files could not be parsed and were not scanned

Auth Postureweight 20

100measured on 65% of this axis

Dependency Healthweight 20

not assessed

no lockfile in the fetched source; dependency versions are unresolved, so no vulnerability can be attributed

Maintenanceweight 15

94measured on 90% of this axis

Transparencyweight 15

The evidence

Every deduction below names the artefact that produced it. Nothing on this page was executed: the source was read, never run, and no running server was contacted.

Code Safety

Showing the 50 most severe of 70 findings on this axis. The score was computed over all of them — findings beyond the fourth of a severity still deduct at a tenth of their weight — so the remainder is omitted from this page, not from the arithmetic.

apps/api/src/telegram-integration/controllers/telegram-controller.ts:74mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    ] as const) {
      if (key in parsed) {
        parsed[key] = "[REDACTED]";
      }
    }
```
apps/api/src/workspace/controllers/get-my-capabilities.ts:19mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
      permissions[resource] = [...actions];
    }
    result[name] = allows(permissions);
  }
  return result;
```
apps/site/hooks/use-task-filters.ts:42mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    if (Array.isArray(value)) {
      const values = value.filter((v): v is string => typeof v === "string");
      normalized[key] = values.length > 0 ? values : null;
    }
  }
```
apps/web/src/components/import/summarize-import-counts.ts:53mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    if (project.status !== "completed") continue;
    for (const key of Object.keys(total) as (keyof ImportCounts)[]) {
      total[key] += project.counts[key];
    }
  }
```
apps/web/src/hooks/use-task-filters-with-labels-support.ts:67mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    if (Array.isArray(value)) {
      const values = value.filter((v): v is string => typeof v === "string");
      normalized[key] = values.length > 0 ? values : null;
    }
  }
```
apps/web/src/hooks/use-task-filters.ts:60mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    if (Array.isArray(value)) {
      const values = value.filter((v): v is string => typeof v === "string");
      normalized[key] = values.length > 0 ? values : null;
    }
  }
```
apps/web/src/hooks/use-workspace-permission.ts:24mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  const out = {} as CapabilityMap;
  for (const key of WORKSPACE_CAPABILITY_NAMES) {
    out[key] = false;
  }
  return out;
```
apps/web/src/lib/task-filters/count-values.ts:8mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  for (const item of items) {
    for (const value of new Set(pick(item))) {
      if (value) counts[value] = (counts[value] ?? 0) + 1;
    }
  }
```
packages/cli/src/render/table.ts:45mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
      if (excess <= 0) return;
      const current = widths[index] ?? 0;
      widths[index] = Math.max(minWidth(index), current - excess);
    }
  };
```
packages/mcp/src/install/merge-config.ts:56mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
          continue;
        }
        map[key] = (raw as Record<string, unknown>)[key];
      }
    }
```
scripts/i18n/shared.mjs:107mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    const next = current[segment];
    if (!next || typeof next !== "object" || Array.isArray(next)) {
      current[segment] = {};
    }
    current = current[segment];
```
scripts/ui-review-bot/ci.mjs:107mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
      );
      await writeFile(path.join(output, name), PNG.sync.write(png));
      item[side] = { ...diagnostics(raw[side], scenario, side), image: name };
    }
    if (scenario.focus) {
```
apps/api/src/import/destination-fetch.ts:8mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
export const destinationFetch: FetchLike = async (input, init) => {
  const response = await fetch(input, {
    ...(init as UndiciRequestInit),
    dispatcher: agent,
```
apps/api/src/mcp/tools.ts:44mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
    const res = await fetch(url, {
      ...init,
      headers,
```
apps/api/src/plugins/discord/client.ts:51mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      data: { integration: "discord" },
    });
    const response = await fetch(webhookUrl, {
      method: "POST",
      headers: {
```
apps/api/src/plugins/gitea/utils/gitea-api.ts:107mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      data: { integration: "gitea" },
    });
    const res = await fetch(url, {
      ...init,
      signal: controller.signal,
```
apps/api/src/plugins/gitlab/utils/gitlab-api.ts:148mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      data: { integration: "gitlab" },
    });
    const res = await fetch(url, {
      ...init,
      signal: controller.signal,
```
apps/api/src/plugins/mattermost/client.ts:26mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  try {
    const response = await fetch(webhookUrl, {
      method: "POST",
      headers: {
```
apps/api/src/plugins/slack/client.ts:39mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      data: { integration: "slack" },
    });
    const response = await fetch(webhookUrl, {
      method: "POST",
      headers: {
```
apps/api/src/utils/bounded-github-fetch.ts:19mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      deadline,
      (async () => {
        const response = await fetch(input, {
          ...init,
          redirect: "error",
```
apps/api/src/utils/outbound-request.ts:84mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    controller.signal.throwIfAborted();
    const response = await withoutOutboundTelemetry(() =>
      fetch(url, {
        ...init,
        method: "POST",
```
apps/site/lib/blog/index.ts:45mcp-js-path-join-unvalidated (medium/low)
A filesystem path is assembled from a non-literal and read or written without confinement. path.join does not resolve away `..`, and path.resolve discards the base entirely on an absolute second component.
```
function readPost(file: string): BlogPost {
  const slug = file.replace(/\.md$/, "");
  const raw = fs.readFileSync(path.join(CONTENT_DIR, file), "utf8");
  const { data, content } = parseFrontmatter(raw, file);
```
apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:107mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  const remove = { ...view, enabled: canDeleteTasks() };

  useShortcut("changeStatus", () => request("status"), edit);
  useShortcut("changePriority", () => request("priority"), edit);
  useShortcut("assignTask", () => request("assignee"), assign);
```
apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:108mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  useShortcut("changeStatus", () => request("status"), edit);
  useShortcut("changePriority", () => request("priority"), edit);
  useShortcut("assignTask", () => request("assignee"), assign);
  useShortcut("changeLabels", () => request("labels"), labels);
```

apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:109mcp-js-ssrf-nonliteral-url (medium/low)

An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.

  useShortcut("changeStatus", () => request("status"), edit);
  useShortcut("changePriority", () => request("priority"), edit);
  useShortcut("assignTask", () => request("assignee"), assign);
  useShortcut("changeLabels", () => request("labels"), labels);
  useShortcut("setDueDate", () => request("dueDate"), edit);

apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:110mcp-js-ssrf-nonliteral-url (medium/low)

An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.

  useShortcut("changePriority", () => request("priority"), edit);
  useShortcut("assignTask", () => request("assignee"), assign);
  useShortcut("changeLabels", () => request("labels"), labels);
  useShortcut("setDueDate", () => request("dueDate"), edit);
  useShortcut("deleteTask", () => request("delete"), remove);

apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:111mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  useShortcut("assignTask", () => request("assignee"), assign);
  useShortcut("changeLabels", () => request("labels"), labels);
  useShortcut("setDueDate", () => request("dueDate"), edit);
  useShortcut("deleteTask", () => request("delete"), remove);
```
apps/web/src/components/project/task-view-keys/use-task-action-shortcuts.ts:112mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  useShortcut("changeLabels", () => request("labels"), labels);
  useShortcut("setDueDate", () => request("dueDate"), edit);
  useShortcut("deleteTask", () => request("delete"), remove);

  useShortcut(
```
apps/web/src/fetchers/discord-integration/create-discord-integration.ts:22mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: CreateDiscordIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/discord-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/discord-integration/delete-discord-integration.ts:6mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function deleteDiscordIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/discord-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/discord-integration/get-discord-integration.ts:24mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function getDiscordIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/discord-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/discord-integration/update-discord-integration.ts:23mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: UpdateDiscordIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/discord-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/generic-webhook-integration/create-generic-webhook-integration.ts:29mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: CreateGenericWebhookIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/generic-webhook-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/generic-webhook-integration/delete-generic-webhook-integration.ts:6mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function deleteGenericWebhookIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/generic-webhook-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/generic-webhook-integration/get-generic-webhook-integration.ts:34mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  projectId: string,
): Promise<GenericWebhookIntegration | null> {
  const response = await fetch(
    getApiUrl(`/generic-webhook-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/generic-webhook-integration/update-generic-webhook-integration.ts:30mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: UpdateGenericWebhookIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/generic-webhook-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/mattermost-integration/create-mattermost-integration.ts:22mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: CreateMattermostIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/mattermost-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/mattermost-integration/delete-mattermost-integration.ts:6mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function deleteMattermostIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/mattermost-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/mattermost-integration/get-mattermost-integration.ts:24mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function getMattermostIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/mattermost-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/mattermost-integration/update-mattermost-integration.ts:23mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: UpdateMattermostIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/mattermost-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/mcp/get-authorization-request.ts:11mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  requestId: string,
): Promise<McpAuthorizationRequest> {
  const response = await fetch(
    getApiUrl(`/mcp/authorize/request/${encodeURIComponent(requestId)}`),
    { credentials: "include" },
```
apps/web/src/fetchers/mcp/submit-authorization-decision.ts:7mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  approved: boolean,
): Promise<string> {
  const response = await fetch(
    getApiUrl(`/mcp/authorize/request/${encodeURIComponent(requestId)}`),
    {
```
apps/web/src/fetchers/notification-preferences/delete-notification-workspace-rule.ts:8mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  workspaceId: string,
): Promise<NotificationPreferences> {
  const response = await fetch(
    getApiUrl(`/notification-preferences/workspaces/${workspaceId}`),
    {
```
apps/web/src/fetchers/notification-preferences/get-notification-preferences.ts:49mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function getNotificationPreferences(): Promise<NotificationPreferences> {
  const response = await fetch(getApiUrl("/notification-preferences"), {
    credentials: "include",
  });
```
apps/web/src/fetchers/notification-preferences/update-notification-preferences.ts:27mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: UpdateNotificationPreferencesRequest,
): Promise<NotificationPreferences> {
  const response = await fetch(getApiUrl("/notification-preferences"), {
    body: JSON.stringify(json),
    credentials: "include",
```
apps/web/src/fetchers/notification-preferences/upsert-notification-workspace-rule.ts:19mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: UpsertNotificationWorkspaceRuleRequest,
): Promise<NotificationPreferences> {
  const response = await fetch(
    getApiUrl(`/notification-preferences/workspaces/${workspaceId}`),
    {
```
apps/web/src/fetchers/project/background.ts:13mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  const upload = await uploadResponse.json();

  const storageResponse = await fetch(upload.uploadUrl, {
    method: "PUT",
    headers: upload.headers,
```
apps/web/src/fetchers/slack-integration/create-slack-integration.ts:22mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  json: CreateSlackIntegrationRequest,
) {
  const response = await fetch(
    getApiUrl(`/slack-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/slack-integration/delete-slack-integration.ts:6mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function deleteSlackIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/slack-integration/project/${projectId}`),
    {
```
apps/web/src/fetchers/slack-integration/get-slack-integration.ts:24mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function getSlackIntegration(projectId: string) {
  const response = await fetch(
    getApiUrl(`/slack-integration/project/${projectId}`),
    {
```

Auth Posture

authentication_model
stdio transport: the client launches the server as a subprocess, so the OS process boundary is the auth boundary — `03` §4 does not penalise absent auth here
transport_security
declared transport: stdio — launched as a subprocess by the client, so the security boundary is the client process, not a network port (`03` §4)
secret_handling
source was fetched but every file in it was oversized, unreadable or excluded, so no source text could be read, so there is nothing to scan for committed credentials
authorization_granularity
source was fetched but every file in it was oversized, unreadable or excluded, so no source text could be read, so neither the tool count nor any access-control logic can be read

Maintenance

recency
last commit 3 day(s) before 2026-10-16
issue_responsiveness
median over 47 issue(s) in the last 6 months: 6.1 day(s) to first maintainer comment
release_cadence
released 4 day(s) ago (by releases), inside `03` §5's 30-day window
bus_factor
3 authors with >= 5 commits in 12 months
repository_signals
`03` §5 scores this by quartile WITHIN the server's category, which needs a distribution across every scanned server and so cannot be computed while scanning one. It is a post-pass over the crawl and that pass does not exist yet.

Transparency

license
LICENSE present with no SPDX-License-Identifier tag; identified as 'MIT' from its text
readme_quality
README.md: installation instructions (+25), configuration documented (+25), exposed tools or resources enumerated (+30), states what the server does in the first 200 words (+20)
declared_scopes
neither the README nor the MCP manifest documents what the server accesses or what side effects it has
changelog
no CHANGELOG in the fetched source. `03` §7's partial credit for tagged releases carrying release notes is not applied here — that needs the forge API, which this check does not call
security_contact
no SECURITY.md and no disclosure contact in the README, so a finder has no route to report a vulnerability privately

Contest a finding

Every number here comes from a rule reading published source, and rules get things wrong. If something on this page is incorrect — or correct but mitigated by a check the rule cannot see — open an issue and we answer it in writing. A finding we got wrong is removed and the rule is fixed; one that stands is answered on the record.

Anyone can file: the maintainer, a researcher who disagrees with the classification, or a user who tested the server and could not reproduce it. Name this server and the rule or advisory ID shown beside the finding above. We aim to reply within five business days and to resolve within ten.

Open an appeal on GitHub