memory-team git:20261017.b8b790aA

Immutable. This exact content never changes and is served at /api/v1/blob/8d2c7b4c9b105c1f.

---
name: memory-team
description: |
  Guided setup for sharing moflo's durable learnings through a git-tracked artifact — for a whole
  TEAM on one repo, OR for one person across several MACHINES (a team of one). Use when the user says
  "share learnings with my team", "commit our moflo memory", "sync memory across my laptop and desktop",
  "set up memory.team_artifact", "auto-export learnings on every PR", or "learnings.jsonl keeps conflicting".
  Installs a pre-commit hook so the artifact rides along in every commit. An existing learnings.jsonl moves
  to the conflict-free layout automatically. For many worktrees on ONE machine, use /memory-worktree.
arguments: "[--solo]"
---

# /memory-team — Share Learnings via a Git-Tracked Artifact

Wires up **`memory.team_artifact`**: a diffable directory (`.moflo/shared/learnings/`, one JSON file per
entry) that lives **in the repo**, reviewed like any other change. One file per entry means two PRs that each
add a learning never conflict — on GitHub or locally. Teammates `git pull` it and their next session
auto-imports the merged learnings; each entry is stamped with its git author. This skill also installs a
**pre-commit hook** so the artifact is re-exported and staged on every commit — the learnings ride along
in each PR with zero effort.

> **One mechanism, two audiences.** A *team* and *one person across machines* are the same problem — push
> the durable slice through git. This skill covers both; the only difference is whether anyone else is on
> the other end. (Prefer a private, non-git file for your own machines? See "Advanced" at the bottom —
> `flo memory sync` moves a binary artifact that keeps embeddings verbatim.)

**Arguments:** `$ARGUMENTS` — pass `--solo` to skip team-oriented wording (still identical setup).

## When to use

- "share learnings / memory with my team"
- "commit our moflo knowledge to the repo"
- "sync memory between my laptop and desktop"
- "auto-export the learnings on every PR / commit"
- "set up `team_artifact`"
- "`learnings.jsonl` conflicts on every PR" → Step 2b (it migrates itself)

For **many worktrees on one machine**, that's a shared local store, not git — use `/memory-worktree`.

## Procedure

### Step 0 — Memory first (gate requirement)

```
mcp__moflo__memory_search { query: "team_artifact learnings jsonl git share import session-start", namespace: "guidance" }
```

### Step 1 — Confirm this is the git path

- Team on one repo, or one person across machines who both push to the same repo? → correct skill.
- Many worktrees on **one** machine, no cross-machine need? → redirect to `/memory-worktree`.
- A private synced file (Dropbox/USB), no git? → point at the Advanced section (`flo memory sync`).

### Step 2 — Set the config

Read the project-root `moflo.yaml` and add/merge under `memory:` — **preserve existing keys**:

```yaml
memory:
  team_artifact: .moflo/shared/learnings/
```

An existing `team_artifact: .moflo/shared/learnings.jsonl` line is fine as it is — a `.jsonl` path names
the directory beside it, so there is nothing to change.

### Step 2b — Existing `learnings.jsonl` setups migrate themselves

**Do nothing.** The old single file conflicted whenever two branches added neighbouring keys, and GitHub
ignores merge drivers, so `merge=union` never helped on the PR page. The next `team-export` — normally the
pre-commit hook — moves it:

| Moment | What happens |
|--------|--------------|
| Session start before the first export | The old file is still imported, so nothing is lost |
| Next `team-export` | Every entry is copied into `.moflo/shared/learnings/`, the `.jsonl` is deleted, and both changes are staged |
| A teammate's older moflo re-creates the `.jsonl` | The next export folds it in and deletes it again |

Existing hooks keep working: when the artifact is git-tracked, `team-export` stages it itself. Refresh an
old hook block to the one in Step 4 anyway, so it names the directory.

### Step 3 — First export (creates + tracks the artifact)

```bash
npx flo memory team-export 2>&1
```

This writes the artifact, pins it to LF in `.gitattributes`, and **rewrites `.gitignore`** from a blanket `.moflo/` to `.moflo/*` +
`!/.moflo/shared/` so the shared artifact is tracked while the machine-local DB stays ignored. Surface
what it reports (entries added, `.gitignore` change). If there are no durable learnings yet, that's fine —
the artifact is created empty and fills in as learnings accrue.

