@eventmodelers/cli 1.0.157 → 1.0.159

package/README.md

@@ -697,6 +697,7 @@ Every config field can be set via an `EVENTMODELERS_*` env var instead of the in
 | `EVENTMODELERS_MODEL` | `model` |
 | `EVENTMODELERS_SUBAGENT_MODEL` | `subagentModel` |
 | `EVENTMODELERS_AGENT_NAME` | `agentName` |
+| `EVENTMODELERS_POCKETBASE_URL` | `pocketbaseUrl` — on-prem only: overrides the PocketBase address the server advertises via `/api/config` (e.g. `/pb` or `https://host/pb`; a leading `/` is resolved against the base URL, replacing any path on it). Also read from `config.json`; either one beats the server's value |
 
 ```bash
 EVENTMODELERS_ORGANIZATION_ID=... EVENTMODELERS_BOARD_ID=... EVENTMODELERS_TOKEN=... \

package/cli.js

@@ -437,6 +437,7 @@ const ENV_CONFIG_MAP = {
   EVENTMODELERS_MODEL: 'model',
   EVENTMODELERS_SUBAGENT_MODEL: 'subagentModel',
   EVENTMODELERS_AGENT_NAME: 'agentName',
+  EVENTMODELERS_POCKETBASE_URL: 'pocketbaseUrl',
 };
 
 function applyEnvOverrides(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.157",
+  "version": "1.0.159",
   "description": "Eventmodelers CLI — real-time Claude agent + skills for Claude Code, for any stack (Node, Supabase, Axon, OpenCQRS, UmaDB, Kurrent, or modeling-only)",
   "type": "module",
   "bin": {

package/shared/build-kit/lib/adapters/pocketbase-realtime-adapter.js

@@ -16,12 +16,20 @@ const REALTIME_EVENTS_COLLECTION = 'realtime_events';
 // ourselves.
 const RECONNECT_INTERVALS_MS = [200, 300, 500, 1000, 1200, 1500, 2000];
 
+// A path like "/pb" (client-side override) is resolved against the platform's base URL,
+// so it replaces any path on it: https://host/api + /pb -> https://host/pb.
+function resolvePocketBaseUrl({ pocketbaseUrl, baseUrl }) {
+  if (!pocketbaseUrl?.startsWith('/')) return pocketbaseUrl;
+  if (!baseUrl) throw new Error(`pocketbaseUrl "${pocketbaseUrl}" is a path but no baseUrl is configured to resolve it against`);
+  return new URL(pocketbaseUrl, baseUrl).href.replace(/\/+$/, '');
+}
+
 // deps.PocketBase is injectable for tests; by default it is the pocketbase SDK's client.
 export async function createPocketBaseRealtimeAdapter(cfg, initialToken, deps = {}) {
   const { EventSource } = await import('eventsource');
   if (!globalThis.EventSource) globalThis.EventSource = EventSource; // PocketBase's SDK assumes a browser-style global
   const PocketBase = deps.PocketBase ?? (await import('pocketbase')).default;
-  const pb = new PocketBase(cfg.pocketbaseUrl);
+  const pb = new PocketBase(resolvePocketBaseUrl(cfg));
   pb.authStore.save(initialToken, null);
 
   // The SDK adds one EventSource listener per subscribe() call — and keeps it when the call

package/shared/build-kit/lib/ralph.js

@@ -99,6 +99,7 @@ const ENV_CONFIG_MAP = {
   EVENTMODELERS_MODEL: 'model',
   EVENTMODELERS_SUBAGENT_MODEL: 'subagentModel',
   EVENTMODELERS_AGENT_NAME: 'agentName',
+  EVENTMODELERS_POCKETBASE_URL: 'pocketbaseUrl',
 };
 
 function loadLocalConfig(kitDir) {
@@ -199,7 +200,10 @@ async function fetchPlatformConfig(local) {
   const remote = await fetchJSON(`${local.baseUrl}/api/config`, {
     headers: { 'x-token': local.token, ...agentHeaders(local) },
   });
-  return { ...local, ...remote };
+  // A client-side pocketbaseUrl (EVENTMODELERS_POCKETBASE_URL / config.json) beats the server's:
+  // on-prem the server may advertise its internal docker address (http://pocketbase:8090) that a
+  // remote agent cannot reach.
+  return { ...local, ...remote, ...(local.pocketbaseUrl ? { pocketbaseUrl: local.pocketbaseUrl } : {}) };
 }
 
 // ── Realtime agent ────────────────────────────────────────────────────────────

package/shared/skills/load-slice/SKILL.md

@@ -22,7 +22,28 @@ If neither is provided, load and persist all slices without filtering.
 
 ---
 
-## Step 2 — Fetch all slices from the slicedata API
+## Step 2 — Fetch the slice(s) from the slicedata API
+
+### When `sliceId` is given: fetch exactly that one slice — never all
+
+Do **not** fetch the board's full slice data, and do not loop over contexts. Only the one slice's full
+definition is fetched, and only that one is persisted in Step 3:
+
+1. **Context known?** If the caller passed a `contextId` (or the chapter id), skip to 3.
+2. **Otherwise locate it with one summary call** — `list_slices { "boardId": "<BOARD_ID>" }` (or the
+   `slicedata/slices` curl below). This is a lookup only: take the entry whose `id === sliceId` and read
+   its `contextName`. Don't persist or fan out over the rest of the list. If the id isn't in the list, stop
+   and report it.
+3. **Resolve the context id unambiguously** (see "A name is not a safe key" below — chapters can share a
+   title), then fetch the full slice with one call:
+   `get_slice_data { "boardId": "<BOARD_ID>", "contextId": "<contextId>", "sliceId": "<sliceId>" }`
+   (curl: `GET …/slicedata?contextId=<contextId>&sliceId=<sliceId>`).
+4. `ALL_SLICES` is then just that one slice; Step 3 persists only it.
+
+A `sliceTitle` without an id is resolved to an id via the same one summary call (stop and ask if the
+title matches more than one slice), then continues from step 3.
+
+### When neither is given: load all slices
 
 Prefer the MCP tool when `mcp__eventmodelers__*` tools are visible in this session:
 
@@ -40,6 +61,22 @@ This call stays full (no `projection`): Step 3 persists the complete slice objec
 
 (`get_slice_data` requires a `contextName` or `contextId`. If the context isn't already known, list the context names in one call — `mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "MODEL_CONTEXT", "projection": "line" }` (only titles needed; a timeline name works as `contextName` too, so fall back to `type: "CHAPTER"` with `projection: "line"` when there are no MODEL_CONTEXT nodes) — then map slices to contexts with `list_slices { "boardId": "<BOARD_ID>", "contextName": "<name>" }` per context. Don't `get_node` each `SLICE_BORDER`.)
 
+**A name is not a safe key — chapters and contexts can share a title.** The backend resolves `contextName`
+to the *first* chapter/context whose title matches (case-insensitive) and silently returns nothing
+if that one holds no slices — even when a same-titled twin holds them. A `SLICE_NOT_FOUND` (404) or an
+empty `slices: []` for a slice that `list_slices` clearly shows is therefore **not** proof the slice is
+missing. Before trusting it:
+
+1. List the chapters (`get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }`)
+   and the MODEL_CONTEXT nodes. If two or more share the title in question, **warn in the output**
+   (`Duplicate chapter title "<title>": <id1>, <id2>`) and retry the full fetch with **`contextId`**
+   set to each candidate id until the slice is found — `contextId` is matched exactly, so it is
+   unambiguous.
+2. Only if it is not found under any candidate id is the slice really absent.
+
+Prefer `contextId` over `contextName` whenever the id is known (a calling harness that already has the
+chapter id, or the list entry's `contextId`).
+
 **Fallback (no MCP):**
 
 ```bash
