jfl 0.3.0 → 0.4.2

package/README.md

@@ -55,28 +55,37 @@ That's it. SessionStart hooks handle repo sync, session branching, Context Hub s
 
 ## Architecture
 
-JFL workspaces are **context layers**, not code repos. Product code lives in separate service repos that register with the GTM.
+JFL supports a three-level hierarchy: **Portfolio > GTM > Services**. Portfolios coordinate multiple products. GTMs are context layers for individual products. Services are the repos that do the actual work.
 
 ```
-my-project/                    <- GTM workspace (strategy, context, orchestration)
+visa-portfolio/                <- Portfolio (strategy, cross-product RL, data flow)
 ├── .jfl/
-│   ├── config.json           <- Project config (team, services, ports)
-│   ├── journal/              <- Session journals (JSONL, one file per session)
-│   ├── memory.db             <- Indexed memory (TF-IDF + embeddings)
-│   ├── agents/              <- Narrowly-scoped agent manifests + policies
-│   ├── flows/               <- Per-agent flow definitions (auto-loaded)
-│   ├── service-events.jsonl  <- Event bus file-drop
-│   └── services.json         <- Registered services
-├── knowledge/                <- Strategy docs (VISION, ROADMAP, THESIS, etc.)
-├── content/                  <- Generated content
-├── suggestions/              <- Per-contributor workspaces
-├── .claude/
-│   ├── settings.json         <- Claude Code hooks (SessionStart, Stop, etc.)
-│   ├── agents/               <- Service agent definitions
-│   └── skills/               <- Slash commands (/hud, /content, etc.)
-├── scripts/session/          <- Session management (init, sync, cleanup)
-├── CLAUDE.md                 <- AI instructions
-└── .mcp.json                 <- MCP server config (Context Hub)
+│   ├── config.json           <- type: "portfolio", registered child GTMs
+│   ├── eval.jsonl            <- Aggregated eval data from all children
+│   ├── flows.yaml            <- Cross-product event routing
+│   └── journal/              <- Portfolio-level + synced child journals
+│
+├── productrank-gtm/           <- GTM workspace (registered as child)
+│   ├── .jfl/
+│   │   ├── config.json       <- type: "gtm", portfolio_parent, registered services
+│   │   ├── eval.jsonl        <- Eval entries from arena competitions
+│   │   ├── journal/          <- Session journals + synced service journals
+│   │   ├── agents/           <- Agent manifests + policies
+│   │   ├── flows/            <- Per-agent flow definitions
+│   │   └── service-events.jsonl
+│   ├── knowledge/            <- Strategy docs (VISION, ROADMAP, THESIS, etc.)
+│   ├── content/              <- Generated content
+│   ├── suggestions/          <- Per-contributor workspaces
+│   ├── .claude/
+│   │   ├── settings.json     <- Claude Code hooks
+│   │   ├── agents/           <- Service agent definitions
+│   │   └── skills/           <- Slash commands (/hud, /content, etc.)
+│   ├── scripts/session/      <- Session management
+│   ├── CLAUDE.md             <- AI instructions
+│   └── .mcp.json             <- MCP server config
+│
+└── seo-agent/                 <- Another GTM (registered as child)
+    └── ...
 
 my-api/                        <- Service repo (registered in GTM)
 ├── src/
@@ -89,7 +98,8 @@ my-api/                        <- Service repo (registered in GTM)
 - Services work independently
 - Multiple services register to one GTM
 - `jfl update` updates tooling without touching service code
-- Journal entries sync from services to parent GTM
+- Eval data dual-writes up the chain (service > GTM > portfolio)
+- Cross-product event routing at portfolio level
 
 ---
 
@@ -106,14 +116,14 @@ jfl context-hub stop          # Stop daemon
 jfl context-hub restart       # Restart daemon
 jfl context-hub doctor        # Diagnose all projects (OK/ZOMBIE/DOWN/STALE)
 jfl context-hub ensure-all    # Start for all GTM projects
-jfl context-hub dashboard     # Live event + context dashboard
+jfl context-hub dashboard     # Open web dashboard (opens browser)
 jfl context-hub install-daemon  # Auto-start on boot (launchd/systemd)
 jfl context-hub uninstall-daemon  # Remove auto-start
 jfl context-hub query         # Query context from CLI
 jfl context-hub serve         # Run in foreground (daemon mode)
 ```
 
