mind-palace-graph 0.3.0

package/skills/mpg-context/references/anti-patterns.md

@@ -0,0 +1,133 @@
+# Anti-patterns
+
+What NOT to do with mpg, and why.
+
+## Search
+
+**Don't use `deep` effort for a quick scan.**
+`quick` is 1/10th the cost. Reserve `deep` (2000-token windows, 100
+nodes) for the final answer-grounding pass, not initial recon.
+
+**Don't search the same pattern twice without stashing.**
+If you'll need a pattern more than once, `mpg_stash` it the first
+time. Stash storage is cheap; re-running a search is not.
+
+**Don't use mpg to read a single file.**
+The host's `read` tool is faster and clearer. mpg is for *searching*
+across multiple files, not retrieving one.
+
+**Don't forget `page: 1` when paginating.**
+Without an explicit page, mpg returns everything (up to `max_nodes`).
+For results expected to exceed 10 hits, pass `page: 1, page_size: 5`
+so you can decide whether to keep going.
+
+**Don't omit `--in` for non-trivial searches.**
+With no source, mpg reads stdin or errors out. Always be explicit
+about where you're searching.
+
+## Mind palace
+
+**Don't stash and immediately drop.**
+If you knew you weren't going to need it, you shouldn't have stashed.
+The cost is the stash decision, not the storage.
+
+**Don't reuse stash names across unrelated investigations.**
+A new investigation = a new task = a new palace (`--mp-path` /
+`MPG_MIND_PALACE`) OR a name-prefixed stash. Reusing names silently
+overwrites or merges, which surprises the model later.
+
+**Don't use comma-separated stash names in `compose` without quoting.**
+The shell may split them. Prefer space-separated:
+`--mp-compose auth-todos perf-hotspots`.
+
+**Don't create stashes with names that look like flags.**
+Avoid names like `--help`, `-v`, etc. mpg handles these but the LLM
+should not have to disambiguate.
+
+**Don't skip `--mp-prune-dry-run`.**
+Always preview a prune before committing. Stash mistakes are
+permanent — the JSON is overwritten in place.
+
+**Don't pound a shared palace with hundreds of near-simultaneous writes.**
+v0.2.4 added a `.lock` + atomic-rename write path, so concurrent
+writers no longer lose data — but they *do* serialize. A swarm of
+agents stashing in tight loops over one palace turns into a
+single-writer queue. For high-write fan-out, give each agent its own
+palace (Layout A in `multi-agent.md`) and compose at the end.
+
+**Don't ignore a "WARNING — mind palace is corrupt" stderr line.**
+When mpg encounters an unparseable palace it copies the file aside as
+`<palace>.corrupt.<timestamp>`, taints the in-memory copy, and
+**refuses to save** for the rest of that process. If you press on
+without inspecting the backup, the next process will start from a
+real empty palace once `MPG_FORCE_RESET=1` is set — you'll lose every
+stash that wasn't already on disk in a parseable state. Read the
+backup file first; recover by hand-merging or by deleting the
+corrupt original.
+
+**Don't ignore `result.errors[]`.**
+When some sources error and others succeed, `status` is `"partial"`
+and the per-source failures land in `errors: [{source, message}]`.
+Treating a partial result as a clean "no matches" leads the agent
+into wrong conclusions about the corpus. Always check the array;
+if it's non-empty, decide explicitly whether to retry, fall back,
+or surface the failure.
+
+**Don't stash without tags.**
+At >10 stashes, untagged ones become impossible to filter or prune.
+Tag every stash with at least one topic word.
+
+**Don't forget TTL on transient findings.**
+Use `--mp-ttl 2h` (or similar) on scratch / exploratory stashes so
+they auto-reap. Manual pruning at agent shutdown is fine too, but TTL
+is the cheaper default. Combined with `--mp-prune-expired` at the
+start of a session, this is how a long-running palace stays small
+without manual gardening.
+
+**Don't let the palace grow unbounded across a long-context task.**
+Stash count creep is the silent killer of multi-hour agent loops:
+`--mp-from` over a 200-stash palace gets noisy fast. Set a budget
+(say 20–30 active stashes) and run `--mp-prune-keep 30` or
+`--mp-prune-older-than 6h` every few major turns. Always
+`--mp-prune-dry-run` first.
+
+**Don't build dense relationship graphs you won't traverse.**
+Edges are cheap, but a graph nobody walks is noise. Only `--mp-link`
+when you actually plan to `--mp-related` or `--mp-graph` later.
+
+## Sources
+
+**Don't pipe gigabyte files to `--cmd` or `--stdin`.**
+mpg buffers in memory (64 MB cap for `--cmd`). For huge corpora, use
+`--in` with file paths so ripgrep streams.
+
+**Don't `--url` against SPA-rendered pages.**
+mpg fetches raw HTML — no JS execution. SPAs return empty shells.
+Use a real HTTP client + render step upstream if you need it.
+
+**Don't combine `--cmd` and `--stdin` for the same content.**
+Pick one. Combining them is legal but confusing — they coexist for
+**different** content sources, not the same one.
+
+## Output format
+
+**Don't parse `llm` format programmatically.**
+It's designed for the model to read. For machine consumption use
+`--format json`.
+
+**Don't strip the `<mpg result ...>` wrapper before showing the
+result to the model.**
+The header carries the pattern, effort, status, pagination state, and
+token budget — load-bearing for the model's reasoning. Keep it.
+
+## Integration
+
+**Don't register the MCP server at project scope when you want it
+everywhere.**
+Use `--scope user` so it's available across all projects:
+`claude mcp add --scope user mpg -- node <path>`.
+
+**Don't shell out from inside an MCP host for the five core tools.**
+That's what the MCP server exists for. Shell-out only for the wider
+mind-palace surface (relationships, prune, intersect, except) that
+isn't exposed via MCP yet.

package/skills/mpg-context/references/integration.md

@@ -0,0 +1,123 @@
+# mpg Integration Paths
+
+mpg works through three different surfaces. Pick the one that matches
+how your agent calls tools.
+
+| Path | Best for | Cost |
+| :--- | :--- | :--- |
+| **MCP server** | Claude Desktop, Claude Code, Cline, Windsurf, Continue.dev | One-time config; auto-discovery of tools |
+| **CLI shell-out** | Any agent that can `Bash`/`exec` | One-time `npm install -g`; no tool registration |
+| **Programmatic import** | Custom Anthropic / Google SDK agents | TS/JS import; full type safety |
+
+## MCP server
+
+mpg ships an MCP server that exposes the five core tools over stdio.
+No network ports, no extra config beyond the launch command.
+
+```json
+{
+  "mcpServers": {
+    "mpg": {
+      "command": "node",
+      "args": ["<path-to-global-install>/dist/mcp-server.js"]
+    }
+  }
+}
+```
+
+For Claude Code, register via the CLI (recommended, user scope makes it
+available across all projects):
+
+```bash
+claude mcp add --scope user mpg -- node "<global-install>/dist/mcp-server.js"
+```
+
+The exposed tools are `mpg_search`, `mpg_stash`, `mpg_list_stashes`,
+`mpg_get_stash`, `mpg_drop_stash`. The wider mind-palace surface
+(relationships, prune, intersect, etc.) is **not** available through
+MCP today — drop to CLI for those.
+
+## CLI shell-out
+
+Any agent that can run a shell command can use mpg directly:
+
+```bash
+mpg "TODO" --in src/ --effort quick --format json
+```
+
+The `--format json` output is designed for machine consumption: it
+includes `status`, `nodes[]`, `pagination`, `total_nodes`, etc. — feed
+it back into the agent as the tool result.
+
+When to prefer CLI over MCP:
+
+- You need a flag that isn't exposed as an MCP tool (relationships,
+  prune, intersect, except, TTL).
+- You're chaining mpg with other shell tools (e.g.
+  `mpg "errors" --cmd "git log -100" --mp-stash recent`).
+- You want a quick recon and the MCP roundtrip is overkill.
+
+When to prefer MCP over CLI:
+
+- You want the tool name visible to the model in its tool list (helps
+  with tool selection).
+- You're running in a host that doesn't auto-allow `mpg` in Bash
+  permissions (MCP bypasses Bash permission prompts).
+
+## Programmatic import
+
+For TS/Node agents that embed mpg directly:
+
+```ts
+import {
+  search,
+  stash,
+  listStashes,
+  getStash,
+  dropStash,
+  claudeTools,
+  geminiTools,
+} from "mpg-cli";
+
+// Run a search
+const result = await search({
+  pattern: "TODO",
+  in: ["src/"],
+  effort: "quick",
+  page: 1,
+  pageSize: 5,
+});
+
+// Stash it for later composition
+await stash(result, {
+  name: "auth-todos",
+  note: "Auth TODOs to review",
+  tags: ["auth", "p0"],
+});
+
+// Register with Anthropic SDK
+const response = await anthropic.messages.create({
+  model: "claude-sonnet-4-6",
+  tools: [...claudeTools],
+  // ...
+});
+
+// Or Google SDK
+const model = genAI.getGenerativeModel({
+  model: "gemini-2.5-pro",
+  tools: [{ functionDeclarations: geminiTools }],
+});
+```
+
+Pre-built tool schemas are exported as `claudeTools` and `geminiTools`.
+Each entry is shaped for its respective provider — no manual schema
+authoring needed.
+
+## Quick decision
+
+```
+Claude Desktop / Code / Cline / Windsurf / Continue?  → MCP
+Custom Anthropic / Google SDK agent in TS/Node?       → import
+Pi agent, Aider, Cursor, shell-only agent?            → CLI
+Need relationships / prune / intersect right now?     → CLI (even from inside an MCP host)
+```

package/skills/mpg-context/references/mind-palace.md

@@ -0,0 +1,217 @@
+# Mind Palace — full surface
+
+The palace is a JSON file (default `./.mpg/mind-palace.json`) holding
+named **stashes** of search results. Stashes are addressable: future
+searches can use them as inputs, compose them, intersect them, link
+them into a graph, and prune them by age/tag/count.
+
+## Lifecycle
+
+```
+SEARCH   →   STASH    →   COMPOSE / FROM / INTERSECT / EXCEPT
+              ↓
+            LIST  ←  TAG, FILTER, PAGINATE
+              ↓
+            LINK  →  RELATED  →  GRAPH (traverse)
+              ↓
+            PRUNE (by age / count / tag / TTL / all)  →  DROP
+```
+
+## Stash operations
+
+| CLI flag | What it does |
+| :--- | :--- |
+| `--mp-stash <name> <note>` | Save current search's results. Merges into existing (dedup by file:line) unless `--mp-replace`. |
+| `--mp-stash-note <note>` | Set note separately from the stash flag. |
+| `--mp-stash-tag <tag>` / `--mp-tag <tag>` | Tag the stash (repeatable). |
+| `--mp-replace` | Overwrite an existing stash outright. |
+| `--mp-ttl <duration>` | Auto-expiry (`30m`, `2h`, `7d`). Expired stashes are reaped on next `--mp-list` / `--mp-get`. |
+| `--mp-stash-locations` | Save only file:line pointers (no context text). Use for lean stashes when you'll re-search later. |
+
+## Recall operations
+
+| CLI flag | What it does |
+| :--- | :--- |
+| `--mp-list` | List all stashes with relative timestamps (`3m ago`, `2d ago`). |
+| `--mp-list-tag <tag>` | Filter list by tag (repeatable). |
+| `--mp-get <name>` | Show full contents of one stash. |
+| `--mp-drop <name>` | Remove a stash. |
+
+## Set operations over file lists
+
+These all run a **fresh search**, scoped to a derived file list.
+
+| Operation | CLI | Files searched |
+| :--- | :--- | :--- |
+| **Scope** | `--mp-from <name>` | Files in the named stash |
+| **Union** | `--mp-compose <a> <b> ...` | Files in **any** of the named stashes |
+| **Intersection** | `--mp-intersect <a> <b> ...` | Files in **all** of the named stashes |
+| **Difference** | `--mp-except <a>` or `--mp-except <a> <b> ...` | Files **not** in the named stash(es) |
+
+Examples:
+
+```bash
+# Re-search a single stash's files
+mpg "rate.limit" --mp-from auth-todos
+
+# Files mentioned in any of two stashes
+mpg "TODO" --mp-compose auth-todos perf-hotspots
+
+# Files mentioned in BOTH stashes
+mpg "TODO" --mp-intersect auth-todos perf-hotspots
+
+# Files in auth-todos but NOT in deprecated
+mpg "TODO" --mp-except deprecated
+```
+
+The MCP tools today expose `from` and `compose` only — drop to CLI for
+`intersect` and `except`.
+
+## Relationships (the graph in mind-palace-graph)
+
+Stashes can be linked into a directed graph. The graph is what lets
+you **traverse the investigation by intent** instead of by remembering
+stash names — `--mp-graph <root> 3` reconstructs an entire thread
+topology in one CLI call, which is the lifeline when a conversation
+gets compacted away mid-task.
+
+| CLI flag | What it does |
+| :--- | :--- |
+| `--mp-link <from> <to> <type> [note]` | Create a directed edge. |
+| `--mp-unlink <from> <to>` | Remove an edge. |
+| `--mp-related <name>` | Show all inbound + outbound neighbors of `name`. |
+| `--mp-graph <name> [depth]` | BFS traversal from `name` up to `[depth]` levels (default 3). |
+
+### Edge type conventions
+
+Edge types are unenforced strings, but consistent vocabulary makes the
+graph readable later. Common types:
+
+| Type | Meaning |
+| :--- | :--- |
+| `depends-on` | "Reading B is a prerequisite for reading A." |
+| `supersedes` | "A is the current view; B is the old one. Ignore B." |
+| `see-also` | "B is a related thread worth surfacing alongside A." |
+| `parent-of` / `child-of` | Hierarchical decomposition of one investigation into subtopics. |
+| `blocks` | "A can't ship until B is resolved." |
+| `contradicts` | "A and B disagree — reconciliation needed." |
+
+Pick a vocabulary at the start of an investigation and stay consistent
+within it. Mixing `depends-on` with `requires` for the same concept
+makes `--mp-graph` output noisy without adding signal.
+
+### Workflow: tracking a multi-thread investigation
+
+The pattern that pays off: build stashes as you investigate (always
+with TTLs + tags), link them the moment you notice a relationship,
+then traverse by intent in future sessions.
+
+```bash
+# Session 1 — building the topology
+mpg "JWT" --in src/auth/   --mp-stash auth-jwt    --mp-tag rewrite --mp-ttl 24h
+mpg "JWT" --in docs/spec/  --mp-stash spec-jwt    --mp-tag rewrite --mp-ttl 24h
+mpg "JWT" --in src/legacy/ --mp-stash legacy-jwt  --mp-tag rewrite --mp-ttl 24h
+
+mpg --mp-link auth-jwt spec-jwt   see-also   "implementation of the spec"
+mpg --mp-link auth-jwt legacy-jwt supersedes "post-rewrite, legacy goes away"
+
+# Session 2 — navigation, no need to remember names
+mpg --mp-related auth-jwt   # one-hop neighbors with edge labels
+mpg --mp-graph auth-jwt 3   # full BFS, three hops out
+
+# When the conversation gets compacted and you've lost the thread:
+mpg --mp-graph <known-root> 3
+# → reconstructs the whole investigation topology, with edge types
+#   that tell you what's current, what's superseded, what blocks what.
+```
+
+### When to link (and when not to)
+
+1. **Only link what you'll traverse.** Edges are cheap to make and
+   cheap to store, but a graph nobody walks is just noise on
+   `--mp-related`. If you wouldn't run `--mp-graph` later, skip the
+   link.
+2. **Link when discovery is fresh.** The right moment is when you
+   notice the relationship. Three sessions later you won't remember
+   why two stashes mattered together.
+3. **Don't link across unrelated tasks.** If you maintain one palace
+   per task (`MPG_MIND_PALACE=.mpg/<task>.json`), this is automatic —
+   cross-task links can't even be expressed.
+4. **Relink with confidence — it's atomic.** `--mp-unlink` then
+   `--mp-link` is a no-op-loss operation; the diff-based save in
+   v0.2.5 ensures both edits land cleanly even under concurrent
+   writers.
+
+### Quick examples by use case
+
+| Situation | Linkage |
+| :--- | :--- |
+| Refactor that obsoletes an old subsystem | `--mp-link new-impl old-impl supersedes "after-rewrite"` |
+| Implementation depends on a shared library you've already mapped | `--mp-link feature-x lib-y depends-on "uses Y's session API"` |
+| Spec and code drift you need to reconcile | `--mp-link spec-claim impl-reality contradicts "spec says X, code does Y"` |
+| Decomposing an epic into discrete threads | `--mp-link epic-payments stripe-webhooks child-of` then `--mp-graph epic-payments 2` to walk the whole epic |
+| Cross-referencing parallel tracks (impl + tests + docs) | Three stashes, two `see-also` edges between them |
+
+## Pruning
+
+A palace grows unbounded unless pruned. Always preview first.
+
+| CLI flag | Effect |
+| :--- | :--- |
+| `--mp-prune-older-than <dur>` | Stashes not updated within duration. |
+| `--mp-prune-keep <n>` | Keep only the N most recently updated. |
+| `--mp-prune-tag <tag>` | All stashes carrying the tag. |
+| `--mp-prune-expired` | All TTL-expired stashes. |
+| `--mp-prune-all` | Entire palace. Requires `--mp-prune-confirm`. |
+| `--mp-prune-dry-run` | Preview only — do not delete. **Use this first.** |
+
+```bash
+mpg --mp-prune-older-than 7d --mp-prune-dry-run    # preview
+mpg --mp-prune-older-than 7d                       # commit
+```
+
+TTL-tagged stashes are *also* auto-reaped on every `--mp-list` or
+`--mp-get` — no explicit prune required for the TTL case.
+
+## Multi-palace isolation
+
+Use a separate palace per task to avoid context bleed.
+
+```bash
+# Explicit per-invocation:
+mpg "TODO" --in src/ --mp-stash t42 "..." --mp-path .mpg/task-42.json
+
+# Or via env, so all subsequent calls use the same palace:
+export MPG_MIND_PALACE=.mpg/task-42.json
+mpg "TODO" --in src/ --mp-stash t42 "..."
+mpg --mp-list
+```
+
+The default `./.mpg/mind-palace.json` is searched walking up from CWD
+(like `.gitignore`), so monorepo subdirs share a project palace by
+default.
+
+## Storage format
+
+Each stash holds:
+
+```jsonc
+{
+  "name": "auth-todos",
+  "note": "Auth TODOs to review",
+  "tags": ["auth", "p0"],
+  "pattern": "TODO",
+  "effort": "quick",
+  "nodes": [ /* file:line + context */ ],
+  "sources": [ /* canonical file paths */ ],
+  "created_at": "2025-...",
+  "updated_at": "2025-...",
+  "expires_at": "2025-..." // if --mp-ttl was set
+}
+```
+
+Plus a top-level `relationships: [{from, to, type, note, created_at}]`
+array for edges.
+
+The file is plain JSON — safe to inspect, version-control, or hand-edit
+for one-off corrections.

