@zeyos/client 0.1.1 → 0.2.0

package/docs/03-cli/02-commands.md

@@ -113,6 +113,7 @@ zeyos list <resource> [options]
 |--------|-------------|
 | `--fields <fields>` | Field selection — comma-separated, JSON object, or JSON array (see below) |
 | `--filter <json>` | Filter criteria — JSON object |
+| `--filter-file <path>` | Read filter criteria from a JSON file |
 | `--sort <fields>` | Sort fields, comma-separated (prefix `+` asc, `-` desc) |
 | `--limit <n>` | Maximum records to return (default: `50`) |
 | `--offset <n>` | Skip the first n records |
@@ -140,6 +141,9 @@ zeyos list tickets
 # Custom filters
 zeyos list tickets --filter '{"status":1,"priority":3}'
 
+# Custom filters from a file
+zeyos list tickets --filter-file ./filters/open-tickets.json
+
 # Specify fields with aliases
 zeyos list accounts --fields '{"Name":"lastname","City":"contact.city"}'
 
@@ -179,6 +183,7 @@ zeyos count <resource> [options]
 | Option | Description |
 |--------|-------------|
 | `--filter <json>` | Filter criteria — JSON object |
+| `--filter-file <path>` | Read filter criteria from a JSON file |
 | `--json` | Output as `{"count": N}` |
 | `--yaml` | YAML output |
 
@@ -193,6 +198,9 @@ zeyos count tickets
 zeyos count tickets --filter '{"status":1}'
 # → 12
 
+# Filtered count using a JSON file
+zeyos count tickets --filter-file ./filters/open-tickets.json
+
 # JSON output for scripting
 zeyos count accounts --json
 # → {"count": 156}
@@ -261,6 +269,7 @@ zeyos create <resource> [--data <json>] [--field value ...]
 | Option | Description |
 |--------|-------------|
 | `--data <json>` | Complete record as a JSON string |
+| `--data-file <path>` | Read the complete record from a JSON file |
 | `--<field> <value>` | Set individual field (any unknown flag becomes a field) |
 
 **Examples:**
@@ -269,6 +278,9 @@ zeyos create <resource> [--data <json>] [--field value ...]
 # Using --data JSON
 zeyos create ticket --data '{"name":"Fix login bug","status":0,"priority":3}'
 
+# Using a JSON file
+zeyos create ticket --data-file ./ticket.json
+
 # Using individual field flags
 zeyos create ticket --name "Fix login bug" --status 0 --priority 3
 
@@ -301,6 +313,9 @@ zeyos update <resource> <id> [--data <json>] [--field value ...]
 # Using --data JSON
 zeyos update ticket 42 --data '{"status":4}'
 
+# Using a JSON file
+zeyos update ticket 42 --data-file ./ticket-update.json
+
 # Using field flags
 zeyos update ticket 42 --status 4 --priority 2
 
@@ -368,6 +383,19 @@ Foreign keys are shown as `→ <table>`, and enum fields list their valid values
 
 ---
 
+## doctor
+
+Check local CLI readiness for coding agents. This runs offline and never prints tokens or client secrets.
+
+```bash
+zeyos doctor agent
+zeyos doctor agent --json
+```
+
+The report includes the CLI version, configured base URL and instance, whether auth values are present through environment/local/global config, and whether the curated resource registry can be loaded.
+
+---
+
 ## skills
 
 Discover and install the bundled ZeyOS agent skill packs into any coding agent, so the agent (Claude Code, Codex, opencode, Factory Droid, pi, …) operates against ZeyOS with the right conventions out of the box.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeyos/client",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Dependency-light JavaScript client for ZeyOS OpenAPI services",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,12 @@
     "scripts/generate-client.mjs",
     "openapi",
     "docs",
-    "samples",
+    "samples/crm",
+    "samples/dashboard",
+    "samples/kanban",
+    "samples/missioncontrol/README.md",
+    "samples/missioncontrol/fetch-data.mjs",
+    "samples/missioncontrol/index.html",
     "agents",
     "README.md",
     "CHANGELOG.md",
