standup-mr 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,40 @@ 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.5.0] - 2026-09-02
+
+### Added
+
+- **`post_standup_note`** — posts a finished note to a Slack or Discord
+  webhook, so an MCP client can deliver the note it just wrote instead of
+  handing it back as text. The webhook URL comes from `STANDUP_WEBHOOK_URL`
+  and is never a tool argument: anyone holding that URL can post to the
+  channel, which makes it a credential. The payload shape is inferred from the
+  URL host, so `kind` is only needed when a proxy hides it. A missing URL, an
+  unrecognisable host, or a webhook that rejects the message is reported as an
+  error — a note is never announced as sent when it was not — and the error
+  text never repeats the URL.
+- **`get_note_instructions`** — returns the note-writing rules the Claude Code
+  skill carries, so a non-Claude assistant can write the note the same way
+  instead of inventing a format. Same content as `standup instructions`.
+
+Both were already in the CLI. Only the MCP server was missing them.
+
+## [0.4.1] - 2026-09-02
+
+### Changed
+
+- `get_standup_data` documents itself properly. The description now gives the
+  shape of the object it returns, says the tool is a snapshot rather than a
+  search API and what that rules out, and spells out failure behaviour: a
+  rejected token, a refused resource or a rate limit surfaces the host's own
+  message after two retries on transient errors, and a blocker whose
+  diagnosis could not be fetched still comes back with `job: "unknown"`. The
+  parameter descriptions gained the interactions the schema cannot express —
+  `host` is required for GitLab and optional for GitHub, a recognisable host
+  settles `provider` on its own, and `lang` relabels dates without
+  translating anything.
+
 ## [0.4.0] - 2026-09-01
 
 ### Added

package/README.md

@@ -1,6 +1,7 @@
 # standup-mr
 
 [![standup-mr MCP server](https://glama.ai/mcp/servers/Jubstaaa/standup-mr/badges/score.svg)](https://glama.ai/mcp/servers/Jubstaaa/standup-mr)
+[![Listed on mcpservers.org](https://mcpservers.org/badge.svg)](https://mcpservers.org/servers/jubstaaa/standup-mr)
 
 Standup notes from **merge request state**, not commit logs.
 
@@ -116,9 +117,20 @@ 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`):
+The server exposes three tools:
+
+| Tool | What it does |
+|---|---|
+| `get_standup_data` | Reads the provider and returns the report as JSON. Optional `provider`, `host`, `lang`. |
+| `get_note_instructions` | Returns the note-writing rules, so the assistant can write the note the way the skill would. |
+| `post_standup_note` | Posts a finished note to a Slack or Discord webhook. |
+
+`post_standup_note` reads the webhook URL from `STANDUP_WEBHOOK_URL` and never
+takes it as an argument — anyone holding that URL can post to the channel, so
+it belongs with the tokens, not in a transcript. The payload shape is inferred
+from the URL host; `kind` is only needed when a proxy hides it.
+
+Outside MCP, the same rules are available on stdout:
 
 ```bash
 npx standup-mr instructions >> AGENTS.md

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

@@ -206,6 +206,20 @@ async function postWebhook(url, text, kind = "slack", fetchImpl = fetch) {
     throw new Error(`Webhook rejected the message: HTTP ${response.status}.`);
   }
 }
+var WEBHOOK_HOSTS = {
+  "hooks.slack.com": "slack",
+  "discord.com": "discord",
+  "discordapp.com": "discord",
+  "ptb.discord.com": "discord",
+  "canary.discord.com": "discord"
+};
+function inferWebhookKind(url) {
+  try {
+    return WEBHOOK_HOSTS[new URL(url).hostname] ?? null;
+  } catch {
+    return null;
+  }
+}
 
 // src/providers/base/http.ts
 function buildUrl(api, path, params) {
@@ -1133,6 +1147,37 @@ async function buildReport(provider, today, lang = "en", lookbackDays = LOOKBACK
   };
 }
 
+// src/manifest/manifest.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+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;
+}
+
+// src/skill/skill.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function readStandupSkillBody() {
+  const moduleDir = dirname2(fileURLToPath2(import.meta.url));
+  const skillPath = join2(findPackageRoot(moduleDir), "skills", "standup", "SKILL.md");
+  if (!existsSync2(skillPath)) {
+    throw new Error(`Cannot find the standup skill file at ${skillPath}`);
+  }
+  const content = readFileSync2(skillPath, "utf8");
+  const withoutFrontmatter = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "");
+  return withoutFrontmatter.replace(/^\n+/, "");
+}
+
 export {
   STALE_DAYS,
   isoDay,
@@ -1153,6 +1198,7 @@ export {
   ghHosts,
   ghToken,
   postWebhook,
+  inferWebhookKind,
   buildUrl,
   ApiError,
   assertUsable,
@@ -1175,5 +1221,7 @@ export {
   chooseKind,
   connect,
   toMarkdown,
-  buildReport
+  buildReport,
+  findPackageRoot,
+  readStandupSkillBody
 };

package/dist/cli.js

@@ -3,14 +3,16 @@ import {
   ConfigError,
   buildReport,
   connect,
+  findPackageRoot,
   postWebhook,
+  readStandupSkillBody,
   toMarkdown
-} from "./chunk-2X2XEEUY.js";
+} from "./chunk-S2PFIUNI.js";
 
 // src/cli/cli.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import { realpathSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { parseArgs } from "util";
 
 // src/cli/cli.constants.ts
@@ -30,43 +32,18 @@ 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.
 
-standup mcp starts the stdio MCP server, exposing get_standup_data.
+standup mcp starts the stdio MCP server, exposing get_standup_data,
+  post_standup_note and get_note_instructions.
 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/manifest/manifest.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-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;
-}
-
 // src/cli/cli.ts
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
   return Buffer.concat(chunks).toString("utf8");
 }
