ship-safe 9.0.0 → 9.1.1

package/cli/bin/ship-safe.js

@@ -175,6 +175,7 @@ program
   .command('rotate [path]')
   .description('Revoke and rotate exposed secrets — opens provider dashboards with step-by-step guide')
   .option('--provider <name>', 'Only rotate secrets for a specific provider (e.g. github, stripe, openai)')
+  .option('--plan <file>', 'Execute a rotation plan downloaded from shipsafecli.com/rotate')
   .action(rotateCommand);
 
 // -----------------------------------------------------------------------------
@@ -226,7 +227,7 @@ program
   .option('--deep', 'LLM-powered taint analysis for critical/high findings')
   .option('--local', 'Use local Ollama model for deep analysis (default: llama3.2)')
   .option('--model <model>', 'LLM model to use for deep/AI analysis')
-  .option('--provider <name>', 'LLM provider: anthropic, openai, google, ollama, groq, together, mistral, cohere, deepseek, xai, lmstudio')
+  .option('--provider <name>', 'LLM provider: anthropic, openai, google, ollama, groq, together, mistral, cohere, deepseek, xai, kimi, lmstudio')
   .option('--base-url <url>', 'Custom OpenAI-compatible endpoint (e.g. http://localhost:1234/v1/chat/completions)')
   .option('--budget <cents>', 'Max spend in cents for deep analysis (default: 50)', parseInt)
   .option('--verify', 'Check if leaked secrets are still active (probes provider APIs)')
@@ -264,9 +265,10 @@ program
   .option('--no-deps', 'Skip dependency audit')
   .option('--no-ai', 'Skip AI classification')
   .option('--deep', 'LLM-powered taint analysis for critical/high findings')
+  .option('--swarm', 'Use Kimi K2.6 native 300-agent swarm instead of local agent execution (requires MOONSHOT_API_KEY)')
   .option('--local', 'Use local Ollama model for deep analysis (default: llama3.2)')
   .option('--model <model>', 'LLM model for deep analysis')
-  .option('--provider <name>', 'LLM provider: anthropic, openai, google, ollama, groq, together, mistral, cohere, deepseek, xai, lmstudio')
+  .option('--provider <name>', 'LLM provider: anthropic, openai, google, ollama, groq, together, mistral, cohere, deepseek, xai, kimi, lmstudio')
   .option('--base-url <url>', 'Custom OpenAI-compatible endpoint (e.g. http://localhost:1234/v1/chat/completions)')
   .option('--budget <cents>', 'Max spend in cents for deep analysis (default: 50)', parseInt)
   .option('-v, --verbose', 'Verbose output')
@@ -281,6 +283,9 @@ program
   .option('--poll', 'Use polling mode (for network drives)')
   .option('--configs', 'Watch only agent config files (openclaw.json, .cursorrules, mcp.json, etc.)')
   .option('--deep', 'Run full agent scanning on changes (not just pattern matching)')
+  .option('--stateful', 'Keep Kimi K2.6 conversation context between scans for incremental analysis (requires MOONSHOT_API_KEY)')
+  .option('--model <model>', 'LLM model for stateful watch (default: kimi-k2.6)')
+  .option('--provider <name>', 'LLM provider for stateful watch (default: kimi)')
   .option('--status', 'Show current watch status and exit')
   .option('--threshold <score>', 'Alert when score drops below threshold', parseInt)
   .option('--debounce <ms>', 'Debounce interval in ms (default: 1500)', parseInt)
