better-dsh 0.2.5 → 0.3.0

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/.tools/omp_pages.txt

@@ -1,35 +0,0 @@
-https://omp.sh/docs
-https://omp.sh/docs/quickstart
-https://omp.sh/docs/using
-https://omp.sh/docs/slash
-https://omp.sh/docs/keybindings
-https://omp.sh/docs/settings
-https://omp.sh/docs/sessions
-https://omp.sh/docs/memory
-https://omp.sh/docs/plan
-https://omp.sh/docs/files
-https://omp.sh/docs/code-intelligence
-https://omp.sh/docs/debugging
-https://omp.sh/docs/editing
-https://omp.sh/docs/subagents
-https://omp.sh/docs/web
-https://omp.sh/docs/github
-https://omp.sh/docs/providers
-https://omp.sh/docs/roles
-https://omp.sh/docs/custom-models
-https://omp.sh/docs/context-files
-https://omp.sh/docs/skills
-https://omp.sh/docs/prompt-templates
-https://omp.sh/docs/hooks
-https://omp.sh/docs/custom-tools
-https://omp.sh/docs/mcp
-https://omp.sh/docs/themes
-https://omp.sh/docs/ttsr
-https://omp.sh/docs/plugins
-https://omp.sh/docs/sdk
-https://omp.sh/docs/rpc
-https://omp.sh/docs/acp
-https://omp.sh/docs/cli
-https://omp.sh/docs/env
-https://omp.sh/docs/session-format
-https://omp.sh/docs/tools

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/.tools/package.json

@@ -1 +0,0 @@
-{ "type": "module" }

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/.tools/pi_convert.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-"""pi.dev docs: convert fetched raw HTML pages to markdown (pi-and-omp/pi/)."""
-import os, re, sys, html
-from bs4 import BeautifulSoup
-from markdownify import markdownify as md
-
-
-def html_to_md(raw: str) -> str:
-    soup = BeautifulSoup(raw, "html.parser")
-    # content container: the article card holds title + prose (pi.dev)
-    main = soup.select_one("section.docs-article-card")
-    if main is None:
-        main = soup.select_one(".docs-main-column")
-    if main is None:
-        main = soup.find("main")
-    if main is None:
-        main = soup.body
-    for sel in ("nav", "aside", "footer", "script", "style", "svg", "button"):
-        for el in main.find_all(sel):
-            el.decompose()
-    # drop decorative leaves: copy-widget text, version badge, page chrome bits
-    for el in main.find_all(True):
-        if el.find_all(True):
-            continue  # only leaves
-        t = el.get_text(strip=True)
-        if t in ("Copied", "copied", "Latest", "Latest·", "·", "Search documentation"):
-            el.decompose()
-    # unwrap syntax-highlight spans inside <pre>; keep plain text lines
-    for pre in main.find_all("pre"):
-        for sp in pre.find_all("span"):
-            sp.unwrap()
-        code = pre.find("code")
-        if code:
-            code.unwrap()
-    out = md(str(main), heading_style="ATX", bullets="-", code_language="")
-    # targeted cleanups for leftover chrome artifacts
-    out = re.sub(r"\[Copied\]\(#[^)]*\)", "", out)
-    out = re.sub(r"^Latest\s*·?\s*$", "", out, flags=re.M)
-    out = re.sub(r"^·\s*$", "", out, flags=re.M)
-    out = re.sub(r"\n{3,}", "\n\n", out)
-    return out.strip() + "\n"
-
-if __name__ == "__main__":
-    src, dst = sys.argv[1], sys.argv[2]
-    raw = open(src, encoding="utf-8", errors="replace").read()
-    out = html_to_md(raw)
-    with open(dst, "w", encoding="utf-8") as f:
-        f.write(out)
-    print("wrote", dst, len(out), "chars")

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/.tools/pi_pages.txt