-function readStandupSkillBody() {
-  const moduleDir = dirname2(fileURLToPath2(import.meta.url));
-  const skillPath = join2(findPackageRoot(moduleDir), "skills", "standup", "SKILL.md");
-  if (!existsSync2(skillPath)) {
-    throw new Error(`Cannot find the standup skill file at ${skillPath}`);
-  }
-  const content = readFileSync2(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") {
@@ -115,8 +92,8 @@ async function main(argv) {
       return 0;
     }
     if (command === "mcp") {
-      const moduleDir = dirname2(fileURLToPath2(import.meta.url));
-      const serverPath = join2(findPackageRoot(moduleDir), "dist", "mcp", "server.js");
+      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();

package/dist/index.d.ts

@@ -130,6 +130,7 @@ declare const PAYLOAD_FIELD: {
 type WebhookKind = keyof typeof PAYLOAD_FIELD;
 
 declare function postWebhook(url: string, text: string, kind?: WebhookKind, fetchImpl?: FetchLike): Promise<void>;
+declare function inferWebhookKind(url: string): WebhookKind | null;
 
 interface Provider {
     readonly kind: ProviderKind;
@@ -279,6 +280,8 @@ declare function toMarkdown(report: StandupReport, lang?: string): string;
 
 declare function buildReport(provider: Provider, today: Date, lang?: string, lookbackDays?: number): Promise<StandupReport>;
 
+declare function readStandupSkillBody(): string;
+
 declare function extractErrors(rawTrace: string, limit?: number): string[];
 
-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 };
+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, inferWebhookKind, isoDay, label, latestStateByReviewer, localAt, mapEvent, markMissingPipelines, normalizeChecks, parseGlabHosts, parseLoggedInHosts, postWebhook, previousActiveDays, readStandupSkillBody, repoFromUrl, resolveHost, resolveToken, sendWithRetry, toMarkdown, undiagnosed, unreachable };

package/dist/index.js

@@ -24,6 +24,7 @@ import {
   ghToken,
   glabHosts,
   glabToken,
+  inferWebhookKind,
   isoDay,
   label,
   latestStateByReviewer,
@@ -35,6 +36,7 @@ import {
   parseLoggedInHosts,
   postWebhook,
   previousActiveDays,
+  readStandupSkillBody,
   repoFromUrl,
   resolveHost,
   resolveToken,
@@ -42,7 +44,7 @@ import {
   toMarkdown,
   undiagnosed,
   unreachable
-} from "./chunk-2X2XEEUY.js";
+} from "./chunk-S2PFIUNI.js";
 export {
   ApiError,
   ConfigError,
@@ -68,6 +70,7 @@ export {
   ghToken,
   glabHosts,
   glabToken,
+  inferWebhookKind,
   isoDay,
   label,
   latestStateByReviewer,
@@ -79,6 +82,7 @@ export {
   parseLoggedInHosts,
   postWebhook,
   previousActiveDays,
+  readStandupSkillBody,
   repoFromUrl,
   resolveHost,
   resolveToken,

package/dist/mcp/server.js

@@ -31,6 +31,41 @@ function packageVersion(moduleUrl) {
   return manifest.version;
 }
 
+// src/notify/notify.constants.ts
+var PAYLOAD_FIELD = { slack: "text", discord: "content" };
+
+// src/notify/notify.ts
+async function postWebhook(url, text2, kind = "slack", fetchImpl = fetch) {
+  const field = PAYLOAD_FIELD[kind];
+  if (!field) {
+    throw new Error(
+      `Unknown webhook kind "${kind}". Use one of: ${Object.keys(PAYLOAD_FIELD).join(", ")}.`
+    );
+  }
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ [field]: text2 })
+  });
+  if (!response.ok) {
+    throw new Error(`Webhook rejected the message: HTTP ${response.status}.`);
+  }
+}
+var WEBHOOK_HOSTS = {
+  "hooks.slack.com": "slack",
+  "discord.com": "discord",
+  "discordapp.com": "discord",
+  "ptb.discord.com": "discord",
+  "canary.discord.com": "discord"
+};
+function inferWebhookKind(url) {
+  try {
+    return WEBHOOK_HOSTS[new URL(url).hostname] ?? null;
+  } catch {
+    return null;
+  }
+}
+
 // src/config/config.ts
 import { execFileSync } from "child_process";
 
@@ -1002,6 +1037,21 @@ function connect(options = {}) {
   return new GitLabProvider(host, token);
 }
 
+// src/skill/skill.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function readStandupSkillBody() {
+  const moduleDir = dirname2(fileURLToPath2(import.meta.url));
+  const skillPath = join2(findPackageRoot(moduleDir), "skills", "standup", "SKILL.md");
+  if (!existsSync2(skillPath)) {
+    throw new Error(`Cannot find the standup skill file at ${skillPath}`);
+  }
+  const content = readFileSync2(skillPath, "utf8");
+  const withoutFrontmatter = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "");
+  return withoutFrontmatter.replace(/^\n+/, "");
+}
+
 // src/report/report.constants.ts
 var LOOKBACK_DAYS = 21;
 
@@ -1044,15 +1094,16 @@ async function collect(options = {}) {
   const provider = options.providerImpl ?? connect({ provider: options.provider, host: options.host, token: options.token });
   return buildReport(provider, /* @__PURE__ */ new Date(), options.lang ?? "en");
 }
+var STANDUP_TOOL_DESCRIPTION = 'Collect merge-request-based standup data from GitLab or GitHub. Returns one JSON object: `today`, `previousDays[]` with the events of each, `todayEvents[]`, `myMrs[]` bucketed ready / blocked / draft / stale, `reviews[]` waiting on you, and `blockers[]` carrying the error lines read out of each failed pipeline job log.\n\nCall it once at the start of a working day, to write a standup note. It is a snapshot, not a search API: it cannot fetch one named merge request, reach further back than the previous working day, or filter by project.\n\nRead-only, and credentials never come from an argument \u2014 they come from the environment or a logged-in gh / glab session. A rejected token, a refused resource or a rate limit fails the call with the host\'s own message, after two retries on transient server errors. A blocker whose diagnosis could not be fetched is still returned, with `job: "unknown"`, so a red pipeline is never silently dropped.';
 var STANDUP_TOOL_SCHEMA = {
   provider: z.enum(["github", "gitlab"]).optional().describe(
-    "Which provider to read. Omit to auto-detect, in this order: a recognisable host, STANDUP_PROVIDER, a GITHUB_*/GITLAB_* environment pair, then whichever of the gh / glab CLIs is logged in."
+    "Which provider to read. Omit to auto-detect, in this order: a recognisable host, STANDUP_PROVIDER, a GITHUB_*/GITLAB_* environment pair, then whichever of the gh / glab CLIs is logged in. Pass it when both are configured \u2014 ambiguity fails the call rather than being guessed at."
   ),
   host: z.string().optional().describe(
-    "Self-hosted host, without a scheme, e.g. gitlab.example.com or github.example.com. GitHub defaults to github.com; GitLab has no default, so self-hosted GitLab needs this or GITLAB_HOST."
+    "Self-hosted host, without a scheme, e.g. gitlab.example.com or github.example.com. Required for GitLab, which has no default host; optional for GitHub, which defaults to github.com. A recognisable host also settles `provider` on its own, so the two are rarely both needed."
   ),
   lang: z.enum(["en", "tr"]).optional().describe(
-    "Language for the date labels inside the returned JSON. Defaults to en. Only the labels change \u2014 the standup note itself is written by the caller."
+    "Language for the date labels inside the returned JSON: en (default) or tr. It relabels dates and nothing else \u2014 no field is translated, and the standup note itself is written by the caller, in whatever language they are speaking."
   )
 };
 async function runStandupTool(args, collector = collect) {
@@ -1063,14 +1114,71 @@ async function runStandupTool(args, collector = collect) {
   });
   return { content: [{ type: "text", text: JSON.stringify(report) }] };
 }
