@linxiraos/pi Mnemopi

GitHub Actions

Local SQLite memory engine for Zeta agents

Add to Cursor Add to VS Code Run on PlugMCP

1{2  "mcpServers": {3    "linxiraos-pi-mnemopi": {4      "command": "npx",5      "args": [6        "-y",7        "@linxiraos/[email protected]"8      ]9    }10  }11}

.cursor/mcp.jsonMCP server

Transport: stdio
Status: Local

Power your agent

Add this server

The publisher's own command. Not a PlugMCP endpoint.

Add to Cursor Add to VS Code Run on PlugMCP

Host a copy with our keys and logs.

Local command

npx -y @linxiraos/[email protected]

Claude Code has no install link for a local command. Copy the command below and run it in a terminal.

shClaude Code

1claude mcp add linxiraos-pi-mnemopi -- npx -y @linxiraos/pi-mnemopi@1.4.3

Run in a terminal.

jsonClaude Desktop

1{2  "mcpServers": {3    "linxiraos-pi-mnemopi": {4      "command": "npx",5      "args": [6        "-y",7        "@linxiraos/[email protected]"8      ]9    }10  }11}

claude_desktop_config.json

Local · npmPublisher installStep-by-step: add this in Claude

Remote URL or a command on your machine? How the two installs differ

Run on PlugMCP

Host a copy with our keys and logs.

A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.

Launch

Server facts

Local

Transport: stdio
Version: 1.4.3
Last checked: 2026-10-28

Stars: —
Tools: —
Uptime: —

Tools

No tool list yet. Remote servers get one after the first health check.

FAQ

Questions

How do I install @linxiraos/pi Mnemopi?

Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.

Does @linxiraos/pi Mnemopi need an API key?

No required environment variable is listed on this record.

What transport does @linxiraos/pi Mnemopi use?

@linxiraos/pi Mnemopi runs locally over stdio.

When was @linxiraos/pi Mnemopi last checked?

Last checked 2026-10-28. Local SQLite memory engine for Zeta agents

From the publisher

Documentation

English · 简体中文

Zeta is a terminal workbench suite: one workspace that tiles real terminals, plus the tools that live inside them — a coding agent, an editor, a terminal IDE, and a file manager. It is an agent development environment (ADE), not an IDE with a chat pane: the session is the unit of work and every pane is a surface the agent can use. Linux is the primary platform; Windows x64 is supported; there is no macOS build.

The Suite

Command	Package	What it is
`zetawork`	`@linxiraos/main`	The workspace: nested-terminal workbench (Rust)
`zeta`	`@linxiraos/main`	Suite index — a bare `zeta` prints the help/command map
`zetacode`	`@linxiraos/zeta`	Coding agent CLI
`zetaide`	`@linxiraos/ide`	Terminal IDE (TermIDE, vendored Rust)