### Step 4 — Install the pre-commit hook

The hook re-exports and stages the artifact on every commit, so it's never stale in a PR. Handle three
cases; **do not clobber** an existing hook.

Define the managed block (POSIX `sh` — git runs hooks via `sh` on Linux, macOS, **and** Windows):

```sh
# >>> moflo team-export (managed by /memory-team) >>>
# Refresh the shared learnings artifact so it rides along in this commit.
npx --no-install flo memory team-export >/dev/null 2>&1 || true
if [ -n "$(git status --porcelain -- .moflo/shared/learnings 2>/dev/null)" ]; then
  git add -A -- .moflo/shared/learnings
fi
# <<< moflo team-export (managed by /memory-team) <<<
```

Install it:

1. **Husky present** (`.husky/pre-commit` exists) → append the block to that file.
2. **Existing `.git/hooks/pre-commit`** → if it already contains the `moflo team-export` markers, replace
   the block between them with the one above (an older block names `learnings.jsonl`); otherwise append the
   block after the shebang.
3. **No hook** → create `.git/hooks/pre-commit` with `#!/bin/sh` as the first line, then the block.

On POSIX, make it executable:

```bash
node -e "require('fs').chmodSync('.git/hooks/pre-commit', 0o755)"
```

(Use the Node `fs.chmodSync` primitive, not `chmod` — it's a harmless no-op on Windows. Never shell out
to `chmod` in a cross-platform step.)

- The `|| true` keeps a failed export from ever blocking a commit.
- The `git status --porcelain` guard means the artifact is only re-staged when it actually changed — no
  empty-diff churn on unrelated commits. `-A` also stages entry files export removed (expired tombstones).
- Using a custom `team_artifact` path? Substitute it for `.moflo/shared/learnings` in both lines.

### Step 5 — Commit and share

```bash
git add .moflo/shared/learnings/ .gitignore .gitattributes
git commit -m "chore: share moflo learnings"
git push
```

Teammates (or your other machine) run `git pull`; their **next session auto-imports** the merged artifact —
no manual import command. To pull learnings without waiting for a restart:

```bash
npx flo memory team-import 2>&1
```

## Output

End with a single-block summary:

```
Team Memory Sharing — configured
─────────────────────────────────
Artifact:    .moflo/shared/learnings/  (git-tracked, one file per entry, author-stamped)
Config key:  memory.team_artifact
PR hook:     .git/hooks/pre-commit  → re-exports + stages on every commit
Import:      automatic at session start (after git pull)  |  npx flo memory team-import
Scope:       learnings + knowledge only (embeddings regenerated on import)
```

## Advanced — one person, a private file (no git)

If you're solo and would rather not commit learnings, carry a binary artifact instead. It keeps the
embeddings verbatim (no recompute on the far side) and merges idempotently:

```bash
npx flo memory sync --to   ~/Dropbox/moflo-learnings.db   # machine A
npx flo memory sync --from ~/Dropbox/moflo-learnings.db   # machine B
```

Same durable slice, no repo footprint, no review — the trade-off is it's not diffable and not shared.

## Rules

- **Don't** reimplement export/import/migration or the `.gitignore` rewrite — `flo memory team-export`
  and `team-import` own all of it. This skill sets config, runs them, and installs the hook.
- **Don't** add a `merge=union` attribute for the artifact — GitHub ignores it, and the directory layout
  does not need it.
- **Don't** overwrite an existing pre-commit hook or husky config — append the marked block only.
- **Don't** use `chmod` / `mkdir` / `rm` in shell steps — Windows lacks them on PATH; use Node `fs`.
- Embeddings are intentionally **omitted** from the artifact (384 floats/entry would wreck diffs) — they're
  regenerated on import. Don't try to add them.

## See Also

- `/memory-worktree` — same-machine sharing across worktrees / Conductor (a shared local store, not git)
- `flo memory team-export --help` / `flo memory sync --help`
- `docs/blog/memory-sharing.html` — the design rationale (durable slice, why not share the whole DB)