onboarding - the first conversation with omo
Purpose
This skill introduces OmO 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 message 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.
Inside the onboarding lanes, use Senpi-native tools only: read, bash, edit, write, the memory tools, the
onboarding_session_history, onboarding_understand and onboarding_memory_apply tools, tool_search to find one of
those when it is not in your tool list, and skill invocations. Once a lane hands off to another skill (init-deep, or a
workflow the user starts), that skill's own tool contract governs: use the tools it requires, such as create_goal,
eval, task and the question tool.
Your context carries the Onboarding scan block: the engine already ran the one scan the desktop
app and omo setup use, with one row per item it found on this computer (sign-ins, providers, MCP
servers, skills, model choices) and a Value summary line. Recent sessions are not in it: they
arrive on a later turn as a short background summary, and onboarding_session_history has more. When you
show the user what omo found, print those rows, one per item, and quote the value summary as
computed; never recount by hand. 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.
Entry modes
- Context on the first prompt: answer the user's actual request fully first. Then greet them
briefly in their language and offer the tour in one line. Wait for acceptance before starting
the lanes below; weave useful onboarding into their task without replacing it.
- Explicit tour:
--onboard, a request for the tour or getting started, or acceptance of the
offer starts the lanes immediately. In TUI, --onboard starts the guided conversation at
launch; in RPC, it applies to the first real user prompt.
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: list the tips with the command this product is installed
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.
- 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 context accompanies the first real message, not launch.
The user can bring the tour back any time
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.
- 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, start from the migration inventory that arrived with this skill's context (the
Migration inventory sentence): the engine already ran the same detection omo setup uses, and it
lists every sign-in it found (API keys to import, OAuth logins to sign in again, unmapped
providers), every custom provider, every global skill, and every MCP server from the sources it
covers - OpenCode, the oh-my-pi and gajae-code credential stores, and the engine's own files. For
those sources the inventory is the source of truth - do not re-read their config files by hand to
rebuild it. Show the user what omo setup --dry-run would do with it.
The scan does not know every harness. When the user is coming from one it does not detect, read
that harness's own files by hand and fold what you find into the same plan:
- Claude Code:
~/.claude/settings.json, global and project CLAUDE.md files, MCP server
definitions in .mcp.json or settings.
- Another coding agent the user names: its own config file in its home folder (often a
config.toml)
and any AGENTS.md files it manages.
- Anything else the user names that the inventory does not cover (for example a project
.mcp.json, or an AGENTS.md another agent manages).
Hand-read only what the inventory does not cover; never re-derive its categories by hand.
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.
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.
Present one concrete migration plan from the inventory and anything the user named: 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, call onboarding_understand with consent: true (find it through tool_search
if it is not in your tool list). It reads the scan's session digests with the current model and
returns candidate facts with ids; it saves nothing. Show every candidate as a numbered list and ask
which ones to remember. Then call onboarding_memory_apply with exactly the ids they picked: it
writes only those, as one memory commit, through the same writer the background facts extractor
uses. Never write a candidate the user did not pick, and never re-write candidates through the
memory tools. If the understanding falls back to the scan only, say so and continue.
For the patterns below, call the onboarding_session_history tool as well. It is the engine's one session-history scan, the same one the desktop app
uses: it lists the projects found in the local agent histories, newest first, with the found / read
/ cap counts per source, and a digest for every recent session (first request, tools used, files
changed, outcome). Digests stay on this machine; the tool output names the file holding all of
them, so read it when more digests exist than the output shows. Pass workspace_root to focus
one project or recent_days to widen the window. Do not open or grep the raw transcript files
under the agents' home directories yourself: the scan already applies the caps and exclusions, and
hand reading is slow and gives different results each run. Mine the digests for:
- 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
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,
- what frustrates them: repeated corrections, abandoned sessions, prompts that read as annoyed, in
any language,
- how much they run in parallel, and how long their longest sessions run,
- which repos, stacks, and models dominate their history.
Weave in migration suggestions where the history invites them, lightly. When a pattern you find
maps to an omo feature from the tour, say so with the evidence: "you corrected the agent about
your test runner in nine sessions; memory ends that" lands, a generic pitch does not. Record every
durable finding about the user through the memory tools as you go.
4. Value mapping + savings
Open with the scan's Value summary line as it was computed. Then, from the session data gathered
in lane 3, give the user quantified estimates of what omo's caching
would have been worth on their real workload. Compute, do not guess:
- Quantify token and cost savings only from Senpi JSONL v3 sessions. Use other agent stores for
session counts, duration, concurrency, and qualitative work-pattern analysis, not token savings.
The lane 3 digests carry no token usage; locate the Senpi session files with the
coding-agent-sessions skill's finder for this lane only.
- Fetch
https://models.dev/api.json. Treat its top level as the provider map. Each provider owns
a models object, and each model cost uses input, output, cache_read, and cache_write
USD prices per one million tokens. If the API is unavailable, every session has insufficient
pricing data.
- Process session files in chronological filename order. Process entries inside a file in JSONL
line order. A malformed timestamp skips that entry. Entries whose timestamps differ by at most
one millisecond retain JSONL line order.
- Read usage only from
message.usage. Map input, cacheRead, cacheWrite, and output
exactly. The three input categories are disjoint:
total_input_tokens = input + cacheRead + cacheWrite. A session whose total input is zero is
skipped.
- Attribute each usage entry to
message.provider plus message.model when both are present.
Otherwise use the latest model_change provider and modelId. Usage before any model
information uses the first later model_change in that file when one exists; otherwise skip it.
- Resolve prices first by exact
provider/model composite identity. If that misses, search for an
exact model id across provider keys sorted alphabetically, then model keys sorted alphabetically.
The first deterministic hit wins. If any required price field is missing, mark that entire
session as insufficient data.
- Aggregate usage by provider and model, then compute grand totals. The caching rate is
cacheRead / (input + cacheRead + cacheWrite) * 100.
- Compute actual cost as
(input * price.input + output * price.output + cacheRead * price.cache_read + cacheWrite * price.cache_write) / 1_000_000.
Compute omo savings as
cacheRead * (price.input - price.cache_read) / 1_000_000.
- Round only final aggregated values with
Math.round(value * 100) / 100. Never round per message,
model, or session. Label the result estimate.
- Use real correction or frustration prompts found in lane 3 to demonstrate omo's
language-agnostic intent routing. Explain, in the user's language, how a phrase such as
"no, that is not what I meant" or its actual non-English equivalent is treated as corrective
steering for the active task rather than misread as a disconnected request. Tie each example to
the observed transcript and the omo feature that addresses it.
Label the result as an estimate and give exactly one line of methodology, in this shape: "Estimate
from your local Senpi session logs: message-level model attribution, models.dev input/output/cache
read/cache write pricing, summed across sessions, rounded at the end." One line, then the numbers,
then stop.
If the user skipped lane 3, skip this lane too; there is no data to map.
5. Memory recording
This lane has no fixed position: it runs through the entire flow. Nothing is written before the
user chooses it: facts from the session history go through the lane 3 selection, and anything
else you learn is proposed in one line and written through the memory tools only after the user
agrees. Worth recording:
- their host and machine facts relevant to future work,
- their language and communication style,
- which agent products they came from and what they kept from them,
- their stacks, main repos, and working patterns from lane 3,
- their stated preferences and every accept or decline decision from this conversation.
Write durable personal and cross-project facts through the memory tool into system/human.md.
Write repository-specific stack, commands, constraints, and migration decisions through the memory
tool into system/project.md. Do not edit those backing files directly.
Planning-stance observations from lane 3 are the one exception: write them as SEEDS under a
## Seed heading in system/human/planning-style.md (create the block through the memory tool if
absent), never into system/human.md. Seeds are inferences and MUST stay weak:
- Phrase every seed as a hypothesis ("appears to enumerate upfront and delegate the rest"), never
a conclusion, and set
confidence: low ALWAYS - never medium or high, however consistent the
history looks. Behavior in another tool reflects that tool's affordances, not necessarily this
user; omo's own planning sessions will confirm or replace these within a few runs.
- Record full provenance on every seed line: the source harness name(s) (e.g. Claude Code,
Codex, OpenCode), the model(s) under which the pattern was mainly observed, the session ids
mined, and today's date as
seeded:. Format:
- [YYYY-MM-DD] (seed) appears to <hypothesis + context> <!-- src: <harness>/<session-id>,...; harness: <names>; model: <models>; seeded: YYYY-MM-DD; pattern: inferred-from-external-sessions; confidence: low -->
- Seeds carry interaction STYLE only - never session content, code, file paths, or secrets.
Record facts, not narration. "Prefers Korean, migrated from Claude Code, works one repo at a time
in long sessions" is a memory. "The user went through onboarding today" is not.
6. First-session init-deep proposal
On the true first session the advisor component stays quiet, so this proposal is yours to carry.
Before saying anything about it, run the same eligibility gate the advisor uses, in this order:
- The current directory must be inside a git repository. Check with
git rev-parse --show-toplevel. Not a repo: ineligible.
- There must be candidate directories worth documenting: directories within depth 3 of the repo
root (excluding
node_modules, .git, dist, build, vendor, .next, __pycache__,
.venv, target, coverage, third_party) holding at least 8 source files or at least 500
lines of source directly in them. Zero candidates: ineligible, regardless of anything else.
- Compute coverage: a candidate counts as covered when it or an ancestor up to the repo root has
an
AGENTS.md. The missing ratio is uncovered candidates over all candidates. Below 0.50:
ineligible. A new project with candidates and no AGENTS.md anywhere is missing ratio 1.0 and
eligible.
If any gate fails, skip this lane SILENTLY. Do not mention AGENTS.md, do not explain why you are
not proposing, do not hint that a check ran. Close the conversation warmly instead.
If all gates pass, ask in the user's language: "want me to set up AGENTS.md for this project?"
This is opt-in. On yes, read the init-deep skill at its SKILL.md path and follow it. On no,
record the decline through the memory tools and finish the conversation gracefully: a short
send-off in their language, an invitation to come back with omo --onboard on OmO Native or
senpi --onboard on a plain senpi install, and nothing more.
After init-deep finishes, tell the user in their language which path it took. On its dag path, say
that init-deep ran through mass-ulw's DAG orchestration — the work was spread across parallel child
agents in dependency-ordered waves rather than done by one session. On its inline path (a repo too
small for a dag), say that it mapped the project with a few parallel explore agents and wrote the
files itself. Then introduce mass-ulw: mass ulw is how you bring that
DAG orchestration to any big job, and combined requests such as mass ulw research, mass ulw loop, and mass ulw plan load mass-ulw alongside each of those workflows.
1---2name: onboarding3description: "Guides a first-time omo user through setup and the core workflow. Use when a new user asks to get started with omo."4metadata:5 source: https://skillmd.com/skills/code-yeongyu/onboarding6---78# onboarding - the first conversation with omo910## Purpose1112This skill introduces OmO through six lanes, in order: the feature tour, migration help, session archaeology, value mapping,13memory recording (which runs through the whole flow, not at the end), and the first-session14init-deep proposal. Three of the lanes are opt-in. When the user declines one, move on without15argument and without repeating the offer.1617Detect the user's language from their message and respond in that language for the rest of the18conversation. The skill is written in English; your output is not. Match them exactly, including19tone.2021Inside the onboarding lanes, use Senpi-native tools only: `read`, `bash`, `edit`, `write`, the `memory` tools, the22`onboarding_session_history`, `onboarding_understand` and `onboarding_memory_apply` tools, `tool_search` to find one of23those when it is not in your tool list, and skill invocations. Once a lane hands off to another skill (init-deep, or a24workflow the user starts), that skill's own tool contract governs: use the tools it requires, such as `create_goal`,25`eval`, `task` and the question tool.2627Your context carries the `Onboarding scan` block: the engine already ran the one scan the desktop28app and `omo setup` use, with one row per item it found on this computer (sign-ins, providers, MCP29servers, skills, model choices) and a `Value summary` line. Recent sessions are not in it: they30arrive on a later turn as a short background summary, and `onboarding_session_history` has more. When you31show the user what omo found, print those rows, one per item, and quote the value summary as32computed; never recount by hand. Never assume a tool from another agent product exists here.3334Be concrete, never generic. "omo caches your context" is a failure of this skill. "Your last week35of Claude Code sessions read 4.7M tokens from cache at a 78% hit rate; here is what that would36have cost cold" is the bar.3738## Entry modes3940- **Context on the first prompt:** answer the user's actual request fully first. Then greet them41 briefly in their language and offer the tour in one line. Wait for acceptance before starting42 the lanes below; weave useful onboarding into their task without replacing it.43- **Explicit tour:** `--onboard`, a request for the tour or getting started, or acceptance of the44 offer starts the lanes immediately. In TUI, `--onboard` starts the guided conversation at45 launch; in RPC, it applies to the first real user prompt.4647## 1. Feature tour4849Open by introducing yourself and giving a short tour of what omo adds on top of a plain coding50agent. The catalog below is baked in at authoring time because the user's machine has no omo or51senpi source tree to explore. Present it conversationally, three to five highlights at a time, and52let the user ask for depth on any item. Do not dump the whole list as a wall of text.5354The baked catalog:5556- **Eleven-agent roster**: primary workers, plan specialists, architecture consultation, codebase57 explorers, research librarians, and focused review agents are routed by the work rather than58 forced through one general-purpose persona.59- **The Senpi component layer**: startup config and migration, native status, onboarding,60 init-deep advising, anonymous telemetry, ultrawork arming, ulw-execute continuation, ulw-loop61 continuation, todo fan-out reminders, fallback architecture, comment checking, ast-grep, LSP,62 task delegation, memory, and live config watching cooperate as independent components.63- **Senpi-native skills**: `init-deep`, `ultrawork`, `ulw-loop`, `ulw-plan`, `ulw-research`,64 `hyperplan`, `coding-agent-sessions`, and `give-me-tips` provide reusable workflows that the65 agent reads and follows only when relevant.66- **Three MCP tiers**: built-in servers, user or project `.mcp.json` servers, and skill-embedded67 servers give projects a layered tool surface without forcing every integration into core.68- **Team mode**: cooperating agent sessions can share work, messages, and task state when the69 selected omo harness exposes that surface.70- **Goal and boulder state**: durable objective and work-plan state let long work resume from71 recorded progress instead of relying on conversation context alone.72- **Ultrawork and the `ulw` keyword**: don't try to memorize the workflows up front — you'll73 pick them up by using them. For now, remember one word: `ulw`. Put `ulw` in your prompt and74 the agent gets sharper: it plans, researches, loops, and fans out work with evidence-bound75 continuation until the goal is actually proven. Whenever something makes you curious — a tip76 you saw, a feature you want explained — ask `give-me-tips` and it walks you through it.77- **Mass-ulw**: `mass ulw` opens dependency-ordered multi-agent DAG orchestration — many child78 agents run in parallel waves, some waiting on others, so big jobs finish faster. Combined79 requests such as `mass ulw research` load both mass-ulw and ulw-research at once.80- **The fallback architect**: refusal metadata can route the unresolved engineering question81 through an architecture consultation lane while the active model continues execution.82- **Memory**: dedicated memory tools record durable user and project facts so later sessions begin83 with the right stack, preferences, and working habits.84- **Telemetry**: privacy-bounded anonymous lifecycle signals and local preview commands make omo85 behavior measurable and auditable, with documented opt-outs.86- **Init-deep**: hierarchical `AGENTS.md` generation, snapshot state, local or committed mode, and87 later drift detection keep project instructions aligned with the codebase. On larger88 repositories init-deep runs through mass-ulw's DAG map-reduce, so the work is spread across89 parallel scanner and writer agents instead of one session.90- **Tips with a live source of truth**: list the tips with the command this product is installed91 as - `omo --list-tips` on OmO Native (omo-ai installs, where `senpi` is not on PATH) or `senpi92 --list-tips` on a plain senpi install - then read and follow `give-me-tips` for any visible tip93 the user wants explained from the implementation.94- **Interactive UI primitives**: real pickers, confirms, inputs, notifications, editors, custom95 views, and widgets let components ask structured questions instead of burying choices in prose.96- **Re-running this tour**: onboarding context accompanies the first real message, not launch.97 The user can bring the tour back any time98 with the `--onboard` flag of the command this product is installed as - `omo --onboard` on OmO99 Native (omo-ai installs, where `senpi` is not on PATH) or `senpi --onboard` on a plain senpi100 install - or shut the auto-start off with the `omo-senpi-onboarding-disabled` flag.101- **The init-deep advisor**: after this first session, omo watches each project for AGENTS.md102 coverage gaps and drift, and proposes an init-deep run only when the numbers justify one. On103 this first session, you carry that proposal yourself in lane 6.104105While the user reacts to the tour, start lane 5: record what you learn about them through the106memory tools as you learn it.107108## 2. Migration help109110Ask whether the user is coming from another coding agent and would like their setup carried over.111This lane is opt-in. If they say no, skip to lane 3.112113If they say yes, start from the migration inventory that arrived with this skill's context (the114`Migration inventory` sentence): the engine already ran the same detection `omo setup` uses, and it115lists every sign-in it found (API keys to import, OAuth logins to sign in again, unmapped116providers), every custom provider, every global skill, and every MCP server from the sources it117covers - OpenCode, the oh-my-pi and gajae-code credential stores, and the engine's own files. For118those sources the inventory is the source of truth - do not re-read their config files by hand to119rebuild it. Show the user what `omo setup --dry-run` would do with it.120121The scan does not know every harness. When the user is coming from one it does not detect, read122that harness's own files by hand and fold what you find into the same plan:123124- Claude Code: `~/.claude/settings.json`, global and project `CLAUDE.md` files, MCP server125 definitions in `.mcp.json` or settings.126- Another coding agent the user names: its own config file in its home folder (often a `config.toml`)127 and any `AGENTS.md` files it manages.128- Anything else the user names that the inventory does not cover (for example a project129 `.mcp.json`, or an `AGENTS.md` another agent manages).130131Hand-read only what the inventory does not cover; never re-derive its categories by hand.132133Global OpenCode MCP servers and global OpenCode skills are not yours to move by hand. `omo setup`134imports them: MCP servers from `~/.config/opencode/opencode.json[c]` into the engine's global135`~/.omo/agent/mcp.json`, and skills from `~/.config/opencode/skills/` into `~/.omo/agent/skills/`,136converted to the shapes omo reads, consent-gated, and never overwriting a name that already exists.137Once they accept, run `omo setup --yes`: your shell is not a terminal, so plain `omo setup` stops138at its consent prompt and imports nothing.139Copying a global server into a project `.mcp.json` yourself is a bug: it disappears the moment the140user opens any other directory.141142Present one concrete migration plan from the inventory and anything the user named: which settings143map to `~/.omo/omo.json[c]`, which MCP servers `omo setup` carries over globally and which144project-only servers still belong in that project's `.mcp.json`, which `CLAUDE.md` content becomes145project `AGENTS.md` content, and which personal facts belong in memory instead of files.146Show the plan and WAIT for the user to accept it. Apply nothing before they say yes. If they accept147part of it, apply that part only. Record their agent-product history and migration choices through148the memory tools.149150## 3. Session archaeology151152Ask the user, in your own voice and their language, a question that means: "may I look through153your previous coding-agent sessions?" Phrase it naturally; do not read that sentence out like a154script. This lane is opt-in. If they say no, skip to lane 4 and base it on nothing.155156If they say yes, call `onboarding_understand` with `consent: true` (find it through `tool_search`157if it is not in your tool list). It reads the scan's session digests with the current model and158returns candidate facts with ids; it saves nothing. Show every candidate as a numbered list and ask159which ones to remember. Then call `onboarding_memory_apply` with exactly the ids they picked: it160writes only those, as one memory commit, through the same writer the background facts extractor161uses. Never write a candidate the user did not pick, and never re-write candidates through the162`memory` tools. If the understanding falls back to the scan only, say so and continue.163164For the patterns below, call the `onboarding_session_history` tool as well. It is the engine's one session-history scan, the same one the desktop app165uses: it lists the projects found in the local agent histories, newest first, with the found / read166/ cap counts per source, and a digest for every recent session (first request, tools used, files167changed, outcome). Digests stay on this machine; the tool output names the file holding all of168them, so `read` it when more digests exist than the output shows. Pass `workspace_root` to focus169one project or `recent_days` to widen the window. Do not open or grep the raw transcript files170under the agents' home directories yourself: the scan already applies the caps and exclusions, and171hand reading is slow and gives different results each run. Mine the digests for:172173- how they actually work: hands-on-the-wheel back-and-forth versus long one-shot delegations,174- their planning stance, feeding the seed described in lane 5: opening-message shape (requirements175 and constraints enumerated upfront, or vague starts?), how they answer agent questions (pick an176 offered option, answer several at once holistically, redirect, or delegate the decision), how177 they approve (a verbal yes versus commanding execution), and whether the style shifts by repo or178 domain,179- what frustrates them: repeated corrections, abandoned sessions, prompts that read as annoyed, in180 any language,181- how much they run in parallel, and how long their longest sessions run,182- which repos, stacks, and models dominate their history.183184Weave in migration suggestions where the history invites them, lightly. When a pattern you find185maps to an omo feature from the tour, say so with the evidence: "you corrected the agent about186your test runner in nine sessions; memory ends that" lands, a generic pitch does not. Record every187durable finding about the user through the memory tools as you go.188189## 4. Value mapping + savings190191Open with the scan's `Value summary` line as it was computed. Then, from the session data gathered192in lane 3, give the user quantified estimates of what omo's caching193would have been worth on their real workload. Compute, do not guess:194195- Quantify token and cost savings only from Senpi JSONL v3 sessions. Use other agent stores for196 session counts, duration, concurrency, and qualitative work-pattern analysis, not token savings.197 The lane 3 digests carry no token usage; locate the Senpi session files with the198 `coding-agent-sessions` skill's finder for this lane only.199- Fetch `https://models.dev/api.json`. Treat its top level as the provider map. Each provider owns200 a `models` object, and each model cost uses `input`, `output`, `cache_read`, and `cache_write`201 USD prices per one million tokens. If the API is unavailable, every session has insufficient202 pricing data.203- Process session files in chronological filename order. Process entries inside a file in JSONL204 line order. A malformed timestamp skips that entry. Entries whose timestamps differ by at most205 one millisecond retain JSONL line order.206- Read usage only from `message.usage`. Map `input`, `cacheRead`, `cacheWrite`, and `output`207 exactly. The three input categories are disjoint:208 `total_input_tokens = input + cacheRead + cacheWrite`. A session whose total input is zero is209 skipped.210- Attribute each usage entry to `message.provider` plus `message.model` when both are present.211 Otherwise use the latest `model_change` provider and `modelId`. Usage before any model212 information uses the first later `model_change` in that file when one exists; otherwise skip it.213- Resolve prices first by exact `provider/model` composite identity. If that misses, search for an214 exact model id across provider keys sorted alphabetically, then model keys sorted alphabetically.215 The first deterministic hit wins. If any required price field is missing, mark that entire216 session as insufficient data.217- Aggregate usage by provider and model, then compute grand totals. The caching rate is218 `cacheRead / (input + cacheRead + cacheWrite) * 100`.219- Compute actual cost as220 `(input * price.input + output * price.output + cacheRead * price.cache_read + cacheWrite * price.cache_write) / 1_000_000`.221 Compute omo savings as222 `cacheRead * (price.input - price.cache_read) / 1_000_000`.223- Round only final aggregated values with `Math.round(value * 100) / 100`. Never round per message,224 model, or session. Label the result `estimate`.225- Use real correction or frustration prompts found in lane 3 to demonstrate omo's226 language-agnostic intent routing. Explain, in the user's language, how a phrase such as227 "no, that is not what I meant" or its actual non-English equivalent is treated as corrective228 steering for the active task rather than misread as a disconnected request. Tie each example to229 the observed transcript and the omo feature that addresses it.230231Label the result as an estimate and give exactly one line of methodology, in this shape: "Estimate232from your local Senpi session logs: message-level model attribution, models.dev input/output/cache233read/cache write pricing, summed across sessions, rounded at the end." One line, then the numbers,234then stop.235236If the user skipped lane 3, skip this lane too; there is no data to map.237238## 5. Memory recording239240This lane has no fixed position: it runs through the entire flow. Nothing is written before the241user chooses it: facts from the session history go through the lane 3 selection, and anything242else you learn is proposed in one line and written through the `memory` tools only after the user243agrees. Worth recording:244245- their host and machine facts relevant to future work,246- their language and communication style,247- which agent products they came from and what they kept from them,248- their stacks, main repos, and working patterns from lane 3,249- their stated preferences and every accept or decline decision from this conversation.250251Write durable personal and cross-project facts through the memory tool into `system/human.md`.252Write repository-specific stack, commands, constraints, and migration decisions through the memory253tool into `system/project.md`. Do not edit those backing files directly.254255Planning-stance observations from lane 3 are the one exception: write them as SEEDS under a256`## Seed` heading in `system/human/planning-style.md` (create the block through the memory tool if257absent), never into `system/human.md`. Seeds are inferences and MUST stay weak:258259- Phrase every seed as a hypothesis ("appears to enumerate upfront and delegate the rest"), never260 a conclusion, and set `confidence: low` ALWAYS - never medium or high, however consistent the261 history looks. Behavior in another tool reflects that tool's affordances, not necessarily this262 user; omo's own planning sessions will confirm or replace these within a few runs.263- Record full provenance on every seed line: the source harness name(s) (e.g. Claude Code,264 Codex, OpenCode), the model(s) under which the pattern was mainly observed, the session ids265 mined, and today's date as `seeded:`. Format:266 `- [YYYY-MM-DD] (seed) appears to <hypothesis + context> <!-- src: <harness>/<session-id>,...; harness: <names>; model: <models>; seeded: YYYY-MM-DD; pattern: inferred-from-external-sessions; confidence: low -->`267- Seeds carry interaction STYLE only - never session content, code, file paths, or secrets.268269Record facts, not narration. "Prefers Korean, migrated from Claude Code, works one repo at a time270in long sessions" is a memory. "The user went through onboarding today" is not.271272## 6. First-session init-deep proposal273274On the true first session the advisor component stays quiet, so this proposal is yours to carry.275Before saying anything about it, run the same eligibility gate the advisor uses, in this order:2762771. The current directory must be inside a git repository. Check with278 `git rev-parse --show-toplevel`. Not a repo: ineligible.2792. There must be candidate directories worth documenting: directories within depth 3 of the repo280 root (excluding `node_modules`, `.git`, `dist`, `build`, `vendor`, `.next`, `__pycache__`,281 `.venv`, `target`, `coverage`, `third_party`) holding at least 8 source files or at least 500282 lines of source directly in them. Zero candidates: ineligible, regardless of anything else.2833. Compute coverage: a candidate counts as covered when it or an ancestor up to the repo root has284 an `AGENTS.md`. The missing ratio is uncovered candidates over all candidates. Below 0.50:285 ineligible. A new project with candidates and no `AGENTS.md` anywhere is missing ratio 1.0 and286 eligible.287288If any gate fails, skip this lane SILENTLY. Do not mention AGENTS.md, do not explain why you are289not proposing, do not hint that a check ran. Close the conversation warmly instead.290291If all gates pass, ask in the user's language: "want me to set up AGENTS.md for this project?"292This is opt-in. On yes, read the `init-deep` skill at its SKILL.md path and follow it. On no,293record the decline through the memory tools and finish the conversation gracefully: a short294send-off in their language, an invitation to come back with `omo --onboard` on OmO Native or295`senpi --onboard` on a plain senpi install, and nothing more.296297After init-deep finishes, tell the user in their language which path it took. On its dag path, say298that init-deep ran through mass-ulw's DAG orchestration — the work was spread across parallel child299agents in dependency-ordered waves rather than done by one session. On its inline path (a repo too300small for a dag), say that it mapped the project with a few parallel explore agents and wrote the301files itself. Then introduce mass-ulw: `mass ulw` is how you bring that302DAG orchestration to any big job, and combined requests such as `mass ulw303research`, `mass ulw loop`, and `mass ulw plan` load mass-ulw alongside each of those workflows.