The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
Document Senpi (oh-my-openagent) support
Claudec8c3469e4e00
diff --git a/CLAUDE.md b/CLAUDE.mdindex 848cf9e1..d0ee2d9a 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -42,6 +42,7 @@ Supported runtime surfaces today:- Pi hook telemetry through a Beacon-managed local extension (`~/.pi/agent/extensions/beacon.ts`, or `.pi/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands including operator `!` commands, file reads/creates/edits with the unified patch, agent reasoning from assistant thinking parts, and token usage/cost. The extension subscribes to seven Pi event types and ignores the streaming and provider internals. Approval decisions are not exposed by Pi's extension API -- its `tool_call` handler can block, but that is an extension deciding rather than an operator being asked -- and are not synthesized, matching the Cline decision.- Oh My Pi (`omp`) hook telemetry through a Beacon-managed local extension (`~/.omp/agent/extensions/beacon.ts`, or `.omp/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, operator approval decisions, commands including operator `!` and `$` Python commands, file reads/creates/edits with the unified patch, MCP tool activity, agent reasoning, and token usage/cost. Oh My Pi is a fork of pi-mono and kept Pi's event payload shapes, so the two share one mapper (`cli/beacon-hooks/cmd/pi_family.go`) but never share identity: separate harness names, separate extension markers, separate install directories. Unlike Pi and Cline it does expose real operator approval decisions (`tool_approval_requested`/`tool_approval_resolved`), so those are recorded as `observed` approvals rather than withheld -- Beacon still never synthesizes one from a blocking `tool_call` handler. Those events carry no tool arguments, so the extension remembers each `tool_call`'s input by `toolCallId` and attaches it to the approval; without it the approval rules, which all match on `command.command` or `file.path`, could not read Oh My Pi approvals at all. The user-level install path honors `PI_CODING_AGENT_DIR` and `PI_CONFIG_DIR`; the project path is always `.omp/extensions`. `mcp_notification` is deliberately not subscribed to.- Prime Agent (Prime Intellect) hook telemetry through a Beacon-managed local extension (`~/.prime/agent/extensions/beacon.ts`, or `.prime/agent/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands, file edits with the unified patch, agent reasoning, and token usage/cost. Prime Agent is the other hard fork of pi-mono, so it shares the `pi_family.go` mapper with Pi and Oh My Pi and never shares their identity: separate harness name (`prime_agent`), separate extension marker, separate install directory. Its subscription list is Pi's exactly, and that is a finding rather than a copy -- it has no `user_python` (its operator surface is `!` alone) and no approval event at all, so approvals are not synthesized, matching the Pi, Cline and fx decision. What is different is its single-tool design: the only default tool is `ipython`, a persistent Python kernel through which the agent reads files, writes files and runs shell commands via `bash()`, so a cell is recorded as `command.executed` with the code in `command.command` and a Python marker in `raw` -- filing it under `tool.completed` would hide essentially every action the agent took from the command-scoped rules. A cell's result carries its captured streams as `command.output`, the runtime's own duration and status (`ok`/`error`/`aborted`; an interrupted cell is not a failed one), and its exception class; no exit code is invented, because a Python cell has none. The diffs the kernel streams for files it rewrote become one `file.modified` each, built with `FromEditFragments` because the pair is a replaced span rather than the file before and after. Two path details are the runtime's own: its config directory name is the two-segment literal `.prime/agent`, joined under the working directory as well as the home directory, so its *project* scope keeps the `agent` segment Pi's and Oh My Pi's drop; and its agent-directory override is `PRIME_AGENT_CODING_AGENT_DIR`, derived from its own package name, so `PI_CODING_AGENT_DIR` is deliberately not honored. MCP is not separately attributed and cannot be: consistent with the single-tool design, Prime Agent does not expose MCP servers as agent tools -- each integration is a Python skill package the model imports and calls from inside the kernel -- so an MCP call arrives as part of a cell's code rather than as an `mcp.tool_invoked` event.+- Senpi (`omo`), the standalone edition of oh-my-openagent (OMO), hook telemetry through a Beacon-managed local extension (`~/.omo/agent/extensions/beacon.ts`, or `.omo/agent/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands, file activity with the unified patch, agent reasoning, and token usage/cost. oh-my-openagent ships three editions -- Ultimate (an OpenCode plugin), Light (a Codex CLI plugin), and Senpi (a standalone CLI) -- and only Senpi is a genuinely new, previously-uncaptured runtime: the other two ride hosts Beacon already observes (`opencode`, `codex`), so their activity already flows through those existing integrations rather than needing a fourth editor-specific mapper here. Senpi is itself an in-flight fork of pi-mono (`code-yeongyu/senpi`, upstream `badlogic/pi-mono`) that OMO brands and bundles its own extension into, so it shares the `pi_family.go` mapper with Pi, Oh My Pi and Prime Agent and never shares their identity: separate harness name (`omo_senpi`), separate extension marker, separate install directory. Its subscription list is Pi's exactly -- it kept pi-mono's ordinary `bash`/`read`/`edit`/`write`/`grep`/`find`/`ls` tool set rather than Prime Agent's single-kernel design, so its telemetry shape looks like Pi's and Oh My Pi's rather than Prime Agent's. It has no `user_python` and no approval event at all -- its `tool_call` handler can block, but that is an extension deciding, and its permission-system builtin owns the real approval prompt without publishing it as an extension event -- so approvals are not synthesized, matching the Pi, Prime Agent and Cline decision. Senpi's own `ExtensionEvent` surface is larger than Pi's (`tool_execution_start`/`tool_execution_end`, `turn_start`/`turn_end`, `agent_start`/`agent_end`/`agent_settled`, `model_select`, and more), but none of those additions describe an agent action `tool_call`/`tool_result` do not already cover, so they are deliberately left unsubscribed rather than adding a second, thinner tool-lifecycle signal beside the one already recorded for every Pi-family runtime. Two path details are the runtime's own: its config directory name for this brand is `.omo`, and its own directory resolver joins the `agent` segment under the working directory as well as the home directory, so its *project* scope keeps the segment Pi's and Oh My Pi's drop, the same shape Prime Agent uses; and its agent-directory override is `OMO_CODING_AGENT_DIR`, falling back to the legacy `SENPI_CODING_AGENT_DIR` and then `PI_CODING_AGENT_DIR` in the same order Senpi's own brand profile reads them, rather than only the newest of the three. The harness name is `omo_senpi` rather than bare `omo` because OMO's other two editions exist and are not observed through this extension; `NormalizeHarnessName` deliberately keeps bare `senpi` and `oh-my-openagent` unmapped for the same reason -- plain Senpi is a separately installable engine, and `oh-my-openagent` also names the OpenCode and Codex CLI editions.- Muse Code (Meta) hook telemetry through a Beacon-owned managed hooks file (`$XDG_CONFIG_HOME/muse/beacon-endpoint-hooks.json`, else `~/.config/muse/...`) that Muse's own `settings.json` points at with the `managed_hooks_path` key. Covers session start, prompts, tool lifecycle, operator approval decisions from `PermissionRequest`, subagent start/stop, context compaction, commands, and file activity. Muse Spark is the model and Muse Code is the agent: the harness is `muse_code`, and Muse Spark spellings are deliberately unmapped in `NormalizeHarnessName` so a model id cannot masquerade as the runtime. `PreLLMCall`/`PostLLMCall` are deliberately not subscribed to -- both carry the full `messages` array and tool schemas on every model call, and `PostLLMCall` fires per response chunk. Not collected, because Muse exposes none of it on a hook: token usage/cost, a session-end event, and subagent-to-parent correlation. Muse publishes no hook API, so the contract is reverse-engineered from a shipped build and a bad hooks file is rejected in total silence -- which is why the installer's emitted shape and the payload readers are both pinned by tests. Implementation lives in `cli/beacon/internal/endpoint/hooks/muse.go` and the `muse` platform branches in `cli/beacon-hooks/cmd`.- OpenHands (All Hands) hook telemetry through the runtime's own `.openhands/hooks.json`, which Beacon merges its six commands into rather than owning. Covers session start and end, prompts, pre-tool and post-tool activity, commands with exit code and output, file reads and edits, MCP tool calls, and failed tools. The harness is `openhands`; OpenHands LM spellings are deliberately unmapped in `NormalizeHarnessName` so a model id cannot masquerade as the runtime. OpenHands rides the shared hook subcommands rather than getting a mapper of its own, because its six events line up one for one with them; the runtime-specific readers live in `cli/beacon-hooks/cmd/openhands.go` and the installer in `cli/beacon/internal/endpoint/hooks/openhands.go`. File diffs come from the observation's `old_content`/`new_content` rather than from the edit instruction, so they describe what landed on disk; one `apply_patch` call becomes one `file.modified` per changed file. Approval decisions are not exposed by OpenHands' hooks and are not synthesized, matching the Cline, Pi and fx decision. Not collected, because OpenHands exposes none of it on a hook: token usage and cost, a per-call tool id, and assistant response text. The verbatim payload is deliberately not retained under `raw`: its only unhoused field is `metadata`, which is empty on five of six events and constant on the sixth. `hooks.json` has a closed schema that rejects silently -- unknown top-level keys are fatal, a legacy `{"hooks": {...}}` wrapper replaces the whole document, and naming one event in both snake_case and PascalCase takes the file down -- so the installer refuses a file that already breaks one of those, and both the emitted shape and the payload readers are pinned by tests. Both scopes are real, but project scope is the one every host reads: the loader takes the first hooks file it finds rather than merging, and the agent server behind the CLI and the GUI reads only the project file.- Kiro (AWS) hook telemetry through a Beacon-owned hook file in the directory Kiro scans (`.kiro/hooks/beacon-endpoint.json` at project scope, `$KIRO_HOME`/`~/.kiro/hooks/` at user scope). Covers session start, prompts, pre-tool and post-tool activity, commands with output, file reads and edits, MCP tool calls, failed tools, and the agent's final response from `Stop`'s `assistant_response` as an `agent.message`. The harness is `kiro` -- one name for the IDE and the CLI, because they are one harness reading one hooks directory. Kiro rides the shared hook subcommands: its envelope is spelled exactly as Claude Code's (`hook_event_name`, `cwd`, `session_id`, `tool_name`, `tool_input`, `tool_response`, `prompt`), so `cli/beacon-hooks/cmd/kiro.go` holds no envelope readers at all -- only the tool taxonomy, the `operations`-array path reader, MCP `@server/tool` detection, and the write-`command` guard. Kiro publishes its tool names and not its tool argument schemas, so classification is keyed on names and the diff builder reads both the Amazon Q lineage spellings (`file_text`, `old_str`, `new_str`) and the ecosystem ones, returning no diff rather than a wrong one when neither resolves. Two contract details are load-bearing and easy to get wrong: hook stdout is *added to the agent's context* on `SessionStart` and `UserPromptSubmit`, so Beacon writes nothing to stdout on this platform (`hookStdoutIsConsumedAsAgentContext`); and a block is exit code 2 with the reason on stderr rather than a JSON object, which is why the policy seam's deny is a `policyDenial` carrying an exit code. Timeouts are seconds and `0` means no timeout at all, so every trigger carries an explicit value. Beacon owns one filename in a directory Kiro loads whole, so the installer never reads another file and refuses rather than overwriting one it did not write. Approval decisions are not exposed by Kiro's hooks and are not synthesized -- Kiro does ask the operator through `permissions.yaml` and a trust picker, and `PreToolUse` fires identically whether or not it will, so an inferred approval would claim a decision precisely where none was made. Not subscribed to: `PostFileCreate`/`PostFileSave`/`PostFileDelete`, which duplicate `PostToolUse` for the same write; `PreTaskExec`/`PostTaskExec`, whose stdin payload Kiro does not document; and `Manual`. Not collected, because Kiro exposes none of it on a hook: token usage and cost, a per-call tool id, and a session-end event. Implementation lives in `cli/beacon-hooks/cmd/kiro.go` and `cli/beacon/internal/endpoint/hooks/kiro.go`.diff --git a/README.md b/README.mdindex da472e92..dc682c51 100644--- a/README.md+++ b/README.md@@ -180,6 +180,7 @@ for the full breakdown by surface.| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/pi-agent.png" alt="" width="16"> | [Pi](https://docs.asymptotelabs.ai/runtimes/pi) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/prime-agent.png" alt="" width="16"> | [Prime Agent](https://docs.asymptotelabs.ai/runtimes/prime-agent) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/qwen-code.png" alt="" width="16"> | [Qwen Code](https://docs.asymptotelabs.ai/runtimes/qwen-code) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – | – |+| <img src="https://www.google.com/s2/favicons?domain=github.com&sz=32" alt="" width="16"> | [Senpi](https://docs.asymptotelabs.ai/runtimes/senpi) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/visual-studio-code.png" alt="" width="16"> | [VS Code](https://docs.asymptotelabs.ai/cli/supported-runtimes-vscode) | OTLP + hooks | ✅ | ✅ | ✅ | ~ | ~ | – | ~ | – |#### Browser Chatdiff --git a/docs/docs.json b/docs/docs.jsonindex 53e2b6e9..3e106c81 100644--- a/docs/docs.json+++ b/docs/docs.json@@ -157,6 +157,7 @@"runtimes/pi","runtimes/prime-agent","runtimes/qwen-code",+ "runtimes/senpi","runtimes/vscode"]},diff --git a/docs/runtimes/index.mdx b/docs/runtimes/index.mdxindex 9bbf1372..1e3d5633 100644--- a/docs/runtimes/index.mdx+++ b/docs/runtimes/index.mdx@@ -41,6 +41,7 @@ These integrations are grouped by where the agent runs and how telemetry is coll| [Pi](/runtimes/pi) | Managed extension hooks | Session lifecycle, prompts, tool lifecycle, commands including operator `!` commands, file reads and edits with the unified patch, agent reasoning, and token usage || [Prime Agent](/runtimes/prime-agent) | Managed extension hooks | Session lifecycle, prompts, tool lifecycle, commands including each `ipython` kernel cell and operator `!` commands, file edits with the unified patch, agent reasoning, and token usage. No approval decisions, because Prime Agent exposes none; MCP calls are not separately attributed, because it does not expose MCP as agent tools || [Qwen Code](/runtimes/qwen-code) | Native hooks | Session, prompt, pre-tool, post-tool, failed tool, permission request, subagent, stop, session-end, command, and file telemetry |+| [Senpi](/runtimes/senpi) | Managed extension hooks | Session lifecycle, prompts, tool lifecycle, commands including operator `!` commands, file reads and edits with the unified patch, agent reasoning, and token usage. The standalone `omo` edition of oh-my-openagent; its OpenCode and Codex CLI editions ride the existing OpenCode and Codex CLI integrations instead. No approval decisions, because Senpi exposes none through its extension API || [VS Code](/runtimes/vscode) | Copilot Chat OTel plus optional preview hooks | Copilot session, prompt, model, and tool activity through OTel; optional hooks for extra lifecycle and cross-agent detail |One row in that table is not a hook or OTLP integration. [fx](/runtimes/vercel-fx) exposes no hook, plugin, or OpenTelemetry surface at all, so Asymptote reads the session records fx commits to disk; every fx event is marked `harness.collection_method=poll`, meaning it was read after the turn was committed rather than observed as the agent worked, and nothing on that path can hold or deny a tool call.diff --git a/docs/runtimes/pi.mdx b/docs/runtimes/pi.mdxindex ac77d2b8..01908985 100644--- a/docs/runtimes/pi.mdx+++ b/docs/runtimes/pi.mdx@@ -8,7 +8,7 @@ description: "Asymptote support details for Pi endpoint telemetry"Asymptote supports [Pi](https://pi.dev/) through a managed local extension.<Note>-Looking for [Oh My Pi](/runtimes/oh-my-pi) (`omp`)? It is a fork of Pi, supported separately and recorded under its own harness name. Unlike Pi, it reports operator approval decisions.+Looking for [Oh My Pi](/runtimes/oh-my-pi) (`omp`), [Prime Agent](/runtimes/prime-agent), or [Senpi](/runtimes/senpi) (`omo`, the standalone edition of oh-my-openagent)? All three are forks of Pi, supported separately and recorded under their own harness names. Unlike Pi, Oh My Pi reports operator approval decisions.</Note>Pi fits neither of Asymptote's two usual integration shapes. It has no hooks configuration file to merge a managed hook block into, and no OpenTelemetry support to point at the local collector. Its documented observation surface is the TypeScript extension API, so the integration is extension-shaped: one Asymptote-owned extension file forwards runtime events to `beacon-hooks`, the same shape as the OpenCode and Cline plugins.diff --git a/docs/runtimes/prime-agent.mdx b/docs/runtimes/prime-agent.mdxindex 1d7bf262..cd2af866 100644--- a/docs/runtimes/prime-agent.mdx+++ b/docs/runtimes/prime-agent.mdx@@ -8,7 +8,7 @@ description: "Asymptote support details for Prime Agent (Prime Intellect) endpoiAsymptote supports [Prime Agent](https://github.com/PrimeIntellect-ai/prime-agent), Prime Intellect's coding and research harness, through a managed local extension.<Note>-Prime Agent is a hard fork of [pi-mono](https://github.com/badlogic/pi-mono), as [Oh My Pi](/runtimes/oh-my-pi) is. All three are supported separately and recorded under their own harness names, because they are separately installed products that one machine can run side by side.+Prime Agent is a hard fork of [pi-mono](https://github.com/badlogic/pi-mono), as [Oh My Pi](/runtimes/oh-my-pi) and [Senpi](/runtimes/senpi) are. All four are supported separately and recorded under their own harness names, because they are separately installed products that one machine can run side by side.</Note>Prime Agent fits neither of Asymptote's two usual integration shapes. It has no hooks configuration file to merge a managed hook block into, and no OpenTelemetry export to point at the local collector. Its documented observation surface is the TypeScript extension API it inherited from Pi, so the integration is extension-shaped: one Asymptote-owned extension file forwards runtime events to `beacon-hooks`, the same shape as the [Pi](/runtimes/pi), [Oh My Pi](/runtimes/oh-my-pi), [OpenCode](/cli/supported-runtimes-opencode) and [Cline](/cli/supported-runtimes-cline) integrations.diff --git a/docs/runtimes/senpi.mdx b/docs/runtimes/senpi.mdxnew file mode 100644index 00000000..15f9ee35--- /dev/null+++ b/docs/runtimes/senpi.mdx@@ -0,0 +1,154 @@+---+title: "Senpi"+description: "Asymptote support details for the Senpi standalone edition of oh-my-openagent"+---++## Runtime overview++Asymptote supports [Senpi](https://github.com/code-yeongyu/senpi), the standalone edition of [oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent) (OMO), through a managed local extension.++<Note>+oh-my-openagent ships three editions. **Ultimate** is a plugin riding [OpenCode](/runtimes/opencode); **Light** is a plugin riding [Codex CLI](/runtimes/codex-cli); both already flow through Asymptote's existing OpenCode and Codex CLI integrations, so no separate work is needed for them. **Senpi** is the one edition with no host of its own: an [in-flight fork of pi-mono](https://github.com/badlogic/pi-mono) that OMO brands and bundles its own extension into, distributed as the `omo` command. This page covers that edition only.+</Note>++Senpi is a hard fork of pi-mono, as [Pi](/runtimes/pi), [Oh My Pi](/runtimes/oh-my-pi), and [Prime Agent](/runtimes/prime-agent) are. All four are supported separately and recorded under their own harness names, because they are separately installed products that one machine can run side by side.++Senpi fits neither of Asymptote's two usual integration shapes. It has no hooks configuration file to merge a managed hook block into, and no OpenTelemetry export to point at the local collector. Its documented observation surface is the TypeScript extension API it inherited from Pi, so the integration is extension-shaped: one Asymptote-owned extension file forwards runtime events to `beacon-hooks`, the same shape as the [Pi](/runtimes/pi), [Oh My Pi](/runtimes/oh-my-pi), [Prime Agent](/runtimes/prime-agent), [OpenCode](/runtimes/opencode) and [Cline](/runtimes/cline) integrations.++```bash+beacon endpoint hooks install --harness omo+```++## Kept pi-mono's tool set++Unlike Prime Agent, which routes essentially everything through a single Python kernel, Senpi kept pi-mono's ordinary built-in tools — `bash`, `read`, `edit`, `write`, `grep`, `find`, and `ls` — alongside its own additions. So its telemetry shape looks like Pi's and Oh My Pi's rather than Prime Agent's: a shell command is `command.executed` with a real command line, an edit is `file.modified` with the unified patch, and a read is `file.read`.++Senpi's own ExtensionEvent surface is larger than Pi's — it adds `tool_execution_start`/`tool_execution_end` for execution progress, `turn_start`/`turn_end` for turn bookkeeping, `agent_start`/`agent_end`/`agent_settled`, `model_select`, and more — but none of those describe a new kind of agent action that `tool_call`/`tool_result` do not already cover, so the managed extension leaves them unsubscribed for the same reason it ignores streaming and provider internals on every other pi-mono fork.++## Prerequisites++Before enabling Senpi telemetry, make sure:++- Senpi's `omo` edition is installed (`bun add -g omo-ai@beta`) and available as the `omo` executable, or has a local state directory at `~/.omo/agent`.+- `beacon endpoint install` has run so shared endpoint config and runtime log paths exist.+- Senpi is restarted after install or removal so new sessions load the updated extension.++## Collection path++Asymptote's managed Senpi extension is a single TypeScript file at one of two auto-discovered extension locations:++| Level | Extension path |+|-------|----------------|+| User | `~/.omo/agent/extensions/beacon.ts` |+| Project | `./.omo/agent/extensions/beacon.ts` |++User level is the default, because it follows the operator rather than one checkout. `beacon endpoint discover` reports on the user path only, so a project-level extension does not appear in discovery output.++<Warning>+The project path keeps the `agent` segment, the same shape [Prime Agent](/runtimes/prime-agent) uses. Senpi's config directory name for this brand is `.omo`, and its own directory resolver joins the `agent` segment under the working directory just as it does under the home directory — where [Pi](/runtimes/pi) uses `.pi/extensions` and [Oh My Pi](/runtimes/oh-my-pi) uses `.omp/extensions` at project scope. A file written to `./.omo/extensions/` is never loaded.+</Warning>++`OMO_CODING_AGENT_DIR` replaces the user-level agent directory outright, and Asymptote honors it — including a leading `~`, which the runtime expands before use. When it is unset, Asymptote falls back to `SENPI_CODING_AGENT_DIR` and then `PI_CODING_AGENT_DIR`, the same two legacy prefixes Senpi's own brand profile keeps readable: `SENPI` is the upstream engine's own name, and `PI` is pi-mono's. None of the three moves the project path, because Senpi does not consult any of them there.++Asymptote identifies its own extension file by the marker `beacon-managed-omo-extension:v1`. The version suffix is part of the contract with the extension source: it is what lets a repair recognize a stale file instead of leaving it in place. A `beacon.ts` without the marker belongs to somebody else, so install will not overwrite it and discovery does not report it as Asymptote telemetry. The marker is distinct from Pi's, Oh My Pi's, and Prime Agent's, so a file found at any of the four paths is attributed to the runtime that actually loads it.++Senpi has no OpenTelemetry export for Asymptote to configure, so there is no OTLP path for this runtime.++## Discovery and status++Asymptote detects Senpi through the `omo` executable, and treats the `~/.omo/agent` state directory as an additional signal. Senpi installed through npm into a directory this process did not inherit on `PATH` is not visible as an executable, because a shell alias, a version manager, or a per-project install can all hide it while the state directory is still present. The Pi, Oh My Pi, Prime Agent, OpenCode, Cursor, and Hermes probes use the same fallback.++`senpi` is deliberately not probed for. It is the upstream engine's own binary name, and a machine can have plain, un-OMO'd Senpi installed without oh-my-openagent at all — probing for it here would claim an install this integration did not verify.++```bash title="Show Senpi discovery state"+beacon endpoint discover --all --json+```++Senpi reports as the `omo_senpi` harness with capability `plugin`:++| Telemetry status | Meaning |+|------------------|---------|+| `missing` | No extension file at the user-level managed path |+| `disabled` | A `beacon.ts` exists but carries no Asymptote marker, so it is somebody else's extension sharing the filename |+| `enabled` | Asymptote's managed extension is in place |++An unmarked extension file reports `disabled` rather than `enabled`, because reporting it as enabled would show the runtime as covered while no events arrive.++## Install or configuration support++`beacon endpoint install` prepares shared endpoint config and runtime log paths. The extension is installed separately, because Senpi loads it from the user's own profile rather than from a machine-wide location:++```bash+beacon endpoint hooks install --harness omo # user level (default)+beacon endpoint hooks install --harness omo --level project+beacon endpoint hooks status --harness omo+beacon endpoint hooks uninstall --harness omo+```++`omo`, `omo_senpi`, and `omo-senpi` all resolve to this runtime. Bare `senpi` and `oh-my-openagent` are deliberately not accepted: plain Senpi is a separately installable engine you can run without OMO at all, and `oh-my-openagent` also names OMO's OpenCode and Codex CLI editions, which install through the existing OpenCode and hook-config paths rather than through this extension. Accepting either spelling here would claim a name that belongs to a different install.++Install writes one file and refuses to touch a `beacon.ts` it did not write, so an extension of your own that happens to share the filename is left alone and the install fails loudly rather than replacing it. Uninstall removes only a file carrying this runtime's marker.++`status` reports `installed=false` when the extension exists but points at a hook binary that is no longer there, which happens after a Beacon uninstall, a partly applied update, or a home directory restored onto a different machine. In each case Senpi loads an extension that spawns nothing.++## Telemetry coverage++| Area | Support |+|------|---------|+| Runtime discovery | Supported through executable and `~/.omo/agent` detection, managed extension path, and telemetry status |+| Harness attribution | Supported. `omo`, `omo_senpi`, and `omo-senpi` all normalize to `omo_senpi` |+| Extension install, status, uninstall, and repair | Supported |+| Session lifecycle | Supported. `session.started` and `session.ended`, carrying why the session started or stopped — a fork and a resume both produce a session with history behind it |+| Prompts | Supported. `prompt.submitted`, with whether the input was typed, delivered over RPC, or injected by another extension |+| Tool use | Supported. `tool.invoked` before execution, then `tool.completed` or `tool.failed` |+| Commands | Supported. `command.executed` for the `bash` tool and for commands you run with the `!` prefix, which are marked as operator-initiated |+| File activity | Supported. `file.read`, `file.created`, and `file.modified` for the `read`, `write`, and `edit` tools, the last carrying the unified patch |+| Agent reasoning | Supported. `agent.reasoning` from an assistant message's thinking parts, in the OTel GenAI reasoning-part shape |+| Token usage and cost | Supported. `token.usage` normalized into `gen_ai.usage`, including cache and reasoning tokens and runtime-reported cost |+| Approval decisions | Not available. Senpi exposes no operator approval decision through its extension API. See [Known gaps](#known-gaps) |+| Local JSONL and dashboard | Supported |+| MDM deployment | Supported for the endpoint agent. The Senpi extension installs separately in the logged-in user's context |++Harness names are matched against a closed set of spellings rather than by substring. `omo` is an ordinary three-letter string that could appear inside an unrelated harness attribute, so a substring rule would misattribute sessions that are not Senpi's.++## Data handling++Senpi content is handled like every other runtime. Prompts, command lines, command output, tool arguments, paths, diffs, and reasoning text are retained in local or customer-controlled logs, with local secret redaction and per-string limits applied before writing, and a hash and byte count on each content-bearing event. Events over the 64 KiB limit drop raw and retained content, preserve stable metadata, and set `field_truncated`.++The extension itself sends nothing over the network. It spawns the local `beacon-hooks` binary with a fixed argv and writes the event to its stdin. A send that has not completed in two seconds is abandoned so Beacon cannot stall Senpi's agent loop, and a failure to spawn costs the event rather than the run.++Senpi's own telemetry — the anonymous, PostHog-backed "OmO Native" analytics pipeline documented in its `senpi-telemetry.md` — is unrelated to this integration. It reports only aggregated buckets and counters with no raw content, and Asymptote neither reads from it nor writes to it.++## Known gaps++- **No approval telemetry.** Senpi's `tool_call` event lets an extension block a call, but that is an extension deciding rather than an operator being asked. Its own permission-system builtin owns the real approval prompt without publishing it as an extension event, so Beacon records these as tool activity and writes no approval events. [Pi](/runtimes/pi) and [Prime Agent](/runtimes/prime-agent) work the same way for the same reason; [Oh My Pi](/runtimes/oh-my-pi) is the fork that does report real ones. Detections in `rules/approval-abuse/` do not fire on Senpi activity.+- **No enforcement.** As with every other runtime, enforcement stays behind the optional, off-by-default policy provider seam (`BEACON_POLICY_PROVIDER`), which is not wired to Senpi.+- **Streaming and progress events are not collected.** The extension subscribes to seven of Senpi's event types and ignores the rest — provider request and response internals, streaming message and tool-execution updates, turn bookkeeping, compaction, model-select, and TUI plumbing. Assistant output is recorded once when a message finalizes rather than token by token, so Beacon stays out of the streaming path.+- **The OpenCode and Codex CLI editions are out of scope for this page.** They ride the existing [OpenCode](/runtimes/opencode) and [Codex CLI](/runtimes/codex-cli) integrations rather than this extension, and are not separately attributed as `omo`-branded sessions today.++## Deployment notes++The extension is loaded when Senpi starts, so an install taken while it is running takes effect on the next launch.++Confirm discovery sees the runtime, then generate one Senpi event and check the log:++```bash+/opt/beacon/bin/beacon endpoint discover --all --json+/opt/beacon/bin/beacon endpoint hooks status --harness omo+/opt/beacon/bin/beacon endpoint doctor --system+grep '"name":"omo_senpi"' ~/.beacon/endpoint/logs/runtime.jsonl | tail -3+```++## Related++<Columns cols={3}>+ <Card title="Pi" icon="code" href="/runtimes/pi">+ The upstream runtime Senpi forked, supported through the same extension shape.+ </Card>+ <Card title="Prime Agent" icon="code" href="/runtimes/prime-agent">+ Another pi-mono fork, this one routing everything through a single Python kernel.+ </Card>+ <Card title="Supported agent harnesses" icon="list-check" href="/runtimes">+ Return to the runtime support overview.+ </Card>+</Columns>