@jam-mcp/server 1.0.0

package/dist/config/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * `.jira-agent/project.yaml` - per-project policy only.
+ * Credentials are never stored here; they come from the CredentialPort.
+ */
+export declare const ProjectConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    project: z.ZodPrefault<z.ZodObject<{
+        key: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    search: z.ZodPrefault<z.ZodObject<{
+        pageSize: z.ZodDefault<z.ZodNumber>;
+        maxPages: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    fields: z.ZodPrefault<z.ZodObject<{
+        lite: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        context: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    customFields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+    output: z.ZodPrefault<z.ZodObject<{
+        searchTokens: z.ZodDefault<z.ZodNumber>;
+        contextTokens: z.ZodDefault<z.ZodNumber>;
+        fullTokens: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    policy: z.ZodPrefault<z.ZodObject<{
+        contextRequiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        fullRequiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    telemetry: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;

package/dist/config/schema.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+/**
+ * `.jira-agent/project.yaml` - per-project policy only.
+ * Credentials are never stored here; they come from the CredentialPort.
+ */
+export const ProjectConfigSchema = z.object({
+    version: z.literal(1).default(1),
+    /**
+     * Empty key is allowed so `jam serve` still boots without a project.yaml;
+     * `jam doctor` is what flags it as unconfigured.
+     */
+    project: z
+        .object({
+        key: z.string().default(""),
+    })
+        .prefault({}),
+    search: z
+        .object({
+        /** Page size sent to Jira. Not the total result count. */
+        pageSize: z.number().int().min(1).max(100).default(50),
+        /** Safety stop for `scope: "complete"`. Hitting it is reported, never silent. */
+        maxPages: z.number().int().min(1).max(200).default(20),
+    })
+        .prefault({}),
+    fields: z
+        .object({
+        lite: z.array(z.string()).default([
+            "summary",
+            "status",
+            "assignee",
+            "priority",
+            "updated",
+            "labels",
+            "components",
+        ]),
+        context: z
+            .array(z.string())
+            .default(["parent", "subtasks", "issuelinks", "issuetype"]),
+    })
+        .prefault({}),
+    /**
+     * Whitelisted project-specific custom fields, surfaced at CONTEXT level and up.
+     * `id` is the Jira field id (customfield_10011); `name` is what the agent sees.
+     */
+    customFields: z
+        .array(z.object({
+        id: z.string().regex(/^customfield_\d+$/),
+        name: z.string().min(1),
+    }))
+        .default([]),
+    output: z
+        .object({
+        /** Rough token ceilings per level. Enforced by OutputBudgetPolicy. */
+        searchTokens: z.number().int().min(200).default(2000),
+        contextTokens: z.number().int().min(200).default(5000),
+        fullTokens: z.number().int().min(200).default(8000),
+    })
+        .prefault({}),
+    policy: z
+        .object({
+        contextRequiredFor: z
+            .array(z.string())
+            .default(["readiness", "dependency", "blocker", "priority"]),
+        fullRequiredFor: z
+            .array(z.string())
+            .default(["agreement", "contract", "approval", "closure"]),
+    })
+        .prefault({}),
+    telemetry: z
+        .object({
+        enabled: z.boolean().default(true),
+    })
+        .prefault({}),
+});

package/dist/deps.d.ts

@@ -0,0 +1,50 @@
+import type { BootstrapSource } from "./bootstrap/project-config-bootstrapper.js";
+import type { GitRemoteFn } from "./bootstrap/workspace-identity.js";
+import type { ProjectConfig } from "./config/schema.js";
+import type { CachePort } from "./ports/cache.port.js";
+import type { CredentialPort } from "./ports/credentials.port.js";
+import type { JiraReadPort } from "./ports/jira-read.port.js";
+import type { TelemetryPort } from "./ports/telemetry.port.js";
+/** Everything the application layer is allowed to reach for. */
+export type JamDeps = {
+    config: ProjectConfig;
+    configPath?: string;
+    /** Where the project key came from when no config file supplied one. */
+    keySource?: BootstrapSource;
+    jira: JiraReadPort;
+    cache: CachePort;
+    telemetry: TelemetryPort;
+    credentials: CredentialPort;
+};
+export type BuildDepsOptions = {
+    cwd?: string;
+    /** Injected by tests to bypass the real REST adapter. */
+    jira?: JiraReadPort;
+    /** Injected by tests to bypass the real process/registry credential lookup. */
+    credentials?: CredentialPort;
+    /**
+     * Whether an explicit key (flag, env, personal binding, preset) may stand in
+     * when the project has no config file, and whether its absence is fatal.
+     * Nothing is written either way - see resolveProjectConfig.
+     */
+    keyFallback?: "required" | "optional";
+    /** `--project` override, passed through from `jam setup`. */
+    explicitKey?: string;
+    /** Injected by tests so a decision never depends on the machine's environment. */
+    env?: NodeJS.ProcessEnv;
+    /** Injected by tests so a decision never reads the developer's own presets. */
+    presetsPath?: string;
+    /** Injected by tests to isolate `~/.jam`. */
+    home?: string;
+    /** Injected by tests so identity never depends on the checkout under test. */
+    git?: GitRemoteFn;
+};
+/**
+ * Single composition root. `jam serve`, `jam doctor` and `jam setup` all wire
+ * through here, so a doctor pass actually proves the server's configuration.
+ *
+ * Credentials come from `CompositeCredentialProvider`: the current process's
+ * own environment first, then the Windows User environment as a fallback for
+ * shells that predate a `setx`.
+ */
+export declare function buildDeps(options?: BuildDepsOptions): Promise<JamDeps>;

package/dist/deps.js

@@ -0,0 +1,39 @@
+import { NoopCache } from "./adapters/cache/noop-cache.js";
+import { CompositeCredentialProvider } from "./adapters/credentials/composite.js";
+import { ConsoleTelemetry } from "./adapters/telemetry/console-telemetry.js";
+import { resolveProjectConfig } from "./bootstrap/project-config-resolver.js";
+/**
+ * Single composition root. `jam serve`, `jam doctor` and `jam setup` all wire
+ * through here, so a doctor pass actually proves the server's configuration.
+ *
+ * Credentials come from `CompositeCredentialProvider`: the current process's
+ * own environment first, then the Windows User environment as a fallback for
+ * shells that predate a `setx`.
+ */
+export async function buildDeps(options = {}) {
+    const resolved = resolveProjectConfig({
+        cwd: options.cwd,
+        ...(options.keyFallback ? { keyFallback: options.keyFallback } : {}),
+        explicitKey: options.explicitKey,
+        ...(options.env ? { env: options.env } : {}),
+        ...(options.presetsPath ? { presetsPath: options.presetsPath } : {}),
+        ...(options.home ? { home: options.home } : {}),
+        ...(options.git ? { git: options.git } : {}),
+    });
+    const credentials = options.credentials ?? new CompositeCredentialProvider();
+    const telemetry = new ConsoleTelemetry(resolved.config.telemetry.enabled);
+    let jira = options.jira;
+    if (!jira) {
+        const { JiraCloudReadAdapter } = await import("./adapters/jira-cloud/jira-read.adapter.js");
+        jira = new JiraCloudReadAdapter(credentials, resolved.config);
+    }
+    return {
+        config: resolved.config,
+        configPath: resolved.configPath,
+        keySource: resolved.keySource,
+        jira,
+        cache: new NoopCache(),
+        telemetry,
+        credentials,
+    };
+}

package/dist/domain/completeness.d.ts

@@ -0,0 +1,63 @@
+export type ContextLevel = "search" | "context" | "full";
+export type IncompleteReason = "OUTPUT_BUDGET" | "PERMISSION" | "PARTIAL_API_RESPONSE" | "UNKNOWN";
+/**
+ * What JAM did not look at.
+ *
+ * Stable codes, never prose: a consumer has to branch on these, and a
+ * sentence that gets reworded silently breaks whoever was matching on it.
+ * Every JAM result carries all of them today, because JAM reads Jira and
+ * nothing else - they exist so that fact is in the payload rather than only
+ * in a tool description nobody re-reads.
+ */
+export type EvidenceLimitation = "REPOSITORY_NOT_EVALUATED" | "EXTERNAL_SOURCES_NOT_EVALUATED" | "NON_JIRA_DEPENDENCIES_NOT_EVALUATED";
+/**
+ * Attached to every tool result so the agent can tell a full picture from a
+ * partial one. Silent truncation is prohibited: anything dropped must show up
+ * here with `complete: false` and a reason.
+ *
+ * `complete` is about retrieval and nothing else: JAM finished the Jira read
+ * it was asked for with no known loss. It is not a claim that Jira holds the
+ * whole story, that the repository agrees, or that the work can start - which
+ * is what `evidenceScope` and `limitations` are here to say out loud.
+ */
+export type CompletenessMeta = {
+    level: ContextLevel;
+    complete: boolean;
+    /** Where this came from. One system today, stated rather than assumed. */
+    source: "jira";
+    /**
+     * Whether Jira itself answered this read, or a cache did. On a cache hit
+     * `fetchedAt` keeps the time Jira was read - it must never be rewritten to
+     * the time the cache answered, or a stale record would look fresh.
+     */
+    provenance: "live" | "cache";
+    /** What kind of evidence this is. Jira records - not project reality. */
+    evidenceScope: "jira-records-only";
+    limitations: EvidenceLimitation[];
+    /** When this snapshot was read from Jira. */
+    fetchedAt: string;
+    pagesFetched?: number;
+    fieldsLoaded?: string[];
+    commentsComplete?: boolean;
+    linksComplete?: boolean;
+    reason?: IncompleteReason;
+    /** Which part of the payload was dropped or could not be read. */
+    overflow?: string[];
+    /** Issue keys the request asked for but could not be returned. */
+    missingKeys?: string[];
+    notes?: string[];
+};
+/**
+ * The evidence boundary every JAM result carries.
+ *
+ * One constant rather than three copies: the day JAM reads something that is
+ * not Jira, or serves a read from cache, exactly one of these has to change
+ * and the three tools cannot drift apart in the meantime.
+ */
+export declare const JIRA_EVIDENCE: {
+    readonly source: "jira";
+    readonly provenance: "live";
+    readonly evidenceScope: "jira-records-only";
+    readonly limitations: ["REPOSITORY_NOT_EVALUATED", "EXTERNAL_SOURCES_NOT_EVALUATED", "NON_JIRA_DEPENDENCIES_NOT_EVALUATED"];
+};
+export declare function nowIso(): string;

package/dist/domain/completeness.js

@@ -0,0 +1,20 @@
+/**
+ * The evidence boundary every JAM result carries.
+ *
+ * One constant rather than three copies: the day JAM reads something that is
+ * not Jira, or serves a read from cache, exactly one of these has to change
+ * and the three tools cannot drift apart in the meantime.
+ */
+export const JIRA_EVIDENCE = {
+    source: "jira",
+    provenance: "live",
+    evidenceScope: "jira-records-only",
+    limitations: [
+        "REPOSITORY_NOT_EVALUATED",
+        "EXTERNAL_SOURCES_NOT_EVALUATED",
+        "NON_JIRA_DEPENDENCIES_NOT_EVALUATED",
+    ],
+};
+export function nowIso() {
+    return new Date().toISOString();
+}

package/dist/domain/context.d.ts

@@ -0,0 +1,38 @@
+import type { IssueLink, IssueRef, IssueSummary } from "./issue.js";
+/** CONTEXT level: enough to judge readiness, blockers, dependencies, priority. */
+export type IssueContext = IssueSummary & {
+    issueType?: string;
+    parent?: IssueRef;
+    subtasks: IssueRef[];
+    links: IssueLink[];
+    customFields: Record<string, unknown>;
+};
+export type NormalizedComment = {
+    id: string;
+    author?: string;
+    created: string;
+    updated?: string;
+    body: string;
+};
+export type RelevantHistory = {
+    created: string;
+    author?: string;
+    field: string;
+    from?: string;
+    to?: string;
+};
+/** FULL level: the Jira record for agreement, contract, approval, closure. */
+export type FullIssueContext = IssueContext & {
+    description?: string;
+    comments: NormalizedComment[];
+    history?: RelevantHistory[];
+    /**
+     * The most recent timestamp on any comment retrieved, edits included.
+     *
+     * A raw fact, not a verdict: how old is too old differs per team, so JAM
+     * reports when the thread last moved and leaves "stale" to the caller.
+     * Costs no extra Jira call - it is computed from comments already fetched,
+     * and is therefore as complete as `commentsComplete` says they are.
+     */
+    latestCommentAt?: string;
+};

package/dist/domain/context.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/errors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Normalized error model.
+ *
+ * Jira raw errors never reach the agent. Everything crossing the tool boundary
+ * is mapped onto one of these codes so the agent (and `jam doctor`) can reason
+ * about failures without parsing vendor-specific payloads.
+ */
+export declare const JAM_ERROR_CODES: readonly ["JIRA_AUTH_FAILED", "JIRA_PERMISSION_DENIED", "JQL_INVALID", "ISSUE_NOT_FOUND", "RATE_LIMITED", "CONTEXT_TOO_LARGE", "PARTIAL_RESULT", "CONFIG_INVALID", "JIRA_UNAVAILABLE", "JAM_SETUP_REQUIRED", "JAM_BINDINGS_UNREADABLE"];
+export type JamErrorCode = (typeof JAM_ERROR_CODES)[number];
+export type JamErrorPayload = {
+    error: {
+        code: JamErrorCode;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+};
+export declare class JamError extends Error {
+    readonly code: JamErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(code: JamErrorCode, message: string, details?: Record<string, unknown>);
+    toPayload(): JamErrorPayload;
+}
+/**
+ * Coerce anything thrown into a JamError. Unknown failures become
+ * JIRA_UNAVAILABLE rather than leaking a raw stack trace to the agent.
+ */
+export declare function toJamError(err: unknown): JamError;

package/dist/domain/errors.js

@@ -0,0 +1,49 @@
+/**
+ * Normalized error model.
+ *
+ * Jira raw errors never reach the agent. Everything crossing the tool boundary
+ * is mapped onto one of these codes so the agent (and `jam doctor`) can reason
+ * about failures without parsing vendor-specific payloads.
+ */
+export const JAM_ERROR_CODES = [
+    "JIRA_AUTH_FAILED",
+    "JIRA_PERMISSION_DENIED",
+    "JQL_INVALID",
+    "ISSUE_NOT_FOUND",
+    "RATE_LIMITED",
+    "CONTEXT_TOO_LARGE",
+    "PARTIAL_RESULT",
+    "CONFIG_INVALID",
+    "JIRA_UNAVAILABLE",
+    "JAM_SETUP_REQUIRED",
+    "JAM_BINDINGS_UNREADABLE",
+];
+export class JamError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "JamError";
+        this.code = code;
+        this.details = details;
+    }
+    toPayload() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                ...(this.details ? { details: this.details } : {}),
+            },
+        };
+    }
+}
+/**
+ * Coerce anything thrown into a JamError. Unknown failures become
+ * JIRA_UNAVAILABLE rather than leaking a raw stack trace to the agent.
+ */
+export function toJamError(err) {
+    if (err instanceof JamError)
+        return err;
+    const message = err instanceof Error ? err.message : String(err);
+    return new JamError("JIRA_UNAVAILABLE", message);
+}

package/dist/domain/issue.d.ts

@@ -0,0 +1,35 @@
+export type IssueRef = {
+    key: string;
+    summary?: string;
+    status?: string;
+};
+/**
+ * SEARCH level. Deliberately excludes description/comments/attachments/changelog
+ * so discovery stays cheap.
+ */
+export type IssueSummary = {
+    key: string;
+    summary: string;
+    status: string;
+    assignee?: string;
+    priority?: string;
+    updated: string;
+    labels: string[];
+    components: string[];
+};
+export type LinkDirection = "outward" | "inward";
+export type IssueLink = {
+    /** Human-readable relationship as Jira words it, e.g. "blocks", "is blocked by". */
+    type: string;
+    direction: LinkDirection;
+    issue: IssueRef;
+    /**
+     * True when Jira's issue-link semantics put this issue on the blocked side.
+     *
+     * A reading of the link, not a verdict on the work: it is derived from how
+     * Jira words the relationship, so `true` is not a finding that work cannot
+     * start, and `false` is not a finding that nothing blocks it. Whatever is
+     * only written in a description, an MR or a spec is not represented here.
+     */
+    blocksThisIssue: boolean;
+};

package/dist/domain/issue.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { runJamCommand } from "./cli-entry.js";
+import { toJamError } from "./domain/errors.js";
+runJamCommand(process.argv.slice(2))
+    .then((code) => {
+    // Setting exitCode and letting Node exit naturally (rather than forcing
+    // process.exit()) avoids a libuv assertion crash observed on Windows when
+    // this process has mixed spawnSync (reg.exe/where) with async fetch calls -
+    // a forced exit can race a handle that is still closing.
+    if (code >= 0)
+        process.exitCode = code;
+})
+    .catch((err) => {
+    const jamError = toJamError(err);
+    process.stderr.write(`[jam] ${jamError.code}: ${jamError.message}\n`);
+    process.exitCode = 1;
+});

package/dist/mcp/create-server.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { JamDeps } from "../deps.js";
+export declare const SERVER_NAME = "jam";
+/**
+ * The external contract: exactly three read tools, stable from the first
+ * release. Internal changes (cache, Rovo, remote transport) must not add or
+ * rename anything here.
+ */
+export declare function createServer(deps: JamDeps): McpServer;

package/dist/mcp/create-server.js

@@ -0,0 +1,32 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createRequire } from "node:module";
+import { registerJiraContext } from "./tools/jira-context.tool.js";
+import { registerJiraFull } from "./tools/jira-full.tool.js";
+import { registerJiraSearch } from "./tools/jira-search.tool.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+export const SERVER_NAME = "jam";
+/**
+ * The external contract: exactly three read tools, stable from the first
+ * release. Internal changes (cache, Rovo, remote transport) must not add or
+ * rename anything here.
+ */
+export function createServer(deps) {
+    const server = new McpServer({ name: SERVER_NAME, version: pkg.version ?? "0.0.0" }, {
+        instructions: [
+            "JAM (Jira Agent MCP) is the default path for reading Jira.",
+            "Pick the tool by what the answer will be used for:",
+            "- listing / discovery / current status -> jira_search",
+            "- readiness, blockers, dependencies, priority -> jira_context",
+            "- agreement, contract, approval, closure -> jira_full",
+            "Never treat a jira_search result as complete issue context.",
+            "Every result carries a `meta` block; if meta.complete is false the answer is partial and must be reported as such.",
+            "meta.complete describes JAM's retrieval, not the project: it means the Jira read finished with no known loss, never that Jira holds the whole story.",
+            "meta.evidenceScope and meta.limitations name what was not evaluated - the repository and every external source among them. Judge Jira evidence from these results; judge execution reality elsewhere.",
+        ].join("\n"),
+    });
+    registerJiraSearch(server, deps);
+    registerJiraContext(server, deps);
+    registerJiraFull(server, deps);
+    return server;
+}

