agentmash 0.3.0 → 0.4.0

package/README.md

@@ -39,9 +39,15 @@ Node 18 or newer. The CLI has no dependencies and needs no checkout of this proj
 | `npx agentmash doctor` | Check exactly what is and isn't working |
 | `npx agentmash status` | Who is working on what, from the terminal |
 | `npx agentmash uninstall` | Remove the hooks from this repo |
+| `npx agentmash team add <name> --agents <a,b\|all>` | Put agents from the crew in this repo as a named team |
+| `npx agentmash team remove <name> [--agents <a,b>]` | Remove a team, or only the agents given |
+| `npx agentmash team list [--json]` | The teams installed in this repo |
+| `npx agentmash team update` | Rewrite the team files from the crew version this CLI carries |
 
 Flags: `--server <url>` (coordination server), `--repo <path>`, `--label <text>`,
-and `--force` with `init` to replace an existing room.
+and `--force` with `init` to replace an existing room. With `team`: `--agents`, `--slug <slug>`,
+`--dry-run` to see what would change without writing, and `--force` to overwrite files that were
+changed locally or not written by the crew.
 
 Reach for `doctor` when someone's events aren't showing up. The hooks fail silently by
 design, so it is the only thing that will tell you why: it resolves the config and shows
@@ -49,6 +55,28 @@ where each value came from, checks the hooks are registered, measures the round
 compares it against what a cold hook needs, validates the room, and lists the teammates it
 can see.
 
