@zivis/mcp 0.1.19 → 0.2.5

package/dist/tools/manage-endpoint-lifecycle.js

@@ -1,180 +0,0 @@
-import { z } from "zod";
-import { requireApplicationId } from "../resolve-application-id.js";
-import { sanitizeResponse } from "../sanitize.js";
-export const MANAGE_ENDPOINT_LIFECYCLE_NAME = "zivis_manage_endpoint_lifecycle";
-export const MANAGE_ENDPOINT_LIFECYCLE_DESCRIPTION = `Manage endpoint lifecycle for an application.
-
-Actions:
-- create: create a single endpoint
-- update: patch an endpoint
-- delete: delete a single endpoint
-- bulk_delete: delete endpoints by source (e.g., openapi)
-- import_openapi: import endpoints from an OpenAPI spec`;
-export const MANAGE_ENDPOINT_LIFECYCLE_SCHEMA = {
-    application_id: z
-        .string()
-        .optional()
-        .describe("Application UUID. If omitted, uses applicationId from .zivis/project.json when set."),
-    action: z
-        .enum(["create", "update", "delete", "bulk_delete", "import_openapi"])
-        .describe("Endpoint lifecycle action"),
-    endpoint_id: z.string().optional().describe("Required for update/delete actions"),
-    path: z.string().optional().describe("Endpoint path, e.g. /api/chat"),
-    method: z
-        .enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])
-        .optional()
-        .describe("HTTP method"),
-    summary: z.string().optional().describe("Endpoint summary"),
-    description: z.string().optional().describe("Endpoint description"),
-    tags: z.array(z.string()).optional().describe("Endpoint tags"),
-    auth_required: z.boolean().optional().describe("Whether auth is required"),
-    deprecated: z.boolean().optional().describe("Whether endpoint is deprecated"),
-    endpoint_type: z
-        .enum(["api", "chat", "sse", "validation", "web"])
-        .optional()
-        .describe("Endpoint type"),
-    request_template: z
-        .string()
-        .optional()
-        .describe("AI request template, usually includes {{message}}"),
-    response_path: z
-        .string()
-        .optional()
-        .describe("JSON path to pull response text"),
-    streaming_enabled: z.boolean().optional().describe("Whether streaming is enabled"),
-    source: z
-        .enum(["openapi", "manual", "discovery"])
-        .optional()
-        .describe("Source filter for bulk_delete"),
-    spec_url: z.string().optional().describe("OpenAPI spec URL for import_openapi"),
-    spec_content: z.string().optional().describe("Raw OpenAPI spec content"),
-    replace_existing: z
-        .boolean()
-        .optional()
-        .describe("When import_openapi, remove previous openapi endpoints first"),
-};
-export function createManageEndpointLifecycleHandler(apiClient) {
-    return async (params) => {
-        const req = requireApplicationId(params.application_id);
-        if (!req.ok) {
-            return {
-                content: [{ type: "text", text: `Error: ${req.message}` }],
-                isError: true,
-            };
-        }
-        const applicationId = req.id;
-        const action = params.action;
-        try {
-            let data;
-            if (action === "create") {
-                if (!params.path || !params.method) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "Error: create requires path and method",
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                data = await apiClient.post(`/api/rt/applications/${applicationId}/endpoints`, {
-                    path: params.path,
-                    method: params.method,
-                    summary: params.summary,
-                    description: params.description,
-                    tags: params.tags,
-                    authRequired: params.auth_required,
-                    deprecated: params.deprecated,
-                    endpointType: params.endpoint_type,
-                    requestTemplate: params.request_template,
-                    responsePath: params.response_path,
-                    streamingEnabled: params.streaming_enabled,
-                });
-            }
-            else if (action === "update") {
-                if (!params.endpoint_id) {
-                    return {
-                        content: [
-                            { type: "text", text: "Error: endpoint_id is required for update" },
-                        ],
-                        isError: true,
-                    };
-                }
-                const body = {};
-                if (params.path !== undefined)
-                    body.path = params.path;
-                if (params.method !== undefined)
-                    body.method = params.method;
-                if (params.summary !== undefined)
-                    body.summary = params.summary;
-                if (params.description !== undefined)
-                    body.description = params.description;
-                if (params.tags !== undefined)
-                    body.tags = params.tags;
-                if (params.auth_required !== undefined)
-                    body.authRequired = params.auth_required;
-                if (params.deprecated !== undefined)
-                    body.deprecated = params.deprecated;
-                if (params.endpoint_type !== undefined)
-                    body.endpointType = params.endpoint_type;
-                if (params.request_template !== undefined)
-                    body.requestTemplate = params.request_template;
-                if (params.response_path !== undefined)
-                    body.responsePath = params.response_path;
-                if (params.streaming_enabled !== undefined) {
-                    body.streamingEnabled = params.streaming_enabled;
-                }
-                data = await apiClient.patch(`/api/rt/applications/${applicationId}/endpoints/${params.endpoint_id}`, body);
-            }
-            else if (action === "delete") {
-                if (!params.endpoint_id) {
-                    return {
-                        content: [
-                            { type: "text", text: "Error: endpoint_id is required for delete" },
-                        ],
-                        isError: true,
-                    };
-                }
-                data = await apiClient.del(`/api/rt/applications/${applicationId}/endpoints/${params.endpoint_id}`);
-            }
-            else if (action === "bulk_delete") {
-                if (!params.source) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "Error: source is required for bulk_delete (openapi/manual/discovery)",
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                data = await apiClient.del(`/api/rt/applications/${applicationId}/endpoints?source=${encodeURIComponent(params.source)}`);
-            }
-            else {
-                data = await apiClient.post(`/api/rt/applications/${applicationId}/endpoints/import-openapi`, {
-                    specUrl: params.spec_url,
-                    specContent: params.spec_content,
-                    replaceExisting: params.replace_existing ?? false,
-                });
-            }
-            const sanitized = sanitizeResponse({
-                action,
-                application_id: applicationId,
-                endpoint_id: params.endpoint_id,
-                result: data,
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify(sanitized, null, 2) }],
-            };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : "Failed to manage endpoint lifecycle";
-            return {
-                content: [{ type: "text", text: `Error: ${message}` }],
-                isError: true,
-            };
-        }
-    };
-}

package/dist/tools/security-review.d.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import type { ApiClient } from "../api-client.js";
-import type { ZivisConfig } from "../types.js";
-export declare const SECURITY_REVIEW_NAME = "zivis_security_review";
-export declare const SECURITY_REVIEW_DESCRIPTION = "Gather ZIVIS security intelligence for an AI-powered code review.\n\nPulls historical findings and open vulnerabilities to give you comprehensive security context. Use this BEFORE reviewing code to understand:\n\n1. **Regression risks** \u2014 Previously fixed vulnerabilities that could be reintroduced\n2. **Known vulnerabilities** \u2014 Open findings that may be relevant to the code being reviewed\n\nReturns structured security context that you should reference during code review. Focus on:\n- Code that touches areas where historical findings were fixed (regression check)\n\nFor dependency risk, use `zivis test dependencies` instead \u2014 this tool no longer checks dependencies.\n\nProvide at least one of: repo or application_id.";
-export declare const SECURITY_REVIEW_SCHEMA: {
-    repo: z.ZodOptional<z.ZodString>;
-    application_id: z.ZodOptional<z.ZodString>;
-    focus_areas: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        regression: "regression";
-        all: "all";
-    }>>>;
-    severity_threshold: z.ZodOptional<z.ZodEnum<{
-        critical: "critical";
-        high: "high";
-        medium: "medium";
-        low: "low";
-        info: "info";
-    }>>;
-    include_resolved: z.ZodDefault<z.ZodBoolean>;
-};
-export declare function createSecurityReviewHandler(apiClient: ApiClient, _config: ZivisConfig): (params: {
-    repo?: string;
-    application_id?: string;
-    focus_areas?: string[];
-    severity_threshold?: string;
-    include_resolved?: boolean;
-}) => Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    isError?: undefined;
-}>;

package/dist/tools/security-review.js

@@ -1,199 +0,0 @@
-import { z } from "zod";
-import { resolveApplicationId } from "../resolve-application-id.js";
-import { sanitizeResponse } from "../sanitize.js";
-export const SECURITY_REVIEW_NAME = "zivis_security_review";
-export const SECURITY_REVIEW_DESCRIPTION = `Gather ZIVIS security intelligence for an AI-powered code review.
-
-Pulls historical findings and open vulnerabilities to give you comprehensive security context. Use this BEFORE reviewing code to understand:
-
-1. **Regression risks** — Previously fixed vulnerabilities that could be reintroduced
-2. **Known vulnerabilities** — Open findings that may be relevant to the code being reviewed
-
-Returns structured security context that you should reference during code review. Focus on:
-- Code that touches areas where historical findings were fixed (regression check)
-
-For dependency risk, use \`zivis test dependencies\` instead — this tool no longer checks dependencies.
-
-Provide at least one of: repo or application_id.`;
-export const SECURITY_REVIEW_SCHEMA = {
-    repo: z.string().optional().describe("Repository name (owner/repo) — pulls findings scoped to this repo"),
-    application_id: z
-        .string()
-        .optional()
-        .describe("Application UUID — pulls findings scoped to this app. If omitted, uses applicationId from .zivis/project.json when set."),
-    focus_areas: z
-        .array(z.enum(["regression", "all"]))
-        .optional()
-        .describe("Which intelligence to gather (default: all)"),
-    severity_threshold: z
-        .enum(["critical", "high", "medium", "low", "info"])
-        .optional()
-        .describe("Minimum severity to include (default: low)"),
-    include_resolved: z
-        .boolean()
-        .default(true)
-        .describe("Include resolved findings for regression checking (default: true)"),
-};
-const SEVERITY_ORDER = {
-    critical: 5,
-    high: 4,
-    medium: 3,
-    low: 2,
-    info: 1,
-};
-export function createSecurityReviewHandler(apiClient, _config) {
-    return async (params) => {
-        const { repo, application_id: application_idParam, focus_areas = ["all"], severity_threshold = "low", include_resolved = true, } = params;
-        const application_id = resolveApplicationId(application_idParam);
-        if (!repo && !application_id) {
-            return {
-                content: [{
-                        type: "text",
-                        text: "Error: Provide at least one of: repo or application_id — " +
-                            "or run `zivis init` to connect this repository to a ZIVIS Application " +
-                            "so application_id resolves automatically.",
-                    }],
-                isError: true,
-            };
-        }
-        const shouldInclude = (area) => focus_areas.includes("all") || focus_areas.includes(area);
-        const context = {
-            _description: "ZIVIS Security Review Context — use this intelligence during code review",
-            generatedAt: new Date().toISOString(),
-            parameters: { repo, application_id },
-        };
-        const errors = [];
-        if (shouldInclude("regression") && (repo || application_id)) {
-            try {
-                const resolvedFindings = await fetchFindings(apiClient, {
-                    repo,
-                    status: "resolved",
-                    limit: 50,
-                });
-                const dismissedFindings = await fetchFindings(apiClient, {
-                    repo,
-                    status: "false_positive",
-                    limit: 20,
-                });
-                const regressionPatterns = buildRegressionPatterns(resolvedFindings);
-                context.regressionCheck = {
-                    _instruction: "Check code changes against these previously fixed vulnerabilities. Flag if similar patterns appear.",
-                    resolvedCount: resolvedFindings.length,
-                    patterns: regressionPatterns,
-                    recentlyFixed: resolvedFindings.slice(0, 10).map(summarizeFinding),
-                    falsePositives: dismissedFindings.slice(0, 5).map(summarizeFinding),
-                };
-            }
-            catch (err) {
-                errors.push(`Regression data: ${err instanceof Error ? err.message : "failed"}`);
-            }
-        }
-        if (shouldInclude("regression") && (repo || application_id)) {
-            try {
-                const minSeverity = SEVERITY_ORDER[severity_threshold] || 2;
-                const openFindings = await fetchFindings(apiClient, {
-                    repo,
-                    status: "open",
-                    limit: 50,
-                });
-                const filtered = openFindings.filter((f) => (SEVERITY_ORDER[f.severity] || 1) >= minSeverity);
-                context.openVulnerabilities = {
-                    _instruction: "These are KNOWN open vulnerabilities. Check if code changes interact with or worsen these issues.",
-                    count: filtered.length,
-                    bySeverity: countBySeverity(filtered),
-                    findings: filtered.slice(0, 20).map(summarizeFinding),
-                };
-            }
-            catch (err) {
-                errors.push(`Open findings: ${err instanceof Error ? err.message : "failed"}`);
-            }
-        }
-        context.reviewGuidance = buildReviewGuidance(context);
-        if (errors.length > 0) {
-            context.warnings = errors;
-        }
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify(sanitizeResponse(context), null, 2),
-                }],
-        };
-    };
-}
-async function fetchFindings(apiClient, params) {
-    const query = new URLSearchParams();
-    if (params.repo)
-        query.set("resourceName", params.repo);
-    if (params.status)
-        query.set("status", params.status);
-    if (params.limit)
-        query.set("limit", String(params.limit));
-    const path = `/api/findings/unified?${query.toString()}`;
-    const data = await apiClient.get(path);
-    return data.findings || [];
-}
-function summarizeFinding(f) {
-    return {
-        title: f.title,
-        severity: f.severity,
-        category: f.category,
-        cweId: f.cweId,
-        status: f.status,
-        targetUrl: f.targetUrl,
-        description: f.description?.substring(0, 300),
-        remediation: f.recommendation?.substring(0, 300) || f.remediation?.substring(0, 300),
-    };
-}
-function countBySeverity(findings) {
-    const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
-    for (const f of findings) {
-        const sev = f.severity || "info";
-        counts[sev] = (counts[sev] || 0) + 1;
-    }
-    return counts;
-}
-function buildRegressionPatterns(resolvedFindings) {
-    const patternMap = new Map();
-    for (const f of resolvedFindings) {
-        const key = `${f.category || "uncategorized"}::${f.cweId || "no-cwe"}`;
-        const existing = patternMap.get(key);
-        if (existing) {
-            existing.count++;
-            if (existing.titles.length < 3)
-                existing.titles.push(f.title);
-        }
-        else {
-            patternMap.set(key, {
-                count: 1,
-                titles: [f.title],
-                cweId: f.cweId,
-                category: f.category,
-            });
-        }
-    }
-    return Array.from(patternMap.values())
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 15)
-        .map((p) => ({
-        category: p.category,
-        cweId: p.cweId,
-        occurrences: p.count,
-        examples: p.titles,
-        _check: `Previously fixed ${p.count}x — verify this pattern is not reintroduced`,
-    }));
-}
-function buildReviewGuidance(context) {
-    const guidance = [];
-    const regression = context.regressionCheck;
-    if (regression?.resolvedCount > 0) {
-        guidance.push(`REGRESSION: ${regression.resolvedCount} previously fixed vulnerabilities. Check ${regression.patterns?.length || 0} recurring patterns.`);
-    }
-    const open = context.openVulnerabilities;
-    if (open?.count > 0) {
-        guidance.push(`OPEN VULNS: ${open.count} known vulnerabilities (${open.bySeverity?.critical || 0} critical, ${open.bySeverity?.high || 0} high). Verify changes don't worsen these.`);
-    }
-    if (guidance.length === 0) {
-        guidance.push("No significant security context found. Perform standard code review best practices.");
-    }
-    return guidance;
-}

package/dist/tools/threat-get-capsule.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod";
-export declare const THREAT_GET_CAPSULE_NAME = "zivis_threat_get_capsule";
-export declare const THREAT_GET_CAPSULE_DESCRIPTION = "Return the full capsule for a single threat-model pattern.\n\nUse after zivis_threat_list_relevant_capsules has surfaced an id the user wants to dig into. The capsule includes:\n- safe_summary, detect_when, risk_hints, architectural_signals \u2014 for explaining the pattern in threat-model language\n- threats[] with STRIDE categories and remediations \u2014 for grounding the conversation in component/flow/boundary terms\n- repair_contract.allowed / forbidden \u2014 what refactors are safe\n- related_patterns \u2014 adjacent ids in the library\n- model_task_prompt_ref \u2014 pass to zivis_threat_get_inference_prompt to get the prompt the host LLM should run for a deeper check\n\nCapsule data is read from the local pack (~/Library/Caches/zivis/pattern-packs/) with SHA256 integrity verification on every read.";
-export declare const THREAT_GET_CAPSULE_SCHEMA: {
-    capsule_id: z.ZodString;
-};
-export declare function createThreatGetCapsuleHandler(): (params: {
-    capsule_id: string;
-}) => Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    isError?: boolean;
-}>;

package/dist/tools/threat-get-capsule.js

@@ -1,53 +0,0 @@
-import { z } from "zod";
-import { loadActivePack, getCapsule, listCapsuleIds } from "../pattern-pack/index.js";
-import { withNextSteps, withNextStepsError } from "../lib/next-steps.js";
-export const THREAT_GET_CAPSULE_NAME = "zivis_threat_get_capsule";
-export const THREAT_GET_CAPSULE_DESCRIPTION = `Return the full capsule for a single threat-model pattern.
-
-Use after zivis_threat_list_relevant_capsules has surfaced an id the user wants to dig into. The capsule includes:
-- safe_summary, detect_when, risk_hints, architectural_signals — for explaining the pattern in threat-model language
-- threats[] with STRIDE categories and remediations — for grounding the conversation in component/flow/boundary terms
-- repair_contract.allowed / forbidden — what refactors are safe
-- related_patterns — adjacent ids in the library
-- model_task_prompt_ref — pass to zivis_threat_get_inference_prompt to get the prompt the host LLM should run for a deeper check
-
-Capsule data is read from the local pack (~/Library/Caches/zivis/pattern-packs/) with SHA256 integrity verification on every read.`;
-export const THREAT_GET_CAPSULE_SCHEMA = {
-    capsule_id: z
-        .string()
-        .describe("Capsule id, e.g. 'agents.privilege-separation'. Discoverable via zivis_threat_list_relevant_capsules."),
-};
-export function createThreatGetCapsuleHandler() {
-    return async (params) => {
-        const handle = await loadActivePack();
-        let capsule;
-        try {
-            capsule = await getCapsule(handle, params.capsule_id);
-        }
-        catch (err) {
-            const ids = await listCapsuleIds(handle);
-            return withNextStepsError(`Capsule '${params.capsule_id}' not found in pack ${handle.manifest.pack_id}@${handle.manifest.version}. ${err.message}`, [
-                {
-                    id: "list_relevant_capsules_first",
-                    label: "Find relevant capsules for the current repo first",
-                    tool: "zivis_threat_list_relevant_capsules",
-                    why: "Returns ids you can pass back into zivis_threat_get_capsule.",
-                },
-            ], `Available capsule ids in this pack: ${ids.join(", ")}`);
-        }
-        return withNextSteps({
-            pack: { id: handle.manifest.pack_id, version: handle.manifest.version },
-            capsule,
-        }, capsule.model_task_prompt_ref
-            ? [
-                {
-                    id: "get_inference_prompt",
-                    label: "Get the inference prompt template the host LLM should run",
-                    tool: "zivis_threat_get_inference_prompt",
-                    args_hint: { capsule_id: capsule.id },
-                    why: "Inference prompt + expected_output_schema together form the prompt bundle the IDE LLM executes.",
-                },
-            ]
-            : [], `Capsule ${capsule.id}@${capsule.version} (${capsule.lifecycle}, ${capsule.sensitivity_level ?? "unspecified-tier"}). Threats: ${(capsule.threats?.length ?? 0)}.`);
-    };
-}

package/dist/tools/threat-get-inference-prompt.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod";
-export declare const THREAT_GET_INFERENCE_PROMPT_NAME = "zivis_threat_get_inference_prompt";
-export declare const THREAT_GET_INFERENCE_PROMPT_DESCRIPTION = "Return the prompt bundle for the host LLM to run local inference for a capsule.\n\nZIVIS doesn't run an LLM itself \u2014 the host (Cursor, Claude Code, etc.) does. This tool returns the prompt template + structured output schema + ambient capsule context so the host model can run the inference and produce JSON the inferred lane accepts.\n\nUse this when:\n- After zivis_threat_get_capsule, the user wants the host LLM to actually evaluate whether the pattern is present in the code\n- The user says \"go check if my code does this\" / \"is this pattern actually in my repo\"\n- The matcher emits an INFER candidate that needs host-LLM evaluation\n\nThe bundle includes:\n- prompt: the markdown inference prompt\n- expected_output_schema: JSON Schema for the structured response\n- safe_summary: ambient capsule context\n- minimum_context_required: hint to the host for how much code to attach\n- evidence_focus: spans the deterministic strategies already flagged\n\nThe host LLM is expected to gather the indicated code spans, fill in the prompt, return JSON matching the schema. That output then flows back into the inferred lane.";
-export declare const THREAT_GET_INFERENCE_PROMPT_SCHEMA: {
-    capsule_id: z.ZodString;
-};
-export declare function createThreatGetInferencePromptHandler(): (params: {
-    capsule_id: string;
-}) => Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    isError?: boolean;
-}>;

package/dist/tools/threat-get-inference-prompt.js

@@ -1,73 +0,0 @@
-import { z } from "zod";
-import { loadActivePack, getCapsule, getInferencePrompt } from "../pattern-pack/index.js";
-import { withNextSteps, withNextStepsError } from "../lib/next-steps.js";
-export const THREAT_GET_INFERENCE_PROMPT_NAME = "zivis_threat_get_inference_prompt";
-export const THREAT_GET_INFERENCE_PROMPT_DESCRIPTION = `Return the prompt bundle for the host LLM to run local inference for a capsule.
-
-ZIVIS doesn't run an LLM itself — the host (Cursor, Claude Code, etc.) does. This tool returns the prompt template + structured output schema + ambient capsule context so the host model can run the inference and produce JSON the inferred lane accepts.
-
-Use this when:
-- After zivis_threat_get_capsule, the user wants the host LLM to actually evaluate whether the pattern is present in the code
-- The user says "go check if my code does this" / "is this pattern actually in my repo"
-- The matcher emits an INFER candidate that needs host-LLM evaluation
-
-The bundle includes:
-- prompt: the markdown inference prompt
-- expected_output_schema: JSON Schema for the structured response
-- safe_summary: ambient capsule context
-- minimum_context_required: hint to the host for how much code to attach
-- evidence_focus: spans the deterministic strategies already flagged
-
-The host LLM is expected to gather the indicated code spans, fill in the prompt, return JSON matching the schema. That output then flows back into the inferred lane.`;
-export const THREAT_GET_INFERENCE_PROMPT_SCHEMA = {
-    capsule_id: z
-        .string()
-        .describe("Capsule id whose INFER prompt should be returned (e.g. 'agents.privilege-separation')."),
-};
-export function createThreatGetInferencePromptHandler() {
-    return async (params) => {
-        const handle = await loadActivePack();
-        let capsule;
-        try {
-            capsule = await getCapsule(handle, params.capsule_id);
-        }
-        catch (err) {
-            return withNextStepsError(`Capsule '${params.capsule_id}' not found. ${err.message}`, [
-                {
-                    id: "list_relevant_capsules_first",
-                    label: "List relevant capsules for the current repo first",
-                    tool: "zivis_threat_list_relevant_capsules",
-                    why: "Returns ids you can pass back here.",
-                },
-            ], "Capsule not found — list first to discover ids.");
-        }
-        if (!capsule.model_task_prompt_ref) {
-            return withNextStepsError(`Capsule '${capsule.id}' has no inference prompt defined (model_task_prompt_ref missing). This capsule is deterministic-only.`, [
-                {
-                    id: "get_capsule",
-                    label: "Read the full capsule to see its deterministic strategies",
-                    tool: "zivis_threat_get_capsule",
-                    args_hint: { capsule_id: capsule.id },
-                    why: "Some capsules have no INFER strategy — only AST/GRAPH/META/etc. that the matcher runs locally.",
-                },
-            ], "No inference prompt for this capsule (deterministic only).");
-        }
-        const promptText = await getInferencePrompt(handle, capsule.model_task_prompt_ref);
-        return withNextSteps({
-            pack: { id: handle.manifest.pack_id, version: handle.manifest.version },
-            capsule_id: capsule.id,
-            prompt: promptText,
-            expected_output_schema: capsule.expected_output_schema ?? null,
-            safe_summary: capsule.safe_summary ?? null,
-            minimum_context_required: capsule.minimum_context_required ?? null,
-            host_instructions: "Gather the code spans indicated by minimum_context_required.symbols (or any deterministic match spans the matcher already flagged), attach them to the prompt above, run inference with your model, and return JSON matching expected_output_schema. The structured output flows back into the inferred lane.",
-        }, [
-            {
-                id: "host_runs_inference",
-                label: "Host LLM runs inference now (no further tool call)",
-                tool: "zivis_threat_get_inference_prompt",
-                why: "MCP cannot invoke your model. The host orchestrates the inference using this bundle.",
-            },
-        ], `Prompt bundle ready for host-side inference of ${capsule.id}.`);
-    };
-}

package/dist/tools/threat-list-relevant-capsules.d.ts

@@ -1,17 +0,0 @@
-import { z } from "zod";
-export declare const THREAT_LIST_RELEVANT_CAPSULES_NAME = "zivis_threat_list_relevant_capsules";
-export declare const THREAT_LIST_RELEVANT_CAPSULES_DESCRIPTION = "List threat-model patterns relevant to the user's current repo.\n\nUse this when the user asks any of:\n- \"what should I be worried about in this code\"\n- \"what threats apply to my app\"\n- \"are there known patterns that match my architecture\"\n- \"what's in my threat model\"\n- mid-conversation when the user describes a feature that touches deps the threat library covers\n\nReads the latest local repo graph artifact (produced by 'zivis inspect') from the user cache, runs every capsule's relevance_filter against it, and returns the subset whose filter passes \u2014 together with each capsule's safe_summary so you can frame the conversation in threat-model terms (component, flow, trust boundary, scenario).\n\nIf no graph artifact exists yet for this repo, the tool returns a next-step pointing to 'zivis inspect'. Always speak in threat-model vocabulary even when the user doesn't.";
-export declare const THREAT_LIST_RELEVANT_CAPSULES_SCHEMA: {
-    artifact_path: z.ZodOptional<z.ZodString>;
-    cwd: z.ZodOptional<z.ZodString>;
-};
-export declare function createThreatListRelevantCapsulesHandler(): (params: {
-    artifact_path?: string;
-    cwd?: string;
-}) => Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    isError?: boolean;
-}>;