@@ -44,6 +49,7 @@
     "generate": "node scripts/generate-client.mjs",
     "test": "node scripts/test.mjs",
     "test:cli-integration": "node --test cli/test/integration.mjs",
-    "test:agent-protocol": "node test/agent-protocol/harness/run.mjs"
+    "test:agent-protocol": "node test/agent-protocol/harness/run.mjs",
+    "test:agent-loop": "node test/agent-protocol/harness/loop.mjs"
   }
 }

package/samples/missioncontrol/README.md

@@ -0,0 +1,106 @@
+# Mission Control
+
+A team-performance dashboard for an IT consultancy running on ZeyOS — built on
+the [`@zeyos/client`](../../README.md) library. It answers the managing
+director's question: **who is actually working, and where is there untapped
+capacity?**
+
+A dark "mission control" view: a velocity KPI row, a 13-week throughput trend,
+a team-capacity strip, and a searchable/sortable/filterable grid of per-employee
+activity cards (click one for a per-type digest + contribution graph).
+
+## What it shows
+
+1. **Velocity** — tickets opened vs closed in the window, net flow, average /
+   median / p90 **cycle time** (open → close), open backlog (with overdue), and
+   total **hours booked**. A 13-week **throughput trend** of opened vs closed.
+2. **Activity card per employee** — open tickets, open tasks, tickets closed,
+   hours booked, a weekly-hours sparkline, team/location tags, a **capacity
+   badge** (Overloaded / Balanced / Available / Idle / Former), and **last
+   activity** (the most recent time entry) — flagged red when it's **older than
+   7 days**. Hover "last activity" to see the engineer's **last 10 time entries**
+   (date · type · customer · ticket · hours).
+3. **Per-employee digest** (click a card) — **booked hours stacked by
+   `extdata.type`** (Weekly / Monthly), and a **GitHub-style contribution graph**
+   of their time-entry activity over the last 53 weeks.
+
+Filters: search by name, **filter by team / department / location** (group
+membership), capacity chips (Engaged / Spare capacity / Inactive >7d /
+Overloaded / All), and sort by activity, hours, throughput, workload, cycle,
+overdue, or least-recent.
+
+The **Team capacity** strip and the *Spare capacity* filter surface the
+"untapped resources": active engineers running light or with no load at all,
+contrasted with the overloaded ones — the clearest place to rebalance work.
+
+## Run it
+
+```bash
+# 1. Authenticate once (if you haven't already)
+zeyos login --base-url https://zeyos.cms-it.de/dev
+
+# 2. Pull live data into data.js (read-only; reuses your CLI credentials)
+node samples/missioncontrol/fetch-data.mjs            # 90-day window
+node samples/missioncontrol/fetch-data.mjs --days 180 # custom window
+
+# 3. Open the dashboard
+#    Either open index.html directly, or serve the folder:
+python3 -m http.server 8765 --directory samples/missioncontrol
+#    → http://localhost:8765
+```
+
+`fetch-data.mjs` writes `data.js` (a `window.MISSION_DATA = …` assignment) so
+`index.html` works straight from disk — no server, no CORS, no token pasting.
+Re-run the fetcher to refresh; the page is otherwise a static, dependency-free
+single file (hand-rolled CSS + inline-SVG charts).
+
+## How it works
+
+`fetch-data.mjs` reads the credentials `zeyos login` stored
+(`.zeyos/auth.json` or `~/.config/zeyos/credentials.json`), builds an
+auto-refreshing client with `createZeyosClient`, and issues a handful of
+**read-only** `list` queries (tickets, `actionsteps`, tasks, groups), then
+aggregates them client-side (ZeyOS has no server-side group-by). It never writes
+to ZeyOS.
+
+### Metric definitions (so the numbers are reproducible)
+
+| Metric | Definition |
+|--------|------------|
+| **Time entry** | an `actionsteps` row with `status IN [1, 3]` (COMPLETED + BOOKED), attributed to an engineer via **`assigneduser`** (`owneruser` is unused here). `effort` is in **minutes**. |
+| **Last activity** | the engineer's most recent time-entry `date`; **stale** (red ⚠) when it's >7 days before the "as of" date. |
+| **Type** | `extdata.type` of each time entry (Intern / Auftrag / Consulting / Wartung / …), selected on `list` via the `extdata.type` field. Top 6 are charted; the rest roll into *Other*. |
+| **Closed / done** | tickets with `status IN [9, 11]` — COMPLETED + BOOKED (BOOKED, completed & billed, is the dominant terminal state). |
+| **Open backlog** | `status IN [0, 1, 2, 4, 6, 7]` — started/accepted/active but not done. |
+| **Opened in window** | tickets whose indexed `date` falls in the window. |
+| **Cycle time** | `lastmodified − creationdate` for tickets closed in the window (a proxy for the close timestamp, which ZeyOS does not store separately). |
+| **Capacity** | relative to the engaged-and-active cohort: *overloaded* (top-quintile workload or ≥3 overdue), *available* (low workload **and** below-median throughput), *idle* (active user, zero load), *balanced* (else), *former* (deactivated user with leftover assignments). |
+| **Team / location** | the engineer's **group memberships** (see below). |
+
+### Notes & limitations
+
+- **Department/location = groups.** ZeyOS *defines* custom fields
+  `users.department`/`users.location`/`users.team`, but the API returns
+  *"Extension data not available for users"* — they can't be read. The org
+  structure instead lives in **group membership** (e.g. `Developers`,
+  `Services`, `Technik`, `Berlin`, `Bayern`, `Nordrhein-Westfalen`), which is
+  what the team/location filter uses.
+- **`extdata` only lists via dot-fields.** Custom fields aren't returned by a
+  plain `list` (or `extdata=1`); they must be selected explicitly, e.g.
+  `fields: ['…','extdata.type']` (returned as `extdata_type`). On single records
+  `getTicket(…, { query:{ extdata:1 } })` returns them under an `extdata` object.
+- **Corrupt time-entry dates.** Many `actionsteps` have far-future `date` values
+  (year 2099+); the fetcher bounds queries to `date ≤ now` to exclude them.
+- **"As of" anchoring.** Windows are measured back from the latest activity in
+  the data, not wall-clock today — so a frozen/dev snapshot still produces
+  meaningful windows (and the 7-day staleness check is relative to it). The
+  anchor date is shown in the header.
+- **`date`, not `creationdate`, for windows.** `creationdate`/`lastmodified` are
+  unindexed on `tickets`; range-scanning them can time out (HTTP 503). The
+  indexed `date` column is used for opened-in-window queries.
+- **Roles aren't distinguished.** Every active user is included; a salesperson
+  with no tickets shows as *Idle*. Use the team filter / search to focus on a
+  delivery team.
+
+> `data.js` / `data.json` are generated and contain real names from your
+> instance — they are git-ignored. Commit only the source.

