# io.github.lvlrSajjad/sidecrew (npm · sidecrew)

Code changes and unit tests by local MLX models, behind a gate a machine can run.

- Trust score: 82/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-27

## Components

- npm · `sidecrew`: 82/100 (this document), [markdown](https://verifymcp.io/servers/lvlrsajjad-sidecrew/sidecrew.md), [page](https://verifymcp.io/servers/lvlrsajjad-sidecrew/sidecrew)

## Channel facts

- Registry: `npm`
- Package: `sidecrew`
- Version: `0.2.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-09-27.

- **Supply Chain Security**: 98/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.
  - 31 of 96 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to lvlrSajjad/sidecrew).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 70/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1750 tokens (~175/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 20/100
  - Stability observed for 6 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% 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.
  - We read all 10 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 10 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.lvlrSajjad/sidecrew MCP server?

io.github.lvlrSajjad/sidecrew runs locally as an npm package, launched with npx -y sidecrew. 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 lvlrsajjad-sidecrew -- npx -y sidecrew
```

### Cursor

```json
{
  "mcpServers": {
    "lvlrsajjad-sidecrew": {
      "command": "npx",
      "args": [
        "-y",
        "sidecrew"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "lvlrsajjad-sidecrew": {
      "command": "npx",
      "args": [
        "-y",
        "sidecrew"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add lvlrsajjad-sidecrew -- npx -y sidecrew
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add lvlrsajjad-sidecrew --command npx --arg -y --arg sidecrew
```

### Hermes

```yaml
mcp_servers:
  lvlrsajjad-sidecrew:
    command: "npx"
    args: ["-y", "sidecrew"]
```

### Netclaw

```json
{
  "McpServers": {
    "lvlrsajjad-sidecrew": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "sidecrew"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add lvlrsajjad-sidecrew -t stdio -c npx -a -y sidecrew
```

### Other

```json
{
  "mcpServers": {
    "lvlrsajjad-sidecrew": {
      "command": "npx",
      "args": [
        "-y",
        "sidecrew"
      ]
    }
  }
}
```

## 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-09-26 (score 82, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-09-25 (score 66, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 66, −13)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Stability: unverified → 0.10
- [functional] Package version: 0.1.2 → 0.2.0

### 2026-09-22 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-21 (score 64)

First indexed and scored.

## MCP tools (10)

### `sidecrew_status` (~117 tokens)

Is a local worker up, which model and revision it is serving, free RAM, and which verifier tools this project has. Call it before a run: everything else here needs a worker, and a missing stryker or muter is why a verdict would fail for a reason that is not the test's fault.

Input parameters:

- `port` (integer): worker port; default 8000
- `project` (string): the project being verified — tsc/vitest/stryker are reported from its node_modules, not sidecrew's

### `sidecrew_generate` (~83 tokens)

One WorkerTask -> one candidate test, generated by the MLX model running on this machine. Costs zero Claude tokens and touches no network: it is an HTTP call to http://localhost:<port>/v1. Raw worker output — verify it before showing it to anyone.

Input parameters:

- `task` (object, required): the task, as docs/specs/pipeline.md defines it

### `sidecrew_verify` (~148 tokens)

compile -> run -> mutate one candidate against the function its task_id names, and return a Verdict. Survive means it compiled, passed against the unmodified source, killed at least one mutant of that function, and was not tautological. Runs entirely on this machine.

Input parameters:

- `candidate` (object, required): what a worker produced, or a hand-written test in the same shape
- `function_name` (string): defaults to the part of task_id before the first colon
- `plan_path` (string, required): path to the test_plan.json the candidate was generated from
- `test_target` (string): Swift only: the test target under Tests/ (ADR-0014), overriding the plan

### `sidecrew_run_batch` (~168 tokens)

Run a whole plan on this machine: for every function x shape, generate -> verify -> retry once with the error appended -> escalate. Generation is local and costs zero Claude tokens; only the BatchResult comes back, so you see survivors and escalations rather than raw worker output. Minutes, not seconds — roughly 10 s per TypeScript candidate and 40 s per Swift one.

Input parameters:

- `concurrency` (integer): candidates in flight; a ceiling, lowered when free RAM says so
- `dry_run` (boolean): write the tasks and report the concurrency, then stop before the first token
- `plan_path` (string, required): path to test_plan.json
- `test_target` (string): Swift only: the test target under Tests/ (ADR-0014), overriding the plan

### `sidecrew_plan_validate` (~154 tokens)

Check a test_plan.json before a run spends anything on it: it parses, its module and exemplars are on disk, every line range really is the function it names, and — unless verify_exemplars is false — every exemplar survives the verifier. Call it after writing or editing a plan. Verifying the exemplars is the expensive half: one verdict per shape, seconds on TypeScript and tens of seconds on Swift. A stale source_sha is a warning here and a refusal in sidecrew_run_batch.

Input parameters:

- `plan_path` (string, required): path to test_plan.json
- `verify_exemplars` (boolean): default true; false is the fast structural pass, and the report warns that it was used

### `sidecrew_escalate` (~176 tokens)

What the local workers could not do, assembled for you to write yourself. Reads .sidecrew/runs/<id>/escalations.jsonl and returns each failed task with the exemplar and rules the worker had, plus both attempts' errors. Costs no worker tokens — it reads a finished run off disk. Two failures in here are NOT the test's fault and must not be rewritten as though they were: a stage_reached of 'mutation' means the mutation tool broke, and four mutation counts of zero mean nothing in that function could be mutated.

Input parameters:

- `dir` (string): where runs/ lives; default .sidecrew
- `model` (string): recorded as suggested_model; sonnet unless you say otherwise
- `run_id` (string): defaults to the most recent run under .sidecrew/runs

### `sidecrew_review` (~202 tokens)

Which survivors are worth reading, and in what batches. Survival is a filter, not an endorsement — a test that pins today's wrong answer kills every mutant — so this returns survivors below the mutation-score threshold plus a deterministic audit sample of the rest, batched under a token cap. The threshold is per language and defaults accordingly: a Swift score is computed over one or two mutants against TypeScript's six to twelve. Reads a finished run off disk; no worker tokens.

Input parameters:

- `audit_fraction` (number): of the survivors above the threshold; default 0.1
- `dir` (string): where runs/ lives; default .sidecrew
- `max_batch_tokens` (integer): estimated input tokens per batch; default 12000
- `run_id` (string): defaults to the most recent run under .sidecrew/runs
- `threshold` (number): overrides the per-language default (0.6 TypeScript, 1.0 Swift)

### `sidecrew_fix_plan_validate` (~213 tokens)

Check a change_plan.json before a run spends anything on it, and REFUSE the tasks no worker could ever pass: a file too large to return whole (a worker rewrites whole files, so ~8k completion tokens is the ceiling), a pre-existing tsc error the ask does not cover (the gate requires zero errors in the task's own files, so such a task is unsatisfiable at any temperature), a file outside the tsconfig's program, two tasks in one step sharing a file. Call it after writing or editing a plan. The expensive half is a real tsc over the project — tens of seconds — and it is the half that produces the refusals; compile: false is the fast structural pass. Worth it: the gate costs about 262 s per attempt, so one refused task saves nine minutes.

Input parameters:

- `compile` (boolean): default true; false skips tsc and therefore skips the refusals
- `plan_path` (string, required): path to change_plan.json

### `sidecrew_fix` (~281 tokens)

Run a whole change plan on this machine: workload #2a, behaviour-preserving changes — type errors, renames, null guards, API migrations, dead code. For each task the local model rewrites the listed files whole, and a gate a machine can run decides what you see: the diff stayed confined to the task's files, tsc is clean in them with none introduced elsewhere, and every test that passed before still passes. Generation is local and costs zero Claude tokens; only the FixResult comes back, so you see survivors and escalations rather than raw worker output. SLOW — the project's own suite runs per candidate, about 4–5 minutes each, so a 12-task plan is roughly an hour. Validate the plan first. Use --dry-run/dry_run to capture the baseline and stop before the first token, which is how you find out the tsconfig or the suite is the problem.

Input parameters:

- `concurrency` (integer): candidates in flight; a ceiling, lowered when free RAM says so
- `dry_run` (boolean): capture the first step's baseline, write the tasks and prompts, then stop
- `keep_sandbox` (boolean): leave the sandbox on disk to inspect what the gate actually saw
- `plan_path` (string, required): path to change_plan.json, written by the change-planner agent

### `sidecrew_fix_escalate` (~208 tokens)

What the local workers could not change, assembled for you to do yourself. Reads a fix run's escalations.jsonl and returns each failed task with the files it was given and every attempt's verdict — which confinement rule fired, which tsc errors remain, which tests regressed. Costs no worker tokens; it reads a finished run off disk. TWO of these are NOT the worker's fault and must not be rewritten as though they were: machine_failure means the sandbox or the runner broke (exclude it from any rate you quote), and a non-null `refused` means the worker said the change cannot be made inside those files — which is usually a plan to fix rather than a change to write.

Input parameters:

- `dir` (string): where runs/ lives; default .sidecrew
- `model` (string): recorded as suggested_model; sonnet unless you say otherwise
- `run_id` (string): defaults to the most recent run under .sidecrew/runs

## Diagnostics

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

## Score history

- 2026-09-27: 82
- 2026-09-26: 82
- 2026-09-25: 66
- 2026-09-24: 66
- 2026-09-23: 79
- 2026-09-22: 79
- 2026-09-21: 64

## Common questions

### What is the io.github.lvlrSajjad/sidecrew MCP server?

io.github.lvlrSajjad/sidecrew is an MCP server listed in the public MCP registry as io.github.lvlrSajjad/sidecrew. Code changes and unit tests by local MLX models, behind a gate a machine can run. This page covers its npm package (sidecrew).

### Is the io.github.lvlrSajjad/sidecrew MCP server safe to use?

io.github.lvlrSajjad/sidecrew scores 82 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 27 September 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.lvlrSajjad/sidecrew MCP server expose?

io.github.lvlrSajjad/sidecrew exposes 10 tools: sidecrew_status, sidecrew_generate, sidecrew_verify, sidecrew_run_batch, sidecrew_plan_validate, and 5 more. Their descriptions and schemas cost roughly 1,750 tokens of context every time the server is loaded.

### Is the io.github.lvlrSajjad/sidecrew MCP server still maintained?

io.github.lvlrSajjad/sidecrew is still listed as active in the MCP registry. We last reached this channel on 27 September 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.lvlrSajjad/sidecrew MCP server under?

io.github.lvlrSajjad/sidecrew declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/sidecrew
- Socket report: https://socket.dev/npm/package/sidecrew
- Repository: https://github.com/lvlrSajjad/sidecrew
- Changelog RSS feed: https://verifymcp.io/servers/lvlrsajjad-sidecrew/sidecrew.xml
- Changelog JSON feed: https://verifymcp.io/servers/lvlrsajjad-sidecrew/sidecrew.json
- HTML version of this page: https://verifymcp.io/servers/lvlrsajjad-sidecrew/sidecrew