@@ -57,7 +94,22 @@ Save the full array as `ALL_SLICES`.
 
 ## Step 3 — Persist slices to .build-kit/.slices/ directory
 
-Apply the following logic for every slice in `ALL_SLICES`.
+Apply the following logic for every slice in `ALL_SLICES` — **or, when `sliceId`/`sliceTitle` was given,
+only for that one slice** (and only its own context's `index.json`). Don't rewrite 90 other slices'
+folders and indexes to load one; they may hold uncommitted local changes.
+
+**`slice.json` must be the full slice, never the list entry.** The `list_slices` / `slicedata/slices`
+payload is a summary (id, title, status, type, context name — no commands, events, fields, specs or
+comments). If the full fetch (Step 2) for a requested slice failed or came back without elements, do
+**not** write the summary as `slice.json` — it reads as an empty slice and has made agents conclude
+"nothing to build". Stop and report the failed fetch instead (see the duplicate-title handling in Step 2).
+
+**Check for collisions before writing.** Two slices in one `<contextSlug>` whose `<sliceFolder>` is
+identical (same title, or titles differing only by spaces/case) would overwrite each other, and so
+would two contexts that slugify identically. Detect this before writing; on a collision, don't write
+either, and report it: `Slice folder collision in <contextSlug>: "<title>" (<idA>, <status>) vs
+"<title>" (<idB>, <status>)`. Also report same-titled slices that don't collide (different contexts) as
+a one-line warning, so callers address slices by id.
 
 ### Derive paths
 
@@ -132,7 +184,9 @@ If `sliceId` was given: find the entry in `ALL_SLICES` where `id === sliceId`.
 If `sliceTitle` was given: find the entry where `title` matches case-insensitively.  
 If neither: return all slices.
 
-If a specific slice was requested but not found, stop and list the available titles.
+If a specific slice was requested but not found, stop and list the available titles — after ruling out the
+duplicate-chapter-title case from Step 2. If several slices share the requested title, don't pick one:
+list them with their ids, contexts and statuses and ask the caller to choose by id.
 
 ---
 
@@ -157,4 +211,11 @@ All slices (<count>) — context: <contextSlug>:
   - ...
 ```
 
+Append any warnings collected above (duplicate chapter titles, same-titled slices, folder collisions):
+
+```
+Warnings:
+  - Duplicate chapter title "Teams": d151f017-… , e985e6b3-… (slice found under e985e6b3-…)
+```
+
 Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.

package/shared/skills/request-feedback/SKILL.md

@@ -71,6 +71,37 @@ Find the slice whose `title` matches `sliceName` (case-insensitive), or whose `i
 If no match is found, stop and list the available slice titles so the caller can pick one. Save the
 matched slice's `id` as `SLICE_NODE_ID` and its current `status` as `CURRENT_STATUS`.
 
+## Step 2.5 — Verify the slice is really empty, and check for duplicate names
+
+"The slice has no elements" is the most common reason to block — and also the easiest to get wrong.
+The backend resolves `contextName` to the *first* chapter/context with a matching title, so when two
+chapters share a title, `slicedata?contextName=…` (and `slicedata/slices?contextName=…`) can return
+nothing for a slice that is fully modeled under the twin. A comment claiming "no elements" then
+blocks a healthy slice. Before posting anything:
+
+1. **Fetch the slice by id, not by name.** Resolve the slice's chapter/context id and call
+   `get_slice_data { "boardId": "<BOARD_ID>", "contextId": "<id>", "sliceId": "<SLICE_NODE_ID>" }`
+   (curl: `GET …/slicedata?contextId=<id>&sliceId=<SLICE_NODE_ID>`). Fetch only this one slice.
+2. **Check for duplicate chapter/context titles.** List chapters and MODEL_CONTEXT nodes
+   (`get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }`, and likewise
+   `MODEL_CONTEXT`). If two or more share the slice's chapter/context title (case-insensitive), retry
+   step 1 with each candidate `contextId` before concluding the slice is empty.
+3. **Check for duplicate slice names.** From the `list_slices` result, note any other slice with the
+   same title (case-insensitive) — in the same or another context — with its id and status.
+4. **Decide:**
+   - The slice has elements under some candidate id → **do not block, do not comment.** The "empty"
+     reading was a lookup artefact; go back and build using the correct `contextId`. Report the
+     duplicate-title problem to the caller instead.
+   - The slice really is empty (or contradictory) under every candidate → continue to Step 3, and
+     **name every duplicate you found in the question**, e.g. `Note: 2 timelines are titled "Teams"
+     (d151f017-…, e985e6b3-…) and a slice "Add Team" also exists in <context> (<id>, <status>) — please
+     check the content isn't under the twin.` so the human can tell a genuinely empty slice from a
+     misplaced one.
+   - Duplicates exist but the cause of the block is unrelated (e.g. a contradiction between two
+     specs): still mention them in the report (Step 5), not necessarily in the comment.
+
+---
+
 ## Step 3 — Post the comment
 
 There is no separate `QUESTION` type at the API level — post a normal `COMMENT` worded as a question.
@@ -138,6 +169,7 @@ Do not continue implementing the slice after this. Report back to whoever invoke
 Requested feedback on slice "<sliceName>" (<SLICE_NODE_ID>)
 Question posted: "<question>"
 Status: <CURRENT_STATUS> → Blocked
+Duplicates: <none | duplicate chapter titles "<title>" (<ids>) | same-titled slices "<title>" (<id> <status>, …)>
 ```
 
 Then stop work on this slice for this run. If the caller has other, unrelated slices queued, it may