callkaro-cli-unofficial 0.9.3 → 0.9.5

package/dist/commands/agentMemory.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsMemoryCommand = agentsMemoryCommand;
+exports.agentsVoiceRotationCommand = agentsVoiceRotationCommand;
+const fs_1 = require("fs");
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const versions_1 = require("../lib/versions");
+const looseJson_1 = require("../lib/looseJson");
+const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
+const agentMemory_1 = require("../lib/agentMemory");
+async function run(agentId, opts, flags, change, describe, what, verify) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const versionId = (0, versions_1.firstVersion)(opts.versions);
+        if (!versionId)
+            throw new Error('--versions <id> is required (find it with `cku agents versions <agentId>`)');
+        const { agent } = await api.getAgent(agentId, versionId);
+        const current = agent.agentMemory;
+        if (!(0, agentMemory_1.hasChanges)(flags)) {
+            if (opts.json)
+                console.log(JSON.stringify(current ?? {}, null, 2));
+            else
+                (0, ui_1.keyValue)(describe(current));
+            return;
+        }
+        const next = change(current);
+        if (verify)
+            await verify(api, next, agent);
+        const body = { agentMemory: next };
+        if (opts.commit)
+            body.commitMessage = opts.commit;
+        const result = await api.updateAgent(agentId, versionId, body);
+        if (opts.json)
+            console.log(JSON.stringify(next, null, 2));
+        else {
+            (0, ui_1.success)(result.msg || `${what} updated.`);
+            (0, ui_1.keyValue)(describe(next));
+            (0, ui_1.info)('  Takes effect on the next call. Publish the version if it is not live yet.');
+        }
+    }
+    catch (error) {
+        (0, ui_1.handleError)(error);
+    }
+}
+function agentsMemoryCommand(agentId, opts) {
+    const { versions, commit, json, ...flags } = opts;
+    return run(agentId, opts, flags, (memory) => (0, agentMemory_1.applyMemoryFlags)(memory, flags), agentMemory_1.describeMemory, 'Call memory');
+}
+function agentsVoiceRotationCommand(agentId, opts) {
+    const { versions, commit, json, voices, ...rest } = opts;
+    const flags = rest;
+    if (voices !== undefined) {
+        const file = String(voices).startsWith('@') ? String(voices).slice(1) : String(voices);
+        if (!(0, fs_1.existsSync)(file)) {
+            (0, ui_1.handleError)(new Error(`File not found: ${file}`));
+            return Promise.resolve();
+        }
+        try {
+            flags.voices = JSON.parse((0, looseJson_1.readJsonFile)(file));
+        }
+        catch (error) {
+            (0, ui_1.handleError)(new Error(`--voices is not valid JSON: ${error.message}`));
+            return Promise.resolve();
+        }
+    }
+    const verify = flags.voices === undefined ? undefined : async (api, memory, version) => {
+        const entries = Object.fromEntries((memory.voice_rotation_config?.voices || []).map((voice, index) => [`voices[${index}]`, voice]));
+        await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, entries, async () => (0, liveVoiceCheck_1.savedVoices)(version));
+    };
+    return run(agentId, opts, flags, (memory) => (0, agentMemory_1.applyRotationFlags)(memory, flags), agentMemory_1.describeRotation, 'Voice rotation', verify);
+}

package/dist/commands/agentVersions.js

@@ -19,6 +19,7 @@ const dashboardApi_1 = require("../lib/dashboardApi");
 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 setJson_1 = require("./setJson");
 /** Keys a clone may override. Anything else is rejected before the request. */
 const CLONE_OVERRIDE_KEYS = new Set([
@@ -60,7 +61,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).patch;
+            overrides = (0, agentUpdate_1.preparePatch)(parsed, { skipVoices: true }).patch;
+            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, {
             ...overrides,

package/dist/commands/agents.js

@@ -53,6 +53,7 @@ const ui_1 = require("../lib/ui");
 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 agentImport_1 = require("../lib/agentImport");
 const dbFields_1 = require("../lib/dbFields");
@@ -400,7 +401,7 @@ async function agentsUpdateCommand(agentId, opts) {
         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); // throws on invalid enum/model values
+        const prepared = (0, agentUpdate_1.preparePatch)(obj, { skipVoices: true });
         patch = prepared.patch;
         versionKeys = prepared.versionKeys;
         wholesaleKeys = prepared.wholesaleKeys;
@@ -421,37 +422,60 @@ async function agentsUpdateCommand(agentId, opts) {
             '  Run the command once per version id.'));
     }
     try {
-        // The backend replaces these objects wholesale, so a partial --set would drop
-        // every sibling key. Merge against the agent's current value first. This is
-        // a no-op when the object sent is already complete. Merge against the
-        // *target* version: without one, getAgent returns the default version, and
-        // its siblings (provider, voice id, …) would be written onto a different
-        // version. Wholesale keys are version-level, so --versions is set here.
-        // `functions` is a whole array on the backend: merge by name unless the
-        // caller asked to replace the list.
+        const vid = (0, versions_1.firstVersion)(opts.versions);
+        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)
+            versionTarget = (await api.getAgent(agentId)).agent.versionId;
         const mergeFns = Array.isArray(patch.functions) && !opts.replaceFunctions;