package/dist/mcp/tool-result.d.ts

@@ -0,0 +1,10 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { TelemetryPort } from "../ports/telemetry.port.js";
+/** Compact JSON - indentation is pure token cost on this path. */
+export declare function ok(payload: unknown): CallToolResult;
+export declare function fail(err: unknown): CallToolResult;
+/**
+ * Every tool goes through here so a thrown Jira error becomes a normalized code
+ * instead of a stack trace, and failures still show up in telemetry.
+ */
+export declare function runTool(tool: string, telemetry: TelemetryPort, fn: () => Promise<unknown>): Promise<CallToolResult>;

package/dist/mcp/tool-result.js

@@ -0,0 +1,33 @@
+import { toJamError } from "../domain/errors.js";
+/** Compact JSON - indentation is pure token cost on this path. */
+export function ok(payload) {
+    return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+}
+export function fail(err) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: JSON.stringify(toJamError(err).toPayload()) }],
+    };
+}
+/**
+ * Every tool goes through here so a thrown Jira error becomes a normalized code
+ * instead of a stack trace, and failures still show up in telemetry.
+ */
+export async function runTool(tool, telemetry, fn) {
+    const started = performance.now();
+    try {
+        return ok(await fn());
+    }
+    catch (err) {
+        const jamError = toJamError(err);
+        telemetry.recordTool({
+            tool,
+            durationMs: performance.now() - started,
+            jiraRequests: 0,
+            issues: 0,
+            responseBytes: 0,
+            errorCode: jamError.code,
+        });
+        return fail(jamError);
+    }
+}

