@bergabruh/code-scanner 0.1.0

package/LICENSE

@@ -0,0 +1,55 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,186 @@
+# Mnogovid Code Scanner
+
+Mnogovid Code Scanner runs approved local security tools, turns their output
+into a readable Markdown report, and can add an evidence-bound AI explanation
+or an independent agent review. It does not install scanners, change project
+files, or apply fixes.
+
+## Install and run
+
+All hosts need Python 3 and the scanner executables they intend to run on
+`PATH`. The normal entrypoint bootstraps the profile and toolchain itself; the
+manual initializer below is only for inspection outside an agent session.
+
+Choose the section for your agent host. The scan modes and consent policy are
+the same everywhere; only installation and invocation differ.
+
+### Codex
+
+Install from the marketplace that contains the plugin:
+
+```bash
+codex plugin add mnogovid-code-scanner@<marketplace-name>
+```
+
+Open a new Codex task after installation, then invoke the plugin or its one
+unified command:
+
+```text
+@mnogovid-code-scanner
+/mnogovid-code-scanner:security-scan
+```
+
+The onboarding workflow checks the profile and scanner toolchain first. On the
+first run it asks before creating `.mnogovid-code-scanner.json`; later runs
+validate that profile and show missing adapters before asking how to analyze the
+evidence: adapters only, adapters plus AI triage, or adapters plus AI triage
+and independent review. Each scanner still needs a preview and approval.
+
+### Claude Code
+
+Install the plugin from your configured Claude Code marketplace. Its
+`.claude-plugin/plugin.json` and bundled MCP configuration provide the plugin
+entry point. Start Claude in the target project:
+
+```bash
+cd /path/to/project
+claude
+```
+
+Then invoke one of the plugin's slash commands:
+
+```text
+/security-scan
+```
+
+### OpenCode
+
+Add the package name to the project or global `opencode.json` and restart
+OpenCode:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@bergabruh/code-scanner"]
+}
+```
+
+OpenCode installs the package through Bun. The package starts its bundled,
+dependency-free Python scanner bridge itself; no `cwd`, MCP block, or copied
+`.opencode` assets are needed. Ask OpenCode to run a workspace security scan;
+it receives the `mnogovid_code_scanner` tool and must still request every
+recorded consent. `python3` and individual scanner executables remain system
+prerequisites and are never installed by the package.
+
+## Choose a mode
+
+| Mode | Use it when | Result |
+| --- | --- | --- |
+| Adapters only | You need reproducible scanner evidence. | Findings and coverage report. |
+| Adapters + AI triage | You want bounded, redacted AI classification. | Scanner evidence plus AI notes. |
+| Adapters + AI triage + independent review | You need a second assessment. | Scanner evidence, AI notes, and review. |
+
+The AI and agent are reviewers, not vulnerability scanners. Scanner evidence
+remains the source of record.
+
+## Scope and consent
+
+Say “scan the whole workspace” to authorize discovery and planning across the
+entire current project. The normal scanner exclusions still apply: `.git`,
+dependency/vendor directories, virtual environments, caches, build artifacts,
+and previous `.mnogovid` reports.
+
+Each permission is independent:
+
+| Permission | What it allows |
+| --- | --- |
+| Profile creation | Create a missing `.mnogovid-code-scanner.json`; an invalid profile stops the workflow. |
+| Network consent | Run a network-dependent scanner after it is separately approved. It is a policy gate, not network isolation. |
+| Per-scanner approval | Start one specific scanner process after its command preview and recorded lifecycle `runId`. |
+| AI sharing | Send only a bounded, redacted findings payload to the host AI. |
+| Agent review | Give the same bounded evidence and recorded AI triage to `security-triage`. |
+
+No permission implies another. A whole-workspace authorization does not permit
+network access, profile writing, or scanner execution by itself.
+
+## Report
+
+Every scan writes a new report to:
+
+```text
+<project>/.mnogovid/code-scanner/<timestamp>/result.md
+```
+
+The report is reader-first:
+
+1. **Verdict** — whether action or human review is needed and whether scan
+   coverage is incomplete.
+2. **What needs attention** — one item per finding with scanner, location,
+   severity, AI assessment, and a detailed explanation.
+3. **Scan coverage** — completed, incomplete, and failed scanners.
+4. **Coverage gaps** — a concrete recovery step and a short redacted
+   diagnostic when a scanner did not produce usable output.
+
+For AI and agent modes, every scanner finding must have a detailed AI note.
+The report cannot finalize with an approved but unrecorded AI or agent stage.
+
+## Initialize a project profile manually
+
+Initialization only discovers the project and checks which scanner executables
+are available; it does not run a scan, install software, or use the network.
+
+```bash
+python3 /path/to/mnogovid-code-scanner/scripts/init.py /path/to/project --json
+```
+
+To create the optional local profile and record that network scanners may be
+considered later:
+
+```bash
+python3 /path/to/mnogovid-code-scanner/scripts/init.py /path/to/project --json --write --allow-network
+```
+
+The command prints missing executables and package-manager installation
+templates. It never installs them. The unified workflow is preferred because it
+also validates the existing profile and binds every execution to a recorded
+preview.
+
+## Develop and update the Codex plugin
+
+After changing this local plugin, validate it and bump its normal semantic
+version before publishing:
+
+```bash
+python3 /path/to/plugin-creator/scripts/validate_plugin.py /path/to/mnogovid-code-scanner
+```
+
+Publish the updated marketplace source, then reinstall the plugin:
+
+```bash
+codex plugin add mnogovid-code-scanner@<marketplace-name>
+```
+
+Start a new Codex task after reinstalling so the updated skills and MCP tools
+are loaded.
+
+## Troubleshooting
+
+- **Profile missing:** rerun the unified workflow and approve profile creation.
+- **Profile invalid:** do not scan; inspect or deliberately replace it through
+  the manual initializer.
+- **Adapter missing:** install it through normal system administration, then
+  restart the workflow; the plugin never installs tools.
+- **MCP not visible:** reinstall/update the plugin and start a new Codex or
+  Claude Code session. In OpenCode, confirm `opencode mcp list` shows it as
+  connected after merging the example config.
+- **No findings:** this is not proof that the workspace is secure; review
+  skipped and failed adapters first.
+
+## Safety model
+
+Only allowlisted scanner executables run, always as an argv array without a
+shell. AI receives only the redacted payload produced by the MCP server. OSV
+advisory lookup requires separate network approval. The plugin never performs
+automatic remediation.
+
+Licensed under the Apache License 2.0. See [LICENSE](LICENSE).

package/opencode.js

@@ -0,0 +1,115 @@
+import { spawn } from "node:child_process"
+import { fileURLToPath } from "node:url"
+import { tool } from "@opencode-ai/plugin"
+
+const METHODS = new Set([
+  "security_catalog",
+  "security_doctor",
+  "security_bootstrap",
+  "security_plan",
+  "security_virtual_run",
+  "security_run",
+  "security_ingest",
+  "security_start_run",
+  "security_record_run",
+  "security_finalize_run",
+  "security_advisory_lookup",
+  "security_ai_triage_payload",
+])
+
+class PythonMcpBridge {
+  constructor(script) {
+    this.nextId = 1
+    this.pending = new Map()
+    this.buffer = ""
+    this.queue = Promise.resolve()
+    this.stderr = ""
+    this.child = spawn("python3", [script], { stdio: ["pipe", "pipe", "pipe"] })
+    this.child.stdout.setEncoding("utf8")
+    this.child.stdout.on("data", (chunk) => this.receive(chunk))
+    this.child.stderr.setEncoding("utf8")
+    this.child.stderr.on("data", (chunk) => {
+      this.stderr = (this.stderr + chunk).slice(-4096)
+    })
+    this.child.on("error", (error) => this.failAll(error))
+    this.child.on("exit", (code, signal) => {
+      this.failAll(new Error(`Python scanner exited (${signal ?? code ?? "unknown"})${this.stderr ? `: ${this.stderr}` : ""}`))
+    })
+    process.once("exit", () => this.child.kill())
+  }
+
+  receive(chunk) {
+    this.buffer += chunk
+    let newline
+    while ((newline = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, newline)
+      this.buffer = this.buffer.slice(newline + 1)
+      if (!line.trim()) continue
+      try {
+        const message = JSON.parse(line)
+        const pending = this.pending.get(message.id)
+        if (!pending) continue
+        this.pending.delete(message.id)
+        if (message.error) pending.reject(new Error(message.error.message ?? "Python scanner protocol error"))
+        else pending.resolve(message.result)
+      } catch (error) {
+        this.failAll(new Error(`Invalid response from Python scanner: ${error.message}`))
+      }
+    }
+  }
+
+  failAll(error) {
+    for (const { reject } of this.pending.values()) reject(error)
+    this.pending.clear()
+  }
+
+  call(method, args) {
+    const request = () => new Promise((resolve, reject) => {
+      if (this.child.exitCode !== null || this.child.killed) {
+        reject(new Error("Python scanner is unavailable; verify that python3 is installed."))
+        return
+      }
+      const id = this.nextId++
+      this.pending.set(id, { resolve, reject })
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method: "tools/call", params: { name: method, arguments: args } })}\n`)
+    })
+    const result = this.queue.then(request, request)
+    this.queue = result.catch(() => undefined)
+    return result
+  }
+}
+
+function parseArguments(raw) {
+  try {
+    const value = JSON.parse(raw)
+    if (!value || Array.isArray(value) || typeof value !== "object") throw new Error("must be a JSON object")
+    return value
+  } catch (error) {
+    throw new Error(`argumentsJson ${error.message}`)
+  }
+}
+
+export const MnogovidCodeScanner = async () => {
+  const script = fileURLToPath(new URL("./scripts/security_mcp.py", import.meta.url))
+  const bridge = new PythonMcpBridge(script)
+
+  return {
+    tool: {
+      mnogovid_code_scanner: tool({
+        description: "Call one consent-gated Mnogovid Code Scanner operation. Valid operations: security_catalog, security_doctor, security_bootstrap, security_plan, security_virtual_run, security_run, security_ingest, security_start_run, security_record_run, security_finalize_run, security_advisory_lookup, security_ai_triage_payload. Pass argumentsJson as a JSON object. The Python core validates workspace paths, recorded lifecycle and consent before any scanner starts.",
+        args: {
+          operation: tool.schema.string(),
+          argumentsJson: tool.schema.string(),
+        },
+        async execute({ operation, argumentsJson }) {
+          if (!METHODS.has(operation)) return `Unknown Mnogovid Code Scanner operation: ${operation}`
+          try {
+            return JSON.stringify(await bridge.call(operation, parseArguments(argumentsJson)))
+          } catch (error) {
+            return JSON.stringify({ error: error.message })
+          }
+        },
+      }),
+    },
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bergabruh/code-scanner",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for consent-gated workspace security scanning.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./opencode.js",
+  "module": "./opencode.js",
+  "exports": "./opencode.js",
+  "files": [
+    "opencode.js",
+    "scripts/*.py",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "security",
+    "sast"
+  ],
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.18.11"
+  },
+  "scripts": {
+    "check": "node --check opencode.js"
+  },
+  "homepage": "https://github.com/BergaBruh/mnogovid",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BergaBruh/mnogovid.git"
+  }
+}