package/samples/missioncontrol/fetch-data.mjs

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * Mission Control — data fetcher
+ * ──────────────────────────────
+ * Pulls team-performance data from a live ZeyOS instance using the
+ * `@zeyos/client` library and the credentials you already created with
+ * `zeyos login` (read from .zeyos/auth.json or ~/.config/zeyos/credentials.json).
+ *
+ * It aggregates tickets (velocity) and `actionsteps` (time entries) into the
+ * metrics the dashboard needs and writes `data.js` (a `window.MISSION_DATA = …`
+ * assignment) so `index.html` can be opened straight from disk — no server, no
+ * CORS, no token pasting.
+ *
+ * Usage:
+ *   node samples/missioncontrol/fetch-data.mjs            # 90-day window
+ *   node samples/missioncontrol/fetch-data.mjs --days 180
+ *
+ * Read-only: this script only issues list/count queries. It never writes to ZeyOS.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createZeyosClient, MemoryTokenStore, normalizeListResult } from '../../src/index.js';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+const DAY = 86400;
+
+// ── Tunables ────────────────────────────────────────────────────────────────
+const WINDOW_DAYS = parseInt(argValue('--days') ?? '90', 10);   // primary window
+const TREND_WEEKS = 13;                                          // velocity / digest trend
+const CONTRIB_WEEKS = 53;                                        // contribution graph span
+const STALE_DAYS = 7;                                            // "last activity" warning threshold
+const TOP_TYPES = 6;                                             // distinct time-entry types to chart; rest → "Other"
+
+// ── Status vocabulary ─────────────────────────────────────────────────────────
+const CLOSED_STATUSES = [9, 11];               // tickets: COMPLETED + BOOKED
+const OPEN_STATUSES = [0, 1, 2, 4, 6, 7];      // tickets/tasks: in-flight backlog
+const TIME_STATUSES = [1, 3];                  // actionsteps: COMPLETED + BOOKED (booked time)
+
+// ── Credentials ───────────────────────────────────────────────────────────────
+const LOCAL_FILE = '.zeyos/auth.json';
+const GLOBAL_FILE = join(homedir(), '.config', 'zeyos', 'credentials.json');
+
+function findCredentials() {
+  let dir = process.cwd();
+  for (;;) {
+    const candidate = join(dir, LOCAL_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return existsSync(GLOBAL_FILE) ? GLOBAL_FILE : null;
+}
+
+const credPath = findCredentials();
+if (!credPath) { console.error('No ZeyOS credentials found. Run `zeyos login` first.'); process.exit(1); }
+const cred = JSON.parse(readFileSync(credPath, 'utf8'));
+if (!cred.baseUrl || !cred.accessToken) {
+  console.error(`Credentials at ${credPath} look incomplete. Run \`zeyos login\` again.`); process.exit(1);
+}
+
+const tokenStore = new MemoryTokenStore({
+  accessToken: cred.accessToken, refreshToken: cred.refreshToken,
+  expiresAt: cred.expiresAt, refreshTokenExpiresAt: cred.refreshTokenExpiresAt,
+});
+const client = createZeyosClient({
+  platform: cred.baseUrl,
+  auth: { mode: 'oauth', oauth: { clientId: cred.clientId, clientSecret: cred.clientSecret, tokenStore, autoRefresh: true } },
+});
+
+async function persistTokens() {
+  try {
+    const ts = await tokenStore.get();
+    if (ts?.accessToken && ts.accessToken !== cred.accessToken) {
+      writeFileSync(credPath, JSON.stringify({ ...cred, ...ts }, null, 2) + '\n', { mode: 0o600 });
+    }
+  } catch { /* non-critical */ }
+}
+
+// ── Query helpers ───────────────────────────────────────────────────────────
+async function listAll(op, body) {
+  return normalizeListResult(await client.api[op]({ limit: 10000, ...body })).data;
+}
+/** Page through a large collection (ZeyOS caps a single page at 10000). */
+async function listPaged(op, body, cap = 250000) {
+  const out = []; const limit = 10000;
+  for (let offset = 0; ; offset += limit) {
+    const page = normalizeListResult(await client.api[op]({ ...body, limit, offset })).data;
+    out.push(...page);
+    if (page.length < limit || out.length >= cap) break;
+  }
+  return out;
+}
+
+// ── Aggregation utilities ─────────────────────────────────────────────────────
+const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+const mean = (xs) => (xs.length ? sum(xs) / xs.length : 0);
+const median = (xs) => { if (!xs.length) return 0; const s = [...xs].sort((a, b) => a - b); const m = s.length >> 1; return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };
+const percentile = (xs, p) => { if (!xs.length) return 0; const s = [...xs].sort((a, b) => a - b); return s[Math.min(s.length - 1, Math.floor((p / 100) * s.length))]; };
+const round1 = (n) => Math.round(n * 10) / 10;
+const weekLabel = (ts) => { const d = new Date(ts * 1000); return `${String(d.getMonth() + 1).padStart(2, '0')}/${String(d.getDate()).padStart(2, '0')}`; };
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+async function main() {
+  const REAL_NOW = Math.floor(Date.now() / 1000);
+  console.error(`⚡️ Mission Control — fetching from ${cred.baseUrl}`);
+  console.error(`   window: last ${WINDOW_DAYS} days · contribution: ${CONTRIB_WEEKS} weeks\n`);
+
+  // 1) Active roster
+  const users = await listAll('listUsers', { fields: ['ID', 'name', 'email'], filters: { activity: 0 } });
+  const userById = new Map(users.map((u) => [u.ID, u]));
+  console.error(`· users (active):        ${users.length}`);
+
+  // 2) Group membership → department/location facet (user extdata isn't API-readable).
+  const groups = await listAll('listGroups', { fields: ['ID', 'name'] });
+  const groupName = new Map(groups.map((g) => [g.ID, g.name]));
+  const g2u = await listPaged('listGroupsToUsers', { fields: ['group', 'user'] });
+  const userGroups = new Map();
+  for (const row of g2u) {
+    if (!userById.has(row.user)) continue;
+    if (!userGroups.has(row.user)) userGroups.set(row.user, []);
+    const name = groupName.get(row.group);
+    if (name) userGroups.get(row.user).push(name);
+  }
+  console.error(`· groups:                ${groups.length}`);
+
+  // 3) Anchor "now" to the latest real activity (data may be a frozen snapshot).
+  const latestTicket = await listAll('listTickets', { fields: ['ID', 'date'], filters: { visibility: 0 }, sort: ['-date'], limit: 1 });
+  let asOf = latestTicket[0]?.date || REAL_NOW;
+
+  // 4) Tickets — velocity (indexed `date` for opened; lastmodified for closed).
+  const trendStart = asOf - TREND_WEEKS * 7 * DAY;
+  const windowStart = asOf - WINDOW_DAYS * DAY;
+  const recentTickets = await listAll('listTickets', {
+    fields: ['ID', 'assigneduser', 'status', 'date', 'creationdate', 'lastmodified'],
+    filters: { visibility: 0, date: { '>=': trendStart, '<=': asOf } }, sort: ['-date'],
+  });
+  const closedTickets = await listAll('listTickets', {
+    fields: ['ID', 'assigneduser', 'status', 'date', 'creationdate', 'lastmodified'],
+    filters: { visibility: 0, status: { IN: CLOSED_STATUSES }, lastmodified: { '>=': trendStart } }, sort: ['-lastmodified'],
+  });
+  const openTickets = await listAll('listTickets', {
+    fields: ['ID', 'assigneduser', 'status', 'duedate'],
+    filters: { visibility: 0, status: { IN: OPEN_STATUSES } },
+  });
+  const openTasks = await listAll('listTasks', {
+    fields: ['ID', 'assigneduser', 'status'],
+    filters: { visibility: 0, status: { IN: OPEN_STATUSES } },
+  });
+  console.error(`· tickets:               ${recentTickets.length} opened / ${closedTickets.length} closed (trend) · ${openTickets.length} open · ${openTasks.length} tasks`);
+
+  // 5) Time entries — actionsteps (booked time). Bound to sane dates (≤ now) to
+  //    skip corrupt far-future rows. Paged; extdata.type pulled via dot-field.
+  const contribStartRaw = asOf - (CONTRIB_WEEKS * 7 - 1) * DAY;
+  // snap contribution window start back to a Monday for clean week columns
+  const csWeekday = (new Date(contribStartRaw * 1000).getDay() + 6) % 7;
+  const contribStart = contribStartRaw - csWeekday * DAY;
+  const entries = await listPaged('listActionSteps', {
+    fields: ['ID', 'assigneduser', 'date', 'effort', 'ticket', 'account', 'extdata.type'],
+    filters: { status: { IN: TIME_STATUSES }, date: { '>=': contribStart, '<=': REAL_NOW } }, sort: ['-date'],
+  });
+  // entries arrive with `extdata_type`; normalise to `type`
+  for (const e of entries) { e.type = e.extdata_type || 'Untyped'; delete e.extdata_type; if (e.date > asOf) asOf = e.date; }
+  console.error(`· time entries:          ${entries.length} (${CONTRIB_WEEKS}w)`);
+
+  await persistTokens();
+
+  // recompute windows against possibly-updated asOf
+  const winStart = asOf - WINDOW_DAYS * DAY;
+  const trStart = asOf - TREND_WEEKS * 7 * DAY;
+
+  // ── Distinct time-entry types → top N + Other (stable chart segmentation) ────
+  const typeTotals = new Map();
+  for (const e of entries) if (e.date >= winStart) typeTotals.set(e.type, (typeTotals.get(e.type) || 0) + e.effort);
+  const topTypes = [...typeTotals.entries()].sort((a, b) => b[1] - a[1]).slice(0, TOP_TYPES).map(([t]) => t);
+  const typeBucket = (t) => (topTypes.includes(t) ? t : 'Other');
+  const TYPE_ORDER = [...topTypes, ...(typeTotals.size > TOP_TYPES ? ['Other'] : [])];
+
+  // ── Velocity (tickets) ──────────────────────────────────────────────────────
+  const weeks = [];
+  for (let w = TREND_WEEKS - 1; w >= 0; w--) {
+    const s = asOf - (w + 1) * 7 * DAY, e = asOf - w * 7 * DAY;
+    weeks.push({ start: s, end: e, label: weekLabel(e),
+      opened: recentTickets.filter((t) => t.date >= s && t.date < e).length,
+      closed: closedTickets.filter((t) => t.lastmodified >= s && t.lastmodified < e).length });
+  }
+  const cycleDaysAll = closedTickets.filter((t) => t.lastmodified >= winStart)
+    .map((t) => (t.lastmodified - (t.creationdate || t.date)) / DAY).filter((d) => d >= 0 && d < 3650);
+  const cycle = { avgDays: round1(mean(cycleDaysAll)), medianDays: round1(median(cycleDaysAll)), p90Days: round1(percentile(cycleDaysAll, 90)), sampleSize: cycleDaysAll.length };
+  const openedInWindow = recentTickets.filter((t) => t.date >= winStart).length;
+  const closedInWindow = closedTickets.filter((t) => t.lastmodified >= winStart).length;
+  const overdueOpen = openTickets.filter((t) => t.duedate > 0 && t.duedate < asOf).length;
+
+  // ── Per-employee aggregation ─────────────────────────────────────────────────
+  const contribCols = Math.ceil((asOf - contribStart) / DAY / 7) + 1;
+  const dayIndex = (ts) => Math.floor((ts - contribStart) / DAY);
+
+  const byUser = new Map();
+  const ensure = (uid) => {
+    if (uid == null) return null;
+    if (!byUser.has(uid)) {
+      const u = userById.get(uid);
+      byUser.set(uid, {
+        id: uid, name: u?.name || `user#${uid}`, email: u?.email || '', active: !!u,
+        groups: userGroups.get(uid) || [],
+        openTickets: 0, overdueTickets: 0, openTasks: 0, openedInWindow: 0, closedInWindow: 0,
+        cycleDays: [], _entries: [], lastActivity: 0,
+      });
+    }
+    return byUser.get(uid);
+  };
+  for (const u of users) ensure(u.ID);
+
+  for (const t of openTickets) { const a = ensure(t.assigneduser); if (!a) continue; a.openTickets++; if (t.duedate > 0 && t.duedate < asOf) a.overdueTickets++; }
+  for (const t of openTasks) { const a = ensure(t.assigneduser); if (a) a.openTasks++; }
+  for (const t of recentTickets) { const a = ensure(t.assigneduser); if (a && t.date >= winStart) a.openedInWindow++; }
+  for (const t of closedTickets) {
+    const a = ensure(t.assigneduser); if (!a) continue;
+    if (t.lastmodified >= winStart) { a.closedInWindow++; const d = (t.lastmodified - (t.creationdate || t.date)) / DAY; if (d >= 0 && d < 3650) a.cycleDays.push(d); }
+  }
+  for (const e of entries) {
+    const a = ensure(e.assigneduser); if (!a) continue;
+    a._entries.push(e);
+    if (e.date > a.lastActivity) a.lastActivity = e.date;
+  }
+
+  // Resolve customer (account) + ticket numbers for the recent-entries hover.
+  // Many entries carry only a ticket, so backfill the customer via the ticket's account.
+  const accIds = new Set(), tkIds = new Set();
+  for (const a of byUser.values()) for (const e of a._entries.slice(0, 10)) { if (e.account) accIds.add(e.account); if (e.ticket) tkIds.add(e.ticket); }
+  const accName = new Map(), tkNum = new Map(), tkAccount = new Map();
+  if (tkIds.size) for (const t of await listAll('listTickets', { fields: ['ID', 'ticketnum', 'account'], filters: { ID: { IN: [...tkIds] } } })) {
+    tkNum.set(t.ID, t.ticketnum || `#${t.ID}`);
+    if (t.account) { tkAccount.set(t.ID, t.account); accIds.add(t.account); }
+  }
+  if (accIds.size) for (const acc of await listAll('listAccounts', { fields: ['ID', 'lastname', 'firstname'], filters: { ID: { IN: [...accIds] } } }))
+    accName.set(acc.ID, acc.lastname || acc.firstname || `#${acc.ID}`);
+  const customerOf = (e) => { const id = e.account || tkAccount.get(e.ticket); return id ? (accName.get(id) || `#${id}`) : ''; };
+
+  let employees = [...byUser.values()].map((e) => {
+    const entriesWin = e._entries.filter((x) => x.date >= winStart);
+    // weekly stacked-by-type (last TREND_WEEKS)
+    const weeklyByType = weeks.map((w) => {
+      const seg = {};
+      for (const x of e._entries) if (x.date >= w.start && x.date < w.end) seg[typeBucket(x.type)] = (seg[typeBucket(x.type)] || 0) + x.effort;
+      return { label: w.label, seg };
+    });
+    // contribution: sparse [dayIndex, count]
+    const contribMap = new Map();
+    for (const x of e._entries) { const d = dayIndex(x.date); if (d >= 0) contribMap.set(d, (contribMap.get(d) || 0) + 1); }
+    const contrib = [...contribMap.entries()].sort((a, b) => a[0] - b[0]);
+    // recent 10 entries for the hover
+    const recentEntries = e._entries.slice(0, 10).map((x) => ({
+      date: x.date, mins: x.effort, type: x.type,
+      customer: customerOf(x),
+      ticket: x.ticket ? (tkNum.get(x.ticket) || `#${x.ticket}`) : '',
+    }));
+    const throughput = e.closedInWindow, workload = e.openTickets + e.openTasks;
+    return {
+      id: e.id, name: e.name, email: e.email, active: e.active, groups: e.groups,
+      openTickets: e.openTickets, overdueTickets: e.overdueTickets, openTasks: e.openTasks,
+      openedInWindow: e.openedInWindow, closedInWindow: e.closedInWindow,
+      avgCycleDays: round1(mean(e.cycleDays)), throughput, workload,
+      lastActivity: e.lastActivity,
+      stale: e.lastActivity > 0 && (asOf - e.lastActivity) > STALE_DAYS * DAY,
+      bookedHours: round1(sum(entriesWin.map((x) => x.effort)) / 60),
+      entriesInWindow: entriesWin.length,
+      recentEntries, weeklyByType, contrib,
+      activityScore: workload + throughput + e.openedInWindow + entriesWin.length,
+    };
+  });
+
+  // ── Capacity classification (engaged-and-active cohort defines thresholds) ───
+  const engaged = employees.filter((e) => e.active && e.activityScore > 0);
+  const wLow = percentile(engaged.map((e) => e.workload), 33);
+  const wHigh = percentile(engaged.map((e) => e.workload), 80);
+  const tMed = median(engaged.map((e) => e.throughput));
+  for (const e of employees) {
+    if (!e.active) e.capacity = 'former';
+    else if (e.activityScore === 0) e.capacity = 'idle';
+    else if (e.workload >= wHigh || e.overdueTickets >= 3) e.capacity = 'overloaded';
+    else if (e.workload <= wLow && e.throughput <= tMed) e.capacity = 'available';
+    else e.capacity = 'balanced';
+  }
+  employees.sort((a, b) => b.activityScore - a.activityScore || b.throughput - a.throughput);
+
+  // ── Group facet for the filter (only groups engaged employees belong to) ─────
+  const groupCount = new Map();
+  for (const e of employees) if (e.capacity !== 'former') for (const g of e.groups) groupCount.set(g, (groupCount.get(g) || 0) + 1);
+  const groupFacet = [...groupCount.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([name, count]) => ({ name, count }));
+
+  // ── Team-level time summary ──────────────────────────────────────────────────
+  const winEntries = entries.filter((e) => e.date >= winStart);
+  const byTypeHours = TYPE_ORDER.map((t) => ({ type: t, hours: round1(sum(winEntries.filter((e) => typeBucket(e.type) === t).map((e) => e.effort)) / 60) }));
+
+  const data = {
+    meta: {
+      instance: cred.baseUrl, generatedAt: REAL_NOW, asOf,
+      windowDays: WINDOW_DAYS, trendWeeks: TREND_WEEKS,
+      contribWeeks: CONTRIB_WEEKS, contribStart, contribCols, staleDays: STALE_DAYS,
+      typeOrder: TYPE_ORDER, closedStatuses: CLOSED_STATUSES, openStatuses: OPEN_STATUSES, timeStatuses: TIME_STATUSES,
+    },
+    velocity: {
+      openedInWindow, closedInWindow, net: openedInWindow - closedInWindow,
+      backlogOpen: openTickets.length, backlogOverdue: overdueOpen, openTasks: openTasks.length,
+      weeklyOpenedAvg: round1(mean(weeks.map((w) => w.opened))), weeklyClosedAvg: round1(mean(weeks.map((w) => w.closed))),
+      cycle, trend: weeks.map(({ label, opened, closed }) => ({ label, opened, closed })),
+    },
+    time: {
+      entries: winEntries.length, bookedHours: round1(sum(winEntries.map((e) => e.effort)) / 60),
+      byType: byTypeHours, staleEngineers: employees.filter((e) => e.active && e.stale).length,
+    },
+    team: {
+      activeUsers: users.length, engaged: engaged.length,
+      available: employees.filter((e) => e.capacity === 'available').length,
+      overloaded: employees.filter((e) => e.capacity === 'overloaded').length,
+      balanced: employees.filter((e) => e.capacity === 'balanced').length,
+      idle: employees.filter((e) => e.capacity === 'idle').length,
+      former: employees.filter((e) => e.capacity === 'former').length,
+    },
+    groups: groupFacet,
+    employees: employees.map(({ activityScore, ...rest }) => rest),
+  };
+
+  const json = JSON.stringify(data, null, 1);
+  writeFileSync(join(__dir, 'data.js'), `window.MISSION_DATA = ${json};\n`);
+  writeFileSync(join(__dir, 'data.json'), json + '\n');
+
+  console.error(`\n✓ Wrote data.js + data.json`);
+  console.error(`  as of ${new Date(asOf * 1000).toISOString().slice(0, 10)} · ${openedInWindow} opened / ${closedInWindow} closed · ` +
+    `${data.time.bookedHours}h booked · ${data.time.staleEngineers} engineers stale (>${STALE_DAYS}d) · ` +
+    `${employees.length} employees · ${data.team.available} available, ${data.team.overloaded} overloaded`);
+}
+
+function argValue(flag) { const i = process.argv.indexOf(flag); return i >= 0 ? process.argv[i + 1] : undefined; }
+
+main().catch((err) => { console.error(`\n✗ ${err.message}`); if (err.status) console.error(`  HTTP ${err.status}`); process.exit(1); });