callkaro-cli-unofficial 0.10.0 → 0.10.1

package/README.md

@@ -19,7 +19,7 @@ cku accounts use tejas@acme.com
 
 **It holds several accounts at once.** The official CLI keeps one session. This one keeps a file per account, and can pin an account to a folder, so two agents working in two directories can't switch each other out from under themselves.
 
-**It reaches the dashboard API.** The official CLI only talks to `/cli/*`. That leaves the KPI board, the call analyzers, and the server's own model catalogue unreachable from a terminal — [`cku kpi`](#only-in-cku) is the whole of that surface.
+**It reaches the dashboard API.** The official CLI only talks to `/cli/*`. That leaves the KPI board and the call analyzers unreachable from a terminal — [`cku kpi`](#only-in-cku) is the whole of that surface.
 
 **It fixes three upstream bugs.** Details and evidence in [`docs/BUG-REPORT.md`](docs/BUG-REPORT.md).
 
@@ -69,7 +69,7 @@ Every arrow above is a real import or a real call, checked against the source. `
 │               sim, analytics, audits, skills       │
 │     ↓                                             │
 │  lib/         api.ts, config.ts, agentUpdate.ts,   │
-│               looseJson.ts, ui.ts, catalog.ts     │
+│               looseJson.ts, ui.ts, liveTest.ts    │
 └──────┬────────────────────────────────────────────┘
        ↓
   account resolution, highest precedence first
@@ -164,7 +164,7 @@ cku dashboard whoami
 cku dashboard probe     # which dashboard routes this token reaches
 ```
 
-The dashboard API needs a *different* token from `/cli/*` — they're not interchangeable, and each rejects the other with an opaque 401. This also unlocks `cku analyzers` and `cku models`. The dashboard token expires every 24h with no refresh endpoint, so `cku dashboard login` saves your password (plain text, mode 0600, alongside the tokens) and re-logs in for you when it lapses. Pass `--no-save-password` to keep it off disk and re-enter it daily; `cku dashboard logout` deletes it.
+The dashboard API needs a *different* token from `/cli/*` — they're not interchangeable, and each rejects the other with an opaque 401. This also unlocks `cku analyzers`. The dashboard token expires every 24h with no refresh endpoint, so `cku dashboard login` saves your password (plain text, mode 0600, alongside the tokens) and re-logs in for you when it lapses. Pass `--no-save-password` to keep it off disk and re-enter it daily; `cku dashboard logout` deletes it.
 
 ### The admin console credential
 
@@ -187,18 +187,7 @@ cku models               # per slot, and which field each governs
 cku models --slot agent
 ```
 
-Models are scoped per slot and **the slots disagree**: `agent` has 44, `post-call` has 9 and excludes `gpt-4o` and `o4-mini`. So the same value is valid in `model` and refused in `postcallmodel`. Works with or without a dashboard session, and says which source it read.
-
-### A catalogue that can't silently rot
-
-The provider tables, and now the model lists, are regenerated from the server rather than hand-copied:
-
-```bash
-npm run catalog:sync     # refresh from the bundle + the live server
-npm run catalog:check    # fail if catalog.json disagrees with the snapshot
-```
-
-`catalog:check` runs offline against a committed snapshot, so it works in CI with no credentials. On 1 October 2026 it caught shipped tables that listed withdrawn models *and* missed live ones in both directions. A wrong voice model otherwise persists silently and only surfaces as a broken call.
+Models are scoped per slot and per account, and **the slots disagree**: `post-call` is narrower than `agent`, so the same value is valid in `model` and refused in `postcallmodel`. `cku models` and `cku transcribers` read the account's live lists (`/cli/llms`, `/cli/transcribers`, official 5.4.8), the same ones `agents update` checks before saving. There is no bundled list to go stale.
 
 ### Live test calls, with you or an LLM as the caller
 
@@ -230,7 +219,7 @@ This is the agent editor's **Test Chat** tab from a terminal: a real test call o
 
 ## Staying current
 
-A daily workflow checks npm for a newer `@callkaro-official/cli` and, when it finds one, regenerates the provider catalogue and opens a PR onto the `official` branch. It never merges anything itself.
+A daily workflow checks npm for a newer `@callkaro-official/cli` and, when it finds one, opens a PR onto the `official` branch with the new pin and a report of which commands changed. It never merges anything itself.
 
 | Branch | What's on it |
 |---|---|
@@ -239,7 +228,7 @@ A daily workflow checks npm for a newer `@callkaro-official/cli` and, when it fi
 
 To take an update: review the PR, merge into `official`, then merge `official` into `main`.
 
-Worth knowing what the sync does and doesn't do. It regenerates `src/data/catalog.json` — the provider tables and the per-slot LLM model lists — because those change when the dashboard changes. It does **not** port command code, because the official source isn't available, so that's maintained by hand. The PR lists which commands were added or removed so you know what to look at.
+Worth knowing what the sync does and doesn't do. It does **not** port command code, because the official source isn't available, so that's maintained by hand. The PR lists which commands were added or removed so you know what to look at.
 
 Keep your customizations in as few files as you can. That diff is the one you have to resolve on every update.
 
@@ -252,9 +241,6 @@ npm run build          # tsc -> dist/, copy endpoints.json, chmod +x
 npm test               # build, then node --test
 npm run test:only      # tests without rebuilding
 npm run dev            # build and run
-npm run catalog:sync   # regenerate the catalogue: provider tables + per-slot LLM lists, from the server
-npm run catalog:check  # fail if catalog.json disagrees with the server snapshot (offline)
-npm run catalog:check:live  # same, against the live server (needs `cku dashboard login`)
 ```
 
 Single test file:

package/dist/commands/agentCommits.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsCommitsCommand = agentsCommitsCommand;
+exports.agentsCommitCommand = agentsCommitCommand;
+exports.agentsRevertCommand = agentsRevertCommand;
+exports.agentsCompareCommand = agentsCompareCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const versions_1 = require("../lib/versions");
+/** `cku agents commits <agentId> [--versions id] [--page n]` */
+async function agentsCommitsCommand(agentId, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().listAgentCommits(agentId, {
+            version: opts.versions ? (0, versions_1.firstVersion)(opts.versions) : undefined,
+            page: opts.page ? Number(opts.page) : undefined,
+        });
+        // Each commit carries the version's whole saved state, so even one page is large: the
+        // table shows the summary and --json/--file have everything.
+        if ((0, ui_1.output)(res, opts, `commits for ${agentId}`))
+            return;
+        if (!res.commits?.length)
+            return void (0, ui_1.info)('No commits found.');
+        (0, ui_1.table)(['COMMIT ID', 'VERSION', 'MESSAGE', 'BY', 'WHEN'], res.commits.map((c) => [
+            c._id, c.versionName || '', c.commitMessage || '', c.commited_by?.name || '',
+            String(c.createdAt || '').slice(0, 19).replace('T', ' '),
+        ]));
+        const { page, totalPages, totalDocs } = res.pagination || {};
+        (0, ui_1.info)(`page ${page ?? 1} of ${totalPages || 1} (${totalDocs ?? res.commits.length} commits)`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku agents commit <commitId>` */
+async function agentsCommitCommand(commitId, opts) {
+    try {
+        const { commit: c } = await (0, session_1.requireApi)().getAgentCommit(commitId);
+        if ((0, ui_1.output)({ commit: c }, opts, `commit ${commitId}`))
+            return;
+        (0, ui_1.keyValue)({ id: c._id, version: c.versionName, versionId: c.versionId, message: c.commitMessage, by: c.commited_by?.name, at: c.createdAt });
+        (0, ui_1.info)('Use --json to see the full saved state.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku agents revert <agentId> <commitId> [--yes]` */
+async function agentsRevertCommand(agentId, commitId, opts) {
+    try {
+        const api = (0, session_1.requireApi)();
+        if (!opts.yes) {
+            (0, ui_1.needTty)('Re-run with --yes to confirm.'); // before the lookup, so a refused revert sends nothing
+            // Name what is being restored: revert overwrites the version's current settings.
+            const { commit: c } = await api.getAgentCommit(commitId);
+            const what = `version "${c.versionName || c.versionId}" to commit ${commitId}${c.commitMessage ? ` ("${c.commitMessage}")` : ''}`;
+            if (!(await (0, ui_1.confirm)(`Revert ${what}? Its current settings are overwritten (a new commit is recorded).`)))
+                return;
+        }
+        const res = await api.revertAgentCommit(agentId, commitId);
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        (0, ui_1.success)(res.msg || 'Reverted.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+const lines = (s) => (s ? s.split('\n').length : 0);
+/** `cku agents compare <agentId> --a <id> --b <id> [--commits] [--field name]` — versions by default. */
+async function agentsCompareCommand(agentId, opts) {
+    try {
+        if (!opts.a || !opts.b)
+            return (0, ui_1.handleError)(new Error('--a <id> and --b <id> are required (version ids, or commit ids with --commits)'));
+        const api = (0, session_1.requireApi)();
+        const res = opts.commits
+            ? await api.compareAgentCommits(agentId, opts.a, opts.b)
+            : await api.compareAgentVersions(agentId, [opts.a, opts.b]);
+        if ((0, ui_1.output)(res, opts, 'comparison'))
+            return;
+        const label = (s) => `${s.versionName || s.id} (${s.id})`;
+        (0, ui_1.info)(`A: ${label(res.left)}\nB: ${label(res.right)}\n`);
+        if (!res.changedFields.length)
+            return void console.log('No differences.');
+        if (opts.field) {
+            if (!res.changedFields.includes(opts.field)) {
+                return (0, ui_1.handleError)(new Error(`"${opts.field}" did not change. Changed: ${res.changedFields.join(', ')}`));
+            }
+            const t = res.textFieldDiffs[opts.field];
+            const a = t ? t.left : JSON.stringify(res.filteredA[opts.field], null, 2);
+            const b = t ? t.right : JSON.stringify(res.filteredB[opts.field], null, 2);
+            return void console.log(`--- A\n${a}\n\n--- B\n${b}`);
+        }
+        (0, ui_1.table)(['FIELD', 'CHANGE'], res.changedFields.map((f) => {
+            const t = res.textFieldDiffs[f];
+            return [f, t ? `text: ${lines(t.left)} → ${lines(t.right)} lines` : 'value changed'];
+        }));
+        (0, ui_1.info)(`\n${res.changedFields.length} field(s) differ. Use --field <name> to see one side by side, or --json for everything.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/agentVersions.js

@@ -5,10 +5,6 @@ exports.agentsPublishCommand = agentsPublishCommand;
 exports.agentsToggleActiveCommand = agentsToggleActiveCommand;
 exports.agentsAbCommand = agentsAbCommand;
 exports.agentsAbAdvancedCommand = agentsAbAdvancedCommand;
-exports.agentsCommitsCommand = agentsCommitsCommand;
-exports.agentsCommitShowCommand = agentsCommitShowCommand;
-exports.agentsDiffCommand = agentsDiffCommand;
-exports.agentsRevertCommand = agentsRevertCommand;
 exports.agentsSaveV2Command = agentsSaveV2Command;
 exports.agentsDeleteVersionCommand = agentsDeleteVersionCommand;
 exports.agentsDuplicateCommand = agentsDuplicateCommand;
@@ -20,6 +16,7 @@ const ui_1 = require("../lib/ui");
 const versions_1 = require("../lib/versions");
 const agentUpdate_1 = require("../lib/agentUpdate");
 const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
+const liveCatalogCheck_1 = require("../lib/liveCatalogCheck");
 const setJson_1 = require("./setJson");
 /** Keys a clone may override. Anything else is rejected before the request. */
 const CLONE_OVERRIDE_KEYS = new Set([
@@ -61,7 +58,8 @@ async function agentsCloneVersionCommand(agentId, opts) {
             if (unsupported.length) {
                 return (0, ui_1.handleError)(new Error(`Unsupported clone override(s): ${unsupported.join(', ')}\n  allowed: ${[...CLONE_OVERRIDE_KEYS].join(', ')}`));
             }
-            overrides = (0, agentUpdate_1.preparePatch)(parsed, { skipVoices: true }).patch;
+            overrides = (0, agentUpdate_1.preparePatch)(parsed).patch;
+            await (0, liveCatalogCheck_1.checkLiveCatalog)(api, overrides, async () => (await api.getAgent(agentId, sourceVersionId)).agent);
             await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, { voice_configuration: overrides.voice_configuration, secondary_voice_configuration: overrides.secondary_voice_configuration }, sourceVersionId ? async () => (0, liveVoiceCheck_1.savedVoices)((await api.getAgent(agentId, sourceVersionId)).agent) : undefined);
         }
         const res = await api.cloneAgentVersion(agentId, sourceVersionId, {
@@ -238,103 +236,6 @@ async function agentsAbAdvancedCommand(agentId, opts) {
         (0, ui_1.handleError)(err);
     }
 }
-/** `cku agents commits <agentId>` */
-async function agentsCommitsCommand(agentId, opts) {
-    try {
-        const res = await (0, dashboardApi_1.dashboardApi)().agentCommits(agentId, {
-            version: opts.versions ? (0, versions_1.firstVersion)(opts.versions) : undefined,
-            page: Number(opts.page) || 1,
-            pageSize: Number(opts.limit) || 25,
-        });
-        if (opts.json)
-            return void console.log(JSON.stringify(res?.commits || res, null, 2));
-        const rows = res?.commits || [];
-        if (!rows.length)
-            return void (0, ui_1.info)('No commits.');
-        (0, ui_1.table)(['COMMIT ID', 'VERSION', 'MESSAGE', 'AUTHOR', 'CREATED'], rows.map((c) => [
-            c._id,
-            c.versionId,
-            c.commitMessage || c.message || '',
-            c.author?.name || c.author?.email || c.user?.email || '',
-            c.createdAt,
-        ]));
-    }
-    catch (err) {
-        (0, ui_1.handleError)(err);
-    }
-}
-/** `cku agents commit-show <commitId>` */
-async function agentsCommitShowCommand(commitId, opts) {
-    try {
-        const res = await (0, dashboardApi_1.dashboardApi)().agentCommit(commitId);
-        const c = res?.commit || res;
-        if (opts.json)
-            return void console.log(JSON.stringify(c, null, 2));
-        (0, ui_1.keyValue)({
-            id: c?._id,
-            versionId: c?.versionId,
-            commitMessage: c?.commitMessage,
-            createdAt: c?.createdAt,
-            model: c?.model,
-            voice_provider: c?.voice_provider,
-            functions: (c?.functions || []).length,
-        });
-    }
-    catch (err) {
-        (0, ui_1.handleError)(err);
-    }
-}
-/** `cku agents diff <agentId> --commits a,b | --versions a,b` */
-async function agentsDiffCommand(agentId, opts) {
-    const usage = 'Pass --commits <idA,idB> or --versions <vA,vB> (two comma-separated ids).';
-    const commits = opts.commits ? (0, versions_1.versionList)(opts.commits) : [];
-    const versions = opts.versions ? (0, versions_1.versionList)(opts.versions) : [];
-    const ids = commits.length ? commits : versions;
-    if (ids.length < 2)
-        return (0, ui_1.handleError)(new Error(usage));
-    try {
-        const api = (0, dashboardApi_1.dashboardApi)();
-        const res = commits.length
-            ? await api.compareAgentCommits(agentId, ids[0], ids[1])
-            : await api.compareAgentVersions([ids[0], ids[1]]);
-        if (opts.json)
-            return void console.log(JSON.stringify(res, null, 2));
-        const diff = res?.diff ?? res?.changes ?? res;
-        if (Array.isArray(diff)) {
-            if (!diff.length)
-                return void (0, ui_1.info)('No differences.');
-            (0, ui_1.table)(['FIELD', 'A', 'B'], diff.map((d) => [d.field || d.key || d.path || '', clipVal(d.a ?? d.before ?? d.from), clipVal(d.b ?? d.after ?? d.to)]));
-            return;
-        }
-        const keys = diff && typeof diff === 'object' ? Object.keys(diff) : [];
-        if (!keys.length)
-            return void (0, ui_1.info)('No differences.');
-        (0, ui_1.info)(`Changed keys (${keys.length}):`);
-        keys.forEach((k) => (0, ui_1.info)(`  ${k}`));
-        (0, ui_1.info)('Full detail: add --json');
-    }
-    catch (err) {
-        (0, ui_1.handleError)(err);
-    }
-}
-function clipVal(v) {
-    const t = v === undefined || v === null ? '' : typeof v === 'string' ? v : JSON.stringify(v);
-    return t.length > 60 ? `${t.slice(0, 59)}…` : t;
-}
-/** `cku agents revert <agentId> <commitId>` */
-async function agentsRevertCommand(agentId, commitId, opts) {
-    try {
-        if (!(await (0, ui_1.confirm)(`Revert agent ${agentId} to commit ${commitId}?`, opts.yes)))
-            return;
-        const res = await (0, dashboardApi_1.dashboardApi)().revertAgentCommit(agentId, commitId);
-        if (opts.json)
-            return void console.log(JSON.stringify(res, null, 2));
-        (0, ui_1.success)(`Reverted ${agentId} to commit ${commitId}.`);
-    }
-    catch (err) {
-        (0, ui_1.handleError)(err);
-    }
-}
 /** `cku agents save-v2 <agentId> --set <json>` */
 async function agentsSaveV2Command(agentId, opts) {
     try {

package/dist/commands/agents.js

@@ -54,7 +54,7 @@ const versions_1 = require("../lib/versions");
 const agentUpdate_1 = require("../lib/agentUpdate");
 Object.defineProperty(exports, "preparePatch", { enumerable: true, get: function () { return agentUpdate_1.preparePatch; } });
 const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
-const dashboardAuth_1 = require("../lib/dashboardAuth");
+const liveCatalogCheck_1 = require("../lib/liveCatalogCheck");
 const agentImport_1 = require("../lib/agentImport");
 const dbFields_1 = require("../lib/dbFields");
 const jsonInput_1 = require("./jsonInput");
@@ -395,13 +395,10 @@ async function agentsUpdateCommand(agentId, opts) {
     let versionKeys;
     let wholesaleKeys;
     try {
-        // Validate model fields against the server's own per-slot list when we can.
-        // Best-effort: without a dashboard session the built-in list still applies.
-        await (0, dashboardAuth_1.refreshModelCatalog)();
         const dbf = (0, dbFields_1.dbManagedFields)(obj);
         if (dbf.length)
             throw new Error((0, dbFields_1.dbManagedFieldsError)(dbf, '--set object'));
-        const prepared = (0, agentUpdate_1.preparePatch)(obj, { skipVoices: true });
+        const prepared = (0, agentUpdate_1.preparePatch)(obj);
         patch = prepared.patch;
         versionKeys = prepared.versionKeys;
         wholesaleKeys = prepared.wholesaleKeys;
@@ -423,6 +420,7 @@ async function agentsUpdateCommand(agentId, opts) {
     }
     try {
         const vid = (0, versions_1.firstVersion)(opts.versions);
+        await (0, liveCatalogCheck_1.checkLiveCatalog)(api, patch, vid ? async () => (await api.getAgent(agentId, vid)).agent : undefined);
         await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, { voice_configuration: patch.voice_configuration, secondary_voice_configuration: patch.secondary_voice_configuration }, vid ? async () => (0, liveVoiceCheck_1.savedVoices)((await api.getAgent(agentId, vid)).agent) : undefined);
         let versionTarget = vid;
         if (opts.commit && !versionTarget)

package/dist/commands/auditReports.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditBatchesCommand = auditBatchesCommand;
+exports.auditStrategyReportsCommand = auditStrategyReportsCommand;
+exports.auditReportCommand = auditReportCommand;
+exports.auditSummaryCommand = auditSummaryCommand;
+exports.auditCallsCommand = auditCallsCommand;
+exports.auditCallCommand = auditCallCommand;
+exports.chatAuditList = chatAuditList;
+exports.chatAuditReportCommand = chatAuditReportCommand;
+exports.chatAuditAuditsCommand = chatAuditAuditsCommand;
+exports.chatAuditOneCommand = chatAuditOneCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const cell = (v, max = 60) => {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'number' && !Number.isInteger(v))
+        return String(Number(v.toFixed(4))); // 1.9724110000000001 -> 1.9724
+    return (typeof v === 'object' ? JSON.stringify(v) : String(v)).replace(/\s+/g, ' ').slice(0, max);
+};
+const day = (v) => (v ? String(v).slice(0, 16).replace('T', ' ') : '');
+const humanize = (k) => k.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ').toUpperCase();
+const pct = (v) => (v === null || v === undefined || v === '' ? '-' : `${v}`);
+/** Voice report lists page with {page,pageSize,hasNext}; summary lists with {page,page_size,has_next}. */
+function pagingHint(p) {
+    if (!p)
+        return '';
+    const next = p.hasNext ?? p.has_next;
+    return `Page ${p.page ?? 1}${next ? '  (more: use --page)' : ''}`;
+}
+/** Table over whichever of `preferred` keys the rows actually have (rows come from several controllers). */
+function rowsTable(rows, preferred, fallbackCount = 5) {
+    const keys = preferred.filter((k) => rows.some((r) => r[k] !== undefined));
+    const cols = keys.length ? keys : Object.keys(rows[0]).filter((k) => typeof rows[0][k] !== 'object').slice(0, fallbackCount);
+    (0, ui_1.table)(cols.map(humanize), rows.map((r) => cols.map((c) => cell(/time|At$|date/i.test(c) ? day(r[c]) : r[c]))));
+}
+/** Scalar fields in full (summaries are the point of a detail view), then every non-empty issue list. */
+function printAuditDetail(d) {
+    const scalars = Object.entries(d).filter(([, v]) => v === null || typeof v !== 'object');
+    (0, ui_1.keyValue)(Object.fromEntries(scalars.map(([k, v]) => [k, cell(v, 600)])));
+    for (const [k, v] of Object.entries(d)) {
+        if (!Array.isArray(v) || !v.length || !/issues$|errors$/.test(k))
+            continue;
+        console.log(`\n${k.replace(/_/g, ' ')} (${v.length})`);
+        v.forEach((it, i) => {
+            if (!it || typeof it !== 'object')
+                return void console.log(`  ${i + 1}. ${cell(it, 300)}`);
+            console.log(`  ${i + 1}. ${it.severity ? `[${it.severity}] ` : ''}${cell(it.problem ?? it.message ?? it.error ?? JSON.stringify(it), 400)}`);
+            for (const f of ['proof', 'expected', 'actual'])
+                if (it[f])
+                    console.log(`       ${f}: ${cell(it[f], 300)}`);
+        });
+    }
+}
+const scopeOf = (id, byStrategy) => (byStrategy ? `strategies/${id}` : `batches/${id}`);
+const dates = (o) => ({ startDate: o.from, endDate: o.to });
+// ───────── voice ─────────
+/** `cku audit batches [--agent id] [--from d --to d]` */
+async function auditBatchesCommand(opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData('audit-reports/batches', { agentId: opts.agent, ...dates(opts), page: opts.page, pageSize: opts.pageSize });
+        if ((0, ui_1.output)(res, opts, 'audit batches'))
+            return;
+        if (!res.data?.length)
+            return void console.log('No audit batches found.');
+        rowsTable(res.data, ['id', 'strategyName', 'agentName', 'status', 'totalCalls', 'avgOverallScore', 'lastAuditTime']);
+        (0, ui_1.info)(pagingHint(res.pagination));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku audit strategy-reports [--agent id] [--from d --to d]` */
+async function auditStrategyReportsCommand(opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData('audit-reports/strategies', { agentId: opts.agent, ...dates(opts), page: opts.page, pageSize: opts.pageSize });
+        if ((0, ui_1.output)(res, opts, 'strategy reports'))
+            return;
+        if (!res.data?.length)
+            return void console.log('No audit reports found.');
+        rowsTable(res.data, ['id', 'strategyName', 'agentName', 'batchCount', 'auditedCalls', 'failedCalls', 'avgOverallScore', 'lastAuditTime']);
+        (0, ui_1.info)(pagingHint(res.pagination));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku audit report <id> [--by-strategy]` */
+async function auditReportCommand(id, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`audit-reports/${scopeOf(id, opts.byStrategy)}`, {
+            ...(opts.byStrategy ? dates(opts) : {}), page: opts.page, pageSize: opts.pageSize,
+        });
+        if ((0, ui_1.output)(res, opts, 'audit report'))
+            return;
+        const head = res.batch || res.strategy || {}; // batch scope returns `batch`, strategy scope `strategy`
+        (0, ui_1.keyValue)({
+            id: head.id, strategy: head.strategyName || head.name, agent: head.agentName, status: head.status, batches: head.batchCount,
+            created: day(head.createdAt) || undefined, completed: day(head.completedAt) || undefined,
+        });
+        const tiles = Array.isArray(res.data) ? res.data : [];
+        if (tiles.length) {
+            console.log();
+            (0, ui_1.keyValue)(Object.fromEntries(tiles.map((t) => [t.name, pct(t.value)])));
+        }
+        if (res.calls?.length) {
+            console.log();
+            rowsTable(res.calls, ['call_id', 'callId', 'id', '_id', 'status', 'overall_score', 'overallScore', 'audit_timestamp', 'auditTimestamp']);
+            (0, ui_1.info)(`${res.pagination?.totalDocs ?? res.calls.length} call(s). ${pagingHint(res.pagination)}`);
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku audit summary <id> [--by-strategy] [--severity s] [--dimension d]` */
+async function auditSummaryCommand(id, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`audit-summary/${scopeOf(id, opts.byStrategy)}/summary`, {
+            ...(opts.byStrategy ? dates(opts) : {}), severity: opts.severity, dimension: opts.dimension,
+        });
+        if ((0, ui_1.output)(res, opts, 'audit summary'))
+            return;
+        const k = res.kpis || {};
+        (0, ui_1.keyValue)({
+            calls: k.total_calls, 'avg score': k.avg_score, 'failed audits': k.failed_audits, 'total issues': k.total_issues,
+            cost: k.total_cost, started: day(k.started_at), finished: day(k.finished_at),
+        });
+        if (res.scores_by_dimension) {
+            console.log('\nScores by dimension');
+            (0, ui_1.keyValue)(Object.fromEntries(Object.entries(res.scores_by_dimension).map(([a, b]) => [a, cell(b)])));
+        }
+        if (res.issues_by_severity?.length) {
+            console.log('\nIssues by severity');
+            rowsTable(res.issues_by_severity, ['severity', 'occurrences']);
+        }
+        if (res.categories?.length) {
+            console.log('\nCategories');
+            rowsTable(res.categories, ['dimension', 'category', 'occurrences', 'calls_affected', 'critical', 'high', 'medium', 'low']);
+        }
+        if (res.top_issue_calls?.length) {
+            console.log('\nTop issue calls');
+            rowsTable(res.top_issue_calls, ['call_id', 'score', 'dimension', 'category', 'problem', 'critical', 'high']);
+        }
+        (0, ui_1.info)('\nDrill in with `cku audit calls <id> --severity|--below-80|--category|--var`, or `cku audit call <id> <callId>`.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku audit calls <id> (--severity s | --below-80 | --category dimension:category | --var name=value)` */
+async function auditCallsCommand(id, opts) {
+    try {
+        const chosen = [opts.severity, opts.below80, opts.category, opts.var].filter(Boolean).length;
+        if (chosen !== 1) {
+            return (0, ui_1.handleError)(new Error('Pick exactly one filter: --severity <s> | --below-80 | --category <dimension:category> | --var <name=value>'));
+        }
+        const base = `audit-summary/${scopeOf(id, opts.byStrategy)}`;
+        let path;
+        if (opts.severity)
+            path = `${base}/severities/${encodeURIComponent(opts.severity.toLowerCase())}/calls`;
+        else if (opts.below80)
+            path = `${base}/scores/below-80/calls`;
+        else if (opts.category) {
+            const [dimension, ...rest] = opts.category.split(':');
+            if (!dimension || !rest.length)
+                return (0, ui_1.handleError)(new Error('--category must be <dimension:category>, as listed by `cku audit summary`'));
+            path = `${base}/categories/${encodeURIComponent(dimension)}/${encodeURIComponent(rest.join(':'))}/calls`;
+        }
+        else {
+            const eq = opts.var.indexOf('=');
+            if (eq < 1)
+                return (0, ui_1.handleError)(new Error('--var must be <name=value>'));
+            path = `${base}/extra-variables/${encodeURIComponent(opts.var.slice(0, eq))}/${encodeURIComponent(opts.var.slice(eq + 1))}/calls`;
+        }
+        const res = await (0, session_1.requireApi)().getAuditData(path, {
+            ...(opts.byStrategy ? dates(opts) : {}), page: opts.page, page_size: opts.pageSize, sort: opts.sort,
+        });
+        if ((0, ui_1.output)(res, opts, 'audited calls'))
+            return;
+        if (!res.calls?.length)
+            return void console.log('No calls match.');
+        rowsTable(res.calls, ['call_id', 'score', 'status', 'problem', 'occurrences', 'issue_count', 'audit_timestamp']);
+        (0, ui_1.info)(pagingHint(res.pagination));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku audit call <id> <callId> [--by-strategy]` */
+async function auditCallCommand(id, callId, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`audit-summary/${scopeOf(id, opts.byStrategy)}/calls/${encodeURIComponent(callId)}`, opts.byStrategy ? dates(opts) : {});
+        if ((0, ui_1.output)(res, opts, `audited call ${callId}`))
+            return;
+        printAuditDetail(res);
+        (0, ui_1.info)('\n--json has every field.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+// ───────── chat ─────────
+const chatRows = ['id', 'strategyName', 'agentName', 'status', 'trigger', 'totalChats', 'failedChats', 'avgOverallScore', 'totalIssues', 'totalCost', 'lastAuditTime'];
+/** `cku chat-audit batches|strategy-reports [--agent id] [--from d --to d]` */
+function chatAuditList(kind) {
+    return async (opts) => {
+        try {
+            const res = await (0, session_1.requireApi)().getAuditData(`chat-audit-reports/${kind}`, { agentId: opts.agent, ...dates(opts), page: opts.page, pageSize: opts.pageSize });
+            if ((0, ui_1.output)(res, opts, `chat audit ${kind}`))
+                return;
+            if (!res.data?.length)
+                return void console.log('No chat audit reports found.');
+            rowsTable(res.data, chatRows);
+            (0, ui_1.info)(pagingHint(res.pagination));
+        }
+        catch (err) {
+            (0, ui_1.handleError)(err);
+        }
+    };
+}
+/** `cku chat-audit report <id> [--by-strategy]` */
+async function chatAuditReportCommand(id, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`chat-audit-reports/${scopeOf(id, opts.byStrategy)}`, dates(opts));
+        if ((0, ui_1.output)(res, opts, 'chat audit report'))
+            return;
+        const d = res.data || {};
+        (0, ui_1.keyValue)(Object.fromEntries(Object.entries(d).filter(([, v]) => v === null || typeof v !== 'object').map(([k, v]) => [k, cell(v)])));
+        if (d.issuesBySeverity) {
+            console.log('\nIssues by severity');
+            (0, ui_1.keyValue)(Object.fromEntries(Object.entries(d.issuesBySeverity).map(([k, v]) => [k, cell(v)])));
+        }
+        if (Array.isArray(d.issuesByDimension) && d.issuesByDimension.length) {
+            console.log('\nIssues by dimension');
+            rowsTable(d.issuesByDimension, ['dimension', 'occurrences', 'chatsAffected']);
+        }
+        (0, ui_1.info)('\nSee the conversations with `cku chat-audit audits <id>`; use --json for everything.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku chat-audit audits <id> [--by-strategy] [--status s] [--sort s]` */
+async function chatAuditAuditsCommand(id, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`chat-audit-reports/${scopeOf(id, opts.byStrategy)}/audits`, {
+            ...dates(opts), status: opts.status, sort: opts.sort, page: opts.page, pageSize: opts.pageSize,
+        });
+        if ((0, ui_1.output)(res, opts, 'chat audits'))
+            return;
+        if (!res.data?.length)
+            return void console.log('No audits match.');
+        rowsTable(res.data, ['id', 'userPhone', 'status', 'overall', 'chatflow', 'functionCall', 'system', 'issues', 'problem', 'auditTime']);
+        (0, ui_1.info)(pagingHint(res.pagination));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku chat-audit audit <auditId>` */
+async function chatAuditOneCommand(auditId, opts) {
+    try {
+        const res = await (0, session_1.requireApi)().getAuditData(`chat-audit-reports/audits/${encodeURIComponent(auditId)}`);
+        if ((0, ui_1.output)(res, opts, `chat audit ${auditId}`))
+            return;
+        const d = res.data || {};
+        printAuditDetail(d);
+        (0, ui_1.info)(`\n${Array.isArray(d.messages) ? d.messages.length : 0} message(s) in the audited window. --json has the full conversation.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}