Skip to main content
Glama
Repository Manager

Repository Manager

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
LLM_AGENT_MODELYesModel used by specialist agent nodes
LLM_ROUTER_MODELYesModel used by the router node
REPO_MANAGER_URLNoBase URL of the target servicehttp://localhost:8000
GRAPH_ROUTER_TIMEOUTNoRouter-node timeout (seconds)300.0
REPO_MANAGER_PASSWORDYesPassword for authentication
REPO_MANAGER_USERNAMENoUsername for authenticationadmin
GRAPH_VERIFIER_TIMEOUTNoVerifier-node timeout (seconds)300.0
REPOSITORY_MANAGER_WORKSPACEYesRoot directory of the git workspace to manage

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Expert tool for managing hierarchical Git workspaces, engineering bulk operations, and documentation.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
logging
{}
prompts
{
  "listChanged": true
}
resources
{
  "subscribe": false,
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
repository_manager_add_projectB

Stage all changes (git add -A) for a single Git project.

repository_manager_add_projectsC

Stage all changes for multiple projects in parallel.

repository_manager_build_projectsB

Build projects serially so compilation cannot exhaust the workstation.

repository_manager_bulk_bumpB

Bumps the version for all projects in the workspace in parallel.

repository_manager_bump_versionA

Bump the version of the project using bump2version.

Args: part (str): The part of the version to bump (major, minor, patch). allow_dirty (bool): Whether to allow dirty working directory. path (str): The path to the project directory. dry_run (bool): Whether to perform a dry run. verbose (bool): Whether to use verbose output (for dry-run visibility). force (bool): If the target version's tag already exists locally (an orphan tag from a prior partial bump that left the version file un-updated), delete that local tag and re-bump instead of silently skipping. The orphan tag must NOT be on the remote.

Returns: GitResult: Result of the operation.

repository_manager_cleanup_artifactsC

Removes test artifacts and temporary files from the specified directory.

repository_manager_clone_projectsC

Clone all specified Git projects in parallel using multiple threads.

Returns: List[GitResult]: A list of GitResult objects, one for each clone operation.

repository_manager_clone_repositoryB

Clone a single Git repository to a specific target path.

Args: url (str): The repository URL to clone. target_path (str): The absolute path where the repository should be cloned.

Returns: GitResult: The result of the Git clone command.

repository_manager_commit_code_projectA

Stage ALL changes (git add -A), optionally gate on pre-commit, then commit.

This is the per-repo "commit our feature code" step the release pipeline runs BEFORE bumping versions. Unlike :meth:commit_project it stages untracked files too (git add -A) and runs the project's pre-commit hooks (auto-formatters land in the same commit), so feature code is never left behind for an implicit push-time commit.

If pre-commit fails for real (not just auto-format), the failure is surfaced and nothing is committed.

repository_manager_commit_code_projectsB

Concurrently stage + pre-commit + commit feature code across projects.

The "add all our code, pre-commit, then commit" release-prep step, throttled by self.threads (the 20% CPU/RAM cap). Scales to thousands of repositories.

repository_manager_commit_projectB

Commit staged changes (git commit -m "{message}") for a single Git project.

repository_manager_commit_projectsC

Commit staged changes for multiple projects in parallel.

repository_manager_create_projectB

Create a new project directory and initialize it as a git repository.

Args: path (str): The path of the project directory to create.

Returns: GitResult: Result of the operation.

repository_manager_discover_projectsA

Scan self.path for immediate subdirectories containing a .git folder. Populates and returns self.project_map.

repository_manager_generate_markdown_summaryC

Generates a beautiful markdown summary of bulk operation results.

repository_manager_generate_workspace_templateC

Generates a workspace.yml template at the specified path.

repository_manager_get_consolidated_skill_pathsA

Returns absolute paths to the 15 specific building and documentation skills.

repository_manager_get_project_mapA

Returns the mapping of repository URLs to their local project paths. Ensures paths are absolute and expanded.

repository_manager_get_readmeA

Get the content and path of the README.md file in the specified path.

Args: path (str, optional): The directory path. Defaults to self.path.

Returns: ReadmeResult: Object containing 'content' and 'path' of the README.md file.

repository_manager_get_workspace_projectsA

Returns a list of project basenames (e.g. 'genius-agent') defined in the workspace.

repository_manager_git_actionC

Execute a Git command in the specified directory.

The operation is admitted through descriptor-pinned helpers before any subprocess is started.

repository_manager_install_projectC

Install a Python project using pip install -e .[extra].

repository_manager_install_projectsC

Bulk installs Python and Node projects in the workspace.

repository_manager_list_branchesA

Returns a dictionary mapping project basenames to their current active git branch.

repository_manager_load_projects_from_yamlC

Loads repository URLs from a YAML workspace file using Pydantic models. Strictly determines self.path relative to the configuration file.

repository_manager_pre_commitB

Execute pre-commit commands in the specified path.

Args: run (bool): Whether to run 'pre-commit run --all-files'. Default True. autoupdate (bool): Whether to run 'pre-commit autoupdate'. Default False. path (str, optional): Path to run in. Defaults to self.path.

repository_manager_pre_commit_projectsC

Execute pre-commit commands for all projects in parallel.

Returns: List[GitResult]: A list of GitResult objects.

repository_manager_pull_projectA

Pull updates for a single Git project and optionally checkout the default branch.

Args: path (str): The path to the project to pull. Defaults to self.path.

Returns: GitResult: The result of the pull operation.

repository_manager_pull_projectsB

Pull updates for multiple projects in parallel.

repository_manager_push_projectA

Atomically publish a clean checkout's exact current branch and release tag.

Publication runs from a sealed private admin repository, uses only the authorized direct destination, and reads every remote ref back before reporting success. Dirty state, gate failure, identity/config drift, non-fast-forward updates, tag collisions, and partial atomic updates all refuse publication; GitHub push protection returns an actionable error.

repository_manager_push_projectsC

Push updates for multiple projects in parallel.

repository_manager_save_workspace_configC

Saves the current or provided WorkspaceConfig to a YAML file.

repository_manager_set_threadsC

Set the number of threads for parallel processing.

Args: threads (int): The number of threads.

Notes: If the input is invalid, defaults 6

repository_manager_setup_from_yamlA

Sets up the workspace structure from a YAML file.

install=True extends clone/pull with the fresh-machine bootstrap gap this closes (CONCEPT:RM-BOOTSTRAP): after every repository is cloned or pulled, materialize the .uv-workspace-siblings/ symlinks and run uv sync for scion-sdk and every cloned project that declares a path dependency on it, dependency-ordered (scion-sdk first). See :meth:install_projects for the mechanism and its documented limits. Install failures are reported, never masked -- setup_from_yaml returns status="error" if any project failed to install, even though every repository was still cloned/pulled.

repository_manager_test_projectsC

Execute pytests for the specified projects in parallel.

Args: progress_phase: Phase name for live progress updates. progress_dict: Shared mutable dict for live progress reporting.

repository_manager_update_dependencyC

Update a package's pinned version in a deps file (pyproject or requirements).

repository_manager_validate_and_releaseC

Validate projects in parallel and report whether all passed.

repository_manager_validate_single_projectA

Validates a single repository by running its FAST-tier gates.

Delegates to :func:repository_manager.gates.run_gate_stage (the same engine rm_gates uses) with stage="fast" (--hook-stage pre-commit). Under the two-tier gate model a repo's HEAVY hooks (pytest, cargo, uv lock --check, ...) are declared stages: [pre-push, manual] and are therefore correctly excluded here -- use rm_gates action=run stage=heavy for those.

repository_manager_worktree_hygieneA

Audit (and optionally prune) session worktrees as a release-flow step.

Wraps :meth:WorktreeManager.audit. Read-only by default — it returns the safe_to_prune/do_not_disturb classification so a release run can report what could be cleaned without touching anything. With prune=True it removes only merged worktrees (and dangling admin pointers), never active/stale work or orphaned directories. This is the audit-aware cleanup the release pipeline runs instead of a blind reaper. (CONCEPT:RM-WORKTREE-AUDIT)

rm_git_cloneC

Clone (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_enumerateC

Enumerate (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_pullC

Pull (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_pushC

Push (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_addC

Add (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_commitC

Commit (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_pre_commitC

Pre commit (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_commit_codeB

Commit code (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_statusC

Status (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_cancelC

Cancel (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

rm_git_rawC

Raw (rm_git). Typed bulk Git operations; arbitrary host commands are prohibited.

repository_ingest_repositoriesB

Natively ingest git repositories into epistemic-graph as typed :GitRepository nodes.

Enumerates repositories across a GitLab instance / GitHub org via the real VCS enumerator and pushes them (typed :GitRepository nodes with vcs/clone_url/web_url/ default_branch provenance) into the knowledge graph via the fast engine client. Best-effort: returns {"ingested": None} when no engine is reachable. CONCEPT:MERISTEM-KG.ingest.enterprise-source-extractor.

rm_lane_startC

Start (rm_lane). The lane lifecycle for concurrent agents and humans (CONCEPT:RM-LANE-DOCTOR).

Every check behind this tool exists because a specific collision destroyed real work while the rule that would have prevented it was written down, in prose, in front of the actor who broke it: editing a canonical checkout a background git reset then discarded; a git stash into the ONE refs/stash shared by ~54 worktrees; a shared CARGO_TARGET_DIR that corrupts rather than merely serializes; an unset PRE_COMMIT_HOME whose shared store swallows unstaged work; a foreign or stale worktree-local .venv worth ~167 phantom failures; and measuring a branch TIP that will never be the tree that lands. The exact all-extras environment managed by scripts/uv_workspace.py is accepted because it is lane-partitioned and synchronized before execution.

doctor is the one to reach for when something behaves impossibly — a test failing that cannot fail, a build that will not go green, a merge that keeps being refused. It answers in under a second and mutates nothing.

rm_lane_doctorB

Doctor (rm_lane). The lane lifecycle for concurrent agents and humans (CONCEPT:RM-LANE-DOCTOR).

Every check behind this tool exists because a specific collision destroyed real work while the rule that would have prevented it was written down, in prose, in front of the actor who broke it: editing a canonical checkout a background git reset then discarded; a git stash into the ONE refs/stash shared by ~54 worktrees; a shared CARGO_TARGET_DIR that corrupts rather than merely serializes; an unset PRE_COMMIT_HOME whose shared store swallows unstaged work; a foreign or stale worktree-local .venv worth ~167 phantom failures; and measuring a branch TIP that will never be the tree that lands. The exact all-extras environment managed by scripts/uv_workspace.py is accepted because it is lane-partitioned and synchronized before execution.

doctor is the one to reach for when something behaves impossibly — a test failing that cannot fail, a build that will not go green, a merge that keeps being refused. It answers in under a second and mutates nothing.

rm_lane_healC

Heal (rm_lane). The lane lifecycle for concurrent agents and humans (CONCEPT:RM-LANE-DOCTOR).

Every check behind this tool exists because a specific collision destroyed real work while the rule that would have prevented it was written down, in prose, in front of the actor who broke it: editing a canonical checkout a background git reset then discarded; a git stash into the ONE refs/stash shared by ~54 worktrees; a shared CARGO_TARGET_DIR that corrupts rather than merely serializes; an unset PRE_COMMIT_HOME whose shared store swallows unstaged work; a foreign or stale worktree-local .venv worth ~167 phantom failures; and measuring a branch TIP that will never be the tree that lands. The exact all-extras environment managed by scripts/uv_workspace.py is accepted because it is lane-partitioned and synchronized before execution.

doctor is the one to reach for when something behaves impossibly — a test failing that cannot fail, a build that will not go green, a merge that keeps being refused. It answers in under a second and mutates nothing.

rm_lane_envC

Env (rm_lane). The lane lifecycle for concurrent agents and humans (CONCEPT:RM-LANE-DOCTOR).

Every check behind this tool exists because a specific collision destroyed real work while the rule that would have prevented it was written down, in prose, in front of the actor who broke it: editing a canonical checkout a background git reset then discarded; a git stash into the ONE refs/stash shared by ~54 worktrees; a shared CARGO_TARGET_DIR that corrupts rather than merely serializes; an unset PRE_COMMIT_HOME whose shared store swallows unstaged work; a foreign or stale worktree-local .venv worth ~167 phantom failures; and measuring a branch TIP that will never be the tree that lands. The exact all-extras environment managed by scripts/uv_workspace.py is accepted because it is lane-partitioned and synchronized before execution.

doctor is the one to reach for when something behaves impossibly — a test failing that cannot fail, a build that will not go green, a merge that keeps being refused. It answers in under a second and mutates nothing.

rm_lane_finishC

Finish (rm_lane). The lane lifecycle for concurrent agents and humans (CONCEPT:RM-LANE-DOCTOR).

Every check behind this tool exists because a specific collision destroyed real work while the rule that would have prevented it was written down, in prose, in front of the actor who broke it: editing a canonical checkout a background git reset then discarded; a git stash into the ONE refs/stash shared by ~54 worktrees; a shared CARGO_TARGET_DIR that corrupts rather than merely serializes; an unset PRE_COMMIT_HOME whose shared store swallows unstaged work; a foreign or stale worktree-local .venv worth ~167 phantom failures; and measuring a branch TIP that will never be the tree that lands. The exact all-extras environment managed by scripts/uv_workspace.py is accepted because it is lane-partitioned and synchronized before execution.

doctor is the one to reach for when something behaves impossibly — a test failing that cannot fail, a build that will not go green, a merge that keeps being refused. It answers in under a second and mutates nothing.

rm_worktree_addC

Add (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_auditC

Audit (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_bulk_addC

Bulk add (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_listC

List (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_mergeC

Merge (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_pruneC

Prune (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_removeC

Remove (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_reset_branchC

Reset branch (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_worktree_syncC

Sync (rm_worktree). Manage git worktrees for concurrent multi-session development (CONCEPT:RM-WORKTREE).

Each session works a repo in its own worktree on its own branch under <WORKTREE_ROOT>/<repo>/<branch> (shared .git, no re-clone), leaving the canonical checkout on its default branch so a working-tree reset never disturbs in-flight session work.

rm_merge_queue_enqueueA

Enqueue (rm_merge_queue). Serialized merge queue for ANY git repository (CONCEPT:RM-MERGE-QUEUE).

The canonical driver of parallel development: lanes take worktrees, work, then hand branches here, and the queue gates them as merged, fast-forwards the base, and prunes the worktree and branch. Set push false when a scheduler must leave publication to a separate push.

The queue does not know what a gate is. Gates are declared in the target repository's own .mergequeue.yaml — a command, a tier, a timeout, and how to compare its result against the base ref. scion-sdk declares pytest + ruff + its contract scripts; epistemic-graph declares cargo check --all-features + clippy; a docs repo could declare only a link check. A repository with no declaration is REFUSED rather than defaulted, because "declared no gates" and "has no queue configured" must not be the same value.

Gating is differential: only a failure the base ref does not already produce blocks a candidate — the base is legitimately red here, and an absolute gate once deadlocked a queue and stranded 19 branches. A baseline that cannot be produced REFUSES the candidate; it never degrades to allow-all.

run holds that repository's reconciliation-merge LEASE. If another runner holds it the call returns deferred: true with the holder — defer, do not retry in a loop.

landed vs pushed (D-W3WPS-3). Each outcome carries both, separately: landed means the declared base ref fast-forwarded in the LOCAL canonical checkout (proven by re-reading it); when push is true, pushed means that commit also reached the configured remote via the repo's own gated push path (_gate_before_push + push_project — the same pre-commit gates and GH013/divergent-remote handling a manual push gets). With push false, publication is deliberately deferred to a separate push. A push failure never fails the landing — landed: true, pushed: false is a legitimate, visible intermediate state; check push_error on the outcome for why. The queue's own run summary also reports pushed/landed_unpushed counts.

rm_merge_queue_statusC

Status (rm_merge_queue). Serialized merge queue for ANY git repository (CONCEPT:RM-MERGE-QUEUE).

The canonical driver of parallel development: lanes take worktrees, work, then hand branches here, and the queue gates them as merged, fast-forwards the base, and prunes the worktree and branch. Set push false when a scheduler must leave publication to a separate push.

The queue does not know what a gate is. Gates are declared in the target repository's own .mergequeue.yaml — a command, a tier, a timeout, and how to compare its result against the base ref. scion-sdk declares pytest + ruff + its contract scripts; epistemic-graph declares cargo check --all-features + clippy; a docs repo could declare only a link check. A repository with no declaration is REFUSED rather than defaulted, because "declared no gates" and "has no queue configured" must not be the same value.

Gating is differential: only a failure the base ref does not already produce blocks a candidate — the base is legitimately red here, and an absolute gate once deadlocked a queue and stranded 19 branches. A baseline that cannot be produced REFUSES the candidate; it never degrades to allow-all.

run holds that repository's reconciliation-merge LEASE. If another runner holds it the call returns deferred: true with the holder — defer, do not retry in a loop.

landed vs pushed (D-W3WPS-3). Each outcome carries both, separately: landed means the declared base ref fast-forwarded in the LOCAL canonical checkout (proven by re-reading it); when push is true, pushed means that commit also reached the configured remote via the repo's own gated push path (_gate_before_push + push_project — the same pre-commit gates and GH013/divergent-remote handling a manual push gets). With push false, publication is deliberately deferred to a separate push. A push failure never fails the landing — landed: true, pushed: false is a legitimate, visible intermediate state; check push_error on the outcome for why. The queue's own run summary also reports pushed/landed_unpushed counts.

rm_merge_queue_withdrawC

Withdraw (rm_merge_queue). Serialized merge queue for ANY git repository (CONCEPT:RM-MERGE-QUEUE).

The canonical driver of parallel development: lanes take worktrees, work, then hand branches here, and the queue gates them as merged, fast-forwards the base, and prunes the worktree and branch. Set push false when a scheduler must leave publication to a separate push.

The queue does not know what a gate is. Gates are declared in the target repository's own .mergequeue.yaml — a command, a tier, a timeout, and how to compare its result against the base ref. scion-sdk declares pytest + ruff + its contract scripts; epistemic-graph declares cargo check --all-features + clippy; a docs repo could declare only a link check. A repository with no declaration is REFUSED rather than defaulted, because "declared no gates" and "has no queue configured" must not be the same value.

Gating is differential: only a failure the base ref does not already produce blocks a candidate — the base is legitimately red here, and an absolute gate once deadlocked a queue and stranded 19 branches. A baseline that cannot be produced REFUSES the candidate; it never degrades to allow-all.

run holds that repository's reconciliation-merge LEASE. If another runner holds it the call returns deferred: true with the holder — defer, do not retry in a loop.

landed vs pushed (D-W3WPS-3). Each outcome carries both, separately: landed means the declared base ref fast-forwarded in the LOCAL canonical checkout (proven by re-reading it); when push is true, pushed means that commit also reached the configured remote via the repo's own gated push path (_gate_before_push + push_project — the same pre-commit gates and GH013/divergent-remote handling a manual push gets). With push false, publication is deliberately deferred to a separate push. A push failure never fails the landing — landed: true, pushed: false is a legitimate, visible intermediate state; check push_error on the outcome for why. The queue's own run summary also reports pushed/landed_unpushed counts.

rm_merge_queue_runA

Run (rm_merge_queue). Serialized merge queue for ANY git repository (CONCEPT:RM-MERGE-QUEUE).

The canonical driver of parallel development: lanes take worktrees, work, then hand branches here, and the queue gates them as merged, fast-forwards the base, and prunes the worktree and branch. Set push false when a scheduler must leave publication to a separate push.

The queue does not know what a gate is. Gates are declared in the target repository's own .mergequeue.yaml — a command, a tier, a timeout, and how to compare its result against the base ref. scion-sdk declares pytest + ruff + its contract scripts; epistemic-graph declares cargo check --all-features + clippy; a docs repo could declare only a link check. A repository with no declaration is REFUSED rather than defaulted, because "declared no gates" and "has no queue configured" must not be the same value.

Gating is differential: only a failure the base ref does not already produce blocks a candidate — the base is legitimately red here, and an absolute gate once deadlocked a queue and stranded 19 branches. A baseline that cannot be produced REFUSES the candidate; it never degrades to allow-all.

run holds that repository's reconciliation-merge LEASE. If another runner holds it the call returns deferred: true with the holder — defer, do not retry in a loop.

landed vs pushed (D-W3WPS-3). Each outcome carries both, separately: landed means the declared base ref fast-forwarded in the LOCAL canonical checkout (proven by re-reading it); when push is true, pushed means that commit also reached the configured remote via the repo's own gated push path (_gate_before_push + push_project — the same pre-commit gates and GH013/divergent-remote handling a manual push gets). With push false, publication is deliberately deferred to a separate push. A push failure never fails the landing — landed: true, pushed: false is a legitimate, visible intermediate state; check push_error on the outcome for why. The queue's own run summary also reports pushed/landed_unpushed counts.

rm_merge_queue_configC

Config (rm_merge_queue). Serialized merge queue for ANY git repository (CONCEPT:RM-MERGE-QUEUE).

The canonical driver of parallel development: lanes take worktrees, work, then hand branches here, and the queue gates them as merged, fast-forwards the base, and prunes the worktree and branch. Set push false when a scheduler must leave publication to a separate push.

The queue does not know what a gate is. Gates are declared in the target repository's own .mergequeue.yaml — a command, a tier, a timeout, and how to compare its result against the base ref. scion-sdk declares pytest + ruff + its contract scripts; epistemic-graph declares cargo check --all-features + clippy; a docs repo could declare only a link check. A repository with no declaration is REFUSED rather than defaulted, because "declared no gates" and "has no queue configured" must not be the same value.

Gating is differential: only a failure the base ref does not already produce blocks a candidate — the base is legitimately red here, and an absolute gate once deadlocked a queue and stranded 19 branches. A baseline that cannot be produced REFUSES the candidate; it never degrades to allow-all.

run holds that repository's reconciliation-merge LEASE. If another runner holds it the call returns deferred: true with the holder — defer, do not retry in a loop.

landed vs pushed (D-W3WPS-3). Each outcome carries both, separately: landed means the declared base ref fast-forwarded in the LOCAL canonical checkout (proven by re-reading it); when push is true, pushed means that commit also reached the configured remote via the repo's own gated push path (_gate_before_push + push_project — the same pre-commit gates and GH013/divergent-remote handling a manual push gets). With push false, publication is deliberately deferred to a separate push. A push failure never fails the landing — landed: true, pushed: false is a legitimate, visible intermediate state; check push_error on the outcome for why. The queue's own run summary also reports pushed/landed_unpushed counts.

rm_build_requestB

Request (rm_build). Content-addressed build broker for ANY repository (CONCEPT:RM-TASK-LEDGER).

Keyed by (repo, tree-sha, feature-set, toolchain-fingerprint, target-triple). The DEDUP is the value: N lanes asking for the same build today each pay for a full cargo/pnpm build into their own target-isolated/node_modules — measured at 21.7 GB across 4 duplicate directories after pruning. This tool publishes named artifacts to a shared, checksummed cache instead.

Honest degradation: a dirty tree or an unfingerprintable toolchain BUILDS — it never serves a possibly-stale artifact and never silently skips the cache as though it were consulted.

Co-location: this tool always passes colocated=True to the underlying reservation, because being inside this pinned MCP server process IS the proof of same-node execution that a bare CLI invocation cannot provide — fcntl leases do not arbitrate across nodes, and the lease files live under an NFS-exported path. Route build requests through this tool rather than a bare local invocation when you are not certain you are on the pinned node.

Arbitration is advisory (D-CP-8): an agent running cargo build directly bypasses this broker entirely.

rm_build_statusC

Status (rm_build). Content-addressed build broker for ANY repository (CONCEPT:RM-TASK-LEDGER).

Keyed by (repo, tree-sha, feature-set, toolchain-fingerprint, target-triple). The DEDUP is the value: N lanes asking for the same build today each pay for a full cargo/pnpm build into their own target-isolated/node_modules — measured at 21.7 GB across 4 duplicate directories after pruning. This tool publishes named artifacts to a shared, checksummed cache instead.

Honest degradation: a dirty tree or an unfingerprintable toolchain BUILDS — it never serves a possibly-stale artifact and never silently skips the cache as though it were consulted.

Co-location: this tool always passes colocated=True to the underlying reservation, because being inside this pinned MCP server process IS the proof of same-node execution that a bare CLI invocation cannot provide — fcntl leases do not arbitrate across nodes, and the lease files live under an NFS-exported path. Route build requests through this tool rather than a bare local invocation when you are not certain you are on the pinned node.

Arbitration is advisory (D-CP-8): an agent running cargo build directly bypasses this broker entirely.

rm_build_artifactsC

Artifacts (rm_build). Content-addressed build broker for ANY repository (CONCEPT:RM-TASK-LEDGER).

Keyed by (repo, tree-sha, feature-set, toolchain-fingerprint, target-triple). The DEDUP is the value: N lanes asking for the same build today each pay for a full cargo/pnpm build into their own target-isolated/node_modules — measured at 21.7 GB across 4 duplicate directories after pruning. This tool publishes named artifacts to a shared, checksummed cache instead.

Honest degradation: a dirty tree or an unfingerprintable toolchain BUILDS — it never serves a possibly-stale artifact and never silently skips the cache as though it were consulted.

Co-location: this tool always passes colocated=True to the underlying reservation, because being inside this pinned MCP server process IS the proof of same-node execution that a bare CLI invocation cannot provide — fcntl leases do not arbitrate across nodes, and the lease files live under an NFS-exported path. Route build requests through this tool rather than a bare local invocation when you are not certain you are on the pinned node.

Arbitration is advisory (D-CP-8): an agent running cargo build directly bypasses this broker entirely.

rm_build_explainC

Explain (rm_build). Content-addressed build broker for ANY repository (CONCEPT:RM-TASK-LEDGER).

Keyed by (repo, tree-sha, feature-set, toolchain-fingerprint, target-triple). The DEDUP is the value: N lanes asking for the same build today each pay for a full cargo/pnpm build into their own target-isolated/node_modules — measured at 21.7 GB across 4 duplicate directories after pruning. This tool publishes named artifacts to a shared, checksummed cache instead.

Honest degradation: a dirty tree or an unfingerprintable toolchain BUILDS — it never serves a possibly-stale artifact and never silently skips the cache as though it were consulted.

Co-location: this tool always passes colocated=True to the underlying reservation, because being inside this pinned MCP server process IS the proof of same-node execution that a bare CLI invocation cannot provide — fcntl leases do not arbitrate across nodes, and the lease files live under an NFS-exported path. Route build requests through this tool rather than a bare local invocation when you are not certain you are on the pinned node.

Arbitration is advisory (D-CP-8): an agent running cargo build directly bypasses this broker entirely.

rm_build_gcC

Gc (rm_build). Content-addressed build broker for ANY repository (CONCEPT:RM-TASK-LEDGER).

Keyed by (repo, tree-sha, feature-set, toolchain-fingerprint, target-triple). The DEDUP is the value: N lanes asking for the same build today each pay for a full cargo/pnpm build into their own target-isolated/node_modules — measured at 21.7 GB across 4 duplicate directories after pruning. This tool publishes named artifacts to a shared, checksummed cache instead.

Honest degradation: a dirty tree or an unfingerprintable toolchain BUILDS — it never serves a possibly-stale artifact and never silently skips the cache as though it were consulted.

Co-location: this tool always passes colocated=True to the underlying reservation, because being inside this pinned MCP server process IS the proof of same-node execution that a bare CLI invocation cannot provide — fcntl leases do not arbitrate across nodes, and the lease files live under an NFS-exported path. Route build requests through this tool rather than a bare local invocation when you are not certain you are on the pinned node.

Arbitration is advisory (D-CP-8): an agent running cargo build directly bypasses this broker entirely.

rm_projects_installB

Install (rm_projects). Bulk install, build, and validate Python projects.

The 'validate' action submits validation as a background job and returns a job_id immediately. Use 'validate_status' with that job_id to poll progress and retrieve results once complete.

rm_projects_buildA

Build (rm_projects). Bulk install, build, and validate Python projects.

The 'validate' action submits validation as a background job and returns a job_id immediately. Use 'validate_status' with that job_id to poll progress and retrieve results once complete.

rm_projects_validateA

Validate (rm_projects). Bulk install, build, and validate Python projects.

The 'validate' action submits validation as a background job and returns a job_id immediately. Use 'validate_status' with that job_id to poll progress and retrieve results once complete.

rm_projects_validate_statusB

Validate status (rm_projects). Bulk install, build, and validate Python projects.

The 'validate' action submits validation as a background job and returns a job_id immediately. Use 'validate_status' with that job_id to poll progress and retrieve results once complete.

rm_docs_readiness_previewC

Preview (rm_docs_readiness). Preview/apply/verify artifacts after per-repository readiness setup.

rm_docs_readiness_applyC

Apply (rm_docs_readiness). Preview/apply/verify artifacts after per-repository readiness setup.

rm_docs_readiness_verifyC

Verify (rm_docs_readiness). Preview/apply/verify artifacts after per-repository readiness setup.

rm_gates_runB

Run (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_retestB

Retest (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_statusC

Status (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_explainC

Explain (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_profileC

Profile (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_audit_fail_fastB

Audit fail fast (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_xdist_planC

Xdist plan (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_xdist_applyC

Xdist apply (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_phase_directionB

Phase direction (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_reposC

Repos (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_gates_phase_direction_hereC

Phase direction here (rm_gates). Run and inspect the two-tier (fast/heavy) pre-commit gate across repos.

The single tool that can actually drive both tiers of the two-tier gate model: stage="fast" exercises a repo's pre-commit-stage hooks, stage="heavy" exercises its pre-push-stage hooks (pytest, cargo, uv lock --check, ...) via pre-commit run --hook-stage <stage>.

rm_rollout_planC

Plan (rm_rollout).

rm_rollout_applyD

Apply (rm_rollout).

rm_rollout_statusD

Status (rm_rollout).

rm_rollout_releaseD

Release (rm_rollout).

rm_workspace_listC

List (rm_workspace). Core workspace organization and configuration.

rm_workspace_list_branchesC

List branches (rm_workspace). Core workspace organization and configuration.

rm_workspace_setupC

Setup (rm_workspace). Core workspace organization and configuration.

rm_workspace_templateC

Template (rm_workspace). Core workspace organization and configuration.

rm_workspace_saveC

Save (rm_workspace). Core workspace organization and configuration.

rm_workspace_fleet_evidence_checkC

Fleet evidence check (rm_workspace). Core workspace organization and configuration.

rm_concepts_reserveB

Reserve (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_getC

Get (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_listC

List (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_materializeC

Materialize (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_releaseC

Release (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_verify_candidateC

Verify candidate (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_verify_generationC

Verify generation (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_concepts_reconcileB

Reconcile (rm_concepts). Concept-id claim coordination against RMDD-16's central authority.

Repository-manager never allocates a concept id itself: every action here is a thin, MCP/CLI-neutral consumer of an injected authority port. When the central authority (scion_sdk.governance. concept_reservation) is unavailable in this environment, every mutating action refuses with a named dependency_blocked/ConceptAuthorityUnavailable error instead of fabricating a local allocation -- it never mints or reuses an id on its own.

rm_remote_workers_register_workerC

Register worker (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_seed_from_inventoryC

Seed from inventory (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_profileC

Profile (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_recheckC

Recheck (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_stage_sourceC

Stage source (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_verify_sourceC

Verify source (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_receive_artifactC

Receive artifact (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_dispatch_buildC

Dispatch build (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

rm_remote_workers_host_loss_reconcileB

Host loss reconcile (rm_remote_workers). Remote worker registry, immutable source staging, and artifact transport.

Composes RMDD-15's repository_manager.remote_execution package with the RMDD-08 CapacityInventory resource ledger. The optional tunnel-manager dependency is never required to import this tool: recheck/live remote dispatch refuse with a named, cause-preserving error when it is absent instead of raising an ImportError. host_loss_reconcile always refuses today: no live WorkItem-authoritative ResourceScheduler is wired into any repository-manager entrypoint yet, and this tool never substitutes a local in-memory reservation ledger for that authority.

Prompts

Interactive templates invoked by user choice

NameDescription
connector-statusAsk for this connector server's current operational status.
repository-manager-concept-steward
repository-manager-operator
repository-manager-release-engineer
repository-manager-repository-maintainer

Resources

Contextual data attached and managed by the client

NameDescription
_connector_status_resourceNative resource exposing this server's static status payload.
ontology://repository-manager/repository.ttl
ontology://repository-manager/contracts.ttl
connector-resourcesData sources, ontology mappings and resources of this connector.
repository-manager-candidate-certification/SKILL.mdUnderstand and verify a branch candidate's and a sealed generation's certification state — the Candidate/Generation lifecycle vocabulary, the validation-stage/evidence model, and the `rm_concepts_verify_candidate` / `verify_generation` marker-collision checks — before trusting a merge-queue outcome as landable. This is the vocabulary and marker-verification layer; the actual batching/differential-gating/bisection mechanics that decide landability live in `rm_merge_queue_*` and are documented in repository-manager-merge-and- reconcile, not duplicated here. Use when an agent must explain why a candidate is in a given state, verify a candidate's or generation's introduced CONCEPT: markers, or reason about a rejected/bisected generation. Do NOT use this skill to actually land a branch (repository-manager-merge-and-reconcile) or to reserve a concept id (repository-manager-concept-coordination).
repository-manager-candidate-certification/_manifestFile listing for repository-manager-candidate-certification
repository-manager-workspace-validation/SKILL.mdInstall, build, and validate the managed projects of a workspace via the repository-manager MCP server — run pre-commit + pytest validation per project and install/build ecosystems. Use when the agent must ensure all projects are valid, fix project errors, or run the validation suite. To raise a dependency floor across the fleet use `rm_rollout` / `repository-manager rollout` (repository-manager-workspace-release). Do NOT use for isolated session worktrees (repository-manager-worktree-orchestration) or bulk clone/pull/push (repository-manager-bulk-git-operations).
repository-manager-workspace-validation/_manifestFile listing for repository-manager-workspace-validation
repository-manager-development/SKILL.mdDeliver a small, source-backed repository-manager change from an isolated worktree through focused validation, normal review, and evidence-based publication. Use this skill for repository-manager's own MCP adapter, CLI, packaging, skills, workflows, and development gates; use the narrower lifecycle and release skills for their detailed operations.
repository-manager-development/_manifestFile listing for repository-manager-development
repository-manager-gate-execution/SKILL.mdRun and inspect the two-tier (fast/heavy) pre-commit gate across repos via `rm_gates_*`, and validate a fix without re-running the whole wave: `run` to populate the durable gate ledger, `retest` to narrow a re-run to only the hooks the ledger last recorded failing (with automatic full-wave escalation on an all-pass), and `profile` to find the slow hooks. Covers the gate ledger's clear-on-improve/staleness/shippability semantics, the cargo-vs-pytest/go fail-fast-flag asymmetry, and three environment traps that reliably produce false gate verdicts. Use when an agent must run a repo's fast or heavy gate, re-validate only what just failed, explain a failure, or find what is slow. Do NOT use for the merge queue's own differential gate-vs-base comparison (repository-manager-merge-and-reconcile), Python install/build via `rm_projects_*` (repository-manager-workspace-validation), or content-addressed build caching (repository-manager-build-coordination).
repository-manager-gate-execution/_manifestFile listing for repository-manager-gate-execution
repository-manager-bulk-git-operations/SKILL.mdBulk, parallel git operations across a whole workspace of repositories via the repository-manager MCP server — clone, pull, push, add, commit, pre-commit, and enumerate every repo across a GitLab instance / GitHub org into an ingest manifest (which also natively ingests them into the knowledge graph as typed :GitRepository nodes). Raw host git commands are permanently retired and always refused. Use when the agent must operate over many repos at once or discover the full repo inventory. Do NOT use for single-session worktree branches (repository-manager-worktree-orchestration) or per-project install/validate/ version bumps (repository-manager-workspace-validation).
repository-manager-bulk-git-operations/_manifestFile listing for repository-manager-bulk-git-operations
repository-manager-lane-lifecycle/SKILL.mdRun one unit of work — one agent session or one person — as an isolated lane in a repository many other lanes are editing at the same time. Covers opening a lane (worktree + partitioned build/test/hook state), staying isolated while working, diagnosing a lane that is behaving impossibly, and closing it out. Use whenever you are about to edit a repository that other agents or humans are also editing, when a test fails in a way that cannot be true, when a build will not go green, or when work has gone missing. Do NOT use for landing a branch and resolving conflicts (repository-manager-merge-and-reconcile) or for workspace-wide sweeps across many repos (repository-manager-fleet-scale-operations).
repository-manager-lane-lifecycle/_manifestFile listing for repository-manager-lane-lifecycle
repository-manager-fleet-scale-operations/SKILL.mdRun development across MANY repositories and many concurrent lanes at once — bulk worktree creation, workspace-wide worktree audits and classification (merged / active / stale / dangling / orphaned), safe mass pruning, draining several repositories' merge queues in parallel, and sizing concurrency against the real binding constraint (disk I/O and swap, not the agent cap). Use when launching or reclaiming a wave of lanes, when worktrees have accumulated, or when deciding how many heavy jobs may run at once. Do NOT use for a single lane's lifecycle (repository-manager-lane-lifecycle) or for landing and reconciling one branch (repository-manager-merge-and-reconcile).
repository-manager-fleet-scale-operations/_manifestFile listing for repository-manager-fleet-scale-operations
repository-manager-development-lifecycle/SKILL.mdThe default entrypoint for one unit of work — plan, start, work with a live heartbeat, check, submit, watch status, and abort — composed entirely from the repository-manager MCP/CLI surface (rm_lane_*, rm_worktree_*, rm_merge_queue_*, and rm_concepts_*). It never opens a raw shell, runs a direct compiler, hand-merges, or writes an unreserved concept marker; every step routes to the governed action that already exists. Use this FIRST for any repository change an agent will land. Do NOT use for many-repository fan-out (repository-manager-fleet-scale-operations), bulk git across repos (repository-manager-bulk-git-operations), build-cache operation (repository-manager-build-coordination), or remote-worker capacity (repository-manager-worker-operations) — those are named lower down in this skill's routing map.
repository-manager-development-lifecycle/_manifestFile listing for repository-manager-development-lifecycle
repository-manager-merge-and-reconcile/SKILL.mdLand a branch into a shared base that dozens of other lanes are landing into at the same time, and reconcile it when it conflicts. Covers the serialized merge queue, per-repository gate declarations, differential gating against a base ref that is legitimately red, measuring the MERGED tree rather than the branch tip, the conflict-resolution decision procedure (generated-file / semantic-divergence / base-moved / gate-red), and safe pruning. Use when a branch is ready to land, when a merge conflicts, when a gate is red and you must decide whether that is NEW, or when a queue candidate is rejected. Do NOT use for opening or isolating a lane (repository-manager-lane-lifecycle) or for workspace-wide sweeps (repository-manager-fleet-scale-operations).
repository-manager-merge-and-reconcile/_manifestFile listing for repository-manager-merge-and-reconcile
repository-manager-parallel-lane-orchestration/SKILL.mdRun a program as one central orchestrator plus many parallel worker agents: brief each lane, land its branch into main locally the moment it arrives, prune the branch and worktree immediately, and push only once the program is complete. Covers the lane briefing contract, land-as-they-arrive merge discipline, provider-before-consumer ordering for cross-repo changes, adjudicating contradictory lane reports, and the verification rules that catch a lane (or the orchestrator) being confidently wrong. Use when dispatching more than one worker agent at a time, when deciding whether a returned lane is safe to land, or when reconciling a workspace back to zero branches and zero worktrees. Do NOT use for the mechanics of a single merge or conflict (repository-manager-merge-and-reconcile), for opening one lane (repository-manager-lane-lifecycle), or for release/publish (repository-manager-workspace-release).
repository-manager-parallel-lane-orchestration/_manifestFile listing for repository-manager-parallel-lane-orchestration
repository-manager-build-coordination/SKILL.mdContent-addressed build/cache coordination for ANY repository via the repository-manager MCP server — dedup-or-build requests, cache-key status, published artifacts, why a key missed cache, and bounded cache reclamation. Routes agents away from a bare, uncoordinated `cargo build`/`uv sync`/`pnpm build` that duplicates work every other lane asking for the same (repo, tree-sha, feature-set, toolchain, target) has already paid for. Use when an agent needs a repository's build artifacts, wants to know whether a build is cached, or must reclaim old cache entries. Do NOT use for the packaging-style `rm_projects_*` install/build (repository-manager-workspace-validation), for the merge queue's own gate execution (repository-manager-merge-and-reconcile), or for sizing how many heavy builds may run at once (repository-manager-fleet-scale-operations).
repository-manager-build-coordination/_manifestFile listing for repository-manager-build-coordination
repository-manager-workspace-release/SKILL.mdRoll a dependency floor across the fleet deterministically and manage the `workspace.yml` manifest — via `rm_rollout` (or `repository-manager rollout`) and `rm_workspace_*`. A rollout selects the workspace.yml group's non-archived repos that depend on the package, plans per repo from main into a resumable ledger, applies each change in a fresh worktree through a pull request with auto-merge, reports merged/failing/pending, and tags `v<version>` only after the PR merged and main's floor is met. Nothing reaches main except through a PR. Use for "roll scion-sdk X to all connectors", "which rollout PRs are failing", "tag the repos whose rollout merged", or scaffolding/saving `workspace.yml`. Do NOT use for per-project validation (repository-manager-workspace-validation) or bulk clone/pull/push (repository-manager-bulk-git-operations).
repository-manager-workspace-release/_manifestFile listing for repository-manager-workspace-release
repository-manager-worker-operations/SKILL.mdRegister a remote host's weighted capacity and authorized repository roots, read its profile, run the dispatch-time entitlement recheck, stage/verify an immutable source commit onto it with a fixed clone/fetch/checkout command sequence, stream artifacts/logs back, and reconcile a lost host — via the repository-manager `rm_remote_workers_*` MCP tool / `--remote-workers` CLI family. Routes agents away from a raw SSH/tunnel command or a hand-rolled clone onto a remote host. ⚠ `recheck`/live dispatch refuse honestly without the optional tunnel-manager dependency, and `host_loss_reconcile` always refuses today — read the fail-closed section before assuming either works. Use when placing or staging work on a non-local host. Do NOT use for a purely local build (repository-manager-build-coordination) or for the lane/worktree lifecycle itself (repository-manager-lane-lifecycle).
repository-manager-worker-operations/_manifestFile listing for repository-manager-worker-operations
repository-manager-concept-coordination/SKILL.mdReserve, inspect, release, and materialize a CONCEPT:ID claim, and verify a candidate's or generation's introduced concept markers against those claims, via the repository-manager `rm_concepts_*` MCP tool / `--concepts` CLI family. Routes agents away from hand-writing a `CONCEPT:` marker without first reserving its id, which is exactly how two concurrent lanes collide on the same identifier. Use before writing any new `CONCEPT:` marker, or to verify a candidate/generation's markers before it lands. ⚠ On `main` as of this lane, every mutating action refuses honestly with `ConceptAuthorityUnavailable` — read the fail-closed section before assuming this tool allocates anything. Do NOT use for the lane/worktree lifecycle itself (repository-manager-lane-lifecycle) or for landing a branch (repository-manager-merge-and-reconcile).
repository-manager-concept-coordination/_manifestFile listing for repository-manager-concept-coordination
repository-manager-worktree-orchestration/SKILL.mdConcurrent multi-session git worktree orchestration via the repository-manager MCP server — create, list, sync, merge, prune, and audit linked worktrees under a shared workspace. Use when the agent must open an isolated branch worktree for a session, list/audit which worktrees are merged / active / stale / dangling, sync a worktree against its base, merge finished work back, or safely prune merged worktrees. Do NOT use for bulk clone/pull/push across repos (repository-manager-bulk-git-operations) or per-project validation/version bumps (repository-manager-workspace-validation).
repository-manager-worktree-orchestration/_manifestFile listing for repository-manager-worktree-orchestration
repository-manager-operations/SKILL.mdOperate repository-manager through its governed MCP and Arbora capabilities, including its development-lifecycle, lane, worktree, merge-queue, build, workspace validation/release, concept-coordination, and remote-worker-operations workflows (see references/catalog.md for the full, current list). Use when a request requires this provider's read, change, automation, ingestion, troubleshooting, or evidence workflows.
repository-manager-operations/_manifestFile listing for repository-manager-operations

TDQS

C2.1/5.0

Scored across 120 tools

Disambiguation1/5

There is massive overlap across families: repository_manager_add_project vs rm_git_add, pull_project vs rm_git_pull, commit_project vs rm_git_commit, and many rm_gates_* tools share nearly identical descriptions. Several families (rm_lane, rm_merge_queue, rm_build, rm_worktree, rm_concepts, rm_remote_workers) repeat the same description for every action, so an agent cannot reliably infer which tool to use.

Naming Consistency2/5

Names are snake_case throughout, but the surface mixes long repository_manager_* prefixes with shorter rm_* families, and some tools use vague or internal action suffixes such as rm_gates_phase_direction_here and rm_gates_explain/profile. The repeated family prefixes help somewhat, but the inconsistent dual naming scheme and duplicated action vocabulary make it feel ad hoc.

Tool Count1/5

At 120 tools, the server is far beyond a reasonable tool surface for repository management. Many tools are near-duplicates, internal workflow phases, or thin wrappers around the same Git operations, so the count is an extreme mismatch rather than a well-scoped set.

Completeness3/5

The surface broadly covers cloning, pulling, pushing, committing, building, testing, validation, worktrees, merge queues, and workspace setup, so core repository workflows are present. However, there are notable gaps and placeholder-like areas such as empty rm_rollout descriptions, no clear project deletion/removal path, and no obvious branch creation/checkout/diff/log lifecycle outside a generic git action.

Maintenance

ActivityActive
ResponsivenessLimited data