better-dsh 0.2.4 → 0.2.5

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

@@ -0,0 +1,35 @@
+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

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

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

@@ -0,0 +1,49 @@
+#!/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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,250 @@
+#!/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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,88 @@
+<!--
+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).