+var WEBHOOK_URL_ENV = "STANDUP_WEBHOOK_URL";
+var POST_TOOL_DESCRIPTION = `Posts a finished standup note to a chat webhook. This one has a side effect: it sends a message other people will see, so only call it on a note the user has agreed to send.
+
+The webhook URL is read from ${WEBHOOK_URL_ENV}, never from an argument \u2014 a webhook URL is a credential, since anyone holding it can post to the channel. Slack and Discord payload shapes are supported; the shape is inferred from the URL host, and \`kind\` is only needed for a proxied or self-hosted endpoint whose host gives nothing away. A missing URL, an unrecognised host, or a webhook that rejects the message comes back as an error rather than a silent success.`;
+var POST_TOOL_SCHEMA = {
+  text: z.string().min(1).describe(
+    "The note to post, as the chat should render it. Slack and Discord both take Markdown, so send the written note rather than the raw JSON from get_standup_data."
+  ),
+  kind: z.enum(["slack", "discord"]).optional().describe(
+    'Which payload shape to send: slack posts {"text"}, discord posts {"content"}. Omit it \u2014 the shape is inferred from the webhook host. Pass it only when the host is not recognisable, e.g. a proxy in front of the real webhook.'
+  )
+};
+var INSTRUCTIONS_TOOL_DESCRIPTION = "Returns the note-writing rules \u2014 the playbook for turning get_standup_data output into a standup note a person would actually say out loud: how to group the previous day by theme, how to derive today from open merge requests, and how to report a blocker from its job log. Read-only, no arguments, no network. Call it once before writing the first note; the rules do not change between calls.";
+function text(body) {
+  return { content: [{ type: "text", text: body }] };
+}
+function failure(body) {
+  return { content: [{ type: "text", text: body }], isError: true };
+}
+async function runPostTool(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const post = deps.post ?? postWebhook;
+  const url = env[WEBHOOK_URL_ENV];
+  if (!url) {
+    return failure(
+      `No webhook configured. Set ${WEBHOOK_URL_ENV} to the Slack or Discord webhook URL; it is deliberately not accepted as a tool argument.`
+    );
+  }
+  const kind = args.kind ?? inferWebhookKind(url);
+  if (!kind) {
+    return failure(
+      `Could not tell from the ${WEBHOOK_URL_ENV} host whether this is a Slack or a Discord webhook. Pass kind explicitly.`
+    );
+  }
+  try {
+    await post(url, args.text, kind);
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    return failure(`The ${kind} webhook did not accept the note: ${detail}`);
+  }
+  return text(`Posted the note to the configured ${kind} webhook.`);
+}
+async function runInstructionsTool() {
+  return text(readStandupSkillBody());
+}
 async function main() {
   const server = new McpServer({ name: "standup-mr", version: packageVersion(import.meta.url) });
   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. Credentials come from the environment or a logged-in gh / glab session, never from an argument.",
+    STANDUP_TOOL_DESCRIPTION,
     STANDUP_TOOL_SCHEMA,
     async (args) => await runStandupTool(args)
   );
