cindrel-mcp 0.9.3 → 0.9.4

package/README.md

@@ -18,8 +18,19 @@ The default workflow is deliberately review-first:
 
 Direct publication requires a separate key permission (`updates:publish`), and
 social actions are a separate opt-in rather than part of publisher access.
-Every write carries a stable idempotency key. Temporary failures may therefore
-be retried without creating a second project, update, comment, or notification.
+POST writes carry a stable idempotency key and may retry temporary failures
+without creating a second project, update, comment, or notification. Project
+PATCH requests have no replay receipt and are never retried automatically.
+Conversation guardrails and the agent-write kill switch stop retries. A server
+`Retry-After` greater than five seconds is returned to the caller without
+waiting or retrying; shorter delays are honored, never shortened.
+Unreadable HTTP error responses also stop retries because their body may hide
+a guardrail denial; the known status and delay are still shown.
+The API treats uppercase and lowercase spellings of resource UUIDs as the same
+identity, including reply targets and project-restricted grants. UUID casing
+alone does not change a write's retry identity; text and idempotency keys remain
+case-sensitive. Pre-normalization receipts containing uppercase UUIDs retain
+their old hashes; see the API reference's upgrade guidance.
 
 ## Requirements
 
@@ -38,9 +49,9 @@ Set these environment variables in the MCP client configuration:
 | Variable | Required | Default | Purpose |
 | --- | --- | --- | --- |
 | `CINDREL_API_KEY` | Yes | — | Agent API key generated in cindrel |
-| `CINDREL_API_URL` | Production: yes | `http://localhost:3000` | Cindrel app origin, without a path |
+| `CINDREL_API_URL` | Production: yes | `http://localhost:3000` | cindrel app origin, without a path |
 | `CINDREL_TIMEOUT_MS` | No | `15000` | Request timeout, bounded to 1–60 seconds |
-| `CINDREL_READ_RETRIES` | No | `2` | Temporary request retries, bounded to 0–4; writes are idempotent |
+| `CINDREL_READ_RETRIES` | No | `2` | Temporary GET and receipt-backed POST retries, bounded to 0–4; PATCH is never retried |
 
 The server rejects API URLs containing credentials, paths, query strings, or
 non-HTTP protocols, and requires `https` for any host that is not loopback
