# io.github.N0moreher0/venira-mcp (npm · venira-mcp)

Workspace-scoped MCP server for coding agents: files, search, shell, checkpoints, PR/CI, audit.

- Trust score: 83/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `venira-mcp`: 83/100 (this document), [markdown](https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp.md), [page](https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp)

## Channel facts

- Registry: `npm`
- Package: `venira-mcp`
- Version: `1.19.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 97/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 57 of 138 dependencies flagged as unhealthy (3 deprecated).
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to N0moreher0/Venira-mcp).
  - Clear OSI-approved license (AGPL-3.0-only).
  - Actively maintained (last published 2 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 10430 tokens (~325/item across 32 items; 32 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 43/100
  - Stability observed for 13 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 89/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 67% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 33 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.N0moreher0/venira-mcp server?

io.github.N0moreher0/venira-mcp runs locally as an npm package, launched with npx -y venira-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add n0moreher0-venira-mcp -- npx -y venira-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "n0moreher0-venira-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "venira-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "n0moreher0-venira-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "venira-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add n0moreher0-venira-mcp -- npx -y venira-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "n0moreher0-venira-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "venira-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add n0moreher0-venira-mcp --command npx --arg -y --arg venira-mcp
```

### Hermes

```yaml
mcp_servers:
  n0moreher0-venira-mcp:
    command: "npx"
    args: ["-y", "venira-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "n0moreher0-venira-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "venira-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add n0moreher0-venira-mcp -t stdio -c npx -a -y venira-mcp
```

### Other

