@mono-agent/agent-app 0.2.2 → 0.4.0

package/skills/mono-agent-composer/SKILL.md

@@ -5,7 +5,7 @@ description: Construct a working mono-agent in the current folder from one mono-
 
 # Mono Agent Composer
 
-Construct a working mono-agent in the user's current folder — empty or already holding knowledge — from one `mono-agent.config.json`. Discover what the user wants (runtime with backup models, communication channels incl. crons and webhooks, skills, MCP servers, memory strategy incl. semantic search, sandbox, operator console, observability), write the config, then make it run with the `mono-agent` CLI. No hand-written host code unless the user genuinely needs programmatic composition. `references/feature-coverage.md` maps every framework feature to a config key, CLI flag, or the programmatic escape hatch — consult it before declaring anything impossible or inventing keys.
+Construct a working mono-agent in the user's current folder — empty or already holding knowledge — from one `mono-agent.config.json`. Discover what the user wants (runtime with backup models, communication channels incl. crons and webhooks, skills, MCP servers, memory strategy incl. semantic search, sandbox, observability), write the config, then make it run with the `mono-agent` CLI. The config is JSON-first: edit `mono-agent.config.json` directly (agents can edit it too); changes apply on the next `mono-agent restart`. No hand-written host code unless the user genuinely needs programmatic composition. `references/feature-coverage.md` maps every framework feature to a config key, CLI flag, or the programmatic escape hatch — consult it before declaring anything impossible or inventing keys.
 
 ## Operating Rules
 
@@ -25,11 +25,12 @@ The `mono-agent` CLI ships with `@mono-agent/agent-app` on npm:
 npm install -g @mono-agent/agent-app   # or: npx @mono-agent/agent-app …
 ```
 
-To run an unreleased build instead, use a clone of the mono-agent workspace:
+To run an unreleased build instead, use a clone of the mono-agent workspace with Node 20+ and pnpm 10 or newer already installed:
 
 ```bash
 git clone <mono-agent-repo> ~/mono-agent && cd ~/mono-agent
-corepack enable && pnpm install --frozen-lockfile && pnpm run build
+pnpm install --frozen-lockfile
+pnpm run build
 alias mono-agent="node ~/mono-agent/packages/agent-app/dist/cli.js"
 ```
 
@@ -41,7 +42,7 @@ Everything below runs in the user's agent folder, not the workspace.
 2. **Scaffold.** In the user's folder run:
 
    ```bash
-   mono-agent init --model <ref> [--fallback-models <csv>] [--memory markdown|journal]
+   mono-agent init --model <ref> [--fallback-models <csv>] [--memory lite|journal|bujo]
    ```
 
    This writes a minimal `mono-agent.config.json` (webhook enabled as the zero-credential smoke channel), an `IDENTITY.md` that references any knowledge files already present, and `.mono-agent/` working directories. It never overwrites existing files.
@@ -59,11 +60,11 @@ Everything below runs in the user's agent folder, not the workspace.
    mono-agent start
    ```
 
-   Then run the acceptance smoke test matching the chosen channel (see `references/validation.md`). The operator console URL printed at start lets the user edit config in the browser; saves re-apply live.
+   Then run the acceptance smoke test matching the chosen channel (see `references/validation.md`). To change anything, edit `mono-agent.config.json` directly and run `mono-agent restart`; there is no live browser re-apply.
 
 ## When Config Is Not Enough
 
-Config-first covers one responder served over any combination of the seven channels (webhook, OpenAI-compatible API, Telegram, Slack, WhatsApp, A2A, cron) plus the operator console, sandbox, memory (markdown or journal with entity graph and optional semantic search), and traceability. Drop to programmatic composition only for: custom runtimes (`MonoRuntimeLike`, incl. the OpenAI Agents SDK), request-scoped runtime extensions, tool approval gates, structured output schemas, multi-agent orchestration (`@mono-agent/agent-orchestrator`), custom channel message texts, or bespoke transports — `references/feature-coverage.md` lists which features are config keys and which are code-only. Read `references/package-map.md` for the package boundaries, and start from `startMonoAgentApp({ drivers, runtime, ... })` or `@mono-agent/agent-host` rather than re-writing lifecycle glue. For eval suites over the composed agent, use `@mono-agent/agent-evals`.
+Config-first covers one responder served over any combination of the seven channels (webhook, OpenAI-compatible API, Telegram, Slack, WhatsApp, A2A, cron) plus sandbox, memory (lite with FTS-only recall, journal with hybrid BM25+vector recall + configured embeddings, or bujo with SQLite-indexed hybrid recall + LLM capture/reconcile + entity graph + auto-scheduled reflection/migration), and traceability. Drop to programmatic composition only for: custom `MonoRuntimeLike` implementations, request-scoped runtime extensions, tool approval gates, structured output schemas, multi-agent orchestration (`@mono-agent/agent-orchestrator`), custom channel message texts, or bespoke transports — `references/feature-coverage.md` lists which features are config keys and which are code-only. Read `references/package-map.md` for the package boundaries, and start from `startMonoAgentApp({ drivers, runtime, ... })` or `@mono-agent/agent-host` rather than re-writing lifecycle glue. For eval suites over the composed agent, use `@mono-agent/agent-evals`.
 
 ## Implementation References
 