package/scripts/init.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Initialize a non-destructive Mnogovid Code Scanner project profile.
+
+The script only inspects the target directory by default.  Pass ``--write`` to
+create the missing ``.mnogovid-code-scanner.json`` profile; an existing profile is
+never changed unless ``--force`` is supplied as well.  ``--allow-network`` is
+recorded as a preference for later scanner runs and never opens a connection.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import platform
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from security_mcp import ADAPTERS, discover, recommend
+
+
+PROFILE_NAME = ".mnogovid-code-scanner.json"
+PACKAGE_MANAGER_HINTS = (
+    ("apt", "apt-get", "sudo apt-get install <package>"),
+    ("dnf", "dnf", "sudo dnf install <package>"),
+    ("yum", "yum", "sudo yum install <package>"),
+    ("pacman", "pacman", "sudo pacman -S <package>"),
+    ("zypper", "zypper", "sudo zypper install <package>"),
+    ("Homebrew", "brew", "brew install <package>"),
+    ("winget", "winget", "winget install <package>"),
+    ("Chocolatey", "choco", "choco install <package>"),
+    ("Scoop", "scoop", "scoop install <package>"),
+    ("pipx", "pipx", "pipx install <package>"),
+    ("Cargo", "cargo", "cargo install <package>"),
+    ("Go", "go", "go install <module>@latest"),
+    ("npm", "npm", "npm install --global <package>"),
+)
+
+
+def installation_guide(missing: list[str]) -> dict[str, object]:
+    managers = [
+        {"name": name, "executable": executable, "commandTemplate": command}
+        for name, executable, command in PACKAGE_MANAGER_HINTS
+        if shutil.which(executable) is not None
+    ]
+    return {
+        "message": "If you want to add more tools, follow the instructions for a package manager available on this system.",
+        "platform": platform.platform(),
+        "missingExecutables": missing,
+        "packageManagers": managers,
+        "note": "Replace <package> or <module> with the scanner's verified package or module name before installing.",
+    }
+
+
+def build_result(project: Path) -> dict[str, object]:
+    found = discover(project)
+    recommended = recommend(found)
+    checks = [
+        {
+            "adapter": adapter,
+            "executable": ADAPTERS[adapter]["exe"],
+            "available": shutil.which(ADAPTERS[adapter]["exe"]) is not None,
+            "requiresNetwork": ADAPTERS[adapter]["network"],
+        }
+        for adapter in recommended
+    ]
+    missing = sorted({str(item["executable"]) for item in checks if not item["available"]})
+    return {
+        "project": str(project),
+        "detected": {
+            "ecosystems": found["ecosystems"],
+            "languages": found["languages"],
+            "surfaces": found["surfaces"],
+        },
+        "checks": checks,
+        "availableAdapters": [item["adapter"] for item in checks if item["available"]],
+        "missingExecutables": missing,
+        "installationGuide": installation_guide(missing),
+    }
+
+
+def profile(result: dict[str, object], allow_network: bool) -> dict[str, object]:
+    return {
+        "schemaVersion": 1,
+        "generatedBy": "mnogovid-code-scanner init",
+        "generatedAt": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "recommendedAdapters": [item["adapter"] for item in result["checks"]],
+        "availableAdapters": result["availableAdapters"],
+        "allowNetwork": allow_network,
+        "installationGuide": result["installationGuide"],
+        "notes": [
+            "Review recommendedAdapters before running scanners.",
+            "Network-dependent scanners still require explicit host approval.",
+        ],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Check project-relevant security scanners and optionally create a local profile."
+    )
+    parser.add_argument("project", nargs="?", default=".", help="project directory (default: current directory)")
+    parser.add_argument("--write", action="store_true", help=f"create {PROFILE_NAME} if it is missing")
+    parser.add_argument("--force", action="store_true", help=f"replace an existing {PROFILE_NAME}; requires --write")
+    parser.add_argument(
+        "--allow-network",
+        action="store_true",
+        help="record approval for network-dependent scanner runs; this command does not use the network",
+    )
+    parser.add_argument("--json", action="store_true", help="print the result as JSON")
+    args = parser.parse_args()
+    if args.force and not args.write:
+        parser.error("--force requires --write")
+
+    project = Path(args.project).expanduser().resolve()
+    if not project.is_dir():
+        parser.error(f"project is not a directory: {project}")
+
+    result = build_result(project)
+    destination = project / PROFILE_NAME
+    existed = destination.exists()
+    if args.write and (not existed or args.force):
+        destination.write_text(json.dumps(profile(result, args.allow_network), indent=2) + "\n", encoding="utf-8")
+        result["profile"] = {"path": str(destination), "action": "replaced" if existed else "created"}
+    elif args.write:
+        result["profile"] = {"path": str(destination), "action": "unchanged", "reason": "already exists"}
+    else:
+        result["profile"] = {"path": str(destination), "action": "not_written"}
+    result["allowNetwork"] = args.allow_network
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(f"Project: {project}")
+        for item in result["checks"]:
+            status = "available" if item["available"] else "missing"
+            print(f"- {item['adapter']}: {item['executable']} ({status})")
+        if result["missingExecutables"]:
+            print("Missing programs: " + ", ".join(result["missingExecutables"]))
+        guide = result["installationGuide"]
+        print("If you want to add more tools, follow the instructions for this system:")
+        print(f"- Platform: {guide['platform']}")
+        for manager in guide["packageManagers"]:
+            print(f"- {manager['name']}: {manager['commandTemplate']}")
+        if not guide["packageManagers"]:
+            print("- No supported package manager was detected; use the scanner's official installation instructions.")
+        print(f"Profile: {result['profile']['action']} ({destination})")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/security_mcp.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+"""Dependency-free MCP security scanner orchestrator.
+
+This is deliberately independent from Mnogovid/Rust. It discovers a workspace,
+plans allowlisted scanner commands, executes them without a shell only after a
+host-approved tool call, normalizes common report formats, and creates a
+bounded/redacted payload for the host model's AI triage.
+"""
+from __future__ import annotations
+
+import json, os, re, shutil, subprocess, sys, time, urllib.error, urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+MAX_OUTPUT = 256 * 1024
+RUNS: dict[str, dict[str, Any]] = {}
+IGNORE = {".git", "node_modules", "target", ".venv", "__pycache__", "vendor", ".mnogovid"}
+PROFILE_NAME = ".mnogovid-code-scanner.json"
+ADAPTERS: dict[str, dict[str, Any]] = {
+    "semgrep": {"category":"sast","exe":"semgrep","network":True,"cmd":lambda p:["--json","--config","auto",str(p)]},
+    "gosec": {"category":"sast","exe":"gosec","network":False,"cmd":lambda p:["-fmt=json","./..."],"cwd":True},
+    "bandit": {"category":"sast","exe":"bandit","network":False,"cmd":lambda p:["-f","json","-r",str(p)]},
+    "brakeman": {"category":"sast","exe":"brakeman","network":False,"cmd":lambda p:["-f","json","-p",str(p)]},
+    "gitleaks": {"category":"secrets","exe":"gitleaks","network":False,"cmd":lambda p:["detect","--source",str(p),"--report-format","json","--no-banner"]},
+    "trufflehog": {"category":"secrets","exe":"trufflehog","network":True,"cmd":lambda p:["filesystem",str(p),"--json"]},
+    "detect-secrets": {"category":"secrets","exe":"detect-secrets","network":False,"cmd":lambda p:["scan",str(p)]},
+    "trivy-fs": {"category":"sca","exe":"trivy","network":True,"cmd":lambda p:["fs","--format","json",str(p)]},
+    "osv-scanner": {"category":"sca","exe":"osv-scanner","network":True,"cmd":lambda p:["scan","source","--format","json",str(p)]},
+    "grype": {"category":"sca","exe":"grype","network":True,"cmd":lambda p:[f"dir:{p}","-o","json"]},
+    "syft": {"category":"sbom","exe":"syft","network":False,"cmd":lambda p:[f"dir:{p}","-o","json"]},
+    "cargo-audit": {"category":"sca","exe":"cargo-audit","network":True,"cmd":lambda p:["audit","--json"],"cwd":True},
+    "cargo-deny": {"category":"sca","exe":"cargo-deny","network":True,"cmd":lambda p:["check","advisories","--format","json"],"cwd":True},
+    "pip-audit": {"category":"sca","exe":"pip-audit","network":True,"cmd":lambda p:["-f","json"] ,"cwd":True},
+    "npm-audit": {"category":"sca","exe":"npm","network":True,"cmd":lambda p:["audit","--json"],"cwd":True},
+    "pnpm-audit": {"category":"sca","exe":"pnpm","network":True,"cmd":lambda p:["audit","--json"],"cwd":True},
+    "yarn-audit": {"category":"sca","exe":"yarn","network":True,"cmd":lambda p:["audit","--json"],"cwd":True},
+    "govulncheck": {"category":"sca","exe":"govulncheck","network":True,"cmd":lambda p:["./..."],"cwd":True},
+    "bundler-audit": {"category":"sca","exe":"bundle-audit","network":True,"cmd":lambda p:["check","--format","json"],"cwd":True},
+    "composer-audit": {"category":"sca","exe":"composer","network":True,"cmd":lambda p:["audit","--format=json"],"cwd":True},
+    "checkov": {"category":"iac","exe":"checkov","network":False,"cmd":lambda p:["-d",str(p),"-o","json"]},
+    "kics": {"category":"iac","exe":"kics","network":False,"cmd":lambda p:["scan","-p",str(p),"--output-path","-"]},
+}
+TOOLS = [
+ {"name":"security_catalog","description":"List independent scanner adapters, categories, executables, and advisory/web data requirements.","inputSchema":{"type":"object","properties":{},"additionalProperties":False}},
+ {"name":"security_doctor","description":"Discover languages, manifests, infrastructure files, recommended scanners, and installed executables. Does not execute a scanner.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"}},"required":["workspace"],"additionalProperties":False}},
+ {"name":"security_bootstrap","description":"Check the code-scanner profile and workspace toolchain before a scan. Set createProfile=true only after explicit user approval to create a missing profile; it does not execute a scanner.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"createProfile":{"type":"boolean"}},"required":["workspace"],"additionalProperties":False}},
+ {"name":"security_plan","description":"Create a non-executing workspace scan plan from detected files and available scanner programs.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"}},"required":["workspace"],"additionalProperties":False}},
+ {"name":"security_virtual_run","description":"Preview one allowlisted scanner command without executing it.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"adapter":{"type":"string"},"allowNetwork":{"type":"boolean"}},"required":["workspace","adapter"],"additionalProperties":False}},
+ {"name":"security_run","description":"Execute one allowlisted scanner without a shell. It requires a started lifecycle and an identical recorded preview; network-dependent scanners require recorded lifecycle consent.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"runId":{"type":"string"},"adapter":{"type":"string"}},"required":["workspace","runId","adapter"],"additionalProperties":False}},
+ {"name":"security_ingest","description":"Normalize an existing local JSON, JSON-lines, or SARIF report without executing any program.","inputSchema":{"type":"object","properties":{"report":{"type":"string"},"format":{"enum":["json","sarif"]},"adapter":{"type":"string"}},"required":["report","format"],"additionalProperties":False}},
+ {"name":"security_start_run","description":"Create an in-memory, schema-owned scan lifecycle. Record only the user approvals supplied by the host; it does not execute or write anything.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"mode":{"enum":["scan","scan-ai","scan-agent"]},"consent":{"type":"object","properties":{"profileWrite":{"type":"boolean"},"network":{"type":"boolean"},"aiTriage":{"type":"boolean"},"agentReview":{"type":"boolean"}},"additionalProperties":False}},"required":["workspace","mode","consent"],"additionalProperties":False}},
+ {"name":"security_record_run","description":"Append scanner evidence, a preview, a skipped-scanner reason, host-AI triage, or independent agent review to a durable started scan lifecycle. It does not execute a process.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"runId":{"type":"string"},"kind":{"enum":["scanner","preview","skipped","host_ai_triage","agent_review"]},"entry":{"type":"object"}},"required":["workspace","runId","kind","entry"],"additionalProperties":False}},
+ {"name":"security_finalize_run","description":"Finalize a durable started scan lifecycle and store its schema-owned redacted Markdown report, including any recorded host-AI triage and independent agent review. The result is <workspace>/.mnogovid/code-scanner/<unixtime>/result.md.","inputSchema":{"type":"object","properties":{"workspace":{"type":"string"},"runId":{"type":"string"},"initialization":{"type":"object"},"doctor":{"type":"object"},"plan":{"type":"object"},"hostAiTriage":{"type":"object"},"aiTriage":{"type":"object"},"agentReview":{"type":"object"}},"required":["workspace","runId"],"additionalProperties":False}},
+ {"name":"security_advisory_lookup","description":"Query the OSV vulnerability advisory website for one package version. It makes an HTTPS request only when allowNetwork=true.","inputSchema":{"type":"object","properties":{"ecosystem":{"type":"string"},"package":{"type":"string"},"version":{"type":"string"},"allowNetwork":{"type":"boolean"}},"required":["ecosystem","package","version"],"additionalProperties":False}},
+ {"name":"security_ai_triage_payload","description":"Prepare bounded, secret-redacted findings for host-model AI triage. It does not contact any model or website itself.","inputSchema":{"type":"object","properties":{"findings":{"type":"array"},"remediation":{"type":"boolean"}},"required":["findings"],"additionalProperties":False}},
+]
+
+def workspace(value: Any) -> Path:
+    if not isinstance(value,str) or not value: raise ValueError("workspace must be a non-empty string")
+    path=Path(value).expanduser().resolve()
+    if not path.is_dir(): raise ValueError(f"workspace is not a directory: {path}")
+    return path
+
+def discover(root: Path) -> dict[str, Any]:
+    manifests=[]; languages=set(); surfaces=set(); visited=0
+    map_lang={".rs":"rust",".py":"python",".go":"go",".js":"javascript",".ts":"typescript",".java":"java",".rb":"ruby",".php":"php",".cs":"csharp",".cpp":"cpp",".c":"cpp"}
+    markers={"Cargo.toml":"cargo","package.json":"npm","pnpm-lock.yaml":"pnpm","yarn.lock":"yarn","pyproject.toml":"pypi","requirements.txt":"pypi","go.mod":"go","Gemfile.lock":"rubygems","composer.lock":"composer","pom.xml":"maven","build.gradle":"gradle","packages.lock.json":"nuget"}
+    for base,dirs,files in os.walk(root):
+        dirs[:]=[d for d in dirs if d not in IGNORE]
+        for name in files:
+            visited+=1; path=Path(base,name); rel=str(path.relative_to(root))
+            if name in markers: manifests.append({"path":rel,"ecosystem":markers[name]})
+            if name.startswith("Dockerfile"): surfaces.add("containers")
+            if path.suffix==".tf": surfaces.add("terraform")
+            if any(x in rel.lower() for x in ("k8s/","kubernetes/","helm/")) and path.suffix in (".yml",".yaml"): surfaces.add("kubernetes")
+            if path.suffix in map_lang: languages.add(map_lang[path.suffix])
+    ecosystems=sorted({x["ecosystem"] for x in manifests})
+    return {"workspacePath":str(root),"manifests":manifests,"ecosystems":ecosystems,"languages":sorted(languages),"surfaces":sorted(surfaces),"visitedEntries":visited}
+
+def recommend(found: dict[str,Any]) -> list[str]:
+    eco=set(found["ecosystems"]); lang=set(found["languages"]); surf=set(found["surfaces"]); out=["gitleaks"]
+    if lang: out.append("semgrep")
+    if "rust" in lang: out += ["cargo-audit","cargo-deny"]
+    if "python" in lang: out += ["bandit","pip-audit"]
+    if "go" in lang: out += ["gosec","govulncheck"]
+    if "ruby" in lang: out += ["brakeman","bundler-audit"]
+    if "npm" in eco or "pnpm" in eco or "yarn" in eco: out.append("npm-audit")
+    if "composer" in eco: out.append("composer-audit")
+    if surf: out += ["checkov","kics","trivy-fs"]
+    if eco: out += ["osv-scanner","grype","syft"]
+    return list(dict.fromkeys(out))
+
+def plan(root: Path) -> dict[str,Any]:
+    found=discover(root); ids=recommend(found)
+    runs=[]
+    for ident in ids:
+        item=ADAPTERS[ident]; exe=shutil.which(item["exe"])
+        runs.append({"adapter":ident,"category":item["category"],"executable":item["exe"],"available":bool(exe),"requiresNetwork":item["network"],"execution":"not_executed"})
+    return {**found,"recommendedAdapters":ids,"runs":runs,"networkUsed":False,"processStarted":False}
+
+def bootstrap(root: Path, create_profile: bool) -> dict[str,Any]:
+    if not isinstance(create_profile,bool): raise ValueError("createProfile must be boolean when supplied")
+    profile_path=root/PROFILE_NAME
+    profile: dict[str,Any]
+    if profile_path.exists() or profile_path.is_symlink():
+        if profile_path.is_symlink() or not profile_path.is_file(): raise ValueError("refusing non-regular or symlinked code-scanner profile")
+        try: saved=json.loads(profile_path.read_text(encoding="utf-8"))
+        except (OSError,json.JSONDecodeError): saved=None
+        valid=isinstance(saved,dict) and saved.get("schemaVersion")==1 and saved.get("generatedBy") in {"mnogovid-code-scanner init","mnogovid-code-scanner bootstrap"}
+        profile={"path":str(profile_path),"action":"verified" if valid else "invalid","valid":valid}
+    elif create_profile:
+        discovered=plan(root)
+        saved={"schemaVersion":1,"generatedBy":"mnogovid-code-scanner bootstrap","generatedAt":datetime.now(timezone.utc).replace(microsecond=0).isoformat(),"recommendedAdapters":discovered["recommendedAdapters"],"availableAdapters":[item["adapter"] for item in discovered["runs"] if item["available"]],"notes":["This profile records discovery only and grants no scanner permission.","Every scanner still requires an explicit preview and approval."]}
+        descriptor=os.open(profile_path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|getattr(os,"O_NOFOLLOW",0),0o600)
+        with os.fdopen(descriptor,"w",encoding="utf-8") as handle: handle.write(json.dumps(saved,ensure_ascii=False,indent=2)+"\n")
+        profile={"path":str(profile_path),"action":"created","valid":True}
+    else: profile={"path":str(profile_path),"action":"missing","valid":False}
+    discovered=plan(root)
+    return {"profile":profile,"doctor":{**discovered,"missingExecutables":[item["executable"] for item in discovered["runs"] if not item["available"]]},"processStarted":False}
+
+def command(root: Path, ident: str) -> tuple[dict[str,Any],list[str],str]:
+    if ident not in ADAPTERS: raise ValueError(f"unknown adapter: {ident}")
+    spec=ADAPTERS[ident]; args=spec["cmd"](root); exe=shutil.which(spec["exe"])
+    return spec, [exe or spec["exe"],*args], str(root if spec.get("cwd") else root)
+
+def redact(value: Any) -> Any:
+    if isinstance(value,dict): return {str(k):redact("[REDACTED]" if re.search(r"(token|secret|password|api.?key|private.?key)",str(k),re.I) else v) for k,v in value.items()}
+    if isinstance(value,list): return [redact(v) for v in value]
+    if isinstance(value,str) and re.search(r"(ghp_|sk-|AKIA|-----BEGIN|(?:token|secret|password|api[_-]?key)\s*[=:])",value,re.I): return "[REDACTED]"
+    return value
+
+def markdown_cell(value: Any) -> str:
+    if value is None: return "—"
+    if isinstance(value,bool): return "yes" if value else "no"
+    if isinstance(value,(dict,list)): return "See details below"
+    return str(value).replace("\\", "\\\\").replace("|", "\\|").replace("\n", "<br>")
+
+def markdown_table(headers: list[str], rows: list[list[Any]]) -> list[str]:
+    if not rows: return ["No data recorded.", ""]
+    return [
+        "| " + " | ".join(headers) + " |",
+        "| " + " | ".join("---" for _ in headers) + " |",
+        *["| " + " | ".join(markdown_cell(cell) for cell in row) + " |" for row in rows],
+        "",
+    ]
+
+def markdown_value(title: str, value: Any, level: int = 2) -> list[str]:
+    lines = ["#" * level + " " + title, ""]
+    if isinstance(value,dict):
+        scalars = [(str(key), item) for key,item in value.items() if not isinstance(item,(dict,list))]
+        if scalars: lines += markdown_table(["Field","Value"], scalars)
+        for key,item in value.items():
+            if isinstance(item,(dict,list)): lines += markdown_value(str(key),item,level+1)
+    elif isinstance(value,list) and all(isinstance(item,dict) for item in value):
+        keys = list(dict.fromkeys(str(key) for item in value for key in item if not isinstance(item[key],(dict,list))))[:8]
+        lines += markdown_table(keys, [[item.get(key) for key in keys] for item in value]) if keys else ["No scalar fields recorded.", ""]
+    elif isinstance(value,list):
+        lines += [f"- {markdown_cell(item)}" for item in value] or ["No data recorded."]
+        lines.append("")
+    else: lines += [markdown_cell(value), ""]
+    return lines
+
+def scanner_results(report: dict[str, Any]) -> list[dict[str, Any]]:
+    candidates = report.get("scannerResults", report.get("results", []))
+    return [item for item in candidates if isinstance(item,dict)] if isinstance(candidates,list) else []
+
+def findings_from(report: dict[str, Any], runs: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    findings = [item for item in report.get("findings",[]) if isinstance(item,dict)] if isinstance(report.get("findings"),list) else []
+    for run in runs:
+        for finding in run.get("findings",[]) if isinstance(run.get("findings"),list) else []:
+            if isinstance(finding,dict): findings.append({"adapter":run.get("adapter"),**finding})
+    return findings[:200]
+
+def finding_value(finding: dict[str, Any], names: tuple[str, ...]) -> Any:
+    for name in names:
+        value = finding.get(name)
+        if value not in (None,""): return value
+    for container in ("package","dependency","artifact","component"):
+        nested = finding.get(container)
+        if isinstance(nested,dict):
+            value = finding_value(nested,names)
+            if value not in (None,""): return value
+    return None
+
+def finding_location_or_library(finding: dict[str, Any]) -> str:
+    location = finding_value(finding,("location","path","file","uri"))
+    line = finding_value(finding,("line","lineNumber","startLine"))
+    library = finding_value(finding,("library","packageName","name","componentName"))
+    parts = []
+    if location: parts.append(f"{location}:{line}" if line else str(location))
+    if library and str(library) != str(location): parts.append(str(library))
+    return "; ".join(parts) if parts else "—"
+
+def vulnerability_row(finding: dict[str, Any]) -> list[Any]:
+    return [
+        finding_value(finding,("vulnerability","ruleId","id","cve","advisory","title")),
+        finding_value(finding,("severity","level","risk")),
+        finding_value(finding,("affectedVersion","installedVersion","currentVersion","version")),
+        finding_value(finding,("fixedVersion","fixedIn","fixVersion","fixed_version")),
+        finding_location_or_library(finding),
+    ]
+
+def finding_title(finding: dict[str, Any]) -> str:
+    identifier = finding_value(finding,("ruleId","id","cve","advisory","testId"))
+    title = finding_value(finding,("title","vulnerability","issueText","message"))
+    if identifier and title: return f"{identifier}: {title}"
+    return str(title or identifier or "Scanner finding")
+
+def scan_verdict(findings: list[dict[str, Any]], notes: dict[int, dict[str, Any]]) -> tuple[str,str]:
+    if not findings: return ("No scanner findings", "No findings were reported by completed scanners. This is not proof that the project has no vulnerabilities.")
+    classifications = [str(note.get("classification","")).lower() for note in notes.values()]
+    if any(value=="true_positive" for value in classifications): return ("Action required", "At least one scanner finding was assessed as a likely real vulnerability.")
+    if any(value=="needs_review" for value in classifications) or not notes: return ("Review required", "Scanner findings need human verification before they are treated as vulnerabilities or dismissed.")
+    return ("No confirmed vulnerabilities", "The recorded AI assessment did not confirm the scanner findings; retain the evidence for review.")
+
+def scanner_recovery(run: dict[str, Any]) -> str:
+    adapter = str(run.get("adapter") or "scanner")
+    steps = {
+        "semgrep":"Re-run the previewed Semgrep command and confirm that it produces JSON with a `results` array. If configuration download was blocked, grant network access for that run or use a local ruleset.",
+        "osv-scanner":"Run `osv-scanner --version`, then re-run the previewed OSV Scanner command. If it still fails, update or reinstall OSV Scanner and retain its diagnostic output for review.",
+        "pip-audit":"Re-run `pip-audit -f json` from the project root. If it cannot resolve dependencies, verify the project dependency files and the approved network connection.",
+        "npm-audit":"Re-run `npm audit --json` from the project root. If it cannot resolve the registry, verify the lockfile and the approved network connection.",
+        "grype":"Re-run the previewed Grype command. If its vulnerability database could not update, verify the approved network connection and refresh the local Grype database.",
+    }
+    diagnostic = str(redact(run.get("stderrSnippet") or "")).strip().replace("\n"," ")
+    diagnostic = diagnostic[:500]
+    suffix = f" Diagnostic (redacted): {diagnostic}" if diagnostic else ""
+    return steps.get(adapter,"Re-run the previewed scanner command and inspect its diagnostic output before treating this area as covered.") + suffix
+
+def host_ai_notes(report: dict[str, Any], finding_count: int) -> dict[int, dict[str, Any]]:
+    triage = report.get("hostAiTriage")
+    items = triage.get("findingNotes") if isinstance(triage,dict) else None
+    if not isinstance(items,list): return {}
+    notes: dict[int,dict[str,Any]] = {}
+    for item in items:
+        if isinstance(item,dict) and isinstance(item.get("findingIndex"),int) and 0 <= item["findingIndex"] < finding_count:
+            notes[item["findingIndex"]]=item
+    return notes
+
+def validate_host_ai_triage(run: dict[str, Any], entry: dict[str, Any]) -> None:
+    finding_count = sum(len(item.get("findings",[])) for item in run["scannerResults"] if isinstance(item.get("findings"),list))
+    if finding_count == 0: return
+    notes = entry.get("findingNotes")
+    if not isinstance(notes,list): raise ValueError("host-AI triage must include findingNotes for every scanner finding")
+    indexed = {item.get("findingIndex"):item for item in notes if isinstance(item,dict) and isinstance(item.get("findingIndex"),int)}
+    missing = [index for index in range(finding_count) if not isinstance(indexed.get(index,{}).get("note"),str) or not indexed[index]["note"].strip()]
+    if missing: raise ValueError(f"host-AI triage is missing detailed notes for finding indexes: {missing}")
+
+def render_report(root: Path, mode: str, report_id: str, generated: str, report: dict[str, Any]) -> str:
+    lines = ["# Security scan report", ""]
+    runs = scanner_results(report); findings = findings_from(report,runs); ai_notes = host_ai_notes(report,len(findings))
+    completed = [run for run in runs if run.get("resultStatus")=="complete"]
+    incomplete = [run for run in runs if run.get("resultStatus")=="incomplete"]
+    failed = [run for run in runs if run.get("resultStatus")=="failed"]
+    verdict, explanation = scan_verdict(findings,ai_notes)
+    lines += ["## Verdict", "", f"**{verdict}.** {explanation}", ""]
+    lines += markdown_table(["Workspace","Mode","Findings","Completed scanners","Incomplete / failed"], [[root,mode,len(findings),len(completed),len(incomplete) + len(failed)]])
+    if incomplete or failed:
+        lines += ["### Coverage gaps", ""]
+        for run in incomplete:
+            lines += [f"- **{run.get('adapter') or 'unknown'}:** exited with code {run.get('exitCode')} but produced no findings that this version could normalize. This is not a clean result. **How to fix:** {scanner_recovery(run)}"]
+        for run in failed:
+            lines += [f"- **{run.get('adapter') or 'unknown'}:** stopped with code {run.get('exitCode')} before a usable result was produced. This does not prove that no vulnerabilities exist. **How to fix:** {scanner_recovery(run)}"]
+        lines.append("")
+    lines += ["## What needs attention", ""]
+    if not findings:
+        lines += ["No scanner findings were reported. Review failed or skipped scanners before treating this as a clean result.", ""]
+    for index,finding in enumerate(findings):
+        note = ai_notes.get(index,{})
+        lines += [f"### {index + 1}. {finding_title(finding)}", ""]
+        lines += [f"**Scanner:** {finding.get('adapter') or 'unknown'}  ", f"**Severity:** {finding_value(finding,('severity','level','risk')) or 'not provided'}  ", f"**Location:** {finding_location_or_library(finding)}", ""]
+        if note:
+            lines += [f"**AI assessment:** {note.get('classification','needs_review')} (confidence: {note.get('confidence','not provided')})  ", f"**Why it matters:** {note.get('note','No detailed AI note was recorded.')}", ""]
+        elif mode in ("scan-ai","scan-agent"):
+            lines += ["**AI assessment:** not recorded — this report is incomplete and should not have been finalized.", ""]
+        else:
+            lines += ["**Next step:** inspect the surrounding code and decide whether this scanner finding is exploitable or a false positive.", ""]
+    lines += ["## Scan coverage", ""]
+    coverage_rows=[]
+    for run in runs:
+        count=(run.get("counts") or {}).get("findings")
+        if count is None: count=len(run.get("findings",[])) if isinstance(run.get("findings"),list) else 0
+        coverage_rows.append([run.get("adapter"),run.get("resultStatus"),count,"network" if run.get("requiresNetwork") else "local"])
+    lines += markdown_table(["Scanner","Result","Findings","Access"],coverage_rows)
+    lines += ["## Report details", ""]
+    lines += markdown_table(["Report ID", "Generated", "AI analysis", "Independent review"], [[report_id,generated,"included" if "hostAiTriage" in report else "not requested","included" if "agentReview" in report else "not requested"]])
+    return "\n".join(lines).rstrip() + "\n"
+
+def write_report(root: Path, mode: str, report: dict[str, Any]) -> dict[str, Any]:
+    reports = root / ".mnogovid"
+    scanner_reports = reports / "code-scanner"
+    if reports.exists() and reports.is_symlink(): raise ValueError("refusing to write reports through a symlinked .mnogovid directory")
+    if scanner_reports.exists() and scanner_reports.is_symlink(): raise ValueError("refusing to write reports through a symlinked code-scanner directory")
+    report_id = str(time.time_ns()); destination = scanner_reports / report_id / "result.md"
+    generated = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    document = render_report(root,mode,report_id,generated,redact(report))
+    truncated = len(document.encode("utf-8")) > MAX_OUTPUT
+    if truncated: document = document.encode("utf-8")[:MAX_OUTPUT].decode("utf-8","ignore") + "\n\n_Report truncated at the storage limit._\n"
+    destination.parent.mkdir(parents=True, exist_ok=False)
+    destination.write_text(document,encoding="utf-8")
+    return {"reportId":report_id,"path":str(destination),"redacted":True,"truncated":truncated}
+
+def state_path(root: Path, run_id: Any) -> Path:
+    if not isinstance(run_id,str) or not run_id.isdigit(): raise ValueError("runId must be a Unix timestamp")
+    return root / ".mnogovid" / "code-scanner" / run_id / "run-state.json"
+
+def save_run(root: Path, run_id: str, run: dict[str, Any]) -> None:
+    path=state_path(root,run_id); path.parent.mkdir(parents=True,exist_ok=True)
+    stored={**run,"workspace":str(root)}; temp=path.with_suffix(".tmp")
+    temp.write_text(json.dumps(redact(stored),ensure_ascii=False,indent=2)+"\n",encoding="utf-8"); temp.replace(path)
+
+def started_run(root: Path, run_id: Any) -> dict[str, Any]:
+    if isinstance(run_id,str) and run_id in RUNS: return RUNS[run_id]
+    path=state_path(root,run_id)
+    if not path.is_file(): raise ValueError("unknown or expired runId")
+    run=json.loads(path.read_text(encoding="utf-8"))
+    if run.get("workspace") != str(root): raise ValueError("runId belongs to a different workspace")
+    RUNS[str(run_id)]=run; return run
+
+def parse_report(value: Any, adapter: str|None=None) -> list[dict[str,Any]]:
+    findings=[]
+    if isinstance(value,dict) and isinstance(value.get("runs"),list):
+        for run in value["runs"]:
+            for result in run.get("results",[]) or []:
+                loc=((result.get("locations") or [{}])[0].get("physicalLocation") or {})
+                findings.append({"adapter":adapter,"ruleId":result.get("ruleId"),"severity":((result.get("level") or "unknown").upper()),"title":result.get("message",{}).get("text","") if isinstance(result.get("message"),dict) else "","location":loc.get("artifactLocation",{}).get("uri"),"line":(loc.get("region",{}) or {}).get("startLine")})
+    elif adapter=="bandit" and isinstance(value,dict) and isinstance(value.get("results"),list):
+        for result in value["results"][:200]:
+            if isinstance(result,dict): findings.append({"adapter":adapter,"ruleId":result.get("test_id"),"severity":result.get("issue_severity"),"confidence":result.get("issue_confidence"),"title":result.get("issue_text"),"location":result.get("filename"),"line":result.get("line_number")})
+    elif isinstance(value,dict) and isinstance(value.get("results"),list):
+        for result in value["results"][:200]: findings.append({"adapter":adapter,"ruleId":result.get("check_id") or result.get("rule_id"),"severity":result.get("extra",{}).get("severity") if isinstance(result.get("extra"),dict) else None,"title":result.get("extra",{}).get("message","") if isinstance(result.get("extra"),dict) else str(result)[:300],"location":result.get("path"),"line":result.get("start",{}).get("line") if isinstance(result.get("start"),dict) else None})
+    elif adapter=="pip-audit" and isinstance(value,list):
+        for dependency in value[:200]:
+            if not isinstance(dependency,dict): continue
+            for vuln in dependency.get("vulns",[]) or []:
+                if isinstance(vuln,dict): findings.append({"adapter":adapter,"ruleId":vuln.get("id"),"title":vuln.get("description"),"severity":"unknown","library":dependency.get("name"),"installedVersion":dependency.get("version"),"fixedVersion":", ".join(vuln.get("fix_versions",[])) if isinstance(vuln.get("fix_versions"),list) else None})
+    elif adapter=="npm-audit" and isinstance(value,dict) and isinstance(value.get("vulnerabilities"),dict):
+        for package_name,detail in value["vulnerabilities"].items():
+            if not isinstance(detail,dict): continue
+            via=detail.get("via",[]); via=via if isinstance(via,list) else [via]
+            advisory_items=[item for item in via if isinstance(item,dict)] or [{}]
+            for advisory in advisory_items:
+                fix=detail.get("fixAvailable")
+                fixed_version=fix.get("version") if isinstance(fix,dict) else None
+                findings.append({"adapter":adapter,"ruleId":advisory.get("url") or advisory.get("source"),"severity":advisory.get("severity") or detail.get("severity"),"title":advisory.get("title") or f"Vulnerable dependency: {package_name}","library":package_name,"installedVersion":detail.get("range"),"fixedVersion":fixed_version})
+    elif adapter=="grype" and isinstance(value,dict) and isinstance(value.get("matches"),list):
+        for match in value["matches"][:200]:
+            if not isinstance(match,dict): continue
+            vulnerability=match.get("vulnerability") if isinstance(match.get("vulnerability"),dict) else {}
+            artifact=match.get("artifact") if isinstance(match.get("artifact"),dict) else {}
+            fix=vulnerability.get("fix") if isinstance(vulnerability.get("fix"),dict) else {}
+            locations=artifact.get("locations") if isinstance(artifact.get("locations"),list) else []
+            location=(locations[0].get("path") if locations and isinstance(locations[0],dict) else None)
+            findings.append({"adapter":adapter,"ruleId":vulnerability.get("id"),"severity":vulnerability.get("severity"),"title":vulnerability.get("description") or vulnerability.get("id"),"library":artifact.get("name"),"installedVersion":artifact.get("version"),"fixedVersion":", ".join(fix.get("versions",[])) if isinstance(fix.get("versions"),list) else None,"location":location})
+    elif isinstance(value,list):
+        for item in value[:200]: findings.append({"adapter":adapter,"severity":item.get("Severity") or item.get("severity") if isinstance(item,dict) else "unknown","title":str(item)[:500]})
+    return redact(findings)
+
+def run_one(root:Path, ident:str, allow:bool, virtual:bool) -> dict[str,Any]:
+    spec,argv,cwd=command(root,ident)
+    result={"adapter":ident,"category":spec["category"],"workspacePath":str(root),"requiresNetwork":spec["network"],"networkRequested":allow,"networkEnforced":False,"command":{"argv":argv,"currentDir":cwd}}
+    if virtual: return {**result,"execution":"virtual","processStarted":False,"resultStatus":"not_executed","findings":[]}
+    if spec["network"] and not allow: raise ValueError(f"adapter '{ident}' requires network; set allowNetwork=true")
+    if not shutil.which(spec["exe"]): raise ValueError(f"scanner executable not found on PATH: {spec['exe']}")
+    completed=subprocess.run(argv,cwd=cwd,capture_output=True,text=True,timeout=300,check=False)
+    text=(completed.stdout or "")[:MAX_OUTPUT]; err=(completed.stderr or "")[:MAX_OUTPUT]
+    parsed=None
+    try: parsed=json.loads(text)
+    except json.JSONDecodeError:
+        try: parsed=[json.loads(line) for line in text.splitlines() if line.strip().startswith("{")]
+        except json.JSONDecodeError: pass
+    findings=parse_report(parsed,ident) if parsed is not None else []
+    secret=spec["category"]=="secrets"
+    if completed.returncode==0: status="complete"
+    elif completed.returncode==1 and findings: status="complete"
+    elif completed.returncode==1: status="incomplete"
+    else: status="failed"
+    return {**result,"execution":"executed","processStarted":True,"resultStatus":status,"exitCode":completed.returncode,"parsedJson":parsed is not None,"findings":findings,"counts":{"findings":len(findings)},"stdoutSnippet":"" if secret else redact(text[:4000]),"stderrSnippet":"" if secret else redact(err[:4000])}
+
+def content(value:Any,error:bool=False)->dict[str,Any]: return {"isError":error,"content":[{"type":"text","text":json.dumps(value,ensure_ascii=False)}]}
+def call(name:str,args:dict[str,Any])->dict[str,Any]:
+    try:
+        if name=="security_catalog": return content({"adapters":[{"id":k,"category":v["category"],"executable":v["exe"],"requiresNetwork":v["network"]} for k,v in ADAPTERS.items()],"webSources":["OSV","NVD","GitHub Advisory Database","vendor advisory databases"],"ai":"Use security_ai_triage_payload with the host model after explicit approval."})
+        if name=="security_doctor":
+            root=workspace(args.get("workspace")); data=plan(root); return content({**data,"missingExecutables":[r["executable"] for r in data["runs"] if not r["available"]]})
+        if name=="security_bootstrap":
+            root=workspace(args.get("workspace")); return content(bootstrap(root,args.get("createProfile",False)))
+        if name=="security_plan": return content(plan(workspace(args.get("workspace"))))
+        if name=="security_start_run":
+            root=workspace(args.get("workspace")); mode=args.get("mode"); consent=args.get("consent")
+            if mode not in ("scan","scan-ai","scan-agent") or not isinstance(consent,dict): raise ValueError("mode and consent are required")
+            run_id=str(time.time_ns())
+            RUNS[run_id]={"workspace":str(root),"mode":mode,"consent":redact(consent),"startedAt":datetime.now(timezone.utc).replace(microsecond=0).isoformat(),"scannerResults":[],"virtualCommands":[],"skippedScanners":[],"hostAiTriage":{"status":"pending" if consent.get("aiTriage") is True else "not_authorized"},"agentReview":{"status":"pending" if consent.get("agentReview") is True else "not_authorized"}}
+            save_run(root,run_id,RUNS[run_id]); return content({"runId":run_id,"workspace":str(root),"statePath":str(state_path(root,run_id)),"mode":mode,"consent":RUNS[run_id]["consent"],"processStarted":False,"reportWritten":False})
+        if name=="security_record_run":
+            root=workspace(args.get("workspace")); run_id=args.get("runId"); run=started_run(root,run_id); kind=args.get("kind"); entry=args.get("entry")
+            if kind not in ("scanner","preview","skipped","host_ai_triage","agent_review") or not isinstance(entry,dict): raise ValueError("kind and entry are required")
+            if kind in ("host_ai_triage","agent_review"):
+                if kind=="host_ai_triage": validate_host_ai_triage(run,entry)
+                key={"host_ai_triage":"hostAiTriage","agent_review":"agentReview"}[kind]
+                run[key]=redact(entry); save_run(root,str(run_id),run); return content({"runId":run_id,"recorded":kind,"entry":run[key]})
+            key={"scanner":"scannerResults","preview":"virtualCommands","skipped":"skippedScanners"}[kind]
+            run[key].append(redact(entry)); save_run(root,str(run_id),run); return content({"runId":run_id,"recorded":kind,"count":len(run[key])})
+        if name=="security_finalize_run":
+            root=workspace(args.get("workspace")); run_id=args.get("runId"); run=started_run(root,run_id)
+            legacy_ai=args.get("aiTriage")
+            host_ai=args.get("hostAiTriage",legacy_ai)
+            if host_ai is not None:
+                if not isinstance(host_ai,dict): raise ValueError("hostAiTriage must be an object")
+                validate_host_ai_triage(run,host_ai)
+                run["hostAiTriage"]=redact(host_ai)
+            if args.get("agentReview") is not None:
+                if not isinstance(args["agentReview"],dict): raise ValueError("agentReview must be an object")
+                run["agentReview"]=redact(args["agentReview"])
+            if run["mode"] in ("scan-ai","scan-agent") and run["consent"].get("aiTriage") is True and run["hostAiTriage"].get("status")=="pending": raise ValueError("record host-AI triage before finalizing an approved AI scan")
+            if run["mode"]=="scan-agent" and run["consent"].get("agentReview") is True and run["agentReview"].get("status")=="pending": raise ValueError("record agent review before finalizing an approved agent scan")
+            report={"runId":run_id,"startedAt":run["startedAt"],"consent":run["consent"],"scannerResults":run["scannerResults"],"virtualCommands":run["virtualCommands"],"skippedScanners":run["skippedScanners"]}
+            if run["mode"] in ("scan-ai","scan-agent"): report["hostAiTriage"]=run["hostAiTriage"]
+            if run["mode"]=="scan-agent": report["agentReview"]=run["agentReview"]
+            for key in ("initialization","doctor","plan"):
+                value=args.get(key)
+                if value is not None:
+                    if not isinstance(value,dict): raise ValueError(f"{key} must be an object")
+                    report[key]=value
+            result=write_report(root,run["mode"],report); state_path(root,run_id).unlink(); del RUNS[run_id]
+            return content({**result,"runId":run_id,"finalized":True})
+        if name=="security_virtual_run":
+            root=workspace(args.get("workspace")); ident=args.get("adapter")
+            if not isinstance(ident,str): raise ValueError("adapter must be a string")
+            return content(run_one(root,ident,args.get("allowNetwork") is True,True))
+        if name=="security_run":
+            root=workspace(args.get("workspace")); ident=args.get("adapter"); run=started_run(root,args.get("runId"))
+            if not isinstance(ident,str): raise ValueError("adapter must be a string")
+            preview=run_one(root,ident,run["consent"].get("network") is True,True)
+            if preview["requiresNetwork"] and run["consent"].get("network") is not True: raise ValueError("network consent was not recorded for this lifecycle")
+            if not any(item.get("adapter")==preview["adapter"] and item.get("command",{}).get("argv")==preview["command"]["argv"] for item in run["virtualCommands"]): raise ValueError("record an identical security_virtual_run preview in this lifecycle before executing")
+            return content(run_one(root,ident,run["consent"].get("network") is True,False))
+        if name=="security_ingest":
+            report=Path(str(args.get("report",""))).expanduser().resolve(); fmt=args.get("format")
+            if not report.is_file() or fmt not in ("json","sarif"): raise ValueError("report must be an existing file and format must be json or sarif")
+            raw=json.loads(report.read_text()); findings=parse_report(raw,args.get("adapter")); return content({"sourcePath":str(report),"format":fmt,"reportOnly":True,"findings":findings,"counts":{"findings":len(findings)}})
+        if name=="security_advisory_lookup":
+            if args.get("allowNetwork") is not True: raise ValueError("OSV lookup requires allowNetwork=true")
+            ecosystem,package_name,version=(args.get("ecosystem"),args.get("package"),args.get("version"))
+            if not all(isinstance(v,str) and v for v in (ecosystem,package_name,version)): raise ValueError("ecosystem, package, and version must be non-empty strings")
+            body=json.dumps({"package":{"ecosystem":ecosystem,"name":package_name},"version":version}).encode()
+            request=urllib.request.Request("https://api.osv.dev/v1/query",data=body,headers={"Content-Type":"application/json"},method="POST")
+            try:
+                with urllib.request.urlopen(request,timeout=15) as response: raw=json.loads(response.read().decode())
+            except (urllib.error.URLError,TimeoutError,json.JSONDecodeError) as exc: raise ValueError(f"OSV advisory lookup failed: {exc}")
+            vulns=raw.get("vulns",[]) if isinstance(raw,dict) else []
+            return content({"source":"OSV","networkUsed":True,"package":{"ecosystem":ecosystem,"name":package_name,"version":version},"vulnerabilities":[{"id":v.get("id"),"summary":v.get("summary"),"modified":v.get("modified"),"aliases":v.get("aliases",[]),"references":v.get("references",[])} for v in vulns[:50]]})
+        if name=="security_ai_triage_payload":
+            items=redact(args.get("findings"));
+            if not isinstance(items,list): raise ValueError("findings must be an array")
+            return content({"mode":"remediation" if args.get("remediation") else "triage","findingLimit":min(len(items),40),"findings":items[:40],"instruction":"Return a JSON object with findingNotes: one item for every supplied finding, in the same zero-based findingIndex order. Each item must include findingIndex, classification (true_positive, false_positive, or needs_review), confidence, and a detailed evidence-based note. Cite only supplied evidence. Propose patches only when remediation was explicitly requested."})
+        raise ValueError(f"unknown tool: {name}")
+    except (ValueError,OSError,subprocess.TimeoutExpired) as exc: return content({"error":str(exc)},True)
+
+def main()->int:
+    for line in sys.stdin:
+        try:
+            req=json.loads(line); method=req.get("method"); rid=req.get("id")
+            if method=="initialize": out={"protocolVersion":"2025-03-26","capabilities":{"tools":{}},"serverInfo":{"name":"mnogovid-code-scanner","version":"0.1.0"}}
+            elif method=="tools/list": out={"tools":TOOLS}
+            elif method=="tools/call": out=call(req.get("params",{}).get("name",""),req.get("params",{}).get("arguments",{}))
+            elif rid is None: continue
+            else: raise ValueError(f"method not found: {method}")
+            print(json.dumps({"jsonrpc":"2.0","id":rid,"result":out},ensure_ascii=False),flush=True)
+        except Exception as exc: print(json.dumps({"jsonrpc":"2.0","id":None,"error":{"code":-32603,"message":str(exc)}}),flush=True)
+    return 0
+if __name__=="__main__": raise SystemExit(main())