@@ -1,30 +0,0 @@
-https://pi.dev/docs/latest
-https://pi.dev/docs/latest/compaction
-https://pi.dev/docs/latest/containerization
-https://pi.dev/docs/latest/custom-provider
-https://pi.dev/docs/latest/development
-https://pi.dev/docs/latest/environment-variables
-https://pi.dev/docs/latest/extensions
-https://pi.dev/docs/latest/json
-https://pi.dev/docs/latest/keybindings
-https://pi.dev/docs/latest/llama-cpp
-https://pi.dev/docs/latest/models
-https://pi.dev/docs/latest/packages
-https://pi.dev/docs/latest/prompt-templates
-https://pi.dev/docs/latest/providers
-https://pi.dev/docs/latest/quickstart
-https://pi.dev/docs/latest/rpc
-https://pi.dev/docs/latest/sdk
-https://pi.dev/docs/latest/security
-https://pi.dev/docs/latest/session-format
-https://pi.dev/docs/latest/sessions
-https://pi.dev/docs/latest/settings
-https://pi.dev/docs/latest/shell-aliases
-https://pi.dev/docs/latest/skills
-https://pi.dev/docs/latest/terminal-setup
-https://pi.dev/docs/latest/termux
-https://pi.dev/docs/latest/themes
-https://pi.dev/docs/latest/tmux
-https://pi.dev/docs/latest/tui
-https://pi.dev/docs/latest/usage
-https://pi.dev/docs/latest/windows

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/.tools/serialize_omp.py

