@descryy/mcp 0.1.0

package/dist/protocol.js

@@ -0,0 +1,127 @@
+/**
+ * JSON-RPC 2.0 and the slice of MCP this server speaks.
+ *
+ * ## Why this is hand-written
+ *
+ * `@modelcontextprotocol/sdk` is the obvious answer and the blueprint's
+ * dependency table names it. It was measured rather than assumed: version 1.30.0
+ * declares **seventeen direct dependencies** — `express`, `hono`,
+ * `@hono/node-server`, `cors`, `express-rate-limit`, `jose`, `pkce-challenge`,
+ * `eventsource`, `ajv`, `zod` — essentially all of which exist to serve the HTTP
+ * and OAuth transports. This server speaks stdio to a coding agent on the same
+ * machine. It will never open a socket.
+ *
+ * The rest of this project has made the same call four times — `node:sqlite`
+ * over `better-sqlite3`, `node --test` over a test runner, `tsc` over a bundler,
+ * `git` invoked directly over a git library — every time on the same grounds:
+ * this is a **locally installed developer tool**, and a dependency tree is a
+ * distribution problem before it is anything else. Both shipped packages have
+ * zero runtime dependencies today. Seventeen transitively-hundreds is a large
+ * price for newline-delimited JSON.
+ *
+ * **The cost is named, not waved away.** Hand-rolling means spec drift is
+ * silent: the wire format changes, the client stops working, and nothing in this
+ * repository fails. Two things pay it down. `PROTOCOL_VERSION` is pinned and
+ * `SUPPORTED_PROTOCOL_VERSIONS` is explicit, so an unknown version is negotiated
+ * rather than assumed compatible; and the handshake is covered by tests that
+ * assert the exact frames, so a change to the shape is a red test rather than a
+ * user-visible mystery. If the protocol moves past what is here, the fix is to
+ * add a version to the list — not to discover it from a bug report.
+ */
+/** Standard JSON-RPC codes. MCP adds none of its own at this layer. */
+export const RPC_PARSE_ERROR = -32700;
+export const RPC_INVALID_REQUEST = -32600;
+export const RPC_METHOD_NOT_FOUND = -32601;
+export const RPC_INVALID_PARAMS = -32602;
+export const RPC_INTERNAL_ERROR = -32603;
+/**
+ * The version this server implements.
+ *
+ * Newest first. Negotiation echoes the client's version when it is on this list
+ * and otherwise answers with `PROTOCOL_VERSION`, which is what the spec asks for
+ * — the client then decides whether it can proceed. Answering with the client's
+ * unknown version instead would be a claim of compatibility nobody has checked.
+ */
+export const PROTOCOL_VERSION = "2025-06-18";
+export const SUPPORTED_PROTOCOL_VERSIONS = [
+    "2025-06-18",
+    "2025-03-26",
+    "2024-11-05",
+];
+export function negotiateVersion(requested) {
+    return typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : PROTOCOL_VERSION;
+}
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+/**
+ * A frame that could not be understood well enough to answer.
+ *
+ * Distinguished from a request that is merely wrong, because JSON-RPC says a
+ * message with no usable id gets no response at all — replying to it with a
+ * fabricated id would put a frame on the wire the client cannot correlate.
+ */
+export class ProtocolError extends Error {
+    code;
+    /** Null when the frame carried no usable id and must therefore go unanswered. */
+    id;
+    constructor(code, message, id) {
+        super(message);
+        this.name = "ProtocolError";
+        this.code = code;
+        this.id = id;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Parse one line into a request or notification, or throw `ProtocolError`. */
+export function parseMessage(line) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        throw new ProtocolError(RPC_PARSE_ERROR, "not valid JSON", null);
+    }
+    if (!isRecord(raw)) {
+        throw new ProtocolError(RPC_INVALID_REQUEST, "message must be a JSON object", null);
+    }
+    // Batch requests were removed from MCP in 2025-06-18 and this server never
+    // supported them; an array reaches the same branch as any other non-object.
+    const id = raw["id"];
+    const usableId = typeof id === "string" || typeof id === "number" ? id : null;
+    if (raw["jsonrpc"] !== "2.0") {
+        throw new ProtocolError(RPC_INVALID_REQUEST, "jsonrpc must be \"2.0\"", usableId);
+    }
+    if (typeof raw["method"] !== "string") {
+        throw new ProtocolError(RPC_INVALID_REQUEST, "method must be a string", usableId);
+    }
+    const params = raw["params"];
+    if (params !== undefined && !isRecord(params)) {
+        // Positional params are legal JSON-RPC and illegal MCP. Rejected rather than
+        // coerced: an array silently read as an object is a wrong answer, not an error.
+        throw new ProtocolError(RPC_INVALID_PARAMS, "params must be an object", usableId);
+    }
+    const method = raw["method"];
+    const base = params === undefined ? {} : { params };
+    return usableId === null
+        ? { jsonrpc: "2.0", method, ...base }
+        : { jsonrpc: "2.0", id: usableId, method, ...base };
+}
+export function isRequest(message) {
+    return "id" in message;
+}
+export function ok(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+export function fail(id, code, message, data) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: { code, message, ...(data === undefined ? {} : { data }) },
+    };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"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"}

