standup-mr 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -4,6 +4,62 @@ All notable changes to standup-mr are recorded here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
 [semantic versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] - 2026-09-01
+
+### Fixed
+
+- One flaky sub-request no longer costs the whole note. A run fans out to
+  several requests per merge request — pull detail, check runs, reviews, and
+  for a red pipeline the run, the job and its log — and any one of them
+  returning a 502 aborted the entire standup. Server errors (5xx) and dropped
+  connections are now retried twice with a short backoff before giving up. When
+  the retries run out the error is raised exactly as before: nothing is
+  swallowed. A rejected token (401), a refused resource (403), a rate limit
+  (429) and a missing resource (404) are not retried, because retrying them is
+  never the right answer.
+- A blocker whose diagnosis could not be fetched is now reported as a blocker
+  with `job: "unknown"` and an error line reading
+  `diagnosis unavailable: <reason>`, instead of failing the run. The merge
+  request is genuinely blocked either way, and the log fetch already degraded
+  this way; the metadata calls around it now match. **A 401 is never degraded**
+  — a revoked or invalid token still fails loudly, which is the whole reason
+  these calls throw in the first place.
+
+### Added
+
+- `mcpName` in `package.json`, for publication to the official MCP Registry.
+
+## [0.3.0] - 2026-09-01
+
+### Added
+
+- `standup mcp` — starts the stdio MCP server directly from the CLI, so
+  `npx -y standup-mr mcp` works without a local clone.
+- `standup instructions` — prints the note-writing playbook (the standup
+  skill body, minus its YAML frontmatter) to stdout, for teaching a
+  non-Claude assistant the same rules, e.g.
+  `npx standup-mr instructions >> AGENTS.md`.
+- README section for using the MCP server from Cursor, Codex, or another
+  assistant.
+
+### Fixed
+
+- The skill wrote the note in English even when the user was speaking Turkish.
+  The language rule was buried as a clause inside a sentence about section
+  structure, and `fetch` was called with no `--lang`, so every date label in
+  the JSON came back English and outweighed it. The rule is now a standalone,
+  unmissable line, and the skill passes `--lang` to match the user's language
+  so the payload reinforces the note instead of fighting it.
+- On a machine where both `gh` and `glab` are authenticated, every run failed
+  once before succeeding: the skill called `fetch` with no `--provider`, hit
+  the "both authenticated" error, then retried with the flag. The skill now
+  passes `--provider` on the first call whenever it's known, and only asks the
+  user (instead of guessing) when it genuinely isn't.
+
+Nothing breaking. `@modelcontextprotocol/sdk` moves from a dev dependency to
+a regular dependency, since the CLI can now start the MCP server itself; the
+CLI's `fetch`/`post`/`instructions` path still pulls nothing.
+
 ## [0.2.1] - 2026-08-31
 
 ### Fixed

package/README.md

@@ -76,6 +76,52 @@ skill. From inside Claude Code:
 
 Then type `/standup`. Updates come with `/plugin marketplace update standup-mr`.
 
