@0xmaxma/claude-gateway 1.6.8 → 1.7.0

package/README.md

@@ -1,7 +1,7 @@
 
 # Claude Gateway
 
-A self-hosted multi-agent gateway for Claude Code. Connect Claude agents to Telegram, HTTP APIs, and scheduled tasks — each agent runs in an isolated session with its own personality, memory, and tools.
+A self-hosted multi-agent gateway for Claude Code — with agents that improve themselves, manage their own memory through nightly dreaming, and build a searchable knowledge base from what they learn.
 
 <p align="center">
   <img src="resource/claude_gateway.svg" alt="Claude Gateway" width="680" />
@@ -11,25 +11,28 @@ A self-hosted multi-agent gateway for Claude Code. Connect Claude agents to Tele
 
 ## Features
 
-- **Multi-agent** — run multiple bots from a single gateway, each with isolated sessions
-- **Multi-channel MCP** — modular tool system per channel (Telegram, Discord, Cron, Skills, extensible to Slack/WhatsApp)
-- **Agent skills** — extensible skill system via SKILL.md files; agents can create, delete, and install skills from URLs at runtime with hot-reload
-- **Agent identity** — define personality, tone, and rules via workspace markdown files
-- **Live status messages** — real-time status updates showing tool usage, thinking, and progress
-- **Typing indicators** — continuous typing animation while the agent is working (Telegram and Discord)
-- **Streaming API** — SSE (Server-Sent Events) endpoint for real-time response streaming
-- **Auto-forward** — agent text output automatically forwarded to Telegram even without explicit reply tool calls
-- **Heartbeat / scheduled tasks** — cron-based proactive messages and recurring tasks via HEARTBEAT.md + REST API; agent jobs deliver output to Telegram, Discord, or both
-- **Persistent chat history** — two-layer storage: session context (`.jsonl`) + permanent SQLite DB with FTS5 full-text search; survives `/compact` and session eviction
-- **Auto-cleanup** — configurable retention policy prunes messages and media files older than N days on a daily schedule
-- **Long-term memory** — persistent memory system across sessions
-- **Config auto-migration** — automatic schema migration when config format changes
-- **Access control** — allowlist, open, or pairing-based Telegram access policies
-- **HTTP API** — REST API with key-based auth for external integrations
-- **App Store** — install, update, and host Docker-compose apps on the gateway; apps get a reverse proxy at `/app/:name/:portName/*`, optional Unix socket bridge for host scripts, and optional AI agent injection
-- **Self-update API** — check for newer versions of `claude-gateway` and `claude-code` and trigger an update via a single API call; no SSH or shell access needed
-- **Session persistence** — conversation history saved and restored across restarts
-- **PTY shell (wrap-shell mode)** — optional interactive pseudo-terminal backend (`gateway.headless: false`) for tools that require a real TTY; includes a live browser viewer (xterm.js) and a `/api/v1/sessions/:sessionId/screen` endpoint that returns the visible screen as plain text — agents can poll it to detect hang states, menus, or unexpected output without parsing ANSI escape codes; a `/cli` chat command (Telegram/Discord/LINE) opens the same viewer for a single agent, agent-scoped and without an admin key; app-agents always stay headless
+- 🧠 **Skill self-improvement** — agents learn reusable skills from their own work: after a substantive turn a background reviewer creates or updates a skill, hot-reloaded for the next turn. Provenance-guarded (never overwrites human-written skills), capped per day, and audited to `SKILLS_LEARNED.md`. See [`gateway.skillLearning`](#gatewayskilllearning)
+- 📚 **Knowledge base (two-lane memory)** — per-agent SQLite/FTS5 searchable archive exposed through `memory_search` / `memory_get` MCP tools, so agents recall notes that don't fit the always-injected core; chunks carry fail-closed provenance and the index is refreshed off the gateway event loop. See [`gateway.knowledge`](#gatewayknowledge)
+- 🌙 **Nightly dreaming** — background consolidation of long-term memory: a print-only reviewer proposes ops that a safe applier writes to `MEMORY.md` / `USER.md` (backup, bounded-loss, net-negative when over budget). Deterministic compaction, budget-scaled pruning, and staleness GC keep memory near budget without forgetting — archived entries stay searchable. See [`gateway.dreaming`](#gatewaydreaming)
+- 🤖 **Multi-agent** — run multiple bots from a single gateway, each with isolated sessions
+- 🔌 **Multi-channel MCP** — modular tool system per channel (Telegram, Discord, Cron, Skills, extensible to Slack/WhatsApp)
+- 🧩 **Agent skills** — extensible skill system via SKILL.md files; agents can create, delete, and install skills from URLs at runtime with hot-reload
+- 🎭 **Agent identity** — define personality, tone, and rules via workspace markdown files
+- 📡 **Live status messages** — real-time status updates showing tool usage, thinking, and progress
+- ⌨️ **Typing indicators** — continuous typing animation while the agent is working (Telegram and Discord)
+- 🌊 **Streaming API** — SSE (Server-Sent Events) endpoint for real-time response streaming
+- ↪️ **Auto-forward** — agent text output automatically forwarded to Telegram even without explicit reply tool calls
+- ⏰ **Heartbeat / scheduled tasks** — cron-based proactive messages and recurring tasks via HEARTBEAT.md + REST API; agent jobs deliver output to Telegram, Discord, or both
+- 💬 **Persistent chat history** — two-layer storage: session context (`.jsonl`) + permanent SQLite DB with FTS5 full-text search; survives `/compact` and session eviction
+- 🧹 **Auto-cleanup** — configurable retention policy prunes messages and media files older than N days on a daily schedule
+- 🗄️ **Long-term memory** — persistent memory system across sessions
+- 🔄 **Config auto-migration** — automatic schema migration when config format changes
+- 🔐 **Access control** — allowlist, open, or pairing-based Telegram access policies
+- 🌐 **HTTP API** — REST API with key-based auth for external integrations
+- 🛍️ **App Store** — install, update, and host Docker-compose apps on the gateway; apps get a reverse proxy at `/app/:name/:portName/*`, optional Unix socket bridge for host scripts, and optional AI agent injection
+- ⬆️ **Self-update API** — check for newer versions of `claude-gateway` and `claude-code` and trigger an update via a single API call; no SSH or shell access needed
+- 💾 **Session persistence** — conversation history saved and restored across restarts
+- 🖥️ **PTY shell (wrap-shell mode)** — optional interactive pseudo-terminal backend (`gateway.headless: false`) for tools that require a real TTY; includes a live browser viewer (xterm.js) and a `/api/v1/sessions/:sessionId/screen` endpoint that returns the visible screen as plain text — agents can poll it to detect hang states, menus, or unexpected output without parsing ANSI escape codes; a `/cli` chat command (Telegram/Discord/LINE) opens the same viewer for a single agent, agent-scoped and without an admin key; app-agents always stay headless
 
 ---
 
@@ -338,6 +341,120 @@ Recovery actions are clamped to a per-stage whitelist and a per-turn budget, and
 }
 ```
 
+### `gateway.skillLearning`
+
+Controls [skill self-improvement](#skill-self-improvement) — agents learning reusable skills from their own work. Telemetry capture is always on; the reviewer/writer/curator honor `enabled`.
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `enabled` | `true` | Master switch for the reviewer/writer/curator (telemetry is captured regardless) |
+| `mode` | `"auto"` | `auto` writes skills directly; `propose` queues them for approval instead |
+| `minToolCalls` | `5` | Minimum tool calls in a turn before it's eligible for review |
+| `reviewModel` | `claude-haiku-4-5-…` | Model used for the background review pass |
+| `maxAutoSkills` | `50` | Cap on the number of non-pinned `origin: auto` skills kept per agent (pinned skills are never evicted and don't count toward the cap) |
+| `maxAgeDays` | `30` | Curator prunes auto-skills older than this (with too few uses) |
+| `minUsesToKeep` | `2` | Auto-skills used fewer times than this are prune candidates |
+| `maxReviewsPerDay` | `20` | Per-day cap on background review runs |
+| `pruneHour` / `pruneTimezone` | `3` / `UTC` | When the daily curator runs |
+| `notify` | `true` | Push a per-write ping to every configured channel (see [notifications](#skill-self-improvement)); the `SKILLS_LEARNED.md` diary is written regardless |
+
+```json
+{
+  "gateway": {
+    "skillLearning": {
+      "enabled": true,
+      "mode": "auto",
+      "notify": true
+    }
+  }
+}
+```
+
+Per-agent overrides are supported under the agent's own `skillLearning` block; unset fields fall back to the gateway default.
+
+### `gateway.memory`
+
+Memory budget discipline. Self-authored memory files (`MEMORY.md`, `USER.md`) that exceed a **soft** char budget get a loud over-budget banner prepended to their `CLAUDE.md` section at compose time — instead of a silent `[TRUNCATED]` — nudging the agent to consolidate. The banner reaches the agent on its next spawn (frozen-at-spawn, no restart) and self-heals once the file is back under budget. The banner lives only in the composed `CLAUDE.md`; the source file on disk is never rewritten with it.
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `memoryBudgetChars` | `8000` | Soft budget for `MEMORY.md` (`0` = disabled) |
+| `userBudgetChars` | `3000` | Soft budget for `USER.md` (`0` = disabled) |
+| `overBudget` | `"warn"` | Banner severity: `warn` (⚠️) or `error` (🛑, stronger wording); an unknown value falls back to `warn` |
+| `writeRouting` | `true` | Inject the **two-tier write contract** into the Memory Rule (`MEMORY.md` = durable facts; task-log → `memory/<topic>.md`) and let nightly dreaming route episodic ops out. `false` = kill-switch (exact pre-routing behavior) |
+| `episodicArchiveDir` | `"memory"` | Workspace-relative dir episodic notes are written under (validated, path-traversal-guarded) |
+
+```json
+{
+  "gateway": {
+    "memory": {
+      "memoryBudgetChars": 8000,
+      "userBudgetChars": 3000,
+      "overBudget": "warn",
+      "writeRouting": true,
+      "episodicArchiveDir": "memory"
+    }
+  }
+}
+```
+
+The soft budget sits well under the hard per-file limit (still applied as a context safety net); the banner is the primary over-budget signal for memory files.
+
+**Write routing (planning-65).** `MEMORY.md` is injected into every prompt, so it should hold only **durable semantic facts** (preferences, standing rules, identity, lessons). **Episodic task-log** (completed work, PR/issue status, dated events) belongs in `memory/<topic>.md` — indexed and retrieved on demand via `memory_search`, never carried in-prompt. When `writeRouting` is on, the Memory Rule states this tier contract to the agent, and the nightly dreaming reviewer may emit `tier:"episodic"` ops that the applier appends to `memory/<topic>.md` (slug-validated + realpath-confined; a memory-only change ⇒ no session restart). To drain an existing over-budget `MEMORY.md`, run the one-shot migration `node dist/agent/dreaming/migrate-cli.js <workspaceDir> [--apply]` — a deterministic terminal sweep (compactor) plus a gated episodic route-out (`propose` writes `.dreaming/migration-plan.md`; `--apply` performs the moves). Pinned sections (`## User`, `## Feedback`, `## Preferences`) are never moved, and every relocated entry stays searchable via `memory_search` (recall preserved). **planning-67:** with `gateway.dreaming.autoRouteOut` on (the default), the nightly dream performs this same route-out **automatically** whenever `MEMORY.md` is over budget — no manual per-agent run — and every over-budget net-shrink `remove` now **relocates** its block to `memory/archive/pruned.md` (searchable) before cutting it, so no dream op ever silently forgets.
+
+### `gateway.dreaming`
+
+Nightly memory **dreaming** — background consolidation of an agent's long-term memory. A print-only `claude -p` reviewer (no tools, no `--dangerously-skip-permissions`) reads a lookback window of the agent's own session transcripts and proposes memory-consolidation ops. In **`auto`** mode (the default) a safe applier writes the ops to `MEMORY.md`/`USER.md` (rollback pre-image first; ordered apply with anchor re-resolution; bounded-loss + append-only fallback; net-negative when over budget) — a memory-only change, so no session is restarted. In **`propose`** mode the proposals are written **only** to a `DREAMS.md` diary + JSONL audit under `<workspace>/.dreaming/` — no memory file is modified (set `mode: "propose"` to keep this dry-run behavior).
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `enabled` | `true` | Master switch (`false` ⇒ no scheduler, no run) |
+| `mode` | `"auto"` | `auto` = apply ops via the safe applier (backup, bounded-loss, net-negative); `propose` = diary-only dry-run |
+| `dreamHour` / `dreamTimezone` | `3` / `UTC` | When the nightly dream runs (invalid tz → UTC) |
+| `dreamMinute` | `0` | Minute-of-hour the dream fires at, paired with `dreamHour` (0–59). Set with `staggerWindowMinutes: 0` to fire at an exact `HH:MM` (e.g. for a controlled re-test) |
+| `quietMinutes` | `30` | Skip a run if a session was active within this window |
+| `lookbackDays` | `3` | How far back to scan sessions |
+| `maxChangesPerRun` | `3` | Cap on proposed ops per run (`0` ⇒ no-op) |
+| `reviewModel` | `claude-haiku-4-5-…` | Cheap model for the reviewer |
+| `promotionThreshold` / `minRecallCount` | `0.6` / `2` | Scoring thresholds for promoting a fact |
+| `autoRouteOut` | `true` | planning-67: in `auto` mode, drain an **over-budget** `MEMORY.md` by routing its episodic task-log to `memory/<topic>.md` automatically each night (archive-safe, pinned excluded, idempotent) instead of a manual per-agent `migrate-cli`. `false` = kill-switch |
+| `staggerWindowMinutes` | `30` | planning-68: spread agents' nightly runs across a window (a deterministic per-agent jitter is added to the delay) so they don't all fire at `dreamHour:00` together. Clamped `[0,55]`; `0` = disabled (all fire at `dreamHour:00`) |
+| `staleness` | *(object)* | Archive staleness GC sub-config (planning-66) — see below |
+
+Per-agent overrides are supported under the agent's own `dreaming` block; unset fields fall back to the gateway default. `enabled:false` or `maxChangesPerRun:0` makes a run a no-op.
+
+> **⚠️ Upgrade note:** the default `mode` for both `gateway.dreaming` and `gateway.knowledge.shared` changed from `propose` (dry-run) to `auto` (configVersion 1.0.24). Once the K4 applier landed (backup + net-negative + bounded-loss + CAS + never-empty; memory-only write ⇒ no session restart), `auto` became the intended default: nightly dreaming now applies consolidation to `MEMORY.md`/`USER.md` and promotes durable memories to the shared vault. Like the `gateway.bind` migration, the migrator upgrades the *retired* `propose` default to `auto` once and logs a one-time warning; an explicit `mode` you set at 1.0.24+ is never touched. To keep dry-run, set `mode: "propose"` explicitly.
+
+**Keeping `MEMORY.md` near budget (`auto` mode).** Two mechanisms stop the on-disk `MEMORY.md` from growing unbounded while preserving recall:
+
+- **Deterministic compaction** — before the LLM reviewer, every `auto` run moves completed/terminal log entries out of `MEMORY.md` into `memory/archive/completed.md`, leaving a one-line pointer. It is **domain-agnostic** (not just dev): an entry is archived when its lead line carries an explicit done marker — an UPPERCASE status word (`DONE`, `COMPLETED`, `RESOLVED`, `CLOSED`, `CANCELLED`, `ARCHIVED`, `MERGED`, `SUPERSEDED`, `OBSOLETE`, `DEPRECATED`, `EXPIRED`, `SHIPPED`, `FINISHED`), a checked task box `[x]`, a ✅, or a ~~strikethrough~~ — and it works on both list bullets and `###` entry headers. The archive lives under `memory/` so it is still indexed and **searchable via `memory_search`** — the agent recalls completed work on demand instead of carrying its full changelog in-prompt. It is conservative (uppercase words only, so prose like "Closes #123", "we're not done", or an unchecked `[ ]` box is never archived), idempotent, and never drops an open/active item.
+- **Budget-scaled pruning** — when `MEMORY.md` is over its soft budget, the reviewer is put in an explicit net-shrink mode (propose only length-reducing ops) and `maxChangesPerRun` scales up **for removals** (the add cap stays tight), so an over-budget file converges toward budget instead of trickling at a few edits per night.
+- **Archive staleness GC (`gateway.dreaming.staleness`, planning-66)** — a deterministic pass that runs next to the compactor (auto mode) to keep the Lane-2 archive's **search quality** high. This is a **search-quality fix, not a prompt-budget one**: planning-65 already moved task-log off the injected prompt, so the point here is that `memory_search` should keep surfacing *current* truth instead of stale/superseded facts. Each nightly run **soft-invalidates** archive entries — superseded ones (a deterministic `supersedes/replaces/obsoletes #N` match, which finally populates the previously-inert `supersedes_key`) and aged-out ones (idle-since-last-**retrieval** past `staleTtlDays` and retrieved fewer than `minRetrievalKeep` times) — by **moving** them to `memory/archive/stale.md` and stamping `invalid_at`. It **never deletes**: a staled entry stays under `memory/` so it is still indexed and **searchable** (ยุบได้แต่ไม่ลืม). An entry that is **retrieved after** it was invalidated is **promoted back** to the active archive (the recall feedback loop — proof we aged it out too soon). Recall is fed by an append-only read-path log (`kb_retrieval_log`, gated by `recordRetrievals`) that the GC folds into each entry's `last_retrieved`. High-importance entries (`keepImportance`) and **pinned** files (`memory/pinned/**`) are never aged out; evergreen Lane-1 (`MEMORY.md`/`USER.md`) is structurally excluded. Every move is CAS-guarded with a timestamped backup, and — being a memory-only write — drops **no live session**. Kill-switches: `staleness.enabled:false` (GC no-ops) and `recordRetrievals:false` (age falls back to first-seen only).
+
+### `gateway.knowledge`
+
+**Two-lane memory** — a per-agent searchable knowledge archive so an agent can recall what does not fit in the always-injected core. A SQLite/FTS5 index (`agents/<id>/kb.sqlite`, built on Node's built-in `node:sqlite` — no new dependency) covers the agent's `memory/*.md` notes plus the evergreen `MEMORY.md`/`USER.md`. Every chunk is tagged with **fail-closed provenance** (`owner`/`agent`/`untrusted`/`system`; unclassified ⇒ `untrusted`). The index is refreshed by a detached subprocess at session spawn, entirely **off the gateway event loop**.
+
+Two read-only MCP tools expose it to the agent: **`memory_search`** (keyword/FTS5 → ranked snippets with file+line, provenance, importance) and **`memory_get`** (bounded, path-traversal-guarded excerpt of a memory-scoped file). When `MEMORY.md` grows past its `gateway.memory` soft budget, compose injects a compact **auto-generated section index** + a pointer to `memory_search` instead of the truncated full text (**core-shrink**) — the on-disk file is never modified and its full content stays searchable. Whenever the archive is on, a short `--- MEMORY RETRIEVAL ---` note is also injected into every agent's system prompt so the tools stay discoverable at all times (not only when the file is over budget).
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `archive.enabled` | `true` | Master switch (`false` ⇒ complete no-op, no DB created, no core-shrink) |
+| `archive.tokenizer` | `"unicode61"` | FTS5 tokenizer (`"trigram"` for CJK/Thai) |
+| `archive.chunkTokens` | `400` | Target chunk size in ~tokens |
+| `archive.chunkOverlap` | `80` | Overlap between chunks (clamped below `chunkTokens`) |
+| `shared.enabled` | `true` | Enable the cross-agent shared KB |
+| `shared.project` | `"global"` | Sharing partition key (one safe path segment) — agents with the same value share one vault; `"global"` ⇒ shared-by-default |
+| `shared.root` | `~/.claude-gateway/shared/kb` | Shared vault root dir (`<root>/<project>/`) |
+| `shared.mode` | `"auto"` | Per-agent→shared promotion mode; `auto` = promote durable dreamed facts, `propose` = dry-run |
+| `shared.graph` | `false` | Compile the memory-wiki graph + dashboards over the shared vault to `<vault>/reports/*.md` (opt-in). Independent of the dashboard **Knowledge base** tab, which computes its graph on-demand |
+
+**Shared KB.** A shared SQLite/FTS5 vault outside any single agent's workspace lets agents build a common knowledge base. Notes under `<root>/<project>/notes/*.md` are indexed and reachable via `memory_search` with `corpus:"shared"` (the shared vault) or `corpus:"all"` (this agent's memory + shared, merged by relevance). Concurrent writers are safe without a lock — atomic note writes (temp+rename) plus a cross-process `PRAGMA busy_timeout` on the index. Per-agent overrides under the agent's own `knowledge` block. The MCP layer runs under Bun, so the read tools query `kb.sqlite` via `bun:sqlite`.
+
+**Knowledge base viewer.** The web dashboard's **Knowledge base** tab renders the shared vault as an Obsidian-style force-directed graph (nodes = notes sized by link degree and coloured by `type`; edges = `[[wiki-links]]`; contradicting claims and stale notes are flagged). It is fed by `GET /knowledge/graph`, which computes the model **on-demand** from the vault (no dependency on `shared.graph` or the nightly reindex). When the vault is empty it shows a clearly-labelled demo dataset (with a size selector for scale testing). A **source** selector switches the graph between the cross-agent Shared KB and any single agent's own Lane-2 memory (`workspace/memory`), a node **search** box filters the graph, and clicking a node opens its full note (fetched via `GET /knowledge/note`) rendered as Markdown below the graph.
+
+**Nightly dreaming viewer.** A **Nightly dreaming** tab renders each agent's memory-consolidation audit trail (`.dreaming/DREAMS.md` + `promotions.jsonl`) as a newest-first timeline of runs — mode (propose/auto), outcome, the proposed/applied changes with scores + anchors, and per-run token/session counts — fed by `GET /knowledge/dreams` and filterable by agent. For a `propose`-mode run you can **accept** proposals directly from the tab: an **Accept** button per proposal (and **Accept all** per run) POSTs to `POST /knowledge/dreams/apply`, which applies the selected ops to `MEMORY.md`/`USER.md` through the same K4 safe applier auto mode uses (backup + bounded-loss + net-negative + CAS; memory-only ⇒ no restart) and — when the shared KB is `auto` — promotes applied `add`s to the shared vault. Accepts are idempotent (recorded to `.dreaming/accepted.jsonl`); applied proposals show ✓ and a proposal whose anchor has since drifted is safely skipped and stays pending for a later retry.
+
 ### `gateway.bind`
 
 Network interface the HTTP/WebSocket server binds to. Defaults to `127.0.0.1` (localhost-only), so the dashboard and API are **not** exposed to the local network out of the box. Set to `0.0.0.0` to listen on all interfaces (for example when a containerized reverse proxy needs to reach the gateway). The `GATEWAY_BIND` environment variable, when set, takes precedence over this field.
@@ -829,6 +946,18 @@ Skills placed in `~/.claude-gateway/shared-skills/` are automatically synced to
 
 This means adding a skill to `shared-skills/` makes it available to **all agents** without per-agent setup or a gateway restart.
 
+### Skill self-improvement
+
+Agents can **learn skills from their own work**. Telemetry is captured for every turn; when a turn does enough substantive work (default ≥ 5 tool calls) and the session goes idle, a lightweight background reviewer reads the transcript and decides whether a reusable skill should be **created or updated**. Written skills are **hot-reloaded** — usable in the next turn without a restart. Controlled by [`gateway.skillLearning`](#gatewayskilllearning) (enabled by default).
+
+- **Provenance guard** — the writer only ever creates new `origin: auto` skills or edits skills it previously authored. Hand-written / user skills are never overwritten.
+- **Caps** — a per-day review cap and a maximum number of auto-skills bound the churn; a daily curator prunes the least-used auto-skills.
+- **Audit diary** — every automatic write appends a line to `<workspace>/SKILLS_LEARNED.md` (always on, offline, immutable).
+- **Notifications** — when `skillLearning.notify` is on (default), a short ping is fanned out to **every channel the agent has configured** (Telegram, Discord, and LINE when set up). Each channel resolves recipients from its own `.<channel>-state/access.json` allowlist. The web/`api` channel has no proactive push and is not notified. Bursts coalesce into a single digest.
+- **Progressive disclosure** — auto-skill descriptions are truncated in the CLAUDE.md skill menu to keep per-turn context small; the full skill body still loads on invoke.
+
+Metrics are exposed via `GET /api/v1/agents/:agentId/skill-metrics` and the `skill_metrics` MCP tool (adoption funnel, cost-to-complete deltas, net-token ledger).
+
 ---
 
 ## Config Auto-Migration

package/config.template.json

@@ -10,7 +10,7 @@
       "claude.dangerouslySkipPermissions"
     ]
   },
