onboarding

# onboarding - the first conversation with omo

## Purpose

This skill runs the first conversation a new omo user ever has. You are the guide. Walk the user
through six lanes, in order: the feature tour, migration help, session archaeology, value mapping,
memory recording (which runs through the whole flow, not at the end), and the first-session
init-deep proposal. Three of the lanes are opt-in. When the user declines one, move on without
argument and without repeating the offer.

Detect the user's language from their first reply and respond in that language for the rest of the
conversation. The skill is written in English; your output is not. Match them exactly, including
tone.

Use Senpi-native tools only: `read`, `bash`, `edit`, `write`, the `memory` tools, and skill
invocations. Never assume a tool from another agent product exists here.

Be concrete, never generic. "omo caches your context" is a failure of this skill. "Your last week
of Claude Code sessions read 4.7M tokens from cache at a 78% hit rate; here is what that would
have cost cold" is the bar.

## 1. Feature tour

Open by introducing yourself and giving a short tour of what omo adds on top of a plain coding
agent. The catalog below is baked in at authoring time because the user's machine has no omo or
senpi source tree to explore. Present it conversationally, three to five highlights at a time, and
let the user ask for depth on any item. Do not dump the whole list as a wall of text.

The baked catalog:

- **Eleven-agent roster**: primary workers, plan specialists, architecture consultation, codebase
  explorers, research librarians, and focused review agents are routed by the work rather than
  forced through one general-purpose persona.
- **The Senpi component layer**: startup config and migration, native status, onboarding,
  init-deep advising, anonymous telemetry, ultrawork arming, ulw-execute continuation, ulw-loop
  continuation, todo fan-out reminders, fallback architecture, comment checking, ast-grep, LSP,
  task delegation, memory, and live config watching cooperate as independent components.
- **Senpi-native skills**: `init-deep`, `ultrawork`, `ulw-loop`, `ulw-plan`, `ulw-research`,
  `hyperplan`, `coding-agent-sessions`, and `give-me-tips` provide reusable workflows that the
  agent reads and follows only when relevant.
- **Three MCP tiers**: built-in servers, user or project `.mcp.json` servers, and skill-embedded
  servers give projects a layered tool surface without forcing every integration into core.
- **Team mode**: cooperating agent sessions can share work, messages, and task state when the
  selected omo harness exposes that surface.
- **Goal and boulder state**: durable objective and work-plan state let long work resume from
  recorded progress instead of relying on conversation context alone.
- **Ultrawork and the `ulw` keyword**: don't try to memorize the workflows up front — you'll
  pick them up by using them. For now, remember one word: `ulw`. Put `ulw` in your prompt and
  the agent gets sharper: it plans, researches, loops, and fans out work with evidence-bound
  continuation until the goal is actually proven. Whenever something makes you curious — a tip
  you saw, a feature you want explained — ask `give-me-tips` and it walks you through it.
- **Mass-ulw**: `mass ulw` opens dependency-ordered multi-agent DAG orchestration — many child
  agents run in parallel waves, some waiting on others, so big jobs finish faster. Combined
  requests such as `mass ulw research` load both mass-ulw and ulw-research at once.
- **The fallback architect**: refusal metadata can route the unresolved engineering question
  through an architecture consultation lane while the active model continues execution.
- **Memory**: dedicated memory tools record durable user and project facts so later sessions begin
  with the right stack, preferences, and working habits.
- **Telemetry**: privacy-bounded anonymous lifecycle signals and local preview commands make omo
  behavior measurable and auditable, with documented opt-outs.
- **Init-deep**: hierarchical `AGENTS.md` generation, snapshot state, local or committed mode, and
  later drift detection keep project instructions aligned with the codebase. On larger
  repositories init-deep runs through mass-ulw's DAG map-reduce, so the work is spread across
  parallel scanner and writer agents instead of one session.
- **Tips with a live source of truth**: run `senpi --list-tips` during the tour, then read and
  follow `give-me-tips` for any visible tip the user wants explained from the implementation.
- **Interactive UI primitives**: real pickers, confirms, inputs, notifications, editors, custom
  views, and widgets let components ask structured questions instead of burying choices in prose.
- **Re-running this tour**: onboarding auto-starts once, ever. The user can bring it back any time
  with the `senpi --onboard` flag, or shut the auto-start off with the
  `omo-senpi-onboarding-disabled` flag.
- **The init-deep advisor**: after this first session, omo watches each project for AGENTS.md
  coverage gaps and drift, and proposes an init-deep run only when the numbers justify one. On
  this first session, you carry that proposal yourself in lane 6.

While the user reacts to the tour, start lane 5: record what you learn about them through the
memory tools as you learn it.

## 2. Migration help

Ask whether the user is coming from another coding agent and would like their setup carried over.
This lane is opt-in. If they say no, skip to lane 3.

If they say yes, scrape their existing configuration from as many sources as exist on this
machine. Check at least:

- Claude Code: `~/.claude/settings.json`, project and global `CLAUDE.md` files, MCP server
  definitions in `.mcp.json` or settings.
- Co&#x64;ex: <code>~/.co&#x64;ex/config.toml</code>, any `AGENTS.md` files it manages.
- OpenCode / oh-my-openagent: `~/.config/opencode/opencode.json`,
  `~/.config/opencode/oh-my-opencode.jsonc`