-**Per-project ports** assigned automatically (or set in `.jfl/config.json` → `contextHub.port`).
+**Per-project ports** assigned automatically (or set in `.jfl/config.json` > `contextHub.port`).
 
 **MCP Tools** (available to Claude Code and any MCP client):
 
@@ -126,9 +136,32 @@ jfl context-hub serve         # Run in foreground (daemon mode)
 | `memory_search` | Search indexed journal memories |
 | `memory_status` | Memory system statistics |
 | `memory_add` | Add manual memory entry |
+| `query_experiment_history` | Query RL trajectories for agent experiments |
 
 **Resilience:** 5-layer system — MCP auto-recovery on ECONNREFUSED, health-check-before-ensure hooks, `ensure-all` for batch startup, `doctor` diagnostics, launchd/systemd daemon with keepalive.
 
+### Dashboard V2
+
+A pre-built Vite + Preact + Tailwind SPA served by Context Hub at `/dashboard/`. Auto-detects workspace type and adapts layout.
+
+**Pages:**
+
+| Page | What It Shows |
+|------|--------------|
+| **Overview** | Activity charts, product cards, metric cards |
+| **Journal** | Searchable journal entries with type filters |
+| **Events** | Live event feed with pattern filter presets (eval, session, flow, etc.) |
+| **Services** | Registered services with type badges, context scope visualization, data flows |
+| **Flows** | Flow definitions and execution history |
+| **Health** | System metrics, context sources, memory index, tracked projects |
+| **Agents** | Eval leaderboards grouped by product domain |
+
+**Features:** Sidebar with structured sections (Workspace / Infra / Eval), inline SVG icons, agent leaderboard in sidebar, sparkline charts, real-time polling.
+
+```bash
+jfl context-hub dashboard     # Opens /dashboard/ in browser
+```
+
 ### MAP Event Bus
 
 Metrics, Agents, Pipeline — an in-process event bus inside Context Hub.
@@ -138,10 +171,126 @@ Metrics, Agents, Pipeline — an in-process event bus inside Context Hub.
 - **Journal bridge** — watches `.jfl/journal/`, emits events on new entries
 - **Pattern-matching subscriptions** (glob support)
 - **Transports:** SSE, WebSocket, HTTP polling
-- **Event types:** `session:started`, `session:ended`, `task:completed`, `journal:entry`, `service:healthy`, `custom`, and more
+- **Cross-product routing** — portfolio flows route events between child GTMs
+- **Event types:** `session:started`, `session:ended`, `eval:scored`, `journal:entry`, `flow:triggered`, `agent:iteration-complete`, `portfolio:phone-home`, and more
 
 Services emit events by appending to `.jfl/service-events.jsonl` — no auth needed, Context Hub watches the file automatically.
 
