@shrkcrft/mcp-server 0.1.0-alpha.2

package/dist/server/http-transport.d.ts

@@ -0,0 +1,24 @@
+import type { Server as McpServer } from '@modelcontextprotocol/sdk/server/index.js';
+export interface StartHttpServerOptions {
+    /** McpServer (NOT yet connected). */
+    server: McpServer;
+    /** Bind host. Default 'localhost'. */
+    host?: string;
+    /** Bind port. Default 4000. */
+    port?: number;
+    /** Path that accepts MCP traffic. Default '/mcp'. */
+    path?: string;
+    /**
+     * Stateful by default — the transport generates a session id and clients
+     * must echo it. Set false for stateless mode.
+     */
+    stateful?: boolean;
+    /** stderr logger. */
+    log?: (line: string) => void;
+}
+export interface HttpServerHandle {
+    url: string;
+    close: () => Promise<void>;
+}
+export declare function startHttpServer(options: StartHttpServerOptions): Promise<HttpServerHandle>;
+//# sourceMappingURL=http-transport.d.ts.map

package/dist/server/http-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/server/http-transport.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAErF,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,MAAM,EAAE,SAAS,CAAC;IAClB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qBAAqB;IACrB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAsBD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmDhG"}

package/dist/server/http-transport.js

@@ -0,0 +1,71 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    if (chunks.length === 0)
+        return undefined;
+    const text = Buffer.concat(chunks).toString('utf8');
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+export async function startHttpServer(options) {
+    const host = options.host ?? 'localhost';
+    const port = options.port ?? 4000;
+    const path = options.path ?? '/mcp';
+    const stateful = options.stateful ?? true;
+    const log = options.log ?? (() => undefined);
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: stateful ? () => randomUUID() : undefined,
+    });
+    await options.server.connect(transport);
+    const http = createServer(async (req, res) => {
+        if (!req.url) {
+            writeJson(res, 400, { error: 'missing url' });
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/healthz') {
+            writeJson(res, 200, { ok: true, transport: 'streamable-http', stateful });
+            return;
+        }
+        const url = new URL(req.url, `http://${host}:${port}`);
+        if (url.pathname !== path) {
+            writeJson(res, 404, { error: `not found: ${url.pathname}` });
+            return;
+        }
+        try {
+            const parsedBody = req.method === 'POST' ? await readBody(req) : undefined;
+            await transport.handleRequest(req, res, parsedBody);
+        }
+        catch (e) {
+            log(`[mcp:http] handleRequest threw: ${e.message}`);
+            if (!res.headersSent) {
+                writeJson(res, 500, { error: e.message });
+            }
+            else {
+                res.end();
+            }
+        }
+    });
+    await new Promise((resolve) => http.listen(port, host, resolve));
+    log(`[mcp:http] listening on http://${host}:${port}${path} (stateful=${stateful})`);
+    return {
+        url: `http://${host}:${port}${path}`,
+        close: async () => {
+            await transport.close().catch(() => undefined);
+            await new Promise((resolve, reject) => http.close((err) => (err ? reject(err) : resolve())));
+        },
+    };
+}

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

@@ -0,0 +1,10 @@
+export interface IMcpServerConfig {
+    name: string;
+    version: string;
+    cwd: string;
+    verbose?: boolean;
+}
+export declare const MCP_SERVER_NAME = "sharkcraft";
+export declare const MCP_SERVER_VERSION = "0.1.0";
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+//# sourceMappingURL=mcp-server-config.d.ts.map

package/dist/server/mcp-server-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-config.d.ts","sourceRoot":"","sources":["../../src/server/mcp-server-config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,eAAe,eAAe,CAAC;AAC5C,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAC1C,eAAO,MAAM,oBAAoB,eAAe,CAAC"}

package/dist/server/mcp-server-config.js

@@ -0,0 +1,3 @@
+export const MCP_SERVER_NAME = 'sharkcraft';
+export const MCP_SERVER_VERSION = '0.1.0';
+export const MCP_PROTOCOL_VERSION = '2024-11-05';

package/dist/server/sharkcraft-watcher.d.ts

