@zivis/mcp 0.1.12 → 0.1.18

package/dist/tools/get-started.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
 import { detectProjectBinding } from "../project-binding.js";
 import { loadActivePack, findRelevantCapsules, } from "../pattern-pack/index.js";
@@ -24,8 +25,10 @@ The 'relevant_threats' field in the response is what makes this tool different f
 generic security menu: ZIVIS is reading the user's actual codebase via the graph
 artifact and naming threats by their architectural shape.
 
-Always speak to the user in threat-model language: components, flows, trust boundaries,
-attack scenarios. Even when they don't yet know those terms — that's how they learn.
+Speak in plain developer language by default — do not introduce jargon (actor, STRIDE,
+kill chain, TTPs) unless the user already used it. Naming the actual product concepts
+("your threat model", \`zivis threatmodel\`) is fine when they are the literal thing being
+discussed; that is a product noun, not jargon to avoid.
 
 Output is a structured JSON object. Present recommended_next_steps as a numbered list
 to the user, in order, and ask them to pick one. If relevant_threats is non-empty, lead
@@ -80,42 +83,44 @@ function stepCheckDeps() {
     return {
         id: "check_dependencies",
         label: "Check the open source libraries you depend on",
-        tool: "zivis_check_repo_trust",
-        why: "Free, no setup. Catches risky AI SDKs and known-bad dependencies before they cause problems.",
-        estimated_time: "1 minute per repo",
-        requires_auth: false,
+        tool: "cli_command",
+        args_hint: { command: "zivis test dependencies" },
+        why: "Runs the ZIVIS dependency-risk methodology (reachability triage) against your resolved lockfile.",
+        estimated_time: "a few minutes — the coding agent does the reasoning",
+        requires_auth: true,
     };
 }
-function stepSetupAiTarget(hint) {
+function stepTestScope(scopeId, label, why) {
     return {
-        id: "setup_ai_target",
-        label: "Tell ZIVIS about your chatbot or AI system so it can test it",
-        tool: "zivis_setup_red_team_target",
-        args_hint: { target_type: "ai_chat", ...hint },
-        why: "ZIVIS needs to know your endpoint to run prompt-injection, jailbreak, and PII-leakage tests.",
-        estimated_time: "2 minutes",
+        id: `test_${scopeId}`,
+        label,
+        tool: "cli_command",
+        args_hint: { command: `zivis test ${scopeId}` },
+        why,
+        estimated_time: "a few minutes — the coding agent does the reasoning",
         requires_auth: true,
     };
 }
-function stepSetupWebTarget(hint) {
+function stepBareTest() {
     return {
-        id: "setup_web_target",
-        label: "Register your web app or API with ZIVIS for testing",
-        tool: "zivis_setup_red_team_target",
-        args_hint: { target_type: "web_app", ...hint },
-        why: "ZIVIS needs to know your app URL to run security tests against it.",
-        estimated_time: "2 minutes",
+        id: "run_test",
+        label: "Run a ZIVIS security review of what changed",
+        tool: "cli_command",
+        args_hint: { command: "zivis test" },
+        why: "Change-aware by default: recommends only the scopes your recent changes touch, using ZIVIS's memory of what was last tested.",
+        estimated_time: "a few minutes — the coding agent does the reasoning",
         requires_auth: true,
     };
 }
-function stepBrowseTests() {
+function stepListScopes() {
     return {
-        id: "browse_test_library",
-        label: "Browse what ZIVIS can test for",
-        tool: "zivis_list_test_scenarios",
-        why: "See the menu of attack categories (prompt injection, auth bypass, data leakage, etc.) before committing to a scan.",
-        estimated_time: "30 seconds",
-        requires_auth: true,
+        id: "list_scopes",
+        label: "See the security areas ZIVIS can test",
+        tool: "cli_command",
+        args_hint: { command: "zivis test --list" },
+        why: "Lists the scopes defined by the verified ZIVIS AppSec methodology pack — pick one instead of guessing a scope name.",
+        estimated_time: "a few seconds",
+        requires_auth: false,
     };
 }
 function stepViewFindings(count) {
@@ -124,8 +129,7 @@ function stepViewFindings(count) {
         label: count
             ? `Review the ${count} open security issue${count === 1 ? "" : "s"} ZIVIS found`
             : "Review open security issues ZIVIS found",
-        tool: "zivis_get_findings",
-        args_hint: { status: "open" },
+        tool: "zivis_security_review",
         why: "Look at what's been found already before starting new scans — no point duplicating work.",
         estimated_time: "5 minutes",
         requires_auth: true,
@@ -136,18 +140,52 @@ function stepRunSecurityReview() {
         id: "run_security_review",
         label: "Get a security readiness summary before launch or audit",
         tool: "zivis_security_review",
-        why: "Pulls together all open findings, past fixes, and known attack scenarios into one pre-launch checklist.",
+        why: "Pulls together open findings and regression history from prior ZIVIS work into one pre-launch checklist.",
         estimated_time: "3 minutes",
         requires_auth: true,
     };
 }
+function stepThreatModel() {
+    return {
+        id: "threat_model",
+        label: "Start or continue this Application's living threat model",
+        tool: "cli_command",
+        args_hint: { command: "zivis threatmodel" },
+        why: "Captures components, data flows, and trust boundaries as a durable, versioned artifact.",
+        estimated_time: "a few minutes — the coding agent does the reasoning",
+        requires_auth: true,
+    };
+}
+function stepGateShip() {
+    return {
+        id: "gate_ship",
+        label: "Get a deterministic ship/no-ship verdict against your committed policy",
+        tool: "cli_command",
+        args_hint: { command: "zivis gate ship" },
+        why: "Deterministic — reads your committed .zivis/policy.yaml against live Zivis state. Never an invented verdict.",
+        estimated_time: "a few seconds",
+        requires_auth: true,
+    };
+}
+function stepGateInit() {
+    return {
+        id: "gate_init",
+        label: "Create a committed ship policy so 'can we ship?' has a real answer",
+        tool: "cli_command",
+        args_hint: { command: "zivis gate --init" },
+        why: "No .zivis/policy.yaml exists yet, so zivis gate has nothing to evaluate — this scaffolds a starter policy to review and commit.",
+        estimated_time: "a minute to review and adjust the generated thresholds",
+        requires_auth: true,
+    };
+}
 function stepSetupProject() {
     return {
         id: "setup_project",
         label: "Connect this project to your ZIVIS org",
-        tool: "zivis_check_project",
-        why: "ZIVIS needs to know which org this project belongs to before it can run tests or store results.",
-        estimated_time: "2 minutes (run 'zivis auth init' in your terminal)",
+        tool: "cli_command",
+        args_hint: { command: "zivis init" },
+        why: "Every ZIVIS command needs a bound Application before it can run tests or store results — this is the one thing that has to happen first.",
+        estimated_time: "2 minutes",
         requires_auth: false,
     };
 }
@@ -163,6 +201,10 @@ function stepInstallGitHubApp(installUrl) {
     };
 }
 async function fetchState(apiClient, cwd) {
+    const hasGatePolicy = await fs
+        .access(path.join(cwd, ".zivis", "policy.yaml"))
+        .then(() => true)
+        .catch(() => false);
     const detected = detectProjectBinding(cwd);
     if (!detected) {
         return {
@@ -171,6 +213,7 @@ async function fetchState(apiClient, cwd) {
             has_scans: false,
             has_findings: false,
             open_findings_count: 0,
+            has_gate_policy: hasGatePolicy,
         };
     }
     const state = {
@@ -180,6 +223,7 @@ async function fetchState(apiClient, cwd) {
         has_scans: false,
         has_findings: false,
         open_findings_count: 0,
+        has_gate_policy: hasGatePolicy,
     };
     try {
         const appsResp = await apiClient.get("/api/rt/applications?limit=1");
@@ -221,28 +265,19 @@ function buildMenu(intent, state, concern) {
     if (!state.bound) {
         return {
             headline: "Welcome to ZIVIS! First, let's connect this project to your organization so results are stored and tracked.",
-            recommended_next_steps: [
-                stepSetupProject(),
-                stepCheckDeps(),
-                stepBrowseTests(),
-            ],
-            guidance_for_assistant: "Present these as a numbered list. The user should run 'zivis auth init' in their terminal to complete step 1. " +
-                "Step 2 (check_dependencies) requires no auth and can be done immediately. " +
-                "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
-            if_user_unsure: "Recommend option 2 (check_dependencies) — it requires no setup and gives immediate results.",
+            recommended_next_steps: [stepSetupProject()],
+            guidance_for_assistant: "Present this as a single step. The user should run 'zivis init' in their terminal — it handles login and " +
+                "Application binding together. Every other ZIVIS command needs this to succeed first; there is nothing " +
+                "useful to offer in parallel. If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
+            if_user_unsure: "Run 'zivis init' — it's the only step available until this project is connected.",
         };
     }
     if (state.has_findings && intent !== "dep_audit") {
         const steps = [
             stepViewFindings(state.open_findings_count),
+            stepBareTest(),
             stepCheckDeps(),
         ];
-        if (!state.has_application) {
-            steps.push(stepSetupWebTarget());
-        }
-        else {
-            steps.push(stepBrowseTests());
-        }
         return {
             headline: `ZIVIS sees your project (${state.org_name ?? "connected"}) and has found ${state.open_findings_count} open security issue${state.open_findings_count === 1 ? "" : "s"}.`,
             recommended_next_steps: steps,
@@ -253,46 +288,28 @@ function buildMenu(intent, state, concern) {
     }
     if (intent === "ai_red_team") {
         const steps = [
-            stepSetupAiTarget(),
+            stepTestScope("ai", "Test your AI system for prompt injection, jailbreaks, and data leakage", "Runs the ZIVIS 'ai' scope methodology, grounded in your actual code — not a generic checklist."),
             stepCheckDeps(),
-            stepBrowseTests(),
         ];
         return {
-            headline: state.has_application
-                ? `ZIVIS sees your project (${state.org_name ?? "connected"}) and has a target configured. Ready to test your AI system.`
-                : `ZIVIS sees your project (${state.org_name ?? "connected"}) but no security testing has run yet.`,
+            headline: `ZIVIS sees your project (${state.org_name ?? "connected"}). Let's test the AI-specific surface.`,
             recommended_next_steps: steps,
             guidance_for_assistant: "The user wants to test an AI/chatbot system. Present these as a numbered list. " +
-                "If they already have a target URL, include it in args_hint. " +
                 "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
-            if_user_unsure: "Recommend option 1 (setup_ai_target) — setting up the chatbot as a test target is the fastest path to finding real issues.",
+            if_user_unsure: "Recommend option 1 (test_ai) — it's the scope built for exactly this.",
         };
     }
     if (intent === "dep_audit") {
         return {
-            headline: "Checking your dependencies is a great place to start — it's free, needs no setup, and often finds the most impactful issues.",
-            recommended_next_steps: [
-                stepCheckDeps(),
-                stepSetupWebTarget(),
-                stepBrowseTests(),
-            ],
-            guidance_for_assistant: "Present these as a numbered list. For step 1, ask the user to share which packages they want to check " +
-                "(the GitHub org/repo of the dependency, e.g. openai/openai-python). " +
-                "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
-            if_user_unsure: "Recommend option 1 (check_dependencies) — it works right now with no setup.",
+            headline: "Checking your dependencies is a great place to start — it often finds the most impactful issues fastest.",
+            recommended_next_steps: [stepCheckDeps(), stepBareTest()],
+            guidance_for_assistant: "Present these as a numbered list. If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
+            if_user_unsure: "Recommend option 1 (check_dependencies).",
         };
     }
     if (intent === "pre_audit" || intent === "pre_launch") {
-        const steps = [
-            stepRunSecurityReview(),
-            stepCheckDeps(),
-        ];
-        if (!state.has_application) {
-            steps.push(stepSetupWebTarget());
-        }
-        else {
-            steps.push(stepBrowseTests());
-        }
+        const gateStep = state.has_gate_policy ? stepGateShip() : stepGateInit();
+        const steps = [stepRunSecurityReview(), gateStep, stepBareTest(), stepCheckDeps()];
         const headline = intent === "pre_audit"
             ? `ZIVIS can help you prepare for an audit. Let's get a security readiness picture first.`
             : `ZIVIS can help you check security before you go live.`;
@@ -300,47 +317,46 @@ function buildMenu(intent, state, concern) {
             headline,
             recommended_next_steps: steps,
             guidance_for_assistant: "The user has a deadline (audit or launch). Start with a security review to understand the current state, " +
-                "then address the highest-severity issues first. " +
-                "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
-            if_user_unsure: "Recommend option 1 (run_security_review) — it gives the fastest complete picture and shows what needs to be fixed before the deadline.",
+                "then address the highest-severity issues first. The security review reflects known findings, not a " +
+                "deterministic ship verdict. If the user actually asks 'can we ship?' / 'go or no-go?', route to " +
+                "'zivis gate' — NEVER answer that question yourself from the review or from general judgment. " +
+                (state.has_gate_policy
+                    ? "A committed policy already exists here, so 'zivis gate ship' (or the relevant gate name) gives a real deterministic answer."
+                    : "No committed policy exists yet, so gate has nothing to evaluate — offer 'zivis gate --init' to scaffold one first, then run the real evaluation. Do not substitute your own opinion in the meantime.") +
+                " If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
+            if_user_unsure: "Recommend option 1 (run_security_review) — it gives the fastest complete picture of what's already known.",
         };
     }
     if (intent === "view_findings") {
         return {
             headline: state.has_findings
                 ? `ZIVIS has ${state.open_findings_count} open finding${state.open_findings_count === 1 ? "" : "s"} for this project.`
-                : `No open findings found yet — ZIVIS may not have run a scan, or all issues are resolved.`,
+                : `No open findings on record yet — that means no test has found one, not that the project is clean.`,
             recommended_next_steps: [
                 stepViewFindings(state.open_findings_count > 0 ? state.open_findings_count : undefined),
-                state.has_application ? stepBrowseTests() : stepSetupWebTarget(),
-                stepCheckDeps(),
+                stepBareTest(),
             ],
-            guidance_for_assistant: "Present these as a numbered list. If the user wants to see findings, call zivis_get_findings directly. " +
+            guidance_for_assistant: "Present these as a numbered list. If the user wants to see findings, call zivis_security_review directly. " +
+                "No open findings does not mean the project passed a test — say so explicitly if the count is zero. " +
                 "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
             if_user_unsure: "Recommend option 1 (view_open_findings) — let's see what ZIVIS already knows.",
         };
     }
