onboarding skill

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:

explorers, research librarians, and focused review agents are routed by the work rather than forced through one general-purpose persona.

• Eleven-agent roster: primary workers, plan specialists, architecture consultation, codebase

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.

• The Senpi component layer: startup config and migration, native status, onboarding,

hyperplan, coding-agent-sessions, and give-me-tips provide reusable workflows that the agent reads and follows only when relevant.

• Senpi-native skills: init-deep, ultrawork, ulw-loop, ulw-plan, ulw-research,

servers give projects a layered tool surface without forcing every integration into core.

• Three MCP tiers: built-in servers, user or project .mcp.json servers, and skill-embedded

selected omo harness exposes that surface.

• Team mode: cooperating agent sessions can share work, messages, and task state when the

recorded progress instead of relying on conversation context alone.

• Goal and boulder state: durable objective and work-plan state let long work resume from

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.

• Ultrawork and the ulw keyword: don't try to memorize the workflows up front — you'll

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.

• Mass-ulw: mass ulw opens dependency-ordered multi-agent DAG orchestration — many child

through an architecture consultation lane while the active model continues execution.

• The fallback architect: refusal metadata can route the unresolved engineering question

with the right stack, preferences, and working habits.

• Memory: dedicated memory tools record durable user and project facts so later sessions begin

behavior measurable and auditable, with documented opt-outs.

• Telemetry: privacy-bounded anonymous lifecycle signals and local preview commands make omo

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.

• Init-deep: hierarchical AGENTS.md generation, snapshot state, local or committed mode, and

as - omo --list-tips on OmO Native (omo-ai installs, where senpi is not on PATH) or senpi --list-tips on a plain senpi install - then read and follow give-me-tips for any visible tip the user wants explained from the implementation.

• Tips with a live source of truth: list the tips with the command this product is installed

views, and widgets let components ask structured questions instead of burying choices in prose.

• Interactive UI primitives: real pickers, confirms, inputs, notifications, editors, custom

with the --onboard flag of the command this product is installed as - omo --onboard on OmO Native (omo-ai installs, where senpi is not on PATH) or senpi --onboard on a plain senpi install - or shut the auto-start off with the omo-senpi-onboarding-disabled flag.

• Re-running this tour: onboarding auto-starts once, ever. The user can bring it back any time

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.

• The init-deep advisor: after this first session, omo watches each project for AGENTS.md

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:

definitions in .mcp.json or settings.

• Claude Code: ~/.claude/settings.json, project and global CLAUDE.md files, MCP server

~/.config/opencode/oh-my-opencode.jsonc, project .mcp.json, and existing AGENTS.md files.

• Codex: ~/.codex/config.toml, any AGENTS.md files it manages.
• OpenCode / oh-my-openagent: ~/.config/opencode/opencode.json,

• Anything else the user names.

Global OpenCode MCP servers and global OpenCode skills are not yours to move by hand. omo setup imports them: MCP servers from ~/.config/opencode/opencode.json[c] into the engine's global ~/.omo/agent/mcp.json, and skills from ~/.config/opencode/skills/ into ~/.omo/agent/skills/, converted to the shapes omo reads, consent-gated, and never overwriting a name that already exists. Run omo setup --dry-run to show the user exactly what would land. Once they accept, run omo setup --yes: your shell is not a terminal, so plain omo setup stops at its consent prompt and imports nothing. Copying a global server into a project .mcp.json yourself is a bug: it disappears the moment the user opens any other directory.

Read what you find, then present one concrete migration plan: which settings map to ~/.omo/omo.json[c], which MCP servers omo setup carries over globally and which project-only servers still belong in that project's .mcp.json, which CLAUDE.md content becomes project AGENTS.md content, and which personal facts belong in memory instead of files. Show the plan and WAIT for the user to accept it. Apply nothing before they say yes. If they accept part of it, apply that part only. Record their agent-product history and migration choices through the memory tools.

3. Session archaeology

Ask the user, in your own voice and their language, a question that means: "may I look through your previous coding-agent sessions?" Phrase it naturally; do not read that sentence out like a script. This lane is opt-in. If they say no, skip to lane 4 and base it on nothing.

If they say yes, drive the coding-agent-sessions skill: read its SKILL.md and follow it. Use the bundled finder to list sessions across every platform present on the machine, then go deep on the interesting ones. Mine for:

and constraints enumerated upfront, or vague starts?), how they answer agent questions (pick an offered option, answer several at once holistically, redirect, or delegate the decision), how they approve (a verbal yes versus commanding execution), and whether the style shifts by repo or domain,

• how they actually work: hands-on-the-wheel back-and-forth versus long one-shot delegations,
• their planning stance, feeding the seed described in lane 5: opening-message shape (requirements

any language,

• what frustrates them: repeated corrections, abandoned sessions, prompts that read as annoyed, in

• how much they run in parallel, and how long their longest sessions run,
• which repos, stacks, and models dominate their history.