+### Using it from Cursor, Codex, or another assistant
+
+If you're not using Claude Code, wire up the MCP server for live data and
+paste in the note-writing rules separately.
+
+**Cursor** — add to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json`
+(project-local):
+
+```json
+{
+  "mcpServers": {
+    "standup": {
+      "command": "npx",
+      "args": ["-y", "standup-mr", "mcp"],
+      "env": {
+        "GITHUB_TOKEN": "ghp_..."
+      }
+    }
+  }
+}
+```
+
+**Codex** — add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.standup]
+command = "npx"
+args = ["-y", "standup-mr", "mcp"]
+
+[mcp_servers.standup.env]
+GITHUB_TOKEN = "ghp_..."
+```
+
+The exact config key and file path are version-dependent for both clients —
+if a snippet above doesn't work, check [Cursor's MCP
+docs](https://docs.cursor.com/context/mcp) or Codex's own config
+documentation for the current format rather than trusting this file blindly.
+
+The tool only returns data; the assistant still needs the note-writing rules
+that the Claude Code skill carries. Paste them into whatever instructions
+file your assistant reads (e.g. `AGENTS.md`):
+
+```bash
+npx standup-mr instructions >> AGENTS.md
+```
+
 ## `--markdown` is a digest, not a written note
 
 `--markdown` organizes the raw material into readable sections. It does **not**
@@ -142,6 +188,10 @@ that the package is missing.
 - **On GitHub, CI that reports only through the legacy commit-statuses API**
   — still how some vendors integrate — shows up as `pipelineMissing`. Check
   state is read from check-runs only.
+- **A blocker whose diagnosis could not be fetched is still reported**, as
+  `job: "unknown"` with a `diagnosis unavailable: …` error line. The merge
+  request is blocked either way; only the explanation is missing. Server
+  errors are retried twice first, and a rejected token still fails the run.
 
 ## Upgrading from 0.1.x
 
@@ -162,7 +212,9 @@ the `standup` skill changed along with the report shape.
 
 ## Requirements
 
-Node 20 or newer. No runtime dependencies.
+Node 20 or newer. The CLI core (`fetch`, `post`, `instructions`) pulls no
+runtime dependencies. The MCP server (`mcp` command) brings one:
+`@modelcontextprotocol/sdk`.
 
 ## License
 

package/dist/{chunk-DL2P3XR6.js → chunk-2X2XEEUY.js}

@@ -218,9 +218,11 @@ function buildUrl(api, path, params) {
   return `${base}?${query.toString()}`;
 }
 var ApiError = class extends Error {
-  constructor(message) {
+  status;
+  constructor(message, status) {
     super(message);
     this.name = "ApiError";
+    this.status = status;
   }
 };
 function remaining(response) {
@@ -244,27 +246,67 @@ function assertUsable(response, host) {
   if (response.ok || response.status === 404) return;
   if (response.status === 403 || response.status === 429) {
     if (remaining(response) === "0") {
-      throw new ApiError(`${host} rate limit reached${resetAt(response)}.`);
+      throw new ApiError(`${host} rate limit reached${resetAt(response)}.`, response.status);
     }
     const retry = retryAfter(response);
-    if (retry) throw new ApiError(`${host} rate limit reached${retry}.`);
+    if (retry) throw new ApiError(`${host} rate limit reached${retry}.`, response.status);
   }
   if (response.status === 401) {
     throw new ApiError(
-      `${host} rejected the token (401). Check the token and its scopes.`
+      `${host} rejected the token (401). Check the token and its scopes.`,
+      401
     );
   }
   if (response.status === 403) {
     throw new ApiError(
-      `${host} refused the request (403). The token has no access to that resource.`
+      `${host} refused the request (403). The token has no access to that resource.`,
+      403
     );
   }
-  throw new ApiError(`${host} returned ${response.status}.`);
+  throw new ApiError(`${host} returned ${response.status}.`, response.status);
 }
 function unreachable(host, cause) {
   const detail = cause instanceof Error ? cause.message : String(cause);
   return new ApiError(`Could not reach ${host}: ${detail}`);
 }
+var RETRY_ATTEMPTS = 3;
+var RETRY_BACKOFF_MS = [250, 750];
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function sendWithRetry(fetchImpl, url, init, host, sleep = wait) {
+  let last;
+  for (let attempt = 0; attempt < RETRY_ATTEMPTS; attempt += 1) {
+    if (attempt > 0) await sleep(RETRY_BACKOFF_MS[attempt - 1]);
+    const final = attempt === RETRY_ATTEMPTS - 1;
+    try {
+      const response = await fetchImpl(url, init);
+      if (response.status >= 500 && !final) continue;
+      return response;
+    } catch (cause) {
+      last = cause;
+      if (final) throw unreachable(host, cause);
+    }
+  }
+  throw unreachable(host, last);
+}
+
+// src/providers/base/diagnosis.ts
+var DIAGNOSIS_UNAVAILABLE = "diagnosis unavailable";
+var UNKNOWN = "unknown";
+function degradable(cause) {
+  return cause instanceof ApiError && cause.status !== 401;
+}
+function undiagnosed(mr, cause) {
+  return {
+    provider: mr.provider,
+    project: mr.project,
+    mr: mr.iid,
+    title: mr.title,
+    job: UNKNOWN,
+    stage: UNKNOWN,
+    url: mr.url,
+    errors: [`${DIAGNOSIS_UNAVAILABLE}: ${cause.message}`]
+  };
+}
 
 // src/trace/trace.constants.ts
 var ANSI = /\x1b\[[0-9;]*[a-zA-Z]/g;
@@ -414,11 +456,12 @@ var GitHubProvider = class {
     };
   }
   async send(url, init) {
-    try {
-      return await this.fetchImpl(url, { headers: this.headers(), ...init });
-    } catch (cause) {
-      throw unreachable(this.host, cause);
-    }
+    return await sendWithRetry(
+      this.fetchImpl,
+      url,
+      { headers: this.headers(), ...init },
+      this.host
+    );
   }
   async getJson(path, params) {
     const response = await this.send(buildUrl(this.api, path, params));
@@ -648,9 +691,17 @@ var GitHubProvider = class {
   }
   async getBlockers(mrs) {
     const red = mrs.filter((mr) => mr.pipeline === "failed");
-    const diagnosed = await Promise.all(red.map((mr) => this.diagnose(mr)));
+    const diagnosed = await Promise.all(red.map((mr) => this.tryDiagnose(mr)));
     return diagnosed.filter((row) => row !== null);
   }
+  async tryDiagnose(mr) {
+    try {
+      return await this.diagnose(mr);
+    } catch (cause) {
+      if (degradable(cause)) return undiagnosed(mr, cause);
+      throw cause;
+    }
+  }
 };
 
 // src/providers/gitlab/gitlab.constants.ts
@@ -671,14 +722,12 @@ var GitLabProvider = class {
     this.fetchImpl = fetchImpl;
   }
   async send(url) {
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        headers: { "PRIVATE-TOKEN": this.token }
-      });
-    } catch (cause) {
-      throw unreachable(this.host, cause);
-    }
+    const response = await sendWithRetry(
+      this.fetchImpl,
+      url,
+      { headers: { "PRIVATE-TOKEN": this.token } },
+      this.host
+    );
     assertUsable(response, this.host);
     return response;
   }