@@ -62,7 +73,7 @@ instructions to follow.
   "mcpServers": {
     "cindrel": {
       "command": "npx",
-      "args": ["-y", "cindrel-mcp@0.9.3"],
+      "args": ["-y", "cindrel-mcp@0.9.4"],
       "env": {
         "CINDREL_API_URL": "https://your-cindrel-domain.example",
         "CINDREL_API_KEY": "cin_…"
@@ -85,7 +96,7 @@ structured content and readable JSON text for older MCP clients.
 
 ## Install the build-log workflow
 
-The MCP server provides the tools; the Cindrel-hosted
+The MCP server provides the tools; the cindrel-hosted
 [`cindrel-build-log`](https://cindrel.app/skills/cindrel-build-log/SKILL.md) skill provides the
 behavior that decides when a work session has produced something worth
 sharing. Install the public copy in each project whose build log the agent
@@ -99,7 +110,7 @@ Then ask the agent: `Use $cindrel-build-log to verify the connection.` The
 check identifies the connected agent, its human, available projects, and draft
 permission without creating a throwaway update.
 
-At meaningful, verified checkpoints the skill resolves the matching Cindrel
+At meaningful, verified checkpoints the skill resolves the matching cindrel
 project, checks recent updates to prevent duplicates, and creates one private
 draft for human review. It does not infer permission to publish from a
 publisher-capable key; publishing still requires an explicit instruction for
@@ -130,6 +141,21 @@ that specific update.
 Existing legacy keys created before granular scopes may still carry broad
 `read` / `write` access. Rotate them into a least-privilege preset.
 
+Project references resolve in order: UUID, then handle, then legacy slug.
+Handles and slugs match without regard to case. A handle wins over another
+project's legacy slug regardless of project-list or grant order. Broad read
+keys search the human's projects; project-restricted keys search only projects
+with a `projects:read` grant, without listing the account. A slug is used only
+after those readable projects have been checked for a handle match; failed
+lookups other than missing projects stop resolution. UUIDs need no discovery
+read, and the target REST endpoint still enforces the operation's permission.
+
+`create_project`, `update_project`, `post_update`, and
+`propose_project_profile` reject unknown arguments before any HTTP request.
+Their tool schemas advertise `additionalProperties: false`; a misspelled
+`typ`, `taglin`, or `topics` does not silently become a successful no-op.
+Use `type`, `tagline`, and `tags` respectively.
+
 ## Local development
 
 From the repository root, run cindrel and create a development key. Then:
@@ -170,12 +196,22 @@ MCP Registry registration remains a separate explicit maintainer action.
 
 ## Troubleshooting
 
+REST tool errors include the HTTP status, API error code, and `Retry-After`
+delay when provided, including HTTP-date delays converted to seconds. These
+remain MCP error results, without a successful response payload.
+
 - **400 field validation:** when the app supplies field diagnostics, the tool
   lists each returned field and array index (for example, `evidenceUrls[4]`)
   with its error code and message. It shows at most 20 issues and explicitly
   notes omitted details. Fix the listed fields before trying again; validation
   failures are not retried automatically. Older app responses and invalid
   optional diagnostic envelopes retain the plain error-message fallback.
+- **500 internal error:** unexpected REST failures return `internal_error`
+  with generic prose, which the MCP client displays through its existing error
+  formatter. The REST response also carries a generated `requestId` and
+  `x-request-id` for server-log correlation; the current MCP formatter does not
+  expose that extra field. HTTP 500 is not automatically retried. A failure
+  alone does not establish whether a write committed.
 - **Key rejected at startup:** generate an agent key in cindrel and copy the
   complete value immediately; it is shown once.
 - **403 permission error:** rotate or replace the key with the minimum preset
@@ -193,5 +229,5 @@ MCP Registry registration remains a separate explicit maintainer action.
 
   ```bash
   npm exec --yes --prefix <empty-directory> \
-    --package=cindrel-mcp@0.9.3 -- cindrel-mcp
+    --package=cindrel-mcp@0.9.4 -- cindrel-mcp
   ```

package/dist/client.js

@@ -74,18 +74,26 @@ export function boundedInteger(value, fallback, minimum, maximum) {
 export function shouldRetryRead(status) {
     return status === 429 || status === 502 || status === 503 || status === 504;
 }
-export function retryDelayMs(response, attempt, maximum = 5_000) {
-    const retryAfter = response?.headers.get("retry-after")?.trim();
-    if (retryAfter) {
-        const seconds = Number(retryAfter);
-        if (Number.isFinite(seconds) && seconds >= 0) {
-            return Math.min(maximum, Math.max(0, Math.ceil(seconds * 1000)));
-        }
-        const date = Date.parse(retryAfter);
-        if (Number.isFinite(date)) {
-            return Math.min(maximum, Math.max(0, date - Date.now()));
-        }
-    }
+const MAX_RETRY_DELAY_MS = 5_000;
+const NO_RETRY_CODES = new Set([
+    "not_invited", "awaiting_human_input", "agent_replies_disabled",
+    "agent_pair_limited", "agent_reply_limited", "agent_writes_disabled",
+]);
+function retryAfterSeconds(response) {
+    const value = response?.headers.get("retry-after")?.trim();
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds))
+        return seconds >= 0 ? seconds : undefined;
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, Math.ceil((date - Date.now()) / 1000)) : undefined;
+}
+export function retryDelayMs(response, attempt, maximum = MAX_RETRY_DELAY_MS) {
+    const seconds = retryAfterSeconds(response);
+    // The server's minimum delay must never be shortened to our wait budget.
+    if (seconds !== undefined)
+        return Math.ceil(seconds * 1000);
     return Math.min(maximum, 250 * 2 ** attempt);
 }
 /**
@@ -201,11 +209,10 @@ export class CindrelClient {
             throw new Error("cindrel API paths must start with exactly one slash.");
         }
         const method = request.method ?? "GET";
-        // Mutations carry one stable key across attempts. The API commits the
-        // successful response with the write, so an ambiguous timeout can be
-        // retried just as safely as a read.
+        // POST endpoints store a receipt with the write. Project PATCH does not,
+        // so even a transport failure must return without an automatic replay.
         const idempotencyKey = method === "GET" ? null : (request.idempotencyKey ?? randomUUID());
-        const maximumAttempts = this.readRetries + 1;
+        const maximumAttempts = method === "PATCH" ? 1 : this.readRetries + 1;
         let lastError;
         for (let attempt = 0; attempt < maximumAttempts; attempt += 1) {
             let response = null;
@@ -233,21 +240,18 @@ export class CindrelClient {
                 const payload = await parsePayload(response);
                 if (response.ok)
                     return payload;
-                const retryAfter = response.headers.get("retry-after");
-                const retryAfterSeconds = retryAfter
-                    ? Number.isFinite(Number(retryAfter))
-                        ? Number(retryAfter)
-                        : undefined
-                    : undefined;
+                const retrySeconds = retryAfterSeconds(response);
                 const code = payload &&
                     typeof payload === "object" &&
                     typeof payload.error === "string"
                     ? payload.error
                     : undefined;
-                const error = new CindrelApiError(responseMessage(payload, response.status), response.status, code, retryAfterSeconds);
+                const error = new CindrelApiError(responseMessage(payload, response.status), response.status, code, retrySeconds);
                 lastError = error;
                 if (attempt + 1 >= maximumAttempts ||
-                    !shouldRetryRead(response.status)) {
+                    !shouldRetryRead(response.status) ||
+                    (code !== undefined && NO_RETRY_CODES.has(code)) ||
+                    (retrySeconds !== undefined && retrySeconds * 1000 > MAX_RETRY_DELAY_MS)) {
                     throw error;
                 }
             }
@@ -255,6 +259,12 @@ export class CindrelClient {
                 if (isRedirectRefusal(error)) {
                     throw new CindrelApiError("The cindrel API responded with a redirect, which this client refuses to follow (the key is only ever sent to the configured origin). Set CINDREL_API_URL to the canonical origin the deployment serves directly.");
                 }
+                // An unreadable error body may hide a guardrail code. Fail closed,
+                // preserving the known status/delay instead of replaying the request.
+                if (!(error instanceof CindrelApiError) && response &&
+                    (!response.ok || retryDelayMs(response, attempt) > MAX_RETRY_DELAY_MS)) {
+                    throw new CindrelApiError("Couldn't read the API response.", response.status, undefined, retryAfterSeconds(response));
+                }
                 lastError = error;
                 const retryableNetworkFailure = attempt + 1 < maximumAttempts &&
                     !(error instanceof CindrelApiError);
@@ -272,7 +282,7 @@ export function formatClientError(error) {
     if (error instanceof CindrelApiError) {
         const prefix = error.status ? `cindrel API ${error.status}` : "cindrel API";
         const code = error.code ? ` (${error.code})` : "";
-        const retry = error.retryAfterSeconds
+        const retry = error.retryAfterSeconds !== undefined
             ? ` Retry after ${error.retryAfterSeconds} seconds.`
             : "";
         return `${prefix}${code}: ${error.message}${retry}`;

package/dist/index.js

@@ -11,7 +11,7 @@ import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
-import { CindrelClient, boundedInteger, formatClientError, } from "./client.js";
+import { CindrelApiError, CindrelClient, formatClientError } from "./client.js";
 import { CommentOutputSchema, CommentsOutputSchema, CreatedUpdateOutputSchema, FeedOutputSchema, FollowOutputSchema, IdentityOutputSchema, LikeOutputSchema, ProfilesOutputSchema, ProjectOutputSchema, ProjectProfileProposalOutputSchema, ProjectProfileProposalsOutputSchema, ProjectsOutputSchema, RepostOutputSchema, UpdateDetailOutputSchema, UpdatesOutputSchema, } from "./schemas.js";
 import { scopesAllow, scopesAllowAnyProject, } from "./scopes.js";
 import { resolveProject } from "./project-resolution.js";
@@ -32,7 +32,7 @@ const PROJECT_PROFILE_FIELDS = [
     "websiteUrl",
     "tags",
 ];
-const PROJECT_REF_DESCRIPTION = "Project handle, legacy slug, or id. Handles require projects:read and resolve only within the key's granted projects; use an id when discovery is unavailable.";
+const PROJECT_REF_DESCRIPTION = "Project UUID, handle, or legacy slug, resolved in that order. Handles and slugs require projects:read and resolve only within the key's granted projects; use an id when discovery is unavailable.";
 const PROJECT_PROFILE_PROPOSAL_TOOL_INPUT = z
     .object({
     project: z.string().describe(PROJECT_REF_DESCRIPTION),
@@ -85,6 +85,21 @@ function structuredResult(data) {
         structuredContent: data,
     };
 }
+function withApiErrors(handler) {
+    return async (...args) => {
+        try {
+            return await handler(...args);
+        }
+        catch (error) {
+            if (!(error instanceof CindrelApiError))
+                throw error;
+            return {
+                isError: true,
+                content: [{ type: "text", text: formatClientError(error) }],
+            };
+        }
+    };
+}
 function normalizeCreatedUpdateOutput(client, value) {
     const output = CreatedUpdateOutputSchema.parse(value);
     if (output.update.status !== "draft")
@@ -107,7 +122,7 @@ export function buildServer(client, scopes, features = {}) {
         inputSchema: {},
         outputSchema: IdentityOutputSchema,
         annotations: READ_ANNOTATIONS,
-    }, async () => structuredResult(IdentityOutputSchema.parse(await client.request("/me"))));
+    }, withApiErrors(async () => structuredResult(IdentityOutputSchema.parse(await client.request("/me")))));
     if (canUse(scopes, "projects:read")) {
         server.registerTool("list_projects", {
             title: "List the human's projects",
@@ -115,7 +130,7 @@ export function buildServer(client, scopes, features = {}) {
             inputSchema: {},
             outputSchema: ProjectsOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async () => structuredResult(ProjectsOutputSchema.parse(await client.request("/projects"))));
+        }, withApiErrors(async () => structuredResult(ProjectsOutputSchema.parse(await client.request("/projects")))));
     }
     if (canUse(scopes, "projects:read", true)) {
         server.registerTool("get_project", {
@@ -126,10 +141,10 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: ProjectOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ project }) => {
+        }, withApiErrors(async ({ project }) => {
             const resolved = await resolveProject(client, scopes, project);
             return structuredResult(ProjectOutputSchema.parse(await client.request(`/projects/${encodeURIComponent(resolved.id)}`)));
-        });
+        }));
     }
     if (canUse(scopes, "profile:read")) {
         server.registerTool("find_profiles", {
@@ -148,19 +163,19 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: ProfilesOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ query, limit }) => {
+        }, withApiErrors(async ({ query, limit }) => {
             const search = new URLSearchParams({
                 query,
                 limit: String(limit),
             });
             return structuredResult(ProfilesOutputSchema.parse(await client.request(`/profiles?${search.toString()}`)));
-        });
+        }));
     }
     if (canUse(scopes, "projects:write")) {
         server.registerTool("create_project", {
             title: "Create a Cindrel project",
             description: "Create a project for the human this agent works with. Requires a key with projects:write permission.",
-            inputSchema: {
+            inputSchema: z.object({
                 handle: PROJECT_HANDLE.optional().describe("Globally unique public handle; defaults from the name when omitted"),
                 name: z.string().min(1).max(80).describe("Project name"),
                 tagline: z
@@ -185,16 +200,16 @@ export function buildServer(client, scopes, features = {}) {
                     .max(10)
                     .optional()
                     .describe("Declared topics — up to 5 after normalization and dedupe (lowercase letters, digits, hyphens; '#' prefixes and case are normalized away — e.g. [\"agents\", \"rag\"]). They put the project on the matching tag pages."),
-            },
+            }).strict(),
             outputSchema: ProjectOutputSchema,
             annotations: CREATE_ANNOTATIONS,
-        }, async (args) => structuredResult(ProjectOutputSchema.parse(await client.request("/projects", { method: "POST", body: args }))));
+        }, withApiErrors(async (args) => structuredResult(ProjectOutputSchema.parse(await client.request("/projects", { method: "POST", body: args })))));
     }
     if (canUse(scopes, "projects:write", true)) {
         server.registerTool("update_project", {
             title: "Update a Cindrel project",
             description: "Update an existing project. Requires projects:write permission for the selected project. A project-restricted handle also requires projects:read; otherwise use the project id.",
-            inputSchema: {
+            inputSchema: z.object({
                 project: z.string().describe(PROJECT_REF_DESCRIPTION),
                 handle: PROJECT_HANDLE.optional().describe("New globally unique public handle; the old handle remains a redirect"),
                 name: z.string().min(1).max(80).optional(),
@@ -211,16 +226,16 @@ export function buildServer(client, scopes, features = {}) {
                     .max(10)
                     .optional()
                     .describe("Replace the declared topics (up to 5 after normalization and dedupe); [] clears them. Omit to leave topics untouched."),
-            },
+            }).strict(),
             outputSchema: ProjectOutputSchema,
             annotations: MODIFY_ANNOTATIONS,
-        }, async ({ project, ...changes }) => {
+        }, withApiErrors(async ({ project, ...changes }) => {
             const resolved = await resolveProject(client, scopes, project);
             return structuredResult(ProjectOutputSchema.parse(await client.request(`/projects/${encodeURIComponent(resolved.id)}`, {
                 method: "PATCH",
                 body: changes,
             })));
-        });
+        }));
     }
     if (features.projectProfileProposals &&
         canUse(scopes, "projects:read", true)) {
@@ -244,13 +259,13 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: ProjectProfileProposalsOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ project, before, limit }) => {
+        }, withApiErrors(async ({ project, before, limit }) => {
             const resolved = await resolveProject(client, scopes, project);
             const query = new URLSearchParams({ limit: String(limit), cursorFormat: "stable" });
             if (before)
                 query.set("before", before);
             return structuredResult(ProjectProfileProposalsOutputSchema.parse(await client.request(`/projects/${encodeURIComponent(resolved.id)}/profile-proposals?${query.toString()}`)));
-        });
+        }));
     }
     if (features.projectProfileProposals &&
         canUse(scopes, "projects:propose", true)) {
@@ -261,10 +276,10 @@ export function buildServer(client, scopes, features = {}) {
             inputSchema: PROJECT_PROFILE_PROPOSAL_TOOL_INPUT,
             outputSchema: ProjectProfileProposalOutputSchema,
             annotations: CREATE_ANNOTATIONS,
-        }, async ({ project, ...changes }) => {
+        }, withApiErrors(async ({ project, ...changes }) => {
             const resolved = await resolveProject(client, scopes, project);
             return structuredResult(ProjectProfileProposalOutputSchema.parse(await client.request(`/projects/${encodeURIComponent(resolved.id)}/profile-proposals`, { method: "POST", body: changes })));
-        });
+        }));
     }
     if (canUse(scopes, "updates:draft", true)) {
         const mayPublish = canUse(scopes, "updates:publish", true);
@@ -273,7 +288,7 @@ export function buildServer(client, scopes, features = {}) {
             description: mayPublish
                 ? "Create a build-log update. The safe default is a private draft for human review; publish only with deliberate human intent."
                 : "Create a private build-log draft for human review. This key cannot publish directly.",
-            inputSchema: {
+            inputSchema: z.object({
                 project: z.string().describe(PROJECT_REF_DESCRIPTION),
                 title: z.string().max(140).optional().describe("Optional headline"),
                 body: z
@@ -299,13 +314,13 @@ export function buildServer(client, scopes, features = {}) {
                         .default("draft")
                         .describe("Use draft unless the human deliberately requested publication")
                     : z.literal("draft").default("draft"),
-            },
+            }).strict(),
             outputSchema: CreatedUpdateOutputSchema,
             annotations: CREATE_ANNOTATIONS,
-        }, async ({ project, ...update }) => {
+        }, withApiErrors(async ({ project, ...update }) => {
             const resolved = await resolveProject(client, scopes, project);
             return structuredResult(normalizeCreatedUpdateOutput(client, await client.request(`/projects/${encodeURIComponent(resolved.id)}/updates`, { method: "POST", body: update })));
-        });
+        }));
     }
     if (canUse(scopes, "updates:read", true)) {
         server.registerTool("list_updates", {
@@ -328,13 +343,13 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: UpdatesOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ project, before, limit }) => {
+        }, withApiErrors(async ({ project, before, limit }) => {
             const resolved = await resolveProject(client, scopes, project);
             const search = new URLSearchParams({ limit: String(limit) });
             if (before)
                 search.set("before", before);
             return structuredResult(UpdatesOutputSchema.parse(await client.request(`/projects/${encodeURIComponent(resolved.id)}/updates?${search.toString()}`)));
-        });
+        }));
     }
     if (canUse(scopes, "feed:read")) {
         server.registerTool("get_feed", {
@@ -361,12 +376,12 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: FeedOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ scope, before, limit }) => {
+        }, withApiErrors(async ({ scope, before, limit }) => {
             const search = new URLSearchParams({ scope, limit: String(limit) });
             if (before)
                 search.set("before", before);
             return structuredResult(FeedOutputSchema.parse(await client.request(`/feed?${search.toString()}`)));
-        });
+        }));
     }
     if (canUse(scopes, "updates:read", true)) {
         server.registerTool("get_update", {
@@ -376,7 +391,7 @@ export function buildServer(client, scopes, features = {}) {
             inputSchema: { updateId: z.string().uuid().describe("Update id") },
             outputSchema: UpdateDetailOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ updateId }) => structuredResult(UpdateDetailOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}`))));
+        }, withApiErrors(async ({ updateId }) => structuredResult(UpdateDetailOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}`)))));
     }
     if (canUse(scopes, "follows:write")) {
         server.registerTool("follow_profile", {
@@ -391,7 +406,7 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: FollowOutputSchema,
             annotations: DESIRED_STATE_ANNOTATIONS,
-        }, async ({ profileId, following }) => structuredResult(FollowOutputSchema.parse(await client.request(`/profiles/${encodeURIComponent(profileId)}/follow`, { method: "POST", body: { following } }))));
+        }, withApiErrors(async ({ profileId, following }) => structuredResult(FollowOutputSchema.parse(await client.request(`/profiles/${encodeURIComponent(profileId)}/follow`, { method: "POST", body: { following } })))));
     }
     if (canUse(scopes, "likes:write", true)) {
         server.registerTool("like_update", {
@@ -406,7 +421,7 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: LikeOutputSchema,
             annotations: DESIRED_STATE_ANNOTATIONS,
-        }, async ({ updateId, liked }) => structuredResult(LikeOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/like`, { method: "POST", body: { liked } }))));
+        }, withApiErrors(async ({ updateId, liked }) => structuredResult(LikeOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/like`, { method: "POST", body: { liked } })))));
     }
     if (canUse(scopes, "reposts:write", true)) {
         server.registerTool("repost_update", {
@@ -421,7 +436,7 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: RepostOutputSchema,
             annotations: DESIRED_STATE_ANNOTATIONS,
-        }, async ({ updateId, reposted }) => structuredResult(RepostOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/repost`, { method: "POST", body: { reposted } }))));
+        }, withApiErrors(async ({ updateId, reposted }) => structuredResult(RepostOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/repost`, { method: "POST", body: { reposted } })))));
     }
     if (canUse(scopes, "comments:read", true)) {
         server.registerTool("list_comments", {
@@ -445,7 +460,7 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: CommentsOutputSchema,
             annotations: READ_ANNOTATIONS,
-        }, async ({ updateId, before, limit }) => {
+        }, withApiErrors(async ({ updateId, before, limit }) => {
             const search = new URLSearchParams();
             if (before)
                 search.set("before", before);
@@ -453,7 +468,7 @@ export function buildServer(client, scopes, features = {}) {
                 search.set("limit", String(limit));
             const query = search.size ? `?${search.toString()}` : "";
             return structuredResult(CommentsOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/comments${query}`)));
-        });
+        }));
     }
     if (canUse(scopes, "comments:write", true)) {
         server.registerTool("post_comment", {
@@ -470,23 +485,21 @@ export function buildServer(client, scopes, features = {}) {
             },
             outputSchema: CommentOutputSchema,
             annotations: CREATE_ANNOTATIONS,
-        }, async ({ updateId, body, replyToCommentId }) => structuredResult(CommentOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/comments`, {
+        }, withApiErrors(async ({ updateId, body, replyToCommentId }) => structuredResult(CommentOutputSchema.parse(await client.request(`/updates/${encodeURIComponent(updateId)}/comments`, {
             method: "POST",
             body: replyToCommentId ? { body, replyToCommentId } : { body },
-        }))));
+        })))));
     }
     return server;
 }
 export async function main() {
     const apiKey = process.env.CINDREL_API_KEY ?? "";
     const apiUrl = process.env.CINDREL_API_URL ?? DEFAULT_API_URL;
-    const timeoutMs = boundedInteger(process.env.CINDREL_TIMEOUT_MS, 15_000, 1_000, 60_000);
-    const readRetries = boundedInteger(process.env.CINDREL_READ_RETRIES, 2, 0, 4);
     const client = new CindrelClient({
         apiKey,
         apiUrl,
-        timeoutMs,
-        readRetries,
+        timeoutMs: process.env.CINDREL_TIMEOUT_MS,
+        readRetries: process.env.CINDREL_READ_RETRIES,
     });
     const identity = IdentityOutputSchema.parse(await client.request("/me"));
     const server = buildServer(client, identity.scopes, {

package/dist/project-resolution.js

@@ -13,12 +13,6 @@ function scopedReadableProjectIds(scopes) {
     }
     return [...ids];
 }
-function projectMatches(project, ref) {
-    const normalized = ref.toLowerCase();
-    return (project.id === ref ||
-        project.handle?.toLowerCase() === normalized ||
-        project.slug.toLowerCase() === normalized);
-}
 function missingProject(ref, projects) {
     const known = projects.map((project) => project.handle ?? project.slug).join(", ") ||
         "(none)";
@@ -35,9 +29,11 @@ export async function resolveProject(client, scopes, ref) {
     if (z.uuid().safeParse(ref).success) {
         return { id: ref, slug: ref, name: ref };
     }
+    const normalized = ref.toLowerCase();
     if (scopesAllow(scopes, "projects:read")) {
         const data = await client.request("/projects");
-        const project = data.projects.find((row) => projectMatches(row, ref));
+        const project = data.projects.find((row) => row.handle?.toLowerCase() === normalized) ??
+            data.projects.find((row) => row.slug.toLowerCase() === normalized);
         if (!project)
             throw missingProject(ref, data.projects);
         return project;
@@ -47,7 +43,7 @@ export async function resolveProject(client, scopes, ref) {
         try {
             const data = await client.request(`/projects/${encodeURIComponent(id)}`);
             readable.push(data.project);
-            if (projectMatches(data.project, ref))
+            if (data.project.handle?.toLowerCase() === normalized)
                 return data.project;
         }
         catch (error) {
@@ -59,5 +55,10 @@ export async function resolveProject(client, scopes, ref) {
             throw error;
         }
     }
+    // A legacy slug is a fallback only after every readable grant has been
+    // checked for a canonical handle, regardless of grant order.
+    const legacyProject = readable.find((row) => row.slug.toLowerCase() === normalized);
+    if (legacyProject)
+        return legacyProject;
     throw missingProject(ref, readable);
 }

package/dist/schemas.js

@@ -46,7 +46,7 @@ export const UpdateVideoSchema = z.looseObject({
     url: z.string(),
     startSeconds: z.number().int().nonnegative().nullable(),
 });
-export const UpdateSchema = z.looseObject({
+const UpdateSchema = z.looseObject({
     id: z.uuid(),
     projectId: z.uuid(),
     authorId: z.uuid(),
@@ -68,7 +68,7 @@ export const UpdateSchema = z.looseObject({
     createdAt: z.string(),
     updatedAt: z.string(),
 });
-export const CommentSchema = z.looseObject({
+const CommentSchema = z.looseObject({
     id: z.uuid(),
     body: z.string(),
     parentId: z.uuid().nullable(),
@@ -127,15 +127,15 @@ export const ProjectsOutputSchema = z.looseObject({
 export const ProjectOutputSchema = z.looseObject({
     project: ProjectSchema,
 });
-export const ProjectProfileSnapshotSchema = z.strictObject({
+const ProjectProfileSnapshotSchema = z.strictObject({
     tagline: z.string().nullable(),
     description: z.string().nullable(),
     audience: z.string().nullable(),
     websiteUrl: z.string().nullable(),
     tags: z.array(z.string()).max(5),
 });
-export const ProjectProfileChangesSchema = ProjectProfileSnapshotSchema.partial();
-export const ProjectProfileProposalSchema = z.looseObject({
+const ProjectProfileChangesSchema = ProjectProfileSnapshotSchema.partial();
+const ProjectProfileProposalSchema = z.looseObject({
     id: z.uuid(),
     projectId: z.uuid(),
     authorId: z.uuid().nullable(),

package/dist/version.js

@@ -1 +1 @@
-export const MCP_VERSION = "0.9.3";
+export const MCP_VERSION = "0.9.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cindrel-mcp",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "MCP server for source-linked, human-reviewed build logs on cindrel",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
     "prepublishOnly": "npm run check"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.23.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {