@zivis/mcp 0.1.0-alpha.26 → 0.1.0-alpha.3

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-guide.d.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-import type { ApiClient } from "../api-client.js";
-export declare const THREAT_GUIDE_NAME = "zivis_threat_guide";
-export declare const THREAT_GUIDE_DESCRIPTION = "Per-turn grounding for the IDE assistant. ZIVIS is not the analyst here \u2014 you are. ZIVIS is the structured grounding layer that makes you smarter about THIS specific codebase: graph, pattern library, threat-model state, enterprise-readiness gaps. Read context_for_host_llm and use it to inform your reply. The user does not need to see the raw fields \u2014 incorporate them as you would any other grounding.\n\nReads the local inspect cache and will not nag the user to re-inspect if a recent run exists. Call this on every conversation turn that touches code, architecture, integrations, dependencies, security, or a launch.\n\nUse this when the user says any of:\n- \"we just added <X>\" / \"we're going to integrate <X>\" / \"we're using <library>\"\n- \"<service A> calls / sends to / fetches from <service B>\"\n- describes any user role, attacker, partner, or external system\n- \"what if <bad thing>?\" / \"could someone <attack>?\" / \"is this safe?\"\n- \"we store <data type>\" / \"we process <PII / payments / credentials>\"\n- \"we added <encryption / rate limiting / WAF / audit logging>\"\n- mentions of launch, audit, compliance, customer ask, regulated buyer\n- any architecture or security clarification request\n\nHow to use the response:\n\nGROUNDING (use silently to inform your reply, do not echo verbatim):\n- context_for_host_llm.graph_summary \u2014 what ZIVIS sees in this repo. Use this to ground your reply in their actual architecture.\n- context_for_host_llm.matched_patterns \u2014 pattern-library matches against the graph. Treat as signals, NOT verdicts. Decide what's actually relevant given what the user just said. False positives are expected; you are the filter.\n- context_for_host_llm.applicable_patterns \u2014 patterns ZIVIS thinks the user could adopt or is bumping into. Surface to the user only when relevant to their utterance.\n- context_for_host_llm.github_app \u2014 Lane-2 conversion grounding. When installed=false, the user has not yet linked their repo to ZIVIS. Surface the install_url ONLY when the user asks about continuous monitoring, CI integration, automated PR scanning, or how ZIVIS picks up code changes \u2014 do not interrupt other conversations to push this.\n- readiness_gaps \u2014 enterprise-readiness artifacts the user hasn't yet built (no threat model, no documented data flows, etc.). Useful for \"is this ready for procurement\" or \"what's missing\" questions. Do not lecture if the user didn't ask.\n- vocabulary_map + teaching_note \u2014 a concept the user is unknowingly bumping into. Weave the term into your reply naturally; don't deliver a lesson.\n\nACTION (act on if the user shows interest, not before):\n- next_action.type === \"call_tool\" \u2192 suggest calling next_action.tool with next_action.args_preview. Confirm with the user before calling unless the call is obviously safe (read-only).\n- next_action.type === \"ask_user\" \u2192 ask next_action.question (use it verbatim or paraphrase).\n- next_action.type === \"run_inspect_first\" \u2192 call zivis_inspect to bootstrap the threat model. (Suppressed automatically if a fresh local artifact exists.)\n- next_action.type === \"no_action\" \u2192 continue the conversation; no ZIVIS-side write is needed.\n\nPRODUCED ARTIFACTS (informational):\n- produced_artifacts \u2014 what this turn added to the user's accumulating record on ZIVIS. Mention if relevant (\"ZIVIS just captured this data flow\"); otherwise stay silent.\n\nThe user is paying $20/mo + credits for this grounding. Make every turn feel like ZIVIS is contributing structure \u2014 not analysis. If you find yourself echoing ZIVIS's matched_patterns or readiness_gaps as a checklist, you're doing it wrong; the user wanted a conversation, not a report.\n\nInputs are all optional. If user_utterance is empty, the response is driven by the highest-priority gap \u2014 useful for \"what should I work on next?\" prompts.";
-export declare const THREAT_GUIDE_SCHEMA: {
-    user_utterance: z.ZodOptional<z.ZodString>;
-    application_id: z.ZodOptional<z.ZodString>;
-    context_hint: z.ZodOptional<z.ZodEnum<{
-        code_change: "code_change";
-        architecture_question: "architecture_question";
-        security_worry: "security_worry";
-        feature: "feature";
-        unknown: "unknown";
-    }>>;
-    cwd: z.ZodOptional<z.ZodString>;
-};
-export declare function createThreatGuideHandler(apiClient: ApiClient): (params: {
-    user_utterance?: string;
-    application_id?: string;
-    context_hint?: "code_change" | "architecture_question" | "security_worry" | "feature" | "unknown";
-    cwd?: string;
-}) => Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    isError?: boolean;
-}>;

package/dist/tools/threat-guide.js

@@ -1,175 +0,0 @@
-import { z } from "zod";
-import { withNextSteps, withNextStepsError } from "../lib/next-steps.js";
-import { locateLatestArtifact, isFresh, inspectCacheTtlMs, } from "../lib/inspect-cache.js";
-export const THREAT_GUIDE_NAME = "zivis_threat_guide";
-export const THREAT_GUIDE_DESCRIPTION = `Per-turn grounding for the IDE assistant. ZIVIS is not the analyst here — you are. ZIVIS is the structured grounding layer that makes you smarter about THIS specific codebase: graph, pattern library, threat-model state, enterprise-readiness gaps. Read context_for_host_llm and use it to inform your reply. The user does not need to see the raw fields — incorporate them as you would any other grounding.
-
-Reads the local inspect cache and will not nag the user to re-inspect if a recent run exists. Call this on every conversation turn that touches code, architecture, integrations, dependencies, security, or a launch.
-
-Use this when the user says any of:
-- "we just added <X>" / "we're going to integrate <X>" / "we're using <library>"
-- "<service A> calls / sends to / fetches from <service B>"
-- describes any user role, attacker, partner, or external system
-- "what if <bad thing>?" / "could someone <attack>?" / "is this safe?"
-- "we store <data type>" / "we process <PII / payments / credentials>"
-- "we added <encryption / rate limiting / WAF / audit logging>"
-- mentions of launch, audit, compliance, customer ask, regulated buyer
-- any architecture or security clarification request
-
-How to use the response:
-
-GROUNDING (use silently to inform your reply, do not echo verbatim):
-- context_for_host_llm.graph_summary — what ZIVIS sees in this repo. Use this to ground your reply in their actual architecture.
-- context_for_host_llm.matched_patterns — pattern-library matches against the graph. Treat as signals, NOT verdicts. Decide what's actually relevant given what the user just said. False positives are expected; you are the filter.
-- context_for_host_llm.applicable_patterns — patterns ZIVIS thinks the user could adopt or is bumping into. Surface to the user only when relevant to their utterance.
-- context_for_host_llm.github_app — Lane-2 conversion grounding. When installed=false, the user has not yet linked their repo to ZIVIS. Surface the install_url ONLY when the user asks about continuous monitoring, CI integration, automated PR scanning, or how ZIVIS picks up code changes — do not interrupt other conversations to push this.
-- readiness_gaps — enterprise-readiness artifacts the user hasn't yet built (no threat model, no documented data flows, etc.). Useful for "is this ready for procurement" or "what's missing" questions. Do not lecture if the user didn't ask.
-- vocabulary_map + teaching_note — a concept the user is unknowingly bumping into. Weave the term into your reply naturally; don't deliver a lesson.
-
-ACTION (act on if the user shows interest, not before):
-- next_action.type === "call_tool" → suggest calling next_action.tool with next_action.args_preview. Confirm with the user before calling unless the call is obviously safe (read-only).
-- next_action.type === "ask_user" → ask next_action.question (use it verbatim or paraphrase).
-- next_action.type === "run_inspect_first" → call zivis_inspect to bootstrap the threat model. (Suppressed automatically if a fresh local artifact exists.)
-- next_action.type === "no_action" → continue the conversation; no ZIVIS-side write is needed.
-
-PRODUCED ARTIFACTS (informational):
-- produced_artifacts — what this turn added to the user's accumulating record on ZIVIS. Mention if relevant ("ZIVIS just captured this data flow"); otherwise stay silent.
-
-The user is paying $20/mo + credits for this grounding. Make every turn feel like ZIVIS is contributing structure — not analysis. If you find yourself echoing ZIVIS's matched_patterns or readiness_gaps as a checklist, you're doing it wrong; the user wanted a conversation, not a report.
-
-Inputs are all optional. If user_utterance is empty, the response is driven by the highest-priority gap — useful for "what should I work on next?" prompts.`;
-export const THREAT_GUIDE_SCHEMA = {
-    user_utterance: z
-        .string()
-        .max(2000)
-        .optional()
-        .describe("Verbatim or near-verbatim of what the user just said. Pass the user's actual words — the classifier reads phrasing cues (verbs, vendor names, role nouns). Omit only when the user is asking 'what should I do next?' with no specific topic."),
-    application_id: z
-        .string()
-        .optional()
-        .describe("Application UUID. If omitted, uses applicationId from .zivis/project.json when set. Required when the binding doesn't resolve a unique app."),
-    context_hint: z
-        .enum(["code_change", "architecture_question", "security_worry", "feature", "unknown"])
-        .optional()
-        .describe("Optional hint about the kind of turn this is. Helps the classifier disambiguate. If unsure, omit or pass 'unknown'."),
-    cwd: z
-        .string()
-        .optional()
-        .describe("Working directory to derive repo identity from when checking the local inspect cache. Defaults to server cwd."),
-};
-export function createThreatGuideHandler(apiClient) {
-    return async (params) => {
-        const cwd = params.cwd ?? process.cwd();
-        let localArtifact;
-        try {
-            localArtifact = await locateLatestArtifact(cwd);
-        }
-        catch {
-            localArtifact = undefined;
-        }
-        const localFresh = !!localArtifact && isFresh(localArtifact.mtimeMs);
-        try {
-            const result = await apiClient.request("POST", "/api/mcp/guide", {
-                user_utterance: params.user_utterance,
-                application_id: params.application_id,
-                context_hint: params.context_hint,
-                local_inspect_mtime_ms: localArtifact?.mtimeMs,
-                local_inspect_fresh: localFresh,
-            });
-            let cacheOverrideNote;
-            if (result.next_action.type === "run_inspect_first" && localArtifact && localFresh) {
-                const ageMin = Math.max(0, Math.round((Date.now() - localArtifact.mtimeMs) / 60000));
-                cacheOverrideNote = `Inspect already fresh (${ageMin}m ago, TTL ${Math.round(inspectCacheTtlMs() / 60000)}m). Using cached graph at ${localArtifact.path} — skipping re-inspection.`;
-                result.next_action = {
-                    type: "call_tool",
-                    tool: "zivis_threat_run_matcher",
-                    args_preview: { artifact_path: localArtifact.path, cwd },
-                    follow_up: cacheOverrideNote,
-                    original_action: "run_inspect_first",
-                };
-            }
-            const next = result.next_action;
-            const nextSteps = [];
-            if (next.type === "call_tool") {
-                nextSteps.push({
-                    id: "execute_suggested_tool",
-                    label: `Call ${next.tool} with the suggested args`,
-                    tool: String(next.tool),
-                    args_hint: next.args_preview ?? {},
-                    why: next.follow_up ??
-                        "The threat-guide endpoint mapped this utterance to a concrete graph operation.",
-                });
-            }
-            else if (next.type === "ask_user") {
-                nextSteps.push({
-                    id: "ask_clarifying_question",
-                    label: "Ask the user this clarifying question",
-                    tool: "zivis_threat_guide",
-                    args_hint: {},
-                    why: String(next.question ?? "Need more info before acting on the graph."),
-                });
-            }
-            else if (next.type === "run_inspect_first") {
-                nextSteps.push({
-                    id: "run_inspect",
-                    label: "Run /inspect to bootstrap the threat model from the repo",
-                    tool: "zivis_inspect",
-                    args_hint: {},
-                    why: "The threat model is empty — bootstrap from the repo before modeling further.",
-                });
-            }
-            let githubAppStatus;
-            try {
-                const ghResp = await apiClient.request("GET", "/api/github-app/status", undefined);
-                githubAppStatus = {
-                    installed: ghResp.installed,
-                    install_url: ghResp.installUrl,
-                    next_step: ghResp.installed
-                        ? undefined
-                        : ghResp.installUrl
-                            ? `Install the ZIVIS GitHub App at ${ghResp.installUrl} to enable continuous monitoring on push.`
-                            : undefined,
-                };
-            }
-            catch {
-            }
-            const baseContext = result.context_for_host_llm ?? {
-                graph_summary: undefined,
-                matched_patterns: [],
-                applicable_patterns: [],
-            };
-            const enriched = {
-                ...result,
-                context_for_host_llm: {
-                    ...baseContext,
-                    ...(githubAppStatus ? { github_app: githubAppStatus } : {}),
-                },
-                readiness_gaps: result.readiness_gaps ?? [],
-                produced_artifacts: result.produced_artifacts ?? [],
-                local_inspect_cache: localArtifact
-                    ? {
-                        artifact_path: localArtifact.path,
-                        mtime_ms: localArtifact.mtimeMs,
-                        fresh: localFresh,
-                        ttl_ms: inspectCacheTtlMs(),
-                        override_applied: !!cacheOverrideNote,
-                    }
-                    : { artifact_path: null, fresh: false, ttl_ms: inspectCacheTtlMs() },
-            };
-            return withNextSteps(enriched, nextSteps, next.type === "no_action"
-                ? "No graph operation needed for this turn — continue conversationally."
-                : `Next: ${next.type === "call_tool" ? `call ${next.tool}` : next.type === "ask_user" ? "ask the clarifying question" : next.type}`);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : "threat_guide call failed";
-            return withNextStepsError(message, [
-                {
-                    id: "check_project",
-                    label: "Verify project binding + auth",
-                    tool: "zivis_check_project",
-                    why: "If the call failed because of auth or binding, this surfaces the specific fix.",
-                },
-            ], "threat_guide call failed — check binding/auth.");
-        }
-    };
-}

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;
-}>;

package/dist/tools/threat-list-relevant-capsules.js

@@ -1,158 +0,0 @@
-import { z } from "zod";
-import * as fs from "node:fs/promises";
-import * as fssync from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { loadActivePack, findRelevantCapsules, } from "../pattern-pack/index.js";
-import { withNextSteps, withNextStepsError } from "../lib/next-steps.js";
-export const THREAT_LIST_RELEVANT_CAPSULES_NAME = "zivis_threat_list_relevant_capsules";
-export const THREAT_LIST_RELEVANT_CAPSULES_DESCRIPTION = `List threat-model patterns relevant to the user's current repo.
-
-Use this when the user asks any of:
-- "what should I be worried about in this code"
-- "what threats apply to my app"
-- "are there known patterns that match my architecture"
-- "what's in my threat model"
-- mid-conversation when the user describes a feature that touches deps the threat library covers
-
-Reads 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 — together with each capsule's safe_summary so you can frame the conversation in threat-model terms (component, flow, trust boundary, scenario).
-
-If 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 const THREAT_LIST_RELEVANT_CAPSULES_SCHEMA = {
-    artifact_path: z
-        .string()
-        .optional()
-        .describe("Optional path to a specific RepoGraphArtifactV1 JSON. If omitted, the tool finds the most recent artifact in ~/Library/Caches/zivis/repos/<repo-id>/inspect/runs/ for the repo at cwd."),
-    cwd: z
-        .string()
-        .optional()
-        .describe("Working directory whose repo cache to search (defaults to server cwd)."),
-};
-export function createThreatListRelevantCapsulesHandler() {
-    return async (params) => {
-        const cwd = params.cwd ?? process.cwd();
-        let artifact;
-        let artifactPath;
-        try {
-            const resolved = await resolveArtifactPath(params.artifact_path, cwd);
-            artifactPath = resolved;
-            const raw = await fs.readFile(resolved, "utf8");
-            artifact = JSON.parse(raw);
-        }
-        catch (err) {
-            return withNextStepsError(`No repo graph artifact found. ${err.message}`, [
-                {
-                    id: "run_zivis_inspect",
-                    label: "Run `zivis inspect` to build the local repo graph",
-                    tool: "zivis_inspect",
-                    why: "The relevance evaluation reads from the latest inspect run in the user cache.",
-                },
-            ], "Run `zivis inspect` first; this tool reads from its output.");
-        }
-        const handle = await loadActivePack();
-        const relevant = await findRelevantCapsules(handle, artifact);
-        const summaries = relevant.map((cap) => ({
-            id: cap.id,
-            title: cap.title,
-            category: cap.category,
-            safe_summary: cap.safe_summary,
-            applicable_languages: cap.applicable_languages,
-            matched_on: matchedTerms(cap, artifact),
-        }));
-        return withNextSteps({
-            artifact_path: artifactPath,
-            pack: { id: handle.manifest.pack_id, version: handle.manifest.version },
-            languages_in_scope: artifact.scope.languages ?? [],
-            relevant_count: summaries.length,
-            relevant_capsules: summaries,
-        }, summaries.length > 0
-            ? [
-                {
-                    id: "get_capsule_details",
-                    label: "Pull the full capsule for any item the user wants to investigate",
-                    tool: "zivis_threat_get_capsule",
-                    why: "The full capsule has threats (with STRIDE), risk_hints, repair_contract, related_patterns.",
-                },
-                {
-                    id: "get_inference_prompt",
-                    label: "Get the inference prompt for the host LLM to run a deeper check",
-                    tool: "zivis_threat_get_inference_prompt",
-                    why: "INFER strategies in each capsule reference a prompt template the user's IDE model executes.",
-                },
-            ]
-            : [
-                {
-                    id: "no_relevant_patterns",
-                    label: "No public-pack patterns matched this repo",
-                    tool: "zivis_threat_list_relevant_capsules",
-                    why: "This is normal for repos without agentic / RAG / self-consistency / multi-tenant patterns. Proprietary patterns may still apply server-side.",
-                },
-            ], summaries.length > 0
-            ? `Found ${summaries.length} relevant capsule(s) in the threat library.`
-            : "No public-pack capsules matched this repo. Proprietary patterns evaluated server-side may still apply.");
-    };
-}
-function userCacheRoot() {
-    const home = os.homedir();
-    if (process.platform === "darwin") {
-        return path.join(home, "Library", "Caches", "zivis");
-    }
-    if (process.platform === "win32") {
-        const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
-        return path.join(localAppData, "zivis", "Cache");
-    }
-    const xdg = process.env.XDG_CACHE_HOME;
-    return path.join(xdg ?? path.join(home, ".cache"), "zivis");
-}
-async function resolveArtifactPath(explicit, cwd) {
-    if (explicit) {
-        if (!fssync.existsSync(explicit)) {
-            throw new Error(`Artifact path does not exist: ${explicit}`);
-        }
-        return explicit;
-    }
-    const reposRoot = path.join(userCacheRoot(), "repos");
-    if (!fssync.existsSync(reposRoot)) {
-        throw new Error(`No inspect cache found at ${reposRoot}. Run \`zivis inspect\` from the repo to populate it.`);
-    }
-    const candidates = [];
-    for (const repo of await fs.readdir(reposRoot, { withFileTypes: true })) {
-        if (!repo.isDirectory())
-            continue;
-        const runs = path.join(reposRoot, repo.name, "inspect", "runs");
-        if (!fssync.existsSync(runs))
-            continue;
-        for (const entry of await fs.readdir(runs)) {
-            if (!entry.endsWith(".json"))
-                continue;
-            const full = path.join(runs, entry);
-            const stat = await fs.stat(full);
-            candidates.push({ file: full, mtime: stat.mtimeMs });
-        }
-    }
-    if (candidates.length === 0) {
-        throw new Error(`No inspect runs found under ${reposRoot}. Run \`zivis inspect\` from the repo to produce one.`);
-    }
-    candidates.sort((a, b) => b.mtime - a.mtime);
-    return candidates[0].file;
-}
-function matchedTerms(cap, artifact) {
-    const matched = [];
-    const pkgs = new Set();
-    for (const node of artifact.nodes) {
-        if (node.type === "external_dependency" && node.attributes?.package) {
-            pkgs.add(node.attributes.package);
-        }
-    }
-    const langs = new Set(artifact.scope.languages ?? []);
-    const f = cap.relevance_filter;
-    if (!f)
-        return ["always-applicable (no relevance_filter set)"];
-    for (const term of [...(f.any_of ?? []), ...(f.all_of ?? [])]) {
-        if (term.dependency && pkgs.has(term.dependency))
-            matched.push(`dep:${term.dependency}`);
-        if (term.language && langs.has(term.language))
-            matched.push(`language:${term.language}`);
-    }
-    return matched.length > 0 ? matched : ["language match only"];
-}

package/dist/tools/threat-run-matcher.d.ts

@@ -1,17 +0,0 @@
-import { z } from "zod";
-export declare const THREAT_RUN_MATCHER_NAME = "zivis_threat_run_matcher";
-export declare const THREAT_RUN_MATCHER_DESCRIPTION = "Run the local pattern matcher against the latest repo graph artifact and emit normalized threat findings.\n\nUse this when:\n- The user asks ZIVIS to actually evaluate (not just list) which patterns fire on their code\n- After 'zivis inspect' has produced an artifact and the user wants concrete findings\n- \"find security issues in my code\", \"check this against the threat library\", \"what's actually wrong here\"\n\nPhase 3 v1 evaluates AST strategies for real (via @ast-grep/napi for TS/JS, plus Python and Go via dynamic language packs). INFER strategies emit a candidate the host LLM is expected to pick up via zivis_threat_get_inference_prompt and run with its own model. GRAPH / META / DEP / CONFIG strategies are surfaced as fired_strategies with match_count: 0 \u2014 visible-but-not-evaluated for now.\n\nLane assignment per finding:\n- trusted: count of fired deterministic strategies meets the capsule's required_evidence_count\n- inferred: at least one strategy fired but the bar wasn't met (host should run inference to confirm)\n\nThe output is a normalized findings array with pattern_id, lane, confidence, evidence spans, and (for inferred-lane findings) an inference_candidate the host LLM uses to run deeper analysis.";
-export declare const THREAT_RUN_MATCHER_SCHEMA: {
-    artifact_path: z.ZodOptional<z.ZodString>;
-    cwd: z.ZodOptional<z.ZodString>;
-};
-export declare function createThreatRunMatcherHandler(): (params: {
-    artifact_path?: string;
-    cwd?: string;
-}) => Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    isError?: boolean;
-}>;