Skip to content
Skills Library
AI & agents · Automation

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

Repository
pipecrew ↗
Licence
Apache-2.0
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
1
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • 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

  1. Usage
  2. Instructions
  3. Notes
Original SKILL.md headings · 180 lines, 1,716 words
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

RepositoryScoreLicence
This page · pipecrew-ai/pipecrew100Apache-2.0
eliyce/paqad-ai96MIT
weber-geoml/choir86Apache-2.0
vacuityv/agenttown84MIT

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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.