+  server.tool(
+    "post_standup_note",
+    POST_TOOL_DESCRIPTION,
+    POST_TOOL_SCHEMA,
+    async (args) => await runPostTool(args)
+  );
+  server.tool(
+    "get_note_instructions",
+    INSTRUCTIONS_TOOL_DESCRIPTION,
+    {},
+    async () => await runInstructionsTool()
+  );
   await server.connect(new StdioServerTransport());
 }
 var entry = process.argv[1];
@@ -1088,8 +1196,15 @@ if (entryUrl && import.meta.url === entryUrl) {
   });
 }
 export {
+  INSTRUCTIONS_TOOL_DESCRIPTION,
+  POST_TOOL_DESCRIPTION,
+  POST_TOOL_SCHEMA,
+  STANDUP_TOOL_DESCRIPTION,
   STANDUP_TOOL_SCHEMA,
+  WEBHOOK_URL_ENV,
   collect,
   main,
+  runInstructionsTool,
+  runPostTool,
   runStandupTool
 };

package/llms-install.md

@@ -0,0 +1,79 @@
+# Installing standup-mr
+
+Instructions for an AI assistant setting this MCP server up on a user's
+machine. Everything here is verified against the published package.
+
+## What it needs
+
+- Node.js 20 or newer. Nothing to clone, nothing to build — the server runs
+  straight from npm.
+- Read access to the user's GitLab or GitHub. It never takes a credential as
+  a tool argument; credentials come from the environment or from a logged-in
+  `gh` / `glab` session.
+
+## Config
+
+Add this to the MCP settings file (for Cline,
+`cline_mcp_settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "standup": {
+      "command": "npx",
+      "args": ["-y", "standup-mr", "mcp"],
+      "env": {}
+    }
+  }
+}
+```
+
+That is the whole install when the user already has `gh` or `glab` logged in
+— leave `env` empty and the server picks the session up.
+
+## Credentials, when there is no CLI session
+
+Add only the pair the user actually needs.
+
+| Variable | When |
+|---|---|
+| `GITHUB_TOKEN` | GitHub, no `gh` session |
+| `GITHUB_HOST` | GitHub Enterprise only; defaults to `github.com` |
+| `GITLAB_TOKEN` | GitLab, no `glab` session |
+| `GITLAB_HOST` | **Required for GitLab** — there is no default host |
+| `STANDUP_PROVIDER` | `github` or `gitlab`, when both are configured and the choice is ambiguous |
+
+Ask the user for a token; do not invent one, and do not put a token anywhere
+but `env`.
+
+## The one tool
+
+`get_standup_data` returns the previous working day's activity, open merge
+requests bucketed by state (ready / blocked / draft / stale), pending
+reviews, and the error lines from any failed pipeline job. All three
+arguments are optional:
+
+- `provider` — `github` or `gitlab`; omit to auto-detect
+- `host` — self-hosted host, no scheme
+- `lang` — `en` or `tr`; changes date labels in the JSON only
+
+## Verifying the install
+
+```bash
+npx -y standup-mr mcp
+```
+
+It speaks MCP over stdio and writes nothing else to stdout. A successful
+`initialize` reports `{"name":"standup-mr","version":"<current>"}`.
+
+If the user is not on an MCP client, `npx standup-mr fetch --markdown`
+prints the same data as a digest.
+
+## Writing the note
+
+The tool returns data, not prose. The note-writing rules live in the bundled
+skill; pour them into whatever instructions file the assistant reads:
+
+```bash
+npx standup-mr instructions >> AGENTS.md
+```

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "standup-mr",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "mcpName": "io.github.Jubstaaa/standup-mr",
     "description": "Standup notes from merge request state, not commit logs.",
     "keywords": [
@@ -48,6 +48,7 @@
         "dist",
         "skills",
         "mcp/README.md",
+        "llms-install.md",
         "README.md",
         "CHANGELOG.md",
         "LICENSE"