@@ -607,7 +612,7 @@ How it works:
 if (process.argv.length === 2) {
   console.log(banner);
   console.log(chalk.yellow('\nQuick start:\n'));
-  console.log(chalk.cyan.bold('  v8.0 — Ship Safe × Hermes Agent'));
+  console.log(chalk.cyan.bold('  v9.0 — Agent Studio, Teams & Findings'));
   console.log(chalk.white('  npx ship-safe audit .       ') + chalk.gray('# Full audit: secrets + 22 agents + deps + remediation'));
   console.log(chalk.white('  npx ship-safe audit . --deep') + chalk.gray('# LLM-powered taint analysis (Anthropic/Ollama)'));
   console.log(chalk.white('  npx ship-safe red-team .    ') + chalk.gray('# 22-agent red team scan (80+ attack classes)'));

package/cli/commands/red-team.js

@@ -18,6 +18,8 @@ import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import { buildOrchestratorAsync } from '../agents/index.js';
+import { SwarmOrchestrator } from '../agents/swarm-orchestrator.js';
+import { ReconAgent } from '../agents/recon-agent.js';
 import { ScoringEngine } from '../agents/scoring-engine.js';
 import { PolicyEngine } from '../agents/policy-engine.js';
 import { HTMLReporter } from '../agents/html-reporter.js';
@@ -34,31 +36,72 @@ export async function redTeamCommand(targetPath = '.', options = {}) {
     process.exit(1);
   }
 
-  console.log();
-  output.header('Ship Safe v4.0 — Multi-Agent Security Audit');
   console.log();
 
-  // ── 1. Run orchestrator ─────────────────────────────────────────────────────
-  const orchestrator = await buildOrchestratorAsync(absolutePath, { quiet: true });
+  let findings = [];
+  let recon = {};
+  let agentResults = [];
 
-  const agentFilter = options.agents
-    ? options.agents.split(',').map(a => a.trim())
-    : null;
+  // ── 1a. Swarm mode (Kimi K2.6 native parallel execution) ─────────────────
+  if (options.swarm) {
+    output.header('Ship Safe — Kimi K2.6 Swarm Mode');
+    console.log();
 
-  const orchestratorOpts = {
-    verbose: options.verbose,
-    agents: agentFilter,
-  };
-  if (options.deep) orchestratorOpts.deep = true;
-  if (options.local) orchestratorOpts.local = true;
-  if (options.model) orchestratorOpts.model = options.model;
-  if (options.provider) orchestratorOpts.provider = options.provider;
-  if (options.baseUrl) orchestratorOpts.baseUrl = options.baseUrl;
-  if (options.budget) orchestratorOpts.budget = options.budget;
+    const swarm = SwarmOrchestrator.create(absolutePath, {
+      provider: options.provider || 'kimi',
+      model: options.model,
+      verbose: options.verbose,
+      budgetCents: options.budget || 200,
+    });
+
+    if (!swarm) {
+      output.error('Swarm mode requires MOONSHOT_API_KEY (Kimi K2.6). Set it and retry.');
+      process.exit(1);
+    }
+
+    const reconSpinner = ora({ text: 'Mapping attack surface...', color: 'cyan' }).start();
+    const reconAgent = new ReconAgent();
+    const reconResult = await reconAgent.analyze({ rootPath: absolutePath });
+    recon = Array.isArray(reconResult) ? {} : reconResult;
+    const files = await reconAgent.discoverFiles(absolutePath);
+    reconSpinner.succeed(chalk.green('Attack surface mapped'));
 
-  const results = await orchestrator.runAll(absolutePath, orchestratorOpts); // ship-safe-ignore — orchestrator result, not LLM output triggering actions
+    const swarmSpinner = ora({ text: `Deploying ${chalk.cyan('23 swarm agents')} via Kimi K2.6...`, color: 'cyan' }).start();
+    try {
+      findings = await swarm.run(absolutePath, recon, files);
+      swarmSpinner.succeed(chalk.green(`Swarm complete — ${findings.length} finding(s)`));
+    } catch (err) {
+      swarmSpinner.fail(chalk.red(`Swarm failed: ${err.message}`));
+      process.exit(1);
+    }
 
-  const { recon, findings, agentResults } = results;
+    agentResults = [{ agent: 'KimiSwarm', category: 'swarm', findingCount: findings.length, success: true }];
+
+  } else {
+    // ── 1b. Standard local orchestration ───────────────────────────────────
+    output.header('Ship Safe v4.0 — Multi-Agent Security Audit');
+    console.log();
+
+    const orchestrator = await buildOrchestratorAsync(absolutePath, { quiet: true });
+
+    const agentFilter = options.agents
+      ? options.agents.split(',').map(a => a.trim())
+      : null;
+
+    const orchestratorOpts = {
+      verbose: options.verbose,
+      agents: agentFilter,
+    };
+    if (options.deep) orchestratorOpts.deep = true;
+    if (options.local) orchestratorOpts.local = true;
+    if (options.model) orchestratorOpts.model = options.model;
+    if (options.provider) orchestratorOpts.provider = options.provider;
+    if (options.baseUrl) orchestratorOpts.baseUrl = options.baseUrl;
+    if (options.budget) orchestratorOpts.budget = options.budget;
+
+    const results = await orchestrator.runAll(absolutePath, orchestratorOpts); // ship-safe-ignore — orchestrator result, not LLM output triggering actions
+    ({ recon, findings, agentResults } = results);
+  }
 
   // ── 2. Dependency audit ─────────────────────────────────────────────────────
   let depVulns = [];

package/cli/commands/rotate.js

@@ -10,8 +10,9 @@
  * (no auth required — designed for reporting exposed credentials).
  *
  * USAGE:
- *   ship-safe rotate .              Scan and rotate all found secrets
- *   ship-safe rotate . --provider github   Only rotate GitHub tokens
+ *   ship-safe rotate .                         Scan local files and rotate found secrets
+ *   ship-safe rotate . --provider github        Only rotate GitHub tokens
+ *   ship-safe rotate --plan rotation-plan.json  Execute a plan from shipsafecli.com/rotate
  *
  * RECOMMENDED ORDER:
  *   1. ship-safe rotate      ← revoke the key so it can't be used
@@ -21,6 +22,7 @@
 
 import fs from 'fs';
 import path from 'path';
+import readline from 'readline';
 import { execSync } from 'child_process';
 import chalk from 'chalk';
 import ora from 'ora';
@@ -461,10 +463,205 @@ function maskToken(token) {
 }
 
 // =============================================================================
-// MAIN COMMAND
+// PLAN-BASED ROTATION (--plan rotation-plan.json)
 // =============================================================================
 
+function promptHidden(question) {
+  return new Promise(resolve => {
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    try { stdin.setRawMode(true); } catch { /* not a TTY */ }
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    let value = '';
+    function onData(ch) {
+      if (ch === '\n' || ch === '\r' || ch === '\u0003') {
+        stdin.removeListener('data', onData);
+        try { stdin.setRawMode(!!wasRaw); } catch { /* ignore */ }
+        stdin.pause();
+        process.stdout.write('\n');
+        if (ch === '\u0003') process.exit(0);
+        resolve(value);
+      } else if (ch === '\u007f' || ch === '\b') {
+        value = value.slice(0, -1);
+      } else {
+        value += ch;
+        process.stdout.write('*');
+      }
+    }
+    stdin.on('data', onData);
+  });
+}
+
+async function updateVercelEnvVar(token, projectId, envId, envType, newValue, teamId) {
+  const params = new URLSearchParams();
+  if (teamId) params.set('teamId', teamId);
+  const url = `https://api.vercel.com/v9/projects/${projectId}/env/${envId}?${params}`;
+  const r = await fetch(url, {
+    method: 'PATCH',
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ value: newValue, type: envType || 'encrypted' }),
+  });
+  if (!r.ok) {
+    const body = await r.text();
+    throw new Error(`${r.status}: ${body}`);
+  }
+}
+
+export async function rotatePlanCommand(planFile) {
+  // ── 1. Read and validate plan ──────────────────────────────────────────────
+  const planPath = path.resolve(planFile);
+  if (!fs.existsSync(planPath)) {
+    output.error(`Plan file not found: ${planPath}`);
+    process.exit(1);
+  }
+
+  let plan;
+  try {
+    plan = JSON.parse(fs.readFileSync(planPath, 'utf-8'));
+  } catch {
+    output.error('Failed to parse rotation plan JSON. Make sure it was downloaded from shipsafecli.com/rotate');
+    process.exit(1);
+  }
+
+  const issuers = plan.issuers;
+  if (!issuers || typeof issuers !== 'object' || Object.keys(issuers).length === 0) {
+    output.success('No credentials in rotation plan — nothing to rotate.');
+    return;
+  }
+
+  const totalEnvVars = Object.values(issuers).reduce((sum, g) => sum + (g.affected?.length ?? 0), 0);
+  const issuerList = Object.entries(issuers);
+
+  output.header('Credential Rotation Plan');
+  console.log(chalk.gray(`\n  Plan generated: ${plan.generated ?? 'unknown'}`));
+  console.log(chalk.gray(`  Projects scanned: ${plan.projectsScanned ?? 'unknown'}`));
+  console.log(chalk.gray(`  Env vars to update: ${totalEnvVars}`));
+  console.log(chalk.gray(`  Credential types: ${issuerList.length}\n`));
+
+  // ── 2. Prompt for Vercel token ────────────────────────────────────────────
+  console.log(chalk.cyan.bold('  This command will update your Vercel env vars via the API.'));
+  console.log(chalk.gray('  Your token is used only for API calls and is never stored.\n'));
+
+  const vercelToken = await promptHidden(chalk.white('  Enter your Vercel API token: '));
+  if (!vercelToken) {
+    output.error('No Vercel token provided. Aborting.');
+    process.exit(1);
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const teamId = plan.teamId || '';
+
+  // ── 3. Process each issuer ────────────────────────────────────────────────
+  const auditLog = [];
+  let totalUpdated = 0;
+  let totalFailed = 0;
+
+  for (let i = 0; i < issuerList.length; i++) {
+    const [issuerKey, issuerData] = issuerList[i];
+    const affected = issuerData.affected ?? [];
+    if (affected.length === 0) continue;
+
+    const projectCount = new Set(affected.map(a => a.projectId)).size;
+    console.log(chalk.white.bold(`\n  [${i + 1}/${issuerList.length}] ${issuerData.name ?? issuerKey}`));
+    console.log(chalk.gray(`       ${affected.length} env var${affected.length !== 1 ? 's' : ''} across ${projectCount} project${projectCount !== 1 ? 's' : ''}`));
+
+    if (issuerData.rotateUrl) {
+      console.log(chalk.gray(`       Rotate URL: ${chalk.cyan(issuerData.rotateUrl)}`));
+      const opened = openBrowser(issuerData.rotateUrl);
+      if (opened) {
+        console.log(chalk.gray('       ✓ Opened in browser'));
+      } else {
+        console.log(chalk.yellow(`       → Open manually: ${issuerData.rotateUrl}`));
+      }
+    } else {
+      console.log(chalk.yellow('       No rotation URL — rotate manually in the provider dashboard.'));
+    }
+
+    // Get one new value per unique env var name for this issuer
+    const uniqueKeys = [...new Set(affected.map(a => a.envVar))];
+    const newValues = {};
+
+    for (const envKey of uniqueKeys) {
+      const newVal = await promptHidden(chalk.white(`\n  Paste new value for ${chalk.cyan(envKey)}: `));
+      if (!newVal) {
+        console.log(chalk.yellow(`  Skipping ${envKey} (no value entered)`));
+        continue;
+      }
+      newValues[envKey] = newVal;
+    }
+
+    if (Object.keys(newValues).length === 0) {
+      console.log(chalk.gray('  Skipped all env vars for this issuer.\n'));
+      continue;
+    }
+
+    // Update each affected env var via Vercel API
+    const spinner = ora({ text: `  Updating ${affected.length} env var${affected.length !== 1 ? 's' : ''}...`, color: 'cyan' }).start();
+    let issuerUpdated = 0;
+    let issuerFailed = 0;
+
+    for (const item of affected) {
+      const newVal = newValues[item.envVar];
+      if (!newVal) continue;
+      try {
+        await updateVercelEnvVar(vercelToken, item.projectId, item.envId, item.envType, newVal, teamId);
+        issuerUpdated++;
+        auditLog.push({
+          ts: new Date().toISOString(),
+          issuer: issuerKey,
+          project: item.projectName,
+          projectId: item.projectId,
+          envVar: item.envVar,
+          status: 'updated',
+        });
+      } catch (e) {
+        issuerFailed++;
+        auditLog.push({
+          ts: new Date().toISOString(),
+          issuer: issuerKey,
+          project: item.projectName,
+          projectId: item.projectId,
+          envVar: item.envVar,
+          status: 'failed',
+          error: e instanceof Error ? e.message : String(e),
+        });
+      }
+    }
+
+    totalUpdated += issuerUpdated;
+    totalFailed += issuerFailed;
+
+    if (issuerFailed === 0) {
+      spinner.succeed(chalk.green(`  Updated ${issuerUpdated} env var${issuerUpdated !== 1 ? 's' : ''}`));
+    } else {
+      spinner.warn(chalk.yellow(`  Updated ${issuerUpdated}, failed ${issuerFailed}`));
+    }
+  }
+
+  rl.close();
+
+  // ── 4. Write audit log ────────────────────────────────────────────────────
+  const auditPath = path.resolve('rotation-audit.json');
+  fs.writeFileSync(auditPath, JSON.stringify({ rotatedAt: new Date().toISOString(), auditLog }, null, 2));
+
+  // ── 5. Summary ────────────────────────────────────────────────────────────
+  console.log();
+  console.log(chalk.cyan.bold('  Rotation complete'));
+  console.log(chalk.white(`  ✓ ${totalUpdated} env var${totalUpdated !== 1 ? 's' : ''} updated`));
+  if (totalFailed > 0) {
+    console.log(chalk.red(`  ✗ ${totalFailed} failed — see rotation-audit.json for details`));
+  }
+  console.log(chalk.gray(`\n  Audit log written to: ${auditPath}`));
+  console.log(chalk.gray('  Run ship-safe scan . to confirm no hardcoded credentials remain.\n'));
+}
+
 export async function rotateCommand(targetPath = '.', options = {}) {
+  // If --plan flag provided, delegate to plan-based rotation
+  if (options.plan) {
+    return rotatePlanCommand(options.plan);
+  }
   const absolutePath = path.resolve(targetPath);
 
   if (!fs.existsSync(absolutePath)) {

package/cli/commands/watch.js

@@ -50,6 +50,11 @@ export async function watchCommand(targetPath = '.', options = {}) {
     return watchConfigs(absolutePath);
   }
 
+  // Stateful mode: persistent K2.6 session (subset of deep)
+  if (options.stateful) {
+    return watchStateful(absolutePath, options);
+  }
+
   // Deep mode: run full orchestrator on changes
   if (options.deep) {
     return watchDeep(absolutePath, options);
@@ -289,6 +294,135 @@ function showWatchStatus(rootPath) {
 // DEEP WATCH MODE (full orchestrator)
 // =============================================================================
 
+async function watchStateful(absolutePath, options = {}) {
+  const { StatefulWatcher } = await import('../agents/stateful-watcher.js');
+  const { ReconAgent } = await import('../agents/recon-agent.js');
+
+  const debounceMs = options.debounce || 2000;
+  const scoringEngine = new ScoringEngine();
+
+  console.log();
+  output.header('Ship Safe — Stateful Watch Mode (Kimi K2.6)');
+  console.log();
+  console.log(chalk.cyan('  Persistent security session — context builds over time'));
+  console.log(chalk.gray(`  Debounce: ${debounceMs}ms`));
+  console.log(chalk.gray('  Press Ctrl+C to stop'));
+  console.log();
+
+  const watcher = StatefulWatcher.create(absolutePath, {
+    provider: options.provider || 'kimi',
+    model: options.model || 'kimi-k2.6',
+    verbose: options.verbose,
+  });
+
+  if (!watcher) {
+    output.error('Stateful watch requires MOONSHOT_API_KEY. Set it and retry.');
+    process.exit(1);
+  }
+
+  // Prime session with baseline
+  const reconAgent = new ReconAgent();
+  console.log(chalk.gray('  Building baseline...'));
+  let recon;
+  try {
+    const reconResult = await reconAgent.analyze({ rootPath: absolutePath });
+    recon = Array.isArray(reconResult) ? {} : reconResult;
+  } catch { recon = {}; }
+  const files = await reconAgent.discoverFiles(absolutePath);
+  await watcher.setBaseline(recon, files);
+  console.log(chalk.green(`  Baseline set (${watcher.provider.name} / ${watcher.provider.model}). Watching...\n`));
+
+  let pendingFiles = new Set();
+  let debounceTimer = null;
+  let allFindings = [];
+
+  const dbDir = path.join(absolutePath, WATCH_DB_DIR);
+  const dbFile = path.join(dbDir, WATCH_DB_FILE);
+
+  const processChanges = async () => {
+    const changedFiles = [...pendingFiles];
+    pendingFiles.clear();
+    if (changedFiles.length === 0) return;
+
+    const timestamp = new Date().toLocaleTimeString();
+    console.log(chalk.gray(`  [${timestamp}] ${changedFiles.length} file(s) changed — stateful scan...`));
+
+    try {
+      const newFindings = await watcher.analyzeChanges(changedFiles);
+
+      if (newFindings.length === 0) {
+        console.log(chalk.green(`  [${timestamp}] ✔ Clean\n`));
+      } else {
+        allFindings = allFindings.concat(newFindings);
+        const scoreResult = scoringEngine.compute(allFindings);
+        const scoreColor = scoreResult.score >= 75 ? chalk.cyan : scoreResult.score >= 50 ? chalk.yellow : chalk.red;
+        console.log(`  [${timestamp}] ${chalk.white(`${newFindings.length} new finding(s)`)}: Score ${scoreColor(`${scoreResult.score}/100`)}`);
+        for (const f of newFindings.filter(f => f.severity === 'critical' || f.severity === 'high')) {
+          const relFile = path.relative(absolutePath, f.file || '');
+          const sev = f.severity === 'critical' ? chalk.red.bold('!!') : chalk.yellow(' !');
+          console.log(`    ${sev} ${f.title} — ${relFile}:${f.line}`);
+        }
+        console.log('');
+
+        // Persist
+        try {
+          if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+          const stats = watcher.getStats();
+          fs.writeFileSync(dbFile, JSON.stringify({
+            mode: 'stateful',
+            lastScan: new Date().toISOString(),
+            scanCount: stats.scanCount,
+            provider: stats.provider,
+            model: stats.model,
+            findings: allFindings.map(f => ({
+              file: path.relative(absolutePath, f.file || ''),
+              line: f.line,
+              severity: f.severity,
+              rule: f.rule,
+              title: f.title,
+            })),
+          }, null, 2));
+        } catch { /* non-fatal */ }
+      }
+    } catch (err) {
+      console.log(chalk.red(`  [${timestamp}] Scan error: ${err.message}\n`));
+    }
+  };
+
+  try {
+    const fsWatcher = fs.watch(absolutePath, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const relPath = filename.replace(/\\/g, '/');
+      for (const skipDir of SKIP_DIRS) {
+        if (relPath.includes(`${skipDir}/`)) return;
+      }
+      const ext = path.extname(filename).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) return;
+      if (SKIP_FILENAMES.has(path.basename(filename))) return;
+      if (filename.endsWith('.min.js') || filename.endsWith('.min.css')) return;
+
+      const fullPath = path.join(absolutePath, filename);
+      if (!fs.existsSync(fullPath)) return;
+
+      pendingFiles.add(fullPath);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(processChanges, debounceMs);
+    });
+
+    process.on('SIGINT', () => {
+      fsWatcher.close();
+      const stats = watcher.getStats();
+      console.log(`\n  Stateful watch stopped. ${stats.scanCount} scan(s), ${allFindings.length} total finding(s).\n`);
+      process.exit(0);
+    });
+
+    setInterval(() => {}, 1000 * 60 * 60);
+  } catch (err) {
+    output.error(`Stateful watch failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
 async function watchDeep(absolutePath, options = {}) {
   const { buildOrchestratorAsync } = await import('../agents/index.js');
   const { ReconAgent } = await import('../agents/recon-agent.js');

package/cli/providers/llm-provider.js

@@ -364,6 +364,8 @@ const OPENAI_COMPATIBLE_PRESETS = {
   perplexity: { baseUrl: 'https://api.perplexity.ai/chat/completions',               model: 'llama-3.1-sonar-large-128k-online', envKey: 'PERPLEXITY_API_KEY' },
   lmstudio:   { baseUrl: 'http://localhost:1234/v1/chat/completions',                model: null,                         envKey: null },
   xai:        { baseUrl: 'https://api.x.ai/v1/chat/completions',                    model: 'grok-3-mini',                envKey: 'XAI_API_KEY' },
+  kimi:       { baseUrl: 'https://api.moonshot.ai/v1/chat/completions',             model: 'kimi-k2.6',                  envKey: 'MOONSHOT_API_KEY' },
+  moonshot:   { baseUrl: 'https://api.moonshot.ai/v1/chat/completions',             model: 'kimi-k2.6',                  envKey: 'MOONSHOT_API_KEY' },
   // Gemma 4 via Ollama — runs fully local, no API key required
   // e4b: MoE 4B active params, ~8GB RAM;  27b: dense, ~20GB RAM
   gemma4:     { baseUrl: 'http://localhost:11434/v1/chat/completions',               model: 'gemma4:e4b',                 envKey: null },
@@ -375,6 +377,57 @@ class OpenAICompatibleProvider extends OpenAIProvider {
     super(apiKey, options);
     this.name = name;
   }
+
+  /** Models known to support OpenAI function calling reliably */
+  get supportsStructuredOutput() {
+    return /kimi|moonshot|gpt-4|grok|deepseek|mistral-large/i.test(this.model || '');
+  }
+
+  /**
+   * Complete with structured output via OpenAI tool-use format.
+   * Used by DeepAnalyzer multi-tier pipeline on non-Anthropic providers.
+   */
+  async completeWithTools(systemPrompt, userPrompt, toolName, inputSchema, options = {}) {
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options.model || this.model,
+        max_tokens: options.maxTokens || 2048,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+        tools: [{
+          type: 'function',
+          function: {
+            name: toolName,
+            description: `Report ${toolName} results`,
+            parameters: inputSchema,
+          },
+        }],
+        tool_choice: { type: 'function', function: { name: toolName } },
+      }),
+    });
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => '');
+      throw new Error(`${this.name} API error: HTTP ${response.status} ${body.slice(0, 200)}`);
+    }
+
+    const data = await response.json();
+    const toolCall = data.choices?.[0]?.message?.tool_calls?.[0];
+    if (!toolCall) return null;
+
+    try {
+      return JSON.parse(toolCall.function.arguments);
+    } catch {
+      return null;
+    }
+  }
 }
 
 // =============================================================================
@@ -439,7 +492,7 @@ export function createProvider(provider, apiKey, options = {}) {
   throw new Error(
     `Unknown LLM provider: "${provider}".\n` +
     `Built-in: anthropic, openai, google, ollama\n` +
-    `Presets:  groq, together, mistral, cohere, deepseek, perplexity, lmstudio, xai\n` +
+    `Presets:  groq, together, mistral, cohere, deepseek, perplexity, lmstudio, xai, kimi\n` +
     `Custom:   pass any name with --base-url <url>`
   );
 }
@@ -480,6 +533,8 @@ export function autoDetectProvider(rootPath, options = {}) {
     MISTRAL_API_KEY:   'mistral',
     DEEPSEEK_API_KEY:  'deepseek',
     XAI_API_KEY:       'xai',
+    MOONSHOT_API_KEY:  'kimi',
+    KIMI_API_KEY:      'kimi',
   };
 
   for (const [envVar, providerName] of Object.entries(envKeys)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ship-safe",
-  "version": "9.0.0",
-  "description": "AI-powered multi-agent security platform. 22 agents scan 80+ attack classes including Hermes Agent deployments (ASI-01–ASI-10), tool registry poisoning, function-call injection, skill permission drift, and agent attestation. Ship Safe × Hermes Agent.",
+  "version": "9.1.1",
+  "description": "AI-powered multi-agent security platform. 23 agents scan 80+ attack classes including AI integration supply chain (Vercel-class attacks), Hermes Agent deployments (ASI-01–ASI-10), tool registry poisoning, function-call injection, skill permission drift, and agent attestation. Ship Safe × Hermes Agent.",
   "main": "cli/index.js",
   "bin": {
     "ship-safe": "cli/bin/ship-safe.js"