package/skills/mono-agent-composer/references/config-blueprint.md

@@ -9,6 +9,7 @@ my-agent/
   mono-agent.config.json   # the single declaration below
   IDENTITY.md              # role, boundaries, references to existing knowledge
   skills/                  # optional: <skill-name>/SKILL.md per selected skill
+  cron/                    # optional: <job-id>.md scheduled prompts
   mcp.json                 # optional: MCP server definitions
   .env                     # optional: secrets; auto-loaded by the CLI, never committed
   .mono-agent/
@@ -40,6 +41,12 @@ my-agent/
   // Local/self-hosted providers for pi:<provider>:<model> references.
   "providers": {
     "piAuthPath": "~/.pi/agent/auth.json", // Pi OAuth credentials (openai-codex, ...)
+    // Pi-native bridge tuning (all optional).
+    "piNative": {
+      "piMaxRetries": 2,                   // 0-8; transient provider-transport retries
+      "maxRetryDelayMs": 60000,            // backoff cap between retries (ms)
+      "piSessionsRoot": ".mono-agent/sessions" // durable JSONL sessions → resume across restarts (unset = in-memory)
+    },
     "local": [
       {
         "id": "ollama",
@@ -63,20 +70,34 @@ my-agent/
   },
 
   // Memory strategy. Omit the section for no memory.
+  // Three tiers over one substrate (memory-store + memory-bujo):
+  //   lite    — FTS keyword recall + rapid-log; no external deps.
+  //   journal — + hybrid recall (BM25+vector) + decay; needs embeddings.
+  //   bujo    — + LLM capture/reconcile + entity graph + auto-scheduled
+  //             reflection/migration; needs embeddings + an app-level memory.llm.
   "memory": {
-    "mode": "journal",                     // markdown | journal
-    "path": "./.mono-agent/memory",        // file for markdown, root dir for journal
-    "writeMode": "append-host-summary",    // disabled | append-host-summary
-    "scope": "single-file",                // markdown only: single-file | per-conversation
+    "mode": "bujo",                        // lite | journal | bujo
+    "path": "./.mono-agent/memory",        // root directory for all tiers
+    "writeMode": "capture",                // disabled | append-host-summary | capture (bujo only)
     "maxBytes": 64000,
-    "tools": { "enabled": true, "allowJournalAppend": true }, // journal only: MCP recall tools
-    "graphPath": "./.mono-agent/memory/graph.jsonl",          // journal only; this is the default
-    "embeddings": {                        // optional: semantic memory_search
+    "embeddings": {                        // required for journal and bujo
       "provider": "ollama",                // ollama | openai
-      "model": "nomic-embed-text",         // default per provider
+      "model": "nomic-embed-text:v1.5",   // use exact :v1.5 tag (pull first with ollama pull)
       "endpoint": "http://localhost:11434",
-      "apiKeyEnv": "OPENAI_API_KEY"        // or inline "apiKey"; required for openai
-    }
+      "apiKeyEnv": "OPENAI_API_KEY",       // or inline "apiKey"; required for openai
+      "dim": 768                           // nomic-embed-text:v1.5 output dimension
+    },
+    "llm": {                               // enables bujo capture/rituals; omit for lite/journal
+      // Env: MONO_AGENT_MEMORY_LLM_PROVIDER / _MODEL / _EXECUTION_MODE / _ENDPOINT.
+      "provider": "ollama",                // ollama | agent-host
+      "model": "qwen3.6:latest",           // ollama: model string; agent-host: runtime ref, e.g. pi:openai-codex:gpt-5.5
+      "endpoint": "http://localhost:11434" // ollama only; invalid for agent-host
+      // For agent-host, use: "model": "pi:openai-codex:gpt-5.5", "executionMode": "sdk"; omit endpoint.
+    },
+    // Bujo auto-scheduler — override defaults or disable per-ritual.
+    // Rituals run in-app; no external cron or launchd needed.
+    "reflection": { "enabled": true, "cron": "0 3 * * *" },  // default: nightly 03:00
+    "migration":  { "enabled": true, "cron": "0 4 1 * *" }   // default: 1st of month 04:00
   },
 
   // Fail-closed tool policy + MCP servers. Deny wins; overlap is rejected.
@@ -97,7 +118,8 @@ my-agent/
     "unsafeAllowHostProcess": false        // explicit opt-in required for the unsafe fallback
   },
 
-  // Observability: JSONL artifacts + the trace-source registry dashboards read.
+  // Observability: JSONL artifacts (always written; the local fallback) + the
+  // trace-source registry that `mono-agent status` reads.
   "artifacts": { "dir": "./.mono-agent/artifacts" },
   "traceability": {
     "registryDir": "./.mono-agent/trace-sources",
@@ -107,10 +129,12 @@ my-agent/
     "staleAfterMs": 30000
   },
 
-  // Local operator console (browser settings + traceability). On by default.
-  "console": {
-    "enabled": true,
-    "port": 0                              // 0 or omitted picks a free loopback port
+  // Optional trace viewer: add a Phoenix (OTLP) exporter to browse traces in
+  // Phoenix. Omit this entry to keep only the local JSONL artifacts.
+  "observability": {
+    "exporters": [
+      { "type": "phoenix", "endpoint": "http://127.0.0.1:6006/v1/traces" }
+    ]
   },
 
   // ----- Channels: one section per channel; all independent. An unconfigured
@@ -137,6 +161,11 @@ my-agent/
     "apiKey": "..."                        // optional bearer required from clients
   },
 
+  // Telegram & Slack deliver only the FINAL answer by default (no streamed
+  // interim edits) while showing a working indicator — Telegram a "typing…"
+  // action, Slack a 👀 "seen" reaction. This is built-in behavior (not a JSON
+  // field); restoring live interim streaming needs a custom channel driver with
+  // stream.finalOnly=false. The OpenAI-compatible endpoint still streams tokens.
   "telegram": {
     "enabled": true,                       // opt-in; defaults to false (off → "disabled")
     "botToken": "...",
@@ -210,14 +239,16 @@ my-agent/
 ## Lifecycle
 
 ```bash
-mono-agent init --model claude:claude-sonnet-4-6 --fallback-models pi:ollama:gemma4:31b [--memory markdown|journal]
-mono-agent validate     # per-section report incl. sandbox, console, every channel; exit 0 means ready
-mono-agent start        # console + traceability + every configured channel
-mono-agent start --no-console   # headless (or "console": { "enabled": false })
-mono-agent start --port 4400    # fixed console port (or "console": { "port": 4400 })
+mono-agent init --model claude:claude-sonnet-4-6 --fallback-models pi:ollama:gemma4:31b [--memory lite|journal|bujo]
+mono-agent validate     # per-section report incl. sandbox, observability, every channel; exit 0 means ready
+mono-agent start        # traceability + every configured channel
+mono-agent restart      # apply config edits (config is JSON-first; restart to re-apply)
+mono-agent restart --force  # restart AND purge persisted pi sessions (fresh start; durable memory kept)
 ```
 
-A `.env` file in the folder is loaded automatically (exported shell variables win); use `--env-file <path>` for an alternate file. `start` prints the operator console URL (config editing in the browser; saves re-apply live without restarting), the traceability source, and one status line per channel: `running` with its endpoint facts, `waiting_for_config` with the exact missing setting, `disabled`, or `failed` with the reason.
+A `.env` file in the folder is loaded automatically (exported shell variables win); use `--env-file <path>` for an alternate file. `start` prints the traceability source (Phoenix when an `observability.exporters` Phoenix entry is configured, otherwise the local JSONL artifacts) and one status line per channel: `running` with its endpoint facts, `waiting_for_config` with the exact missing setting, `disabled`, or `failed` with the reason. Config is JSON-first: edit `mono-agent.config.json` directly (agents can edit it) and run `mono-agent restart` to apply — there is no live browser re-apply.
+
+For BuJo capture and rituals, configure `memory.llm`. Use `provider: "ollama"` with a local Ollama chat model string and optional `endpoint`, or `provider: "agent-host"` with `model` as a normal SDK runtime model reference such as `pi:openai-codex:gpt-5.5` and `executionMode: "sdk"`. `endpoint` is Ollama-only, and CLI-backed refs such as `codex:gpt-5.5` are rejected for memory LLMs until runtimes can enforce no external actions. The same values can be supplied via `MONO_AGENT_MEMORY_LLM_PROVIDER`, `MONO_AGENT_MEMORY_LLM_MODEL`, `MONO_AGENT_MEMORY_LLM_EXECUTION_MODE`, and `MONO_AGENT_MEMORY_LLM_ENDPOINT`. The standalone `memory-bujo` maintenance CLI remains Ollama-only; `agent-host` LLM capture is an in-app composition path that injects the `LlmComplete` implementation into the BuJo store.
 
 For a local terminal chat against the same config, `@mono-agent/tui` ships a `mono-agent-tui` bin: `mono-agent-tui --config ./mono-agent.config.json`.
 
@@ -230,7 +261,7 @@ import { startMonoAgentApp, defaultChannelDrivers } from "@mono-agent/agent-app"
 
 const app = await startMonoAgentApp({
   cwd: process.cwd(),
-  runtime: myCustomRuntime,            // any MonoRuntimeLike (incl. createOpenAIAgentsRuntime)
+  runtime: myCustomRuntime,            // any MonoRuntimeLike
   drivers: [...defaultChannelDrivers(), myCustomDriver],
 });
 ```

package/skills/mono-agent-composer/references/discovery-questions.md

@@ -74,7 +74,7 @@ What tools or MCP servers does the agent actually need?
 4. Both
 ```
 
-Fills: `tools.allowedTools`, `tools.disallowedTools` (denylist wins), `tools.mcpConfigPath`. Record exact tool names; do not broaden access as a convenience.
+Fills: `tools.allowedTools`, `tools.disallowedTools` (denylist wins), `tools.mcpConfigPath`. Record exact tool names; do not broaden access as a convenience. To expose adapter-derived send tools, include `slack_send_message` / `telegram_send_message`; valid enabled Slack/Telegram adapter config and destination allowlists are still required.
 
 ## 6. Memory Strategy
 
@@ -84,12 +84,124 @@ Question:
 Should the agent remember anything between conversations?
 
 1. No durable memory yet (recommended for first integration)
-2. Markdown memory file (read into context; optional host summaries appended)
-3. Journal memory (daily notes + entity graph, optional MCP recall tools)
-4. Journal memory with semantic search (adds an embedding index for memory_search)
+2. Lite memory — FTS keyword recall + rapid-log capture; zero external deps
+3. Journal memory — hybrid recall (BM25+vector) + salience decay; requires embeddings
+4. BuJo memory — full tier: journal + LLM capture/reconcile + entity graph + auto-scheduled
+   reflection/migration; requires embeddings AND a chat model
 ```
 
-Fills: the `memory` section — `mode` (`markdown`/`journal`), `path`, `writeMode` (`disabled`/`append-host-summary`), `scope`, and for journal mode `tools.enabled` / `tools.allowJournalAppend` to give the runtime memory recall/append tools over MCP. The entity graph defaults to `<path>/graph.jsonl` (`memory.graphPath` to relocate). For semantic search fill `memory.embeddings`: `provider` (`ollama` with local `nomic-embed-text` — pull it first with `ollama pull nomic-embed-text` — or `openai` which requires `apiKey`/`apiKeyEnv`), optional `model`/`endpoint`. Without embeddings, `memory_search` falls back to keyword search.
+All tiers share the same `@mono-agent/memory-bujo` substrate. Fills: `memory.mode`
+(`lite`/`journal`/`bujo`), `memory.path`, `memory.writeMode`
+(`disabled`/`append-host-summary`/`capture`), and tier-specific blocks below.
+
+**Tier 2 — lite (no external deps):**
+
+Write:
+
+```jsonc
+"memory": {
+  "mode": "lite",
+  "path": "./.mono-agent/memory",
+  "writeMode": "append-host-summary"
+}
+```
+
+No prerequisites. No Ollama. SQLite is bundled.
+
+**Tier 3 — journal (embeddings required):**
+
+- Ask: which embeddings provider/model?
+  - Ollama default: `provider: "ollama"`, model `nomic-embed-text:v1.5`, dim `768`
+    (use the exact `:v1.5` tag; pull first with `ollama pull nomic-embed-text:v1.5`).
+  - OpenAI option: `provider: "openai"`, model `text-embedding-3-small`, API key via
+    `apiKeyEnv`, dim matching the model.
+
+Write:
+
+```jsonc
+"memory": {
+  "mode": "journal",
+  "path": "./.mono-agent/memory",
+  "writeMode": "append-host-summary",
+  "embeddings": {
+    "provider": "ollama",
+    "model": "nomic-embed-text:v1.5",
+    "dim": 768
+  }
+}
+```
+
+After writing, remind the user to run `mono-agent validate` (checks root writability and
+provider-specific liveness; Ollama model pulls are checked only when using Ollama).
+
+**Tier 4 — bujo (embeddings + chat model + auto-rituals):**
+
+Proactively explain what bujo does: capture → reconcile (ADD/UPDATE/SUPERSEDE/NOOP),
+hybrid BM25+vector recall, entity graph, reflection (decay + insight synthesis), monthly
+migration (promote/reschedule/cluster/forget), living `index.md` + `future-log.md`.
+The reflection and migration rituals are **auto-scheduled in-app** — no external cron or
+launchd setup needed.
+
+- Ask: which embeddings provider/model? Use the same choices as journal.
+- Ask: which chat LLM provider/model for LLM pipelines?
+  - Ollama: local model string such as `qwen3.6:latest`; pull it first with
+    `ollama pull qwen3.6:latest`.
+  - agent-host: SDK runtime model reference such as `pi:openai-codex:gpt-5.5` with
+    `executionMode: "sdk"`. Do not use CLI-backed refs such as `codex:gpt-5.5`; they are
+    rejected for memory LLMs until runtimes can enforce no external actions.
+- Ask: should per-turn intelligent capture be enabled (`writeMode: "capture"`), or only
+  deterministic rapid-log summaries (`append-host-summary`) plus scheduled rituals?
+- Ask: should we keep the default reflection/migration schedule (nightly `0 3 * * *` /
+  monthly `0 4 1 * *`), or customise the cron expressions?
+
+Write (embeddings + chat model):
+
+```jsonc
+"memory": {
+  "mode": "bujo",
+  "path": "./.mono-agent/memory",
+  "writeMode": "capture",
+  "embeddings": {
+    "provider": "ollama",
+    "model": "nomic-embed-text:v1.5",
+    "dim": 768
+  },
+  "llm": {
+    "provider": "ollama",
+    "model": "qwen3.6:latest"
+  }
+}
+```
+
+For an agent-host memory LLM, write the `llm` block as:
+
+```jsonc
+"llm": {
+  "provider": "agent-host",
+  "model": "pi:openai-codex:gpt-5.5",
+  "executionMode": "sdk"
+}
+```
+
+If the user customises the ritual schedule, add the `reflection`/`migration` blocks:
+
+```jsonc
+"reflection": { "enabled": true, "cron": "0 3 * * *" },
+"migration":  { "enabled": true, "cron": "0 4 1 * *" }
+```
+
+After writing, append a prerequisite note:
+
+```
+Before running mono-agent validate, pull the required models:
+  ollama pull nomic-embed-text:v1.5
+  ollama pull qwen3.6:latest          # only if using llm.provider: "ollama"
+```
+
+Then run `mono-agent validate` — the Memory section confirms the root is writable,
+provider-specific liveness, and the ritual cadence (with next-run times).
+See `docs/memory.md` for the full tier table, config shapes, and CLI subcommands
+(`memory-bujo rebuild|recall|index|reflect|migrate`).
 
 ## 7. Sandbox
 
@@ -111,14 +223,13 @@ Fills: the `sandbox` section — `mode`, `network.mode` (`none`/`localhost`/`all
 Question:
 
 ```text
-Do you need browsable traceability or just local artifacts?
+Do you need a browsable trace viewer or just local artifacts?
 
-1. JSONL artifacts and the operator console (recommended; console is on by default)
-2. JSONL artifacts and the console on a fixed port
-3. JSONL artifacts only (headless)
+1. JSONL artifacts plus Phoenix as the trace viewer (recommended; add an `observability.exporters` Phoenix entry)
+2. JSONL artifacts only (the local fallback; no external viewer)
 ```
 
-Fills: `artifacts.dir`, `traceability.registryDir` / `sourceId` / `sourceLabel`, and the `console` section — `console.port` for a fixed loopback port, `console.enabled: false` (or `start --no-console`) for headless. Artifacts record runtime/tool/message events and summaries, not private chain-of-thought. For a local terminal chat instead of (or alongside) the browser console, mention `mono-agent-tui --config ./mono-agent.config.json`.
+Fills: `artifacts.dir`, `traceability.registryDir` / `sourceId` / `sourceLabel`, and — when Phoenix is wanted — an `observability.exporters` (phoenix) OTLP entry. Local JSONL artifacts are always written and are the fallback when no exporter is configured. Artifacts record runtime/tool/message events and summaries, not private chain-of-thought. For a local terminal chat, mention `mono-agent-tui --config ./mono-agent.config.json`. Config is JSON-first — edit `mono-agent.config.json` directly and run `mono-agent restart` to apply changes.
 
 ## 9. Acceptance Smoke Test
 

package/skills/mono-agent-composer/references/feature-coverage.md

@@ -14,10 +14,11 @@ Every framework capability and how a composed agent reaches it. Use this to answ
 | Continuous provider sessions with idle eviction | config | `runtime.session.{mode,idleTimeoutMs}` |
 | Local providers (Ollama / LM Studio / OpenAI-compatible) | config | `providers.local[]` |
 | Pi OAuth credentials | config | `providers.piAuthPath` |
-| Context compaction, tool-output bloat guard, cost tracking | auto | built into every run |
+| Tool-output bloat guard, cost tracking | auto | built into every run |
+| Context handling | provider | delegated to the provider; the pi bridge (pi-agent-core AgentHarness) runs no automatic in-loop summarization, so runs report `context_compaction_applied: null` |
 | Structured output (JSON schema), live input steering | code | harness `runtimeOptions` |
 | Tool approval gates (risk tiers, timeouts, always-allow) | code | `createMonoRuntime({ onToolApprovalRequest, ... })` — needs a host UI |
-| OpenAI Agents SDK backend / fully custom runtime | code | `startMonoAgentApp({ runtime })` |
+| Fully custom runtime | code | `startMonoAgentApp({ runtime })` |
 
 ## Context, skills, memory
 
@@ -27,14 +28,15 @@ Every framework capability and how a composed agent reaches it. Use this to answ
 | Selected skills from a skills root | config | `context.skillsRoot`, `context.selectedSkills` |
 | Per-skill byte cap | config | `context.skillMaxBytes` |
 | Conversation history (in-memory; unlimited unless turns are capped) | auto | sized from `runtime.maxTurns`; custom store via code |
-| Markdown memory (single-file / per-conversation, capped) | config | `memory.mode: "markdown"`, `path`, `maxBytes`, `scope` |
-| Journal memory (daily notes always in context) | config | `memory.mode: "journal"`, `path` |
+| Lite memory (FTS keyword recall + rapid-log capture; no external deps) | config | `memory.mode: "lite"`, `path`, `maxBytes`, `writeMode` |
+| Journal memory (hybrid recall BM25+vector + salience decay; needs configured embeddings) | config | `memory.mode: "journal"`, `path`, `memory.embeddings.{provider,model,dim}` (`provider: "ollama" | "openai"`) |
+| BuJo memory (journal + LLM capture/reconcile ADD/UPDATE/SUPERSEDE/NOOP + entity graph + auto-scheduled reflection/migration; needs embeddings + an app-level `memory.llm`) | config | `memory.mode: "bujo"`, `path`, `memory.embeddings.{provider,model,dim}`, `memory.llm` with `provider: "ollama"` (`model`, optional `endpoint`) or `provider: "agent-host"` (`model` is an SDK runtime model ref, e.g. `pi:openai-codex:gpt-5.5`, optional `executionMode: "sdk"`) — see `docs/memory.md` |
+| BuJo reflection auto-scheduler (nightly decay + insight synthesis; in-app, no external cron needed) | config | `memory.reflection.{enabled,cron}` (default `0 3 * * *`); env `MONO_AGENT_MEMORY_REFLECTION_CRON`, `MONO_AGENT_MEMORY_REFLECTION_ENABLED` |
+| BuJo migration auto-scheduler (monthly promote/reschedule/cluster/forget; in-app) | config | `memory.migration.{enabled,cron}` (default `0 4 1 * *`); env `MONO_AGENT_MEMORY_MIGRATION_CRON`, `MONO_AGENT_MEMORY_MIGRATION_ENABLED` |
+| Memory out-of-band maintenance CLI (rebuild/recall/index/reflect/migrate) | cli | `memory-bujo <subcommand> <root>`; opt-in `MONO_AGENT_MEMORY_EMBEDDINGS_PROVIDER`/`_MODEL`/`_DIM` for semantic recall; reflect/migrate are Ollama-only and require `MONO_AGENT_MEMORY_LLM_MODEL` (optional `MONO_AGENT_MEMORY_LLM_ENDPOINT`) |
+| Memory liveness check (root writable; provider-specific Ollama checks only when embeddings/chat use Ollama; BuJo LLM config + ritual cadence — loud warn, no silent fallback) | cli | `mono-agent validate` |
 | Host summaries appended after runs | config | `memory.writeMode: "append-host-summary"` |
-| Entity graph + salience digest in context (journal) | config | automatic; path override `memory.graphPath` |
-| MCP recall tools (`memory_read_day`, `memory_list_days`, `memory_grep`, `memory_search`, `entity_get`) | config | `memory.tools.enabled` |
-| Model-initiated notes (`journal_append`) | config | `memory.tools.allowJournalAppend` |
-| Semantic `memory_search` (Ollama nomic-embed-text or OpenAI embeddings; keyword fallback when unset) | config | `memory.embeddings.{provider,model,endpoint,apiKey,apiKeyEnv}` |
-| Consolidation tools (`entity_upsert`, `memory_reindex`) | code | exposed by `@mono-agent/memory-mcp`, not in the default allowlist |
+| Auto-provisioned read-only `memory_recall` tool (hybrid keyword+semantic search) exposed to the agent from the single memory config; no chat LLM | config | `config.memory.recallTool.enabled` (`MONO_AGENT_MEMORY_RECALL_TOOL_ENABLED`, default on for journal/bujo with embeddings) |
 
 ## Tools, MCP, sandbox
 
@@ -43,6 +45,7 @@ Every framework capability and how a composed agent reaches it. Use this to answ
 | Fail-closed tool policy (empty allowlist = no tools) | auto | default |
 | Tool allow/deny lists (deny wins) | config | `tools.allowedTools`, `tools.disallowedTools` |
 | MCP servers (stdio/sse/http) from a JSON file | config | `tools.mcpConfigPath` |
+| Adapter-derived send tools for enabled Slack/Telegram adapters | config | `tools.allowedTools` must include `slack_send_message` / `telegram_send_message`; valid `slack.*` / `telegram.*` config and existing adapter allowlists provide credentials and destination bounds |
 | Sandbox on/off + srt engine | config | `sandbox.mode` |
 | Network policy (none/localhost/allowlist/all) | config | `sandbox.network.{mode,allowlist}` |
 | Filesystem scopes (readable/writable roots, deny-write globs) | config | `sandbox.readableRoots`, `sandbox.writableRoots`, `sandbox.denyWrite` |
@@ -60,7 +63,7 @@ Every framework capability and how a composed agent reaches it. Use this to answ
 | WhatsApp (Baileys, QR login, group mention/any triggers) | config | `whatsapp` section |
 | A2A provider (Agent Card, JSON-RPC + REST, streaming, bearer) | config | `a2a.provider` + `a2a.agent` + `a2a.skill` |
 | A2A consumer settings (remote agent URLs, timeouts) | config + code | `a2a.consumer` holds settings; calls via `createA2AConsumerResponder` |
-| Cron jobs (five-field expressions, timezones, overlap skip) | config | `cron.jobs[]` |
+| Cron jobs (five-field expressions, timezones, overlap skip) | config | `cron.jobs[]`, single-job `MONO_AGENT_CRON_*`, or one markdown file per job in `cron.dir` / `MONO_AGENT_CRON_DIR` (default `cron/`) |
 | Channel message texts / stream tuning (welcome, debounce, ...) | code | channel driver overrides |
 | Custom transports | code | implement `ChannelDriver`, pass via `startMonoAgentApp({ drivers })` |
 
@@ -69,8 +72,8 @@ Every framework capability and how a composed agent reaches it. Use this to answ
 | Capability | Coverage | Where |
 | --- | --- | --- |
 | JSONL run artifacts (events + summaries, secrets redacted) | config | `artifacts.dir` |
-| Trace-source registry (heartbeat manifests for dashboards) | config | `traceability.{registryDir,sourceId,sourceLabel,heartbeatMs,staleAfterMs}` |
-| Operator console (browser settings editor, traceability views, live config re-apply, bearer token) | config + cli | `console.{enabled,port}`; `--port`, `--no-console` |
+| Trace-source registry (heartbeat manifests `mono-agent status` reads) | config | `traceability.{registryDir,sourceId,sourceLabel,heartbeatMs,staleAfterMs}` |
+| Phoenix trace viewer (OTLP exporter; local JSONL artifacts are the fallback) | config | `observability.exporters` (phoenix entry) |
 | Terminal chat (TUI with transcript + redacted config pane) | cli | `mono-agent-tui --config ./mono-agent.config.json` |
 | Scaffold / validate / start / install-skill | cli | `mono-agent init|validate|start|install-skill` |
 | `.env` auto-loading | cli | automatic; `--env-file <path>` |

package/skills/mono-agent-composer/references/package-map.md

@@ -4,7 +4,7 @@ Use this map to select the smallest mono-agent package set for a host. Package c
 
 ## App Join (default)
 
-`@mono-agent/agent-app` is the config-first host: it loads `mono-agent.config.json`, builds the responder through `agent-host`, and drives every configured channel plus the operator console and traceability. It ships the `mono-agent` CLI (`init`, `validate`, `start`) and is the only publishable package allowed to compose communication adapters.
+`@mono-agent/agent-app` is the config-first host: it loads `mono-agent.config.json`, builds the responder through `agent-host`, and drives every configured channel plus traceability and any configured observability exporters. It ships the `mono-agent` CLI (`init`, `validate`, `start`) and is the only publishable package allowed to compose communication adapters.
 
 ```ts
 import { startMonoAgentApp } from "@mono-agent/agent-app";
@@ -48,11 +48,10 @@ Use this path when the agent needs identity, selected skills, history, and optio
 | --- | --- | --- |
 | Prompt assembly | `@mono-agent/context` | Load identity/SOUL/skills/history/memory into deterministic prompt context |
 | Selected skill bodies | `@mono-agent/skills` | Load only configured skills from `<skillsRoot>/<name>/SKILL.md` |
-| Markdown memory | `@mono-agent/memory-md` | Read capped memory blocks and optionally append host summaries |
-| Daily journal memory | `@mono-agent/memory-journal` | Keep a today note in context and persist continuous local journaling |
-| Entity graph memory | `@mono-agent/memory-graph` | Store local JSONL entities, relations, and observations (`memory.graphPath`) |
-| Searchable memory | `@mono-agent/memory-search` | Chunk and semantically search local memory with embeddings (`memory.embeddings`) |
-| Runtime memory tools | `@mono-agent/memory-mcp` | Expose memory tools over MCP when the runtime should query memory itself (`memory.tools`); also ships host-side `entity_upsert`/`memory_reindex` consolidation tools |
+| Memory substrate (schema, migrations, FTS+vector db, RRF) | `@mono-agent/memory-store` | SQLite storage, BM25 FTS, optional vector index, hybrid recall; `MemoryStore`/`MemoryBlock`/`MemoryWriteResult` contract |
+| Memory engine (all tiers: lite/journal/bujo) | `@mono-agent/memory-bujo` | `BujoMemoryStore` — tier-aware: FTS recall (lite), hybrid recall + decay (journal), LLM capture/reconcile + entity graph + reflection/migration + auto-scheduler (bujo) |
+| Embedding providers | `@mono-agent/memory-search` | Ollama/OpenAI embedding providers used by memory-store for vector recall |
+| Recall tool surface | `@mono-agent/agent-app` (bundled) | Auto-provisions a read-only `memory_recall` tool (hybrid keyword+semantic search) from `config.memory.recallTool.enabled`; spawns the bundled `mono-agent-memory` stdio child using the same memory root + embeddings as the in-app memory |
 
 Mono-agent selected skills are not auto-selected by description. The host chooses `context.selectedSkills`, and the harness loads those exact bodies.
 
@@ -103,17 +102,16 @@ Communication adapters are edge packages. They accept an `AgentResponder` and ow
 | Webhook | `@mono-agent/webhook-adapter` | `curl` the configured invocation path |
 | Cron | `@mono-agent/cron-adapter` | One scheduled or manually triggered invocation |
 
-Adapters must not import the harness, runtime adapter, memory packages, or other adapters. `@mono-agent/agent-app` composes them from config; custom hosts and demos may compose them directly.
+Adapters must not import the harness, runtime adapter, memory packages (`memory-store`, `memory-bujo`, `memory-search`), or other adapters. `@mono-agent/agent-app` composes them from config; custom hosts and demos may compose them directly.
 
-## Operator And Observability Join
+## Observability Join
 
 Use:
 
-- `@mono-agent/operator-console` for local browser settings and traceability (`console` config section; per-boot bearer token; saves re-apply live).
 - `@mono-agent/tui` for local terminal chat and redacted read-only config (`mono-agent-tui --config ./mono-agent.config.json`).
-- `@mono-agent/observability` for JSONL event artifacts, summaries, and trace-source registration.
+- `@mono-agent/observability` for JSONL event artifacts, summaries, and trace-source registration; add `@mono-agent/observability-otel` for the Phoenix OTLP exporter configured via `observability.exporters`.
 
-Traceability is local-first. A running host registers a source manifest; the operator console reads artifacts by `(sourceId, runId)` so duplicate run ids do not collide.
+Traceability is local-first. A running host registers a source manifest; `mono-agent status` reads the trace-source registry to report live sources, and artifacts are keyed by `(sourceId, runId)` so duplicate run ids do not collide. Phoenix is the recommended trace viewer when an `observability.exporters` (phoenix) entry is configured; local JSONL artifacts are the fallback otherwise.
 
 ## Evaluation Join
 

package/skills/mono-agent-composer/references/validation.md

@@ -10,7 +10,7 @@ In the user's agent folder:
 mono-agent validate
 ```
 
-The report covers core config, runtime support for the primary and every fallback model, identity/skills/memory/MCP paths, the sandbox policy, the operator console section, and every channel (`ok` / `waiting` / `off` / `error`). Exit 0 means the folder is ready to start. Fix every `[error]`; `[waiting]` channels are simply unconfigured.
+The report covers core config, runtime support for the primary and every fallback model, identity/skills/memory/MCP paths, the sandbox policy, the observability section (artifacts, traceability, and any configured exporters), and every channel (`ok` / `waiting` / `off` / `error`). Exit 0 means the folder is ready to start. Fix every `[error]`; `[waiting]` channels are simply unconfigured.
 
 Then start and confirm the status lines:
 
@@ -75,14 +75,15 @@ pnpm run test:demo
 | TUI | Start the host and complete one local prompt. |
 | Telegram | Send one allowed chat message and verify the reply. |
 | Slack | Send one allowed DM or channel message and verify formatting. |
+| Adapter send tools | When `tools.allowedTools` includes `slack_send_message` / `telegram_send_message`, call them from a non-Slack/Telegram surface such as TUI, cron, or OpenAI API to an allowed destination and verify delivery. |
 | WhatsApp | Send one allowed sender/group trigger and verify the reply. |
 | OpenAI API | `curl /v1/models` and `/v1/chat/completions`. |
 | A2A | Send text to the Agent Card URL with `sendA2AMessage()`. |
 | Webhook | `curl` the invocation path and inspect the response body/status. |
 | Cron | Run a one-off scheduled invocation or wait for one tick. |
-| Operator console | Open Settings and Traceability; confirm redaction and a visible run artifact. |
-| Journal memory tools | Ask the agent to recall yesterday (`memory_read_day`/`memory_grep` should appear in the run artifact). |
-| Semantic memory search | With `memory.embeddings` set (Ollama: `ollama pull nomic-embed-text` first), ask a paraphrased question about an old note and confirm `memory_search` returns it. |
+| Observability | Confirm a run writes a redacted JSONL artifact; if an `observability.exporters` Phoenix entry is set, confirm the trace appears in Phoenix. |
+| Memory recall tool | With `memory.recallTool.enabled` (default on for journal/bujo with embeddings), ask the agent to recall an old note and confirm `memory_recall` appears in the run artifact and returns it. |
+| Semantic memory search | With `memory.embeddings` set (Ollama: `ollama pull nomic-embed-text:v1.5` first), ask a paraphrased question about an old note and confirm `memory_recall` (hybrid keyword + semantic) returns it. |
 
 ## Failure Handling