```json
{
  "mcpServers": {
    "n0moreher0-venira-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "venira-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-19 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-14 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-12 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-10 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-09 (score 77, +15)

- [security improvement] Malware scan: unverified → pass
- [functional improvement] Stability: unverified → 0.03

### 2026-11-08 (score 62)

First indexed and scored.

## MCP tools (32)

### `project_list_files` (~168 tokens)

List files

List files/directories in the workspace. depth 1..3 shows the tree in a single call.
Use when: you need to see the directory tree, check a path, or list files before reading.
Avoid when: you only need one file's metadata (project_get_file_info) or one file's contents (project_read_file).
Speed: fast; TTL cache 1.5s, auto-wiped on write/edit/delete.
Output: file_list: entries, truncated, hint.
Batch-safe: yes

Input parameters:

- `depth` (integer)
- `include_ignored` (integer): Numeric flag: 1=enabled, 0=disabled.
- `limit` (integer)
- `relative_path` (string): Path inside the workspace (relative, or absolute inside the workspace)

### `project_read_file` (~208 tokens)

Read file

Read a text file, optionally by line range (1-based). The result carries next_start_line when truncated.
Use when: you need the contents of one file, or one line range of a large file.
Avoid when: you need to read 2+ files (project_read_batch) or only need metadata (project_get_file_info).
Speed: very fast on repeat; cache validated by mtime+size.
Output: file_read: text, first_line, last_line, total_bytes, next_start_line.
Batch-safe: yes

Input parameters:

- `end_line` (integer)
- `line_numbers` (integer): Numeric flag: 1=enabled, 0=disabled.
- `max_bytes` (integer)
- `ranges` (array): Multiple disjoint ranges of the SAME file (max 16). Use instead of multiple read_file calls.
- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)
- `start_line` (integer)

### `project_get_file_info` (~113 tokens)

Get file info

File/directory metadata (kind, size, modification time).
Use when: you only need size/mtime/kind, or want to check that a path exists.
Avoid when: you need the file's contents (project_read_file).
Speed: very fast; cache validated by mtime+size.
Output: file_info: relative_path, kind, size_bytes, modified_unix_seconds.
Batch-safe: yes

Input parameters:

- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)

### `project_search` (~359 tokens)

Search workspace

Search by file name, directory name, content (literal or regex=1), or symbol declaration lines (definition).
Use when: you need to find code/strings/symbols before reading; use kind=literal_content or definition.
Avoid when: you already know the exact path to read.
Speed: medium (file scan); TTL cache 3s for the same query.
Output: search: hits (source+confidence when hybrid:1), complete, diagnostics, hint.
Batch-safe: yes

Input parameters:

- `case_sensitive` (integer): Numeric flag: 1=enabled, 0=disabled.
- `context_lines` (integer)
- `count_only` (integer): Numeric flag: 1=enabled, 0=disabled.
- `exclude_glob` (string)
- `glob` (string)
- `hybrid` (integer): 1 = tag each hit with source (symbol_index|symbol_reference|content) and confidence (exact_match|text_match); a scoped identifier query with 0 hits widens once to the workspace (scope_widened:true).…
- `include_hidden` (integer): 1 = include hidden files (default); 0 = skip dotfiles (rg-style). Secrets (.env*, credentials, keys) are always excluded either way.
- `kind` (string, required)
- `limit` (integer)
- `query` (string, required)
- `regex` (integer): Numeric flag: 1=enabled, 0=disabled.
- `relative_path` (string): Path inside the workspace (relative, or absolute inside the workspace)
- `whole_word` (integer): 1 = whole-word match only (rg -w / JS word boundaries) for literal_content and definition.

### `project_recent_files` (~264 tokens)

Recent files

List files modified most recently in the workspace, newest first, plus session_edits (files you already wrote this session). Cheap orientation call: use it at the start of a task, when resuming, before editing a file the user may have changed, and after shell/build/git steps to see what really changed (bounded filesystem scan, skips node_modules/target/.git).
Use when: starting or resuming a task, checking what the user or a command just changed (after shell/build/format/git), re-orienting after context loss, or picking the next files to feed into project_read_batch. Prefer it over listing a whole tree.
Avoid when: you need the full list / by name (project_list_files) or content search (project_search).
Speed: medium (filesystem walk); TTL cache 2s, bounded to 4000 files / 300 directories.
Output: recent_files: entries[] sorted by mtime desc, scanned_files, truncated.
Batch-safe: no

Input parameters:

- `depth` (integer)
- `include_ignored` (integer): Numeric flag: 1=enabled, 0=disabled.
- `limit` (integer)
- `relative_path` (string): Path inside the workspace (relative, or absolute inside the workspace)

### `project_read_batch` (~180 tokens)

Batch read

Run up to 8 READ-ONLY ops (list_files, read_file, get_file_info, search) in one call; read/info use the cache so repeats are very fast. Each item takes the same arguments as the standalone tool, including numeric 0/1 flags (e.g. search regex, case_sensitive, hybrid).
Use when: you need to read 2+ files/ops in the same step (reading context, scanning several files).
Avoid when: there is only a single op; or you need a mutating op (use the corresponding tool).
Speed: fastest for read-heavy work; sequential + cached, with a response budget.
Output: read_batch: responses[] (each item is an ok/error envelope).
Batch-safe: yes

Input parameters:

- `max_response_bytes_per_item` (integer)
- `requests` (array, required)

### `project_write_file` (~285 tokens)

Write file

Write a file. mode=create errors if it exists; overwrite replaces existing contents; append concatenates. Create and verify a scoped project_snapshot before overwriting existing file contents.
Use when: create a new file or append content; before mode=overwrite on an existing file, create a scoped project_snapshot, confirm it captured the target, and keep the returned id.
Avoid when: only a small section needs to change (project_edit_file), or an existing file would be overwritten without a verified pre-write project_snapshot.
Speed: fast; clears the read/list/search cache for the affected path.
Output: file_written: action, bytes_written, sha256_after.
Batch-safe: no

Input parameters:

- `content` (string, required)
- `create_dirs` (integer): Numeric flag: 1=enabled, 0=disabled.
- `expected_sha256` (string)
- `mode` (string): overwrite replaces existing contents; create and verify a scoped project_snapshot first. create fails if the path exists; append adds to the end.
- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)

### `project_edit_file` (~493 tokens)

Edit file

Edit a file by exact text replacement: one old_text/new_text pair, or edits[] for multiple sections. Supports TOCTOU guard mode (guard=sha256) for atomic read-edit-verify cycle.
Use when: change one or a few text sections whose exact content you know; pair with expected_sha256 to guard against blind overwrites. Use guard=sha256 for atomic read-edit-verify. Before editing 2+ files or 2+ sections, create a scoped project_snapshot and confirm coverage.
Avoid when: the whole file must change (project_write_file), or you have not read the file to know old_text.
Speed: fast; clears the read/list/search cache for the affected path.
Output: file_written: replacements, sha256_before/after, verified (with guard=sha256).
Batch-safe: no

Input parameters:

- `case_insensitive` (integer): P2: Case-insensitive fuzzy matching; 1=on, 0=off.
- `edits` (array): Multiple section replacements in this file. Create a scoped project_snapshot first when applying 2+ edits or when the change is hard to recreate.
- `expected_sha256` (string)
- `fuzzy_distance` (integer): P2: Max Levenshtein distance for fuzzy matching (default 3).
- `guard` (string): TOCTOU guard: 'sha256' reads fresh content, verifies expected_sha256, applies edits, writes, then re-reads to verify content+sha256 match. Provides atomic read-edit-verify cycle.
- `ignore_indentation` (integer): P2: Ignore leading whitespace differences in fuzzy matching; 1=on, 0=off.
- `new_text` (string)
- `old_text` (string)
- `old_text_fuzzy` (string): P2: Fuzzy-match fallback for old_text (used when exact match fails and VENIRA_EDIT_FUZZY=1).
- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)
- `replace_all` (integer): Numeric flag: 1=enabled, 0=disabled.

### `project_edit_batch` (~207 tokens)

Edit batch

Apply multiple edit_file operations atomically in one call; aborts after the first failure and restores the pre-batch snapshot when possible.
Use when: before editing existing files in a multi-edit batch, create a scoped project_snapshot when it spans multiple files/sections or needs rollback after later checks. Batch rollback covers an in-batch failure only; it does not undo a successful batch after tests fail.
Avoid when: a single edit (project_edit_file) or a whole-file rewrite (project_write_file).
Speed: depends on item count; each runs edit_file and clears caches.
Output: batch: responses[] {ok, response|error}, atomic metadata with executed/skipped indexes and rollback status.
Batch-safe: no

Input parameters:

- `edits` (array, required): Array of edit_file arguments. For existing files across multiple edits, create a scoped project_snapshot first if later validation may require full rollback; automatic rollback only handles in-batch…
- `max_response_bytes_per_item` (integer)

### `project_delete_path` (~260 tokens)

Delete path

Delete a file or directory (directories require recursive=1). Create and verify a scoped snapshot before using this irreversible tool; do not delete if the checkpoint is incomplete.
Use when: only after creating a scoped project_snapshot for the exact target, confirming file_count/truncated/skipped cover the intended files, and keeping its id for recovery.
Avoid when: the target is ambiguous or a pre-delete snapshot is missing, truncated, or skipped the target. This op is not undoable; capture and verify a checkpoint first.
Speed: fast; clears the read/list/search cache.
Output: path_deleted: entries_deleted, bytes_deleted.
Batch-safe: no

Input parameters:

- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `recursive` (integer): For recursive directory deletion, set 1 only after confirming the target and creating a scoped project_snapshot; required for directory deletion.
- `relative_path` (string, required): Exact workspace path to delete. Create a scoped project_snapshot first and confirm this target is captured; do not delete if it is skipped or the checkpoint is truncated.

### `project_shell_run` (~787 tokens)

Shell run

Run a shell command (cwd defaults to /workdir). Asynchronous by default: returns run_id immediately, so poll project_shell_status for the output. Pass background=0 (or false) for a foreground run: the call blocks until the command exits and returns the final stdout/stderr. For commands that overwrite/delete existing workspace source files, create and verify a scoped project_snapshot first; prefer project file tools for targeted edits. Commands pass a policy gate: risky ones return an approval_required error with a pending approval_id; catastrophic ones are denied outright. Named overrides require operator allowlisting and a per-call reason.
Use when: build/test/lint/long-running commands. For hard-to-reverse workspace file changes, checkpoint first. Default (background=1) returns run_id immediately so it never blocks other tools; set background=0 when you need the final output in this call — it blocks until the command exits, and you must not start other work while waiting. After approval_required, ask the user to approve the approval_id in an interactive terminal, then retry.
Avoid when: a command that may never finish: use the async default plus project_shell_status/project_shell_cancel.
Speed: background=1 returns in ~5 ms, run time is up to the command; background=0 blocks for the whole run (bounded by timeout_ms, default 10 min).
Output: shell_run: run_id/shell_id, running, exit_code, background/foreground, stdout_tail/stderr_tail, timed_out, policy; background=0 also returns bounded stdout/stderr. approval_required: rule, reason, approval_id, retry_with.
Batch-safe: no

Input parameters:

- `approval_id` (string): Approval ID from the approval_required envelope, granted by a human running `data.approval.approve_command` or using client elicitation. Retry once after they confirm.
- `approval_scope` (string): Ignored: scope (once/session) is chosen by the human at approval time (`--approve <id> --session`), never by the model.
- `approval_token` (string): REMOVED in v1.15: passing it returns an error. Use approval_id instead.
- `approval_wait_ms` (integer): If the command needs approval, wait up to this many ms (max 45000) for the human to grant it and run in the same call. On timeout you get the normal approval_required response.
- `background`: 1/true = background (default): return immediately with run_id. 0/false = foreground: block until the command exits, then return the final stdout/stderr in this call.
- `command` (string, required): Command line to execute. If it overwrites or deletes existing workspace source files, create and verify a scoped project_snapshot first; use project_write_file/project_edit_file/project_delete_path f…
- `dry_run` (integer): 1 = evaluate policy only: returns tier, rule and whether approval would be needed. Nothing runs and no approval is created.
- `override` (string): Named exception; only works when the operator enabled this exact name in VENIRA_SHELL_OVERRIDES.
- `reason` (string): Required with override; explain the specific intent in one line. Redacted and recorded in the SQLite audit trail.
- `relative_cwd` (string): Working directory inside the workspace (default: workspace root).
- `secret_env` (array): Names of stored secrets (project_secret) to inject as environment variables for this command, e.g. ["GITHUB_TOKEN"]. The value never appears in the command, the audit log or the output.
- `shell` (string)
- `timeout_ms` (integer): Kill the whole process tree after this many milliseconds. Unset or 0 uses the default 10-minute timeout; capped by VENIRA_SHELL_MAX_TIMEOUT_MS.

### `project_shell_status` (~106 tokens)

Shell status

Check status + output of a running command. wait_seconds (0..30) is an observation window, not a timeout.
Use when: after project_shell_run; poll until running=false.
Avoid when: no run_id available yet.
Speed: fast; not queued so it never blocks other tools.
Output: shell_run: running, exit_code, stdout_tail/stderr_tail.
Batch-safe: no

Input parameters:

- `run_id` (string, required)
- `wait_seconds` (integer)

### `project_shell_cancel` (~95 tokens)

Shell cancel

Cancel a running shell command by run_id.
Use when: the command is running too long or its result is no longer needed.
Avoid when: the command already finished (check with project_shell_status).
Speed: fast; kills the whole process tree so grandchildren do not keep running.
Output: cancellation: accepted, cleanup_complete.
Batch-safe: no

Input parameters:

- `kill_key` (string, required)
- `run_id` (string, required)

### `project_create` (~285 tokens)

Create file or directory

Create a directory OR a file in ONE call. For an existing file, mode=overwrite replaces its contents: create and verify a scoped project_snapshot first.
Use when: create a directory or new file; if replacing an existing file, first create a scoped project_snapshot, confirm it captured the target, and keep its id.
Avoid when: editing an existing file (project_edit_file/project_write_file); never use mode=overwrite unless a pre-write project_snapshot covers the existing contents.
Speed: fast; triggers cache invalidation on write / new directory.
Output: directory_created or file_written (data kind depends on the op).
Batch-safe: no

Input parameters:

- `content` (string)
- `create_dirs` (integer): Numeric flag: 1=enabled, 0=disabled.
- `expected_sha256` (string)
- `kind` (string, required)
- `mode` (string): overwrite replaces existing contents; create and verify a scoped project_snapshot first. create fails if the path exists; append adds to the end.
- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)

### `project_health` (~164 tokens)

Health & metrics

Server diagnostics: corehost/data dir/audit DB, capability, queue depth, cache hit-rate, running shells, p50/p95 metrics, plus a security-limit notice (guard rail, not sandbox).
Use when: debugging slowness/errors, checking the backend/DB/audit before reporting, or inspecting this session's cache/metrics.
Avoid when: you just need to read/write files normally.
Speed: fast (~a few ms + 1 audit DB query); set include_audit=0 to skip the DB query.
Output: health: notice, server, corehost, capability, queue, caches, shells, metrics, audit.
Batch-safe: no

Input parameters:

- `include_audit` (integer): Numeric flag: 1=enabled, 0=disabled.

### `project_cache_clear` (~125 tokens)

Clear caches

Clear in-process read/search/list/recent/search/shell/graph caches. Use after a toolchain generates files outside normal write flow, or to force fresh reads.
Use when: force-fresh reads after external tooling mutated files, or the cache stats show high hit/miss pressure.
Avoid when: normal flow (cache invalidates on write/edit/delete).
Speed: instant; clears LRU/TTL maps only (no backend call).
Output: cache_clear: type, cleared per-cache entry counts.
Batch-safe: no

Input parameters:

- `type` (string): Which cache to clear.

### `project_trace_status` (~138 tokens)

Trace status

Show the most recent traced tool calls from the in-memory buffer (last N) plus the trace configuration.
Use when: VENIRA_TRACE=1 and you want to see what ran recently without reading the log file.
Avoid when: tracing is disabled (returns an empty buffer) or you need the full on-disk log (read VENIRA_TRACE_FILE instead).
Speed: instant; in-memory buffer only, no I/O.
Output: trace_status: enabled, file, buffered, recent[] (newest last).
Batch-safe: yes

Input parameters:

- `limit` (integer): How many recent traces to return (default 20, max 100).

### `project_read_audit` (~186 tokens)

Read audit log

Read recent rows from the SQLite audit log (WAL). Filter by session/operation/outcome; bounded by limit.
Use when: you need to inspect what operations were recorded (audit trail) — e.g. compliance or debugging a prior action.
Avoid when: you only need the live cache/metric report (project_health include_audit=1) — that one is faster.
Speed: fast; one bounded SQLite read (readonly, WAL-safe).
Output: audit_read: rows[] (newest first), count, truncated, db_path.
Batch-safe: yes

Input parameters:

- `limit` (integer)
- `operation` (string)
- `outcome` (string)
- `session_id` (string)
- `since_unix` (integer)
- `verify` (integer): 1 verifies the audit hash chain and returns chain_ok; 0 disables verification.

### `project_shell_cancel_session` (~113 tokens)

Shell cancel session

Cancel ALL shell runs tracked in this session (kills every process tree). Use to cleanly tear down a session.
Use when: a session is ending or a stuck session has many running commands and they must all be stopped.
Avoid when: only one run needs cancelling (project_shell_cancel by run_id). Destructive: running commands are killed.
Speed: fast; iterates the in-process shell run table and kills each tree.
Output: shell_cancel_session: cancelled_run_ids[], count.
Batch-safe: no

### `project_outline_symbol` (~193 tokens)

Outline symbols

Parse a source file and return its symbol outline (functions, classes, types, interfaces) with line numbers.
Use when: you need to see the structure / top-level symbols of a file before reading or refactoring it.
Avoid when: you need every usage of a symbol (project_symbol_references) or a text-only diff (project_diff_files).
Speed: fast; single-file regex scan, no external indexer.
Output: outline_symbol: total_symbols, symbols[] {name, kind, line, signature}.
Batch-safe: yes

Input parameters:

- `include_classes` (integer): Numeric flag: 1=enabled, 0=disabled.
- `include_functions` (integer): Numeric flag: 1=enabled, 0=disabled.
- `language` (string)
- `max_symbols` (integer)
- `relative_path` (string, required): Path inside the workspace (relative, or absolute inside the workspace)

### `project_diff_files` (~171 tokens)

Diff files

Unified (git-style) diff between two workspace files. Reports lines_added/lines_removed and the full hunk text.
Use when: comparing two versions of a file, or reviewing changes before/after an edit.
Avoid when: the two files are in different languages or one is binary; large binaries are not supported.
Speed: medium; LCS-based diff over the two full texts, bounded by max_lines.
Output: diff_files: lines_added, lines_removed, unified_diff, truncated.
Batch-safe: yes

Input parameters:

- `context_lines` (integer)
- `max_lines` (integer)
- `relative_path_a` (string, required): Path inside the workspace (relative, or absolute inside the workspace)
- `relative_path_b` (string, required): Path inside the workspace (relative, or absolute inside the workspace)

### `project_symbol_references` (~167 tokens)

Symbol references

Find every occurrence of a named symbol. scope=file (fast, single file) or scope=workspace (uses content search).
Use when: you need to know where a symbol is used before renaming/refactoring it.
Avoid when: you only need its declaration (project_outline_symbol) or an arbitrary string (project_search).
Speed: fast for scope=file; medium for scope=workspace (single search call).
Output: symbol_references: count, references[] {relative_path, line_number, context}.
Batch-safe: yes

Input parameters:

- `limit` (integer)
- `max_references` (integer)
- `relative_path` (string): Path inside the workspace (relative, or absolute inside the workspace)
- `scope` (string)
- `symbol_name` (string, required)

### `project_selective_search` (~190 tokens)

Selective search

Smart multi-query search: combine several patterns with AND/OR/NOT + fuzzy scoring. Bounded to a file set you pass in.
Use when: you need to rank many files by how well they match several keywords at once (e.g. locating the right module among candidates).
Avoid when: you need a single exact literal (project_search) or to inspect one file's content (project_read_file).
Speed: medium; reads a bounded set of files (files_hint or a shallow listing) and scores each line.
Output: selective_search: hits[] {relative_path, line_number, text, score, matched}, total_files, total_hits, truncated.
Batch-safe: yes

Input parameters:

- `files_hint` (array)
- `limit` (integer)
- `queries` (array, required)
- `relative_path` (string): Path inside the workspace (relative, or absolute inside the workspace)

### `project_dependency_graph` (~430 tokens)

Dependency graph

Build a deterministic file/symbol dependency graph for TypeScript/JavaScript, Python, Rust, Go, Java and Kotlin (module declarations, pub mod, use crate::/super::, extern crate, go.mod module resolution, import (...) blocks, relative imports, require(), dynamic import(), extends/implements, cross-file symbol references). Renders as JSON, DOT or Mermaid.
Use when: you need the import graph, a module map to render, or the files/symbols a change can reach before refactoring.
Avoid when: you only need usages of one symbol in one file (project_symbol_references) or a text search (project_search).
Speed: medium; bounded walk (<=5000 files / 64 MB), parser-lite line scan, 5 s index cache invalidated on writes. No network.
Output: dependency_graph: nodes[] {id, type, language, loc}, edges[] {from, to, type (import|extends|implements|references), confidence, line, via}, external[] {id, used_by}, unresolved[], stats, truncated; format=dot|mermaid returns data.graph.
Batch-safe: yes

Input parameters:

- `depth` (integer): Directory recursion cap (default 3, max 10).
- `format` (string): Output format (default json). dot/mermaid return data.graph.
- `include_external` (integer): 1 aggregates npm/pip/node package nodes in external[]. Default 0.
- `include_tests` (integer): 1 includes test files/edges (default); 0 hides them.
- `kind` (string): files (imports), symbols (references/extends), or both (default files).
- `languages` (array): Language filter, e.g. ["ts","py","rs","go","java","kotlin"] (default: all supported).
- `max_edges` (integer): Max edges (default 2000).
- `max_nodes` (integer): Max file nodes (default 500).
- `relative_path` (string): Limit the walk to this subtree (default: the workspace root).

### `project_change_impact` (~325 tokens)

Change impact

Answer "if I change these files/symbols, what depends on them?" with a bounded reverse (or forward) closure: affected files, distance, path, reason and confidence, plus affected symbols and a separate test count.
Use when: before renaming/changing a function or file, to list the dependents you should read/test (direction=dependents), or the dependencies a module relies on.
Avoid when: you need the whole graph (project_dependency_graph) or exact textual usages in one file (project_symbol_references).
Speed: medium; reuses the dependency index (5 s cache, invalidated on writes), BFS bounded by depth. No network.
Output: change_impact: seed {files, symbols}, affected[] {id, distance, path, reason, confidence, symbols?}, unresolved[], summary {affected_files, affected_symbols, max_distance, tests_affected}, truncated; format=mermaid returns data.graph.
Batch-safe: yes

Input parameters:

- `depth` (integer): BFS hop cap (default 5).
- `direction` (string): Traversal direction (default dependents).
- `files` (array): Workspace paths you plan to edit.
- `format` (string): Output format (default json).
- `include_tests` (integer): 1 includes test files (default) and counts them in tests_affected.
- `max_nodes` (integer): Max affected files (default 300).
- `symbols` (array): Symbols you plan to rename/change; pass a name, or {name, file} when the name is ambiguous.

### `project_detect_harnesses` (~123 tokens)

Detect MCP harnesses

Detect which MCP-client harnesses (OpenCode/Claude/Cursor/Codex/Kimi/DeepSeek/Antigravity) have a config on this machine.
Use when: before installing venira, to know which client configs exist and can be updated.
Avoid when: you already know the config path (skip straight to project_install_self).
Speed: fast; filesystem checks, no writes.
Output: harness_detect: detected[] (found harnesses), harnesses[] {harness, detected, config_path, format, note}.
Batch-safe: yes

### `project_install_self` (~235 tokens)

Self-install venira MCP

Add the venira MCP entry to a target client's config (OpenCode/Claude/Cursor/Codex/Kimi/DeepSeek/Antigravity). Atomic + backup.
Use when: a user asks to 'install venira into <client>' — add the MCP server block to that client's config file.
Avoid when: the config path is unknown (run project_detect_harnesses first), or the user wants a dry-run (set dry_run=1).
Speed: fast; one atomic write per config. Always backs up the original to <file>.venira-bak.
Output: install_self: {harness, config_path, status (installed|already_present|config_missing|error), needs_restart, error?}.
Batch-safe: no

Input parameters:

- `data_dir` (string): VENIRA_DATA_DIR value to write (default: the per-user Venira data directory).
- `dry_run` (integer): 1 reports what would happen without writing; 0 performs the action.
- `harness` (string, required)
- `workspace` (string): VENIRA_WORKSPACE value to write (default: process.cwd()).

### `project_explain_error` (~263 tokens)

Explain an error

Diagnose a failure from its error text / log tail: known signatures (errno, TypeScript, Python, git, npm, GitHub, venira codes) → likely cause + ready-to-send next tool calls. Rule-based, offline, instant.
Use when: a command, test, build or provider call failed and you want the fastest route to the fix (feed it the stderr tail or the CI log tail).
Avoid when: you already know the cause and only need the file contents (use project_read_file, which also accepts ranges).
Speed: pure local rules, < 1 ms; no network and no model call.
Output: explain_error: matched, summary, error_line, language, diagnoses[] {rule_id, title, likely_cause, suggested_fix[], retry_hint?, next_actions[]}, next_actions[].
Batch-safe: yes

Input parameters:

- `error_text` (string): The error block (stderr, exception, compiler output). One of error_text/log_tail is required.
- `language` (string): Optional language hint (typescript|python|rust|go|...) when the text does not show a file extension.
- `log_tail` (string): Tail of the failing output (e.g. project_ci_logs / project_shell_status text).

### `project_plan_read_batch` (~296 tokens)

Plan reads from a task

Plan a read: extract keywords from the task, run bounded content + file-name searches (+recent files), rank candidate source files by hits, path/name match and prose weight (build output, DB/log artifacts excluded), and return a ready project_read_batch call with a calibrated estimate. Deterministic planner, no model call.
Use when: starting a task in an unfamiliar area and you do not know which files matter yet (one call instead of guess-read-repeat).
Avoid when: you already know the exact files (call project_read_batch directly), or the task is a one-line lookup (project_search).
Speed: 1-3 bounded content searches (~20 ms each) + local ranking; no file contents are returned.
Output: plan_read_batch: task, keywords[], searched, candidates[] {relative_path, reason, hits}, steps[] {tool, arguments, why}, estimated_ms, notes.
Batch-safe: yes

Input parameters:

- `files_hint` (array): Files you already suspect (ranked first, no search needed for them).
- `include_search` (integer): 1 runs keyword searches (default); 0 plans only from files_hint/recent files.
- `max_files` (integer): Max candidates to plan (default 6; batch accepts 8).
- `task_description` (string, required): What you are about to do, in one line, e.g. "add retry handling to the GitHub client".

### `project_snapshot` (~743 tokens)

Workspace checkpoint

Checkpoint/rollback for the workspace: create a labeled, scoped snapshot before multi-file or hard-to-reverse edits; keep its returned id. For rollback, preview with restore dry_run=1 (size-based preview only; it cannot detect same-size content changes), inspect newer user edits, then restore that exact id with verify=1 and delete_extra=0. Content-addressed and deduplicated.
Use when: before multi-file, cross-file, refactor/rename or hard-to-reverse edits: create with a descriptive label, scope paths to the affected area, retain the exact returned id, and confirm required files were captured. For rollback, run restore dry_run=1 to preview path/size changes (same-size content differences are not detected); inspect files with newer user edits, then restore the exact id with verify=1 and delete_extra=0. Example: checkpoint → edit 3 files → tests fail → inspect scope → restore.
Avoid when: a tiny, easily recreated single-file edit, generated build output, or a commit already provides the needed recovery point; do not restore over newer user changes without inspecting them.
Speed: create walks/hashes the captured files (skips .git/node_modules/dist, symlinks, huge files); repeats only store new blobs. restore is atomic per file, concurrency 4, SHA-256 verified by default; dry_run previews path/size only, not same-size content changes.
Output: snapshot_create: id, label, file_count, total_bytes, new_blob_bytes, skipped[], truncated; snapshot_list: checkpoints[]; snapshot_restore: restored_count/restored[], deleted_count, skipped[]; snapshot_delete: deleted, bytes_freed; snapshot_mirror: status, copied_blobs, copied_indexes, bytes, failed[] (needs VENIRA_SNAPSHOT_MIRROR_DIR); snapshot_create adds mirror{} when configured.
Batch-safe: no

Input parameters:

- `action` (string)
- `delete_extra` (integer): restore only: 1 also deletes files inside captured dirs not in the checkpoint (capped at 500); default/0 keeps them. Use 1 only when deletion is explicitly intended.
- `dry_run` (integer): restore only: 1 previews path/size changes without writing (same-size content changes are not detected); inspect current user edits before applying.
- `exclude` (array): Extra directory/file names to skip.
- `id` (string): Checkpoint id (required for restore/delete; returned by create/list).
- `label` (string): Human label for the checkpoint, e.g. "before refactor auth".
- `limit` (integer): list only: max checkpoints to return (default 20).
- `max_files` (integer)
- `max_total_bytes` (integer)
- `paths` (array): Capture affected paths (default ['.'] only when scope is unclear); restore accepts a subset to filter files.
- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `respect_default_excludes` (integer): 1 skips standard generated/cache directories (default); 0 disables those exclusions.
- `scope` (array): Deprecated alias for paths; supplied scope is honored and missing paths return not_found.
- `verify` (integer): restore: 1 verifies each blob before writing (default); 0 disables verification. mirror: 1 re-hashes every blob already at the mirror and re-copies bad ones (default 0 trusts existing files).

### `project_github_connect` (~202 tokens)

Connect GitHub

Connect GitHub through its Device Flow. The user authorizes at github.com; access and refresh tokens are saved in the encrypted local vault and are never returned.
Use when: the user wants to connect or replace the local GitHub credential without pasting a token into chat.
Avoid when: the user only needs GitHub public read access or has already configured a token.
Speed: start returns a short-lived verification code; poll only at the interval GitHub specifies.
Output: github_connect: start returns verification_uri, user_code, pending_id and expiry; poll returns pending, denied, expired or connected (never a token).
Batch-safe: no

Input parameters:

- `action` (string, required)
- `pending_id` (string): action=poll: opaque id returned by action=start; it does not contain the device code or token.
- `replace_existing` (integer): action=start: 1 explicitly authorizes replacing an existing GitHub credential; 0 does not.

### `project_secret` (~482 tokens)

Manage secrets

Manage API tokens/credentials without leaking them: values are encrypted at rest and never returned by default. Inject them into commands with project_shell_run secret_env=["NAME"] instead of pasting them into a command line. Rotation metadata (expiry, last use, use count) is tracked by default and expired secrets are refused.
Use when: storing a non-GitHub token (action=set), checking whether one exists or is due for rotation (action=get / action=list), removing one (action=delete). Then use secret_env on project_shell_run or the built-in GitHub tools.
Avoid when: the value is a normal, non-secret config (put it in .env or the config file); or you need the plaintext printed (only with reveal=1 + VENIRA_SECRET_ALLOW_REVEAL=1).
Speed: fast; encrypted AES-256-GCM store, atomic writes, values decrypted only when injected. Expiry/use fields are metadata only.
Output: secret_set: name, length, sha256_12, updated_at, expires_at, days_left, created, rotated; secret_get/list: metadata only (expires_at, expired, days_left, last_used_at, use_count, rotated_at); secret_delete: deleted.
Batch-safe: no

Input parameters:

- `action` (string)
- `expires_at`: action=set: absolute expiry (epoch ms or ISO-8601), instead of expires_in_days.
- `expires_in_days` (integer): action=set: expiry in days (e.g. 90 for quarterly rotation). Expired secrets are not injected.
- `name` (string): Env-var style name, e.g. GITHUB_TOKEN (required for get/set/delete).
- `reason` (string): Why this change is made (e.g. "sua loi null pointer o dong 45"). Recorded in the audit trail so later sessions know the intent. Single line, max 400 chars, secrets are redacted.
- `reveal` (integer): action=get: 1 returns the plaintext value and requires VENIRA_SECRET_ALLOW_REVEAL=1 on the host; prefer secret_env injection.
- `value` (string): Secret value for action=set. Prefer value_env so it never appears in the transcript.
- `value_env` (string): Read the value from this host environment variable instead of `value` (never logged).

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp#diagnostics

## Score history

- 2026-11-21: 83
- 2026-11-20: 82
- 2026-11-19: 82
- 2026-11-18: 81
- 2026-11-17: 81
- 2026-11-16: 80
- 2026-11-15: 80
- 2026-11-14: 80
- 2026-11-13: 79
- 2026-11-12: 79
- 2026-11-11: 78
- 2026-11-10: 78
- 2026-11-09: 77
- 2026-11-08: 62

## Common questions

### What is the io.github.N0moreher0/venira-mcp server?

io.github.N0moreher0/venira-mcp is listed in the public MCP registry as io.github.N0moreher0/venira-mcp. Workspace-scoped MCP server for coding agents: files, search, shell, checkpoints, PR/CI, audit. This page covers its npm package (venira-mcp).

### Is the io.github.N0moreher0/venira-mcp server safe to use?

io.github.N0moreher0/venira-mcp scores 83 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.N0moreher0/venira-mcp server expose?

io.github.N0moreher0/venira-mcp exposes 32 tools: project_list_files, project_read_file, project_get_file_info, project_search, project_recent_files, and 27 more. Their descriptions and schemas cost roughly 8,356 tokens of context every time the server is loaded.

### Is the io.github.N0moreher0/venira-mcp server still maintained?

io.github.N0moreher0/venira-mcp is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.N0moreher0/venira-mcp server under?

io.github.N0moreher0/venira-mcp declares the AGPL-3.0-only licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the io.github.N0moreher0/venira-mcp server?

VerifyMCP ran 16 checks on io.github.N0moreher0/venira-mcp, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/venira-mcp
- Socket report: https://socket.dev/npm/package/venira-mcp
- Repository: https://github.com/N0moreher0/Venira-mcp
- Changelog RSS feed: https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp.json
- HTML version of this page: https://verifymcp.io/servers/n0moreher0-venira-mcp/venira-mcp
