---
name: agent-fleet-export
description: >-
  Use when moving a multi-agent setup (bots, skills, schedules, scratch docs,
  connector shape) off one agent product so any other agent stack can rebuild
  it. Produces a portable folder. Never packs secrets.
---

# Agent fleet export

## Goal
Build one durable folder the owner can zip and hand to any other agent stack. Capture roles, recipes, schedules, working docs, and connector shape. Never secrets.

## Output
`agent-fleet-export-<YYYY-MM-DD>/` somewhere the owner chooses:

```
MANIFEST.md            # source product, date, counts, what's included vs skipped
handoff.md             # how the fleet works together: lead agent, lanes, hard rules
fleet-index.md         # one row per agent: name, title, its one job, host, scratch location
agents/<agent-slug>/
  profile.md           # name, title, description, hard rules
  memory.md            # durable facts and conventions only
  routines.md          # each schedule/trigger: name, when, job text, enabled or paused
  automations/         # raw schedule files when the source has them (no run history)
  connectors.md        # service, purpose, auth kind (OAuth, API key, CLI login). No tokens.
  scratch/             # durable working docs: indexes, STATUS, QUEUE, maps, rollups
skills/
  INDEX.md             # slug → when to use
  <slug>/SKILL.md      # every user-authored skill
  managed.txt          # marketplace/plugin skills by name only, to reinstall
environments.md        # where things run: cloud box, laptop, CLIs, path conventions
schedules.md           # every schedule and event trigger across the fleet in one table
local-only.md          # things that live only on a personal machine, with paths to copy
OMITTED.md             # what was left out on purpose, and why
```

## Steps
1. **List agents.** Every assistant the owner runs. Skip empty or test stubs unless they want them.
2. **Profiles.** Name, title, description, hard rules. Keep owner paths and handles for a personal move. Scrub them if the packet will be shared.
3. **Memory.** Durable facts and conventions only. Skip episodic logs, chat noise, credentials, and tokenized URLs.
4. **Routines.** Write each trigger in plain language ("daily 8:15am America/Los_Angeles", "on PR opened in owner/repo"), the job text, and whether it's on. Copy raw schedule files too when they exist, minus run history.
5. **Skills.** Copy every user-authored skill whole. List managed or marketplace skills by name so they get reinstalled, not copied.
6. **Scratch.** Copy the docs that route work: indexes, STATUS and QUEUE files, maps, rollups, briefs. Prefer these over transcripts.
7. **Connectors.** Every service an agent touches, what it's used for, and how it authenticates. Write "re-auth on destination" instead of copying credentials.
8. **Where things run.** Cloud box vs laptop vs hosted. Which agents need a local machine (messaging bridges, desktop control, local files). Put local-only paths in `local-only.md`.
9. **Handoff narrative.** `handoff.md` explains the fleet as a system: who leads, who does what, how work gets delegated, spend or usage limits, hard rules.
10. **Manifest and omissions.** Counts, timestamp, source product. `OMITTED.md` lists everything skipped on purpose.

## Never pack
Secrets files, API keys, OAuth tokens, cookies, webhook signing keys, gateway configs, databases, raw transcript dumps, audit outboxes. If a file might contain a credential, leave it out and note it in `OMITTED.md`.

## Finding things on the source system
Every product stores this differently. Look for:
- a per-agent folder or config (profile, persona, system prompt)
- a shared skills or workflows directory
- automation or schedule definitions (JSON, YAML, cron entries, webhook configs)
- a memory store split into durable profile vs episodic log
- working directories the agents write to, on the host and on any laptop they reach

If the source agent can read its own config, ask it to inventory itself first and check its list against what's on disk.

## Done when
The owner can open `handoff.md` and `fleet-index.md` and see every role, recipe, schedule, and connector needed to rebuild the fleet, with no secret material anywhere in the folder, plus a checklist for anything that only lives on a local machine.

---
name: agent-fleet-import
description: >-
  Use when handed an agent-fleet-export packet and asked to recreate that
  multi-agent setup on the current stack. Translates intent into this
  product's primitives instead of cloning the source product's APIs.
---

# Agent fleet import

## Goal
Take an `agent-fleet-export-*` packet and rebuild an equivalent setup here. Translate intent. Don't treat the source product's tool names as if they exist on this stack.

## Inputs
- The packet folder or zip.
- The owner's constraints: which agents to keep, where they run, which services are already connected.

## Steps
1. **Read first.** `MANIFEST.md`, `handoff.md`, `fleet-index.md`, `OMITTED.md`. Summarize for the owner: how many agents, skills, and schedules, what's machine-bound, what's missing. If the fleet is large, ask which subset to bring over.
2. **Map primitives.** Build a translation table before creating anything:

   | Packet concept | Here |
   |---|---|
   | Agent profile | agent, project, persona, or instruction file |
   | Shared skill | skill, instruction snippet, or repo skill folder |
   | Routine | scheduled task, webhook, CI listener, or reminder |
   | Scratch docs | repo folder, knowledge files, or attached project files |
   | Connector | native integration, MCP server, or CLI login (owner re-auths) |
   | Lead agent | an agent that routes work, or a human checklist if this stack is single-agent |

   Anything with no equivalent goes in `IMPORT-GAPS.md`.
3. **Skills first.** Port `skills/` as reusable recipes. Rewrite source tool names as capabilities ("send a Slack message", "run gh on the laptop"). Keep each when-to-use line. Reinstall anything in `managed.txt` from this stack's marketplace if it exists.
4. **Agents.** For each agent the owner kept: persona from `profile.md`, attach its skills, seed memory from `memory.md`. Keep each agent to one job.
5. **Scratch.** Copy each agent's `scratch/` into durable storage here. Rewrite paths to match this environment.
6. **Schedules.** Recreate each routine from `routines.md` and `schedules.md` with the closest trigger available. Rewrite job text for this stack's tools. Prefer coarser cadences when unsure. Ask before enabling anything that sends messages to other people.
7. **Connectors.** Use `connectors.md` and `environments.md` as a checklist. The owner re-authenticates. Never invent credentials. Mark each one connected, blocked, or skipped.
8. **Orchestration.** Turn the routing rules and hard rules in `handoff.md` into standing instructions for the lead agent.
9. **Check.** Compare the packet against what's live. Give the owner a short card: what's running, what's blocked and on what, what's in `IMPORT-GAPS.md`.

## How to port
This is a briefing, not a byte-for-byte clone. Think "over there this agent did X on schedule Y using Z. Here it does the same job with A and B."

## Safety
- Don't send email, Slack, texts, or posts as the owner unless they ask for that specific send.
- The packet has no secrets. Don't go looking for them and don't make them up.
- Don't turn on anything that spends money or burns usage without an explicit go.

## Done when
The owner has the fleet (or the subset they picked) running here with personas, skills, and schedules, plus a gap list of what still needs their login or a feature this stack doesn't have.