@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-"""Serialize omp extracted element trees (omp_extracted.json) to markdown files."""
-import json, os, re, datetime, sys
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-OUT = os.path.join(os.path.dirname(HERE), "omp")   # HERE=pi-and-omp/.tools -> pi-and-omp/omp
-os.makedirs(OUT, exist_ok=True)
-TODAY = "2026-09-06"
-
-WS_RE = re.compile(r"^\s*$")
-
-def children_of(node):
-    """Return list of child tokens (strings/elements) with whitespace-only separators dropped."""
-    ch = node.get("p", {}).get("children") if isinstance(node, dict) else None
-    if ch is None:
-        return []
-    if not isinstance(ch, list):
-        ch = [ch]
-    out = []
-    for x in ch:
-        if isinstance(x, str):
-            if WS_RE.match(x):
-                continue
-            out.append(x)
-        elif isinstance(x, (int, float)):
-            out.append(str(x))
-        elif isinstance(x, dict):
-            out.append(x)
-        else:
-            out.append(str(x))
-    return out
-
-def is_elem(x):
-    return isinstance(x, dict) and "t" in x
-
-def tag(x):
-    return x.get("t") if is_elem(x) else None
-
-def text_of(x):
-    """Plain text of a token or subtree."""
-    if isinstance(x, str):
-        return x
-    if isinstance(x, (int, float)):
-        return str(x)
-    if not is_elem(x):
-        return ""
-    t = tag(x)
-    if t == "br":
-        return "\n"
-    return "".join(text_of(c) for c in children_of(x))
-
-def inline(x):
-    """Markdown inline rendering of a token or subtree."""
-    if isinstance(x, str):
-        return x
-    if isinstance(x, (int, float)):
-        return str(x)
-    if not is_elem(x):
-        return ""
-    t = tag(x)
-    props = x.get("p", {})
-    if t == "br":
-        return "\n"
-    if t == "code":
-        return "`%s`" % text_of(children_of(x)[0]) if children_of(x) else "``"
-    if t == "kbd":
-        return "<kbd>%s</kbd>" % text_of(x)
-    if t == "strong":
-        return "**%s**" % "".join(inline(c) for c in children_of(x))
-    if t == "em":
-        return "*%s*" % "".join(inline(c) for c in children_of(x))
-    if t == "a":
-        href = props.get("href", "")
-        inner = "".join(inline(c) for c in children_of(x))
-        return "[%s](%s)" % (inner, href)
-    # default: recurse inline for unknown inline-ish tags
-    return "".join(inline(c) for c in children_of(x))
-
-def text_of_list(tokens):
-    return "".join(text_of(t) for t in tokens)
-
-def render_table(node):
-    rows = []  # list of list of str (inline cell md)
-    for child in children_of(node):  # thead/tbody/tr
-        ctag = tag(child)
-        if ctag == "thead":
-            for tr in children_of(child):
-                if tag(tr) == "tr":
-                    cells = [inline(c) for c in children_of(tr) if tag(c) == "th"]
-                    rows.append(cells)
-        elif ctag == "tbody":
-            for tr in children_of(child):
-                if tag(tr) == "tr":
-                    cells = [inline(c) for c in children_of(tr) if tag(c) == "td"]
-                    rows.append(cells)
-        elif ctag == "tr":  # loose table without thead
-            cells = [inline(c) for c in children_of(child) if tag(c) in ("td", "th")]
-            rows.append(cells)
-    if not rows:
-        return ""
-    ncol = max(len(r) for r in rows)
-    rows = [r + [""] * (ncol - len(r)) for r in rows]
-    # escape pipes inside cells
-    esc = lambda s: s.replace("|", "\\|").replace("\n", " ")
-    lines = ["| " + " | ".join(esc(c) for c in rows[0]) + " |"]
-    lines.append("| " + " | ".join("---" for _ in range(ncol)) + " |")
-    for r in rows[1:]:
-        lines.append("| " + " | ".join(esc(c) for c in r) + " |")
-    return "\n".join(lines)
-
-def render_list(node, depth=0):
-    ordered = tag(node) == "ol"
-    lines = []
-    items = [c for c in children_of(node) if tag(c) == "li"]
-    num = 1
-    indent = "  " * depth
-    for li in items:
-        marker = ("%d. " % num) if ordered else "- "
-        num += 1
-        toks = children_of(li)
-        # split: leading inline text then optional nested blocks
-        first = ""
-        rest = []
-        for tk in toks:
-            if is_elem(tk) and tag(tk) in ("ul", "ol", "p", "pre", "table"):
-                rest.append(tk)
-            else:
-                first += inline(tk)
-        if first:
-            lines.append(indent + marker + first)
-            # content after a list item paragraph stays aligned
-            for r in rest:
-                if tag(r) in ("ul", "ol"):
-                    lines.append(render_list(r, depth + 1).rstrip("\n"))
-                elif tag(r) == "p":
-                    for sub in children_of(r):
-                        lines.append(indent + "  " + inline(sub))
-                elif tag(r) == "pre":
-                    lines.append(indent + "  " + render_pre(r).replace("\n", "\n" + indent + "  "))
-                elif tag(r) == "table":
-                    lines.append(indent + "  " + render_table(r).replace("\n", "\n" + indent + "  "))
-        else:
-            # li whose content starts with nested list
-            firstmd = "".join(render_list(r, depth + 1).rstrip("\n") for r in rest if tag(r) in ("ul", "ol"))
-            if firstmd:
-                lines.append(indent + marker.rstrip())
-                lines.append(firstmd)
-            else:
-                lines.append(indent + marker)
-    return "\n".join(lines) + "\n"
-
-def render_pre(node):
-    lang = ""
-    code_txt = ""
-    for c in children_of(node):
-        if tag(c) == "code":
-            cls = c.get("p", {}).get("className", "")
-            m = re.match(r"language-([\w+-]+)", cls or "")
-            if m:
-                lang = m.group(1)
-            code_txt = text_of(c)
-            break
-    fence = "```"
-    return "%s%s\n%s\n%s" % (fence, lang, code_txt.rstrip("\n"), fence)
-def render_dl(node):
-    """dt/dd description list -> bold label paragraph + content paragraphs."""
-    out = []
-    cur_label = None
-    for child in children_of(node):
-        if isinstance(child, str):
-            continue
-        t = tag(child)
-        if t == "dt":
-            cur_label = "**" + text_of(child).strip() + "**"
-        elif t == "dd" and cur_label:
-            out.append(cur_label)
-            for c in children_of(child):
-                if isinstance(c, str):
-                    continue
-                ct = tag(c)
-                if ct == "p":
-                    out.append("".join(inline(k) for k in children_of(c)).strip())
-                elif ct == "ul" or ct == "ol":
-                    out.append(render_list(c).rstrip("\n"))
-                elif ct == "pre":
-                    out.append(render_pre(c))
-                else:
-                    out.append(render_block(c).rstrip("\n"))
-            cur_label = None
-    return "\n\n".join(x for x in out if x)
-
-
-def render_block(node):
-    t = tag(node)
-    if t is None:
-        return inline(node)
-    if t == "@@FRAGMENT@@":
-        return "\n\n".join(render_block(c).rstrip("\n") for c in children_of(node))
-    if t in ("h2", "h3", "h4"):
-        return "%s %s" % ("#" * int(t[1]), "".join(inline(c) for c in children_of(node)).strip())
-    if t == "dl":
-        return render_dl(node)
-    if t == "p":
-        return "".join(inline(c) for c in children_of(node)).strip()
-    if t == "pre":
-        return render_pre(node)
-    if t == "ul" or t == "ol":
-        return render_list(node).rstrip("\n")
-    if t == "table":
-        return render_table(node)
-    if t == "blockquote":
-        body = "".join(render_block(c) for c in children_of(node)).strip()
-        return "\n".join("> " + ln for ln in body.split("\n"))
-    if t == "hr":
-        return "---"
-    if t == "li":
-        return inline(node)
-    return "".join(inline(c) for c in children_of(node))
-
-def page_markdown(entry):
-    title = entry.get("title") or ""
-    lede = entry.get("lede") or ""
-    tree = entry.get("tree")
-    parts = []
-    if title:
-        parts.append("# " + title.strip())
-    if lede:
-        parts.append("> " + lede.strip())
-    body = ""
-    if tree:
-        body = render_block(tree)  # tree root is the @@FRAGMENT@@ element
-    parts.append(body)
-    md = "\n\n".join(p.strip("\n") for p in parts if p and p.strip())
-    md = re.sub(r"\n{3,}", "\n\n", md)
-    return md.strip() + "\n"
-
-def slug_to_url(slug):
-    return "https://omp.sh/docs" if slug == "Overview" else "https://omp.sh/docs/" + slug
-
-if __name__ == "__main__":
-    data = json.load(open(os.path.join(HERE, "omp_extracted.json"), encoding="utf-8"))
-    n = 0
-    for slug, entry in sorted(data.items()):
-        url = slug_to_url(slug)
-        md = page_markdown(entry)
-        header = "<!--\nsource: %s\nfetched: %s\n-->\n\n" % (url, TODAY)
-        with open(os.path.join(OUT, slug + ".md"), "w", encoding="utf-8") as f:
-            f.write(header + md)
-        n += 1
-    print("wrote", n, "markdown files to", OUT)

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/README.md