-  "configVersion": "1.0.16",
+  "configVersion": "1.0.29",
   "gateway": {
     "logDir": "~/.claude-gateway/logs",
     "timezone": "Asia/Bangkok",
@@ -63,6 +63,64 @@
       "buildCachePrune": true,
       "buildCacheMaxAgeHours": 168,
       "danglingImagePrune": true
+    },
+    "skillLearning": {
+      "enabled": true,
+      "mode": "auto",
+      "minToolCalls": 5,
+      "reviewModel": "claude-haiku-4-5-20251001",
+      "maxAutoSkills": 50,
+      "maxAgeDays": 30,
+      "minUsesToKeep": 2,
+      "maxReviewsPerDay": 20,
+      "pruneHour": 3,
+      "pruneTimezone": "UTC",
+      "notify": true
+    },
+    "memory": {
+      "memoryBudgetChars": 8000,
+      "userBudgetChars": 3000,
+      "overBudget": "warn",
+      "writeRouting": true,
+      "episodicArchiveDir": "memory"
+    },
+    "dreaming": {
+      "enabled": true,
+      "mode": "auto",
+      "dreamHour": 3,
+      "dreamMinute": 0,
+      "dreamTimezone": "UTC",
+      "quietMinutes": 30,
+      "lookbackDays": 3,
+      "maxChangesPerRun": 3,
+      "reviewModel": "claude-haiku-4-5-20251001",
+      "promotionThreshold": 0.6,
+      "minRecallCount": 2,
+      "autoRouteOut": true,
+      "staggerWindowMinutes": 30,
+      "staleness": {
+        "enabled": true,
+        "staleTtlDays": 90,
+        "keepImportance": 7,
+        "minRetrievalKeep": 1,
+        "supersession": true,
+        "recordRetrievals": true
+      }
+    },
+    "knowledge": {
+      "archive": {
+        "enabled": true,
+        "tokenizer": "unicode61",
+        "chunkTokens": 400,
+        "chunkOverlap": 80
+      },
+      "shared": {
+        "enabled": true,
+        "project": "global",
+        "root": "~/.claude-gateway/shared/kb",
+        "mode": "auto",
+        "graph": false
+      }
     }
   },
   "agents": [

package/dist/agent/dreaming/accept.d.ts

@@ -0,0 +1,43 @@
+import { type ApplyFileResult } from './applier';
+import type { DreamProposal } from './types';
+export interface AcceptOptions {
+    memoryBudgetChars: number;
+    userBudgetChars: number;
+    /** planning-65: episodic archive dir (relative to workspace) so accepted episodic ops append to memory/<topic>.md. */
+    episodicArchiveDir?: string;
+    /** Promote each applied `add` to the shared vault (only when shared KB is auto). */
+    sharedPromote?: (p: DreamProposal) => void;
+}
+export interface AcceptResult {
+    /** Proposals matched from the run after the index filter (before dedup). */
+    requested: number;
+    /** Ops the applier actually wrote to memory. */
+    applied: number;
+    /** Matched but not written this call (stale anchor, net-negative, over-budget add). */
+    skipped: number;
+    /** Excluded because a prior accept already applied them. */
+    alreadyAccepted: number;
+    /** Per-file applier outcome (for surfacing backup paths / byte deltas). */
+    files: ApplyFileResult[];
+    /** Rollback pre-image paths written this call. */
+    backups: string[];
+}
+/**
+ * Ordered proposals for a single run (matched by `ts`), each with its index —
+ * the position among that run's proposals, matching the report/UI ordering.
+ * Malformed or unusable lines are skipped but still consume an index slot so
+ * indexes stay aligned with what the report renders.
+ */
+export declare function loadRunProposals(workspaceDir: string, ts: number): Array<{
+    index: number;
+    proposal: DreamProposal;
+}>;
+/** Set of `"<ts>:<index>"` keys already accepted for this agent. */
+export declare function readAcceptedKeys(workspaceDir: string): Set<string>;
+/**
+ * Accept (apply) the selected proposals of one dreaming run.
+ *
+ * @param indexes proposal indexes to accept within the run, or `null` for all.
+ */
+export declare function acceptDreamProposals(workspaceDir: string, ts: number, indexes: number[] | null, opts: AcceptOptions, now?: number): AcceptResult;
+//# sourceMappingURL=accept.d.ts.map

package/dist/agent/dreaming/accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../../src/agent/dreaming/accept.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAEtE,OAAO,KAAK,EAAE,aAAa,EAA0B,MAAM,SAAS,CAAC;AAKrE,MAAM,WAAW,aAAa;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,sHAAsH;IACtH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,kDAAkD;IAClD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AA0BD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,EAAE,EAAE,MAAM,GACT,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,CAAC,CA2BnD;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAsBlE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EACxB,IAAI,EAAE,aAAa,EACnB,GAAG,GAAE,MAAmB,GACvB,YAAY,CAoFd"}

package/dist/agent/dreaming/accept.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRunProposals = loadRunProposals;
+exports.readAcceptedKeys = readAcceptedKeys;
+exports.acceptDreamProposals = acceptDreamProposals;
+/**
+ * Manual accept of dreaming proposals (dashboard action).
+ *
+ * In `propose` mode the nightly reviewer only records its proposals to
+ * `<workspace>/.dreaming/promotions.jsonl` — nothing is written to memory. This
+ * module lets a human accept one or more of those recorded proposals from the
+ * dashboard and apply them through the SAME K4 safe applier the auto mode uses
+ * (backup pre-image + ordered anchor re-resolution + bounded-loss + net-negative
+ * + CAS + never-empty). Writing MEMORY.md/USER.md is memory-only ⇒ no session
+ * restart.
+ *
+ * Idempotency: each applied proposal is recorded to `<workspace>/.dreaming/
+ * accepted.jsonl` keyed by `"<ts>:<index>"`. A proposal already accepted is
+ * skipped on a repeat request. A proposal the applier *skipped* (stale anchor,
+ * net-negative, etc.) is NOT recorded, so it can be retried later.
+ *
+ * Pure of any clock — `now` is injected so it stays unit-testable.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const audit_1 = require("./audit");
+const applier_1 = require("./applier");
+const episodic_1 = require("./episodic");
+const OP_KINDS = new Set(['add', 'replace', 'remove']);
+const DREAM_FILES = new Set(['MEMORY.md', 'USER.md']);
+/** One promotions.jsonl object → a valid DreamProposal, or null if unusable. */
+function coerceProposal(o) {
+    const op = String(o.op ?? '');
+    if (!OP_KINDS.has(op))
+        return null;
+    const content = typeof o.content === 'string' ? o.content : undefined;
+    const target = typeof o.target === 'string' ? o.target : undefined;
+    const reason = String(o.reason ?? '');
+    const score = Number(o.score) || 0;
+    const recallCount = Number(o.recallCount) || 0;
+    // planning-65: episodic ops (add-only, memory/<topic>.md) recorded in propose mode.
+    if (o.tier === 'episodic') {
+        if (op !== 'add' || !(0, episodic_1.isValidTopicSlug)(o.topic) || !content)
+            return null;
+        return { op, tier: 'episodic', topic: o.topic, content, reason, score, recallCount };
+    }
+    // Durable op (unchanged): needs a valid evergreen file + the right fields.
+    const file = String(o.file ?? '');
+    if (!DREAM_FILES.has(file))
+        return null;
+    if (op === 'add' && !content)
+        return null;
+    if ((op === 'replace' || op === 'remove') && !target)
+        return null;
+    return { op, file, tier: 'durable', target, content, reason, score, recallCount };
+}
+/**
+ * Ordered proposals for a single run (matched by `ts`), each with its index —
+ * the position among that run's proposals, matching the report/UI ordering.
+ * Malformed or unusable lines are skipped but still consume an index slot so
+ * indexes stay aligned with what the report renders.
+ */
+function loadRunProposals(workspaceDir, ts) {
+    const file = path.join(workspaceDir, audit_1.DREAMING_DIR, 'promotions.jsonl');
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    let index = 0;
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let o;
+        try {
+            o = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (Number(o.ts) !== ts)
+            continue;
+        const proposal = coerceProposal(o);
+        // Consume an index slot even for an unusable line so indexes match the
+        // report's per-run ordering (which also lists every proposal line).
+        const slot = index++;
+        if (proposal)
+            out.push({ index: slot, proposal });
+    }
+    return out;
+}
+/** Set of `"<ts>:<index>"` keys already accepted for this agent. */
+function readAcceptedKeys(workspaceDir) {
+    const file = path.join(workspaceDir, audit_1.DREAMING_DIR, 'accepted.jsonl');
+    const keys = new Set();
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return keys;
+    }
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const o = JSON.parse(trimmed);
+            const ts = Number(o.ts);
+            const idx = Number(o.index);
+            if (Number.isFinite(ts) && Number.isFinite(idx))
+                keys.add(`${ts}:${idx}`);
+        }
+        catch {
+            /* skip malformed line */
+        }
+    }
+    return keys;
+}
+/**
+ * Accept (apply) the selected proposals of one dreaming run.
+ *
+ * @param indexes proposal indexes to accept within the run, or `null` for all.
+ */
+function acceptDreamProposals(workspaceDir, ts, indexes, opts, now = Date.now()) {
+    const all = loadRunProposals(workspaceDir, ts);
+    const wanted = indexes === null ? all : all.filter((x) => indexes.includes(x.index));
+    const acceptedKeys = readAcceptedKeys(workspaceDir);
+    const already = wanted.filter((x) => acceptedKeys.has(`${ts}:${x.index}`));
+    const fresh = wanted.filter((x) => !acceptedKeys.has(`${ts}:${x.index}`));
+    if (fresh.length === 0) {
+        return {
+            requested: wanted.length,
+            applied: 0,
+            skipped: 0,
+            alreadyAccepted: already.length,
+            files: [],
+            backups: [],
+        };
+    }
+    const res = (0, applier_1.applyDreamProposals)(workspaceDir, fresh.map((x) => x.proposal), {
+        memoryBudgetChars: opts.memoryBudgetChars,
+        userBudgetChars: opts.userBudgetChars,
+        episodicArchiveDir: opts.episodicArchiveDir,
+    }, now);
+    // Identity match: applyDreamProposals returns the SAME proposal objects it
+    // actually wrote, so a reference Set maps applied ops back to their indexes.
+    const appliedSet = new Set(res.appliedProposals);
+    const acceptedRecords = [];
+    for (const x of fresh) {
+        if (!appliedSet.has(x.proposal))
+            continue;
+        acceptedRecords.push(JSON.stringify({
+            ts,
+            index: x.index,
+            file: x.proposal.tier === 'episodic' ? `memory/${x.proposal.topic}.md` : x.proposal.file,
+            op: x.proposal.op,
+            acceptedAt: now,
+        }));
+        // Shared promotion mirrors the nightly auto path: only applied DURABLE `add`s.
+        // Episodic task-log is per-agent local history — never auto-promoted to shared.
+        if (opts.sharedPromote &&
+            x.proposal.op === 'add' &&
+            x.proposal.content &&
+            x.proposal.tier !== 'episodic') {
+            try {
+                opts.sharedPromote(x.proposal);
+            }
+            catch {
+                /* best-effort — a promotion failure never fails the local accept */
+            }
+        }
+    }
+    if (acceptedRecords.length) {
+        try {
+            const dir = path.join(workspaceDir, audit_1.DREAMING_DIR);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.appendFileSync(path.join(dir, 'accepted.jsonl'), acceptedRecords.join('\n') + '\n', 'utf8');
+        }
+        catch {
+            /* best-effort audit — the memory write already committed */
+        }
+    }
+    return {
+        requested: wanted.length,
+        applied: res.totalApplied,
+        skipped: fresh.length - res.totalApplied,
+        alreadyAccepted: already.length,
+        files: res.files,
+        backups: res.files.map((f) => f.backupPath).filter((b) => !!b),
+    };
+}
+//# sourceMappingURL=accept.js.map

package/dist/agent/dreaming/accept.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accept.js","sourceRoot":"","sources":["../../../src/agent/dreaming/accept.ts"],"names":[],"mappings":"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"}