package/dist/mcp/tools/jira-context.tool.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { JamDeps } from "../../deps.js";
+export declare function registerJiraContext(server: McpServer, deps: JamDeps): void;

package/dist/mcp/tools/jira-context.tool.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { getIssueContext } from "../../application/get-issue-context.js";
+import { runTool } from "../tool-result.js";
+const DESCRIPTION = `Get the dependency and readiness picture for one or more Jira issues.
+
+Use for: "can I start this", "what is blocking it", "what should I do first", parent/subtask structure, cross-team dependencies, priority ordering.
+
+Returns everything jira_search returns plus issue type, parent, subtasks, issue links (with blocksThisIssue flagged) and the project's whitelisted custom fields. It does NOT return the comment thread - if the question is whether something was agreed, approved, or finished, use jira_full instead.
+
+This is the Jira-recorded evidence relevant to readiness, blockers, dependencies and priority - not a readiness verdict. blocksThisIssue reports how Jira words a link; an empty links array means Jira holds no visible link for you, not that nothing blocks the work. Repository and external sources are not evaluated.
+
+Pass every key you care about in one call; they are fetched in a single batched round trip. Check meta.complete and meta.missingKeys before drawing conclusions.`;
+export function registerJiraContext(server, deps) {
+    server.registerTool("jira_context", {
+        title: "Jira issue context (dependencies, blockers, readiness)",
+        description: DESCRIPTION,
+        inputSchema: {
+            issueKeys: z
+                .array(z.string().min(1))
+                .min(1)
+                .describe('Issue keys, e.g. ["PROJECT-97", "PROJECT-101"]. Batch them in one call.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => runTool("jira_context", deps.telemetry, () => getIssueContext(deps, { issueKeys: args.issueKeys })));
+}

package/dist/mcp/tools/jira-full.tool.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { JamDeps } from "../../deps.js";
+export declare function registerJiraFull(server: McpServer, deps: JamDeps): void;

package/dist/mcp/tools/jira-full.tool.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { getFullIssueContext } from "../../application/get-full-issue-context.js";
+import { runTool } from "../tool-result.js";
+const DESCRIPTION = `Get the complete record for one or more Jira issues, including the description and the full comment thread.
+
+Use for final judgements: was this agreed, is the contract settled, was it approved, can it be closed, what did the other team actually answer, what does this issue mean right now.
+
+Returns everything jira_context returns plus description and every comment (normalized to plain text). This is the most expensive tool - prefer jira_search for listing and jira_context for readiness, and reach for this one when the answer must not be wrong.
+
+Ask for as few keys as possible: with several issues at once the output budget may drop the oldest comments. Always check meta.commentsComplete and meta.complete - if either is false, the thread you are reading is partial and a "yes, it is agreed" answer is not supported.
+
+This is the Jira-recorded evidence relevant to agreement, contract, approval and closure. Repository and external sources are not evaluated.
+
+Absence of evidence in Jira is not evidence of absence. A complete read with no supporting comments proves only what Jira holds. If the issue references an external canonical source (an MR/PR, a spec or contract document, Confluence, another issue), do not conclude "not agreed", "not approved" or "cannot start": check that source if you can reach it, and otherwise report that Jira alone cannot settle the question and name the source that must be checked. Issues that reference no external source do not warrant an open-ended search.`;
+export function registerJiraFull(server, deps) {
+    server.registerTool("jira_full", {
+        title: "Full Jira issue record (description + comments)",
+        description: DESCRIPTION,
+        inputSchema: {
+            issueKeys: z
+                .array(z.string().min(1))
+                .min(1)
+                .describe('Issue keys, e.g. ["PROJECT-97"]. Keep the list short - the full record is large.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => runTool("jira_full", deps.telemetry, () => getFullIssueContext(deps, { issueKeys: args.issueKeys })));
+}

package/dist/mcp/tools/jira-search.tool.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { JamDeps } from "../../deps.js";
+export declare function registerJiraSearch(server: McpServer, deps: JamDeps): void;