-        if (wholesaleKeys.length || mergeFns) {
-            const { agent } = await api.getAgent(agentId, (0, versions_1.firstVersion)(opts.versions));
-            patch = (0, agentUpdate_1.mergeWholesaleKeys)(patch, agent);
+        let current;
+        try {
+            current = (await api.getAgent(agentId, versionTarget)).agent;
+        }
+        catch (error) {
+            if (mergeFns)
+                throw error;
+            (0, ui_1.info)('  (could not read the current values; sending the patch as given)');
+        }
+        let effectivePatch = patch;
+        if (current) {
+            if (wholesaleKeys.length)
+                effectivePatch = (0, agentUpdate_1.mergeWholesaleKeys)(effectivePatch, current);
             if (mergeFns)
-                patch.functions = (0, agentUpdate_1.mergeFunctions)(patch.functions, agent.functions);
+                effectivePatch.functions = (0, agentUpdate_1.mergeFunctions)(effectivePatch.functions, current.functions);
+        }
+        let { send, changed, unchanged } = current
+            ? (0, agentUpdate_1.planUpdate)(current, effectivePatch)
+            : { send: effectivePatch, changed: Object.keys(effectivePatch), unchanged: [] };
+        if (opts.dryRun) {
+            if (opts.json)
+                console.log(JSON.stringify({ dryRun: true, changing: changed, unchanged }, null, 2));
+            else {
+                (0, ui_1.info)(`  would change: ${changed.join(', ') || '(nothing)'}`);
+                if (unchanged.length)
+                    (0, ui_1.info)(`  already set, skipped: ${unchanged.join(', ')}`);
+                (0, ui_1.info)('  Nothing saved (--dry-run).');
+            }
+            return;
+        }
+        if (!changed.length) {
+            (0, ui_1.info)(`Nothing to change: ${unchanged.join(', ')} already hold the requested value(s).`);
+            return;
         }
-        // A commit message is recorded against a version. Version-level updates
-        // already name one; for an agent-level-only update with --commit, attach it
-        // to the agent's current version so the change (e.g. a rename) is logged.
-        let versionTarget = (0, versions_1.firstVersion)(opts.versions);
-        if (opts.commit && !versionTarget) {
-            const { agent } = await api.getAgent(agentId);
-            versionTarget = agent.versionId;
+        if (changed.length > agentUpdate_1.MAX_FIELDS_WITHOUT_YES && !opts.yes) {
+            return (0, ui_1.handleError)(new Error(`This would change ${changed.length} fields (${changed.join(', ')}).\n` +
+                '  Send only the fields you mean to change. If this is intended, re-run with --yes (or preview with --dry-run).'));
         }
-        const body = { ...patch };
+        const body = { ...send };
         if (opts.commit)
             body.commitMessage = opts.commit;
         const res = await api.updateAgent(agentId, versionTarget, body);
         if (opts.json)
             return void console.log(JSON.stringify(res, null, 2));
         (0, ui_1.success)(res.msg || 'Agent updated.');
-        (0, ui_1.info)(`  updated: ${Object.keys(patch).join(', ')}`);
+        (0, ui_1.info)(`  updated: ${changed.join(', ')}`);
+        if (unchanged.length)
+            (0, ui_1.info)(`  already set, skipped: ${unchanged.join(', ')}`);
         if (opts.commit)
             (0, ui_1.info)(`  commit:  ${opts.commit}`);
     }

package/dist/commands/skills.js

@@ -12,6 +12,7 @@ const os_1 = require("os");
 const child_process_1 = require("child_process");
 const ui_1 = require("../lib/ui");
 const config_1 = require("../lib/config");
+const updateCheck_1 = require("../lib/updateCheck");
 /**
  * Skills live in their own public repo (Mail-Daddy-AI/callkaro-skills), NOT in
  * this package — so a skills update never requires a CLI release. Install and
@@ -157,15 +158,15 @@ function restoreOwnershipIfSudo(dest) {
 /** Codex has no skills system — wire a pointer block into ~/.codex/AGENTS.md. */
 function wireCodexPointer() {
     const codexHome = (0, path_1.join)((0, os_1.homedir)(), '.codex');
-    const block = `${CODEX_MARK_START}
-## CallKaro voice agents
-For ANY task involving CallKaro (voice agents, calls, batch campaigns,
-simulations, phone numbers, analytics): FIRST read
-~/.codex/skills/callkaro/SKILL.md and follow the files it routes to
-(INSTRUCTIONS.md for how to operate; authoring-pipeline/ when building agents).
-All operations run through the \`cku\` CLI (this fork) — it must be logged in (\`cku login\`).
-If you have the official CLI instead, substitute \`ck\` for \`cku\` throughout.
-Prefer \`--json\` output and never invent ids — list first.
+    const block = `${CODEX_MARK_START}
+## CallKaro voice agents
+For ANY task involving CallKaro (voice agents, calls, batch campaigns,
+simulations, phone numbers, analytics): FIRST read
+~/.codex/skills/callkaro/SKILL.md and follow the files it routes to
+(INSTRUCTIONS.md for how to operate; authoring-pipeline/ when building agents).
+All operations run through the \`cku\` CLI (this fork) — it must be logged in (\`cku login\`).
+If you have the official CLI instead, substitute \`ck\` for \`cku\` throughout.
+Prefer \`--json\` output and never invent ids — list first.
 ${CODEX_MARK_END}`;
     const agentsMd = (0, path_1.join)(codexHome, 'AGENTS.md');
     let content = (0, fs_1.existsSync)(agentsMd) ? (0, fs_1.readFileSync)(agentsMd, 'utf8') : '';
@@ -209,6 +210,9 @@ async function installOrUpdate(opts, verb, pack) {
         (0, ui_1.info)(`\nPack: ${which}`);
         (0, ui_1.info)('Open a new agent session and ask it anything about CallKaro.');
         (0, ui_1.info)('Requires the `cku` CLI to be logged in (`cku login`) — the skill pack documents that CLI.');
+        // A shared pack serves several targets; its caller records the install once.
+        if (!pack)
+            await (0, updateCheck_1.recordSkillsInstalled)(repo, (0, config_1.skillsBranch)());
     }
     finally {
         cleanup();
@@ -299,6 +303,7 @@ async function skillsUpdateCommand(opts) {
             try {
                 for (const t of targets)
                     await installOrUpdate(t.opts, 'Updated', shared);
+                await (0, updateCheck_1.recordSkillsInstalled)(repo, (0, config_1.skillsBranch)());
             }
             finally {
                 pack.cleanup();

package/dist/index.js

@@ -51,6 +51,7 @@ const KPI_COLUMNS = 'action_items | in_progress | testing_ab | live_prod | done
 const analyzers_1 = require("./commands/analyzers");
 const models_1 = require("./commands/models");
 const agents_1 = require("./commands/agents");
+const agentMemory_1 = require("./commands/agentMemory");
 const agentChat_1 = require("./commands/agentChat");
 const scheduled_1 = require("./commands/scheduled");
 const agentVersions_1 = require("./commands/agentVersions");
@@ -877,8 +878,33 @@ agents.command('update <agentId>').description('update fields via --set \'{json}
     .option('--versions <id>', 'target a specific version (needed for version-level fields)')
     .option('--commit <msg>', 'commit message for the version change')
     .option('--replace-functions', 'replace the whole functions list instead of merging by name (default merges; omitted functions are kept)')
+    .option('--dry-run', 'show which fields would change, without saving')
+    .option('--yes', 'allow an update that changes more than 8 fields')
     .option('--json', 'output the raw updated-agent response')
     .action(agents_1.agentsUpdateCommand);
+agents.command('memory <agentId>').description('show or change call memory (x_call_history for functions); no flags = show')
+    .option('--versions <id>', 'version id (required)')
+    .option('--enable', 'turn call memory on').option('--disable', 'turn call memory off')
+    .option('--max-calls <n>', 'earlier calls to load, -1 (all, up to 200) to 200')
+    .option('--days <n>', 'only calls from the last n days, 0 = no limit')
+    .option('--only-connected', 'only calls that connected').option('--all-calls', 'include calls that did not connect')
+    .option('--with-transcript', 'include transcripts (large)').option('--without-transcript', 'leave transcripts out')
+    .option('--agents <scope>', 'self | all | <agentId,agentId,...> - whose calls to read')
+    .option('--commit <msg>', 'commit message for the version change')
+    .option('--json', 'output the raw agentMemory object')
+    .action(agentMemory_1.agentsMemoryCommand);
+agents.command('voice-rotation <agentId>').description('show or change voice rotation on retry; no flags = show')
+    .option('--versions <id>', 'version id (required)')
+    .option('--enable', 'turn rotation on').option('--disable', 'turn rotation off')
+    .option('--trigger <mode>', 'instant_hangup | custom')
+    .option('--status <status>', 'custom trigger: previous call connected | not_connected')
+    .option('--condition <expr>', 'custom trigger condition source[.field]:operator[:value] (repeatable)', (value, previous = []) => [...previous, value])
+    .option('--clear-conditions', 'remove all conditions')
+    .option('--voices <@file.json>', 'JSON array of retry voice configurations (max 5)')
+    .option('--on-exhausted <mode>', 'last | primary | cycle')
+    .option('--commit <msg>', 'commit message for the version change')
+    .option('--json', 'output the raw agentMemory object')
+    .action(agentMemory_1.agentsVoiceRotationCommand);
 // Phone assignment (agent-centric). The one-inbound-agent rule is enforced server-side.
 agents.command('set-inbound <agentId>').description("add/remove an agent's inbound phone number")
     .option('--number <id>', 'phone number id')

package/dist/lib/agentMemory.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasChanges = exports.CONDITION_OPERATORS = exports.CONDITION_SOURCES = exports.ON_EXHAUSTED = exports.PREVIOUS_STATUSES = exports.TRIGGER_MODES = exports.MAX_CONDITIONS = exports.MAX_ROTATION_VOICES = exports.MAX_DAYS_RANGE = exports.MAX_CALLS_RANGE = void 0;
+exports.applyMemoryFlags = applyMemoryFlags;
+exports.parseCondition = parseCondition;
+exports.applyRotationFlags = applyRotationFlags;
+exports.describeMemory = describeMemory;
+exports.describeRotation = describeRotation;
+/** Helpers for call memory and retry voice rotation stored in version.agentMemory. */
+exports.MAX_CALLS_RANGE = [-1, 200];
+exports.MAX_DAYS_RANGE = [0, 3650];
+exports.MAX_ROTATION_VOICES = 5;
+exports.MAX_CONDITIONS = 20;
+exports.TRIGGER_MODES = ['instant_hangup', 'custom'];
+exports.PREVIOUS_STATUSES = ['connected', 'not_connected'];
+exports.ON_EXHAUSTED = ['last', 'primary', 'cycle'];
+exports.CONDITION_SOURCES = ['post_call_variable', 'hangup_reason', 'call_duration', 'conversion_status'];
+exports.CONDITION_OPERATORS = ['equals', 'not_equals', 'empty', 'not_empty', 'eq', 'gt', 'gte', 'lt', 'lte'];
+const OBJECT_ID = /^[0-9a-fA-F]{24}$/;
+const clone = (value) => JSON.parse(JSON.stringify(value ?? {}));
+function oneOf(label, value, allowed) {
+    if (!allowed.includes(value))
+        throw new Error(`Invalid ${label} "${value}"\n  allowed: ${allowed.join(', ')}`);
+    return value;
+}
+function intIn(label, raw, [min, max]) {
+    const value = Number(raw);
+    if (raw.trim() === '' || !Number.isInteger(value) || value < min || value > max) {
+        throw new Error(`Invalid ${label} "${raw}": expected a whole number from ${min} to ${max}`);
+    }
+    return value;
+}
+function pairFlag(label, on, off, onFlag, offFlag) {
+    if (on && off)
+        throw new Error(`${onFlag} and ${offFlag} cannot be used together (${label})`);
+}
+const hasChanges = (flags) => Object.values(flags).some((value) => value !== undefined && value !== false);
+exports.hasChanges = hasChanges;
+function applyMemoryFlags(current, flags) {
+    pairFlag('on/off', flags.enable, flags.disable, '--enable', '--disable');
+    pairFlag('connected filter', flags.onlyConnected, flags.allCalls, '--only-connected', '--all-calls');
+    pairFlag('transcript', flags.withTranscript, flags.withoutTranscript, '--with-transcript', '--without-transcript');
+    const out = clone(current);
+    const filters = (out.call_filters = out.call_filters || {});
+    if (flags.enable)
+        out.enabled_for_call = true;
+    if (flags.disable)
+        out.enabled_for_call = false;
+    if (flags.maxCalls !== undefined)
+        filters.maxCalls = intIn('--max-calls', String(flags.maxCalls), exports.MAX_CALLS_RANGE);
+    if (flags.days !== undefined)
+        filters.maxDays = intIn('--days', String(flags.days), exports.MAX_DAYS_RANGE);
+    if (flags.onlyConnected)
+        filters.onlyConnected = true;
+    if (flags.allCalls)
+        filters.onlyConnected = false;
+    if (flags.withTranscript)
+        filters.includeTranscript = true;
+    if (flags.withoutTranscript)
+        filters.includeTranscript = false;
+    if (flags.agents !== undefined) {
+        const raw = String(flags.agents).trim();
+        if (raw === 'self' || raw === 'all')
+            filters.additionalAgents = { mode: raw, agentIds: [] };
+        else {
+            const ids = raw.split(',').map((id) => id.trim()).filter(Boolean);
+            const bad = ids.filter((id) => !OBJECT_ID.test(id));
+            if (!ids.length || bad.length) {
+                throw new Error(`Invalid --agents "${raw}": use self, all, or a comma-separated list of agent ids${bad.length ? ` (bad: ${bad.join(', ')})` : ''}`);
+            }
+            if (ids.length > 50)
+                throw new Error('--agents takes at most 50 agent ids');
+            filters.additionalAgents = { mode: 'selected', agentIds: ids };
+        }
+    }
+    return out;
+}
+/** Parse source[.field]:operator[:value]. */
+function parseCondition(text) {
+    const [lhs, operator, ...rest] = text.split(':');
+    if (!lhs || !operator)
+        throw new Error(`Bad --condition "${text}": expected source[.field]:operator[:value], e.g. hangup_reason:equals:user_busy`);
+    const dot = lhs.indexOf('.');
+    const source = dot < 0 ? lhs : lhs.slice(0, dot);
+    const field = dot < 0 ? undefined : lhs.slice(dot + 1);
+    oneOf('condition source', source, exports.CONDITION_SOURCES);
+    oneOf('condition operator', operator, exports.CONDITION_OPERATORS);
+    if (source === 'post_call_variable' && !field)
+        throw new Error(`Bad --condition "${text}": post_call_variable needs a field, e.g. post_call_variable.interested:equals:false`);
+    if (source !== 'post_call_variable' && field)
+        throw new Error(`Bad --condition "${text}": only post_call_variable takes a .field`);
+    const condition = { source, operator };
+    if (field)
+        condition.field = field;
+    if (operator !== 'empty' && operator !== 'not_empty') {
+        if (!rest.length)
+            throw new Error(`Bad --condition "${text}": operator "${operator}" needs a value`);
+        const raw = rest.join(':');
+        try {
+            condition.value = JSON.parse(raw);
+        }
+        catch {
+            condition.value = raw;
+        }
+        if (typeof condition.value === 'object')
+            condition.value = raw;
+    }
+    return condition;
+}
+function applyRotationFlags(current, flags) {
+    pairFlag('on/off', flags.enable, flags.disable, '--enable', '--disable');
+    if (flags.clearConditions && flags.condition?.length)
+        throw new Error('--clear-conditions and --condition cannot be used together');
+    const out = clone(current);
+    const rotation = (out.voice_rotation_config = out.voice_rotation_config || {});
+    const trigger = (rotation.trigger = rotation.trigger || {});
+    if (flags.enable)
+        rotation.enabled = true;
+    if (flags.disable)
+        rotation.enabled = false;
+    if (flags.trigger !== undefined)
+        trigger.mode = oneOf('--trigger', flags.trigger, exports.TRIGGER_MODES);
+    if (flags.status !== undefined)
+        trigger.previous_call_status = oneOf('--status', flags.status, exports.PREVIOUS_STATUSES);
+    if (flags.onExhausted !== undefined)
+        rotation.on_exhausted = oneOf('--on-exhausted', flags.onExhausted, exports.ON_EXHAUSTED);
+    if (flags.clearConditions)
+        trigger.conditions = [];
+    if (flags.condition?.length)
+        trigger.conditions = flags.condition.map(parseCondition);
+    if ((trigger.conditions || []).length > exports.MAX_CONDITIONS)
+        throw new Error(`At most ${exports.MAX_CONDITIONS} conditions`);
+    if ((trigger.conditions || []).length && (trigger.mode || 'instant_hangup') !== 'custom') {
+        throw new Error('Conditions only apply with --trigger custom (instant_hangup ignores them)');
+    }
+    if (flags.voices !== undefined) {
+        if (!Array.isArray(flags.voices) || flags.voices.some((voice) => !voice || typeof voice !== 'object' || Array.isArray(voice))) {
+            throw new Error('--voices must be a JSON array of voice configuration objects');
+        }
+        if (flags.voices.length > exports.MAX_ROTATION_VOICES)
+            throw new Error(`At most ${exports.MAX_ROTATION_VOICES} retry voices (got ${flags.voices.length})`);
+        flags.voices.forEach((voice, index) => {
+            if (typeof voice.voice_provider !== 'string' || !voice.voice_provider.trim()) {
+                throw new Error(`voices[${index}]: voice_provider is required - copy the "configuration" object from \`cku voices --json\` unchanged`);
+            }
+        });
+        rotation.voices = flags.voices;
+    }
+    if (rotation.enabled && !(rotation.voices || []).length)
+        throw new Error('Rotation needs at least one retry voice - pass --voices @voices.json (a JSON array), or leave it disabled');
+    return out;
+}
+function describeMemory(memory) {
+    const value = memory || {};
+    const filters = value.call_filters || {};
+    const agents = filters.additionalAgents || {};
+    const maxCalls = filters.maxCalls ?? 10;
+    return {
+        'call memory': value.enabled_for_call ? 'on' : 'off',
+        'max calls': maxCalls < 0 ? 'all (up to 200)' : String(maxCalls),
+        'max age (days)': (filters.maxDays ?? 0) > 0 ? String(filters.maxDays) : 'no limit',
+        'connected only': filters.onlyConnected === false ? 'no' : 'yes',
+        transcripts: filters.includeTranscript ? 'yes' : 'no',
+        'agents read': agents.mode === 'selected' ? `selected (${(agents.agentIds || []).length})` : agents.mode || 'self',
+    };
+}
+function describeRotation(memory) {
+    const rotation = (memory || {}).voice_rotation_config || {};
+    const trigger = rotation.trigger || {};
+    const mode = trigger.mode || 'instant_hangup';
+    return {
+        'voice rotation': rotation.enabled ? 'on' : 'off',
+        trigger: mode === 'custom' ? `custom (previous call ${trigger.previous_call_status || 'connected'}, ${(trigger.conditions || []).length} condition(s))` : 'instant_hangup',
+        'retry voices': String((rotation.voices || []).length),
+        'when exhausted': rotation.on_exhausted || 'last',
+    };
+}

package/dist/lib/agentUpdate.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENUMS = exports.STRING_ARRAY_KEYS = exports.REPLACE_WHOLESALE_KEYS = void 0;
+exports.MAX_FIELDS_WITHOUT_YES = exports.ENUMS = exports.STRING_ARRAY_KEYS = exports.REPLACE_WHOLESALE_KEYS = void 0;
 exports.applyLiveModels = applyLiveModels;
 exports.validateEnums = validateEnums;
 exports.validateCallSettings = validateCallSettings;
 exports.validateProviderConfigs = validateProviderConfigs;
 exports.preparePatch = preparePatch;
+exports.jsonEqual = jsonEqual;
+exports.planUpdate = planUpdate;
 exports.coerce = coerce;
 exports.deepMerge = deepMerge;
 exports.mergeWholesaleKeys = mergeWholesaleKeys;
@@ -28,7 +30,7 @@ const catalog_1 = require("./catalog");
 exports.REPLACE_WHOLESALE_KEYS = new Set([
     'preFormatVariables', 'customPronunciations', 'transcriber', 'secondary_transcriber',
     'voice_configuration', 'secondary_voice_configuration', 'callFlow_json',
-    'variableSource', 'callPropertyMapping',
+    'variableSource', 'callPropertyMapping', 'agentMemory',
 ]);
 /** String-array fields the web trims + drops empties on; we match that. */
 exports.STRING_ARRAY_KEYS = new Set([
@@ -160,8 +162,10 @@ const PROVIDER_CONFIGS = [
  * Patches may be partial (a dotted `--set` touching only `voice_speed`), so each
  * check runs only when the keys it needs are actually present.
  */
-function validateProviderConfigs(obj) {
+function validateProviderConfigs(obj, opts = {}) {
     for (const { key, kind } of PROVIDER_CONFIGS) {
+        if (opts.skipVoices && kind === 'voice')
+            continue;
         const cfg = obj[key];
         if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg))
             continue;
@@ -199,7 +203,7 @@ function validateProviderConfigs(obj) {
  * `wholesaleKeys` lists the replace-wholesale objects present in the patch, so
  * the caller can merge them against the agent's current value before sending.
  */
-function preparePatch(obj) {
+function preparePatch(obj, opts = {}) {
     if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
         throw new Error('--set must be a JSON object of fields, e.g. \'{"name":"x","temperature":5}\'');
     }
@@ -207,7 +211,7 @@ function preparePatch(obj) {
     validateEnums(source);
     validateCallSettings(source);
     const patch = { ...source };
-    validateProviderConfigs(patch);
+    validateProviderConfigs(patch, opts);
     for (const key of Object.keys(patch)) {
         if (exports.STRING_ARRAY_KEYS.has(key))
             patch[key] = normalizeStringArray(patch[key]);
@@ -216,6 +220,32 @@ function preparePatch(obj) {
     const wholesaleKeys = Object.keys(patch).filter((k) => exports.REPLACE_WHOLESALE_KEYS.has(k) && patch[k] && typeof patch[k] === 'object' && !Array.isArray(patch[k]));
     return { patch, versionKeys, wholesaleKeys };
 }
+exports.MAX_FIELDS_WITHOUT_YES = 8;
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+/** Structural JSON equality: object key order does not matter; array order does. */
+function jsonEqual(a, b) {
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, i) => jsonEqual(value, b[i]));
+    if (isObject(a) && isObject(b))
+        return [...new Set([...Object.keys(a), ...Object.keys(b)])].every((key) => jsonEqual(a[key], b[key]));
+    return a === b;
+}
+function planUpdate(current, patch) {
+    const send = {};
+    const changed = [];
+    const unchanged = [];
+    for (const [key, value] of Object.entries(patch)) {
+        const before = current[key];
+        const next = exports.REPLACE_WHOLESALE_KEYS.has(key) && isObject(before) && isObject(value) ? deepMerge(before, value) : value;
+        if (jsonEqual(before, next))
+            unchanged.push(key);
+        else {
+            send[key] = next;
+            changed.push(key);
+        }
+    }
+    return { send, changed, unchanged };
+}
 /** JSON-first value coercion: `true`→bool, `5`→num, `[...]`→array, else the raw string. */
 function coerce(raw) {
     try {

package/dist/lib/liveVoiceCheck.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkVoiceConfigs = checkVoiceConfigs;
+exports.savedVoices = savedVoices;
+/** Validate TTS provider/model pairs against the account's live voice catalogue. */
+const slug = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+async function checkVoiceConfigs(api, entries, saved) {
+    const todo = Object.entries(entries).filter(([, config]) => !!config && typeof config === 'object' && !Array.isArray(config) && typeof config.voice_provider === 'string');
+    if (!todo.length)
+        return;
+    let providers;
+    try {
+        providers = (await api.getVoiceCatalog()).providers || [];
+    }
+    catch (error) {
+        console.error(`! Could not check voices against the live catalogue (${error.message}); the backend will still validate.`);
+        return;
+    }
+    let savedPairs;
+    const alreadySaved = async (config) => {
+        if (!saved)
+            return false;
+        if (!savedPairs) {
+            try {
+                savedPairs = new Set((await saved()).filter((voice) => typeof voice?.voice_provider === 'string')
+                    .map((voice) => `${slug(voice.voice_provider)}|${voice.voice_model ?? ''}`));
+            }
+            catch {
+                savedPairs = new Set();
+            }
+        }
+        return savedPairs.has(`${slug(String(config.voice_provider))}|${config.voice_model ?? ''}`);
+    };
+    for (const [label, raw] of todo) {
+        const config = raw;
+        const name = String(config.voice_provider);
+        const provider = providers.find((candidate) => slug(candidate.provider) === slug(name));
+        if (!provider) {
+            if (await alreadySaved(config))
+                continue;
+            throw new Error(`Unknown voice_provider "${name}" in ${label}\n  allowed (live): ${providers.map((candidate) => candidate.provider).join(', ')}`);
+        }
+        if (name !== provider.provider)
+            config.voice_provider = provider.provider;
+        const models = provider.models || [];
+        if (typeof config.voice_model === 'string' && config.voice_model && models.length && !models.includes(config.voice_model)) {
+            if (await alreadySaved(config))
+                continue;
+            throw new Error(`"${config.voice_model}" is not a ${provider.provider} voice_model (in ${label})\n  allowed (live): ${models.join(', ')}`);
+        }
+    }
+}
+function savedVoices(version) {
+    return [version?.voice_configuration, version?.secondary_voice_configuration, ...(version?.agentMemory?.voice_rotation_config?.voices || [])].filter(Boolean);
+}

package/dist/lib/updateCheck.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillsOutdated = skillsOutdated;
+exports.recordSkillsInstalled = recordSkillsInstalled;
 exports.isNewer = isNewer;
 exports.notifyIfOutdated = notifyIfOutdated;
 const os_1 = require("os");
@@ -10,9 +12,56 @@ const path_1 = require("path");
 const fs_1 = require("fs");
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./config");
 const CACHE = (0, path_1.join)(process.env.CK_CONFIG_DIR || (0, path_1.join)((0, os_1.homedir)(), '.config', 'callkaro-unofficial'), 'update-check.json');
+/** Which commit of each skill pack was installed, keyed `<repo>@<branch>`. */
+const SKILLS_INSTALLED = (0, path_1.join)((0, path_1.dirname)(CACHE), 'skills-installed.json');
 const DAY = 24 * 60 * 60 * 1000;
 const REGISTRY = 'https://registry.npmjs.org/callkaro-cli-unofficial/latest';
+// With this Accept header GitHub answers with the bare commit sha as text.
+const SHA_HEADERS = { Accept: 'application/vnd.github.sha', 'User-Agent': 'cku' };
+const SHA = /^[0-9a-f]{40}$/;
+const shaUrl = (repo, branch) => `https://api.github.com/repos/${repo}/commits/${branch}`;
+const skillsKey = () => `${(0, config_1.skillsRepo)()}@${(0, config_1.skillsBranch)()}`;
+const readJson = (file) => {
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * True when the skill pack recorded at install time is not the repo's current
+ * head. Without a recorded install there is nothing to compare, so no notice.
+ */
+function skillsOutdated(installed, latest) {
+    return Boolean(installed && latest && installed !== latest);
+}
+/**
+ * Record which commit of the skill pack was just installed, so a later run can
+ * tell when the repo has moved on. The tarball does not carry its sha, so this
+ * asks GitHub for the branch head right after the install. Best effort: a
+ * failure only means no notice until the next `cku skills update`.
+ */
+async function recordSkillsInstalled(repo, branch) {
+    try {
+        const res = await fetch(shaUrl(repo, branch), { headers: SHA_HEADERS, signal: AbortSignal.timeout(5000) });
+        const sha = res.ok ? (await res.text()).trim() : '';
+        if (!SHA.test(sha))
+            return;
+        const key = `${repo}@${branch}`;
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(CACHE), { recursive: true });
+        (0, fs_1.writeFileSync)(SKILLS_INSTALLED, JSON.stringify({ ...readJson(SKILLS_INSTALLED), [key]: sha }));
+        // Keep the cached head in step, or a head cached before this install would
+        // report the pack outdated until the next daily check.
+        if (key === skillsKey())
+            (0, fs_1.writeFileSync)(CACHE, JSON.stringify({ ...readJson(CACHE), skillsSha: sha }));
+    }
+    catch {
+        /* recording the install must never break it */
+    }
+}
 /** True when `latest` is a higher x.y.z than `current` (pre-release tags ignored). */
 function isNewer(latest, current) {
     const n = (v) => v.split('-')[0].split('.').map((x) => parseInt(x, 10) || 0);
@@ -29,6 +78,7 @@ function isNewer(latest, current) {
  * Reads the answer cached by an earlier run and prints it to stderr after the
  * command's own output, so stdout / --json stay clean. The npm lookup runs in a
  * detached child at most once a day, so it never delays or breaks a command.
+ * The same child reads the skill repo's head, for the skill-pack notice.
  * Opt out with CK_NO_UPDATE_CHECK=1 (or when running under `node --test`).
  */
 function notifyIfOutdated(current, argv) {
@@ -37,12 +87,15 @@ function notifyIfOutdated(current, argv) {
             return;
         if (argv.some((a) => ['update', '-v', '--version', '-h', '--help'].includes(a)))
             return;
-        let cache = {};
-        try {
-            cache = JSON.parse((0, fs_1.readFileSync)(CACHE, 'utf8'));
-        }
-        catch {
-            /* first run */
+        const cache = readJson(CACHE);
+        if (cache.skillsSha) {
+            process.on('exit', () => {
+                // Read at exit, not at start: `cku skills install` moves both records during this very run.
+                if (!skillsOutdated(readJson(SKILLS_INSTALLED)[skillsKey()], readJson(CACHE).skillsSha))
+                    return;
+                process.stderr.write(chalk_1.default.yellow(`\nThe CallKaro skill pack (${(0, config_1.skillsRepo)()}) has changed since it was installed.\n` +
+                    `AI agents: tell the user the skills are outdated and ask if they want to refresh; if yes, run \`cku skills update\`.\n`));
+            });
         }
         if (cache.latest && isNewer(cache.latest, current)) {
             process.on('exit', () => {
@@ -53,14 +106,18 @@ function notifyIfOutdated(current, argv) {
         if (!cache.checkedAt || Date.now() - cache.checkedAt > DAY) {
             const script = `
         const fs = require('fs'), path = require('path');
-        const file = process.argv[1];
+        const [, file, shaUrl] = process.argv;
         (async () => {
-          let latest;
+          let latest, skillsSha;
           try { latest = (await (await fetch(${JSON.stringify(REGISTRY)}, { signal: AbortSignal.timeout(5000) })).json()).version; } catch {}
+          try {
+            const sha = (await (await fetch(shaUrl, { headers: ${JSON.stringify(SHA_HEADERS)}, signal: AbortSignal.timeout(5000) })).text()).trim();
+            if (${String(SHA)}.test(sha)) skillsSha = sha;
+          } catch {}
           fs.mkdirSync(path.dirname(file), { recursive: true });
-          fs.writeFileSync(file, JSON.stringify({ checkedAt: Date.now(), latest }));
+          fs.writeFileSync(file, JSON.stringify({ checkedAt: Date.now(), latest, skillsSha }));
         })();`;
-            (0, child_process_1.spawn)(process.execPath, ['-e', script, CACHE], { detached: true, stdio: 'ignore' }).unref();
+            (0, child_process_1.spawn)(process.execPath, ['-e', script, CACHE, shaUrl((0, config_1.skillsRepo)(), (0, config_1.skillsBranch)())], { detached: true, stdio: 'ignore' }).unref();
         }
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callkaro-cli-unofficial",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "license": "Apache-2.0",
   "description": "Unofficial fork of the CallKaro CLI — manage your voice AI agents from the terminal",
   "bin": {