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

Stage all changes for multiple projects in parallel.

Build projects serially so compilation cannot exhaust the workstation.

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

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.

Removes test artifacts and temporary files from the specified directory.

Clone all specified Git projects in parallel using multiple threads.

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

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.

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.

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.

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

Commit staged changes for multiple projects in parallel.

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.

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

Generates a beautiful markdown summary of bulk operation results.

Generates a workspace.yml template at the specified path.

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

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

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.

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

Execute a Git command in the specified directory.

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

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

Bulk installs Python and Node projects in the workspace.

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

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

Execute the phased bumpversion workflow: pre-commits + phased bumping.

auto_start (the default) begins the run at the lowest phase that actually contains a repo with pending work (advancing start_phase forward, never backward) so unchanged upstream phases are skipped. A change in phase N still cascades to every phase >= N. It stands down — running from the explicit start_phase — when project_filter or force is set, since those are explicit-targeting requests that deliberately bypass change detection. Pass auto_start=False to opt out and always start at start_phase.

Concept: CONCEPT:RM-BUMP

Execute the phased bumpversion workflow: pre-commits + phased bumping.

auto_start (the default) begins the run at the lowest phase that actually contains a repo with pending work (advancing start_phase forward, never backward) so unchanged upstream phases are skipped. A change in phase N still cascades to every phase >= N. It stands down — running from the explicit start_phase — when project_filter or force is set, since those are explicit-targeting requests that deliberately bypass change detection. Pass auto_start=False to opt out and always start at start_phase.

Concept: CONCEPT:RM-BUMP

Execute the phased git push workflow.

auto_start (the default) begins the push at the lowest phase that has a repo with unpushed work (advancing start_phase forward, never backward), skipping the inter-phase waits of unchanged upstream phases. It stands down — pushing from the explicit start_phase — when project_filter is set, since that is an explicit-targeting request. Pass auto_start=False to opt out and always start at start_phase.

Concept: CONCEPT:RM-PUSH

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.

Execute pre-commit commands for all projects in parallel.

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

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.

Pull updates for multiple projects in parallel.

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.

Push updates for multiple projects in parallel.

Saves the current or provided WorkspaceConfig to a YAML file.

Set the number of threads for parallel processing.

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

Notes: If the input is invalid, defaults 6

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 agent-connector-sdk and every cloned project that declares a path dependency on it, dependency-ordered (agent-connector-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.

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.

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

Validate projects in parallel, optionally triggering a release if successful.

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.

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)

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

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

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

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

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

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

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

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

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

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

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

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

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:AU-KG.ingest.enterprise-source-extractor.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 phased 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. agent-connector-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 the phased-push scheduler. 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.

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 phased 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. agent-connector-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 the phased-push scheduler. 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.

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 phased 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. agent-connector-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 the phased-push scheduler. 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.

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 phased 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. agent-connector-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 the phased-push scheduler. 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.

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 phased 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. agent-connector-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 the phased-push scheduler. 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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

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>.

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>.

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>.

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>.

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>.

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>.

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>.

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>.

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>.

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>.

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>.

List (rm_workspace). Core workspace organization, configuration, and maintenance.

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

Setup (rm_workspace). Core workspace organization, configuration, and maintenance.

Template (rm_workspace). Core workspace organization, configuration, and maintenance.

Save (rm_workspace). Core workspace organization, configuration, and maintenance.

Maintain (rm_workspace). Core workspace organization, configuration, and maintenance.

Maintain status (rm_workspace). Core workspace organization, configuration, and maintenance.

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

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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 (agent_connector_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.

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.

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.

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.

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.

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.

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.

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.

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.

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.