@@ -1,80 +0,0 @@
-# pi-and-omp — pi.dev & omp.sh official docs (fetch stage)
-
-Grouped together because **omp (oh-my-pi) is pi-based** — the projects share lineage and an
-overlapping vocabulary (`sdk`, `rpc`, `session-format`, `sessions`, `settings`, `keybindings`,
-`skills`, `prompt-templates`, `providers`, …). But their **exposed SDKs are not the same
-surface**, so each project is fetched independently into its own sub-directory:
-
-- **`pi/`**  ← https://pi.dev/docs/latest  (Pi, by Earendil Inc.)  — **30 pages**
-- **`omp/`** ← https://omp.sh/docs        (omp, by Stencil)       — **56 pages**
-
-Proof that the "related but different" reading is right: omp's SDK (`@oh-my-pi/pi-coding-agent`,
-Bun-only) mirrors pi's SDK API (`createAgentSession`, `SessionManager.inMemory`, stream events
-like `message_update`) — omp renamed/reforked pi's package — yet omp's own doc surface diverges
-with pages pi does not have (`acp`, `plugins`, `marketplace`, `hooks`, `custom-tools`, `modes`,
-`ttsr`, …), and pi keeps pages omp lacks (`termux`, `tmux`, `llama-cpp`, `compaction`,
-`packages`, …). Distill each project from its own directory.
-
-## Method
-
-- **pi.dev** — server-rendered site. The full set under `/docs/*` was BFS-crawled (queue drained
-  to zero → 30 pages). Each page was fetched as raw HTML and converted locally to Markdown
-  (BeautifulSoup + markdownify on the `section.docs-article-card` article container).
-- **omp.sh** — client-rendered SPA (every path returns only a JS shell; `llms.txt`/`sitemap.xml`
-  are not a content source — the sitemap is **stale, listing only 35 of 56 pages**). The app's
-  own router table and compiled page chunks carry the authoritative set: **56 docs pages**
-  (55 topics + the `/docs` Overview). Content was recovered from the site's compiled MDX chunks:
-  each page's element tree was materialized with stub runtimes (record-only `jsx-runtime`) under
-  Node, then serialized to Markdown. This preserves internal links (`[Providers](/docs/providers)`),
-  fenced code with languages, tables, `<kbd>`, and definition lists — higher fidelity than a
-  headless-browser text render.
-- Every file starts with an HTML comment header: `<!-- source: <URL>  fetched: 2026-09-06 -->`.
-
-## Layout
-
-```
-pi-and-omp/
-├── README.md
-├── .tools/                        # fetch tooling + provenance (re-run recipes)
-│   ├── pi_pages.txt  omp_pages.txt           # canonical URL inventories (30 / 56)
-│   ├── pi_convert.py  fetch_pi.py            # pi.dev: html -> markdown
-│   ├── extract_omp.mjs  serialize_omp.py     # omp.sh: chunks -> element trees -> markdown
-│   ├── jsx-runtime-BHwPObl3.js  MdxPage-CTY7atqe.js  package.json   # record-only stubs
-│   └── omp_extracted.json                    # element trees (source of truth for omp/)
-├── pi/                            # 30 markdown files, one per /docs/latest page
-│   ├── index.md  quickstart.md  usage.md  development.md  models.md  providers.md
-│   ├── custom-provider.md  settings.md  keybindings.md  sessions.md  session-format.md
-│   ├── compaction.md  containerization.md  environment-variables.md  extensions.md
-│   ├── json.md  llama-cpp.md  packages.md  prompt-templates.md  rpc.md  sdk.md
-│   ├── security.md  shell-aliases.md  skills.md  terminal-setup.md  termux.md
-│   ├── themes.md  tmux.md  tui.md  windows.md
-│   └── pages.txt                   # 30 canonical URLs
-└── omp/                           # 56 markdown files (55 topic slugs + Overview for /docs)
-    ├── Overview.md  quickstart.md  using.md  slash.md  keybindings.md  settings.md  modes.md
-    ├── sessions.md  session-tree.md  memory.md  compaction.md  plan.md  goal.md  handoff.md
-    ├── files.md  code-intelligence.md  debugging.md  editing.md  review.md  commit.md
-    ├── security.md  subagents.md  advisor.md  vibe.md  collab.md  web.md  computer.md
-    ├── github.md  providers.md  roles.md  agents-and-roles.md  custom-models.md  prewalk.md
-    ├── context-files.md  skills.md  prompt-templates.md  magic-keywords.md  hooks.md
-    ├── custom-tools.md  subagent-authoring.md  mcp.md  mcp-authoring.md  themes.md  ttsr.md
-    ├── plugins.md  extension-authoring.md  marketplace.md  sdk.md  rpc.md  acp.md  cli.md
-    ├── env.md  secrets.md  approvals.md  session-format.md  tools.md
-    └── pages.txt                   # 56 canonical URLs
-```
-
-## Completeness
-
-- **pi.dev**: 30/30 fetched, 0 failures — full reachable `/docs/*` set.
-- **omp.sh**: 56/56 pages (55 router topics + Overview) recovered from the compiled chunks;
-  every page mapped to its router entry, none missing. Fences balanced, no empty files, no
-  renderer-chrome artifacts.
-
-## Provenance / re-run notes
-
-- `pi/` and `omp/` are derived from live site snapshots fetched 2026-09-06. If the upstream
-  sites change, re-run the recipes in `.tools/`:
-  - pi: re-crawl `/docs/*`, then `fetch_pi.py` (needs `markdownify` + `beautifulsoup4`).
-  - omp: re-download the six `assets/*.js` page chunks (names are version-hashed), place them
-    next to `extract_omp.mjs`, ensure the stub filenames match the current `jsx-runtime` /
-    `MdxPage` hashes, run `node extract_omp.mjs`, then `python3 serialize_omp.py`.
-- `.tools/omp_extracted.json` lets `serialize_omp.py` rebuild `omp/*.md` without re-downloading.