package/skills/mpg-context/references/multi-agent.md

@@ -0,0 +1,147 @@
+# Multi-agent palace patterns
+
+The mind palace is a single JSON file. Multiple processes / agents
+sharing it coordinate via a per-palace `.lock` file plus an atomic
+write path (tmp file + rename + on-disk re-read-and-merge under the
+lock). The race conditions that earlier versions had — silently lost
+stashes when two agents stashed in the same second — no longer apply.
+
+You still pick a layout based on **what kind of context you want
+agents to share**, not based on data-loss risk.
+
+## Recommended layouts
+
+### Layout A: per-agent isolated palaces
+
+Each agent gets its own palace file. Use when agents are pursuing
+genuinely independent investigations and you don't want context bleed
+between them.
+
+```bash
+# Agent A
+MPG_MIND_PALACE=.mpg/agent-a.json mpg "TODO" --in src/ --mp-stash mine "..."
+
+# Agent B
+MPG_MIND_PALACE=.mpg/agent-b.json mpg "TODO" --in src/ --mp-stash mine "..."
+```
+
+Pros: zero lock contention, easy to garbage-collect (just `rm` the
+file when the agent finishes), one task = one palace = one mental model.
+Cons: agents can't see each other's findings — you have to manually
+copy or merge if context-sharing turns out to matter.
+
+### Layout B: shared read-only palace + per-agent scratch
+
+One canonical palace, populated by a coordinator agent. Worker agents
+**read** from it (`--mp-from`, `--mp-compose`, `--mp-list`,
+`--mp-get`) but write to their own scratch palaces.
+
+```bash
+# Coordinator stashes the project's key contexts:
+MPG_MIND_PALACE=.mpg/shared.json mpg "TODO" --in src/auth/ \
+  --mp-stash auth-overview "Auth subsystem"
+
+# Workers read from shared, write to their own scratch:
+MPG_MIND_PALACE=.mpg/worker-1.json \
+  mpg "rate.limit" --mp-from auth-overview --mp-stash w1-findings "..."
+```
+
+Pros: shared context with a clear authorship model — coordinator
+owns the canonical map, workers own their own findings.
+Cons: workers can't contribute back to the shared palace without an
+explicit merge step.
+
+### Layout C: shared read-write palace
+
+All agents share one palace. As of v0.2.4 this is safe under
+concurrent writes: each save acquires a `.lock` file, re-reads the
+on-disk palace under the lock, merges any stashes the other writer
+added, then renames atomically into place.
+
+```bash
+# All agents
+export MPG_MIND_PALACE=.mpg/team.json
+```
+
+Pros: maximum visibility — everyone sees everyone's findings as
+soon as they're written.
+Cons: lock contention if many agents stash in a tight loop. For
+extreme write loads (autopilot/swarm patterns with hundreds of
+near-simultaneous stashes), still prefer Layout A or B — the lock
+will serialize you, and serialization at high write rates means
+the slowest agent's stash latency becomes everyone's stash latency.
+
+## Concurrency model (what the lock actually does)
+
+mpg's write path is:
+
+1. Acquire `<palace>.lock` (sibling file, `O_EXCL`). Backs off with
+   jitter for up to 2s; force-breaks a stale lock older than 30s.
+2. Read the on-disk palace JSON (the version *some other process*
+   may have written since we last loaded).
+3. Merge stashes the on-disk version has that our in-memory copy
+   doesn't (last-write-wins on collision by stash name).
+4. Write to `<palace>.tmp.<pid>.<rand>` then atomically rename onto
+   the real path.
+5. Release the lock.
+
+Consequence for agent design:
+
+- **Two agents stashing different stash names in parallel: both land.**
+  The merge step in (3) ensures it.
+- **Two agents stashing the same name in parallel: last writer wins
+  for that stash.** This is intentional — `mpg_stash` with `replace`
+  semantics is supposed to overwrite. If you want a merge of two
+  parallel updates to the same stash, model them as two different
+  names and compose them later.
+- **A crashed agent that died mid-write leaves a stale lock.** Other
+  agents will detect this (mtime > 30s) and break it. No manual
+  cleanup needed unless something is very wrong (in which case
+  `rm <palace>.lock`).
+- **A corrupted palace file is preserved, not overwritten.** mpg
+  copies it aside as `<palace>.corrupt.<timestamp>` and **refuses
+  to save** for the rest of that process unless `MPG_FORCE_RESET=1`
+  is set. Inspect the backup before forcing.
+
+The palace file is still plain JSON. If you suspect divergence between
+two agents' worldviews, diff the file directly — there's no opaque
+binary state.
+
+## Naming conventions for shared palaces
+
+When multiple agents share a palace, name stashes with a prefix to
+avoid collisions and make ownership obvious:
+
+```
+<agent-id>-<topic>           e.g. coordinator-auth, worker1-perf
+<task-id>-<topic>            e.g. t42-auth, t42-perf
+<phase>-<topic>              e.g. grounding-auth, planning-auth
+```
+
+Tag with the agent or task ID too:
+
+```bash
+mpg "TODO" --in src/ --mp-stash w1-auth "Worker 1 auth findings" \
+  --mp-tag worker1 --mp-tag task-42
+```
+
+That makes `--mp-list-tag worker1` or `--mp-prune-tag worker1` work
+cleanly when a worker is done.
+
+## Lifecycle hygiene
+
+- **Use TTL on transient findings**: `--mp-ttl 2h` on a worker's
+  exploratory stashes so the palace self-cleans.
+- **Prune by tag on agent shutdown**: when a worker finishes, run
+  `mpg --mp-prune-tag <worker-id>` to drop its scratch.
+- **Snapshot before destructive ops**: `cp .mpg/shared.json .mpg/shared.bak`
+  before any `--mp-prune-*`.
+
+## Anti-patterns
+
+- **Multiple concurrent writers to one palace with high frequency.**
+  Will lose stashes. Use Layout A or serialize writes.
+- **Sharing a palace across unrelated tasks.** Context bleed makes
+  stashes harder to find and prune. One palace per task.
+- **Stashing tool outputs with no TTL in a long-running agent.**
+  The palace grows unbounded.