memory-team

name	memory-team
description	Guided setup for sharing moflo's durable learnings through a git-tracked JSONL 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", or "auto-export learnings on every PR". Installs a pre-commit hook so the artifact rides along in every commit. For many worktrees on ONE machine, use /memory-worktree instead.
arguments	[--solo]

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

Wires up memory.team_artifact: a diffable JSONL file (.moflo/shared/learnings.jsonl) that lives in the repo, reviewed like any other change. 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"

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:

memory:
  team_artifact: .moflo/shared/learnings.jsonl

.moflo/shared/learnings.jsonl is the default; only override if the user wants a different tracked path.

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

npx flo memory team-export 2>&1

This writes the JSONL, 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):

# >>> 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.jsonl 2>/dev/null)" ]; then
  git add .moflo/shared/learnings.jsonl
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, leave it (idempotent); 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:

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.

Step 5 — Commit and share

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

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

npx flo memory team-import 2>&1

Output

End with a single-block summary:

Team Memory Sharing — configured
─────────────────────────────────
Artifact:    .moflo/shared/learnings.jsonl  (git-tracked, JSONL, 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:

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 or the .gitignore rewrite — flo memory team-export/team-import own all of it (team-artifact-sync.ts). This skill sets config, runs them, and installs the hook.
• 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 JSONL (384 floats/row 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)