package/docs/80_upstream-docs-and-skills/dsh-dev-skill/pi-and-omp/omp/Overview.md

@@ -1,88 +0,0 @@
-<!--
-source: https://omp.sh/docs
-fetched: 2026-09-06
--->
-
-# Overview
-
-> Bring a real software task to your terminal. omp can inspect the repository, change code, run your development tools, and keep the work in a resumable session.
-
-## Start with a real task
-
-omp is a terminal-first coding agent for work that takes more than a pasted snippet. Run it inside a project, describe the outcome you want, and it can investigate the codebase, edit files, run commands, and explain the result without making you shuttle context between an editor, a shell, and a chat window.
-
-If this is your first visit, begin with the [Quickstart](/docs/quickstart). It covers installation and provider authentication. Then open a project and start an interactive session:
-
-```sh
-cd path/to/your-project
-omp
-```
-
-Give it a concrete task in ordinary language:
-
-```text
-Find why the user-session test hangs, fix the root cause, run the smallest relevant test, and explain what changed.
-```
-
-omp streams its response and shows file operations, commands, and other work as compact cards. Press <kbd>Ctrl</kbd>+<kbd>O</kbd> to expand a card and inspect its full output or diff. You can follow up, correct course, or press <kbd>Escape</kbd> to stop the active turn.
-
-A good first task has a clear goal and a way to verify it. If you only want an explanation, say “investigate, but do not edit.” For a large or risky change, start with [Plan mode](/docs/plan) so you can review the approach before implementation.
-
-## Why use omp
-
-Software work rarely ends at generating code. A useful change may require finding the right files, understanding existing conventions, renaming symbols safely, running a focused test, inspecting a live process, or checking a pull request. omp keeps that loop in one session and works with the repository and development environment already on your machine.
-
-It is a good fit for developers who:
-
-- prefer to direct and review work from a terminal;
-- work in existing repositories where context and verification matter;
-- want to choose their own model providers instead of being tied to one;
-- need a short investigation today and a resumable, multi-step change tomorrow; or
-- want one workflow that can grow from a single agent to planning, parallel work, and shared sessions.
-
-omp can modify files and run commands in your environment, so review its work as you would a teammate’s change and use [approval controls](/docs/approvals) for sensitive projects. Prompts and relevant context are sent to the model provider you select; integrations may also contact their corresponding services.
-
-## What you notice as a user
-
-**One loop from request to verification**
-
-Ask for an outcome rather than copying code into a browser. omp can combine repository search, edits, commands, [language-aware code intelligence](/docs/code-intelligence), [live debugging](/docs/debugging), [browser work](/docs/web), and [GitHub context](/docs/github) when the task calls for them. Its work remains visible in the session.
-
-**Your choice of models**
-
-Connect API-key, OAuth, subscription, gateway, or local providers, then choose models for everyday work, fast tasks, deeper reasoning, and planning. Start with [Providers](/docs/providers); use [Settings](/docs/settings) when you want to tune routing or behavior.
-
-**Work you can leave and return to**
-
-Sessions are saved locally by default. Resume earlier work, branch when you want to try a different direction without discarding history, or share a session when someone else needs the context. See [Sessions](/docs/sessions) for the user controls.
-
-**Planning before implementation**
-
-Run `/plan` for a separate planning turn, refine the proposal, and decide when to execute it. This is useful for migrations, architectural changes, and work where the order of operations matters. See [Plan mode](/docs/plan).
-
-**Parallel work when the task actually splits**
-
-Ask omp to delegate independent parts of a task to subagents, such as auditing several packages at once. You can watch their progress and steer them while they work. See [Subagents](/docs/subagents).
-
-**A workflow you can extend**
-
-Project rules and [skills](/docs/skills) teach omp how your team works. Extensions and [MCP servers](/docs/mcp) can add public integrations when the built-in capabilities are not enough.
-
-## A practical learning path
-
-1. **Get one prompt working:**[Quickstart](/docs/quickstart) covers installation, authentication, terminal setup, and your first session.
-2. **Learn the interactive controls:**[Using omp](/docs/using) explains the screen, editor, message queue, and one-shot mode.
-3. **Keep useful work:**[Sessions](/docs/sessions) covers resume, branch, fork, export, and sharing.
-4. **Choose the next guide for your goal:**
-
-| You want to… | Go to… |
-| --- | --- |
-| Control a running session efficiently | [Slash commands](/docs/slash) and [Keybindings](/docs/keybindings) |
-| Connect or change models | [Providers](/docs/providers) and [Settings](/docs/settings) |
-| Design a large change before touching code | [Plan mode](/docs/plan) |
-| Investigate symbols, diagnostics, or a live process | [Code intelligence](/docs/code-intelligence) and [Debugging](/docs/debugging) |
-| Split independent work or share a live session | [Subagents](/docs/subagents) and [Collab](/docs/collab) |
-| Use omp from scripts or another program | [CLI reference](/docs/cli), [RPC mode](/docs/rpc), or the [SDK](/docs/sdk) |
-| Add team instructions or integrations | [Skills](/docs/skills), [MCP](/docs/mcp), and [authoring extensions](/docs/extension-authoring) |
-
-Not sure which branch to take? Complete the [Quickstart](/docs/quickstart), run one small task in a repository you know, and continue with [Using omp](/docs/using).