arc-mcp-server

Name: arc-mcp-server
Author: tomevault-io

AI Community

Repo stars 0
Author updated Live
Author repo skills-registry

Fluxly profile Facts only: domain, agents, trust score, runtime, permissions and network

Domain: AI
Compatible agents: Claude Code
Cursor
Cline
Codex
Windsurf
Gemini CLI

+20
Trust score: 88 / 100 · community maintained
Author / version / license: @tomevault-io · no license declared
Token usage: Lean
Setup complexity: Guided setup
External API key: Required · Vendor-specific
Operating systems: macOS · Linux · Windows
Runtime requirements: Bun
Permissions: Read-only
Write / modify
Shell exec
Network behavior: External requests
Install commands: 26 variants

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview arc-mcp-server.preview

---
name: arc-mcp-server
description: MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when t…
category: ai
runtime: Bun
---

# arc-mcp-server output preview

## PART A: Task fit
- Use case: MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when this capability is needed. Exposes Arc's core surfaces via the Model Context Protocol (MCP). External Claude Code instances, Cursor, or any MCP client can interact with Arc's task queue, skill tree, memory, and dispatch state. requires Vendor-specific API key; r….
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “Architecture / Exposed Surfaces / Tools (read-write)” and do not present inference as author intent.

## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when this capability is needed. Exposes Arc's core surfaces via the Model Context Protocol (MCP). External Claude Code instances, Cursor, or any MCP client can interact with Arc's task queue, skill tree, memory, and dispatch state. requires Vendor-specific API key; r…”.
- **02** When the source has headings, the agent prioritizes “Architecture / Exposed Surfaces / Tools (read-write)” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files, run shell commands; may access external network resources; requires Vendor-specific API keys.

## Running Rules
- read files, write/modify files, run shell commands; may access external network resources; requires Vendor-specific API keys.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options.

SKILL.md SKILL.md

---
name: arc-mcp-server
description: MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when t…
category: ai
source: tomevault-io/skills-registry
---

# arc-mcp-server

## When to use
- MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when this capability is need…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.

## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.

## Execution rules
- Organize steps around “Architecture / Exposed Surfaces / Tools (read-write)” and keep inference separate from source facts.
- read files, write/modify files, run shell commands; may access external network resources; requires Vendor-specific API keys.
- Validate with a small sample before expanding the task.

## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies.

Evidence boundary and execution chain

The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.

skill "arc-mcp-server" {
  input      -> user goal + target files + boundaries + acceptance criteria
  context    -> Architecture / Exposed Surfaces / Tools (read-write)
  rules      -> SKILL.md triggers / order / output contract
  runtime    -> Bun | read files, write/modify files, run shell commands | may access external network resources
  guardrails -> requires Vendor-specific API keys + small-sample validation + diff/log review
  output     -> copyable result + checklist + next iteration
}

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: MCP server exposing Arc's task queue, skills, and memory to external Claude instances Use when this capability is needed. Expose…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “Architecture”, “Exposed Surfaces”, “Tools (read-write)”, “Resources (read-only)”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name arc-mcp-server directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “Architecture / Exposed Surfaces / Tools (read-write)” before expanding.

Boundaries And Review

Dependencies: Prepare Vendor-specific API keys before running a full task.
Permissions: Declared permissions include read / write / shell-exec; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

mcp-server

Exposes Arc's core surfaces via the Model Context Protocol (MCP). External Claude Code instances, Cursor, or any MCP client can interact with Arc's task queue, skill tree, memory, and dispatch state.

Architecture

Runtime: Bun + @modelcontextprotocol/sdk
Transports: stdio (local, default) or HTTP (remote, --transport http)
Auth: API key via --auth-key flag or mcp-server/auth_key credential (HTTP only)
Database: Read/write to db/arc.sqlite via existing src/db.ts functions

Exposed Surfaces

Tools (read-write)

Tool	Description
`list_tasks`	List tasks by status/priority (default: pending + active)
`create_task`	Queue a new task with subject, priority, skills
`get_task`	Fetch task details + result by ID
`close_task`	Mark task completed or failed with summary
`list_skills`	List installed skills with metadata
`get_status`	Agent status: pending/active counts, costs, last cycle

Resources (read-only)

Resource	URI	Description
Memory	`arc://memory`	Current MEMORY.md contents
Cycle Log	`arc://cycles`	Last 20 dispatch cycles

CLI

arc skills run --name mcp-server -- start                          # stdio transport (default)
arc skills run --name mcp-server -- start --transport http         # HTTP on port 3100
arc skills run --name mcp-server -- start --port 3100 --auth-key KEY  # custom port + auth

When to Load

Load when: building or maintaining the MCP server itself, debugging connection issues, or adding new tools to the exposed surface. Do NOT load when using Arc as a dispatch agent — this skill is for managing the MCP server, not for tasks executed by external MCP clients.

Claude Code Integration

Add to .claude/settings.json (external client config, not Arc's own dispatch):

{
  "mcpServers": {
    "arc": {
      "command": "bun",
      "args": ["skills/arc-mcp-server/server.ts"],
      "alwaysLoad": true
    }
  }
}

alwaysLoad: true is recommended for external clients — it ensures tools are immediately available without a ToolSearch round-trip. Do NOT add arc-mcp-server to Arc's own .claude/settings.json; Arc uses the arc CLI directly during dispatch and does not connect to its own MCP surface.

For remote HTTP:

{
  "mcpServers": {
    "arc": {
      "url": "http://localhost:3100/mcp",
      "alwaysLoad": true
    }
  }
}

Timeout Configuration

External Claude Code clients connecting via HTTP transport should set MCP_TOOL_TIMEOUT for long-running resource operations:

export MCP_TOOL_TIMEOUT=120000  # 120 seconds (default: 60s)

This is primarily relevant for large MEMORY.md reads or extended cycle log queries. Arc's native tools (list_tasks, create_task, get_status) typically complete in <5 seconds. See Claude Code v2.1.142+ release notes for details on MCP_TOOL_TIMEOUT behavior.

Source: arc0btc/arc-starter — distributed by TomeVault.

Install command

One-click installPick a runner, click Copy, paste into your terminal, press enter

npx skills add tomevault-io/skills-registry/arc0btc--arc-starter--arc-mcp-server -y

Open general install guide

View skill source

Works with

Claude Code
Cursor
Cline
Codex
Windsurf
Gemini
OpenCode
Roo Code
AAide
+Augment
GitHub Copilot
OpenClaw
KKiro
Junie
WWarp
Goose
Trae
Kilo Code
OpenHands
Amp
Zencoder
CContinue
AIAider
CodeBuddy
CodeGeeX
Replit Agent

Security audit

88 / 100

Community

未声明 license/许可。
未声明 version。
未限定 allowed-tools，默认拥有全部工具权限。

Metadata

Source: github
tomevault-io/skills-registry
中文

More by @tomevault-io

Category & tags

Category AI