Every command launches standalone with its own --help; a bare zeta prints the suite index. The workbench is the unified entry: its coding/IDE panes hand off to zetacode and zetaide, and its editor pane is built in (the @linxiraos/editor package name and its publish chain are reserved for that pane's binary payload; nothing is published under it today and it declares no command of its own).

Repository Map

The product has four layers and one rule: the runtime depends on nothing above it, and no front-end depends on another front-end. The HTTP gateway is an adapter, not the hub — it exists so a browser can talk to the runtime, not because anything else needs it. document/architecture-layers.md is the full contract; this is the orientation.

Layer	Where	What it does
Core runtime	`packages/coding-agent/src/` (+ `packages/agent`, `packages/ai`, `packages/tui`, `packages/channels`, `packages/stats`)	Sessions, tools, extensions/plugins, memory, skills, IRC/mesh. Runs in-process; no HTTP, no UI.
Host	`packages/coding-agent/src/server/` (`zeta-server.ts`), `packages/coding-agent/src/channels/`	Wires a session to its workspace, IM channels, the router, config and the default workspace. Nothing here serves HTTP.
Front-ends	`main/crates/zeta-main` (TUI), `main/crates/zetawork-gui` (GUI), `packages/coding-agent/src/commands/` (CLI), `web-ui/` (browser)	Each one is a client of the host. IM bots are a front-end too.
HTTP adapter	`packages/coding-agent/src/server/web-gateway/`	REST/SSE/WS over the host. `zetacode serve` starts it; the browser UI and remote phones consume it.

Where each directory belongs:

Path	Contents
`packages/`	The published runtime packages (`@linxiraos/*`): coding-agent, ai, agent, tui, catalog, stats, channels, wire, mnemopi, natives, utils, omptype, browser-relay, collab-web.
`main/`	zetawork, its own Cargo workspace: the TUI (`crates/zeta-main`), the native GUI (`crates/zetawork-gui`), and `crates/sysmon` (shared system sampling).
`termide/`	Vendored TermIDE panel library — the panels both workbenches embed — plus the `zetaide` entry (`@linxiraos/ide`). Deviations from the vendored snapshot are logged in `termide/VENDOR.md`.
`editor/`	The built-in editor pane's npm face. The payload is a `termide-editor` binary; the package declares no command.
`crates/`	Rust runtime crates compiled as native addons (`pi-natives`, `pi-ast`, `pi-diff`, `pi-builtins`, …), built by Bazel.
`web-ui/`	The browser UI (a diverged OMP Web snapshot, npm-managed, not a root workspace package). Two jobs only: chat in a browser, and hosting HTML plugin pages.
`desktop/`	The retiring Electron shell. No new code; the desktop product is zetawork's GUI.
`plugins/`	`official/` first-party plugins (source in-tree, `INDEX.md` registry) and `community/` pointer files.
`docs/`	Runtime documentation shipped with the product (`zeta://docs`).
`document/`	Internal engineering docs: architecture contracts, merge playbook, release mechanics, roadmap. Never packaged.
`scripts/`	Build, release, packaging and the mechanical guards CI runs.
`sdk/`	Protocol SDKs (`rust/`, `python/`, `go/`) for embedding the runtime.
`python/robomp/`	The containerised agent runner.
`infra/`, `bazel/`, `nix/`, `patches/`, `lsp/`, `skills/`, `assets/`, `types/`	Build infrastructure, toolchain files, patch set, LSP server table, bundled skills, image assets, ambient type shims.

Plugin layers

A plugin is TypeScript, but what it shows is a choice of layer. Pick by what the surface needs, not by what the plugin is written in:

Layer	Surface	Use it for
Behaviour	Any front-end (tools, commands, hooks, messaging)	Work the agent performs. Rendered by nobody; identical in every client.
Declarative panel	zetawork GUI, natively	Lists, forms, charts: the GUI draws them with its own widgets and theme.
HTML page	web-ui, and zetawork's plugin column via a webview	Rich or third-party pages that cannot be expressed declaratively.

zetaide has no plugin layer, and the workbench TUI does not host plugin surfaces — a plugin that needs the terminal reaches it through the agent's own tools instead.

Quick Start

Install the workspace (Node 18+ or Bun on the machine):

npm i -g @linxiraos/main      # or: bun add -g @linxiraos/main
zetawork                      # opens the workspace in the current directory
zetawork web                  # serves the full Web UI on loopback for your browser
zetawork doctor               # suite install status + exact fixes

zetawork doctor lists every suite tool with installed/missing state and the exact install command for what is missing. Missing tools also self-install into a workbench pane on first use. Install any tool standalone the same way:

npm i -g @linxiraos/zeta      # zetacode — coding agent CLI
npm i -g @linxiraos/ide       # zetaide — terminal IDE

The editor is a workbench pane, not a standalone tool, so it has no install line: @linxiraos/editor is a reserved package name whose payload is not published today.

From a source checkout:

bun install
bun run build:native
bun run dev

The Workspace

zetawork is a real terminal multiplexer with product opinions, written in Rust:

Tabs and tiled panes — each pane is a real PTY: anything that runs in a terminal runs in a pane (a shell, a zetacode session, the editor, the IDE). Split any pane left/right or top/bottom; panes keep a stack of pages so one pane can hold several terminals without closing anything.
Mouse-first — every control (menu bar, tab bar, pane title controls, page tabs) is clickable; keyboard shortcuts exist as accelerators, not as a requirement. Switching, splitting, closing, and layout repair are all pointer operations.
Widget panes — a clock with a clickable calendar, a pomodoro timer, and a clipboard history pane run as native panes, not external tools.
Suite-aware — the Tools menu and zetawork doctor know the suite; a missing tool installs itself into the pane that asked for it.

The Coding Agent

zetacode is the coding CLI (built on the OMP runtime):

A terminal coding workspace with file reading, search, patching, shell, git, task delegation, and structured tool output.
Multi-provider model access, local configuration, OAuth flows, model discovery, session recovery, and controllable retry behavior.
A local web workbench (zetacode serve, Next.js app in web-ui/) and a desktop shell (zeta-desktop, Electron) that embed the same runtime — one session tree, one settings model, one gateway API (/api/*).
Native text, image, terminal, browser, and desktop capabilities where the host platform supports them.

An agent development environment (ADE)

The suite is not an IDE with a chatbot bolted on. It is an ADE — an Agent Development Environment, the way an IDE is an Integrated Development Environment: the same structure, with the first word changed from Integrated to Agent.

	IDE	ADE (this suite)
Center of gravity	the open file	the agent session
Who drives the tools	the editor drives LSP, builds, the debugger	the agent drives tools; editors and terminals are its work surfaces
Unit of work	a buffer	a session: context, tools, subagents, verification
Where the loop lives	type → build → debug	plan → execute → verify, with the human steering

Zeta keeps the IDE's shape — panes, tabs, real PTYs, LSP, an editor pane, a terminal IDE (zetaide) — because an agent needs somewhere to work. What moves is the center: zetacode sessions, subagent orchestration, the mesh (agent://), extensions and skills are first-class; the editor, terminals and file manager are the environment the agent operates in. A human can still drive any pane directly; the suite simply assumes the agent is the primary worker and the panes are how it observes and changes the world.

Origins

Zeta is built on two upstream projects:

Project	Role in Zeta
OMP (oh-my-pi)	The runtime tree, integrated only at complete official releases
Pi	Semantic-port source for feature work, never a raw merge source

The workbench (main/) and the desktop-facing additions are ours. Vendored projects keep their own licences and are listed in THIRD-PARTY-NOTICES.txt; the merge procedure is recorded in document/upstream-sync.md.

Component Lineage

The distribution is assembled from parts with different origins. What a part inherits from upstream — and what Zeta owns — is stated per component:

Component	Origin
`main/` (workspace, `@linxiraos/main`, binaries `zetawork`/`zeta`)	Zeta-originated
`packages/coding-agent/` (CLI, `zetacode`)	OMP runtime tree, release-tag merges
`packages/ai`, `agent`, `catalog`, `tui`, `natives`, `utils`, `stats`	OMP runtime tree
`termide/` (TermIDE, `@linxiraos/ide`, binaries `zetaide`)	termide/termide, vendored
`web-ui/`	Frozen browser UI; manual cherry-picks only
`desktop/`	Zeta-originated
`packages/coding-agent/src/channels/` (WeChat/Feishu/Telegram bridge)	Zeta-originated
`packages/coding-agent/src/server/` (web-gateway, `zetacode serve`)	Zeta-originated

Zeta-Originated Capabilities

Beyond the OMP runtime lineage, Zeta ships its own capabilities (roadmap in document/roadmap.md):

The workspace (zetawork) — tabs, tiled PTY panes with per-pane page stacks, a menu bar with full mouse control, native widget panes, and suite install/doctor integration.
Adaptive long-term tracking — ongoing session observation with standing system guidance that keeps provider prefix caches stable across long sessions.
Experiment measurement — per-project local experiment tracking with metrics, directions, and baseline commits.
TypeScript custom commands — user-defined slash commands from ~/.zeta/commands/ and project command dirs, with arktype/typebox/zod argument schemas and full access to the runtime API.
Command marketplace — install and share slash commands as Bun packages.
ACP collaboration builtins — Agent Client Protocol session support.
Channel runtime — WeChat/Feishu/Telegram bridges embedded in zetacode serve, with plan-image routing and workspace-scoped execution tools.
Web gateway — REST API behind the web UI (/api/*), one handler module per resource, consumed by both the browser UI and the desktop shell.
Desktop shell — Electron tray application embedding a standalone build of the web UI plus the compiled runtime; target machines need neither Bun nor Node.
Linux downstream packaging — zeta-desktop ships as a release asset with a frozen name/digest contract so downstream repositories (pacman et al.) can pin and verify it; see document/release.md.
Local stats dashboard — zetacode stats observability for the coding agent.

Documentation

The repository keeps two documentation trees with different audiences:

docs/ — runtime documentation, packaged with the product. Agents read it at runtime through zeta://docs/ (embedded in binaries and the npm bundle; from a source checkout it reads the live tree). Covers tools, tool-call conversion, skills, protocols, configuration, and Zeta features.
document/ — internal development and product-process documentation, never packaged. Includes the development roadmap, the upstream sync ledger, and the porting guide.

Interface Language

The CLI ships Simplified Chinese and English catalogues. The active language resolves in this order:

language in the settings file (~/.zeta/settings.json) — the explicit choice, written by /language.
ZETA_LANG / LC_ALL / LC_MESSAGES / LANG — the shell locale.
The OS UI language (Intl) — so a Chinese Windows box gets Chinese with no configuration at all.
English when nothing matches.

/language switches live: slash-command descriptions, the composer, and every localized panel re-resolve on the next render without a restart. Both catalogues are complete, so the choice is per-install rather than per-build — plugins can register their own text through the same source.

Development

# Static checks for TypeScript and Rust
bun check

# Coding-agent checks only
bun --cwd=packages/coding-agent run check

# Focused tests
bun --cwd=packages/coding-agent test test/<file>.test.ts

The primary application lives in packages/coding-agent/. Shared runtime packages include packages/ai/, packages/catalog/, packages/agent/, packages/tui/, and packages/natives/. The workspace lives in main/ (its own Cargo workspace), with the vendored tree under termide/.

Platform Support

Linux is the primary platform (Linxira OS, Arch-based); Windows x64 is a supported development/target platform; macOS is not built.

Surface	Linux	Windows	macOS
`zetawork` workspace (`@linxiraos/main`)	x64	x64	—
`zetacode` CLI	x64, arm64	x64	—
`zetaide` (`@linxiraos/ide`)	x64	x64	—
`zetacode serve` (web workbench)	x64, arm64	x64	—
`zeta-desktop` shell	x64	x64	—

Native text/grep and image capabilities require the platform C/C++ toolchain when built from source; released binaries bundle the prebuilt native modules.

Upstream Policy

Zeta follows OMP only through complete, official release tags. Each release is merged as real Git history on a temporary integration branch, then receives any required Zeta package, brand, Bun, CI, and product adaptations in separate commits. The exact source tag, SHA, conflict decisions, and checks are recorded in document/upstream-sync.md.

Pi is a semantic feature source, not a raw merge source. See AGENTS.md for the repository rules.

Commercial surfaces

Upstream ships commercial surfaces: the Stencil build service, a hosted model catalog, the hosted /share viewer, its Homebrew tap, and OTLP telemetry. Zeta runs none of them. The build service and telemetry are not in this tree; every hosted endpoint the code still references is pinned in document/upstream-commercial-assets.md with its replacement status, and bun scripts/check-shared-infra.ts fails when an unregistered upstream endpoint appears.

License

Zeta carries two licences, split by path:

Path	Licence
`main/` — the zetawork workbench (`zetawork`, `zeta`, and its npm packages)	AGPL-3.0-only (text)
`packages/`, `crates/`, `sdk/`, `web-ui/`, `desktop/`, `docs/`, `document/`, `scripts/`	MIT
`termide/`, `editor/` — vendored TermIDE	MIT (text)

The root LICENSE states the split and reproduces the MIT text that governs everything outside main/. Derived and vendored projects keep their own licences and are listed in THIRD-PARTY-NOTICES.txt.

Commercial licensing of the workbench is available by arrangement with the maintainers.

The workbench's editor pane is built in: @linxiraos/editor is the reserved package name for its binary payload (the earlier TTT-derived Go payload was removed 2026-10-16 and stays credited in source history).

简体中文

Zeta 是一套终端工作台套件：一个可平铺真实终端的工作区，加上活在工作区里的工具——编码 Agent、编辑器、终端 IDE 和文件管理器。它是 Agent 开发环境（ADE），不是"IDE 加聊天框"：会话是工作单元，每个窗格都是 agent 可以使用的工作面。Linux 是主力平台；支持 Windows x64;不提供 macOS 构建。

目录与分层

产品分四层，依赖单向：核心运行时 → Host → 前端 → HTTP 适配器。HTTP 只是适配器，不是中枢；浏览器 UI 和远程手机是它的消费者，其它前端不依赖它（完整契约见 document/architecture-layers.md）。

路径	是什么
`packages/`	运行时包（`@linxiraos/*`）：coding-agent、ai、agent、tui、catalog、stats、channels、wire、mnemopi、natives 等
`main/`	zetawork：TUI（`crates/zeta-main`）、原生 GUI（`crates/zetawork-gui`）、共享采样（`crates/sysmon`）
`termide/`	vendored TermIDE 面板库 + `zetaide`；对快照的偏离登记在 `termide/VENDOR.md`
`editor/`	内置编辑器面板的 npm 面（载荷是 `termide-editor` 二进制，不声明命令）
`crates/`	原生 Rust 运行时 crate（`pi-natives` 等），由 Bazel 构建
`web-ui/`	浏览器 UI（OMP Web 分叉快照）：只负责浏览器里的对话 + HTML 插件宿主
`desktop/`	待退役 Electron 壳（桌面产品是 zetawork GUI）
`plugins/`	`official/`（第一方插件源码 + `INDEX.md` 登记）与 `community/`（指针文件）
`docs/`	随产品打包的运行时文档（`zeta://docs`）；`document/` 是内部工程文档，不打包
`scripts/`	构建、发布、打包与 CI 守卫
`sdk/`、`python/robomp/`	协议 SDK（rust/python/go）、容器化 Agent 运行器

插件分三层，按"要显示在哪个面"选，而不是按插件用什么语言写：行为（工具/命令/钩子，所有前端一致）、声明式面板（zetawork GUI 原生渲染：列表/表单/图表）、HTML 页 （web-ui，以及 zetawork 插件栏的 webview）。zetaide 没有插件层，工作台 TUI 也不托管插件面板。

套件

命令	包	是什么
`zetawork`	`@linxiraos/main`	工作区：嵌套终端工作台(Rust)
`zeta`	`@linxiraos/main`	套件索引——裸 `zeta` 打印帮助/命令表
`zetacode`	`@linxiraos/zeta`	编码 Agent CLI
`zetaide`	`@linxiraos/ide`	终端 IDE(TermIDE,vendored Rust)

每条命令都能独立启动、各有自己的 --help;裸 zeta 打印套件索引。工作区是统一入口:其中的编码/IDE 面板会接力到 zetacode 与 zetaide,编辑器面板则是内置的(@linxiraos/editor 包名与发布链预留给该面板的二进制载荷,当前不发布,也没有自己的命令)。

快速开始

安装工作区(机器上需有 Node 18+ 或 Bun):

npm i -g @linxiraos/main      # 或:bun add -g @linxiraos/main
zetawork                      # 在当前目录打开工作区
zetawork web                  # 在 loopback 上起本机 Web UI 供浏览器访问
zetawork doctor               # 套件安装状态 + 精确修复命令

zetawork doctor 逐项列出套件工具的安装状态,缺失项给出精确安装命令。缺失的工具也能在工作区里首次使用时直接装进窗格。任一工具同样可以独立安装:

npm i -g @linxiraos/zeta      # zetacode — 编码 Agent CLI
npm i -g @linxiraos/ide       # zetaide — 终端 IDE

编辑器是工作区里的内置面板,不是独立工具,因此没有安装行:@linxiraos/editor 是预留包名,其载荷当前不发布。

从源码检出运行:

bun install
bun run build:native
bun run dev

工作区

zetawork 是一个有产品主张的真实终端复用器,Rust 编写:

标签页与平铺窗格 —— 每个窗格都是真实 PTY:终端里能跑的都能跑在窗格里(shell、zetacode 会话、编辑器、IDE)。任意窗格可左右或上下分裂; 窗格内还有子页栈,一个窗格容纳多个终端而互不关闭。
鼠标优先 —— 所有控件(菜单栏、标签栏、窗格标题控件、子页标签)都可点击;快捷键只是加速器,不是前提。切换、分裂、关闭、布局修复全是鼠标操作。
组件窗格 —— 带可点击日历的时钟、番茄钟、剪贴板历史,都是原生窗格, 不依赖外部工具。
感知套件 —— Tools 菜单和 zetawork doctor 认识全套件;缺失工具会在请求它的那个窗格里直接自装。

编码 Agent

zetacode 是编码 CLI(基于 OMP 运行时构建):

终端编码工作区,包含文件读取、搜索、补丁、shell、git、任务委派和结构化工具输出。
多提供商模型访问、本地配置、OAuth 流程、模型发现、会话恢复和可控的重试行为。
本地 Web 工作台(zetacode serve,web-ui/ 的 Next.js 应用)和桌面外壳 (zeta-desktop,Electron)嵌入同一运行时——同一会话树、同一设置模型、同一网关 API(/api/*)。
宿主平台支持时提供原生文本、图像、终端、浏览器和桌面能力。

Agent 开发环境（ADE）

这套件不是"IDE 加个聊天框",而是 ADE——Agent Development Environment (Agent 开发环境);它与 IDE(Integrated Development Environment,集成开发环境)结构相同,只把第一个词从 Integrated 换成 Agent。

	IDE	ADE(本套件)
重心	打开的文件	agent 会话
谁驱动工具	编辑器驱动 LSP、构建、调试器	agent 驱动工具;编辑器与终端是它的工作面
工作单元	一个缓冲区	一次会话:上下文、工具、子代理、验证
循环在哪	写 → 构建 → 调试	规划 → 执行 → 验证,人负责掌舵

Zeta 保留 IDE 的形态——窗格、标签页、真实 PTY、LSP、编辑器面板、终端 IDE (zetaide)——因为 agent 需要一个工作的地方。移动的是中心:zetacode 会话、子代理编排、mesh(agent://)、扩展与技能都是一等公民;编辑器、终端和文件管理器是 agent 操作的环境。人仍然可以直接驱动任何窗格;套件只是假定 agent 是主要工作者,窗格是它观察和改变世界的方式。

上游来源

Zeta 基于两个上游项目:

项目	在 Zeta 中的角色
OMP (oh-my-pi)	运行时树,只在完整官方发布上合并
Pi	功能工作的语义移植来源,绝不作为原始合并源

工作台(main/)与桌面相关增补由我们维护。vendored 项目保持各自的许可, 列在 THIRD-PARTY-NOTICES.txt;合并流程记录在 document/upstream-sync.md。

组件谱系

该发行版由不同来源的部件组装而成。每个部件继承了什么、Zeta 拥有什么, 逐组件说明:

组件	来源
`main/`(工作区,`@linxiraos/main`,二进制 `zetawork`/`zeta`)	Zeta 原创
`packages/coding-agent/`(CLI,`zetacode`)	OMP 运行时树,按发布 tag 合并
`packages/ai`、`agent`、`catalog`、`tui`、`natives`、`utils`、`stats`	OMP 运行时树
`termide/`(TermIDE,`@linxiraos/ide`,二进制 `zetaide`)	termide/termide,vendored
`web-ui/`	冻结的浏览器 UI,仅手动挑选
`desktop/`	Zeta 原创
`packages/coding-agent/src/channels/`(微信/飞书/Telegram 桥接)	Zeta 原创
`packages/coding-agent/src/server/`(web-gateway,`zetacode serve`)	Zeta 原创

Zeta 自有能力

除 OMP 运行时谱系之外,Zeta 还提供自己的能力(路线图见 document/roadmap.md):

工作区(zetawork)—— 标签页、带子页栈的平铺 PTY 窗格、全鼠标可控的菜单栏、原生组件窗格,以及套件安装/doctor 集成。
自适应长期跟踪 —— 持续的会话观察与常驻系统指引,在长会话中保持提供商前缀缓存稳定。
实验度量 —— 按项目的本地实验跟踪,包含指标、方向和基线提交。
TypeScript 自定义命令 —— 来自 ~/.zeta/commands/ 和项目命令目录的用户自定义斜杠命令,支持 arktype/typebox/zod 参数 schema,并可完全访问运行时 API。
命令市场 —— 以 Bun 包的形式安装和分享斜杠命令。
ACP 协作内建 —— Agent Client Protocol 会话支持。
通道运行时 —— 嵌入 zetacode serve 的微信/飞书/Telegram 桥接,带 plan-image 路由和工作区作用域的执行工具。
Web 网关 —— Web UI 背后的 REST API(/api/*),每个资源一个处理模块,由浏览器 UI 和桌面外壳共同消费。
桌面外壳 —— Electron 托盘应用,嵌入 Web UI 的独立构建和编译后的运行时;目标机器无需 Bun 或 Node。
Linux 下游打包 —— zeta-desktop 以冻结名称/摘要契约作为发布资产提供,下游仓库(pacman 等)可以固定并校验它;见 document/release.md。
本地统计仪表板 —— 面向编码 Agent 的 zetacode stats 可观测性。

文档

仓库保留两棵面向不同读者的文档树:

docs/ —— 运行时文档,随产品打包。Agent 在运行时通过 zeta://docs/ 读取(内嵌于二进制和 npm 包;源码检出时读取实际目录)。涵盖工具、工具调用转换、技能、协议、配置和 Zeta 功能。
document/ —— 内部开发与产品流程文档,绝不打包。包括开发路线图、上游同步台账和移植指南。

界面语言

CLI 提供简体中文和英文两套目录。活动语言按以下顺序解析:

设置文件中的 language(~/.zeta/settings.json)——显式选择,由 /language 写入。
ZETA_LANG / LC_ALL / LC_MESSAGES / LANG —— shell 区域设置。
操作系统 UI 语言(Intl)——因此中文 Windows 无需任何配置即显示中文。
都不匹配时使用英文。

/language 即时切换:斜杠命令描述、输入框和每个本地化面板在下一次渲染时重新解析,无需重启。两套目录都是完整的,因此该选择是按安装而非按构建—— 插件可以通过同一来源注册自己的文本。

开发

# TypeScript 与 Rust 的静态检查
bun check

# 仅编码 Agent 检查
bun --cwd=packages/coding-agent run check

# 聚焦测试
bun --cwd=packages/coding-agent test test/<file>.test.ts

主应用位于 packages/coding-agent/。共享运行时包包括 packages/ai/、 packages/catalog/、packages/agent/、packages/tui/ 和 packages/natives/。工作区在 main/(独立 Cargo workspace),vendored 树在 termide/。

平台支持

Linux 是主力平台(Linxira OS,基于 Arch);Windows x64 是受支持的开发与目标平台;不构建 macOS。

形态	Linux	Windows	macOS
`zetawork` 工作区(`@linxiraos/main`)	x64	x64	—
`zetacode` CLI	x64, arm64	x64	—
`zetaide`(`@linxiraos/ide`)	x64	x64	—
`zetacode serve`(Web 工作台)	x64, arm64	x64	—
`zeta-desktop` 外壳	x64	x64	—

从源码构建时,原生文本/grep 和图像能力需要平台 C/C++ 工具链;发布的二进制内置预构建原生模块。

上游政策

Zeta 只通过完整、官方的发布 tag 跟随 OMP。每次发布都在临时集成分支上作真实 Git 历史合并,然后以独立提交加入所需的 Zeta 包、品牌、Bun、CI 和产品适配。确切的来源 tag、SHA、冲突决策和检查记录在 document/upstream-sync.md。

Pi 是语义功能来源,不是原始合并来源。仓库规则见 AGENTS.md。

商业面

上游随代码发布自己的商业面:Stencil 构建服务、托管模型目录、托管 /share 查看页、自家 Homebrew tap 与 OTLP 遥测。Zeta 一个都不运行:构建服务与遥测不在本树内;代码仍引用的每个托管端点都钉在 document/upstream-commercial-assets.md 并标注替代状态;出现未登记的上游端点时 bun scripts/check-shared-infra.ts 会直接失败。

许可证

Zeta 按路径承载两种许可:

路径	许可
`main/` — zetawork 工作台(`zetawork`、`zeta` 及其 npm 包)	AGPL-3.0-only(全文)
`packages/`、`crates/`、`sdk/`、`web-ui/`、`desktop/`、`docs/`、`document/`、`scripts/`	MIT
`termide/`、`editor/` — vendored TermIDE	MIT(全文)

根目录 LICENSE 说明分层,并复述管辖 main/ 之外全部代码的 MIT 文本。派生与 vendored 项目保持各自许可,列在 THIRD-PARTY-NOTICES.txt。

工作台的商业授权可与维护者协商。

工作区的编辑器是内置面板:@linxiraos/editor 是预留给该面板二进制载荷的包名 (早先由 TTT Editor 派生的 Go 载荷已于 2026-10-16 移除,仍在源代码历史中获得致谢)。

Command

Package

What it is

zetawork

@linxiraos/main

The workspace: nested-terminal workbench (Rust)

zeta

@linxiraos/main

Suite index — a bare zeta prints the help/command map

zetacode

@linxiraos/zeta

Coding agent CLI

zetaide

@linxiraos/ide

Terminal IDE (TermIDE, vendored Rust)

Layer

Where

What it does

Core runtime

packages/coding-agent/src/ (+ packages/agent, packages/ai, packages/tui, packages/channels, packages/stats)

Sessions, tools, extensions/plugins, memory, skills, IRC/mesh. Runs in-process; no HTTP, no UI.

Host

packages/coding-agent/src/server/ (zeta-server.ts), packages/coding-agent/src/channels/

Wires a session to its workspace, IM channels, the router, config and the default workspace. Nothing here serves HTTP.

Front-ends

main/crates/zeta-main (TUI), main/crates/zetawork-gui (GUI), packages/coding-agent/src/commands/ (CLI), web-ui/ (browser)

Each one is a client of the host. IM bots are a front-end too.

HTTP adapter

packages/coding-agent/src/server/web-gateway/

REST/SSE/WS over the host. zetacode serve starts it; the browser UI and remote phones consume it.

Path

Contents

packages/

The published runtime packages (@linxiraos/*): coding-agent, ai, agent, tui, catalog, stats, channels, wire, mnemopi, natives, utils, omptype, browser-relay, collab-web.

main/

zetawork, its own Cargo workspace: the TUI (crates/zeta-main), the native GUI (crates/zetawork-gui), and crates/sysmon (shared system sampling).

termide/

Vendored TermIDE panel library — the panels both workbenches embed — plus the zetaide entry (@linxiraos/ide). Deviations from the vendored snapshot are logged in termide/VENDOR.md.

editor/

The built-in editor pane's npm face. The payload is a termide-editor binary; the package declares no command.

crates/

Rust runtime crates compiled as native addons (pi-natives, pi-ast, pi-diff, pi-builtins, …), built by Bazel.

web-ui/

The browser UI (a diverged OMP Web snapshot, npm-managed, not a root workspace package). Two jobs only: chat in a browser, and hosting HTML plugin pages.

desktop/

The retiring Electron shell. No new code; the desktop product is zetawork's GUI.

plugins/

official/ first-party plugins (source in-tree, INDEX.md registry) and community/ pointer files.

docs/

Runtime documentation shipped with the product (zeta://docs).

document/

Internal engineering docs: architecture contracts, merge playbook, release mechanics, roadmap. Never packaged.

scripts/

Build, release, packaging and the mechanical guards CI runs.

sdk/

Protocol SDKs (rust/, python/, go/) for embedding the runtime.

python/robomp/

The containerised agent runner.

infra/, bazel/, nix/, patches/, lsp/, skills/, assets/, types/

Build infrastructure, toolchain files, patch set, LSP server table, bundled skills, image assets, ambient type shims.

Layer

Surface

Use it for

Behaviour

Any front-end (tools, commands, hooks, messaging)

Work the agent performs. Rendered by nobody; identical in every client.

Declarative panel

zetawork GUI, natively

Lists, forms, charts: the GUI draws them with its own widgets and theme.

HTML page

web-ui, and zetawork's plugin column via a webview

Rich or third-party pages that cannot be expressed declaratively.

npm i -g @linxiraos/main # or: bun add -g @linxiraos/main zetawork # opens the workspace in the current directory zetawork web # serves the full Web UI on loopback for your browser zetawork doctor # suite install status + exact fixes

IDE

ADE (this suite)

Center of gravity

the open file

the agent session

Who drives the tools

the editor drives LSP, builds, the debugger

the agent drives tools; editors and terminals are its work surfaces

Unit of work

a buffer

a session: context, tools, subagents, verification

Where the loop lives

type → build → debug

plan → execute → verify, with the human steering

Project

Role in Zeta

OMP (oh-my-pi)

The runtime tree, integrated only at complete official releases

Semantic-port source for feature work, never a raw merge source

Component

Origin

main/ (workspace, @linxiraos/main, binaries zetawork/zeta)

Zeta-originated

packages/coding-agent/ (CLI, zetacode)

OMP runtime tree, release-tag merges

packages/ai, agent, catalog, tui, natives, utils, stats

OMP runtime tree

termide/ (TermIDE, @linxiraos/ide, binaries zetaide)

termide/termide, vendored

web-ui/

Frozen browser UI; manual cherry-picks only

desktop/

Zeta-originated

packages/coding-agent/src/channels/ (WeChat/Feishu/Telegram bridge)

Zeta-originated

packages/coding-agent/src/server/ (web-gateway, zetacode serve)

Zeta-originated

Surface

Linux

Windows

macOS

zetawork workspace (@linxiraos/main)

x64

—

zetacode CLI

x64, arm64

x64

—

zetaide (@linxiraos/ide)

x64

—

zetacode serve (web workbench)

x64, arm64

x64

—

zeta-desktop shell

x64

—

Path

Licence

main/ — the zetawork workbench (zetawork, zeta, and its npm packages)

AGPL-3.0-only (text)

packages/, crates/, sdk/, web-ui/, desktop/, docs/, document/, scripts/

MIT

termide/, editor/ — vendored TermIDE

MIT (text)

路径

是什么

packages/

运行时包（@linxiraos/*）：coding-agent、ai、agent、tui、catalog、stats、channels、wire、mnemopi、natives 等

main/

zetawork：TUI（crates/zeta-main）、原生 GUI（crates/zetawork-gui）、共享采样（crates/sysmon）

termide/

vendored TermIDE 面板库 + zetaide；对快照的偏离登记在 termide/VENDOR.md

editor/

内置编辑器面板的 npm 面（载荷是 termide-editor 二进制，不声明命令）

crates/

原生 Rust 运行时 crate（pi-natives 等），由 Bazel 构建

web-ui/

浏览器 UI（OMP Web 分叉快照）：只负责浏览器里的对话 + HTML 插件宿主

desktop/

待退役 Electron 壳（桌面产品是 zetawork GUI）

plugins/

official/（第一方插件源码 + INDEX.md 登记）与 community/（指针文件）

docs/

随产品打包的运行时文档（zeta://docs）；document/ 是内部工程文档，不打包

scripts/

构建、发布、打包与 CI 守卫

sdk/、python/robomp/

协议 SDK（rust/python/go）、容器化 Agent 运行器

命令

包

是什么

zetawork

@linxiraos/main

工作区：嵌套终端工作台(Rust)

zeta

@linxiraos/main

套件索引——裸 zeta 打印帮助/命令表

zetacode

@linxiraos/zeta

编码 Agent CLI

zetaide

@linxiraos/ide

终端 IDE(TermIDE,vendored Rust)

npm i -g @linxiraos/main # 或:bun add -g @linxiraos/main zetawork # 在当前目录打开工作区 zetawork web # 在 loopback 上起本机 Web UI 供浏览器访问 zetawork doctor # 套件安装状态 + 精确修复命令

IDE

ADE(本套件)

重心

打开的文件

agent 会话

谁驱动工具

编辑器驱动 LSP、构建、调试器

agent 驱动工具;编辑器与终端是它的工作面

工作单元

一个缓冲区

一次会话:上下文、工具、子代理、验证

循环在哪

写 → 构建 → 调试

规划 → 执行 → 验证,人负责掌舵

项目

在 Zeta 中的角色

OMP (oh-my-pi)

运行时树,只在完整官方发布上合并

功能工作的语义移植来源,绝不作为原始合并源

组件

来源

main/(工作区,@linxiraos/main,二进制 zetawork/zeta)

Zeta 原创

packages/coding-agent/(CLI,zetacode)

OMP 运行时树,按发布 tag 合并

packages/ai、agent、catalog、tui、natives、utils、stats

OMP 运行时树

termide/(TermIDE,@linxiraos/ide,二进制 zetaide)

termide/termide,vendored

web-ui/

冻结的浏览器 UI,仅手动挑选

desktop/

Zeta 原创

packages/coding-agent/src/channels/(微信/飞书/Telegram 桥接)

Zeta 原创

packages/coding-agent/src/server/(web-gateway,zetacode serve)

Zeta 原创

形态

Linux

Windows

macOS

zetawork 工作区(@linxiraos/main)

x64

—

zetacode CLI

x64, arm64

x64

—

zetaide(@linxiraos/ide)

x64

—

zetacode serve(Web 工作台)

x64, arm64

x64

—

zeta-desktop 外壳

x64

—

路径

许可

main/ — zetawork 工作台(zetawork、zeta 及其 npm 包)

AGPL-3.0-only(全文)

packages/、crates/、sdk/、web-ui/、desktop/、docs/、document/、scripts/

MIT

termide/、editor/ — vendored TermIDE

MIT(全文)