+### Eval Framework
+
+Track agent performance over time. Eval entries dual-write up the parent chain (service > GTM > portfolio) so every level has visibility.
+
+```bash
+jfl eval list                 # List recent eval entries
+jfl eval list -a shadow       # Filter by agent
+jfl eval trajectory -a shadow # Composite score over time (with sparkline)
+jfl eval log -a shadow -m '{"composite":0.69}' # Log an eval entry
+jfl eval compare              # Side-by-side agent comparison
+jfl eval tuples               # Extract (state, action, reward) training tuples
+```
+
+**Eval entries** are JSONL with agent name, metrics, composite score, model version, and deltas:
+
+```json
+{
+  "v": 1, "ts": "2026-03-05T15:22:47Z",
+  "agent": "productrank-shadow",
+  "dataset": "vibe-50-v1",
+  "model_version": "shadow-0.3.1",
+  "metrics": {"ndcg@10": 0.59, "mrr": 0.77, "precision@5": 0.43},
+  "composite": 0.6935,
+  "delta": {"composite": -0.029}
+}
+```
+
+**Leaderboard:** Agents grouped by metric domain. ProductRank agents scored on ndcg@10, mrr, precision@5. SEO agents scored on avg_rank, keywords_ranked. Dashboard Agents page shows leaderboards per domain.
+
+**Training tuples** extracted from journals for fine-tuning: `(state, action, reward)` — maps codebase state + experiment action to eval score delta.
+
+**API endpoints** on Context Hub:
+- `GET /api/eval/leaderboard` — all agents ranked by composite
+- `GET /api/eval/trajectory?agent=X&metric=composite` — score trajectory with timestamps
+
+### RL Infrastructure
+
+JFL generalizes the Karpathy nanochat pattern: structured journals are the replay buffer, eval scores are rewards, agents learn in-context from past trajectories.
+
+```
+Agent LLM (Policy)        > reads trajectories, proposes experiments
+Stratus (World Model)     > predicts outcomes, filters bad proposals
+Journals (Replay Buffer)  > structured experiment history
+Eval Framework (Reward)   > composite scores, score deltas
+Event Bus (Nervous System) > connects everything
+```
+
+**JournalEntry type** — canonical schema with 6 RL fields: `hypothesis`, `outcome`, `score_delta`, `eval_snapshot`, `diff_hash`, `context_entries`.
+
+**TrajectoryLoader** — query, filter, and render experiment trajectories for agent context windows. Supports filtering by session, agent, outcome, score range.
+
+**Peter Parker** — model-routed orchestrator with cost/balanced/quality profiles. Routes tasks to haiku/sonnet/opus based on complexity. Subscribes to event bus for reactive dispatch.
+
+**Flow Engine** — declarative trigger-action automation in `.jfl/flows.yaml`:
+
+```yaml
+- name: eval-scored-trigger-analysis
+  trigger:
+    pattern: "eval:scored"
+  gate:
+    requires_approval: true
+  actions:
+    - type: spawn
+      command: "claude -p 'Analyze the latest eval results'"
+```
+
+Flow actions: `log`, `emit`, `journal`, `webhook`, `command`, `spawn`. Gates: `after` (time-gated), `before` (deadline), `requires_approval`.
+
+**MCP tool:** `query_experiment_history` — agents query past experiment trajectories to inform next proposals.
+
+### Portfolio Management
+
+Coordinate multiple GTM workspaces under one portfolio.
+
+```bash
+jfl portfolio register /path/to/gtm   # Register a GTM in this portfolio
+jfl portfolio list                     # List child GTMs with health
+jfl portfolio unregister <name>        # Remove a GTM
+jfl portfolio status                   # Portfolio health + eval summary
+jfl portfolio phone-home               # Report GTM health to portfolio parent
+```
+
+**Portfolio Context Hub** operates in fan-out mode:
+- Connects to child GTM hubs via SSE
+- Bridges child events into portfolio event bus
+- Fans out search queries across all child hubs
+- Aggregates eval leaderboard across products
+- Enforces context scope (produces/consumes/denied) between GTMs
+
+**Cross-product flows** defined in `.jfl/flows.yaml`:
+
+```yaml
+- name: tool-trends-to-seo
+  trigger:
+    pattern: "discovery:tool-trend"
+    source: "productrank-gtm"
+  actions:
+    - type: webhook
+      url: "http://localhost:{{child.seo-agent.port}}/api/events"
+```
+
+Template variables: `{{child.NAME.port}}`, `{{child.NAME.token}}`
+
+**Context scope** — each child GTM declares what events it produces and consumes. Portfolio enforces boundaries:
+
+```json
+{
+  "context_scope": {
+    "produces": ["discovery:tool-trend", "eval:*"],
+    "consumes": ["strategy:*", "seo:serp-data"],
+    "denied": []
+  }
+}
+```
+
 ### Memory System
 
 Hybrid search over all journal entries with TF-IDF (40%) + semantic embeddings (60%).
@@ -164,6 +313,7 @@ Automatic session isolation for parallel work:
 - **Multiple concurrent sessions:** Isolated git worktrees prevent conflicts
 - **Auto-commit:** Saves work every 2 minutes (knowledge, journal, suggestions)
 - **Crash recovery:** Detects uncommitted work in stale sessions, auto-commits on next start