@@ -0,0 +1,18 @@
+export interface StartWatcherOptions {
+    cwd: string;
+    /** Debounce window in ms. Default 200. */
+    debounceMs?: number;
+    onChange: (changedPath: string) => void | Promise<void>;
+    log?: (line: string) => void;
+}
+export interface IWatcherHandle {
+    stop: () => void;
+}
+/**
+ * Watches `<cwd>/sharkcraft/` (recursive on macOS/Linux/Windows where supported).
+ * Coalesces bursty events through a debounce. On any change, invokes onChange
+ * once with the most-recent path. If `sharkcraft/` does not exist, the watcher
+ * is a no-op (but still returns a stop()).
+ */
+export declare function startSharkcraftWatcher(options: StartWatcherOptions): IWatcherHandle;
+//# sourceMappingURL=sharkcraft-watcher.d.ts.map

package/dist/server/sharkcraft-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharkcraft-watcher.d.ts","sourceRoot":"","sources":["../../src/server/sharkcraft-watcher.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAkDnF"}

package/dist/server/sharkcraft-watcher.js

@@ -0,0 +1,60 @@
+import { existsSync, watch } from 'node:fs';
+import * as nodePath from 'node:path';
+/**
+ * Watches `<cwd>/sharkcraft/` (recursive on macOS/Linux/Windows where supported).
+ * Coalesces bursty events through a debounce. On any change, invokes onChange
+ * once with the most-recent path. If `sharkcraft/` does not exist, the watcher
+ * is a no-op (but still returns a stop()).
+ */
+export function startSharkcraftWatcher(options) {
+    const debounceMs = options.debounceMs ?? 200;
+    const log = options.log ?? (() => undefined);
+    const sharkcraftDir = nodePath.join(options.cwd, 'sharkcraft');
+    if (!existsSync(sharkcraftDir)) {
+        log(`no sharkcraft/ directory at ${sharkcraftDir} — watcher disabled`);
+        return { stop: () => undefined };
+    }
+    let pendingTimer = null;
+    let lastPath = '';
+    let stopped = false;
+    function schedule(path) {
+        if (stopped)
+            return;
+        lastPath = path;
+        if (pendingTimer)
+            clearTimeout(pendingTimer);
+        pendingTimer = setTimeout(() => {
+            pendingTimer = null;
+            Promise.resolve(options.onChange(lastPath)).catch((e) => {
+                log(`onChange threw: ${e.message}`);
+            });
+        }, debounceMs);
+    }
+    let watcher = null;
+    try {
+        watcher = watch(sharkcraftDir, { recursive: true }, (event, filename) => {
+            if (stopped)
+                return;
+            const filePath = filename ? nodePath.join(sharkcraftDir, filename.toString()) : sharkcraftDir;
+            log(`event=${event} ${filePath}`);
+            schedule(filePath);
+        });
+        log(`watching ${sharkcraftDir}`);
+    }
+    catch (e) {
+        log(`failed to start watcher: ${e.message}`);
+    }
+    return {
+        stop: () => {
+            stopped = true;
+            if (pendingTimer)
+                clearTimeout(pendingTimer);
+            try {
+                watcher?.close();
+            }
+            catch {
+                // ignore
+            }
+        },
+    };
+}

package/dist/server/tool-definition.d.ts

@@ -0,0 +1,56 @@
+import type { ISharkcraftInspection } from '@shrkcrft/inspector';
+export interface IToolJsonSchema {
+    type: 'object';
+    properties?: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface IToolContext {
+    inspection: ISharkcraftInspection;
+    cwd: string;
+}
+export interface IToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: IToolJsonSchema;
+    handler: (input: Record<string, unknown>, context: IToolContext) => Promise<IToolResponse> | IToolResponse;
+    /**
+     * Optional CLI sibling command this tool mirrors. Used by the
+     * tier-gating layer: if the sibling is experimental and not enabled
+     * in the project's surface config, the MCP tool returns the same
+     * structured not-enabled error the CLI does.
+     *
+     * Tools without a CLI sibling (bootstrap MCP-only tools like
+     * `get_command_catalog` or `inspect_workspace`) leave this absent
+     * and are always callable.
+     */
+    cliCommand?: string;
+}
+/**
+ * Result of the MCP-side tier gate. `null` = callable, otherwise
+ * structured info for the not-enabled response.
+ */
+export interface IMcpGateDecision {
+    command: string;
+    reason?: string;
+}
+export type McpGateResolver = (tool: IToolDefinition) => IMcpGateDecision | null;
+export interface IToolError {
+    /** Stable machine-readable error code (e.g. `cache-miss`, `not-found`). */
+    code: string;
+    /** Human-readable summary. */
+    message: string;
+    /** Optional structured details (recovery hints, suggested next calls). */
+    details?: unknown;
+}
+export interface IToolResponse {
+    /** Text representation. */
+    text?: string;
+    /** Structured JSON output (for clients that prefer it). */
+    data?: unknown;
+    /** True if the tool should be reported as an error. */
+    isError?: boolean;
+    /** Optional structured error block — set together with `isError: true`. */
+    error?: IToolError;
+}
+//# sourceMappingURL=tool-definition.d.ts.map

package/dist/server/tool-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-definition.d.ts","sourceRoot":"","sources":["../../src/server/tool-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,qBAAqB,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;IAC3G;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,eAAe,KAAK,gBAAgB,GAAG,IAAI,CAAC;AAEjF,MAAM,WAAW,UAAU;IACzB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uDAAuD;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB"}

package/dist/server/tool-definition.js

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

package/dist/server/tool-input-validators.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const TOOL_INPUT_SCHEMAS: Readonly<Record<string, z.ZodTypeAny>>;
+export interface IToolValidationFailure {
+    toolName: string;
+    message: string;
+    issues: {
+        path: string;
+        message: string;
+    }[];
+}
+export declare function validateToolInput(toolName: string, input: unknown): {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+    failure: IToolValidationFailure;
+};
+//# sourceMappingURL=tool-input-validators.d.ts.map

package/dist/server/tool-input-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-input-validators.d.ts","sourceRoot":"","sources":["../../src/server/tool-input-validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwFxB,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAgBpE,CAAC;AAEH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC7C;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAA;CAAE,CAkB9E"}

package/dist/server/tool-input-validators.js

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for MCP tool inputs that have structured arguments. The schemas
+ * are intentionally narrow: they exist to give MCP clients clear errors when
+ * arguments are malformed, not to replicate the JSON Schema we advertise.
+ */
+const createGenerationPlanSchema = z
+    .object({
+    templateId: z.string().min(1, 'templateId is required'),
+    name: z.string().optional(),
+    variables: z.record(z.string(), z.string()).optional(),
+})
+    .strict();
+const renderTemplatePreviewSchema = createGenerationPlanSchema;
+const explainGenerationTargetSchema = z
+    .object({
+    templateId: z.string().min(1, 'templateId is required'),
+    name: z.string().optional(),
+    variables: z.record(z.string(), z.string()).optional(),
+    task: z.string().optional(),
+})
+    .strict();
+const getKnowledgeSchema = z.object({ id: z.string().min(1) }).strict();
+const getRuleSchema = z.object({ id: z.string().min(1) }).strict();
+const getPathConventionSchema = z.object({ id: z.string().min(1) }).strict();
+const getTemplateSchema = z.object({ id: z.string().min(1) }).strict();
+const searchTemplatesSchema = z.object({ query: z.string() }).strict();
+const getRelevantContextSchema = z
+    .object({
+    task: z.string().min(1, 'task is required'),
+    framework: z.string().optional(),
+    area: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    scope: z.array(z.string()).optional(),
+    maxTokens: z.number().int().min(100).optional(),
+    includeExamples: z.boolean().optional(),
+    includeTemplates: z.boolean().optional(),
+    includeRules: z.boolean().optional(),
+    includePaths: z.boolean().optional(),
+    includeDocs: z.boolean().optional(),
+})
+    .strict();
+const getRelevantRulesSchema = z
+    .object({
+    task: z.string().min(1, 'task is required'),
+    scope: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    appliesWhen: z.array(z.string()).optional(),
+    limit: z.number().int().min(1).optional(),
+})
+    .strict();
+const getActionHintsSchema = z
+    .object({
+    task: z.string().optional(),
+    entryIds: z.array(z.string()).optional(),
+    limit: z.number().int().min(1).optional(),
+})
+    .strict();
+const getPipelineSchema = z.object({ id: z.string().min(1) }).strict();
+const getPackSchema = z.object({ packageName: z.string().min(1) }).strict();
+const createPipelinePlanSchema = z
+    .object({
+    id: z.string().min(1),
+    task: z.string().min(1),
+    inputs: z.record(z.string(), z.string()).optional(),
+    includeOptional: z.array(z.string()).optional(),
+    includeScript: z.boolean().optional(),
+})
+    .strict();
+const getPipelineContextSchema = z
+    .object({
+    id: z.string().min(1, 'id is required'),
+    task: z.string().min(1, 'task is required'),
+    maxTokens: z.number().int().min(100).optional(),
+    scope: z.array(z.string()).optional(),
+})
+    .strict();
+export const TOOL_INPUT_SCHEMAS = Object.freeze({
+    create_generation_plan: createGenerationPlanSchema,
+    render_template_preview: renderTemplatePreviewSchema,
+    explain_generation_target: explainGenerationTargetSchema,
+    get_knowledge: getKnowledgeSchema,
+    get_rule: getRuleSchema,
+    get_path_convention: getPathConventionSchema,
+    get_template: getTemplateSchema,
+    search_templates: searchTemplatesSchema,
+    get_relevant_context: getRelevantContextSchema,
+    get_relevant_rules: getRelevantRulesSchema,
+    get_action_hints: getActionHintsSchema,
+    get_pipeline: getPipelineSchema,
+    get_pipeline_context: getPipelineContextSchema,
+    get_pack: getPackSchema,
+    create_pipeline_plan: createPipelinePlanSchema,
+});
+export function validateToolInput(toolName, input) {
+    const schema = TOOL_INPUT_SCHEMAS[toolName];
+    if (!schema)
+        return { ok: true, data: input };
+    const parsed = schema.safeParse(input);
+    if (parsed.success)
+        return { ok: true, data: parsed.data };
+    return {
+        ok: false,
+        failure: {
+            toolName,
+            message: parsed.error.issues
+                .map((iss) => `${iss.path.join('.') || '<root>'}: ${iss.message}`)
+                .join('; '),
+            issues: parsed.error.issues.map((iss) => ({
+                path: iss.path.join('.'),
+                message: iss.message,
+            })),
+        },
+    };
+}

package/dist/tools/acceptance-replay.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getAcceptanceReplayTool: IToolDefinition;
+//# sourceMappingURL=acceptance-replay.tool.d.ts.map

package/dist/tools/acceptance-replay.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance-replay.tool.d.ts","sourceRoot":"","sources":["../../src/tools/acceptance-replay.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,eAsDrC,CAAC"}

package/dist/tools/acceptance-replay.tool.js

@@ -0,0 +1,53 @@
+import { buildAcceptanceReplay, buildChangesSummary, ReplayProfile, } from '@shrkcrft/inspector';
+export const getAcceptanceReplayTool = {
+    name: 'get_acceptance_replay',
+    description: 'Acceptance-command replay: given a change set, lists previous validation commands to re-run, with reasons. Read-only — does NOT execute the commands.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            since: { type: 'string', description: 'Diff base (git ref / tag).' },
+            staged: { type: 'boolean' },
+            files: { type: 'array', items: { type: 'string' } },
+            profile: { type: 'string', enum: ['changed-only', 'standard', 'strict'] },
+            roundLabel: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const since = typeof input.since === 'string'
+            ? input.since
+            : undefined;
+        const staged = input.staged === true;
+        const filesIn = input.files;
+        const files = Array.isArray(filesIn)
+            ? filesIn.filter((x) => typeof x === 'string')
+            : undefined;
+        const profileRaw = typeof input.profile === 'string'
+            ? input.profile
+            : 'changed-only';
+        const profile = profileRaw === 'standard'
+            ? ReplayProfile.Standard
+            : profileRaw === 'strict'
+                ? ReplayProfile.Strict
+                : ReplayProfile.ChangedOnly;
+        const roundLabel = typeof input.roundLabel === 'string'
+            ? input.roundLabel
+            : undefined;
+        const opts = {};
+        if (since)
+            opts.since = since;
+        if (staged)
+            opts.staged = true;
+        if (files && files.length > 0)
+            opts.files = files;
+        if (roundLabel)
+            opts.roundLabel = roundLabel;
+        const summary = await buildChangesSummary(ctx.inspection, opts);
+        const data = buildAcceptanceReplay({
+            summary,
+            profile,
+            ...(roundLabel ? { roundLabel } : {}),
+        });
+        return { data };
+    },
+};

package/dist/tools/adoption-checkpoint.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getAdoptionCheckpointStatusTool: IToolDefinition;
+//# sourceMappingURL=adoption-checkpoint.tool.d.ts.map

package/dist/tools/adoption-checkpoint.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adoption-checkpoint.tool.d.ts","sourceRoot":"","sources":["../../src/tools/adoption-checkpoint.tool.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,+BAA+B,EAAE,eA+C7C,CAAC"}

package/dist/tools/adoption-checkpoint.tool.js

@@ -0,0 +1,49 @@
+import { buildConstructAdoptionDiff, buildOnboardAdoptionDiff, evaluateAdoptionCheckpoint, hashDiffBody, loadConstructs, readAdoptionCheckpoint, renderConstructAdoptionDiff, renderOnboardAdoptionDiff, } from '@shrkcrft/inspector';
+export const getAdoptionCheckpointStatusTool = {
+    name: 'get_adoption_checkpoint_status',
+    description: 'Read the adoption checkpoint (onboard or construct) and report whether targets/drafts/diff hash still match. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['kind'],
+        properties: {
+            kind: { type: 'string', enum: ['onboard', 'construct'] },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const kindRaw = typeof input['kind'] === 'string' ? input['kind'] : 'onboard';
+        if (kindRaw !== 'onboard' && kindRaw !== 'construct') {
+            return {
+                isError: true,
+                text: `Unknown kind "${kindRaw}". Use onboard|construct.`,
+                error: { code: 'invalid-kind', message: `Unknown kind "${kindRaw}".` },
+            };
+        }
+        const read = readAdoptionCheckpoint(ctx.cwd, kindRaw);
+        let evaluation = null;
+        if (read.checkpoint) {
+            if (kindRaw === 'construct') {
+                await loadConstructs(ctx.inspection);
+                const diff = await buildConstructAdoptionDiff(ctx.inspection);
+                const canonical = renderConstructAdoptionDiff(diff, 'json');
+                evaluation = evaluateAdoptionCheckpoint(ctx.cwd, read.checkpoint, hashDiffBody(canonical));
+            }
+            else {
+                const diff = buildOnboardAdoptionDiff(ctx.inspection);
+                const canonical = renderOnboardAdoptionDiff(diff, 'json');
+                evaluation = evaluateAdoptionCheckpoint(ctx.cwd, read.checkpoint, hashDiffBody(canonical));
+            }
+        }
+        return {
+            data: {
+                kind: kindRaw,
+                path: read.path,
+                exists: read.exists,
+                checkpoint: read.checkpoint,
+                ...(evaluation
+                    ? { status: evaluation.status, reasons: evaluation.reasons, changedTargets: evaluation.changedTargets, changedDrafts: evaluation.changedDrafts }
+                    : { status: 'missing', reasons: ['no checkpoint on disk yet'] }),
+            },
+        };
+    },
+};

package/dist/tools/agent-brief-chunks.tool.d.ts

@@ -0,0 +1,6 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const startAgentBriefChunksTool: IToolDefinition;
+export declare const getAgentBriefChunkIndexTool: IToolDefinition;
+export declare const getAgentBriefChunkTool: IToolDefinition;
+export declare function _resetAgentBriefChunkCache(): void;
+//# sourceMappingURL=agent-brief-chunks.tool.d.ts.map

package/dist/tools/agent-brief-chunks.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-brief-chunks.tool.d.ts","sourceRoot":"","sources":["../../src/tools/agent-brief-chunks.tool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AA4EpE,eAAO,MAAM,yBAAyB,EAAE,eAuHvC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,eAmEzC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAoFpC,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}