+## Crew teams
+
+The [agentmash crew](https://github.com/IskakovDamir/agentmash-crew) is 18 Claude Code agents
+with Mash, the conductor, in every team. `team add` puts the ones you pick into this repo under a
+name:
+
+```bash
+npx agentmash team add "agentmash crew" --agents pipe,flex,probe
+```
+
+That writes the agents to `.claude/agents/`, the crew's skills and one skill for the team to
+`.claude/skills/`, a guard hook to `.claude/agentmash-crew/` (registered in `.claude/settings.json`
+beside anything already there), and a record of it all to `.claude/agentmash-crew/teams.json`. It
+prints the `git add` for exactly those files. Commit them, start a new Claude Code session at the
+repo root, and say `agentmash crew, <task>`.
+
+Teams have nothing to do with the room. `team` never calls the coordination server, needs no
+`init`, and `uninstall` leaves teams where they are. A file the crew did not write is never
+overwritten without `--force`, and a refusal writes nothing at all. The files are the same bytes
+the crew's own installer and the one-click pull request on agentmash.dev write: all three run the
+crew's planner, which this package carries at the version pinned in `crew/crew.lock.json`.
+
 ## Running your own server
 
 `init` points at a shared server by default. To coordinate on your own infrastructure,

package/agentmash.mjs

@@ -9,6 +9,7 @@
 //   npx agentmash status    who is working on what, right now
 //   npx agentmash git-hook  install or remove the post-commit client
 //   npx agentmash uninstall remove the hooks from this repo
+//   npx agentmash team      install agents from the agentmash crew as a named team
 //   npx agentmash mcp       serve the MCP tools on stdio (what .mcp.json runs)
 
 import fs from 'node:fs';
@@ -1161,6 +1162,8 @@ async function cmdDoctor(args) {
     info(`install it with ${c.bold('agentmash git-hook install')} (local to this checkout)`);
   }
 
+  await doctorCrew(repo);
+
   const me = identity(repo);
   ok(`you are ${c.cyan(me.who)}  ${c.dim(`(${me.from})`)}`);
 
@@ -1340,6 +1343,11 @@ function cmdUninstall(args) {
   console.log(`\n${c.bold('AgentMash removed')} from ${repo}\n`);
   if (git.ok) info(git.message);
   else warn(git.message);
+  // Crew teams need no room and are not part of what init installed, so they
+  // stay. Said out loud, or "removed" reads as "everything agentmash wrote".
+  if (pathKind(path.join(repo, CREW_MANIFEST)) !== 'missing') {
+    info(`crew teams stay installed — remove them with ${c.bold('npx agentmash team remove <name>')}`);
+  }
   info('your teammates still have it until they pull this change\n');
 }
 
@@ -1677,6 +1685,295 @@ async function cmdDelete(args) {
   info('the hooks are still installed and now do nothing — run: agentmash init, or uninstall\n');
 }
 
+// ── crew teams ─────────────────────────────────────────────────────────────
+// `agentmash team` puts agents from the agentmash crew into the repo as a named
+// team: agent files in .claude/agents, the shared skills, one skill per team,
+// a guard hook, and a record of all of it in .claude/agentmash-crew/teams.json.
+// It is not part of the room. It never calls the coordination server, needs no
+// room, and works while the server is closed or unreachable.
+//
+// None of the planning happens here. The crew's own installer is vendored at
+// crew/ by tools/sync-crew.mjs and imported as it is, so a team installed with
+// this command is byte for byte the team the crew's installer and the
+// agentmash.dev pull request write: all three run the same planChange.
+
+const CREW_FILES = ['bundle.json', 'install.mjs', 'team-plan.mjs', 'crew.lock.json'];
+
+// The bundle's meta.manifestPath. Kept as a constant so uninstall can look for
+// it without loading a 300 KB bundle; the uninstall test installs a team the
+// real way, so a bundle that moved the manifest fails that test.
+const CREW_MANIFEST = path.join('.claude', 'agentmash-crew', 'teams.json');
+
+/**
+ * The vendored crew: the repo checkout's crew/ in dev, or the copy
+ * sync-hooks.mjs packs into the published package. Checkout first, for the
+ * reason hookSourceDir gives: cli/crew/ is a copy that goes stale the moment
+ * someone syncs a new crew release.
+ */
+function crewSourceDir() {
+  for (const candidate of [path.join(HERE, '..', 'crew'), path.join(HERE, 'crew')]) {
+    if (CREW_FILES.every((f) => fs.existsSync(path.join(candidate, f)))) return candidate;
+  }
+  return null;
+}
+
+/**
+ * The crew's installer module and its verified bundle. Throws instead of
+ * dying, because doctor wants to say this as a warning. loadBundle checks the
+ * sha256 of every file the bundle installs before anything is planned.
+ */
+async function loadCrew() {
+  const dir = crewSourceDir();
+  if (!dir) throw new Error('could not locate the crew files to install (broken package?)');
+  const install = await import(pathToFileURL(path.join(dir, 'install.mjs')).href);
+  return { install, bundle: install.loadBundle(path.join(dir, 'bundle.json')) };
+}
+
+// What each action takes. The rest of the CLI ignores a flag it does not know;
+// `team` refuses one, because an ignored `--dryrun` is a dry run that writes.
+const TEAM_ACTIONS = {
+  add: { name: true, flags: ['agents', 'slug', 'repo', 'dry-run', 'force'] },
+  remove: { name: true, flags: ['agents', 'repo', 'dry-run', 'force'] },
+  list: { name: false, flags: ['repo', 'json'] },
+  update: { name: false, flags: ['repo', 'dry-run', 'force'] },
+};
+const TEAM_VALUE_FLAGS = ['agents', 'slug', 'repo'];
+// parseArgs stores booleans under camelCase keys; turn them back into what was typed.
+const FLAG_SPELLING = { dryRun: 'dry-run', noGitHook: 'no-git-hook', noOpen: 'no-open', forceHooksPath: 'force-hooks-path' };
+
+const TEAM_ROW = { created: ok, updated: ok, deleted: ok, overwritten: warn, kept: warn, left: warn };
+
+/** One line per file the plan touched (or would touch); unchanged files are only counted. */
+function printTeamPlan(plan, dryRun) {
+  const rows = plan.changes.filter((change) => change.action !== 'unchanged');
+  if (plan.settings.action !== 'unchanged') rows.push({ path: plan.settings.path, action: plan.settings.action });
+  if (plan.manifestAction !== 'unchanged') rows.push({ path: plan.manifestPath, action: plan.manifestAction });
+  const width = Math.max(0, ...rows.map((row) => row.action.length));
+  // A dry run's rows are what would happen, so none of them gets a ✓.
+  for (const row of rows) {
+    const mark = dryRun ? info : (TEAM_ROW[row.action] ?? info);
+    mark(`${row.action.padEnd(width)}  ${c.dim(row.path)}`);
+  }
+  const same = plan.changes.filter((change) => change.action === 'unchanged').length;
+  if (same > 0) info(`${same} file${same === 1 ? '' : 's'} unchanged`);
+  for (const message of plan.warnings) warn(message);
+  if (dryRun) info('dry run: nothing was written');
+  else if (!plan.changed) info('nothing to change');
+}
+
+function printTeamSteps(steps) {
+  console.log(`\n  ${c.bold('next:')}`);
+  steps.forEach((step, i) => console.log(`    ${i + 1}. ${step}`));
+  console.log('');
+}
+
+// Claude Code reads the project's .claude/settings.json, and with it the guard
+// hook, only from the directory it starts in, while agents and skills also load
+// from a subfolder. So the restart step names the repository root.
+const TEAM_RESTART =
+  'start a new Claude Code session at the repository root, so it loads the agents, skills and guard hook (the hook does not load when Claude Code starts in a subfolder)';
+
+/** Quotes a path for a POSIX shell, and for cmd and PowerShell too when the path allows plain double quotes. */
+function shellQuote(value) {
+  if (/^[\w@%+=:,./-]+$/.test(value)) return value;
+  if (!/["$`!\\]/.test(value)) return `"${value}"`;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * The commit step, as the crew's own installer prints it. It stages exactly
+ * the files the installer manages after this run (also those an earlier,
+ * uncommitted run wrote) and the ones it deleted, so other work under .claude/
+ * — including AgentMash's own hooks — and the files the plan kept or left
+ * because someone changed them stay out of the commit. Deletions go through
+ * `git rm --cached --ignore-unmatch`, because `git add` fails on a path that is
+ * neither on disk nor tracked (a team removed before it was ever committed).
+ * `git -C <root>` makes the command work from any folder.
+ */
+function teamCommitStep(plan, root, message) {
+  const managed = plan.teams.length > 0;
+  const added = [];
+  const removed = [];
+  const note = (rel, action) => {
+    if (action === 'deleted') removed.push(rel);
+    else if (['created', 'updated', 'overwritten'].includes(action) || (action === 'unchanged' && managed)) added.push(rel);
+  };
+  for (const change of plan.changes) note(change.path, change.action);
+  note(plan.settings.path, plan.settings.action);
+  note(plan.manifestPath, plan.manifestAction);
+
+  const git = path.resolve(process.cwd()) === root ? 'git' : `git -C ${shellQuote(root)}`;
+  const steps = [];
+  if (added.length > 0) steps.push(`${git} add -- ${added.sort().join(' ')}`);
+  if (removed.length > 0) steps.push(`${git} rm -q --cached --ignore-unmatch -- ${removed.sort().join(' ')}`);
+  steps.push(`${git} commit -m "${message}"`);
+  return steps.join(' && ');
+}
+
+const splitAgents = (value) => value.split(/[\s,]+/).filter(Boolean);
+
+async function cmdTeam(args) {
+  const action = args._[0];
+  const spec = Object.hasOwn(TEAM_ACTIONS, action ?? '') ? TEAM_ACTIONS[action] : null;
+  if (!spec) {
+    die(
+      `${action ? `unknown team command "${action}" — ` : ''}usage: agentmash team <add|remove|list|update>\n` +
+        `        e.g. npx agentmash team add "agentmash crew" --agents pipe,flex,probe`
+    );
+  }
+  for (const key of Object.keys(args)) {
+    if (key === '_') continue;
+    const flag = FLAG_SPELLING[key] ?? key;
+    if (!spec.flags.includes(flag)) die(`--${flag} does not apply to team ${action}`);
+  }
+  for (const flag of TEAM_VALUE_FLAGS) {
+    const value = args[flag];
+    if (Object.hasOwn(args, flag) && (typeof value !== 'string' || value.startsWith('--') || !value.trim())) {
+      die(`--${flag} needs a value`);
+    }
+  }
+  const rest = args._.slice(1);
+  if (spec.name && rest.length === 0) die(`team ${action} needs a team name, e.g. npx agentmash team ${action} "agentmash crew"`);
+  if (rest.length > (spec.name ? 1 : 0)) {
+    die(
+      spec.name
+        ? `the team name must be one argument; quote it: npx agentmash team ${action} "${rest.join(' ')}"`
+        : `team ${action} takes no arguments (got ${rest.join(' ')})`
+    );
+  }
+  if (action === 'add' && args.agents === undefined) {
+    die('team add needs --agents, e.g. npx agentmash team add "agentmash crew" --agents pipe,flex,probe');
+  }
+
+  // Any folder inside the repo will do; the crew's installer walks up to the
+  // root itself, and refuses a home directory that happens to be a repo.
+  const start = args.repo ? path.resolve(args.repo) : process.cwd();
+  if (!findRepoRoot(start)) die("not inside a git repository — run this in your team's repo, or pass --repo <path>");
+
+  let crew;
+  try {
+    crew = await loadCrew();
+  } catch (err) {
+    die(err.message);
+  }
+  const { install, bundle } = crew;
+  const dryRun = Boolean(args.dryRun);
+  const force = Boolean(args.force);
+
+  // The installer validates everything before its first write and throws with
+  // a message meant for people: a foreign file, a bad name, an unknown agent.
+  const attempt = (fn) => {
+    try {
+      return fn();
+    } catch (err) {
+      die(err.message);
+    }
+  };
+
+  if (action === 'list') {
+    const { root, teams } = attempt(() => install.listTeams({ repo: start, bundle }));
+    if (args.json) {
+      console.log(JSON.stringify({ teams }, null, 2));
+      return;
+    }
+    if (teams.length === 0) {
+      console.log(`\n  no agentmash teams in ${c.dim(root)}\n`);
+      return;
+    }
+    console.log('');
+    for (const team of teams) {
+      console.log(`  ${c.bold(team.name)} ${c.dim(`(${team.slug})`)}: ${team.members.map((m) => m.split('-')[0]).join(', ')}`);
+    }
+    console.log('');
+    return;
+  }
+
+  let op;
+  if (action === 'add') op = { type: 'add', name: rest[0], slug: args.slug, members: splitAgents(args.agents), force };
+  else if (action === 'remove') {
+    op = { type: 'remove', team: rest[0], members: args.agents === undefined ? undefined : splitAgents(args.agents), force };
+  } else op = { type: 'update', force };
+
+  const { root, plan } = attempt(() => install.runTeamOp({ repo: start, bundle, op, dryRun }));
+  const team = plan.target;
+  if (action === 'update') {
+    const count = plan.teams.length;
+    console.log(`\n${c.bold(`${count} team${count === 1 ? '' : 's'}`)}, agentmash-crew ${bundle.meta.version}\n`);
+  } else if (team.members === null) {
+    console.log(`\n${c.bold(`removed team ${team.name}`)} ${c.dim(`(${team.slug})`)}\n`);
+  } else {
+    console.log(`\n${c.bold(`team ${team.name}`)} ${c.dim(`(${team.slug})`)}: ${team.members.join(', ')}\n`);
+  }
+  printTeamPlan(plan, dryRun);
+  if (dryRun || !plan.changed) {
+    console.log('');
+    return;
+  }
+
+  if (action === 'add') {
+    printTeamSteps([
+      teamCommitStep(plan, root, `chore: ${plan.targetIsNew ? 'add' : 'update'} agentmash team ${team.name}`),
+      TEAM_RESTART,
+      `then say: ${team.name}, <your task>   (or type: /team-${team.slug} <your task>)`,
+    ]);
+  } else if (action === 'remove') {
+    const message = team.members === null ? `chore: remove agentmash team ${team.name}` : `chore: update agentmash team ${team.name}`;
+    printTeamSteps([teamCommitStep(plan, root, message), 'restart Claude Code in this repo so it reloads the agents']);
+  } else {
+    printTeamSteps([teamCommitStep(plan, root, `chore: update agentmash teams to ${bundle.meta.version}`), TEAM_RESTART]);
+  }
+}
+
+/**
+ * The crew section of doctor: whether teams.json parses, how many teams it
+ * records, and which of the files it records no longer have the bytes it
+ * wrote. Crew teams work without a room or a server, so nothing here is an
+ * AgentMash problem: warnings at most, and doctor's verdict never changes.
+ */
+async function doctorCrew(repo) {
+  if (pathKind(path.join(repo, CREW_MANIFEST)) === 'missing') return;
+  let state;
+  let bundle;
+  try {
+    const crew = await loadCrew();
+    bundle = crew.bundle;
+    // `update` is the operation that touches every file teams.json lists, so
+    // its snapshot hashes exactly the files there are to compare.
+    state = crew.install.readState(repo, bundle, { type: 'update' });
+  } catch (err) {
+    warn(`crew teams: ${err.message}`);
+    return;
+  }
+  const { manifest } = state;
+  if (!manifest) return; // removed between the look and the read
+  const version = typeof manifest.source?.version === 'string' ? manifest.source.version : 'unknown version';
+  const names = manifest.teams.map((team) => team.name).join(', ');
+  ok(`crew teams: ${manifest.teams.length}  ${c.dim(`${names || 'none'} · agentmash-crew ${version}`)}`);
+
+  const drifted = Object.keys(manifest.files).filter((file) => state.onDisk[file] !== manifest.files[file]);
+  const missing = drifted.filter((file) => state.onDisk[file] === null);
+  const changed = drifted.filter((file) => state.onDisk[file] !== null);
+  if (missing.length > 0) {
+    warn(`${missing.length} crew file${missing.length === 1 ? ' is' : 's are'} missing: ${missing.join(', ')}`);
+    info(`${c.bold('npx agentmash team update')} puts ${missing.length === 1 ? 'it' : 'them'} back`);
+  }
+  if (changed.length > 0) {
+    warn(`${changed.length} crew file${changed.length === 1 ? '' : 's'} changed since install: ${changed.join(', ')}`);
+    info(`fine if that was on purpose; ${c.bold('npx agentmash team update --force')} puts the installed version back`);
+  }
+
+  let guarded = false;
+  try {
+    const settings = JSON.parse(state.settingsText ?? '{}');
+    guarded = JSON.stringify(settings?.hooks?.[bundle.meta.hook.event] ?? []).includes(bundle.meta.hook.marker);
+  } catch {
+    /* an unparseable settings.json has no guard in it either */
+  }
+  if (manifest.teams.length > 0 && !guarded) {
+    warn(`the crew guard hook is not in .claude/settings.json — ${c.bold('npx agentmash team update')} adds it back`);
+  }
+}
+
 function usage() {
   console.log(`
 ${c.bold('agentmash')} — let your team see each other's work on one repository
@@ -1690,6 +1987,13 @@ ${c.bold('agentmash')} — let your team see each other's work on one repository
                                  the post-commit client, for teammates
                                  who are not using Claude Code
   ${c.bold('npx agentmash uninstall')}         remove the hooks from this repo
+  ${c.bold('npx agentmash team add')} <name> --agents <a,b|all>
+                                 put agents from the crew in this repo as a
+                                 named team; Mash conducts every team
+  ${c.bold('npx agentmash team remove')} <name> [--agents <a,b>]
+                                 remove a team, or only the agents given
+  ${c.bold('npx agentmash team list')}         the teams installed here ${c.dim('(--json)')}
+  ${c.bold('npx agentmash team update')}       rewrite the team files from this version of the crew
   ${c.bold('npx agentmash-digest')}            the week in review, to a channel or your terminal
   ${c.dim('npx agentmash mcp')}               serve the MCP tools on stdio ${c.dim('(what .mcp.json runs)')}
 
@@ -1707,6 +2011,10 @@ ${c.bold('agentmash')} — let your team see each other's work on one repository
   ${c.dim('--repo <path>')}    target repository   ${c.dim('(default: enclosing git repo)')}
   ${c.dim('--label <text>')}   name for the room   ${c.dim('(default: repo folder name)')}
   ${c.dim('--force')}          with init: replace an existing room
+                   with team: overwrite files changed locally or not written by the crew
+  ${c.dim('--agents <a,b>')}   with team: agents by short or full name (pipe, pipe-backend), or all
+  ${c.dim('--slug <slug>')}    with team add: folder name for the team skill ${c.dim('(default: from the name)')}
+  ${c.dim('--dry-run')}        with team: show what would change and write nothing
   ${c.dim('--no-git-hook')}    with init/join: skip the post-commit client
   ${c.dim('--no-open')}        with init/join/demo: do not open the browser
   ${c.dim('--force-hooks-path')} install into a core.hooksPath inside the working tree
@@ -1717,18 +2025,42 @@ ${c.bold('agentmash')} — let your team see each other's work on one repository
 `);
 }
 
+/**
+ * The flags that take no value, as typed, and the key each is kept under.
+ * Booleans have to be listed here: anything else takes the next token as its
+ * value, so `team add --dry-run "agentmash crew"` would lose the name.
+ */
+const BOOLEAN_FLAGS = {
+  '--force': 'force',
+  '--no-git-hook': 'noGitHook',
+  '--no-open': 'noOpen',
+  '--force-hooks-path': 'forceHooksPath',
+  '--yes': 'yes',
+  '--local': 'local',
+  '--dry-run': 'dryRun',
+  '--json': 'json',
+  '--help': 'help',
+  '-h': 'help',
+};
+
 function parseArgs(argv) {
   const args = { _: [] };
+  // The crew's own command refuses a flag given twice, and keeping the last
+  // one would install a smaller team than was typed: --agents pipe --agents flex.
+  const set = (key, value) => {
+    if (Object.hasOwn(args, key)) die(`--${key} is given twice`);
+    args[key] = value;
+  };
   for (let i = 0; i < argv.length; i++) {
     const token = argv[i];
-    if (token === '--force') args.force = true;
-    else if (token === '--no-git-hook') args.noGitHook = true;
-    else if (token === '--no-open') args.noOpen = true;
-    else if (token === '--force-hooks-path') args.forceHooksPath = true;
-    else if (token === '--yes') args.yes = true;
-    else if (token === '--local') args.local = true;
-    else if (token === '--help' || token === '-h') args.help = true;
-    else if (token.startsWith('--')) args[token.slice(2)] = argv[++i];
+    const eq = token.startsWith('--') ? token.indexOf('=') : -1;
+    if (Object.hasOwn(BOOLEAN_FLAGS, token)) args[BOOLEAN_FLAGS[token]] = true;
+    // --agents=all as well as --agents all, as the crew's own command reads it.
+    // A boolean spelled that way is refused, so --dry-run=false is not a yes.
+    else if (eq > 2) {
+      if (Object.hasOwn(BOOLEAN_FLAGS, token.slice(0, eq))) die(`${token.slice(0, eq)} takes no value`);
+      set(token.slice(2, eq), token.slice(eq + 1));
+    } else if (token.startsWith('--')) set(token.slice(2), argv[++i]);
     else args._.push(token);
   }
   return args;
@@ -1786,6 +2118,7 @@ const commands = {
   purge: cmdPurge,
   delete: cmdDelete,
   uninstall: async (a) => cmdUninstall(a),
+  team: cmdTeam,
   mcp: cmdMcp,
 };
 

package/crew/README.md

@@ -0,0 +1,52 @@
+# crew
+
+The [agentmash crew](https://github.com/IskakovDamir/agentmash-crew): 18 Claude Code agents, Mash the conductor among them, vendored at [v1.2.0](https://github.com/IskakovDamir/agentmash-crew/tree/v1.2.0) (commit `5ad6818f6fcb926ea66f7389fd00a0041d4fc1c7`). `npx agentmash team`, the one-click pull request on agentmash.dev and the /agents pages all read these files, so a team installed any of those ways is byte for byte the team the crew's own installer writes. The install format is specified upstream in [docs/bundle-format.md](https://github.com/IskakovDamir/agentmash-crew/blob/v1.2.0/docs/bundle-format.md).
+
+| file | where it comes from | what it is for |
+| --- | --- | --- |
+| `bundle.json` | `dist/bundle.json` | every file an install writes, the team skill template and the guard hook |
+| `catalog.json` | `catalog.json` | the /agents pages, and the agent names the server routes accept |
+| `team-plan.mjs` | `lib/team-plan.mjs` | the pure planner (`planChange`) the CLI and the server both run |
+| `install.mjs` | `lib/install.mjs` | the file-system side the CLI runs (`runTeamOp`, `listTeams`, `loadBundle`) |
+| `team-plan.d.mts` | this repo, `tools/crew-team-plan.d.mts` | TypeScript declarations for `team-plan.mjs` |
+| `crew.lock.json` | the sync | the tag, the commit and the sha256 of every other file here |
+
+## Never edit by hand
+
+Everything here is written by `tools/sync-crew.mjs`, and `cli/test/crew-lock.test.mjs` re-hashes it against `crew.lock.json`, so a hand edit fails the tests. A change to an agent, the bundle or the planner goes upstream, gets a tag, and comes here by a sync. The declarations are the one file kept in this repo: edit `tools/crew-team-plan.d.mts` and sync again.
+
+## Updating
+
+```bash
+git -C ../agentmash-crew fetch --tags
+git -C ../agentmash-crew checkout v<new version>
+node tools/sync-crew.mjs --from ../agentmash-crew
+```
+
+The script refuses a checkout that has local changes or is not exactly at the tag, and checks every file against the blob in the tagged commit. Review the diff of `crew/`, run the tests, and commit `crew/` with its lock. The CLI package carries its own copy of these files, so people running `npx agentmash` get a new crew version with the next CLI release.
+
+## License
+
+`bundle.json`, `catalog.json`, `team-plan.mjs` and `install.mjs` are copied from [agentmash-crew](https://github.com/IskakovDamir/agentmash-crew) and are under its MIT License:
+
+    MIT License
+
+    Copyright (c) 2026 Damir Iskakov
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.