forge (SidCorp-co/forge) is an MCP server listed on the M8ven Trust Index. It scores 74 out of 100, grade C. It declares 62 tools. No publisher has claimed this listing.

C
Emerging
74/100

forge

Self-hosted lifecycle platform for software powered by Claude Code. Configurable pipelines, devices you control, no credentials on the server. Apache-2.0.

Emerging. No concerning findings. Grades remain capped until the project builds reputation through adoption. Grades reflect the full trust pyramid: code, verification depth, and reputation. New projects cap at C until adoption is earned.

How we verified

⚡ Live Monitored: not connected

Verified is a snapshot. Live keeps it current, and builds your track record.

⚡ Connect GitHub → continuous verification on every pushwhy connect →

Who stands behind it

SidCorp-co

Source: github_repo_search

Is this your MCP?

Claim it to get a verified publisher badge, a free copy of our full audit findings, and direct contact for any high-priority issues we find. Or connect your repo for our deepest verification, Live Monitored: read-only, revoke anytime. What we access →

Install from

The grade above is for the source repository. Registries can serve a different version, so we mark the ones we were not able to read.

// key findings
No credential exfiltration, no sensitive file access, no obfuscation
Static analysis found nothing flowing your secrets to unexpected places.
Open source with a license and README
Anyone can audit the code, the license is declared, and the publisher documents what it does.
🔐
You'll be asked for 1 credential: ANTHROPIC_API_KEY
These are read from process.env at runtime. Make sure you trust where they’ll be sent.
// tools this server exposes62 tools

These names and descriptions are the publisher's own, read from the source code. We print them as written. Our assessment is the findings above, not this list.

forge_agent_sessions.list

List agent sessions for a project. Optional issueId/status filters. Returns a lightweight projection per session: the heavy jsonb columns (messages transcript, diff, usage, pipelineTelemetry, pipelineHealth, pipelineControl) are OMITTED to stay under the response token cap — `messageCount` exposes t

forge_agent_sessions.get

Fetch a single agent session. Truncates `messages` to the last 20 entries (totalMessages exposes the full count) so MCP payloads stay bounded. Requires the principal to be a member of the session’s project; PAT principals must additionally have the session’s project in their allowlist.

forge_collaborators

List the collaborators across your projects (projects you own or are a member of) with a membership matrix scoped to those projects. Read-only. Action: `list` (optional `search` matches email prefix; paginated). Each user includes `memberships: [{ projectId, projectSlug, role }]` limited to your vis

forge_comments
forge_config
forge_coolify_deploy
forge_feedback
forge_guide
forge_health

Server snapshot: version, uptime, db/queue/ws status, last builtin-skills seed result, and active jobs count. No project scope.

forge_issues
forge_jobs.list

List jobs scoped to a project (default 25, max 200; ordered newest-first). Supports status/type/issueId filters. Returns a lightweight projection per job: the heavy fields (payload, promptBlocks, failureMeta jsonb and the unbounded userPromptSnapshot/error text) are OMITTED to stay under the respons

forge_jobs.get

Fetch a single job by id including its linked agentSessionId. A `queued` job also carries `gate`: `{ ok: true }` when it is dispatchable and merely awaiting its turn, or `{ ok: false, reason }` naming the gate holding it — the answer to "why has this been queued for days?", which `status` alone cann

forge_jobs.events
forge_jobs.cancel

Cancel a single job (audited manual intervention). queued/held → cancelled; dispatched/running → cancellation requested + device push. Cancelling a `held` step leaves its issue and run untouched — reach for this instead of cancelling the whole run, which additionally parks the issue at on_hold. Work

forge_jobs.resume

Put a `held` job back in the queue (audited manual intervention). Use this when the hold's cause is FIXED — `retry_rounds_exhausted` and `non_retryable_terminal` never clear on their own, so without a resume the only way out of one is to cancel the step and lose it. The resume does not re-check the

forge_knowledge
forge_memory.search

Search project memory (issues, comments, jobs, notes, knowledge, decisions, policies). A semantic or hybrid search costs one embedding call (`embedMs` in the result names what it took, `took_ms` the whole); a keyword search costs none. When the question names an issue key, a status or a count, answe

forge_memory.get

List memory rows for a project, filtered by source / sourceRef / metadata containment. Returns rows sorted by createdAt|updatedAt|embeddedAt + a total count. Does NOT embed — use for natural-key lookups (e.g. step handoff by run_id+step+attempt). Live rows only unless includeArchived:true, which als

forge_memory.delete

Delete a memory row by (projectId, source, sourceRef). Idempotent — returns {deleted:false} when no row matches. Requires project membership.

forge_memory.feedback

Report the outcome of verifying a memory row against live code/state. verdict=confirmed stamps last_verified_at (protects the row from usage decay); verdict=outdated archives the row immediately (evidence required — what disproved it; a fresh write to the same sourceRef revives it). Agent-curated so

forge_memory.write

Write (upsert) a memory row for a project. Embeds textContent via the configured embedding model and stores under the unique key (projectId, source, sourceRef) — the ref you name is ALWAYS the ref that is written, and no other row is ever modified. Re-writing an existing ref REPLACES its body; the b

forge_metrics.project_step_durations

Aggregated pipeline-step durations (p50/p95/avg/cost/sample size) for one project over `pipeline_run_step_durations`. Requires project membership. Filterable by `days` (1..90, default 30) and `step`. Returns `{ rows: [{ step, p50, p95, avg, totalCostUsd, n }], windowDays, projectId }`. Pass `breakdo

forge_metrics.project_timeseries

Project time-series trend for the v2 dashboard charts (ISS-380). Returns a dense (gap-filled) bucketed series for one `metric` of cost | throughput | cycle_time | queue_wait | runner_utilization | cache_hit_rate, derived entirely from existing tables. Requires project membership. Params: `projectId`

forge_metrics.project_retry_rescues

Retry failures later rescued by a successful retry, reconstructed from historical job chains. Requires project membership. Groups results by the original failure reason. Params: `projectId` and `days` (1..90, default 30). Returns `{ rows: [{ failureKind, failureReason, rescues, lastRescuedAt }], tot

forge_metrics.session_failures

Failed agent sessions grouped by ISS-877 failure cause. Requires project membership. Params: `projectId` and `days` (1..90, default 30). Counts sessions whose STATUS is `failed` or `cancelled_stale`. Returns `{ rows: [{ cause, origin, sessions, isRealFailure, lastAt }], total, unclassified, unclassi

forge_orgs.list

List organizations the calling principal belongs to, with the caller's org role (owner|admin|member) and the isPersonal flag. Use the id as `orgId` for forge_projects.create or org-owned integration connections. Org management (create/members) lives on REST /api/orgs.

forge_orgs.members

List the members of an org the calling principal belongs to (userId, email, role, createdAt). Non-members read NOT_FOUND.

forge_phase

Declare which phase of an autonomous run you are in. Call action `start` BEFORE beginning a phase (understand, plan, code, self-review, review, merge, ship) and action `end` when it finishes, with `outcome` one of ok/failed/abandoned. The `start` call returns the `attempt` number to pass back to `en

forge_pipeline_runs.get

[DEPRECATED — use forge_project_pipeline_runs (action=get)] Fetch a single pipeline run plus a per-status job count breakdown. Requires the principal to be a member of the run’s project; PAT principals must additionally have the run’s project in their allowlist.

forge_pm.set_dependency
forge_project_pipeline_runs
forge_project_pm
forge_projects.list

List projects visible to the principal (explicit project membership of any role, plus org owner/admin implicit access). For PAT principals, results are additionally narrowed to the token's projectIds allowlist when set. Returns id, slug, name, orgId, role (effective: admin|member|viewer).

forge_projects.create

Create a new project in an org (orgId optional — defaults to the caller's personal org; the caller becomes a project admin). Accepts slug+name plus optional initial description/repoPath/baseBranch/productionBranch. PAT principals must carry the `write` scope and have a null `projectIds` allowlist (s

forge_projects.update

Update project settings (name, description, repoPath, baseBranch, productionBranch, kind). `kind` is the project's SHAPE, not a label: `website` means an Epodsystem-backed storefront where the store is the source of truth and a git repo is optional, and the runner then skips the git preflight and th

forge_projects.get

Fetch project detail visible to the principal — id, slug, name, description, orgId, createdBy, role (effective: admin|member|viewer), repoPath, workspaceSetup, baseBranch, productionBranch, defaultDeviceId, previewDeploy.{stagingUrl,stagingApiUrl,testingUrls,testCredentials,notes}, createdAt. `works

forge_reconcile

Update Pipeline stage ② (Reconcile) tool. Actions: - trigger: Start a reconcile run for a skill × packet pair (admin-only). Enforces C1–C5 contract. Returns runId or a structured refusal. - get: Fetch a single reconcile run by runId (member-gated). Returns run status, verdict, gate, bundle snaps

forge_runners

Manage runners for projects in your scope (projects you own or are a member of). Actions: `list` (optional projectId/status/type filters, restricted to your projects; returns inFlightCount per runner plus quarantinedUntil/quarantineReason — non-null means the box is HARD-excluded from dispatch after

forge_schedules
forge_skill_facts.list

List Forge Facts — the FIXED Forge process knowledge a skill author references instead of copy-pasting (status ladder, complexity/priority/category enums, relation kinds, plan/release-notes/handoff formats, worktree protocol). Each fact carries id, tier (`mandatory` = always injected; `contextual` =

forge_skill_facts.get

Fetch one Forge Fact by id (project-resolved), returning its full canonical `preview` text — the exact block a skill body gets when it references `{{forge:<id>}}`. Pass optional `stage` for stage-specific facts. Throws NOT_FOUND for an unknown id. Requires project membership.

forge_skills.list

Catalog of skills visible to a project, deduped by name. Returns a lightweight projection per skill (catalog metadata + dedup hints); the heavy bodies (skillMd, prompt, files, tools, manifest, changelog, localGuide) are OMITTED to stay under the response token cap — fetch a skill body via forge_skil

forge_skills.get

Fetch a single skill by id. Returns null when the skill is project-scoped to a different project (no cross-project leak).

forge_skills.register

Bind a PROJECT skill to a pipeline stage for this project (or clear with stage=null). Only project-scoped skills may be registered — a global template must be adopted (forge_skills.adopt) into the project first, else this rejects with SKILL_NOT_PROJECT_SCOPED. Requires project owner/admin.

forge_skills.list_registrations

List the project's stage→skill bindings overlaid with per-stage `enabled` and `mode` from `agentConfig.pipelineConfig.states`. `enabled` applies at every stage. `mode` ('auto'|'manual') gates at the ENTRY status alone — it decides whether a human releases work before it starts — and comes back `null

forge_skills.create

Create a project-scoped skill (folder-first: a SKILL.md body + optional supporting files[]). Use this to load a local skill into Forge as the source of truth. Returns the created skill row (with id, version, contentHash). Requires owner/admin on the project. Global skills cannot be created here.

forge_skills.update

Update a project-scoped skill (name/description/skillMd/target/files/localGuide/installOnly). Bumps version + recomputes contentHash when the body or files change. Set installOnly:true to force-sync a manual / user-invocable utility skill to runners WITHOUT binding it to a pipeline stage — it enters

forge_skills.delete

Delete a project-scoped skill. Requires owner/admin. Global skills cannot be deleted here.

forge_skills.effective

The project's CATALOG — deduped by name: project skills (scope='project', USABLE) plus global TEMPLATES (scope='global', adoptable, NOT usable). Each row carries skillMd, files, effectiveHash, scope, and shadowsGlobal/shadowedGlobalSkillId (catalog hints only). NOTE: this is NOT what a device instal

forge_skills.adopt

Adopt a global skill TEMPLATE into this project: clones the global (skillId must be a global) into a new project-scoped skill of the same name, which the project then owns and can edit + register. This is the ONLY way a global enters a project at runtime (globals never install/dispatch directly). Re

forge_skills.sync_status

Per-device skill freshness for the project: for each device-bound runner and each registered skill, whether it is synced / outdated / missing (server effectiveHash vs the device-reported installedHash) plus syncedAt. Use after a push to verify a device picked up the new skills. Requires project memb

forge_skills.push

Push (sync) the project's skills to its device-bound runners. Sends a `skill.sync` command over WebSocket to each targeted device room; the device pulls its effective manifest and reports installed hashes back — bodies are NOT sent in this call. Omit deviceId to signal every device-bound runner of t

forge_step_handoff.write

Upsert a step handoff (structured pipeline-state output) for an issue. Stores `payload` under `kind='handoff'` keyed on (issueId, step, attempt). Validates payload via the per-step discriminated schema. Requires project membership.

forge_step_handoff.get

List step handoffs for an issue. Filter by pipelineRunId and/or `steps` allow-list. Returns rows sorted by createdAt (default desc). Requires project membership.

forge_step_handoff.delete

Delete a step handoff by (issueId, step, attempt). Idempotent — returns {deleted: false} when no row matches. Requires project membership.

forge_step_start

Check in at the start of work on an issue. Never moves the issue — pass `stage` and it returns the working bundle: the issue (with `attachments[]`), the most-recent comments, the latest step handoffs, and the resolved `branchConfig` (issue override layered over project defaults — null means NOT conf

forge_storefront_target
forge_uploads
forge_ux_findings
forge
forge_memory.note
forge_preferences
// environment variables
To run this server yourself, you supply these values. They go in your own MCP client configuration and stay on your machine. The secret label means the value is sensitive, not that the server mishandles it.
🔐 secretANTHROPIC_API_KEY
configANTHROPIC_API_URL
configFORGE_ALERT_SCHEDULE_ACTIVE_WINDOW_HOURS
configFORGE_ALERT_SPEND_MIN_USD
configFORGE_ALERT_SPEND_WINDOW_HOURS
configFORGE_ALERT_SWEEP_INTERVAL_MS
configFORGE_CENSUS_DATABASE_URL
configLOG_LEVEL
configSESSION_SEND_ACK_MS
Deployment configuration, supplied by whoever hosts the server. Users are not asked for these.
deployDATABASE_URL
// quality suggestions

Tool annotations

No tools have read-only/destructive annotations

Add readOnlyHint or destructiveHint annotations to every tool so hosts can warn users before invoking.

All four hints declared on every tool

62/62 tools missing one or more hints — forge_agent_sessions.list (missing: readOnlyHint, destructiveHint, idempotentHint, openWorldHint); forge_agent_sessions.get (missing: readOnlyHint, destructiveHint, idempotentHint, openWorldHint); forge_collaborators (missing: readOnlyHint, destructiveHint, idempotentHint, openWorldHint), +59 more. OpenAI's directory rejects tools where any of the four hints are missing or non-boolean.

For every tool, set all four hints (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) to explicit true/false values that match the handler’s actual behaviour.

Domain consistency

npm scope @forge doesn't match GitHub owner sidcorp-co

Use the same org name across GitHub, npm, and your homepage so users can verify the publisher.

Claim the listing to review these findings one by one and send us a correction where you disagree, straight to the team. Claiming also means we tell you when the grade moves, and reach you first if we find anything urgent.

// full audit trail
The findings above are the summary. The full trail, every check we ran, each deduction, the network hosts observed and the dependency advisories, goes to verified publishers, along with an alert whenever a new one lands. Verified publishers can also review each finding and dispute it in one click. Publisher corrections have sharpened several of our checks this month, because the maintainer knows the codebase better than any scanner.
// improvement guidance — verified publishers only
We have 3 concrete improvements we can share with the publisher of this MCP. Each comes with specific guidance to raise the trust score.
// embed badge in your README
[![M8ven Score](https://m8ven.ai/badge/mcp/sidcorp-co/forge)](https://m8ven.ai/mcp/sidcorp-co/forge)
Shows your grade and updates automatically. Prefer no grade? Append ?variant=verified to the badge URL.
commit: 99c1002ac80ba9007cb658df7dcd2bb367c37cdf
code hash: 422d5d3d67c3418f479d93b756b95e7c7daa2a0babb9ac86a7baf1164bbacffa
view raw JSON →
Check MCPs from inside your assistant
Tool Check · MCP

Vetting this one by hand? Tool Check is an MCP that scores other MCPs. Add it once and ask Claude, ChatGPT, or any MCP client to grade a server, surface CVEs, check the publisher, and suggest safer alternatives — before you install.

https://m8ven.ai/api/mcp/tool-check
check_toolsearch_toolscompare_toolsrecommend_alternativescheck_publisherreport_concern
How to add it →Free · no account needed · works in any MCP client