@@ -830,31 +879,36 @@ var GitLabProvider = class {
     );
     return rows.sort((a, b) => b.updated.localeCompare(a.updated));
   }
+  async diagnose(mr) {
+    const jobs = await this.getJson(
+      `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
+      { per_page: PAGE_SIZE2 }
+    ) ?? [];
+    const job = jobs.find((j) => j.status === "failed");
+    if (!job) return null;
+    const trace = await this.getText(`projects/${mr.projectId}/jobs/${job.id}/trace`);
+    return {
+      provider: "gitlab",
+      project: mr.project,
+      mr: mr.iid,
+      title: mr.title,
+      job: job.name,
+      stage: job.stage,
+      url: mr.url,
+      errors: extractErrors(trace)
+    };
+  }
+  async tryDiagnose(mr) {
+    try {
+      return await this.diagnose(mr);
+    } catch (cause) {
+      if (degradable(cause)) return undiagnosed(mr, cause);
+      throw cause;
+    }
+  }
   async getBlockers(mrs) {
     const red = mrs.filter((mr) => mr.pipeline === "failed");
-    const diagnosed = await Promise.all(
-      red.map(async (mr) => {
-        const jobs = await this.getJson(
-          `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
-          { per_page: PAGE_SIZE2 }
-        ) ?? [];
-        const job = jobs.find((j) => j.status === "failed");
-        if (!job) return null;
-        const trace = await this.getText(
-          `projects/${mr.projectId}/jobs/${job.id}/trace`
-        );
-        return {
-          provider: "gitlab",
-          project: mr.project,
-          mr: mr.iid,
-          title: mr.title,
-          job: job.name,
-          stage: job.stage,
-          url: mr.url,
-          errors: extractErrors(trace)
-        };
-      })
-    );
+    const diagnosed = await Promise.all(red.map((mr) => this.tryDiagnose(mr)));
     return diagnosed.filter((row) => row !== null);
   }
 };
@@ -1103,6 +1157,12 @@ export {
   ApiError,
   assertUsable,
   unreachable,
+  RETRY_ATTEMPTS,
+  RETRY_BACKOFF_MS,
+  sendWithRetry,
+  DIAGNOSIS_UNAVAILABLE,
+  degradable,
+  undiagnosed,
   extractErrors,
   repoFromUrl,
   mapEvent,

package/dist/cli.js

@@ -5,11 +5,12 @@ import {
   connect,
   postWebhook,
   toMarkdown
-} from "./chunk-DL2P3XR6.js";
+} from "./chunk-2X2XEEUY.js";
 
 // src/cli/cli.ts
-import { realpathSync } from "fs";
-import { pathToFileURL } from "url";
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { parseArgs } from "util";
 
 // src/cli/cli.constants.ts