+- **Cleanup guard:** Prevents `rm -rf` on main branch when no worktrees exist
 
 ```bash
 # Hooks handle everything automatically. Manual control:
@@ -212,6 +362,18 @@ jfl services                  # Interactive TUI (no args)
 - Service entry in `.jfl/services.json`
 - Config in service repo (`.jfl/config.json` with `gtm_parent`)
 
+**Context scoping:** Each service declares what events it produces and consumes. The GTM enforces scope — teams can't read each other's journals unless explicitly granted.
+
+```json
+{
+  "context_scope": {
+    "produces": ["eval:submission", "journal:my-team*"],
+    "consumes": ["eval:scored", "leaderboard:updated"],
+    "denied": ["journal:other-team*"]
+  }
+}
+```
+
 **Phone-home on session end:** When a service session ends, it syncs to the parent GTM:
 - Journal entries copied to `GTM/.jfl/journal/service-{name}-*.jsonl`
 - Comprehensive sync payload (git stats, health, environment)
@@ -254,12 +416,32 @@ jfl services                  # Interactive TUI (no args)
 | `jfl context-hub status` | Health check |
 | `jfl context-hub doctor [--clean]` | Diagnose all projects |
 | `jfl context-hub ensure-all` | Start for all GTM projects |
-| `jfl context-hub dashboard` | Live event/context dashboard |
+| `jfl context-hub dashboard` | Open web dashboard in browser |
 | `jfl context-hub query` | Query context from CLI |
 | `jfl context-hub serve` | Run in foreground (daemon mode) |
 | `jfl context-hub install-daemon` | Auto-start on boot |
 | `jfl context-hub uninstall-daemon` | Remove auto-start |
 
+### Eval Framework
+
+| Command | Description |
+|---------|-------------|
+| `jfl eval list [-a agent] [-l limit]` | List recent eval entries |
+| `jfl eval trajectory -a <agent>` | Composite score trajectory with sparkline |
+| `jfl eval log -a <agent> -m <metrics>` | Log an eval entry |
+| `jfl eval compare` | Side-by-side agent comparison |
+| `jfl eval tuples [--limit N] [--format json]` | Extract training tuples from journals |
+
+### Portfolio
+
+| Command | Description |
+|---------|-------------|
+| `jfl portfolio register <path>` | Register GTM workspace in portfolio |
+| `jfl portfolio list` | List child GTMs with health status |
+| `jfl portfolio unregister <name>` | Remove GTM from portfolio |
+| `jfl portfolio status` | Portfolio health and eval summary |
+| `jfl portfolio phone-home` | Report GTM health to portfolio parent |
+
 ### Memory
 
 | Command | Description |
@@ -302,6 +484,22 @@ jfl services                  # Interactive TUI (no args)
 | `jfl dashboard` | Interactive service monitoring TUI |
 | `jfl events [-p pattern]` | Live MAP event bus dashboard |
 
+### Hooks & Flows
+
+| Command | Description |
+|---------|-------------|
+| `jfl hooks init` | Generate HTTP hooks + default flows |
+| `jfl hooks status` | Check hooks and hub connectivity |
+| `jfl hooks remove` | Remove HTTP hooks |
+| `jfl hooks deploy` | Deploy hooks to all registered services |
+| `jfl flows list` | List configured event-action flows |
+| `jfl flows add` | Interactive flow builder |
+| `jfl flows test <name>` | Test a flow with synthetic event |
+| `jfl flows enable/disable <name>` | Toggle flows |
+| `jfl scope list` | View service context scopes |
+| `jfl scope set` | Set scope declarations |
+| `jfl scope test` | Test scope enforcement |
+
 ### Platform
 
 | Command | Description |
@@ -319,7 +517,7 @@ jfl services                  # Interactive TUI (no args)
 |---------|-------------|
 | `jfl telemetry status` | Show telemetry status |
 | `jfl telemetry show` | Show queued events |
-| `jfl telemetry digest [--hours N] [--format json] [--platform]` | Cost breakdown, health analysis, suggestions |
+| `jfl telemetry digest [--hours N] [--format json] [--plots]` | Cost breakdown, health analysis, terminal charts |
 | `jfl telemetry reset` | Reset install ID |
 | `jfl telemetry track --category <c> --event <e>` | Emit event from shell scripts |
 | `jfl improve [--dry-run] [--auto] [--hours N]` | Self-improvement loop: analyze, suggest, create issues |
@@ -327,7 +525,7 @@ jfl services                  # Interactive TUI (no args)
 
 **Model cost tracking:** Every Stratus API call emits token counts and estimated cost. Covers claude-opus-4-6, claude-sonnet-4-6, claude-sonnet-4-5, claude-haiku-3-5, gpt-4o.
 
-**`jfl telemetry digest`** analyzes local events: per-model cost tables, command stats, error rates, hub/memory/session health. Flags issues like high MCP latency, cost concentration, crash rates.
+**`jfl telemetry digest`** analyzes local events: per-model cost tables, command stats, error rates, hub/memory/session health. `--plots` renders bar charts via kuva (falls back to ASCII).
 
 **`jfl improve`** generates actionable suggestions from the digest. `--dry-run` previews, `--auto` creates GitHub issues tagged `[jfl-improve]`.
 
@@ -461,14 +659,16 @@ Every session MUST write journal entries. Hooks enforce this.
   "summary": "Built jfl onboard command that registers service repos in GTM",
   "detail": "Creates agent definition, skill wrapper, services.json entry...",
   "files": ["src/commands/onboard.ts"],
-  "incomplete": ["peer sync not wired"],
-  "next": "Wire phone-home on session end"
+  "hypothesis": "Structured onboarding reduces setup errors",
+  "outcome": "confirmed",
+  "score_delta": 0.12,
+  "eval_snapshot": {"composite": 0.85}
 }
 ```
 
 **Write entries when:** Feature completed, decision made, bug fixed, milestone reached, session ending.
 