package/dist/registry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * How the server reaches adapters without this repository depending on them.
+ *
+ * `descry-core` must not import `descry-adapters`: the IR boundary is a
+ * dependency-direction fact, and an import here would invert it in the one place
+ * where it matters most — the process that runs everything. So sources are named
+ * in configuration as module specifiers and loaded at runtime. The engine knows
+ * `IRSource`; it never knows the word "python".
+ *
+ * ## The factory convention, and why it is a convention rather than an interface
+ *
+ * Every adapter in `descry-adapters` exports `ADAPTER_ID`, `ADAPTER_VERSION` and
+ * a factory named `create<Something>Adapter` — `createGoAdapter`,
+ * `createTypeScriptAdapter`, `createOpenApiAdapter`. There is no uniform name,
+ * and inventing one now would be a breaking change across twelve packages to
+ * save a regular expression. So: an explicit `export` in config wins; failing
+ * that, the single export matching `create*Adapter` is used; **two matches is an
+ * error, not a coin toss.**
+ *
+ * ## Failing to load a source is a disclosure, never a shrug
+ *
+ * An adapter that will not import is the difference between "we found no problem
+ * in your Python service" and "we could not read your Python service" — §20.2
+ * keeps those in different categories, and a registry that quietly skipped a
+ * broken specifier would collapse them at the very bottom of the stack, where no
+ * layer above could ever recover the distinction. Every failure comes back as a
+ * `SourceLoadFailure` carrying the specifier and the reason, and the caller is
+ * structurally unable to take the loaded sources without also taking the list of
+ * ones that are missing.
+ */
+import type { IRSource, LanguageAdapter, RepoRoot } from "@descryy/ir";
+/** One entry in the configured source list. A bare string is `{ module }`. */
+export interface SourceSpec {
+    readonly module: string;
+    /** Named export to call. Defaults to the `create*Adapter` convention. */
+    readonly export?: string;
+    /** Passed to the factory. Adapter-specific and opaque here. */
+    readonly options?: Record<string, unknown>;
+}
+export interface LoadedSource {
+    readonly spec: SourceSpec;
+    readonly source: IRSource;
+    /** Present when the source implements `LanguageAdapter`, so `detect` can run. */
+    readonly adapter: LanguageAdapter | null;
+}
+export interface SourceLoadFailure {
+    readonly spec: SourceSpec;
+    readonly reason: string;
+}
+export interface RegistryResult {
+    readonly loaded: readonly LoadedSource[];
+    readonly failed: readonly SourceLoadFailure[];
+}
+export declare function normaliseSpec(entry: string | SourceSpec): SourceSpec;
+export declare function loadSources(entries: readonly (string | SourceSpec)[]): Promise<RegistryResult>;
+/**
+ * Ask each loaded adapter whether it claims this repository.
+ *
+ * A source that is not a `LanguageAdapter` — the git history reader is the
+ * standing example — has nothing to detect and always runs. A `detect` that
+ * throws is treated as "did not detect", **with the reason recorded**: a broken
+ * detector must not be able to fail the whole run, and must not be able to hide
+ * either.
+ */
+export declare function detectSources(sources: readonly LoadedSource[], root: RepoRoot): Promise<{
+    readonly applicable: readonly LoadedSource[];
+    readonly skipped: readonly {
+        source: LoadedSource;
+        reason: string;
+    }[];
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC/C;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAEpE;AAyBD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,GACxC,OAAO,CAAC,cAAc,CAAC,CAczB;AAsCD;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC;IACT,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACvE,CAAC,CAuBD"}

package/dist/registry.js

@@ -0,0 +1,136 @@
+/**
+ * How the server reaches adapters without this repository depending on them.
+ *
+ * `descry-core` must not import `descry-adapters`: the IR boundary is a
+ * dependency-direction fact, and an import here would invert it in the one place
+ * where it matters most — the process that runs everything. So sources are named
+ * in configuration as module specifiers and loaded at runtime. The engine knows
+ * `IRSource`; it never knows the word "python".
+ *
+ * ## The factory convention, and why it is a convention rather than an interface
+ *
+ * Every adapter in `descry-adapters` exports `ADAPTER_ID`, `ADAPTER_VERSION` and
+ * a factory named `create<Something>Adapter` — `createGoAdapter`,
+ * `createTypeScriptAdapter`, `createOpenApiAdapter`. There is no uniform name,
+ * and inventing one now would be a breaking change across twelve packages to
+ * save a regular expression. So: an explicit `export` in config wins; failing
+ * that, the single export matching `create*Adapter` is used; **two matches is an
+ * error, not a coin toss.**
+ *
+ * ## Failing to load a source is a disclosure, never a shrug
+ *
+ * An adapter that will not import is the difference between "we found no problem
+ * in your Python service" and "we could not read your Python service" — §20.2
+ * keeps those in different categories, and a registry that quietly skipped a
+ * broken specifier would collapse them at the very bottom of the stack, where no
+ * layer above could ever recover the distinction. Every failure comes back as a
+ * `SourceLoadFailure` carrying the specifier and the reason, and the caller is
+ * structurally unable to take the loaded sources without also taking the list of
+ * ones that are missing.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+const FACTORY_PATTERN = /^create[A-Za-z0-9]*Adapter$/;
+export function normaliseSpec(entry) {
+    return typeof entry === "string" ? { module: entry } : entry;
+}
+/**
+ * A loaded module is a `LanguageAdapter` when it can be asked what it supports.
+ *
+ * Duck-typed on the two methods that matter rather than on a marker, because the
+ * adapters are compiled separately and `instanceof` across package boundaries is
+ * a well-known way to be wrong. `detect` and `capabilities` are the two the
+ * server actually calls; a source with both is one it can treat as an adapter.
+ */
+function asAdapter(source) {
+    const candidate = source;
+    return typeof candidate.detect === "function" && typeof candidate.capabilities === "function"
+        ? source
+        : null;
+}
+function describe(error) {
+    if (error instanceof Error) {
+        const code = error.code;
+        return code === undefined ? error.message : `${code}: ${error.message}`;
+    }
+    return String(error);
+}
+export async function loadSources(entries) {
+    const loaded = [];
+    const failed = [];
+    for (const entry of entries) {
+        const spec = normaliseSpec(entry);
+        try {
+            loaded.push({ ...(await instantiate(spec)), spec });
+        }
+        catch (error) {
+            failed.push({ spec, reason: describe(error) });
+        }
+    }
+    return { loaded, failed };
+}
+async function instantiate(spec) {
+    const module = (await import(__rewriteRelativeImportExtension(spec.module)));
+    let factoryName = spec.export;
+    if (factoryName === undefined) {
+        const candidates = Object.keys(module).filter((key) => FACTORY_PATTERN.test(key) && typeof module[key] === "function");
+        if (candidates.length === 0) {
+            throw new Error(`no export matching create*Adapter. Name one explicitly with ` +
+                `{ "module": "${spec.module}", "export": "..." }.`);
+        }
+        if (candidates.length > 1) {
+            throw new Error(`${candidates.length} exports match create*Adapter (${candidates.sort().join(", ")}). ` +
+                "Name the one to use explicitly rather than letting the choice depend on export order.");
+        }
+        factoryName = candidates[0];
+    }
+    const factory = module[factoryName];
+    if (typeof factory !== "function") {
+        throw new Error(`export "${factoryName}" is not a function`);
+    }
+    const source = factory(spec.options);
+    if (typeof source?.emit !== "function" || typeof source.id !== "string") {
+        throw new Error(`"${factoryName}" did not return an IRSource (needs \`id\` and \`emit\`)`);
+    }
+    return { source, adapter: asAdapter(source) };
+}
+/**
+ * Ask each loaded adapter whether it claims this repository.
+ *
+ * A source that is not a `LanguageAdapter` — the git history reader is the
+ * standing example — has nothing to detect and always runs. A `detect` that
+ * throws is treated as "did not detect", **with the reason recorded**: a broken
+ * detector must not be able to fail the whole run, and must not be able to hide
+ * either.
+ */
+export async function detectSources(sources, root) {
+    const applicable = [];
+    const skipped = [];
+    for (const entry of sources) {
+        if (entry.adapter === null) {
+            applicable.push(entry);
+            continue;
+        }
+        try {
+            const detection = await entry.adapter.detect(root);
+            if (detection.detected)
+                applicable.push(entry);
+            else
+                skipped.push({
+                    source: entry,
+                    reason: "found nothing it recognises in this repository",
+                });
+        }
+        catch (error) {
+            skipped.push({ source: entry, reason: `detection failed — ${describe(error)}` });
+        }
+    }
+    return { applicable, skipped };
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/dist/render.d.ts

@@ -0,0 +1,275 @@
+/**
+ * The one way an engine answer becomes an MCP tool result.
+ *
+ * ## Why this file exists rather than each tool formatting its own reply
+ *
+ * `QueryResult` carries three things a caller would rather not think about: a
+ * staleness stamp (§27.3), a `truncated` flag, and `notes` — the plain-words
+ * disclosures that populate the five result states' `refused`/`empty`/`failed`/
+ * `timed_out` cases. The engine computes all three correctly today. Every one of
+ * them is one careless `return result.data` away from never reaching a user.
+ *
+ * So the tool handler's return type is `QueryResult`, not content. A handler
+ * *cannot* build a reply; it can only produce an answer, and this module is the
+ * only thing that turns an answer into frames. Rule 7 — honest degradation, no
+ * silent doing-less — becomes a property of the type system rather than of
+ * whoever writes the next tool.
+ *
+ * ## `ai-tool-contract.md` §2 — the frozen envelope
+ *
+ * This module used to ship a two-value `status: "ok" | "not_analysable"`. The
+ * contract froze five: `ok` / `empty` / `refused` / `failed` / `timed_out`
+ * (§1), plus `class`, `toolVersion`, `budget` and a structured `truncated`
+ * object (§2). `AnswerStatus`/`renderAnswer`'s old two-state shape is gone
+ * rather than kept alongside the new one — two envelope shapes on the wire is
+ * the thing DEC-277's "one process mints" reasoning exists to avoid one layer
+ * up, applied here to a type rather than a decision number.
+ *
+ * ## Four invariants, asserted rather than documented (§2.1)
+ *
+ * `render.ts` already enforced the first two; the other two are new.
+ *
+ * 1. `truncated != null` with empty `disclosures` → throw.
+ * 2. `state` in `{refused, failed, timed_out}` with empty `disclosures` → throw.
+ * 3. `state == "refused"` with no verbatim reason in `disclosures` → throw (§4).
+ * 4. `class == "action"` returning anything other than a handshake envelope on
+ *    the first call → throw (§7) — enforced in `action-handshake.ts` and
+ *    `server.ts`, not here: this module never sees a mint, only a redeemed run.
+ */
+import { type ReliabilityClass, type ReportCategory } from "@descryy/ir";
+import type { ResultState, ToolClass } from "@descryy/ir";
+import type { QueryResult } from "@descryy/core";
+export type { ResultState } from "@descryy/ir";
+/**
+ * MK-5 — which of the sixteen tools states a conclusion about the user's code
+ * versus which reports a fact about the graph.
+ *
+ * Lives here rather than in `@descryy/ir`: `tool-surface.ts`'s own header
+ * scopes that file to exactly `ResultState` and `ToolClass` ("and nothing
+ * else"), because those two cross into the pipeline and the desktop surface.
+ * This distinction is agent-mode-only (`plugin-and-mcp-surface.md` §3 PL-1),
+ * so a third shared union there would be scope creep the file's own doc
+ * disclaims. `kit.ts` imports it from here rather than the reverse, because
+ * `kit.ts` already depends on this module for `ToolAnswer`/`TruncationDetail`
+ * — defining it in `kit.ts` instead would make this module import back from
+ * `kit.ts` and cycle.
+ *
+ * - `conclusion` — the output is a statement about the user's code
+ *   (`validate`, `contracts`, `cross_pr`). Never raw candidates: an
+ *   already-adjudicated result carrying the category and the disclosure
+ *   sentence as one payload.
+ * - `evidence` — the output is a fact the graph computed, already carrying
+ *   its own resolution and qualification. The other thirteen.
+ */
+export declare const TOOL_TIERS: readonly ["conclusion", "evidence"];
+export type ToolTier = (typeof TOOL_TIERS)[number];
+/**
+ * MK-6 — a conclusion produced through this server must not carry the same
+ * badge as one produced by the app's full governance pipeline
+ * (`plugin-and-mcp-surface.md` §3 PL-4). Every value here is a fact about
+ * *this server*, not about any one call, so it is one constant reused on
+ * every envelope rather than a per-tool computation.
+ */
+export interface Provenance {
+    readonly surface: "mcp";
+    readonly adjudicatedBy: "descry";
+    readonly presentedBy: "host-agent";
+    /** MK-11: the G1–G5 governance pipeline does not run in this surface. */
+    readonly governancePipeline: false;
+}
+export interface TruncationDetail {
+    /** How many of the primary collection are in this reply. */
+    readonly shown: number;
+    /** The count before the cap — §5.5: "the count before the cap". */
+    readonly total: number;
+    /** A cursor to fetch the rest. `null` until pagination exists to redeem one. */
+    readonly more: string | null;
+}
+export interface ToolAnswer<T> {
+    readonly result: QueryResult<T>;
+    /**
+     * One of the five result states (§1). Omitted means `"ok"` — the common
+     * case, and the one that needs no tool-author ceremony.
+     *
+     * `"empty"` is a claim a tool must *earn* (§1.3b): reach for it only when
+     * the search ran against a population known to be real (an `analysed`/`ran`
+     * flag already true, a resolved node, a read that completed). Default to
+     * `"refused"` when that is not established — never to `"ok"` with a quietly
+     * empty collection, which is the exact defect §1 exists to close.
+     */
+    readonly state?: ResultState;
+    /**
+     * Is this a claim about a *name* or about a *shape*? §11A.5 gives R2 two
+     * different caps depending on the answer, so it is required rather than
+     * defaulted — see `reliabilityCap`.
+     */
+    readonly nameLevel: boolean;
+    /** One line the agent reads first. The payload is underneath it. */
+    readonly headline: string;
+    /**
+     * Present only when the tool already computed `shown`/`total` for its
+     * primary list at the return site (most do, for the "N further… capped at
+     * limit" note). `null` falls back to a bare boolean-shaped truncation with
+     * no counts — still non-null per invariant 1, just less informative.
+     */
+    readonly truncatedDetail?: TruncationDetail;
+    /**
+     * §5.4's `refusals` field, populated by a tool whose *own call* produced a
+     * fresh population of `UnresolvedRef` rows to summarise — as opposed to
+     * `refusal_fetch`, which pages the whole graph's stored ledger. `analyze`
+     * is the one tool that fits today: a run reads sources and the refs it
+     * could not resolve are this call's own result, not a read of prior state.
+     * Omit when the tool has no such population, or when it summarised zero
+     * rows — an empty summary carries no exemplar or handle to show.
+     */
+    readonly refusalSummary?: {
+        readonly count: number;
+        readonly exemplar: string;
+        readonly handle: string;
+    };
+}
+export interface McpContent {
+    readonly type: "text";
+    readonly text: string;
+}
+export interface CallToolResult {
+    readonly content: readonly McpContent[];
+    readonly structuredContent: Record<string, unknown>;
+    readonly isError?: boolean;
+}
+/**
+ * The machine-readable envelope. Shape is stable across every tool.
+ *
+ * `T` is the tool's own `data` type — every tool exports one (`ImpactData`,
+ * `ScopeData`, …) and types its handler against it, so `tsc` rejects a handler
+ * that returns a shape the declaration does not name. The parameter defaults
+ * to `unknown` so a caller handling any tool's reply generically still type
+ * checks; a caller that knows which tool it called writes
+ * `AnswerEnvelope<ImpactData>` and gets the shape.
+ */
+export interface AnswerEnvelope<T = unknown> {
+    readonly tool: string;
+    /** Contract §6, rule 8. A behaviour change is a version bump; recorded with the run. */
+    readonly toolVersion: string;
+    readonly state: ResultState;
+    /** DEC-278's three classes — §6's retry table reads this. */
+    readonly class: ToolClass;
+    readonly headline: string;
+    /** `null` on `failed` (§2.2: always). May carry disambiguation, never an answer, on `refused`. */
+    readonly data: T | null;
+    readonly graph: {
+        readonly commitSha: string | null;
+        readonly builtAt: string | null;
+        readonly irSchemaVersion: number;
+        /** `null` — never absent — when the graph was not consulted at all (§3). */
+        readonly resolutionFloor: number | null;
+        readonly reliabilityCap: ReliabilityClass;
+    };
+    readonly truncated: TruncationDetail | null;
+    /**
+     * §5.4. `null` unless the answering tool supplied `refusalSummary` — see
+     * that field's own doc for which tools have a population to summarise.
+     */
+    readonly refusals: {
+        readonly count: number;
+        readonly exemplar: string;
+        readonly handle: string;
+    } | null;
+    readonly budget: {
+        readonly elapsedMs: number;
+        readonly limitMs: number;
+    };
+    /** Never empty when the answer is degraded, truncated or refused/failed/timed-out. */
+    readonly disclosures: readonly string[];
+    /**
+     * MK-8/MK-11 — §19's five categories, settled for this surface: a
+     * `conclusion`-tier tool states its verdict in `headline`'s own plain words
+     * rather than through this apparatus (it is a fact, not a hypothesis), so
+     * this is `null` there. An `evidence`-tier tool never carries runtime
+     * evidence in this surface — descry-runtime's loop does not run inside an
+     * MCP call — so G3 always short-circuits: `refused` maps to the direct
+     * equivalent, `not analysable` ("could not look" vs. "cannot establish
+     * this here" are the same statement); `ok`/`empty` map to `unconfirmed`,
+     * since a graph fact with no runtime corroboration is never `confirmed` by
+     * construction; `failed`/`timed_out` carry no claim at all, so `null`.
+     * `confirmed` stays reserved for the app's full pipeline and is therefore
+     * unreachable from here — the honest outcome MK-11 ruled on, not a gap.
+     */
+    readonly reportCategory: ReportCategory | null;
+    /** MK-6. Constant for this server — see `Provenance`'s own doc. */
+    readonly provenance: Provenance;
+}
+export declare class DisclosureError extends Error {
+    constructor(message: string);
+}
+export interface RenderOptions {
+    readonly toolVersion: string;
+    readonly toolClass: ToolClass;
+    /** MK-5/MK-8 — which report-category rule applies. See `ToolTier`. */
+    readonly toolTier: ToolTier;
+    readonly elapsedMs: number;
+    readonly limitMs: number;
+}
+/**
+ * A refusal's reason must be the specific, verbatim thing that blocked it —
+ * never just the state name. This is a heuristic proxy for that rule (§4):
+ * `disclosures` must contain something a template did not produce, which we
+ * cannot verify from here, but we CAN verify the weaker, structurally
+ * checkable half — that at least one disclosure exists and it is not empty
+ * text — the same shape invariant 2 already asserts. The stronger claim (the
+ * reason is *this* refusal's actual cause, not a generic string) is a
+ * per-tool authoring discipline this function cannot see into; it is checked
+ * by `tool-contract-gate.mjs`'s exemplar reading instead.
+ */
+export declare function renderAnswer<T>(tool: string, answer: ToolAnswer<T>, options: RenderOptions): CallToolResult;
+/**
+ * A failure that is the caller's to fix — a bad argument, a missing graph.
+ *
+ * Returned as a tool result with `isError`, not as a JSON-RPC error, which is
+ * what the MCP spec asks for: protocol errors are for malformed protocol, tool
+ * errors are for tools, and an agent can act on the second only if it arrives as
+ * content it can read.
+ *
+ * Deliberately outside the five-state envelope: a bad argument is not a
+ * statement about what Descry found or could not find, it is "fix your call
+ * and retry" — a different kind of thing than `refused`/`failed`.
+ */
+export declare function renderToolError(tool: string, message: string): CallToolResult;
+/**
+ * `state: "failed"` — §1.1: "promoted from a transport error to a result."
+ *
+ * An unexpected/internal error, not a bad argument (`renderToolError` still
+ * handles those). `data` is always `null` here (§2.2): the tool does not know
+ * what happened, and anything it returned would be a guess about its own
+ * fault. `isError` stays `true` so a generic MCP client that only reads the
+ * transport-level signal still treats this as a failure; an AI-layer-aware
+ * caller additionally gets `state: "failed"` in `structuredContent` to reason
+ * about rather than a bare `{tool, status, message}` shape.
+ */
+export declare function renderFailed(tool: string, message: string, options: RenderOptions): CallToolResult;
+/**
+ * The one legitimate producer of a pending-handshake payload — §7's mint call.
+ *
+ * `class == "action"` returning anything other than this shape on an
+ * unconfirmed first call is invariant 4 (§2.1): "throw." This function is
+ * where that shape is produced, so the throw lives at the one call site that
+ * builds anything else for an action tool's first call — `server.ts`'s
+ * dispatch loop calls this and only this when `resolveActionDispatch` returns
+ * `{kind: "handshake"}`, never `tool.run`.
+ *
+ * `state: "ok"` deliberately: a mint is not a refusal, a failure or an empty
+ * result — it is a successful "here is what I would do", and the *pending*
+ * flag inside `data` is what tells a caller nothing was performed yet.
+ */
+export declare function renderHandshake(tool: string, token: string, willDo: string, options: RenderOptions): CallToolResult;
+/**
+ * `state: "timed_out"` — the call ran out of its declared budget.
+ *
+ * §6: "not a silent truncation and never a `failed`". `data` is `null` here
+ * because none of the registered tools currently produce genuine partial
+ * results mid-run (none checks `ctx.signal` internally yet — a disclosed gap,
+ * not a silent one, named in the returned disclosure); the envelope shape
+ * supports a populated partial `data` the day a tool does.
+ */
+export declare function renderTimedOut(tool: string, options: RenderOptions): CallToolResult;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"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"}