@@ -19,13 +20,20 @@ Usage:
   standup fetch [--provider github|gitlab] [--host H] [--token T]
                 [--lang en|tr] [--markdown]
   standup post (--slack URL | --discord URL) [--text TEXT]
+  standup mcp
+  standup instructions
 
 The provider is taken from --provider, then STANDUP_PROVIDER, then whichever of
 GITHUB_* / GITLAB_* is set, then whichever of gh / glab is logged in.
 
 Credentials resolve as: flag, then GITHUB_HOST / GITHUB_TOKEN (or GITLAB_HOST /
 GITLAB_TOKEN), then the gh or glab config.
---text defaults to '-', meaning read stdin.`;
+--text defaults to '-', meaning read stdin.
+
+standup mcp starts the stdio MCP server, exposing get_standup_data.
+standup instructions prints the note-writing playbook (the standup skill body)
+to stdout, for teaching a non-Claude assistant the same rules, e.g.:
+  npx standup-mr instructions >> AGENTS.md`;
 
 // src/cli/cli.ts
 async function readStdin() {
@@ -33,6 +41,27 @@ async function readStdin() {
   for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
   return Buffer.concat(chunks).toString("utf8");
 }
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (!existsSync(join(dir, "package.json"))) {
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not locate package.json above ${startDir}`);
+    }
+    dir = parent;
+  }
+  return dir;
+}
+function readStandupSkillBody() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const skillPath = join(findPackageRoot(moduleDir), "skills", "standup", "SKILL.md");
+  if (!existsSync(skillPath)) {
+    throw new Error(`Cannot find the standup skill file at ${skillPath}`);
+  }
+  const content = readFileSync(skillPath, "utf8");
+  const withoutFrontmatter = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "");
+  return withoutFrontmatter.replace(/^\n+/, "");
+}
 async function main(argv) {
   const [command, ...rest] = argv;
   if (!command || command === "--help" || command === "-h") {
@@ -80,6 +109,18 @@ async function main(argv) {
       await postWebhook(url, text, values.slack ? "slack" : "discord");
       return 0;
     }
+    if (command === "mcp") {
+      const moduleDir = dirname(fileURLToPath(import.meta.url));
+      const serverPath = join(findPackageRoot(moduleDir), "dist", "mcp", "server.js");
+      const serverUrl = pathToFileURL(serverPath).href;
+      const { main: startMcpServer } = await import(serverUrl);
+      await startMcpServer();
+      return 0;
+    }
+    if (command === "instructions") {
+      process.stdout.write(readStandupSkillBody());
+      return 0;
+    }
     process.stderr.write(`Unknown command: ${command}
 
 ${USAGE}

package/dist/index.d.ts

@@ -142,10 +142,19 @@ interface Provider {
 
 declare function buildUrl(api: string, path: string, params?: Record<string, string | number>): string;
 declare class ApiError extends Error {
-    constructor(message: string);
+    readonly status?: number;
+    constructor(message: string, status?: number);
 }
 declare function assertUsable(response: Response, host: string): void;
 declare function unreachable(host: string, cause: unknown): ApiError;
+declare const RETRY_ATTEMPTS = 3;
+declare const RETRY_BACKOFF_MS: number[];
+type Sleep = (ms: number) => Promise<void>;
+declare function sendWithRetry(fetchImpl: FetchLike, url: string, init: RequestInit | undefined, host: string, sleep?: Sleep): Promise<Response>;
+
+declare const DIAGNOSIS_UNAVAILABLE = "diagnosis unavailable";
+declare function degradable(cause: unknown): cause is ApiError;
+declare function undiagnosed(mr: MergeRequest, cause: ApiError): Blocker;
 
 type Params$1 = Record<string, string | number>;
 declare class GitHubProvider implements Provider {
@@ -171,6 +180,7 @@ declare class GitHubProvider implements Provider {
     private checkRunBlocker;
     private diagnose;
     getBlockers(mrs: MergeRequest[]): Promise<Blocker[]>;
+    private tryDiagnose;
 }
 
 interface RawCommit {
@@ -247,6 +257,8 @@ declare class GitLabProvider implements Provider {
     getMyMrs(today: Date): Promise<MergeRequest[]>;
     private approvedByMe;
     getReviews(identity: Identity, today: Date): Promise<Review[]>;
+    private diagnose;
+    private tryDiagnose;
     getBlockers(mrs: MergeRequest[]): Promise<Blocker[]>;
 }
 
@@ -269,4 +281,4 @@ declare function buildReport(provider: Provider, today: Date, lang?: string, loo
 
 declare function extractErrors(rawTrace: string, limit?: number): string[];
 
-export { type ActiveDay, type ActivityEvent, ApiError, type Blocker, type Bucket, ConfigError, type FetchLike, GITHUB_LABELS, GITLAB_LABELS, GitHubProvider, GitLabProvider, type Identity, type MergeRequest, type Provider, type ProviderKind, type ProviderLabels, type Review, STALE_DAYS, type SelectOptions, type StandupReport, approvedBy, assertUsable, buildReport, buildUrl, chooseKind, classify, connect, countChangesRequested, extractErrors, ghHosts, ghToken, glabHosts, glabToken, isoDay, label, latestStateByReviewer, localAt, mapEvent, markMissingPipelines, normalizeChecks, parseGlabHosts, parseLoggedInHosts, postWebhook, previousActiveDays, repoFromUrl, resolveHost, resolveToken, toMarkdown, unreachable };
+export { type ActiveDay, type ActivityEvent, ApiError, type Blocker, type Bucket, ConfigError, DIAGNOSIS_UNAVAILABLE, type FetchLike, GITHUB_LABELS, GITLAB_LABELS, GitHubProvider, GitLabProvider, type Identity, type MergeRequest, type Provider, type ProviderKind, type ProviderLabels, RETRY_ATTEMPTS, RETRY_BACKOFF_MS, type Review, STALE_DAYS, type SelectOptions, type StandupReport, approvedBy, assertUsable, buildReport, buildUrl, chooseKind, classify, connect, countChangesRequested, degradable, extractErrors, ghHosts, ghToken, glabHosts, glabToken, isoDay, label, latestStateByReviewer, localAt, mapEvent, markMissingPipelines, normalizeChecks, parseGlabHosts, parseLoggedInHosts, postWebhook, previousActiveDays, repoFromUrl, resolveHost, resolveToken, sendWithRetry, toMarkdown, undiagnosed, unreachable };

package/dist/index.js

@@ -2,10 +2,13 @@
 import {
   ApiError,
   ConfigError,
+  DIAGNOSIS_UNAVAILABLE,
   GITHUB_LABELS,
   GITLAB_LABELS,
   GitHubProvider,
   GitLabProvider,
+  RETRY_ATTEMPTS,
+  RETRY_BACKOFF_MS,
   STALE_DAYS,
   approvedBy,
   assertUsable,
@@ -15,6 +18,7 @@ import {
   classify,
   connect,
   countChangesRequested,
+  degradable,
   extractErrors,
   ghHosts,
   ghToken,
@@ -34,16 +38,21 @@ import {
   repoFromUrl,
   resolveHost,
   resolveToken,
+  sendWithRetry,
   toMarkdown,
+  undiagnosed,
   unreachable
-} from "./chunk-DL2P3XR6.js";
+} from "./chunk-2X2XEEUY.js";
 export {
   ApiError,
   ConfigError,
+  DIAGNOSIS_UNAVAILABLE,
   GITHUB_LABELS,
   GITLAB_LABELS,
   GitHubProvider,
   GitLabProvider,
+  RETRY_ATTEMPTS,
+  RETRY_BACKOFF_MS,
   STALE_DAYS,
   approvedBy,
   assertUsable,
@@ -53,6 +62,7 @@ export {
   classify,
   connect,
   countChangesRequested,
+  degradable,
   extractErrors,
   ghHosts,
   ghToken,
@@ -72,6 +82,8 @@ export {
   repoFromUrl,
   resolveHost,
   resolveToken,
+  sendWithRetry,
   toMarkdown,
+  undiagnosed,
   unreachable
 };

package/dist/mcp/server.js

@@ -3,6 +3,8 @@
 // mcp/server.ts
 import { realpathSync } from "fs";
 import { pathToFileURL } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/config/config.ts
 import { execFileSync } from "child_process";
@@ -241,9 +243,11 @@ function buildUrl(api, path, params) {
   return `${base}?${query.toString()}`;
 }
 var ApiError = class extends Error {
-  constructor(message) {
+  status;
+  constructor(message, status) {
     super(message);
     this.name = "ApiError";
+    this.status = status;
   }
 };
 function remaining(response) {
@@ -267,27 +271,67 @@ function assertUsable(response, host) {
   if (response.ok || response.status === 404) return;
   if (response.status === 403 || response.status === 429) {
     if (remaining(response) === "0") {
-      throw new ApiError(`${host} rate limit reached${resetAt(response)}.`);
+      throw new ApiError(`${host} rate limit reached${resetAt(response)}.`, response.status);
     }
     const retry = retryAfter(response);
-    if (retry) throw new ApiError(`${host} rate limit reached${retry}.`);
+    if (retry) throw new ApiError(`${host} rate limit reached${retry}.`, response.status);
   }
   if (response.status === 401) {
     throw new ApiError(
-      `${host} rejected the token (401). Check the token and its scopes.`
+      `${host} rejected the token (401). Check the token and its scopes.`,
+      401
     );
   }
   if (response.status === 403) {
     throw new ApiError(
-      `${host} refused the request (403). The token has no access to that resource.`
+      `${host} refused the request (403). The token has no access to that resource.`,
+      403
     );
   }
-  throw new ApiError(`${host} returned ${response.status}.`);
+  throw new ApiError(`${host} returned ${response.status}.`, response.status);
 }
 function unreachable(host, cause) {
   const detail = cause instanceof Error ? cause.message : String(cause);
   return new ApiError(`Could not reach ${host}: ${detail}`);
 }
+var RETRY_ATTEMPTS = 3;
+var RETRY_BACKOFF_MS = [250, 750];
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function sendWithRetry(fetchImpl, url, init, host, sleep = wait) {
+  let last;
+  for (let attempt = 0; attempt < RETRY_ATTEMPTS; attempt += 1) {
+    if (attempt > 0) await sleep(RETRY_BACKOFF_MS[attempt - 1]);
+    const final = attempt === RETRY_ATTEMPTS - 1;
+    try {
+      const response = await fetchImpl(url, init);
+      if (response.status >= 500 && !final) continue;
+      return response;
+    } catch (cause) {
+      last = cause;
+      if (final) throw unreachable(host, cause);
+    }
+  }
+  throw unreachable(host, last);
+}
+
+// src/providers/base/diagnosis.ts
+var DIAGNOSIS_UNAVAILABLE = "diagnosis unavailable";
+var UNKNOWN = "unknown";
+function degradable(cause) {
+  return cause instanceof ApiError && cause.status !== 401;
+}
+function undiagnosed(mr, cause) {
+  return {
+    provider: mr.provider,
+    project: mr.project,
+    mr: mr.iid,
+    title: mr.title,
+    job: UNKNOWN,
+    stage: UNKNOWN,
+    url: mr.url,
+    errors: [`${DIAGNOSIS_UNAVAILABLE}: ${cause.message}`]
+  };
+}
 
 // src/providers/github/github.constants.ts
 var PAGE_SIZE = 100;
@@ -396,11 +440,12 @@ var GitHubProvider = class {
     };
   }
   async send(url, init) {
-    try {
-      return await this.fetchImpl(url, { headers: this.headers(), ...init });
-    } catch (cause) {
-      throw unreachable(this.host, cause);
-    }
+    return await sendWithRetry(
+      this.fetchImpl,
+      url,
+      { headers: this.headers(), ...init },
+      this.host
+    );
   }
   async getJson(path, params) {
     const response = await this.send(buildUrl(this.api, path, params));
@@ -630,9 +675,17 @@ var GitHubProvider = class {
   }
   async getBlockers(mrs) {
     const red = mrs.filter((mr) => mr.pipeline === "failed");
-    const diagnosed = await Promise.all(red.map((mr) => this.diagnose(mr)));
+    const diagnosed = await Promise.all(red.map((mr) => this.tryDiagnose(mr)));
     return diagnosed.filter((row) => row !== null);
   }
+  async tryDiagnose(mr) {
+    try {
+      return await this.diagnose(mr);
+    } catch (cause) {
+      if (degradable(cause)) return undiagnosed(mr, cause);
+      throw cause;
+    }
+  }
 };
 
 // src/providers/gitlab/gitlab.constants.ts
@@ -653,14 +706,12 @@ var GitLabProvider = class {
     this.fetchImpl = fetchImpl;
   }
   async send(url) {
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        headers: { "PRIVATE-TOKEN": this.token }
-      });
-    } catch (cause) {
-      throw unreachable(this.host, cause);
-    }
+    const response = await sendWithRetry(
+      this.fetchImpl,
+      url,
+      { headers: { "PRIVATE-TOKEN": this.token } },
+      this.host
+    );
     assertUsable(response, this.host);
     return response;
   }
@@ -812,31 +863,36 @@ var GitLabProvider = class {
     );
     return rows.sort((a, b) => b.updated.localeCompare(a.updated));
   }
+  async diagnose(mr) {
+    const jobs = await this.getJson(
+      `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
+      { per_page: PAGE_SIZE2 }
+    ) ?? [];
+    const job = jobs.find((j) => j.status === "failed");
+    if (!job) return null;
+    const trace = await this.getText(`projects/${mr.projectId}/jobs/${job.id}/trace`);
+    return {
+      provider: "gitlab",
+      project: mr.project,
+      mr: mr.iid,
+      title: mr.title,
+      job: job.name,
+      stage: job.stage,
+      url: mr.url,
+      errors: extractErrors(trace)
+    };
+  }
+  async tryDiagnose(mr) {
+    try {
+      return await this.diagnose(mr);
+    } catch (cause) {
+      if (degradable(cause)) return undiagnosed(mr, cause);
+      throw cause;
+    }
+  }
   async getBlockers(mrs) {
     const red = mrs.filter((mr) => mr.pipeline === "failed");
-    const diagnosed = await Promise.all(
-      red.map(async (mr) => {
-        const jobs = await this.getJson(
-          `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
-          { per_page: PAGE_SIZE2 }
-        ) ?? [];
-        const job = jobs.find((j) => j.status === "failed");
-        if (!job) return null;
-        const trace = await this.getText(
-          `projects/${mr.projectId}/jobs/${job.id}/trace`
-        );
-        return {
-          provider: "gitlab",
-          project: mr.project,
-          mr: mr.iid,
-          title: mr.title,
-          job: job.name,
-          stage: job.stage,
-          url: mr.url,
-          errors: extractErrors(trace)
-        };
-      })
-    );
+    const diagnosed = await Promise.all(red.map((mr) => this.tryDiagnose(mr)));
     return diagnosed.filter((row) => row !== null);
   }
 };
@@ -964,9 +1020,7 @@ async function collect(options = {}) {
   return buildReport(provider, /* @__PURE__ */ new Date(), options.lang ?? "en");
 }
 async function main() {
-  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
-  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const server = new McpServer({ name: "standup-mr", version: "0.2.1" });
+  const server = new McpServer({ name: "standup-mr", version: "0.3.0" });
   server.tool(
     "get_standup_data",
     "Collect merge-request-based standup data from GitLab or GitHub. Returns the previous working day activity, open merge requests or pull requests bucketed by state (ready / blocked / draft / stale), pending reviews, and the error lines from any failed pipeline or check.",
@@ -987,14 +1041,9 @@ try {
 }
 if (entryUrl && import.meta.url === entryUrl) {
   main().catch((error) => {
-    if (error instanceof Error && error.code === "ERR_MODULE_NOT_FOUND") {
-      process.stderr.write(
-        "standup-mr MCP server requires the optional dependency @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk\n"
-      );
-      process.exitCode = 1;
-      return;
-    }
-    throw error;
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
   });
 }
 export {

package/mcp/README.md

@@ -3,12 +3,6 @@
 Exposes one tool, `get_standup_data`, for either GitLab or GitHub, returning
 the same JSON as `standup fetch`.
 
-## Install
-
-```bash
-npm install standup-mr @modelcontextprotocol/sdk
-```
-
 ## Configure
 
 GitLab:
@@ -17,8 +11,8 @@ GitLab:
 {
   "mcpServers": {
     "standup": {
-      "command": "node",
-      "args": ["/absolute/path/to/standup-mr/dist/mcp/server.js"],
+      "command": "npx",
+      "args": ["-y", "standup-mr", "mcp"],
       "env": {
         "GITLAB_HOST": "gitlab.example.com",
         "GITLAB_TOKEN": "glpat-..."
@@ -30,6 +24,26 @@ GitLab:
 
 GitHub:
 
+```json
+{
+  "mcpServers": {
+    "standup": {
+      "command": "npx",
+      "args": ["-y", "standup-mr", "mcp"],
+      "env": {
+        "GITHUB_HOST": "github.com",
+        "GITHUB_TOKEN": "ghp_..."
+      }
+    }
+  }
+}
+```
+
+### Running from a clone
+
+If you're working from a local clone instead of the published package, point
+`command` at `node` and `args` at the absolute path to the built server:
+
 ```json
 {
   "mcpServers": {

package/package.json

@@ -1,6 +1,7 @@
 {
     "name": "standup-mr",
-    "version": "0.2.1",
+    "version": "0.3.1",
+    "mcpName": "io.github.Jubstaaa/standup-mr",
     "description": "Standup notes from merge request state, not commit logs.",
     "keywords": [
         "standup",
@@ -58,19 +59,13 @@
         "typecheck": "tsc --noEmit",
         "prepublishOnly": "tsup"
     },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+    },
     "devDependencies": {
-        "@modelcontextprotocol/sdk": "^1.0.0",
         "@types/bun": "^1.0.0",
         "@types/node": "^22.0.0",
         "tsup": "^8.0.0",
         "typescript": "^5.5.0"
-    },
-    "peerDependencies": {
-        "@modelcontextprotocol/sdk": "^1.0.0"
-    },
-    "peerDependenciesMeta": {
-        "@modelcontextprotocol/sdk": {
-            "optional": true
-        }
     }
 }

package/skills/standup/SKILL.md

@@ -19,22 +19,43 @@ Not a commit log — what finished, what is waiting, what is stuck.
 npx standup-mr fetch
 ```
 
-Prints one JSON document. The command picks GitLab or GitHub on its own — from
-flags, host, environment, or whichever of `gh`/`glab` is logged in. If the user
-already said which one they mean, pass it explicitly instead of guessing:
+Prints one JSON document. Nothing else needs running: the command resolves
+the host and token, works out which day to report on, and reads failed job
+logs itself.
+
+**Know the provider before the first call, don't discover it from a failure.**
+If the user has named GitHub or GitLab, or it is otherwise obvious from
+context, pass it on the very first invocation:
 
 ```bash
 npx standup-mr fetch --provider github
 npx standup-mr fetch --provider gitlab
 ```
 
-Add `--lang tr` for Turkish date labels. Nothing else needs running: the
-command resolves the host and token, works out which day to report on, and
-reads failed job logs itself.
-
-If the command exits non-zero, relay its stderr verbatim — do not invent a
-cause. The usual fix is `gh auth login` or `glab auth login`, depending on
-which provider it was trying to reach.
+If it is not known, do not guess. The command resolves it itself, in order:
+`--provider` → a recognisable `--host` → `STANDUP_PROVIDER` → the
+`GITHUB_*`/`GITLAB_*` env pair → whichever of `gh`/`glab` is logged in → an
+error naming what it found. On a machine where both `gh` and `glab` are
+authenticated, that resolution is ambiguous and the bare call fails with
+`Both gh and glab are authenticated. Pass --provider github or --provider
+gitlab.` — if you hit that, ask the user which one they mean rather than
+picking one silently, unless the conversation already makes it obvious, in
+which case pass that provider and say so in the note.
+
+If the command exits non-zero for any other reason, relay its stderr verbatim
+— do not invent a cause. The usual fix is `gh auth login` or `glab auth
+login`, depending on which provider it was trying to reach.
+
+**Pass `--lang` to match the language the user is speaking** — `--lang tr`
+for Turkish. It only affects the date labels inside the JSON (`"label":
+"Friday, 28 August"` → `"Cuma, 28 Ağustos"`); the prose of the note is always
+your own work, in the user's language, regardless of this flag. Passing it
+matters because the payload is otherwise ~1000 lines of English labels
+fighting a note you're trying to write in another language. Today `--lang`
+supports only `en` (default) and `tr` — any other value silently falls back
+to English labels. If the user speaks a language `--lang` doesn't cover,
+still write the note in their language; just leave the date labels in
+English rather than passing a value that won't take effect.
 
 ## 2. Shape of the JSON
 
@@ -57,8 +78,12 @@ under its own `label`, never merged into a single "yesterday".
 
 ## 3. Write the note
 
-Three sections: **Previous day · Today · Blockers**. Short, in the language the
-user is speaking, phrased the way they would say it out loud.
+**Write in the language the user is speaking, not the language of the JSON.**
+The payload's labels and field names are English regardless of `--lang`
+coverage — that is source data, not a cue for what language to write in.
+
+Three sections: **Previous day · Today · Blockers**. Short, phrased the way
+the user would say it out loud.
 
 ### Previous day