@agimon-ai/doompi 0.0.1-alpha.13 → 0.0.1-alpha.15

package/README.md

@@ -2,13 +2,23 @@
 
 **A coding agent that loads only the skills and tools you name.**
 
-Plugin systems scope what an agent knows. Nothing scopes what it can reach. Claude Code
-gives you `enableAllProjectMcpServers` and a static denylist, both repository-wide, so
-every session pays for every MCP server's tool schemas whether the task is a database
-migration or a landing page.
+> It begins with one useful MCP server. Then another. Soon the agent fixing a heading
+> wakes up with database tools, browser controls, and their small novel of schemas. This
+> is our config.
 
-Doompi makes both a declared input. Three YAML files decide what a session loads, and
-`--explain` prints the bill before you launch.
+Doompi is a configuration framework for [Pi](https://github.com/earendil-works/pi)
+tailored for people whose agent has one MCP server too many. It turns extensions, skills,
+MCP servers, and system prompts into config instead of background noise.
+
+Plugin systems scope what an agent knows. Nothing scopes what it can reach. Claude Code's
+`enableAllProjectMcpServers` and static denylist are repository-wide. Doompi draws that
+boundary around the session. Pick a major mode and some domains; add a profile if you want
+one. Three YAML files decide what loads; `doompi --explain` tells you what got in, why, and
+what it costs before launch.
+
+It borrows its shape from [Doom Emacs Core](https://github.com/doomemacs/core): quick to
+start, close to Pi, opinionated where defaults help, and easy to pull apart when they do
+not. Use it as-is, build your own config on top, or raid it for parts.
 
 ## Install
 
@@ -25,8 +35,11 @@ doompi --explain                             # what would load, and why
 doompi                                       # start a session
 ```
 
-`.doom/` is committed to git, so a checkout carries its own agent configuration. Edit a
-YAML file and the next launch picks it up.
+`doompi init` is the one machine-wide step. It seeds `~/.pi/.doom`; copy those files into
+a repository when the repository needs its own agent. Commit `.doom/`. Now the config
+follows the code instead of living in someone's shell history.
+
+Flags override the defaults for one session:
 
 ```bash
 doompi --major-mode dev --domains development
@@ -34,342 +47,80 @@ doompi --domains marketing --profile marketing
 doompi --domains analytics --explain
 ```
 
-## The three axes
-
-Doompi wraps [Pi](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) and
-resolves a declared configuration into a session rather than asking you to wire one up.
-The three choices are independent: adding a domain requires no knowledge of major modes,
-and swapping a profile changes nothing about either.
-
-| Choice         | Decides                              | Declared in           |
-| -------------- | ------------------------------------ | --------------------- |
-| **Major mode** | what the agent is wrapped in         | `.doom/modes.yaml`    |
-| **Domains**    | what it knows, and what it can reach | `.doom/domains.yaml`  |
-| **Profile**    | who it speaks as                     | `.doom/profiles.yaml` |
-
-A domain names plugins and an MCP allowlist together, so `--domains marketing` and
-`--domains development` are the same agent with different knowledge and a different reach,
-not two different agents. That is the lever for keeping context small, and
-[`--explain`](#minimal-context) prices it before you commit.
-
-## What is actually different
-
-**Compaction reads state, it does not summarize prose.** When the context fills, Doompi
-does not guess at coordination state from the transcript. It reads the live plan, task
-graph, and team snapshot, and commits them next to the summary as authoritative. The agent
-comes out the other side knowing what it was doing, what is still running, and who is doing
-what. See [Long runs](#long-runs).
-
-**Spec-driven and meta-prompting systems change what the agent is told. Doompi changes what
-it loads.** The two compose fine. This one is about the context window, not the prompt.
-
-**One configuration serves two readers.** A human gets a keyboard surface that does not
-move; an autonomous agent gets a small tool surface and a context window that compacts
-itself.
-
 ## Philosophy
 
-**Give the agent fewer things to choose between.** [Major modes, domains, and
-profiles](#major-modes-domains-profiles) decide what loads, so a session carries the skills
-and MCP servers its domains named and nothing else. Whatever still overflows [compacts in
-the background](#long-runs).
-
-**Shift the work onto deterministic workflows.** Autonomous runs are [GitHub Actions
-shaped](#workflows), with jobs, dependencies, steps, timeouts, and declared artifacts, so
-the same job resolves the same way every time.
-
-**Keep the keyboard ergonomic.** `SPC` is the whole surface, Spacemacs and Doom Emacs
-style, and [it opens only when the draft is empty](#leader-space), so a half-written prompt
-is never a casualty.
-
-**Batteries included, without the bloat.** Plan mode, tasks, teams, a supervised runner,
-voice, and workflows ship in the box, but [core is not a
-layer](#core-is-not-a-layer) and every opinion waits behind a layer or a domain.
-
-**One major mode, several minor modes.** A session runs under exactly one major mode, which
-is what selects its layers. [Plan, loop, and workflow](#minor-modes) are minor modes: you
-toggle them mid-session, they stack, and they report themselves on a shared status line.
-
-## Two ways to run
-
-The launcher resolves your three choices per run and spawns Pi with them. Skills, agents,
-MCP configs, and the persona prompt are assembled into a temporary directory that is
-deleted on exit. Nothing is written back into the repository, and every session pays the
-resolution cost.
-
-`doompi sync` is the other way in, and the Doom Emacs one. Resolve once, write the
-result where Pi looks, then run `pi` yourself.
-
-```bash
-doompi init          # seed ~/.pi/.doom, once per machine
-doompi build         # warm the selected launch bundle and skill cache
-doompi sync          # resolve the selection into .pi/
-pi                   # the agent
-
-doompi sync --check  # exit non-zero when the synced config is out of date
-```
-
-A synced session takes `--major-mode`, `--domains`, `--profile`, and `--mute` the same way
-the launcher does, and `/mode`, `/domains`, and `/profile` all switch in place: the
-extension set is composed on every load rather than frozen at startup, so a reload is
-enough.
-
-Both paths compose the extension set from the same function, `assembleExtensions`, which
-owns load order. Two things differ. A synced session forces `--auto-stop` off, and it
-reads mute from `DOOMPI_MUTE` instead of an argument.
-
-`doompi build` is the launcher warm-up step, analogous to `doom build`: it resolves the
-selected matrix, compiles its exact extension graph into one `.pi/doom/dist` ESM file,
-and warms the persistent skill manifest without starting Pi or changing
-`.pi/settings.json`. A sidecar manifest retains every original extension and exact
-`SKILL.md` path, so resource discovery never depends on the bundle's location.
-Launch still builds on a cache miss, so the command is optional; run it after installing
-or upgrading Doom packages when first-input latency matters.
-
-Syncing does not disturb the launcher. Pi merges the extensions a project declares with
-the ones passed on the command line, so the synced entry stands down whenever it sees the
-composed set already there, which is what the launcher and every detached subagent pass.
-
-## For humans
-
-### Leader Space
-
-`@agimon-ai/doompi-ui` owns the leader state machine, rendering, conflict handling, and the
-core bindings.
-
-Space opens the leader **only when the draft is empty**. With text in the editor, space is
-a space. `ctrl+space` opens the leader either way, and the draft survives the sequence, so
-you never lose a half-written prompt to a keystroke. That is the space the human keeps.
-
-Inside a sequence: `escape` cancels, `backspace` pops one segment, and any key that
-matches nothing cancels. There is no partial state to get stuck in.
-
-Core groups. Every level of the map renders in leader-key alphabetical order, so the table
-below is the order you see:
-
-| Key | Group     | Bindings                                 |
-| --- | --------- | ---------------------------------------- |
-| `e` | extension | `e` external editor, `t` tools browser   |
-| `h` | help      | `h` hotkeys, `l` log metrics             |
-| `m` | models    | `m` select, `n` next, `t` thinking level |
-| `q` | quit      | `q` exit                                 |
-| `s` | sessions  | `f` fork, `n` new, `r` resume, `t` tree  |
-
-`t` is deliberately left out of core at the root and reserved for doom-task.
-
-Optional feature extensions own the bindings for their own commands. The UI never
-hardcodes a binding for a layer that may not be loaded, so a group appears only while its
-extension is loaded:
-
-| Chord                | Source                        | Opens                          |
-| -------------------- | ----------------------------- | ------------------------------ |
-| `SPC a`              | `@agimon-ai/doompi-team`      | subagent fleet                 |
-| `SPC h l`            | `@agimon-ai/doompi-log`       | log metrics                    |
-| `SPC l s`, `SPC l l` | `@agimon-ai/doompi-loop`      | start loops, list/stop loops   |
-| `SPC p p/c/d/f`      | `@agimon-ai/doompi-plan`      | plan normal/cancel/debug/fable |
-| `SPC t t`            | `@agimon-ai/doompi-task`      | tasks                          |
-| `SPC r r`            | `@agimon-ai/doompi-runner`    | background processes           |
-| `SPC v v`            | `@agimon-ai/doompi-voice`     | record or transcribe           |
-| `SPC w w/l/r`        | `@agimon-ai/doompi-workflow`  | launch/manage/recover          |
-| `SPC e f`            | `@agimon-ai/doompi-file-edit` | session edits                  |
-| `SPC e s`            | `@agimon-ai/doompi`           | skills catalog                 |
-| `SPC e c`            | `@agimon-ai/doompi-ui`        | config panel (core binding)    |
-| `SPC g s/e/p`        | `@agimon-ai/doompi-goal`      | start/end/history              |
-
-Contributions go through the public `@agimon-ai/doompi-ui/leader` API:
-
-```ts
-registerDoomLeaderContribution(pi, {
-  source: '@agimon-ai/doompi-log',
-  bindings: [
-    {
-      id: 'log.metrics',
-      path: [
-        { key: 'h', label: 'help', order: 70 },
-        { key: 'l', label: 'logs', detail: 'telemetry' },
-      ],
-      command: { name: 'log-metrics' },
-    },
-  ],
-});
-```
-
-A path excludes the leading `SPC`. The UI turns this into `SPC h l`, dispatches
-`/log-metrics` through the normal editor submission path, and preserves the draft. A
-binding carries either a `command` descriptor or an `action` name, never both. Commands
-stay owned by the extension that registered the slash command; actions route back to the
-contributor through `registerDoomLeaderActionHandlers`, which is what doom-plan uses.
-
-The map is deterministic because the registry is strict:
-
-- Keys are a single lowercase alphanumeric character, paths are at most four segments.
-- Shared group prefixes must agree on label, detail, and order, or the contribution is
-  rejected.
-- Exact chord conflicts are rejected rather than silently overridden. A conflict in a core
-  binding throws; a conflict from a contributor produces a diagnostic and a warning.
-- Re-registering the same `source` replaces that source's complete binding set. Registering
-  an empty set removes it.
-- Rebuilds sort by source name then binding id, so load order does not affect the result.
-- Options render in leader-key alphabetical order at every level. A segment's `order` is
-  group identity that shared prefixes must agree on, not a display position.
-
-Registration runs over Pi's shared extension event bus with a 250 ms timeout. A timeout is
-swallowed, so an extension loaded without the UI degrades quietly instead of failing.
-
-### Major modes, domains, profiles
-
-Three choices, three files, committed to git. They are independent. Adding a domain
-requires no knowledge of major modes, and swapping a profile changes nothing about either.
-
-| Choice          | Loads                                 | Declared in           |
-| --------------- | ------------------------------------- | --------------------- |
-| **Major modes** | a named set of layers                 | `.doom/modes.yaml`    |
-| **Domains**     | plugins, meaning skills and MCP       | `.doom/domains.yaml`  |
-| **Profiles**    | a persona and the brand it speaks for | `.doom/profiles.yaml` |
-
-**Layers are protection and steering.** A layer is a set of Pi extensions plus a set of
-hook groups. The extensions add behavior the agent runs with; the hooks fire around its
-tool calls and can block it, warn it, or steer it back. You define the set you want, along
-the lines of `guardrails`, `lint`, `code-intel`, `team`, `plan-mode`, `runner`, and
-`ask-user`. The hooks themselves live in `.doom/hooks.yaml`, one registry shared by every
-frontend, where a group is either `core` and always loads, or is pulled in by whichever
-layer wants it.
-
-**A major mode is the one you actually pick.** You do not assemble layers one by one at the
-prompt. You select one named major mode with `--major-mode <name>`, and
-`.doom/modes.yaml` says which layers it contains. A session has exactly one, the way
-an Emacs buffer has exactly one major mode. The file can choose the fallback without
-renaming that mode:
-
-```yaml
-defaultMajorMode: minimal
-majorMode:
-  minimal: [guardrails, team]
-  copilot: [guardrails, team, plan-mode, runner]
-```
-
-An explicit `--major-mode` wins, then `DOOMPI_MAJOR_MODE`, then
-`defaultMajorMode`. Omitting the field preserves the compatible `copilot` fallback.
-
-The flag is `--major-mode` and not `--mode` because Pi already owns `--mode` for its output
-mode (`text`, `json`, `rpc`), and for any other value it consumes the argument and ignores
-it without a diagnostic. Use `--output-format` for Pi's output mode.
-
-**Domains are plugins, and a plugin is skills plus MCP.** Selecting a domain decides which
-plugins contribute their skills and subagents, which MCP servers the session can reach,
-and whether the always-on shared skills apply. A domain can take a whole plugin or a named
-subset of one. This is the choice that decides how much the agent can see, so it is also
-the lever for keeping context small. Defaults are plural because domains compose:
-
-```yaml
-defaultDomains: [development, qa]
-domains:
-  development:
-    plugins: [plugins/development]
-  qa:
-    plugins: [plugins/qa]
-```
-
-Explicit `--domain` or `--domains` flags win, then `DOOMPI_DOMAINS`, then
-`defaultDomains`.
+An agent does not need every tool for every job. Doompi separates the base session from
+the things you switch on for a while: modes choose behavior, domains choose subject
+matter, and profiles choose a point of view.
 
-**Profiles are a persona and a brand.** `.doom/profiles.yaml` points at a directory under
-`agents/<brand>/<person>/`, and doom concatenates that person's `profile.md`, `SOUL.md`,
-and `AGENTS.md` into the system prompt: identity and the brand it represents, then voice,
-then role and rules. A profile also carries environment defaults, and nothing else. It
-cannot select domains, major modes, models, presets, or policy, and an exported value
-always beats a profile default.
+### Major and minor modes
 
-Switching is live. `/mode`, `/domains`, and `/profile` re-resolve into the running
-session and reload. A domain or profile switch always applies in place. A major mode switch
-applies in place too unless the new mode changes which extension packages load, since Pi
-freezes the `--extension` set at construction; the picker tells you when a relaunch is
-needed.
+A major mode is the base config. It names the extension layers for development, marketing,
+or whatever else you do. Define as many as you like; only one is active at a time, and you
+can switch it without leaving the session.
 
-### Minor modes
+Minor modes are switches inside that base. They start off, stack freely, and bring their
+own tools and instructions when turned on. Doompi ships five:
 
-A major mode is chosen once per session and selects layers. Minor modes are the opposite:
-you toggle them while the session runs, several can be on at once, and none of them changes
-which extensions are loaded.
+- **Plan mode** — make the repository read-only while you agree on an approach.
+- **Loop mode** — run a prompt now, then run it again on a schedule.
+- **Goal mode** — keep one objective in view until it is done or dismissed.
+- **Workflow mode** — run jobs with dependencies, timeouts, and artifacts.
+- **Voice mode** — replace typing with local speech.
 
-| Minor mode | Toggle               | Owned by                     |
-| ---------- | -------------------- | ---------------------------- |
-| goal       | `/goal`, `SPC g`     | `@agimon-ai/doompi-goal`     |
-| plan       | `/plan`, `SPC p`     | `@agimon-ai/doompi-plan`     |
-| loop       | `/loop`, `SPC l`     | `@agimon-ai/doompi-loop`     |
-| workflow   | `/workflow`, `SPC w` | `@agimon-ai/doompi-workflow` |
+### Domains
 
-Goal is assembled in `minimal`, `copilot`, custom major modes, and detached children rather
-than selected by a layer. It starts dormant: `/goal` is available, but its tools, system
-prompt, automatic continuation, and `GOAL` status stay off until an objective is accepted
-or an active Goal is restored. Paused, blocked, limited, and queue-waiting Goals retain the
-status item without retaining execution capabilities. Parent hosts load the Doom entry;
-detached children load the UI-independent Pi entry.
+A domain is a named group of Pi plugins. It carries the skills and MCP servers for one
+kind of work, and `/domains` switches it while the session is running.
 
-Each enabled minor mode publishes a label to a shared `MODES` line rather than painting a
-row of its own. The registry is `@agimon-ai/doompi-extension-contracts/mode`.
+A blog is not one task. Research it, draft it, make the assets, then review it. Turn on the
+`visual` domain while making assets; the other three steps have no reason to carry it.
 
-Existing `pi-goal.json` files remain readable. Both legacy `toolVisibility` values now mean
-that Goal tools are managed only while execution is operational; neither exposes tools in
-a dormant session. `experimental.goals` controls queues only.
+### Profile
 
-If an edited `modes.yaml` still defines or selects a Goal layer, remove that definition and
-its major-mode references, then run `doompi sync`. Normal `doompi init` preserves edited
-files. `doompi init --force` is a full template reset and may overwrite unrelated edits.
+An LLM has no house style until you give it one. A profile can supply a narrative, brand
+rules, or a different voice. It is optional; no profile is a perfectly good profile.
 
-## For autonomous agents
+## What this buys you
 
-### Minimal context
+Every tool schema and skill name competes for the same context. Loading less has two
+immediate effects:
 
-Fewer options, better choices. Domains cut the skill list and the tool list together. A
-domain that names three plugins gives the agent those plugins' skills and nothing else,
-and one with an `mcp` allowlist reaches only the servers and proxy upstreams it names.
+1. You spend fewer tokens before the work begins.
+2. The model has fewer plausible-but-wrong tools and skills to choose from.
 
-`--explain` prints what any combination costs before you launch it, and ends with the bill:
+The savings get larger when each workflow job starts with its own config instead of
+inheriting the last job's toolbox.
 
-```
-$ doompi --domains development --explain
-...
-skills: 24 (from 3 directories)
-
-context cost (tokens)
-  skills prompt       3,772  always on
-  persona                 0  always on
-  startup total       3,772
-  skill bodies       54,145  read on demand
-
-  Excludes MCP tool schemas, which the servers only report once connected,
-  and skills contributed by extensions, which register after startup.
-```
+### Copilot
 
-Every figure comes from files on disk, so two runs of the same selection print the same
-numbers and you can reproduce them on your own repository rather than trusting these.
+I got tired of remembering slash commands, so `SPC` is the map. It opens only when the
+draft is empty; a space in the middle of a prompt remains a space. Press it, read the
+choices, then press the next key.
 
-MCP tool schemas are the one cost this cannot price. They exist only after a server
-connects, and pricing them would mean spawning every configured server on a command meant
-to be instant. Scoping them is still a declared choice; the saving is just not counted here.
+When the keyboard is the wrong tool, autonomous Voice mode keeps the conversation going.
+You can talk to the agent while doing the chores instead of carrying a laptop around the
+house.
 
-A domain without an `mcp` key admits everything, and one unscoped domain in the selection
-unfilters the rest. Scoping applies only when every selected domain declares it.
+### Autopilot
 
-A domain can also take a named subset of one plugin's skills, by name or glob.
+Copilot helps while you are present. Loop and Workflow keep work moving when you are not.
+Together they can dispatch structured jobs from one live session.
 
-### Workflows
+#### Workflows
 
-Long autonomous work runs as workflows, in the shape a GitHub Actions user already knows:
-`on:`, `jobs:`, `needs:`, `steps:`, timeouts, and declared artifacts.
-
-The payoff is that every step names the session it wants. A workflow is where
-`--major-mode`, `--domains`, and `--profile` stop being things you type and become part of
-the definition, so one run can hand each job exactly the context that job needs and nothing
-else:
+GitHub Actions already has a decent vocabulary for long jobs, so Doompi reuses it. Each job
+declares the Doompi session it wants. Here, implementation gets coding tools; the release
+note waits for it and gets marketing context plus a brand voice:
 
 ```yaml
+on:
+  workflow_dispatch:
+
 jobs:
   implement:
-    needs: intake
     steps:
-      - name: Implement
+      - name: Build the feature
         timeout-minutes: 180
         artifacts: [implementation/report.md]
         interactiveRun:
@@ -377,10 +128,10 @@ jobs:
             doompi --major-mode dev --domains development --auto-stop \
               --cwd "$PWD" "$JOB_SYSTEM_PROMPT"
 
-  announce:
+  release-note:
     needs: implement
     steps:
-      - name: Draft the release note
+      - name: Write the release note
         timeout-minutes: 30
         artifacts: [marketing/release-note.md]
         interactiveRun:
@@ -390,211 +141,107 @@ jobs:
               --cwd "$PWD" "$JOB_SYSTEM_PROMPT"
 ```
 
-Two jobs, two different agents. `implement` runs under a major mode carrying lint and code
-intelligence and a domain carrying coding skills. `announce` drops both, takes a domain
-scoped to a handful of MCP servers, and adds a profile, so the release note comes out in a
-named persona's voice rather than the agent's own. Neither job can drift into the other's
-context, and the same job resolves the same way on every run.
-
-The one real departure from GitHub Actions is `extends:`, which lets a job inherit shared
-setup from a named template rather than repeating it.
-
-The engine itself is not in this package. `@agimon-ai/doompi-workflow` provides the in-session
-surface on `SPC w`, and its dispatcher exposes `list_workflows` to any session but scopes
-`launch_workflow` to the root session, so a subagent can look but not spawn. The `workflow`
-hook group is `core`, so it loads in any major mode.
-
-### Long runs
-
-Tasks, teams, runners, and compaction share one working state, so a long autonomous run
-does not lose its place.
-
-- **Tasks** (`SPC t`) are a file-backed graph with dependencies and delegation, not a
-  scratch list.
-- **Teams** (`SPC a`) run named subagents asynchronously against that same board,
-  sequentially or in parallel.
-- **Runners** (`SPC r`) replace the bash tool and detach long commands, then reconcile
-  them afterwards.
-- **Compaction** runs on a three-pass ladder in a worker thread, so the session never
-  blocks on it.
+#### Loop
 
-The integration is the point. When compaction summarizes, it does not guess at
-coordination state: it reads the live plan, tasks, and team snapshot, and commits them
-next to the summary as authoritative rather than leaving them to be reconstructed from
-prose. Detached runners reconcile themselves once the context has been rewritten. The
-agent comes out the other side knowing what it was doing, what is still running, and who
-is doing what.
+Workflow definitions are exposed like skills, so the agent can choose one for the job. A
+loop can send a subagent to fetch the next task, then dispatch the workflow that matches
+it. One session becomes the dispatcher instead of the place every job has to fit.
 
-## Core is not a layer
+## Features
 
-Telemetry, workflow orchestration, Goal's dormant runtime, the dispatch loop, and editor
-plumbing ship unconditionally and are absent from `modes.yaml` on purpose. They are the
-reason the harness exists, so making them optional would only create broken configurations.
-Layers are for opinions, not foundations.
+Doompi is a distribution, not one giant extension. Each package owns one job; shared TUI
+and session contracts make them behave like one. Use the defaults together or replace
+them one at a time.
 
-## Who owns what
+### Configuration and composition
 
-Doom Pi is a meta-package. It depends on the Doom closure (`@agimon-ai/doompi-*`) and composes
-it, and it depends on nothing that belongs to the repository consuming it. The Agiflow and
-Agent Hooks extensions are consumer-owned: the repository declares them in its own
-`.doom/modes.yaml` and installs them itself, and they load after the Doom packages.
+`@agimon-ai/doompi` is both an extension and the command-line config compiler. The
+`doompi init` command writes the config; `doompi sync` resolves every major mode and
+domain into a distribution Pi can load quickly. A large major mode with 15 extensions
+adds only 400 ms of code startup time.
 
-That split decides where a specifier resolves. A package the repository declares resolves
-from the repository root, walking its module chain; anything that does not resolve there
-falls back to what ships with the installed meta-package. So a consumer can add a layer
-without Doom Pi knowing the package exists, and Doom Pi can ship its own closure without
-the consumer declaring it.
+### Leader key
 
-Package resources follow the same rule: the UI theme is shipped by `@agimon-ai/doompi-ui`
-and the workflow-recovery skill by `@agimon-ai/doompi-workflow`, each declared in its own
-manifest, so an installed package is discoverable without this checkout. Every Doom package
-publishes through an explicit `files` allowlist, which keeps repository material such as
-`docs/ideas/` out of any tarball.
+`@agimon-ai/doompi-ui` turns `SPC` into a map of the available commands. It stays out of
+the way when a draft is not empty, and other packages contribute bindings through one
+leader API instead of hardcoding their own menus.
 
-A repository is recognised by a Doom or trusted Pi marker: a `.doom/` directory, or an
-existing `.pi/settings.json`. No Nx, pnpm workspace, or plugins profile is required, so a
-plain repository that installs the package can launch it.
+### Agent team
 
-## Lazy config
+`@agimon-ai/doompi-team` runs named subagents asynchronously against a shared task board.
+They can work in parallel, message one another, and use the model policy attached to the
+selected Team package entry. `SPC a l` lists available agents; `SPC a r` opens current-session runs and
+their controls.
 
-Under the launcher, everything is resolved per run and nothing is written back into the
-repository. Editing a YAML file is the entire change.
+### Tasks
 
-`doompi sync` trades that for a pinned setup: the same resolution runs once and lands in
-`.pi/doom/`, while `.pi/settings.json` keeps the stable `@agimon-ai/doompi` extension name.
-An internal `.pi/@agimon-ai/doompi` package alias lets Pi resolve that stable name; the
-package entry then locates and dynamically loads the generated bootstrap from synced state.
-Edit a YAML file and the next session says the config changed, the way doom emacs asks you
-to re-run `doom sync`.
+`@agimon-ai/doompi-task` keeps a task graph on disk, not a disposable checklist in the
+transcript. Dependencies and delegation survive compaction, and work can be handed to a
+subagent—including a smaller model when the job does not need the expensive one.
 
-`doompi init` seeds `~/.pi/.doom` with all five file names, but only `config.yaml` from
-there is read at runtime. Major modes, domains, profiles, and hooks are always read from the
-repository `.doom/`, so the other four seeded files affect nothing beyond the inputs hash.
+### Auto-compact
 
-Either way the hook registry compiles to the files other frontends read before any harness
-code runs, and `doompi sync` regenerates them.
+Ordinary compaction waits for one summary to save an overgrown session.
+`@agimon-ai/doompi-autocompact` leaves checkpoints instead:
 
-## Other frontends
+1. At 50%, it writes the first compact summary.
+2. Later, it combines that summary with the messages since; the model decides whether the
+   result is ready to use.
+3. On the third pass, it combines them again and forces compaction.
 
-Pi is the primary frontend. Claude Code, Codex, and Antigravity run through
-`doompi compat <provider>` and share the same domain config as far as each can:
+The work runs off-thread. Each checkpoint carries the live plan, task graph, team state,
+and user request with it, so coordination does not have to be guessed back out of prose.
 
-|                     | Pi                | Claude Code                   | Codex                    | Antigravity         |
-| ------------------- | ----------------- | ----------------------------- | ------------------------ | ------------------- |
-| domains to plugins  | yes               | yes                           | yes                      | yes                 |
-| hooks               | from the registry | generated `settings.json`     | generated `hooks.json`   | copied `hooks.json` |
-| MCP servers         | scoped            | scoped                        | unscoped                 | scoped              |
-| MCP proxy upstreams | scoped            | scoped                        | scoped                   | scoped              |
-| major mode          | packages + hooks  | shared hook groups            | shared hook groups       | shared hook groups  |
-| personas            | system prompt     | `--append-system-prompt-file` | `developer_instructions` | no                  |
+### MCP
 
-Compatibility frontends use the selected major mode for shared hook state. Layer packages
-and Pi extensions are loaded only by Pi.
-
-Antigravity is the odd one. It reads its configuration from the workspace and from the
-user's home directory rather than from arguments, so every selection is written to disk
-before launch and reverted when it is no longer selected. Everything the harness writes is
-tracked in a managed-state file, so a file you created by hand is never silently replaced.
-Its hooks are copied from `.antigravity-local/hooks.json`, which is maintained by hand
-rather than generated from the registry.
+`@agimon-ai/doompi-mcp` is the gate between a session and its servers. It reads `.mcp.json`
+and other common formats, then exposes only the servers and proxy upstreams allowed by the
+selected domains. Switch domains and that boundary reloads with them.
 
-Where a concept has no equivalent, it is left out rather than approximated.
-
-## Files
+### Ask user question
 
-All Doompi configuration lives in `.doom/`, committed to git.
+`@agimon-ai/doompi-user-feedback` gives the agent a structured question that actually
+waits for an answer. In autonomous Voice mode it skips the modal, narrates the choices,
+and accepts the next spoken response as an ordinary user message.
 
-```
-.doom/
-  config.yaml               projectTrust, plus the selection sync pins
-  domains.yaml              domains, plus aliases for shorthand bundles
-  modes.yaml          layer definitions and the named major modes built from them
-  hooks.yaml                canonical hooks for all three frontends
-  profiles.yaml             persona and environment profiles
-
-agents/<product>/<person>/  persona source, referenced never copied
-```
-
-`doompi sync` writes into `.pi/`:
-
-```
-.pi/settings.json           committed; sync owns extensions, themes, and theme
-.pi/doom/                   generated and gitignored
-  state.json                environment, resolved paths, and the inputs hash
-  mcp.json  mcp-extension.ts  agents/  persona.md  doom-pi-dark.json
-  run/<pid>/                one session's live switches, never the baseline
-    harness-state.json      that session's own state, owned by its process
-```
-
-### One owner for the state
+### Logging and telemetry
 
-The resolved matrix a session runs on is a file, not a set of variables.
-`DOOMPI_STATE` points at it, and everything else the harness exports is derived from
-it: a projection published for the readers that can only see an environment, which are bash
-hooks, the shell launchers, `agent-hooks`, and any process spawned by any of them. Two
-fields never appear there at all, because nothing outside `@agimon-ai/doompi-config` reads
-them and every hook spawn would otherwise copy them: the plugin hook list and the profile's
-environment defaults.
+Doompi telemetry records counters and spans, never prompt text or file content, in a local
+SQLite database by default. `SPC h l` opens the metrics, and `@agimon-ai/log-sink-mcp`
+gives the agent CLI tools for inspecting its own runs.
 
-Ownership is per process, and that is the point. Doom Team subagents run detached, from an
-environment snapshot, and can outlive the parent that spawned them. So a spawner writes the
-child a file of its own in that run's directory, and any process that finds a file it does
-not own copies it before its first write. A child can neither corrupt its parent's session
-nor lose its own when the parent cleans up.
+### Plan mode
 
-It also regenerates the two hook files the other frontends read before any harness code
-runs, which live outside `.pi/`:
+A promise to "only plan" is not a permission boundary. `@agimon-ai/doompi-plan` makes the
+repository read-only while the agent explores, persists the plan, and hands it back for
+approval. Use `SPC p p` for normal planning, `SPC p d` for debug planning, `SPC p f` for
+the Fable flow, and `SPC p e` to exit. Turn it on when the approach should be settled
+before the files move.
 
-```
-.claude/settings.json       the "hooks" key only; every other key is preserved
-.codex-local/hooks.json     the whole file
-```
-
-Edit `hooks.yaml` and re-run `doompi sync` to regenerate both.
-
-## Selection
+### Loop mode
 
-Use singular `--profile <name>` for one persona and its environment defaults. Use
-`--domains <name[,name...]>` for plugin bundles. Both `--major-mode` and `--profile` take
-exactly one name, reject a comma, and can be given only once. The removed `--layer`,
-`--layers`, `--profiles`, and `--target` flags throw and point at the replacement, and so
-does the removed `DOOMPI_LAYER` variable: a stale export is worth an error rather than a
-session quietly starting on the default.
+`@agimon-ai/doompi-loop` is an in-session scheduler. It runs a prompt immediately and then
+repeats it on an interval; several loops can coexist. Use `SPC l s` to start one and
+`SPC l l` to list or stop them. It is for recurring checks and prompts that belong to the
+current session.
 
-Defaults when you name nothing: `defaultMajorMode` from `.doom/modes.yaml` and the
-`defaultDomains` list from `.doom/domains.yaml`. Omitting those fields preserves the
-compatible fallbacks: major mode `copilot`, plus domain `marketing` for the legacy
-`marketing` mode or `default` for every other mode.
+### Goal mode
 
-Environment equivalents are `DOOMPI_MAJOR_MODE`, `DOOMPI_DOMAINS`, and `DOOMPI_PROFILE`.
-`DOOMPI_PRESET` and `DOOMPI_ADDITIONAL_DIRS` work the same way for `--preset` and
-`--add-dir`. An empty `DOOMPI_DOMAINS` means no domains, not the default. No profile is
-selected unless one is named.
+`@agimon-ai/doompi-goal` pins one objective to the session until it completes or you end
+it. Use `SPC g g` for status, `SPC g s` to start, `SPC g e` to end, and `SPC g p` for
+history. Finished goals leave the prompt and tools behind but remain in history when you
+want to restart one.
 
-There is one variable per axis. A nested run inherits its launcher's choice because the
-launcher writes the resolved value into the child environment under the same name, so
-anything you exported yourself is what a top-level run uses and what a spawned run
-overrides. These used to be two variables, `DOOM_PI_*` for the selection and
-`AGENT_HARNESS_*` for the resolved projection, with the second outranking the first. Any
-surviving `AGENT_HARNESS_*` variable now throws and names its replacement, because a stale
-export in a shell profile is worth an error.
+### Workflow mode
 
-`DOOMPI_LAYERS`, plural, is a different variable from `DOOMPI_LAYER`. It carries the
-resolved layer components rather than the mode that selected them.
+`@agimon-ai/doompi-workflow` runs GitHub Actions-style job graphs with dependencies,
+timeouts, artifacts, and a separate Doompi session for each step. Use `SPC w w` to launch,
+`SPC w l` to manage, `SPC w r` to recover a failed run, and `SPC w e` to give the agent
+workflow tools or take them back. It is for work that needs hard job boundaries and
+explicit handoffs rather than one long conversation.
 
-A repository can also pin the full selection used by a bare `doompi sync` or
-`doompi build`. A flag still wins, then an exported variable, then the matching
-`selection` field, then `modes.yaml`'s `defaultMajorMode` or `domains.yaml`'s
-`defaultDomains`:
-
-```yaml
-# .doom/config.yaml
-selection:
-  majorMode: dev
-  domains: [development]
-  profile: house-voice
-```
+### Voice mode
 
-Pi asks once before it trusts a project and loads `.pi` resources, so a synced session
-prompts on first run regardless of `projectTrust`, which reaches Pi as a launcher flag.
-Answer yes, or run `/trust`.
+`@agimon-ai/doompi-voice` records and transcribes speech locally; audio stays on the
+machine. Use `SPC v v` for one recording or `SPC v a` to toggle autonomous capture. It
+replaces the keyboard without replacing the work already in progress.