-Entries become searchable via `jfl memory search` and MCP `memory_search` tool.
+Entries become searchable via `jfl memory search` and MCP `memory_search` tool. RL fields (`hypothesis`, `outcome`, `score_delta`, `eval_snapshot`, `diff_hash`, `context_entries`) enable trajectory-based learning.
 
 ---
 
@@ -488,13 +688,63 @@ SessionStart hook fires          You work normally                Stop hook fire
                     ├─ Serves MCP tools to Claude Code
                     ├─ Aggregates journal + knowledge + code
                     ├─ Bridges service events from file-drop
-                    └─ Watches journal/ for live entries
+                    ├─ Watches journal/ for live entries
+                    ├─ Portfolio mode: fans out to child hubs
+                    ├─ Flow engine: reactive trigger→action
+                    └─ Web dashboard at /dashboard/
 ```
 
 **Everything is files.** No proprietary database. No lock-in. Context is git-native — version controlled, portable, model-agnostic.
 
 ---
 
+## CI/CD
+
+Two GitHub Actions workflows handle quality and releases.
+
+### CI — `.github/workflows/ci.yml`
+
+Runs on every push and PR to `main`:
+
+- TypeScript strict mode type checking
+- Full test suite (~365 tests across 17 test files)
+- Coverage report uploaded as artifact
+
+### CD — `.github/workflows/release.yml`
+
+Fires after CI passes on `main`. Uses [Changesets](https://github.com/changesets/changesets) for version management and npm Trusted Publisher (OIDC) for secretless publishing.
+
+**Auto-changeset generation:** `scripts/generate-changesets.sh` converts conventional commit messages into changesets automatically:
+- `feat:` = minor bump
+- `fix:` = patch bump
+- `feat!:` = major bump
+
+No manual `npx changeset` needed for most changes.
+
+**Release flow:**
+
+```bash
+# Option A: Manual changeset
+npx changeset         # pick bump level, write summary
+
+# Option B: Just use conventional commits — auto-generated on CI
+
+# Push to main — CI runs, then release.yml fires
+#   → changesets/action creates a "Version Packages" PR
+
+# Merge the Version PR
+#   → release.yml fires again → npm publish --provenance --access public
+```
+
+No `NPM_TOKEN` needed. Publishing uses OIDC provenance via npm Trusted Publisher.
+
+**One-time setup (per package):**
+> npmjs.com > `jfl` package > Settings > Publish Access > Add Provenance
+> - Repository: `402goose/jfl-cli`
+> - Workflow: `.github/workflows/release.yml`
+
+---
+
 ## Auto-Update
 
 JFL checks for npm updates on session start (24-hour cache):
@@ -530,6 +780,20 @@ jfl wallet                    # Wallet and day pass status
 
 ## What's New
 
+**0.3.0**
+- Feat: **Portfolio workspace type** — `jfl portfolio register/list/unregister/status/phone-home`. Portfolios contain multiple GTM workspaces with cross-product event routing via SSE, context scope enforcement (produces/consumes/denied), fan-out queries to child hubs, and portfolio-level leaderboard aggregation
+- Feat: **Dashboard V2** — pre-built Vite + Preact + Tailwind SPA served at `/dashboard/`. Pages: Overview (activity charts, metric cards), Journal (search + type filters), Events (pattern filter presets), Services (type badges, context scope, data flows), Flows (definitions + execution history), Health (system metrics, memory index), Agents (eval leaderboards grouped by domain)
+- Feat: **Eval framework** — `jfl eval list/trajectory/log/compare/tuples`. Track agent metrics over time with composite scores, dual-write up parent chain, extract (state, action, reward) training tuples. Agents grouped by metric domain (ProductRank: ndcg@10/mrr/precision@5, SEO: avg_rank/keywords_ranked)
+- Feat: **RL infrastructure (Phase 1)** — `JournalEntry` type with 6 RL fields, `TrajectoryLoader` for querying experiment history, `query_experiment_history` MCP tool
+- Feat: **Flow engine** — declarative trigger-action automation in `.jfl/flows.yaml`. Actions: log, emit, journal, webhook, command, spawn. Gates: time-gated, deadline, requires_approval. Template interpolation with `{{child.NAME.port}}`
+- Feat: **HTTP hooks** — Claude Code lifecycle hooks (PostToolUse, Stop, PreCompact, SubagentStart/Stop) POST to Context Hub. `jfl hooks init/status/remove/deploy`
+- Feat: **Context scope enforcement** — produces/consumes/denied patterns. Event bus filters by scope declarations. `jfl scope list/set/test`
+- Feat: CI/CD pipeline — GitHub Actions CI (strict TypeScript + Jest gate) + CD via Changesets with auto-generation from conventional commits. npm Trusted Publisher with OIDC provenance
+- Feat: Service agent templates (CLAUDE.md, settings.json, knowledge docs)
+- Feat: Session cleanup guard — prevents `rm -rf` on main when no worktrees exist
+- Fix: TypeScript strict mode build errors resolved
+- Test: ~365 tests across 17 test files (up from 237)
+
 **0.2.5**
 - Feat: Docker-style grouped `jfl --help` — 5 groups (Getting Started, Daily Use, Management, Platform, Advanced), ~30 lines down from 52
 - Feat: `jfl doctor [--fix]` — unified project health checker (9 checks: .jfl dir, config, Context Hub, hooks, memory, journal, agents, flows, git). Auto-repairs hooks, config, and journal with `--fix`

package/dist/commands/context-hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-hub.d.ts","sourceRoot":"","sources":["../../src/commands/context-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmzCH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBjF;AA2ND,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAiHxF;AAMD,wBAAsB,iBAAiB,CACrC,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,iBA8enE"}
+{"version":3,"file":"context-hub.d.ts","sourceRoot":"","sources":["../../src/commands/context-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAg8CH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBjF;AA2ND,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAiHxF;AAMD,wBAAsB,iBAAiB,CACrC,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,iBA+fnE"}

package/dist/commands/context-hub.js

@@ -632,10 +632,16 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
                         scope: cfg.context_scope || null,
                         registered_services: (cfg.registered_services || []).map((s) => ({
                             name: s.name,
+                            path: s.path,
                             type: s.type,
                             status: s.status,
                             context_scope: s.context_scope || null,
                         })),
+                        openclaw_agents: (cfg.openclaw_agents || []).map((a) => ({
+                            id: a.id,
+                            runtime: a.runtime,
+                            registered_at: a.registered_at,
+                        })),
                         gtm_parent: cfg.gtm_parent || null,
                         portfolio_parent: cfg.portfolio_parent || null,
                     };
@@ -876,6 +882,38 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             }
             return;
         }
+        // Synopsis (work summary)
+        if (url.pathname === "/api/synopsis" && req.method === "GET") {
+            try {
+                const hours = parseInt(url.searchParams.get("hours") || "24", 10);
+                const author = url.searchParams.get("author") || undefined;
+                const { generateSynopsis } = await import("./synopsis.js");
+                const synopsis = generateSynopsis(projectRoot, hours, author);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(synopsis));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Prediction accuracy (Stratus)
+        if (url.pathname === "/api/eval/predictions" && req.method === "GET") {
+            try {
+                const { Predictor } = await import("../lib/predictor.js");
+                const predictor = new Predictor({ projectRoot });
+                const accuracy = predictor.getAccuracy();
+                const recent = predictor.getHistory(20).reverse();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy, recent }));
+            }
+            catch (err) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy: { total: 0, resolved: 0, direction_accuracy: 0, mean_delta_error: 0, calibration: 0 }, recent: [] }));
+            }
+            return;
+        }
         // Cross-project health
         if (url.pathname === "/api/projects" && req.method === "GET") {
             const tracked = getTrackedProjects();
@@ -1005,6 +1043,39 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             }
             return;
         }
+        // Telemetry agent status
+        if (url.pathname === "/api/telemetry/agent" && req.method === "GET") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(agent.getStatus()));
+            }
+            else {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ running: false, lastRun: '', runCount: 0, lastInsights: [] }));
+            }
+            return;
+        }
+        // Telemetry agent: trigger manual run
+        if (url.pathname === "/api/telemetry/agent/run" && req.method === "POST") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                try {
+                    const insights = await agent.run();
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, insights }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            }
+            else {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Telemetry agent not running" }));
+            }
+            return;
+        }
         // Flow definitions
         if (url.pathname === "/api/flows" && req.method === "GET") {
             if (!flowEngine) {
@@ -1061,6 +1132,72 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             });
             return;
         }
+        if (url.pathname.match(/^\/api\/flows\/[^/]+\/toggle$/) && req.method === "POST") {
+            if (!flowEngine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Flow engine not initialized" }));
+                return;
+            }
+            const flowName = decodeURIComponent(url.pathname.split("/")[3]);
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { enabled } = JSON.parse(body || "{}");
+                    const result = flowEngine.toggleFlow(flowName, enabled);
+                    if (!result) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Flow not found" }));
+                        return;
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, flow: flowName, enabled: result.enabled }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        if (url.pathname === "/api/actions/spawn" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { command, args, cwd, event_type, event_data } = JSON.parse(body || "{}");
+                    if (!command) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "command required" }));
+                        return;
+                    }
+                    const env = { ...process.env };
+                    delete env.ANTHROPIC_API_KEY;
+                    delete env.CLAUDE_CODE_ENTRYPOINT;
+                    const child = spawn(command, args || [], {
+                        cwd: cwd || projectRoot,
+                        detached: true,
+                        stdio: "ignore",
+                        env,
+                    });
+                    child.unref();
+                    if (event_type && eventBus) {
+                        eventBus.emit({
+                            type: event_type,
+                            source: "dashboard:action",
+                            data: event_data || { command, args, pid: child.pid },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, pid: child.pid }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
         // 404
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Not found" }));
@@ -1728,6 +1865,23 @@ export async function contextHubCommand(action, options = {}) {
                 catch (err) {
                     console.error(`[${timestamp}] Failed to start flow engine:`, err.message);
                 }
+                // Start telemetry agent (periodic pattern detection)
+                try {
+                    const { TelemetryAgent } = await import("../lib/telemetry-agent.js");
+                    const telemetryAgent = new TelemetryAgent({
+                        projectRoot,
+                        intervalMs: 30 * 60 * 1000,
+                        emitEvent: (type, data, source) => {
+                            eventBus.emit({ type: type, data, source: source || 'telemetry-agent' });
+                        },
+                    });
+                    telemetryAgent.start();
+                    server.__telemetryAgent = telemetryAgent;
+                    console.log(`[${timestamp}] Telemetry agent started (interval: 30m)`);
+                }
+                catch (err) {
+                    console.error(`[${timestamp}] Failed to start telemetry agent:`, err.message);
+                }
                 console.log(`[${timestamp}] MAP event bus initialized (buffer: 1000, subscribers: ${eventBus.getSubscriberCount()})`);
                 console.log(`[${timestamp}] Ready to serve requests`);
             });