callkaro-cli-unofficial 0.1.0

package/dist/commands/kpi.js

@@ -0,0 +1,681 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kpiAgentsCommand = kpiAgentsCommand;
+exports.kpiShowCommand = kpiShowCommand;
+exports.kpiTasksCommand = kpiTasksCommand;
+exports.kpiHistoryCommand = kpiHistoryCommand;
+exports.kpiCreateCommand = kpiCreateCommand;
+exports.kpiMoveCommand = kpiMoveCommand;
+exports.kpiSetCommand = kpiSetCommand;
+exports.kpiCommentCommand = kpiCommentCommand;
+exports.kpiAssignCommand = kpiAssignCommand;
+exports.kpiAssigneesCommand = kpiAssigneesCommand;
+exports.kpiTargetCommand = kpiTargetCommand;
+exports.kpiRcaCommand = kpiRcaCommand;
+const dashboardApi_1 = require("../lib/dashboardApi");
+const ui_1 = require("../lib/ui");
+/** Table cells are one line each; these keep a long prompt from wrapping a row. */
+function clip(value, max = 60) {
+    const text = value === undefined || value === null ? '' : String(value).replace(/\s+/g, ' ').trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+/** `--limit` with a sane floor, so `--limit 0` or garbage cannot dump 1220 rows. */
+function pageSize(raw, fallback = 25) {
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/**
+ * Date fields are plain `YYYY-MM-DD` strings, so string comparison orders them
+ * correctly. Accepts `2026-09-01`, `today`, `-7d`, `30d`, or `thisweek`.
+ */
+function dateBound(spec, endOfDay) {
+    const day = 86_400_000;
+    const now = new Date();
+    if (spec === 'today')
+        return now.toISOString().slice(0, 10);
+    if (/^-?\d+d$/.test(spec)) {
+        return new Date(now.getTime() - Number(spec.replace('d', '')) * day).toISOString().slice(0, 10);
+    }
+    if (spec === 'thisweek') {
+        // Monday-anchored, matching how the board's own weekly rollup is labelled.
+        const back = (now.getUTCDay() + 6) % 7;
+        return new Date(now.getTime() - back * day).toISOString().slice(0, 10);
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(spec))
+        return spec;
+    void endOfDay;
+    throw new Error(`Unrecognised date "${spec}".\n` +
+        '  Use YYYY-MM-DD (2026-09-01), a relative window (7d, 30d), or today / thisweek.');
+}
+/**
+ * Every filter the board actually supports, checked against a real 1220-record
+ * response. `/pending-tasks` takes no parameters, so all of this runs locally —
+ * which is also why each filter is ANDed and the count is always reported.
+ */
+function buildFilters(opts) {
+    const filters = [];
+    if (opts.severity) {
+        // The board uses four values; case-insensitive match, and comma = any-of.
+        const want = String(opts.severity).split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+        filters.push({ label: `severity in ${want.join(',')}`, keep: (t) => want.includes(String(t.severity || '').toLowerCase()) });
+    }
+    if (opts.agent) {
+        // Match the id OR the name, because "Retail Negotiations" is what a person
+        // reads off the board and the id is what they get from `cku kpi agents`.
+        const want = String(opts.agent).toLowerCase();
+        filters.push({
+            label: `agent ~ ${opts.agent}`,
+            keep: (t) => String(t.agentId || '').toLowerCase() === want ||
+                String(t.agentName || '').toLowerCase() === want ||
+                String(t.agentName || '').toLowerCase().includes(want),
+        });
+    }
+    if (opts.since) {
+        const from = dateBound(String(opts.since), false);
+        filters.push({ label: `rcaDate >= ${from}`, keep: (t) => String(t.rcaDate || t.createdAt || '') >= from });
+    }
+    if (opts.until) {
+        const to = dateBound(String(opts.until), true);
+        filters.push({ label: `rcaDate <= ${to}`, keep: (t) => String(t.rcaDate || t.createdAt || '') <= to });
+    }
+    if (opts.assigned) {
+        const want = String(opts.assigned).toLowerCase();
+        filters.push({
+            label: `assigned to ${opts.assigned}`,
+            keep: (t) => want === 'none'
+                ? !t.assignedToName
+                : String(t.assignedToName || '').toLowerCase().includes(want),
+        });
+    }
+    if (opts.source) {
+        const want = String(opts.source).toLowerCase();
+        filters.push({ label: `source ${opts.source}`, keep: (t) => String(t.reportSource || '').toLowerCase() === want });
+    }
+    if (opts.search) {
+        const want = String(opts.search).toLowerCase();
+        filters.push({
+            label: `text ~ ${opts.search}`,
+            keep: (t) => [t.cause, t.recommendedFix, t.description, t.agentName].some((f) => String(f || '').toLowerCase().includes(want)),
+        });
+    }
+    if (opts.hasComments) {
+        filters.push({ label: 'has comments', keep: (t) => Array.isArray(t.comments) && t.comments.length > 0 });
+    }
+    if (opts.withCalls) {
+        filters.push({ label: 'has calls', keep: (t) => Array.isArray(t.callIds) && t.callIds.length > 0 });
+    }
+    if (opts.column) {
+        // Comma = any-of, so `--column in_progress,done` is the "still open" query.
+        // Resolved through columnId() so a label works here too, and a typo fails
+        // here rather than matching nothing and looking like an empty board.
+        const want = String(opts.column).split(',').map((s) => columnId(s));
+        filters.push({ label: `column in ${want.join(',')}`, keep: (t) => want.includes(String(t.columnId || '')) });
+    }
+    return filters;
+}
+/**
+ * The board's columns, in board order. Read out of the dashboard bundle, which
+ * is where the ids come from — they are not the labels, so guessing "In
+ * Progress" as an id would 404 on every call.
+ */
+const COLUMNS = [
+    { id: 'action_items', label: 'Action Items' },
+    { id: 'in_progress', label: 'In Progress' },
+    { id: 'testing_ab', label: 'Testing in A/B' },
+    { id: 'live_prod', label: 'Live in Prod' },
+    { id: 'done', label: 'Done' },
+    { id: 'rejected', label: 'Rejected' },
+];
+/**
+ * Severity order, worst first. Six values, not four: the dashboard also renders
+ * "Very Low" and "Negligible", and omitting them meant `--severity "Very Low"`
+ * matched nothing at all while the worst-severity rollup ranked them below Low.
+ */
+const SEVERITY_ORDER = ['Very High', 'High', 'Medium', 'Low', 'Very Low', 'Negligible'];
+/**
+ * Columns accept the id, the label, or a slug of either, case-insensitively.
+ *
+ * Every side goes through the same normaliser. Normalising only the right-hand
+ * side is a silent mismatch: `slug('In Progress')` is `inprogress`, which never
+ * equals the raw `in progress`, so a label would be rejected. The id is tried
+ * as-written first, because that is what the server actually keys on.
+ */
+function columnId(raw) {
+    const text = String(raw || '').trim().toLowerCase();
+    const hit = COLUMNS.find((c) => c.id === text || slug(c.label) === slug(text) || slug(c.id) === slug(text));
+    if (!hit) {
+        throw new Error(`Unknown column "${raw}".\n` +
+            `  Columns: ${COLUMNS.map((c) => `${c.id} (${c.label})`).join(', ')}`);
+    }
+    return hit.id;
+}
+/** Accepts "Very High", "very-high", "very_high" or "veryhigh" alike. */
+function severity(raw) {
+    const want = slug(String(raw || '').toLowerCase());
+    const hit = SEVERITY_ORDER.find((s) => slug(s) === want);
+    if (!hit) {
+        throw new Error(`Unknown severity "${raw}".\n  Severities: ${SEVERITY_ORDER.join(', ')}`);
+    }
+    return hit;
+}
+/** Lowercase, letters and digits only. Folds "Testing in A/B" to "testinginab". */
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '');
+/**
+ * True when `candidate` outranks `current`.
+ *
+ * An empty `current` has to rank BELOW every real severity, not use
+ * `indexOf('')` — that returns -1, which loses to "Low" and leaves the
+ * worst-severity column blank forever.
+ */
+function worse(candidate, current) {
+    const a = SEVERITY_ORDER.indexOf(candidate || '');
+    if (a === -1)
+        return false; // unknown severity never wins
+    if (!current)
+        return true; // nothing recorded yet
+    const b = SEVERITY_ORDER.indexOf(current);
+    return b === -1 || a < b; // an unrecognised `current` is replaced
+}
+/** `cku kpi agents` — the agents on the board, with names for `--agent`. */
+async function kpiAgentsCommand(opts) {
+    try {
+        const api = (0, dashboardApi_1.dashboardApi)();
+        const [idsRes, tasksRes] = await Promise.all([api.kpiAgents(), api.pendingTasks()]);
+        const ids = Array.isArray(idsRes?.agentIds) ? idsRes.agentIds : [];
+        const tasks = Array.isArray(tasksRes?.tasks) ? tasksRes.tasks : [];
+        // The board carries agentName per task; roll it up so `--agent` can take a
+        // readable name instead of forcing the user to look up an ObjectId.
+        const names = new Map();
+        for (const t of tasks) {
+            if (!t.agentId)
+                continue;
+            const row = names.get(t.agentId) || { name: t.agentName || '', tasks: 0, worst: '', counts: {} };
+            row.tasks += 1;
+            const sev = t.severity || '';
+            row.counts[sev] = (row.counts[sev] || 0) + 1;
+            // `if (worse(...))` — never `row.worst = worse(...) ? sev : row.worst || ''`.
+            // That idiom discards the current value whenever worse() is correctly
+            // false, which is most calls, and leaves the column blank.
+            if (worse(sev, row.worst))
+                row.worst = sev;
+            names.set(t.agentId, row);
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify({ agentIds: ids, agents: [...names].map(([id, v]) => ({ id, ...v })) }, null, 2));
+        if (!names.size)
+            return void (0, ui_1.info)(ids.length ? `${ids.length} agent id(s): ${ids.join(', ')}` : 'No agents on the KPI board.');
+        (0, ui_1.table)(['AGENT ID', 'AGENT', 'TASKS', 'WORST', 'VH', 'H', 'M', 'L'], [...names]
+            .sort((a, b) => b[1].tasks - a[1].tasks)
+            .map(([id, v]) => [
+            id,
+            v.name || '(unnamed)',
+            v.tasks,
+            v.worst || '',
+            v.counts['Very High'] || '',
+            v.counts['High'] || '',
+            v.counts['Medium'] || '',
+            v.counts['Low'] || '',
+        ]));
+        (0, ui_1.info)('\nUse the id or the name with `cku kpi tasks --agent <value>`. VH/H/M/L = severity counts.');
+        if (ids.length > names.size)
+            (0, ui_1.info)(`${ids.length - names.size} scored agent(s) have no tasks yet.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * `cku kpi show <taskId>` — one task in full.
+ *
+ * The table deliberately truncates `cause` and hides `recommendedFix`,
+ * `metricImpact`, `comments` and `attachmentUrls`; this is where they are
+ * readable. taskId looks like `<agentId>:<rcaDate>:<n>`, so quote it in shells.
+ */
+async function kpiShowCommand(taskId, opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().pendingTasks();
+        const tasks = Array.isArray(res?.tasks) ? res.tasks : [];
+        const found = tasks.find((t) => t.taskId === taskId);
+        if (!found) {
+            return (0, ui_1.handleError)(new Error(`No pending task with id "${taskId}".\n` +
+                '  Ids look like <agentId>:<date>:<n> — find one with: cku kpi tasks --limit 50\n' +
+                `  ${tasks.length} task(s) currently on the board.`));
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify(found, null, 2));
+        (0, ui_1.keyValue)({
+            taskId: found.taskId,
+            agent: found.agentName || found.agentId,
+            severity: found.severity,
+            rcaDate: found.rcaDate,
+            source: found.reportSource,
+            assignedTo: found.assignedToName || '(unassigned)',
+            assignedOn: found.assignedOn,
+            updated: found.updatedAt,
+        });
+        // `rank` is a zero-padded position index whose width grows with the record
+        // count (t4 on 2026-09-10, 0001 on 09-28, 21 digits on 09-30). It is a
+        // sort key, not an identifier, so it is labelled as such and kept out of the
+        // task list — taskId is what you pass back to this command.
+        if (found.rank)
+            (0, ui_1.info)(`\nboard position key: ${found.rank}`);
+        (0, ui_1.info)(`\nCause:\n${found.cause || '(none)'}`);
+        if (found.recommendedFix)
+            (0, ui_1.info)(`\nRecommended fix:\n${found.recommendedFix}`);
+        if (found.metricImpact?.length) {
+            (0, ui_1.info)('\nMetric impact:');
+            (0, ui_1.table)([...new Set(found.metricImpact.flatMap((m) => Object.keys(m || {})))], found.metricImpact.map((m) => Object.values(m || {}).map(String)));
+        }
+        if (found.callIds?.length)
+            (0, ui_1.info)(`\nCall ids (${found.callIds.length}): ${found.callIds.slice(0, 10).join(', ')}${found.callIds.length > 10 ? ' …' : ''}`);
+        if (found.comments?.length) {
+            (0, ui_1.info)('\nComments:');
+            for (const c of found.comments)
+                (0, ui_1.info)(`  ${c?.author || c?.user?.name || '?'}: ${c?.text || c?.comment || JSON.stringify(c)}`);
+        }
+        if (found.attachmentUrls?.length)
+            (0, ui_1.info)(`\nAttachments:\n  ${found.attachmentUrls.join('\n  ')}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi tasks` — the pending-task board, filtered and paged. */
+async function kpiTasksCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().pendingTasks();
+        const all = Array.isArray(res?.tasks) ? res.tasks : [];
+        let filters;
+        try {
+            filters = buildFilters(opts);
+        }
+        catch (err) {
+            return (0, ui_1.handleError)(err);
+        }
+        const rows = filters.length ? all.filter((t) => filters.every((f) => f.keep(t))) : all;
+        if (opts.json)
+            return void console.log(JSON.stringify({ total: rows.length, tasks: rows }, null, 2));
+        const limit = pageSize(opts.limit);
+        (0, ui_1.info)(`Pending tasks · ${rows.length} of ${all.length}` +
+            (filters.length ? ` (${filters.map((f) => f.label).join(' AND ')})` : '') +
+            ` · showing ${Math.min(limit, rows.length)}\n`);
+        if (!rows.length) {
+            return void (0, ui_1.info)(all.length
+                ? 'Nothing matches. Filters are case-insensitive and combine with AND; --help lists them.'
+                : 'Nothing pending.');
+        }
+        (0, ui_1.table)(['TASK ID', 'COLUMN', 'DATE', 'SEVERITY', 'AGENT', 'ASSIGNED TO', 'CAUSE', 'CALLS'], rows.slice(0, limit).map((t) => [
+            t.taskId || '',
+            columnLabel(t.columnId),
+            t.rcaDate || t.createdAt || '',
+            t.severity || '',
+            t.agentName || t.agentId || '',
+            t.assignedToName || '',
+            clip(t.cause, 54),
+            Array.isArray(t.callIds) ? t.callIds.length : '',
+        ]));
+        if (rows.length > limit) {
+            (0, ui_1.info)(`\n${rows.length - limit} more. Raise with --limit <n>, or use --json to page it yourself.`);
+        }
+        (0, ui_1.info)('\nRead one in full: cku kpi show "<taskId>"  (quote it — it contains colons).');
+        (0, ui_1.info)('Move one: cku kpi move "<taskId>" <column>   Filter: --column action_items');
+        (0, ui_1.info)('`recommendedFix`, `metricImpact`, `comments` and `attachmentUrls` are only in --json.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi history --agents <ids>` — metric history for the given agents. */
+async function kpiHistoryCommand(opts) {
+    if (!opts.agents?.trim()) {
+        return (0, ui_1.handleError)(new Error('--agents <id,id,...> is required.\n  Get the list with: cku kpi agents'));
+    }
+    try {
+        const agentIds = opts.agents.split(',').map((s) => s.trim()).filter(Boolean);
+        if (!agentIds.length) {
+            return (0, ui_1.handleError)(new Error(`No agent ids in --agents "${opts.agents}".\n  Use a comma-separated list, e.g. --agents abc123,def456`));
+        }
+        const res = await (0, dashboardApi_1.dashboardApi)().kpiHistory({ agentIds: agentIds.join(',') });
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        // Deliberately generic: this response's shape was not confirmed field by field,
+        // so rendering it structurally is safer than asserting columns that may not exist.
+        if (Array.isArray(res)) {
+            if (!res.length)
+                return void (0, ui_1.info)('No history for those agents.');
+            const columns = [...new Set(res.flatMap((r) => (r && typeof r === 'object' ? Object.keys(r) : [])))];
+            (0, ui_1.table)(columns, res.map((row) => columns.map((c) => clip(row?.[c], 28))));
+            return;
+        }
+        if (res && typeof res === 'object') {
+            for (const [key, value] of Object.entries(res)) {
+                (0, ui_1.info)(`\n${key}`);
+                (0, ui_1.keyValue)(typeof value === 'object' && value ? value : { value });
+            }
+            return;
+        }
+        (0, ui_1.info)(String(res));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+// --- writes -----------------------------------------------------------------
+//
+// Routes and bodies below come from the dashboard's own bundle (see
+// `DashboardApi`'s comment on the write methods). Two constraints that reading
+// settled, and that shape every command here:
+//
+//   * There is no delete. A card is retired by moving it to `rejected`, which is
+//     reversible; nothing here destroys a card.
+//   * PATCH writes `description` only. cause / recommendedFix / severity are set
+//     at create and are not editable afterwards, so `kpi set` says so rather than
+//     silently dropping the field the user asked for.
+/** `cku kpi create` — add a card to the board. */
+async function kpiCreateCommand(opts) {
+    try {
+        const cause = String(opts.cause || '').trim();
+        if (!cause) {
+            return (0, ui_1.handleError)(new Error('--cause <text> is required. It is the only field the server insists on.'));
+        }
+        const body = {
+            columnId: columnId(opts.column || 'action_items'),
+            cause,
+            recommendedFix: String(opts.fix || '').trim(),
+            description: String(opts.description || '').trim(),
+            severity: opts.severity ? severity(opts.severity) : '',
+            estimatedImpactPct: numeric(opts.impact, '--impact'),
+            callIds: splitList(opts.calls),
+        };
+        const res = await (0, dashboardApi_1.dashboardApi)().createPendingTask(body);
+        const task = res?.task;
+        if (!task) {
+            return (0, ui_1.handleError)(new Error('The server accepted the request but returned no task. Nothing was created.'));
+        }
+        (0, ui_1.success)(`Created ${task.taskId} in ${columnLabel(task.columnId)}.`);
+        if (task.taskId)
+            (0, ui_1.info)(`  Read it: cku kpi show "${task.taskId}"`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi move <taskId> <column>` — the board's only way to retire a card. */
+async function kpiMoveCommand(taskId, to, opts) {
+    try {
+        const target = columnId(to);
+        const api = (0, dashboardApi_1.dashboardApi)();
+        // Read the board first: it is the only way to know the card exists and which
+        // column it is in, and a no-op move should say so instead of silently
+        // re-writing a card the user thinks they moved.
+        const res = await api.pendingTasks();
+        const tasks = Array.isArray(res?.tasks) ? res.tasks : [];
+        const task = tasks.find((t) => t.taskId === taskId);
+        if (!task) {
+            return (0, ui_1.handleError)(new Error(`No pending task with id "${taskId}".\n` +
+                '  Ids look like <agentId>:<date>:<n> — find one with: cku kpi tasks --limit 50'));
+        }
+        if (task.columnId === target) {
+            return (0, ui_1.handleError)(new Error(`${taskId} is already in ${columnLabel(target)}; nothing to do.`));
+        }
+        const moved = await api.movePendingTask(taskId, target);
+        const after = moved?.task?.columnId || target;
+        if (opts.json)
+            return void console.log(JSON.stringify(moved?.task || { taskId, columnId: after }, null, 2));
+        (0, ui_1.success)(`Moved ${taskId}: ${columnLabel(task.columnId)} → ${columnLabel(after)}`);
+        if (target === 'rejected') {
+            (0, ui_1.info)(`  The card is retained, not deleted — move it back with: cku kpi move "${taskId}" action_items`);
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi set <taskId> --description <text>` — the one editable field. */
+async function kpiSetCommand(taskId, opts) {
+    try {
+        const description = String(opts.description ?? '').trim();
+        if (!description) {
+            return (0, ui_1.handleError)(new Error('--description <text> is required.\n' +
+                '  description is the only field the board lets you edit. cause, --fix and\n' +
+                '  --severity are set at create and cannot be changed afterwards — to correct\n' +
+                '  one, create a replacement and move the original to rejected:\n' +
+                '    cku kpi create --cause "…" --fix "…" --severity "…"\n' +
+                `    cku kpi move "${taskId}" rejected`));
+        }
+        const res = await (0, dashboardApi_1.dashboardApi)().updatePendingTask(taskId, { description });
+        const task = res?.task;
+        if (opts.json)
+            return void console.log(JSON.stringify(task || { taskId, description }, null, 2));
+        (0, ui_1.success)(`Updated the description on ${taskId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi comment <taskId> <text>` — append a comment. */
+async function kpiCommentCommand(taskId, text, opts = {}) {
+    try {
+        const body = String(text || '').trim();
+        if (!body) {
+            return (0, ui_1.handleError)(new Error('Comment text is required, e.g. cku kpi comment "t1:2026-09-30:1" "fixed in v3"'));
+        }
+        const res = await (0, dashboardApi_1.dashboardApi)().commentOnPendingTask(taskId, body);
+        const task = res?.task;
+        if (opts.json)
+            return void console.log(JSON.stringify(task || { taskId, text: body }, null, 2));
+        const total = Array.isArray(task?.comments) ? task.comments.length : undefined;
+        (0, ui_1.success)(`Comment added to ${taskId}.`);
+        if (total)
+            (0, ui_1.info)(`  ${total} comment(s) on the card now.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * `cku kpi assign <taskId> --to <who>` — hand a card to a person, or to AI FDE.
+ *
+ * AI FDE is a different animal: the server queues the change behind whatever
+ * that version is already doing, so a queued result is a success, not a failure.
+ */
+async function kpiAssignCommand(taskId, opts) {
+    try {
+        let to = String(opts.to || '').trim();
+        if (!to) {
+            return (0, ui_1.handleError)(new Error('--to <who> is required.\n' +
+                '  Use a team member, or "ai_fde" to hand it to AI FDE.\n' +
+                '  List people with: cku kpi assignees'));
+        }
+        const api = (0, dashboardApi_1.dashboardApi)();
+        const isFde = to.toLowerCase() === 'ai_fde';
+        const agentId = String(opts.agent || '').trim();
+        const versionIds = splitList(opts.versions);
+        if (isFde) {
+            // The server rejects an AI FDE assignment with no target versions, so
+            // fail here where the fix is legible rather than as a 400.
+            if (!agentId) {
+                return (0, ui_1.handleError)(new Error('Assigning to ai_fde needs --agent <id> — which agent should change.\n' +
+                    '  List them with: cku kpi agents'));
+            }
+            if (!versionIds.length) {
+                return (0, ui_1.handleError)(new Error('Assigning to ai_fde needs --versions <id,id,...> — which versions to change.\n' +
+                    '  Leaving it out would ask AI FDE to act on nothing.'));
+            }
+        }
+        // Resolve the label server-side style: the payload carries both id and
+        // label, and team members are the only source of a readable name.
+        let label = to;
+        if (!isFde) {
+            let members = [];
+            try {
+                const team = await api.teamMembers();
+                members = Array.isArray(team?.teamMembers) ? team.teamMembers : Array.isArray(team) ? team : [];
+            }
+            catch {
+                // Not being able to read the roster should not block the write; the id
+                // is what the server keys on, and the label is only for display.
+            }
+            const hit = members.find((m) => String(m._id || m.id) === to || String(m.name || '').toLowerCase() === to.toLowerCase());
+            if (members.length && !hit) {
+                return (0, ui_1.handleError)(new Error(`No team member matching "${to}".\n` +
+                    `  Known: ${members.map((m) => m.name).filter(Boolean).join(', ') || '(none)'}\n` +
+                    '  Or hand it to AI FDE with --to ai_fde'));
+            }
+            if (hit) {
+                label = hit.name;
+                to = String(hit._id || hit.id);
+            }
+        }
+        else {
+            label = 'AI FDE';
+        }
+        const res = await api.savePendingAssignments([
+            {
+                taskId,
+                assignTo: to,
+                assignToLabel: label,
+                versionIds,
+                versionNames: splitList(opts.versionNames),
+                agentId: isFde ? agentId : String(opts.agent || ''),
+                abSplit: Boolean(opts.abSplit),
+                applyToPublished: Boolean(opts.applyToPublished),
+            },
+        ]);
+        const result = Array.isArray(res?.results) ? res.results[0] : undefined;
+        if (result && result.success === false) {
+            return (0, ui_1.handleError)(new Error(result.error || 'The server refused the assignment.'));
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        (0, ui_1.success)(`${taskId} assigned to ${label}.`);
+        if (result?.queued) {
+            (0, ui_1.info)('  Queued: AI FDE is already working this version, so the change starts when that finishes.');
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi assignees` — the people a card can be handed to. */
+async function kpiAssigneesCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().teamMembers();
+        const members = Array.isArray(res?.teamMembers) ? res.teamMembers
+            : Array.isArray(res) ? res : [];
+        if (opts.json)
+            return void console.log(JSON.stringify(members, null, 2));
+        if (!members.length)
+            return void (0, ui_1.info)('No team members returned.');
+        (0, ui_1.table)(['ID', 'NAME', 'EMAIL'], members.map((m) => [m._id || m.id || '', m.name || '', m.email || '']));
+        (0, ui_1.info)('\nAssign: cku kpi assign "<taskId>" --to <id or name>   (or --to ai_fde)');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * `cku kpi target --agent <id> --value <n>` — set the KPI Manager target.
+ *
+ * The server replaces the whole `kpi_metrics` array and the RCA config together,
+ * so the current values are read first and sent back. Omitting them would clear
+ * a configured RCA prompt on an account that has one.
+ */
+async function kpiTargetCommand(opts) {
+    try {
+        const agentId = String(opts.agent || '').trim();
+        if (!agentId) {
+            return (0, ui_1.handleError)(new Error('--agent <id> is required. List them with: cku kpi agents'));
+        }
+        if (opts.value === undefined || String(opts.value).trim() === '') {
+            return (0, ui_1.handleError)(new Error('--value <n> is required — the target percentage.\n' +
+                '  See the current one with: cku kpi target --agent ' + agentId + ' --show'));
+        }
+        const api = (0, dashboardApi_1.dashboardApi)();
+        let current = {};
+        try {
+            current = (await api.kpiAgentConfig(agentId)) || {};
+        }
+        catch {
+            // No config yet is a normal state, not a failure: the PUT creates it.
+            current = {};
+        }
+        const metricName = 'connected_to_conversion_percentage';
+        const body = {
+            kpi_metrics: [{ name: metricName, source: metricName, value: String(opts.value).trim() }],
+        };
+        // Only send the RCA fields when the user names them, or when the account
+        // already has them and would otherwise be wiped.
+        const rcaModel = opts.rcaModel ?? current.rca_model;
+        const rcaPrompt = opts.rcaPrompt ?? current.rca_prompt;
+        if (rcaModel)
+            body.rca_model = String(rcaModel);
+        if (rcaPrompt !== undefined)
+            body.rca_prompt = String(rcaPrompt);
+        const res = await api.setKpiAgentConfig(agentId, body);
+        if (opts.json)
+            return void console.log(JSON.stringify(res ?? body, null, 2));
+        (0, ui_1.success)(`KPI Manager target for ${agentId} set to ${String(opts.value).trim()}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku kpi rca --agent <id> --since <date> --until <date>` — start an RCA run. */
+async function kpiRcaCommand(opts) {
+    try {
+        const agentId = String(opts.agent || '').trim();
+        if (!agentId) {
+            return (0, ui_1.handleError)(new Error('--agent <id> is required. List them with: cku kpi agents'));
+        }
+        if (agentId.includes(',')) {
+            return (0, ui_1.handleError)(new Error('RCA runs against one agent at a time; --agent took more than one id.\n' +
+                '  Run it once per agent.'));
+        }
+        if (!opts.since || !opts.until) {
+            return (0, ui_1.handleError)(new Error('--since <date> and --until <date> are both required — RCA is scoped to a range.\n' +
+                '  e.g. --since 2026-09-01 --until 2026-09-30   (also 7d / 30d / today / thisweek)'));
+        }
+        let filters;
+        try {
+            filters = {
+                agent_id: agentId,
+                start_date: dateBound(String(opts.since), false),
+                end_date: dateBound(String(opts.until), true),
+            };
+        }
+        catch (err) {
+            return (0, ui_1.handleError)(err);
+        }
+        const res = await (0, dashboardApi_1.dashboardApi)().runKpiRca(agentId, filters);
+        if (opts.json)
+            return void console.log(JSON.stringify(res ?? {}, null, 2));
+        (0, ui_1.success)('RCA started.');
+        (0, ui_1.info)('  Results appear under RCA History on the dashboard, and as new cards on the board.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** A human label for a column id, falling back to the id itself. */
+function columnLabel(id) {
+    const hit = COLUMNS.find((c) => c.id === id);
+    return hit ? hit.label : String(id ?? '?');
+}
+/** `--impact` as a number, or undefined. A bad value is an error, not a NaN. */
+function numeric(raw, flag) {
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`${flag} must be a number (got "${raw}").`);
+    }
+    return n;
+}
+/** `--calls a,b` / `--versions a,b` into a clean array. */
+function splitList(raw) {
+    return String(raw || '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}