join
/join
Onboard a teammate onto an EXISTING pipecrew workspace from its shared GitHub memory repo — no /discover, no re-analysis. Run it from the directory the project should live in: it clones the private memory repo there (context/platform.md, agents/, history/, config.portable.json), then rebuilds the machine-specific config.json locally: for each repo it either clones from the repo's repo_url as a direct sibling of the memory clone or points at a copy the teammate already has. The inverse of what the workspace owner published via memory-sync. Use when a colleague has set up a workspace with GitHub
- Author
- pipecrew-ai ↗
- Repository
- pipecrew ↗
- Licence
- Apache-2.0
- Last repository change
- 25.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 1
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
What it does and when to use it
Onboard a teammate onto an EXISTING pipecrew workspace from its shared GitHub memory repo — no /discover, no re-analysis. Run it from the directory the project should live in: it clones the private memory repo there (context/platform.md, agents/, history/, config.portable.json), then rebuilds the machine-specific config.json locally: for each repo it either clones from the repo's repo_url as a direct sibling of the memory clone or points at a copy the teammate already has. The inverse of what the workspace owner published via memory-sync. Use when a colleague has set up a workspace with GitHub
Original author description
Onboard a teammate onto an EXISTING pipecrew workspace from its shared GitHub memory repo — no /discover, no re-analysis. Run it from the directory the project should live in: it clones the private memory repo there (context/platform.md, agents/, history/, config.portable.json), then rebuilds the machine-specific config.json locally: for each repo it either clones from the repo's repo_url as a direct sibling of the memory clone or points at a copy the teammate already has. The inverse of what the workspace owner published via memory-sync. Use when a colleague has set up a workspace with GitHub
How it works
- Usage
- Instructions
- Notes
SKILL.md preview
---
name: join
description: "Onboard a teammate onto an EXISTING pipecrew workspace from its shared GitHub memory repo — no /discover, no re-analysis. Run it from the directory the project should live in: it clones the private memory repo there (context/platform.md, agents/, history/, config.portable.json), then rebuilds the machine-specific config.json locally: for each repo it either clones from the repo's repo_url as a direct sibling of the memory clone or points at a copy the teammate already has. The inverse of what the workspace owner published via memory-sync. Use when a colleague has set up a workspace with GitHub-backed memory and you want to run /deliver, /review, etc. against the same shared platform context."
---
## Usage
```
/pipecrew:join <memory-repo-url> [--workspace=<slug>] [--repos-root=<dir>] [--mode=clone|local]
```
`<memory-repo-url>` is the **private** memory repo the workspace owner created
(default name `{slug}-memory`, e.g. `git@github.com:acme/acme-saas-memory.git`).
It is the same URL that shows up as `config.workspace.memory.remote` on their machine.
This skill is the teammate counterpart to `/pipecrew:memory-sync`: memory-sync
*operates on* memory you already have (status / pull / sync / enable); `join`
*gets you the memory in the first place* and wires up a working local workspace.
---
## Instructions
### CRITICAL RULES
- **The memory remote MUST be private.** After cloning, verify visibility (`gh repo view <url> --json visibility`). If it is public, STOP and warn the user — a public memory repo is a privacy defect on the owner's side; do not continue wiring it up as if trusted.
- **Never clone code repos without confirmation.** Cloning is a network fetch. List every repo + its `repo_url` and get a single explicit yes before cloning (Step 4). A repo with no `repo_url` is resolved by asking the user — either a clone URL they paste, or a path to a local copy. Never guess, fabricate, or infer a URL; never silently skip a missing repo.
- **Do not run redaction or push anything.** `join` is read-mostly on the memory side: it clones and reads. It writes only local, gitignored files (`config.json`, `config.local.json`). It never commits to or pushes the memory repo — the owner's syncs and the teammate's later runs do that.
- **This is not `/discover`.** Never re-analyze the code or regenerate `platform.md`/agents — the shared memory is authoritative. If the teammate wants a fresh analysis, that's `/discover`, not `join`.
### Step 1: Resolve the project directory + slug
1. **`{workspace_root}`**: the directory the user ran `/join` from (the session's
working directory) — that directory IS the project directory, and everything this
skill creates lands under it: the memory clone at `{workspace_root}/{slug}`,
cloned repos as its direct siblings, and the root routing context at
`{workspace_root}` itself. `$PIPECREW_WORKSPACE_ROOT`, if set, overrides. Echo the resolved directory to the user before creating
anything — if they ran `/join` somewhere unintended, they should say so now, not
after three clones. If `--mode=local` was passed (the repos already exist on this
machine), add one line to that echo: the best place to run `/join` from is the
directory that contains those repos, so the workspace lands beside them — and if
the cwd isn't it, ask before cloning. (Without the flag the mode isn't known yet;
Step 4 offers to relocate instead.)
2. **`{slug}`**: from `--workspace=<slug>` if given; else derive from the remote URL's repo name with any trailing `-memory` stripped (e.g. `acme-saas-memory.git` → `acme-saas`). Confirm the derived slug with the user before creating anything.
3. If `{workspace_root}/{slug}/` already exists:
- If it's already this memory repo (same `origin`) → skip Step 2, go to Step 3 (re-join / repair).
- If it exists but is something else → STOP and ask; do not clobber.
### Step 2: Clone the memory repo
```bash
git clone <memory-repo-url> {workspace_root}/{slug}
```
Then enforce privacy (CRITICAL RULE 1). On success you now have `context/`, `agents/`,
`history/`, and `config.portable.json` locally. You do **not** have the code repos or a
`config.json` yet — that's the rest of this skill.
### Step 3: Read the repo roster
Read `{workspace_root}/{slug}/config.portable.json`. Each `repos.{key}` entry carries:
- `dir` — the owner's subpath (informational; not used to place the teammate's clones),
- `repo_url` — the clone URL if the owner captured one (**absent ⇒ point-to-local only**),
- `type` / `role` / `description`.
Present the roster to the user: which repos have a `repo_url` (cloneable) and which don't.
### Step 4: Resolve each repo
**Goal: every repo in the roster ends up with a local path on this machine.** A repo
that isn't present yet is **cloned**, not skipped — skipping is a deliberate choice the
user makes, never the default for a repo that merely hasn't been fetched. Resolve each
repo **independently**; the old global "clone vs local" question is now just a default for
the per-repo decision (and `--mode` still forces one for a non-interactive run).
First decide the **clone root** (where fresh clones land): `{workspace_root}` itself by
default, so each clone is a **direct sibling** of the memory clone (`{workspace_root}/{key}`),
never inside it (the memory repo is itself a git repo) — the same repos-plus-workspace
layout the owner has. Override with `--repos-root=<dir>`; confirm it with the user.
Then classify each repo:
1. **Already on disk** → point at it. A copy exists at `{clone_root}/{key}`, at a
`--map=key=path` the user gave, or (local mode) under the teammate's `repos_root`.
No network fetch. (If a destination path exists but is *not* this repo, STOP and
ask — `--map` it elsewhere or `--skip`; never clone over it.)
2. **Missing but has `repo_url`** → **clone it** (this is the case backfill + the owner's
last `/memory-sync sync` exists to enable):
```bash
git clone <repo_url> {clone_root}/{key}
```
3. **Missing and no `repo_url`** → **ask the user for a clone URL to paste.** If they give
one, clone it (into `{clone_root}/{key}`). If they'd rather point at a copy they already
have, take a path and `--map` it. **Only if they decline both** do you `--skip` it —
and say so explicitly in the Step 6 summary, naming the services that drops (Step 5's
rehydrate prints them). Never fabricate a URL.
**Confirm once, then act.** Present the full resolved plan — already-local repos, repos to
clone (URL → destination), and any repo still needing a URL from the user — and get a
single explicit yes before the first `git clone`. If a workspace's portable config has no
`repo_url` anywhere (an older workspace, every repo falling to case 3), tell the user the
one-command owner-side fix: the workspace owner runs `/pipecrew:memory-sync sync`, which
backfills `repo_url` from their local git remotes into the shared memory — after that a
re-join clones automatically.
**Keep the workspace with the code** (mainly local mode): if the resolved `repos_root`
differs from `{workspace_root}`, offer to move the memory clone there —
`{workspace_root}/{slug}` → `{repos_root}/{slug}` (a plain directory move; nothing
references the path yet — `config.json`, registration, and the root routing context all
happen in Steps 5–6). On yes, move it and set `{workspace_root} = {repos_root}` for the
remaining steps. On no, continue as-is — cwd inference resolves the workspace from both
locations either way.
You end up with, per repo, one of: an absolute local path (pointed-at or freshly cloned),
or a deliberate skip. Build a `--map=key=path,...` for explicit paths and a
`--skip=key,...` for any the user opted out of. Use a single `--repos-root` when every
remaining path is just `{root}/{key}`.
### Step 5: Rebuild config.json
```bash
node {plugin_dir}/scripts/rehydrate-config.js \
--portable={workspace_root}/{slug}/config.portable.json \
--out={workspace_root}/{slug}/config.json \
[--repos-root={clone_root or teammate repos_root}] \
[--map=key=abs,...] [--skip=key,...]
```
This strips the portable markers (`_portable`, `repos_root`, per-repo `dir`), sets each
repo's local `path`, keeps `repo_url`, and preserves the `workspace.memory` block so
auto-sync stays on. It refuses (exit 2) if any repo has neither a mapped path nor a
`--repos-root` — resolve or `--skip` those and re-run.
Then record the teammate's root so future `config.portable.json` regens stay stable:
```bash
# {workspace_root}/{slug}/config.local.json (gitignored)
{ "repos_root": "{clone_root or teammate repos_root}" }
```
### Step 6: Validate + report
```bash
node {plugin_dir}/scripts/validate-config.js {workspace_root}/{slug}/config.json
node {plugin_dir}/scripts/workspace-registry.js --register={workspace_root}/{slug} --default
node {plugin_dir}/scripts/sync-memory.js status {workspace_root}/{slug}
node {plugin_dir}/scripts/sync-root-claude.js --config={workspace_root}/{slug}/config.json
```
- The validator confirms every resolved `path` exists on disk (so it catches a clone that
didn't land or a wrong local path) — fix and re-run Step 5 on any error.
- `--register … --default` adds the joined workspace to the teammate's registry and makes it
the default, so subsequent `/deliver`, `/memory-sync`, etc. resolve it by slug from anywhere
(sessions working inside another workspace's repos still resolve that one via cwd inference).
- `status` confirms the memory repo is wired and reports how fresh it is.
- `sync-root-claude` places (or updates) the PipeCrew routing context at the parent
directory(ies) of the repos just wired up (for clone mode that's the project
directory `/join` ran from; for local mode the teammate's own repos root) — the
guide that tells any agent session
launched in or below those repos that the PipeCrew skills/agents exist and when to
use them, with this workspace's context paths and agent names. Content lands in
`AGENTS.md` (read natively by Cursor and other agents) with a one-line `CLAUDE.md`
shim (`@AGENTS.md`) beside it for Claude Code — same convention as per-repo docs.
It ships with the teammate's own plugin (so it always matches their version), only
ever rewrites this workspace's block between the `<!-- pipecrew:workspaces -->`
markers, migrates a pre-parity plugin-owned CLAUDE.md lazily, and never touches a
hand-authored file's content. On exit 1 (malformed markers), surface the error —
don't hand-edit the user's file. Opt-out: `"root_context": false` under `workspace`
in config.json makes the script a no-op (the flag arrives via config.portable.json
if the owner set it); `--remove` uninstalls an existing footprint.
- **Optional user-level breadcrumb**: after the above, offer (strictly opt-in — it edits
the teammate's personal `~/.claude/CLAUDE.md`) to run
`node {plugin_dir}/scripts/sync-root-claude.js --user`, which maintains a tiny
marker-managed block listing this machine's registered workspaces so every session
knows they exist. Same consent prompt as /discover Phase C Step 5. On `no`, skip
silently.
Report one concise summary: workspace joined, N repos wired (cloned / local / skipped),
memory sync mode, and the next step — e.g. `Run /deliver --workspace={slug}`. Note that
future runs pull the team's latest memory at pre-flight and sync back automatically.
---
## Notes
- **Relationship to `/discover`:** `discover` builds a workspace by *analyzing code*; `join` reconstructs one by *reading shared memory*. A teammate who joins never pays for re-analysis and gets exactly the owner's curated `platform.md`, agents, and history.
- **Relationship to `/memory-sync`:** after `join`, the daily surface is `/pipecrew:memory-sync status | pull | sync`. `join` is a one-time (or repair) action.
- **Skipped repos:** if a teammate only works part of the platform, `--skip` leaves those repos out of their local `config.json` (and drops any service that referenced them, so the config still validates). They can re-run `join` later to add them.
- **No `repo_url` anywhere?** Older workspaces onboarded before `repo_url` capture won't have clone URLs — that's fine, `join` runs fully in point-to-local mode. The owner can re-run `/discover` (or add `repo_url` by hand) to enable cloning for the next teammate.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · pipecrew-ai/pipecrew | 100 | Apache-2.0 |
| eliyce/paqad-ai | 96 | MIT |
| weber-geoml/choir | 86 | Apache-2.0 |
| vacuityv/agenttown | 84 | MIT |
Database snapshot: 13.11.2026 · package version 7cb2f9ed1d71 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100siteview-fleet
Launch the machine-wide PipeCrew fleet dashboard — a live view of EVERY Claude Code session on this machine (not just the current /deliver run), each card showing token usage, sub-agents, and a "needs approval" badge. PipeCrew /deliver sessions render with the same pharaoh crew… - 90Nerve Workspace Config
Change your own configuration — skills, cron jobs, sources, and settings that live in the workspace. Covers both routes: a pull request when the workspace is a shared config repo (and the only route when this instance is locked), or a direct edit when the workspace is purely… - 100memory-promote
Audit this repo's auto-memory files and suggest promoting each one to a more persistent layer — user or repo CLAUDE.md, an existing or new skill, a settings.json hook, or a checked-in reference doc. Use when the user says "audit memory", "promote memory", "clean up memories",… - 100siteview-list
List every PipeCrew site-view server currently running on localhost. Probes ports 5173-5195 via the /state endpoint and reports port, PID, workspace, run-id, character count, and whether any server is awaiting user input. Use when you've started multiple runs and need to see… - 100build-memory
Use this skill when the user wants to build, refresh, or teach their Aicoo agent memory from their real context — files, repo, git history, docs, or Claude/agent memory. Triggers on: 'build my memory', 'build my agent memory', 'teach my agent about me', 'what should my agent… - 90bm-share
Promote a note from your personal Basic Memory project to a shared team project, with attribution. Use when the user says "share this with the team", "publish this decision", or runs /basic-memory:bm-share. This is the deliberate way to write to a team workspace — auto-capture never does.