-    const steps = [];
-    if (!state.has_application) {
-        steps.push(stepSetupWebTarget());
-    }
-    steps.push(stepCheckDeps());
+    const steps = [stepBareTest(), stepCheckDeps()];
     if (state.has_findings) {
         steps.push(stepViewFindings(state.open_findings_count));
     }
     else {
-        steps.push(stepBrowseTests());
+        steps.push(stepListScopes());
     }
-    if (steps.length < 3)
-        steps.push(stepBrowseTests());
+    if (!state.has_application)
+        steps.push(stepThreatModel());
     return {
-        headline: state.has_application
-            ? `ZIVIS is connected to your project (${state.org_name ?? "org"}). Here are the most useful things to do next.`
-            : `ZIVIS is connected to your project (${state.org_name ?? "org"}) but no app has been registered for testing yet.`,
+        headline: `ZIVIS is connected to your project (${state.org_name ?? "org"}). Here are the most useful things to do next.`,
         recommended_next_steps: steps.slice(0, 4),
         guidance_for_assistant: "Present these as a numbered list. Ask the user to pick one before taking any action. " +
             "If they ask 'why' something matters, expand on the 'why' field — do not make new claims.",
-        if_user_unsure: "Recommend option 2 (check_dependencies) — it's free, fast, and shows value without setup.",
+        if_user_unsure: "Recommend option 1 (run_test) — bare 'zivis test' is change-aware and the natural default entry point.",
     };
 }
 async function findRelevantThreats(cwd) {

package/dist/tools/get-trust-keys.d.ts

@@ -1,6 +1,6 @@
 import type { ZivisConfig } from "../types.js";
 export declare const GET_TRUST_KEYS_NAME = "zivis_get_trust_keys";
-export declare const GET_TRUST_KEYS_DESCRIPTION = "Retrieve the ZIVIS public signing keys (JWKS) for independent cryptographic verification of trust marks and ZATs.\n\nReturns a JWKS (JSON Web Key Set) containing two keys:\n\n1. **ML-DSA-65 key** (post-quantum, FIPS-204):\n   - Algorithm: CRYSTALS-Dilithium Level 3\n   - NIST Security Category 3 (128-bit quantum security)\n   - Used to verify the full digital signature on ZATs and trust marks\n   - Key type: \"PQ-LWE\" (proposed post-quantum JWK key type)\n   - The \"x\" field is the base64url-encoded public key bytes\n\n2. **Ed25519 key** (RFC 8032):\n   - Used to verify compact trust tokens (shorter, URL-safe format)\n   - Standard JWK format (kty: \"OKP\", crv: \"Ed25519\")\n\nThese keys enable third-party, offline verification without trusting ZIVIS infrastructure.\nThis is critical for ATNP (Agent Trust Negotiation Protocol) where agents must independently verify trust marks.\n\nVerification workflow:\n1. Get a ZAT (from zivis_get_oss_zat or zivis_get_org_zat)\n2. Get the public keys (this tool)\n3. Verify the signature using ML-DSA-65 or Ed25519 library of your choice\n4. Check expiration and claims\n\nNo parameters required. No authentication required.";
+export declare const GET_TRUST_KEYS_DESCRIPTION = "Retrieve the ZIVIS public signing keys (JWKS) for independent cryptographic verification of trust marks and ZATs.\n\nReturns a JWKS (JSON Web Key Set) containing two keys:\n\n1. **ML-DSA-65 key** (post-quantum, FIPS-204):\n   - Algorithm: CRYSTALS-Dilithium Level 3\n   - NIST Security Category 3 (128-bit quantum security)\n   - Used to verify the full digital signature on ZATs and trust marks\n   - Key type: \"PQ-LWE\" (proposed post-quantum JWK key type)\n   - The \"x\" field is the base64url-encoded public key bytes\n\n2. **Ed25519 key** (RFC 8032):\n   - Used to verify compact trust tokens (shorter, URL-safe format)\n   - Standard JWK format (kty: \"OKP\", crv: \"Ed25519\")\n\nThese keys enable third-party, offline verification without trusting ZIVIS infrastructure.\nThis is critical for ATNP (Agent Trust Negotiation Protocol) where agents must independently verify trust marks.\n\nVerification workflow:\n1. Get a ZAT (from zivis_get_org_zat)\n2. Get the public keys (this tool)\n3. Verify the signature using ML-DSA-65 or Ed25519 library of your choice\n4. Check expiration and claims\n\nNo parameters required. No authentication required.";
 export declare const GET_TRUST_KEYS_SCHEMA: {};
 export declare function createGetTrustKeysHandler(config: ZivisConfig): () => Promise<{
     content: {

package/dist/tools/get-trust-keys.js

@@ -18,7 +18,7 @@ These keys enable third-party, offline verification without trusting ZIVIS infra
 This is critical for ATNP (Agent Trust Negotiation Protocol) where agents must independently verify trust marks.
 
 Verification workflow:
-1. Get a ZAT (from zivis_get_oss_zat or zivis_get_org_zat)
+1. Get a ZAT (from zivis_get_org_zat)
 2. Get the public keys (this tool)
 3. Verify the signature using ML-DSA-65 or Ed25519 library of your choice
 4. Check expiration and claims

package/dist/tools/inspect-zat.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare const INSPECT_ZAT_NAME = "zivis_inspect_zat";
-export declare const INSPECT_ZAT_DESCRIPTION = "Parse a ZIVIS Attestation Token (ZAT) JSON and produce a human-readable explanation of all fields.\n\nThis tool does NOT make any API calls \u2014 it parses the ZAT locally and explains what each field means.\n\nUse this after retrieving a ZAT from zivis_get_oss_zat or zivis_get_org_zat to understand:\n- What the claims mean (Z-Score, trust tiers, coverage, findings)\n- Whether signatures are present and which algorithms were used\n- Token validity and expiration\n- Evidence manifest integrity\n- Framework and methodology details\n- Lens-level scores (for OSS ZATs)\n\nAccepts either:\n- A JSON string (the raw ZAT output)\n- A JSON object with a \"zat\" field (the wrapper returned by the API)\n\nZAT Field Reference:\n- **iss**: Issuer (always \"zivis.ai\")\n- **sub**: Subject \u2014 \"org:<slug>\" for enterprise, \"github:<owner>/<repo>\" for OSS\n- **mark_id**: Unique identifier (ztm_...) \u2014 references the trust mark\n- **issued_at / expires_at**: ISO 8601 timestamps \u2014 ZATs are short-lived (48h)\n- **frameworks[]**: Which security frameworks were assessed (NIST IR 8596, ISO 42001, OWASP LLM Top 10, etc.)\n  - basis: \"tested\" | \"mapped\" | \"self-attested\" | \"third-party\" \u2014 how the assessment was performed\n  - csf_version: Present if framework is NIST CSF 2.0 derived (enables cross-framework comparison)\n- **claims**: The actual trust posture\n  - For enterprise: z_score_raw (0-1), z_score_display (0-1000), tier (0-3), tier_label, coverage_pct, mapped_outcomes\n  - For OSS: score (0-100), grade (A+ to F), check_types, findings by severity, commit SHA\n  - Tier meanings: 0=Commitment, 1=Foundational Trust (600+), 2=Operational Trust (700+), 3=Systemic Trust (800+)\n- **evidence_manifest**: SHA-256 hash of the evidence bundle \u2014 proves the assessment data hasn't been tampered with\n- **methodology**: How the assessment was performed (model version, scoring algorithm, evaluator type)\n- **sig**: Cryptographic signatures\n  - alg: \"ML-DSA-65\" (FIPS-204, post-quantum CRYSTALS-Dilithium Level 3)\n  - compact: Ed25519 (RFC 8032) compact token for lightweight verification\n- **ver**: ZAT spec version (e.g., \"0.3.0\")";
+export declare const INSPECT_ZAT_DESCRIPTION = "Parse a ZIVIS Attestation Token (ZAT) JSON and produce a human-readable explanation of all fields.\n\nThis tool does NOT make any API calls \u2014 it parses the ZAT locally and explains what each field means.\n\nUse this after retrieving a ZAT from zivis_get_org_zat to understand:\n- What the claims mean (Z-Score, trust tiers, coverage, findings)\n- Whether signatures are present and which algorithms were used\n- Token validity and expiration\n- Evidence manifest integrity\n- Framework and methodology details\n- Lens-level scores (for OSS ZATs)\n\nAccepts either:\n- A JSON string (the raw ZAT output)\n- A JSON object with a \"zat\" field (the wrapper returned by the API)\n\nZAT Field Reference:\n- **iss**: Issuer (always \"zivis.ai\")\n- **sub**: Subject \u2014 \"org:<slug>\" for enterprise, \"github:<owner>/<repo>\" for OSS\n- **mark_id**: Unique identifier (ztm_...) \u2014 references the trust mark\n- **issued_at / expires_at**: ISO 8601 timestamps \u2014 ZATs are short-lived (48h)\n- **frameworks[]**: Which security frameworks were assessed (NIST IR 8596, ISO 42001, OWASP LLM Top 10, etc.)\n  - basis: \"tested\" | \"mapped\" | \"self-attested\" | \"third-party\" \u2014 how the assessment was performed\n  - csf_version: Present if framework is NIST CSF 2.0 derived (enables cross-framework comparison)\n- **claims**: The actual trust posture\n  - For enterprise: z_score_raw (0-1), z_score_display (0-1000), tier (0-3), tier_label, coverage_pct, mapped_outcomes\n  - For OSS: score (0-100), grade (A+ to F), check_types, findings by severity, commit SHA\n  - Tier meanings: 0=Commitment, 1=Foundational Trust (600+), 2=Operational Trust (700+), 3=Systemic Trust (800+)\n- **evidence_manifest**: SHA-256 hash of the evidence bundle \u2014 proves the assessment data hasn't been tampered with\n- **methodology**: How the assessment was performed (model version, scoring algorithm, evaluator type)\n- **sig**: Cryptographic signatures\n  - alg: \"ML-DSA-65\" (FIPS-204, post-quantum CRYSTALS-Dilithium Level 3)\n  - compact: Ed25519 (RFC 8032) compact token for lightweight verification\n- **ver**: ZAT spec version (e.g., \"0.3.0\")";
 export declare const INSPECT_ZAT_SCHEMA: {
     zat_json: z.ZodString;
 };

package/dist/tools/inspect-zat.js

@@ -4,7 +4,7 @@ export const INSPECT_ZAT_DESCRIPTION = `Parse a ZIVIS Attestation Token (ZAT) JS
 
 This tool does NOT make any API calls — it parses the ZAT locally and explains what each field means.
 
-Use this after retrieving a ZAT from zivis_get_oss_zat or zivis_get_org_zat to understand:
+Use this after retrieving a ZAT from zivis_get_org_zat to understand:
 - What the claims mean (Z-Score, trust tiers, coverage, findings)
 - Whether signatures are present and which algorithms were used
 - Token validity and expiration
@@ -37,7 +37,7 @@ ZAT Field Reference:
 export const INSPECT_ZAT_SCHEMA = {
     zat_json: z
         .string()
-        .describe("The ZAT JSON string to inspect (from zivis_get_oss_zat or zivis_get_org_zat output)"),
+        .describe("The ZAT JSON string to inspect (from zivis_get_org_zat output)"),
 };
 export function createInspectZatHandler() {
     return async (params) => {

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

@@ -2,14 +2,12 @@ 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\n3. **Dependency risks** \u2014 OSS trust scores for dependencies in the code\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- Use of low-trust dependencies\n\nProvide at least one of: repo, application_id, or campaign_id.";
+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>;
-    campaign_id: z.ZodOptional<z.ZodString>;
     focus_areas: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         regression: "regression";
-        dependencies: "dependencies";
         all: "all";
     }>>>;
     severity_threshold: z.ZodOptional<z.ZodEnum<{
@@ -20,16 +18,13 @@ export declare const SECURITY_REVIEW_SCHEMA: {
         info: "info";
     }>>;
     include_resolved: z.ZodDefault<z.ZodBoolean>;
-    dependency_list: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
-export declare function createSecurityReviewHandler(apiClient: ApiClient, config: ZivisConfig): (params: {
+export declare function createSecurityReviewHandler(apiClient: ApiClient, _config: ZivisConfig): (params: {
     repo?: string;
     application_id?: string;
-    campaign_id?: string;
     focus_areas?: string[];
     severity_threshold?: string;
     include_resolved?: boolean;
-    dependency_list?: string[];
 }) => Promise<{
     content: {
         type: "text";

package/dist/tools/security-review.js

@@ -8,22 +8,21 @@ Pulls historical findings and open vulnerabilities to give you comprehensive sec
 
 1. **Regression risks** — Previously fixed vulnerabilities that could be reintroduced
 2. **Known vulnerabilities** — Open findings that may be relevant to the code being reviewed
-3. **Dependency risks** — OSS trust scores for dependencies in the code
 
 Returns structured security context that you should reference during code review. Focus on:
 - Code that touches areas where historical findings were fixed (regression check)
-- Use of low-trust dependencies
 
-Provide at least one of: repo, application_id, or campaign_id.`;
+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 and OSS trust data"),
+    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."),
-    campaign_id: z.string().optional().describe("Campaign UUID — pulls campaign-specific findings"),
     focus_areas: z
-        .array(z.enum(["regression", "dependencies", "all"]))
+        .array(z.enum(["regression", "all"]))
         .optional()
         .describe("Which intelligence to gather (default: all)"),
     severity_threshold: z
@@ -34,10 +33,6 @@ export const SECURITY_REVIEW_SCHEMA = {
         .boolean()
         .default(true)
         .describe("Include resolved findings for regression checking (default: true)"),
-    dependency_list: z
-        .array(z.string())
-        .optional()
-        .describe("Specific dependencies to check trust scores for (owner/repo format)"),
 };
 const SEVERITY_ORDER = {
     critical: 5,
@@ -46,16 +41,17 @@ const SEVERITY_ORDER = {
     low: 2,
     info: 1,
 };
-export function createSecurityReviewHandler(apiClient, config) {
+export function createSecurityReviewHandler(apiClient, _config) {
     return async (params) => {
-        const { repo, application_id: application_idParam, campaign_id, focus_areas = ["all"], severity_threshold = "low", include_resolved = true, dependency_list, } = 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 && !campaign_id) {
+        if (!repo && !application_id) {
             return {
                 content: [{
                         type: "text",
-                        text: "Error: Provide at least one of: repo, application_id, or campaign_id " +
-                            "(or set applicationId in .zivis/project.json for default app scope)",
+                        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,
             };
@@ -64,7 +60,7 @@ export function createSecurityReviewHandler(apiClient, config) {
         const context = {
             _description: "ZIVIS Security Review Context — use this intelligence during code review",
             generatedAt: new Date().toISOString(),
-            parameters: { repo, application_id, campaign_id },
+            parameters: { repo, application_id },
         };
         const errors = [];
         if (shouldInclude("regression") && (repo || application_id)) {
@@ -112,65 +108,6 @@ export function createSecurityReviewHandler(apiClient, config) {
                 errors.push(`Open findings: ${err instanceof Error ? err.message : "failed"}`);
             }
         }
-        if (shouldInclude("dependencies") && dependency_list && dependency_list.length > 0) {
-            const depResults = [];
-            const baseUrl = config.apiBaseUrl;
-            for (const dep of dependency_list.slice(0, 10)) {
-                try {
-                    const parsed = parseRepo(dep);
-                    if (!parsed) {
-                        depResults.push({ repo: dep, error: "Invalid format" });
-                        continue;
-                    }
-                    const res = await fetch(`${baseUrl}/api/oss-trust/repos/${parsed.owner}/${parsed.repo}`);
-                    if (res.ok) {
-                        const entry = await res.json();
-                        depResults.push({
-                            repo: dep,
-                            trustGrade: entry.trustGrade,
-                            trustScore: entry.trustScore,
-                            findings: {
-                                critical: entry.findingsCritical ?? 0,
-                                high: entry.findingsHigh ?? 0,
-                                medium: entry.findingsMedium ?? 0,
-                                low: entry.findingsLow ?? 0,
-                            },
-                            lastScanned: entry.lastScannedAt,
-                        });
-                    }
-                    else {
-                        depResults.push({ repo: dep, trustGrade: "unscanned", trustScore: null });
-                    }
-                }
-                catch {
-                    depResults.push({ repo: dep, error: "Failed to fetch" });
-                }
-            }
-            const risky = depResults.filter((d) => d.trustScore != null && d.trustScore < 70);
-            context.dependencyRisks = {
-                _instruction: "Flag usage of low-trust dependencies. Consider alternatives for dependencies with grade C or below.",
-                checked: depResults.length,
-                riskyCount: risky.length,
-                dependencies: depResults,
-            };
-        }
-        if (campaign_id) {
-            try {
-                const campaignFindings = await apiClient.get(`/api/campaigns/${campaign_id}/findings?limit=50`);
-                const findings = campaignFindings.findings || [];
-                const minSeverity = SEVERITY_ORDER[severity_threshold] || 2;
-                const filtered = findings.filter((f) => (SEVERITY_ORDER[f.severity] || 1) >= minSeverity);
-                context.campaignFindings = {
-                    _instruction: "These findings are from active security testing campaigns. Check if code changes address or affect these.",
-                    count: filtered.length,
-                    bySeverity: countBySeverity(filtered),
-                    findings: filtered.slice(0, 20).map(summarizeFinding),
-                };
-            }
-            catch (err) {
-                errors.push(`Campaign findings: ${err instanceof Error ? err.message : "failed"}`);
-            }
-        }
         context.reviewGuidance = buildReviewGuidance(context);
         if (errors.length > 0) {
             context.warnings = errors;
@@ -255,24 +192,8 @@ function buildReviewGuidance(context) {
     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.`);
     }
-    const deps = context.dependencyRisks;
-    if (deps?.riskyCount > 0) {
-        guidance.push(`RISKY DEPS: ${deps.riskyCount} dependencies with low trust scores. Consider alternatives.`);
-    }
     if (guidance.length === 0) {
         guidance.push("No significant security context found. Perform standard code review best practices.");
     }
     return guidance;
 }
-function parseRepo(input) {
-    const trimmed = input.trim();
-    const urlMatch = trimmed.match(/^https?:\/\/(?:www\.)?github\.com\/([a-zA-Z0-9._-]+)\/([a-zA-Z0-9._-]+)/);
-    if (urlMatch) {
-        return { owner: urlMatch[1], repo: urlMatch[2].replace(/\.git$/, "") };
-    }
-    const slashMatch = trimmed.match(/^([a-zA-Z0-9._-]+)\/([a-zA-Z0-9._-]+)$/);
-    if (slashMatch) {
-        return { owner: slashMatch[1], repo: slashMatch[2] };
-    }
-    return null;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zivis/mcp",
-  "version": "0.1.12",
+  "version": "0.1.18",
   "description": "ZIVIS MCP server — threat modeling, security scans, and AI red team tools for IDE integration",
   "license": "Apache-2.0",
   "homepage": "https://zivis.ai",
@@ -43,12 +43,12 @@
     "build:pattern-pack": "tsx ../scripts/build-pattern-pack.ts",
     "build": "tsc -p tsconfig.build.json && pnpm run build:pattern-pack && node scripts/ensure-symlink.cjs",
     "prepublishOnly": "rm -rf dist && pnpm run build",
-    "postpublish": "node -e \"const p=require('./package.json'); require('child_process').execSync('npm dist-tag add '+p.name+'@'+p.version+' latest',{stdio:'inherit'});\"",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit",
+    "check:drift": "tsx scripts/check-drift.ts",
     "build:installer": "bash scripts/build-installer.sh"
   },
   "engines": {