@velaro/cli 1.4.89 → 1.4.91

package/bin/velaro.js

@@ -56,6 +56,7 @@ import { keywordIntelligenceCommand } from '../lib/commands/keyword-intelligence
 import { aiFieldExtractionCommand } from '../lib/commands/ai-field-extraction.js';
 import { sentimentCommand, qualityCommand, chatIntelligenceThemesCommand } from '../lib/commands/quality-reports.js';
 import { cannedLearningCommand } from '../lib/commands/canned-learning.js';
+import { chatIntelligenceTopicsCommand } from '../lib/commands/chat-intelligence-topics.js';
 import { focusCommand }       from '../lib/commands/focus.js';
 import { triageCommand }      from '../lib/commands/triage.js';
 import { automationDraftCommand } from '../lib/commands/automation-draft.js';
@@ -96,6 +97,7 @@ import { supportCommand }           from '../lib/commands/support.js';
 import { routingCommand }           from '../lib/commands/routing.js';
 import { diagnosticsCommand }       from '../lib/commands/diagnostics.js';
 import { aiSpendCommand }           from '../lib/commands/ai-spend.js';
+import { aiFederationCommand }       from '../lib/commands/ai-federation.js';
 import { statusPageCommand }        from '../lib/commands/status-page.js';
 import { statusNotifyCommand }      from '../lib/commands/status-notify.js';
 import { statusSlaCommand }         from '../lib/commands/status-sla.js';
@@ -187,6 +189,7 @@ await yargs(hideBin(process.argv))
   .command(qualityCommand)
   .command(chatIntelligenceThemesCommand)
   .command(cannedLearningCommand)
+  .command(chatIntelligenceTopicsCommand)
   .command(focusCommand)
   .command(triageCommand)
   .command(automationDraftCommand)
@@ -227,6 +230,7 @@ await yargs(hideBin(process.argv))
   .command(routingCommand)
   .command(diagnosticsCommand)
   .command(aiSpendCommand)
+  .command(aiFederationCommand)
   .command(statusPageCommand)
   .command(statusNotifyCommand)
   .command(statusSlaCommand)

package/lib/ai-followups.js

@@ -0,0 +1,16 @@
+// AI follow-up suggestions ("AI mode" on a transferToAI node). Pure helpers, no I/O.
+// Resolution on the server: node value ?? account default (SiteSettings) ?? OFF.
+
+export function applyFollowUpOptions(node, { mode, count, instruction } = {}) {
+  const updated = { ...node };
+  if (mode === 'on')      updated.suggestFollowUps = true;
+  if (mode === 'off')     updated.suggestFollowUps = false;
+  // "inherit" CLEARS the node value so the account default decides (never persist false for it).
+  if (mode === 'inherit') delete updated.suggestFollowUps;
+  if (count != null)      updated.suggestFollowUpCount = Math.min(4, Math.max(2, Math.round(count)));
+  if (instruction != null) {
+    if (instruction === '') delete updated.suggestFollowUpInstruction;
+    else updated.suggestFollowUpInstruction = String(instruction).slice(0, 300);
+  }
+  return updated;
+}

package/lib/ai-followups.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { applyFollowUpOptions } from './ai-followups.js';
+
+const node = { id: 1, actionType: 'transferToAI', aiConfigId: 5 };
+
+test('on/off set the node value; inherit clears it', () => {
+  assert.equal(applyFollowUpOptions(node, { mode: 'on' }).suggestFollowUps, true);
+  assert.equal(applyFollowUpOptions(node, { mode: 'off' }).suggestFollowUps, false);
+  const cleared = applyFollowUpOptions({ ...node, suggestFollowUps: true }, { mode: 'inherit' });
+  assert.equal('suggestFollowUps' in cleared, false);
+});
+
+test('count clamps to 2-4 and unrelated fields survive', () => {
+  assert.equal(applyFollowUpOptions(node, { count: 0 }).suggestFollowUpCount, 2);
+  assert.equal(applyFollowUpOptions(node, { count: 9 }).suggestFollowUpCount, 4);
+  assert.equal(applyFollowUpOptions(node, { count: 3 }).aiConfigId, 5);
+});
+
+test('instruction is capped at 300 chars and empty string clears it', () => {
+  assert.equal(applyFollowUpOptions(node, { instruction: 'x'.repeat(500) }).suggestFollowUpInstruction.length, 300);
+  const cleared = applyFollowUpOptions({ ...node, suggestFollowUpInstruction: 'a' }, { instruction: '' });
+  assert.equal('suggestFollowUpInstruction' in cleared, false);
+});
+
+test('workflow command wires the helper and the site-default route', () => {
+  const src = fs.readFileSync(new URL('./commands/workflow.js', import.meta.url), 'utf8');
+  assert.match(src, /applyFollowUpOptions/);
+  assert.match(src, /\/SiteSettings\/AiFollowUps/);
+  assert.match(src, /ai-followups <workflowId> <nodeId>/);
+});

package/lib/commands/ai-federation.js

@@ -0,0 +1,55 @@
+import { get, post } from '../api.js';
+
+function fmtPT(ts) {
+  if (!ts) return '-';
+  return new Date(ts).toLocaleString('en-US', { timeZone: 'America/Los_Angeles', dateStyle: 'short', timeStyle: 'short' }) + ' PT';
+}
+
+function printStatus(s) {
+  console.log(`Anthropic federation: ${s.enabled ? 'ENABLED' : 'disabled'}${s.enabled && !s.configured ? ' (NOT fully configured)' : ''}`);
+  console.log(`  breaker:        ${s.breakerState}${s.breakerOpenUntil ? ' until ' + fmtPT(s.breakerOpenUntil) : ''}`);
+  console.log(`  last success:   ${fmtPT(s.lastSuccessUtc)}`);
+  console.log(`  last failure:   ${fmtPT(s.lastFailureUtc)}${s.lastFailureReason ? '  ' + s.lastFailureReason : ''}`);
+  console.log(`  calls:          federated ${s.federatedCalls}, api-key fallback ${s.fallbackCalls}, breaker opens ${s.breakerOpens}`);
+  console.log(`  token expires:  ${fmtPT(s.tokenExpiresUtc)}`);
+}
+
+const statusCommand = {
+  command: 'status',
+  describe: 'Anthropic federation state: enabled, breaker, last success/failure, federated vs fallback counts (superadmin only)',
+  builder: (y) => y.option('json', { type: 'boolean', default: false }),
+  handler: async (argv) => {
+    const s = await get('AiFederation/status');
+    if (argv.json) { console.log(JSON.stringify(s, null, 2)); return; }
+    printStatus(s);
+  },
+};
+
+const testCommand = {
+  command: 'test',
+  describe: 'Real token exchange plus a 1-token Haiku message; reports which auth path served it',
+  builder: (y) => y.option('json', { type: 'boolean', default: false }),
+  handler: async (argv) => {
+    const r = await post('AiFederation/test', {});
+    if (argv.json) { console.log(JSON.stringify(r, null, 2)); return; }
+    console.log(`exchange: ${r.exchangeOk ? 'OK' : 'FAILED ' + (r.exchangeError ?? '')}`);
+    console.log(`message:  HTTP ${r.messageStatus ?? '-'}${r.messageError ? '  ' + r.messageError : ''}`);
+    console.log(`path used: ${r.pathUsed ?? 'unknown'}`);
+    printStatus(r.status);
+  },
+};
+
+const resetCommand = {
+  command: 'reset-breaker',
+  describe: 'Close the federation circuit breaker so the next call retries federated auth',
+  builder: (y) => y,
+  handler: async () => { printStatus(await post('AiFederation/reset-breaker', {})); },
+};
+
+export const aiFederationCommand = {
+  command: 'ai-federation <subcommand>',
+  describe: 'Anthropic Workload Identity Federation status, test and breaker reset (superadmin only)',
+  builder: (y) => y.command(statusCommand).command(testCommand).command(resetCommand)
+    .demandCommand(1, 'Specify a subcommand: status, test, reset-breaker').strict(),
+  handler: () => {},
+};

package/lib/commands/billing.js

@@ -13,7 +13,7 @@ function fmtDate(iso) {
 // ── plan-status ───────────────────────────────────────────────────────────────
 
 async function planStatus() {
-  const s = await request('GET', '/BillingPayment/plan-status');
+  const s = await request('GET', '/api/BillingPayment/plan-status');
 
   console.log(`\nPlan Status — Site ${s.siteId}\n${'─'.repeat(50)}`);
 

package/lib/commands/chat-intelligence-topics.js

@@ -0,0 +1,47 @@
+import { messagingGet, messagingPost, messagingPut } from '../api.js';
+import { runCommand } from '../run.js';
+
+const print = (data) => console.log(JSON.stringify(data, null, 2));
+const list = (v) => (v == null ? [] : String(v).split(',').map((s) => s.trim()).filter(Boolean));
+
+// velaro chat-topics <show|set|template|merge|rename|retire|group|group-suggestions|suggestions|accept|dismiss|
+//                     reclassify-estimate|reclassify|analysis-estimate|analysis|proposal>
+// REST: messaging /ChatIntelligenceTopics/*  (site comes from the CLI session, never an argument)
+export const chatIntelligenceTopicsCommand = {
+  command: 'chat-topics <action>',
+  describe: 'Chat Intelligence topics: edit the list, merge/rename/group (no AI cost), suggested topics, optional reclassify and analysis',
+  builder: (y) => y
+    .positional('action', { choices: ['show', 'set', 'template', 'merge', 'rename', 'retire', 'group', 'group-suggestions', 'suggestions', 'accept', 'dismiss', 'reclassify-estimate', 'reclassify', 'analysis-estimate', 'analysis', 'proposal'] })
+    .option('topics', { type: 'string', describe: 'set: comma-separated topic list' })
+    .option('industry', { type: 'string', describe: 'template: insurance|healthcare|retail|ecommerce|financial|saas|government|manufacturing' })
+    .option('from', { type: 'string', describe: 'merge/rename/retire/group: comma-separated topics' })
+    .option('to', { type: 'string', describe: 'merge/rename: target topic' })
+    .option('group', { type: 'string', describe: 'group: group name (empty clears)' })
+    .option('suggestion', { type: 'string', describe: 'accept/dismiss/merge a suggested topic' })
+    .option('scope', { type: 'string', default: 'other', describe: 'reclassify: other (default) or all' })
+    .option('days', { type: 'number', default: 90 })
+    .option('max', { type: 'number', describe: 'reclassify: cap (server hard cap 500)' })
+    .option('confirm', { type: 'boolean', default: false, describe: 'reclassify/analysis: required after reading the estimate' })
+    .option('id', { type: 'string', describe: 'proposal: proposal id' })
+    .option('accept', { type: 'boolean', default: true, describe: 'proposal: --no-accept rejects' }),
+  handler: runCommand(async (a) => {
+    const base = '/ChatIntelligenceTopics';
+    const ops = (op) => messagingPost(`${base}/mapping`, { ops: [{ op, from: list(a.from), to: a.to ?? null, group: a.group ?? null }] });
+    switch (a.action) {
+      case 'show': return print(await messagingGet(base));
+      case 'set': return print(await messagingPut(base, { topics: list(a.topics) }));
+      case 'template': return print(await messagingPost(`${base}/template`, { industry: a.industry }));
+      case 'merge': case 'rename': case 'retire': case 'group': return print(await ops(a.action));
+      case 'group-suggestions': return print(await messagingGet(`${base}/group-suggestions?days=${a.days}`));
+      case 'suggestions': return print(await messagingGet(`${base}/suggestions?days=${a.days}`));
+      case 'accept': return print(await messagingPost(`${base}/suggestions/resolve`, { suggestion: a.suggestion, action: a.to ? 'merge' : 'accept', target: a.to ?? null }));
+      case 'dismiss': return print(await messagingPost(`${base}/suggestions/resolve`, { suggestion: a.suggestion, action: 'dismiss' }));
+      case 'reclassify-estimate': return print(await messagingGet(`${base}/reclassify/estimate?scope=${a.scope}&days=${a.days}${a.max ? `&max=${a.max}` : ''}`));
+      case 'reclassify': return print(await messagingPost(`${base}/reclassify`, { scope: a.scope, days: a.days, max: a.max ?? null, confirm: a.confirm }));
+      case 'analysis-estimate': return print(await messagingGet(`${base}/analysis/estimate`));
+      case 'analysis': return print(a.confirm ? await messagingPost(`${base}/analysis`, { confirm: true }) : await messagingGet(`${base}/analysis`));
+      case 'proposal': return print(await messagingPost(`${base}/analysis/proposals`, { id: a.id, accept: a.accept }));
+      default: throw new Error(`Unknown action ${a.action}`);
+    }
+  }),
+};

package/lib/commands/enterprise-reports.js

@@ -13,6 +13,12 @@ const REPORTS = {
   'sentiment-breakdown': 'Sentiment by website, team, agent or topic',
   'topic-radar': 'Topics by volume, growth, transfer rate and handle time',
   'weekly-brief': 'Preview the Monday brief sections',
+  'repeat-contact': 'Share of closed chats where the same contact came back within --window-days, by agent, topic and program',
+  'demand-coverage': 'Day-of-week by hour demand against Available agent hours over whole local weeks (from/to ignored), top gaps, after-hours, next-week forecast',
+  'bot-containment': 'Claimed vs true bot containment and handoff regret',
+  'effort-index': 'Inferred 0-100 customer effort by topic, program and team (not a survey CES)',
+  'promise-ledger': 'Agent commitments made in chat and whether a follow-up appeared; overdue list',
+  'promise-dismiss': 'Dismiss one promise by --id (managers only)',
   'weekly-brief-send-test': 'Email this week\'s brief to the signed-in user',
 };
 
@@ -29,14 +35,27 @@ export const enterpriseReportsCommand = {
     .option('threshold', { type: 'number', describe: 'coaching-queue: queue chats scored below this (1-100)' })
     .option('per-agent', { type: 'number', describe: 'coaching-queue: chats listed per agent' })
     .option('limit', { type: 'number', describe: 'topic-radar: max topics' })
-    .option('days', { type: 'number', describe: 'weekly-brief: days to cover' }),
+    .option('days', { type: 'number', describe: 'weekly-brief: days to cover' })
+    .option('window-days', { type: 'number', describe: 'repeat-contact: days a contact has to come back to count as a repeat (1-30, default 7)' })
+    .option('weeks', { type: 'number', describe: 'demand-coverage: whole local weeks of history (1-12, default 6). from/to are IGNORED by this report' })
+    .option('handle-minutes', { type: 'number', describe: 'demand-coverage: assumed minutes per chat (1-120, default 10)' })
+    .option('max-concurrent', { type: 'number', describe: 'demand-coverage: assumed chats an agent handles at once (1-10, default 3)' })
+    .option('time-zone', { type: 'string', describe: 'demand-coverage: IANA time zone (default America/Los_Angeles)' })
+    .option('low-score', { type: 'number', describe: 'bot-containment: QA score below which a handed-off chat counts as regret (1-100, default 60)' })
+    .option('include-demo', { type: 'boolean', describe: 'Show only the seeded sample (demo) data' })
+    .option('id', { type: 'string', describe: 'promise-dismiss: the promise id' }),
   handler:  runCommand(async (argv) => {
     if (argv.report === 'weekly-brief-send-test') {
       console.log(JSON.stringify(await messagingPost('/api/enterprise-reports/weekly-brief/send-test', {}), null, 2));
       return;
     }
+    if (argv.report === 'promise-dismiss') {
+      if (!argv.id) throw new Error('--id is required for promise-dismiss');
+      console.log(JSON.stringify(await messagingPost(`/api/enterprise-reports/promise-ledger/${encodeURIComponent(String(argv.id))}/dismiss`, {}), null, 2));
+      return;
+    }
     const qs = new URLSearchParams();
-    const map = { from: 'from', to: 'to', groupBy: 'groupBy', deploymentId: 'deploymentId', teamId: 'teamId', threshold: 'threshold', perAgent: 'perAgent', limit: 'limit', days: 'days' };
+    const map = { from: 'from', to: 'to', groupBy: 'groupBy', deploymentId: 'deploymentId', teamId: 'teamId', threshold: 'threshold', perAgent: 'perAgent', limit: 'limit', days: 'days', windowDays: 'windowDays', weeks: 'weeks', handleMinutes: 'handleMinutes', maxConcurrent: 'maxConcurrent', timeZone: 'timeZone', lowScore: 'lowScore', includeDemo: 'includeDemo' };
     for (const [arg, key] of Object.entries(map)) if (argv[arg] != null && argv[arg] !== '') qs.set(key, String(argv[arg]));
     const q = qs.toString();
     console.log(JSON.stringify(await messagingGet(`/api/enterprise-reports/${argv.report}${q ? `?${q}` : ''}`), null, 2));

package/lib/commands/executive-insights.js

@@ -1,5 +1,5 @@
 import { writeFileSync } from 'node:fs';
-import { messagingGet, messagingPost } from '../api.js';
+import { messagingGet, messagingPost, messagingRequestText } from '../api.js';
 import { runCommand } from '../run.js';
 
 // -- velaro executive-insights ---------------------------------------------------
@@ -27,7 +27,7 @@ const frictionCommand = {
   handler: runCommand(async (argv) => {
     const qs = rangeArgs(argv);
     qs.set('limit', String(argv.limit ?? 20));
-    const r = await messagingGet(`/executive-insights/friction-radar?${qs}`);
+    const r = await messagingGet(`/api/executive-insights/friction-radar?${qs}`);
     console.log(`Friction radar: ${r.conversationsScanned} conversations scanned${r.truncated ? ' (truncated)' : ''}`);
     for (const t of r.topics ?? []) {
       const growth = t.isNew ? 'new' : t.growthPct == null ? 'n/a' : `${t.growthPct}%`;
@@ -41,7 +41,7 @@ const briefCommand = {
   describe: 'Executive brief: volume, sentiment, QA, Experience Impact, rising keywords, top friction',
   builder: rangeOptions,
   handler: runCommand(async (argv) => {
-    const r = await messagingGet(`/executive-insights/brief?${rangeArgs(argv)}`);
+    const r = await messagingGet(`/api/executive-insights/brief?${rangeArgs(argv)}`);
     console.log(JSON.stringify(r.brief, null, 2));
   }),
 };
@@ -51,12 +51,14 @@ const exportCommand = {
   describe: 'CSV of conversations with sentiment, QA score, tag, escalations, handle time and keywords',
   builder: (y) => rangeOptions(y).option('out', { type: 'string', describe: 'Write the CSV to this file (default: stdout)' }),
   handler: runCommand(async (argv) => {
-    const r = await messagingGet(`/executive-insights/export?${rangeArgs(argv)}`);
+    // The endpoint is GET api/executive-insights/export.csv and answers text/csv, not JSON.
+    const csv = await messagingRequestText('GET', `/api/executive-insights/export.csv?${rangeArgs(argv)}`);
     if (argv.out) {
-      writeFileSync(argv.out, r.csv, 'utf8');
-      console.log(`Wrote ${r.rows} rows to ${argv.out}${r.truncated ? ' (truncated at the row cap)' : ''}`);
+      writeFileSync(argv.out, csv, 'utf8');
+      const rows = Math.max(csv.split('\n').filter((l) => l.trim().length > 0).length - 1, 0);
+      console.log(`Wrote ${rows} rows to ${argv.out}`);
     } else {
-      process.stdout.write(r.csv);
+      process.stdout.write(csv);
     }
   }),
 };

package/lib/commands/index.js

@@ -74,7 +74,12 @@ const listCommand = {
       ]);
 
       // Quota from subscription
-      const sub = await get('/Subscription/Get').catch(() => null);
+      // GET /Subscription lives on the MESSAGING api (the old admin /Subscription/Get never existed, and its
+      // .catch(() => null) hid that, so the quota line silently never rendered).
+      const sub = await messagingGet('/Subscription').catch((err) => {
+        console.error(`\x1b[33m⚠ Could not read subscription quota: ${err.message}\x1b[0m`);
+        return null;
+      });
       const chunkCap = sub?.maxIndexedChunkTotal ?? 0;
       const usedChunks = indexes.reduce((s, i) => s + (i.documentCount ?? 0), 0);
 
@@ -169,7 +174,10 @@ const reingestCommand = {
     const creds = await getCredentials();
 
     // Check quota before allowing reingest
-    const sub = await get('/Subscription/Get').catch(() => null);
+    const sub = await messagingGet('/Subscription').catch((err) => {
+      console.error(`\x1b[33m⚠ Could not read subscription quota (index quota pre-check skipped): ${err.message}\x1b[0m`);
+      return null;
+    });
     if (!isVelaroAdmin(creds) && sub?.maxIndexedChunkTotal > 0) {
       const indexes = await messagingGet('/AzureIndexes/List').catch(() => []);
       const usedChunks = indexes.reduce((s, i) => s + (i.documentCount ?? 0), 0);

package/lib/commands/ingest.js

@@ -1,4 +1,4 @@
-import { getCredentials, post } from '../api.js';
+import { getCredentials, messagingPost } from '../api.js';
 import { runCommand }           from '../run.js';
 
 export const ingestCommand = {
@@ -18,7 +18,8 @@ export const ingestCommand = {
 
     console.log(`Triggering ingestion for job ${argv['job-id']} on site ${creds.siteId}...`);
 
-    const result = await post('/AzureIndexes/IngestJobDirect', {
+    // AzureIndexesController (IngestJobDirect) lives on the MESSAGING api; the admin api has no such route.
+    const result = await messagingPost('/AzureIndexes/IngestJobDirect', {
       siteId: creds.siteId,
       jobId:  argv['job-id'],
     });

package/lib/commands/kb.js

@@ -122,7 +122,8 @@ const reindexCommand = {
       }
     } else {
       console.log("Reindexing your site's KB articles\u2026");
-      const result = await post('/KBSearchIndex/reindex', {});
+      // KBSearchIndexController is routed api/kb/search (the old /KBSearchIndex/reindex 404'd).
+      const result = await post('/api/kb/search/reindex', {});
       if (result.success === false) {
         console.error(`❌ Failed: ${result.message}`);
       } else {

package/lib/commands/recruiting.js

@@ -1,6 +1,7 @@
 import { writeFileSync } from 'fs';
 import { messagingGet, messagingPost, messagingPut, messagingDel, getCredentials } from '../api.js';
 import { runCommand } from '../run.js';
+import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody, buildRenewBody, jobLifecyclePath } from '../recruiting-apply.js';
 
 // -- velaro recruiting --------------------------------------------------------
 // CLI surface for the Recruiting Bot: job-feed sync (JSON/XML/RSS/Indeed/
@@ -15,7 +16,10 @@ import { runCommand } from '../run.js';
 //   POST   Recruiting/Sync                             -> { success, error, added, updated, total }
 //   GET    Recruiting/Jobs?search=&location=&department= -> jobListing[]
 //   DELETE Recruiting/Jobs/{id}                        -> { success }
+//   GET    Recruiting/Jobs?includeAll=true             -> every status (needs the Job Board lifecycle package)
+//   POST   Recruiting/Jobs/{id}/close | /renew { days? } ; GET Recruiting/Lifecycle -> { entitled, defaultListingDays } (403 without the package)
 //   GET    Recruiting/Applications                     -> candidateApplication[]
+//   GET    Recruiting/Applications/AtsFailures; POST Recruiting/Applications/{id}/AtsRetry; PUT Recruiting/ApplySettings { publicApplyEnabled?, autoCreateCaseTypeId?, defaultListingDays? }; GET Recruiting/Applications/{id}/Resume (binary)
 //   GET    Recruiting/Applications/ExportEeoc           -> text/csv (Professional tier+, EnableRecruitingBotEeoc)
 
 const BOLD = '\x1b[1m';
@@ -70,7 +74,8 @@ async function jobsListHandler(argv) {
   }
   console.log(`\n${BOLD}Recruiting Bot job listings${RST} (${jobs.length})\n`);
   for (const j of jobs) {
-    console.log(`  ${DIM}#${j.id}${RST}  ${j.title}  ${DIM}${j.department || '-'} / ${j.location || '-'}${RST}`);
+    const life = j.status ? `  ${DIM}${j.status}${j.expiresAt ? ` until ${j.expiresAt}` : ''}${RST}` : '';
+    console.log(`  ${DIM}#${j.id}${RST}  ${j.title}  ${DIM}${j.department || '-'} / ${j.location || '-'}${RST}${life}`);
   }
   console.log('');
 }
@@ -80,6 +85,7 @@ function buildQuery(argv) {
   if (argv.search)     params.set('search', argv.search);
   if (argv.location)   params.set('location', argv.location);
   if (argv.department) params.set('department', argv.department);
+  if (argv.all)        params.set('includeAll', 'true');
   const qs = params.toString();
   return qs ? `?${qs}` : '';
 }
@@ -89,6 +95,23 @@ async function jobsDeleteHandler(argv) {
   console.log(`\n${GRN}OK${RST} Job listing ${argv.jobId} deleted.\n`);
 }
 
+async function jobsCloseHandler(argv) {
+  const job = await messagingPost(jobLifecyclePath(argv.jobId, 'close'), {});
+  console.log(`\n${GRN}OK${RST} Job listing ${job.id} closed (status ${job.status}, closed at ${job.closedAt}).\n`);
+}
+
+async function jobsRenewHandler(argv) {
+  const job = await messagingPost(jobLifecyclePath(argv.jobId, 'renew'), buildRenewBody(argv.days));
+  console.log(`\n${GRN}OK${RST} Job listing ${job.id} renewed until ${job.expiresAt} (renewal #${job.renewalCount}, status ${job.status}).\n`);
+}
+
+async function jobsLifecycleHandler() {
+  const r = await messagingGet('/Recruiting/Lifecycle');
+  console.log(`\n${BOLD}Job Board lifecycle${RST}`);
+  console.log(`  Package:              ${r.entitled ? `${GRN}included${RST}` : 'not included (close, renew and JSON-LD pages return 403)'}`);
+  console.log(`  Default listing days: ${r.defaultListingDays}\n`);
+}
+
 async function applicationsListHandler() {
   const apps = await messagingGet('/Recruiting/Applications');
   if (!Array.isArray(apps) || !apps.length) {
@@ -123,6 +146,56 @@ async function applicationsExportEeocHandler(argv) {
   console.log(`\n${GRN}OK${RST} EEOC export saved to ${outPath}\n`);
 }
 
+async function atsFailuresHandler() {
+  const rows = await messagingGet('/Recruiting/Applications/AtsFailures');
+  if (!Array.isArray(rows) || !rows.length) {
+    console.log('\n  No applications with pending or failed ATS write-back.\n');
+    return;
+  }
+  console.log(`\n${BOLD}ATS write-back queue${RST} (${rows.length})\n`);
+  for (const r of rows) {
+    console.log(`  ${DIM}#${r.id}${RST}  ${r.candidateName}  ${r.atsSyncStatus}  ${DIM}attempts=${r.atsSyncAttempts} next=${r.atsSyncNextRetryAt || '-'} ${r.atsSyncLastError || ''}${RST}`);
+  }
+  console.log('');
+}
+
+async function atsRetryHandler(argv) {
+  const r = await messagingPost(applicationIdPath(argv.applicationId, 'AtsRetry'), {});
+  console.log(`\n${GRN}OK${RST} Application ${r.id} ATS status: ${r.atsSyncStatus} (attempts ${r.atsSyncAttempts})${r.atsSyncLastError ? `  ${RED}${r.atsSyncLastError}${RST}` : ''}\n`);
+}
+
+async function botSettingsHandler(argv) {
+  const keys = ['pageContext', 'revealPostedDate', 'revealDescription', 'revealApplyLink', 'publicApply', 'applyMode', 'tone', 'maxResults', 'greeting'];
+  const given = Object.fromEntries(keys.filter((k) => argv[k] !== undefined).map((k) => [k, argv[k]]));
+  // No flags = show current settings.
+  const r = Object.keys(given).length ? await messagingPut('/Recruiting/BotSettings', buildBotSettingsBody(given)) : await messagingGet('/Recruiting/BotSettings');
+  console.log(`\n${GRN}OK${RST} Recruiting bot settings:\n${JSON.stringify(r, null, 2)}\n`);
+}
+
+async function applySettingsHandler(argv) {
+  const r = await messagingPut('/Recruiting/ApplySettings', buildApplySettingsBody({ publicApply: argv.publicApply, caseTypeId: argv.caseTypeId, defaultListingDays: argv.defaultListingDays }));
+  console.log(`\n${GRN}OK${RST} Apply settings: publicApplyEnabled=${r.publicApplyEnabled}, autoCreateCaseTypeId=${r.autoCreateCaseTypeId ?? '(none)'}, defaultListingDays=${r.defaultListingDays ?? '(unchanged)'}\n`);
+}
+
+// Resume is a binary download; fetch raw (messagingGet JSON-parses) with the same auth/site header.
+async function resumeDownloadHandler(argv) {
+  const creds = await getCredentials();
+  const res = await fetch(`${creds.messagingApiBase.replace(/\/+$/, '')}${applicationIdPath(argv.applicationId, 'Resume')}`, {
+    headers: {
+      Authorization: `Bearer ${creds.velaroToken}`,
+      ...(creds.siteId ? { 'vmsg-siteId': String(creds.siteId) } : {}),
+    },
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`GET Resume -> ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const m = /filename\*?=(?:UTF-8'')?"?([^";]+)"?/i.exec(res.headers.get('content-disposition') || '');
+  const outPath = argv.out || (m ? decodeURIComponent(m[1]) : `resume-${argv.applicationId}`);
+  writeFileSync(outPath, Buffer.from(await res.arrayBuffer()));
+  console.log(`\n${GRN}OK${RST} Resume saved to ${outPath}\n`);
+}
+
 const syncCommand = {
   command:  'sync',
   describe: 'Manually trigger a Recruiting Bot job-feed sync for this site',
@@ -164,16 +237,36 @@ const jobsCommand = {
       builder:  (y2) => y2
         .option('search',     { describe: 'Free-text search across title/description', type: 'string' })
         .option('location',   { describe: 'Filter by location', type: 'string' })
-        .option('department', { describe: 'Filter by department', type: 'string' }),
+        .option('department', { describe: 'Filter by department', type: 'string' })
+        .option('all',        { describe: 'Include closed, paused and expired listings (needs the Job Board lifecycle package)', type: 'boolean' }),
       handler: runCommand(jobsListHandler),
     })
+    .command({
+      command:  'close <jobId>',
+      describe: 'Close a listing (gone from search and the public board; its public page and applying answer 410). Needs the Job Board lifecycle package',
+      builder:  (y2) => y2.positional('jobId', { describe: 'Job listing ID', type: 'number' }),
+      handler:  runCommand(jobsCloseHandler),
+    })
+    .command({
+      command:  'renew <jobId>',
+      describe: 'Renew a listing: extend its expiry and republish it. Needs the Job Board lifecycle package',
+      builder:  (y2) => y2
+        .positional('jobId', { describe: 'Job listing ID', type: 'number' })
+        .option('days', { describe: 'Days to extend by (1-365; default: the site default listing days)', type: 'number' }),
+      handler:  runCommand(jobsRenewHandler),
+    })
+    .command({
+      command:  'lifecycle',
+      describe: 'Show whether this site has the Job Board lifecycle package and its default listing days',
+      handler:  runCommand(jobsLifecycleHandler),
+    })
     .command({
       command:  'delete <jobId>',
       describe: 'Delete a synced job listing',
       builder:  (y2) => y2.positional('jobId', { describe: 'Job listing ID', type: 'number' }),
       handler:  runCommand(jobsDeleteHandler),
     })
-    .demandCommand(1, 'Specify a jobs subcommand: list | delete'),
+    .demandCommand(1, 'Specify a jobs subcommand: list | close | renew | lifecycle | delete'),
   handler: () => {},
 };
 
@@ -192,7 +285,44 @@ const applicationsCommand = {
       builder:  (y2) => y2.option('out', { describe: 'Output CSV file path (default: eeoc-export-<timestamp>.csv)', type: 'string' }),
       handler:  runCommand(applicationsExportEeocHandler),
     })
-    .demandCommand(1, 'Specify an applications subcommand: list | export-eeoc'),
+    .command({ command: 'ats-failures', describe: 'List applications whose ATS write-back is Pending/Failed/Abandoned', handler: runCommand(atsFailuresHandler) })
+    .command({
+      command:  'ats-retry <applicationId>',
+      describe: 'Retry the ATS write-back for one application now (resets attempts)',
+      builder:  (y2) => y2.positional('applicationId', { type: 'number' }),
+      handler:  runCommand(atsRetryHandler),
+    })
+    .command({
+      command:  'resume <applicationId>',
+      describe: 'Download an applicant resume',
+      builder:  (y2) => y2.positional('applicationId', { type: 'number' }).option('out', { describe: 'Output file path (default: original file name)', type: 'string' }),
+      handler:  runCommand(resumeDownloadHandler),
+    })
+    .command({
+      command:  'apply-settings',
+      describe: 'Set public apply form options (apply-if-present)',
+      builder:  (y2) => y2
+        .option('public-apply', { describe: 'Enable/disable the public apply endpoint for this site', type: 'boolean' })
+        .option('case-type-id', { describe: 'Case type to auto-create a case per application (0 clears)', type: 'number' })
+        .option('default-listing-days', { describe: 'Days a new listing stays live when its feed gives no expiry (1-365; needs the Job Board lifecycle package)', type: 'number' }),
+      handler:  runCommand(applySettingsHandler),
+    })
+    .command({
+      command:  'bot-settings',
+      describe: 'Show or set what the recruiting bot reveals and how it behaves (omit flags to show)',
+      builder:  (y2) => y2
+        .option('page-context', { describe: 'Use the job from the host page (Velaro context call)', type: 'boolean' })
+        .option('reveal-posted-date', { describe: 'Let the bot share when a job was first listed', type: 'boolean' })
+        .option('reveal-description', { describe: 'Let the bot share the full job description', type: 'boolean' })
+        .option('reveal-apply-link', { describe: 'Let the bot share the listing link', type: 'boolean' })
+        .option('public-apply', { describe: 'Enable the public apply endpoint', type: 'boolean' })
+        .option('apply-mode', { describe: 'both | link | inproduct', type: 'string' })
+        .option('tone', { describe: 'friendly | professional | concise', type: 'string' })
+        .option('max-results', { describe: 'Most jobs per search (1-10)', type: 'number' })
+        .option('greeting', { describe: 'Opening greeting (500 chars max)', type: 'string' }),
+      handler:  runCommand(botSettingsHandler),
+    })
+    .demandCommand(1, 'Specify an applications subcommand: list | export-eeoc | ats-failures | ats-retry | resume | apply-settings | bot-settings'),
   handler: () => {},
 };
 

package/lib/commands/rule.js

@@ -1,4 +1,4 @@
-import { messagingGet as get, messagingPost as post, messagingDel as del } from '../api.js';
+import { messagingGet as get, messagingPost as post, messagingRequest } from '../api.js';
 import { requireFeature }  from '../subscription.js';
 import { runCommand }      from '../run.js';
 
@@ -79,7 +79,9 @@ const ruleDeleteCommand = {
   builder:  (y) => y.positional('id', { type: 'number', describe: 'Rule ID' }),
   handler:  runCommand(async (argv) => {
     await requireFeature('enableWorkflowRules', 'Routing Rules');
-    await del(`/Rules/${argv.id}`);
+    // RulesController.DeleteAsync is `[HttpDelete]` taking the rule in the BODY (DELETE /Rules {id}); there is no
+    // DELETE /Rules/{id} route (it 404'd). Verified live on staging 2026-10-12: DELETE /Rules {"id":N} -> 200.
+    await messagingRequest('DELETE', '/Rules', { id: argv.id });
     console.log(`Rule ${argv.id} deleted.`);
   }),
 };

package/lib/commands/teams.js

@@ -101,6 +101,61 @@ export const teamsCommand = {
           else { console.error(`Send failed: ${result?.message || 'unknown error'}`); process.exit(1); }
         }
       )
+      .command(
+        'send-direct <user> <title>',
+        'Send a 1:1 Teams message to any user in the tenant (UPN or Entra id). Velaro staff only.',
+        (y) =>
+          y
+            .positional('user', { type: 'string', describe: 'alex@velaro.com or Entra object id' })
+            .positional('title', { type: 'string', describe: 'Card title' })
+            .option('message', { type: 'string', alias: 'm', describe: 'Message text' })
+            .option('fact', { type: 'array', describe: 'Repeatable "Label=Value"' })
+            .option('button-label', { type: 'string' })
+            .option('button-url', { type: 'string' }),
+        async (argv) => {
+          const facts = (argv.fact || []).map((f) => { const eq = f.indexOf('='); return { label: f.slice(0, eq), value: f.slice(eq + 1) }; });
+          const r = await request('POST', '/TeamsMessaging/Direct', {
+            user: argv.user, title: argv.title, message: argv.message || '', facts,
+            actionUrl: argv.buttonUrl, actionLabel: argv.buttonLabel,
+          });
+          if (r?.sent) console.log(`Sent to ${argv.user} via ${r.path}.`);
+          else { console.error(`Send failed: ${r?.error || 'unknown error'}`); process.exit(1); }
+        }
+      )
+      .command(
+        'card <title>',
+        'Post a card to a named DevOps-team channel with real @mentions (Velaro staff). Destinations: prs, workflows, deploys, alerts, qa, general.',
+        (y) =>
+          y
+            .positional('title', { type: 'string' })
+            .option('destination', { type: 'string', alias: 'd', describe: 'Named channel (see: velaro teams destinations)' })
+            .option('mention', { type: 'array', describe: 'Repeatable UPN or UPN=Display Name, e.g. --mention andrea@velaro.com=Andrea' })
+            .option('message', { type: 'string', alias: 'm', describe: 'Subtitle text' })
+            .option('fact', { type: 'array', describe: 'Repeatable "Label=Value"' })
+            .option('button-label', { type: 'string' })
+            .option('button-url', { type: 'string' }),
+        async (argv) => {
+          const facts = (argv.fact || []).map((f) => { const eq = f.indexOf('='); return { label: f.slice(0, eq), value: f.slice(eq + 1) }; });
+          const mentions = (argv.mention || []).map((m) => { const t = String(m); const eq = t.indexOf('='); return eq < 0 ? { user: t } : { user: t.slice(0, eq), name: t.slice(eq + 1) }; });
+          const r = await request('POST', '/TeamsMessaging/Card', {
+            title: argv.title, subtitle: argv.message || '', facts, mentions, destination: argv.destination,
+            actionUrl: argv.buttonUrl, actionLabel: argv.buttonLabel,
+          });
+          if (r?.sent) console.log(`Card sent via ${r.path}.${r.warnings?.length ? ' Warnings: ' + r.warnings.join('; ') : ''}`);
+          else { console.error(`Send failed: ${r?.error || 'unknown error'}`); process.exit(1); }
+        }
+      )
+      .command(
+        'destinations',
+        'List named Teams destinations and the live channels of the DevOps team (Velaro staff)',
+        () => {},
+        async () => {
+          const r = await request('GET', '/TeamsMessaging/Destinations');
+          for (const n of r.named || []) console.log(`${n.name.padEnd(10)} ${n.resolved ? n.channelId : '(not resolved: set app setting TeamsDestinations:' + n.name + ':ChannelId)'}`);
+          console.log('\nChannels:');
+          for (const c of r.channels || []) console.log(`  ${c.displayName}  ${c.id}`);
+        }
+      )
       .command(
         'push-settings',
         'Show or change which alerts the Velaro Bot pushes into Teams (per-alert switches + daily cap). Only flags you pass are changed.',

package/lib/commands/workflow.js

@@ -2,6 +2,7 @@ import fs                          from 'node:fs';
 import { getCredentials, messagingGet, messagingPost, messagingPut } from '../api.js';
 import { requireFeature }          from '../subscription.js';
 import { runCommand }              from '../run.js';
+import { applyFollowUpOptions }    from '../ai-followups.js';
 
 export const workflowCommand = {
   command:  'workflow <subcommand>',
@@ -15,7 +16,9 @@ export const workflowCommand = {
       .command(workflowDisableCommand)
       .command(workflowNodeOptionsCommand)
       .command(workflowIntegrityScanCommand)
-      .demandCommand(1, 'Specify a subcommand: list, get, create, enable, disable, node-options, integrity-scan'),
+      .command(workflowAiFollowupsCommand)
+      .command(siteAiFollowupsCommand)
+      .demandCommand(1, 'Specify a subcommand: list, get, create, enable, disable, node-options, integrity-scan, ai-followups, ai-followups-site'),
   handler: () => {},
 };
 
@@ -232,6 +235,68 @@ const workflowNodeOptionsCommand = {
   }),
 };
 
+// ── ai-followups (AI follow-up suggestions / "AI mode" on a transferToAI node) ────────
+// After each bot reply the bot offers 2-4 short tappable follow-up replies (web chat; typing stays
+// available). Node value ?? account default ?? OFF. "inherit" CLEARS the node value so the account
+// default decides. Same read-modify-write PUT /Workflows as node-options (no per-node route exists).
+
+const workflowAiFollowupsCommand = {
+  command:  'ai-followups <workflowId> <nodeId>',
+  describe: 'View or set AI follow-up suggestions on an AI Chatbot (transferToAI) node',
+  builder:  (y) =>
+    y
+      .positional('workflowId', { type: 'number', describe: 'Workflow ID' })
+      .positional('nodeId',     { type: 'number', describe: 'Node ID of the transferToAI node' })
+      .option('mode',        { type: 'string', choices: ['on', 'off', 'inherit'], describe: 'on/off for this node, or inherit = use the account default' })
+      .option('count',       { type: 'number', describe: 'Number of suggestions, 2-4 (default 3)' })
+      .option('instruction', { type: 'string', describe: 'Optional style/focus guidance (max 300 chars); pass "" to clear' }),
+  handler:  runCommand(async (argv) => {
+    await requireFeature('enableAutomation', 'Workflows');
+    const w = await messagingGet(`/Workflows/${argv.workflowId}`);
+    if (!w) { console.error(`Workflow ${argv.workflowId} not found.`); process.exit(1); }
+    const nodes = w.nodes ?? {};
+    const nodeKey = String(argv.nodeId);
+    const node = nodes[nodeKey];
+    if (!node) { console.error(`Node ${argv.nodeId} not found in workflow ${argv.workflowId}.`); process.exit(1); }
+    if (node.actionType !== 'transferToAI') {
+      console.error(`Node ${argv.nodeId} is not an AI Chatbot (transferToAI) node (found: ${node.actionType}).`);
+      process.exit(1);
+    }
+
+    const hasChanges = argv.mode || argv.count != null || argv.instruction != null;
+    if (!hasChanges) {
+      const mode = node.suggestFollowUps === true ? 'on' : node.suggestFollowUps === false ? 'off' : 'inherit (account default)';
+      console.log(`\nNode ${argv.nodeId} — AI follow-up suggestions:`);
+      console.log(`  Mode:        ${mode}`);
+      console.log(`  Count:       ${node.suggestFollowUpCount ?? '3 (default)'}`);
+      console.log(`  Guidance:    ${node.suggestFollowUpInstruction ?? '(none)'}`);
+      return;
+    }
+
+    const updated = applyFollowUpOptions(node, { mode: argv.mode, count: argv.count, instruction: argv.instruction });
+    await messagingPut('/Workflows', { ...w, nodes: { ...nodes, [nodeKey]: updated } });
+    // Read back from the server -- a "saved" message alone is not evidence.
+    const check = (await messagingGet(`/Workflows/${argv.workflowId}`))?.nodes?.[nodeKey] ?? {};
+    console.log(`Node ${argv.nodeId} updated. Read-back: suggestFollowUps=${check.suggestFollowUps ?? 'unset'} count=${check.suggestFollowUpCount ?? 'unset'}`);
+  }),
+};
+
+const siteAiFollowupsCommand = {
+  command:  'ai-followups-site',
+  describe: "View or set this account's default for AI follow-up suggestions (nodes can override)",
+  builder:  (y) => y.option('mode', { type: 'string', choices: ['on', 'off', 'inherit'], describe: 'on/off, or inherit = clear (platform default: off)' }),
+  handler:  runCommand(async (argv) => {
+    const show = (r) => (r?.enabled === true ? 'on' : r?.enabled === false ? 'off' : 'unset (off)');
+    if (!argv.mode) {
+      console.log(`Account default: ${show(await messagingGet('/SiteSettings/AiFollowUps'))}`);
+      return;
+    }
+    const enabled = argv.mode === 'on' ? true : argv.mode === 'off' ? false : null;
+    await messagingPut('/SiteSettings/AiFollowUps', { enabled });
+    console.log(`Account default now: ${show(await messagingGet('/SiteSettings/AiFollowUps'))}`);
+  }),
+};
+
 // ── integrity-scan (Velaro staff only) ──────────────────────────────────────────
 
 const workflowIntegrityScanCommand = {

package/lib/enterprise-reports.test.js

@@ -0,0 +1,10 @@
+// The five novel Enterprise Reports (asks 11-15) must stay wired into the CLI with the exact messaging route segments.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { enterpriseReportsCommand } from './commands/enterprise-reports.js';
+
+test('describe lists the five novel reports and the promise dismiss action', () => {
+  for (const r of ['repeat-contact', 'demand-coverage', 'bot-containment', 'effort-index', 'promise-ledger', 'promise-dismiss']) {
+    assert.ok(enterpriseReportsCommand.describe.includes(r), `${r} missing from describe`);
+  }
+});

package/lib/messaging-routes.test.js

@@ -9,7 +9,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const dir = path.join(path.dirname(fileURLToPath(import.meta.url)), 'commands');
-const MESSAGING_ONLY = ['/Teams/List', '/Deployment', '/Users/List', '/Workflows/List', '/Rules', '/Ticket/knowledge-overrides', '/UserStatus/admin', '/api/ivr/config', '/WooCommerce/billing', '/WooCommerce/auth', '/diagnostics/test-magento', '/voice/admin'];
+const MESSAGING_ONLY = ['/Teams/List', '/Deployment', '/Users/List', '/Workflows/List', '/Rules', '/Ticket/knowledge-overrides', '/UserStatus/admin', '/api/ivr/config', '/WooCommerce/billing', '/WooCommerce/auth', '/diagnostics/test-magento', '/voice/admin', '/api/enterprise-reports'];
 
 test('messaging-only routes are never called through the admin api helpers', () => {
   const offenders = [];

package/lib/recruiting-apply.js

@@ -0,0 +1,75 @@
+// Pure helpers for the Recruiting public-apply / ATS write-back CLI commands.
+// Backend: velaro-messaging RecruitingController (Applications/AtsFailures, Applications/{id}/AtsRetry,
+// ApplySettings, Applications/{id}/Resume).
+
+export function applicationIdPath(id, suffix) {
+  const n = Number(id);
+  if (!Number.isInteger(n) || n <= 0) throw new Error('applicationId must be a positive integer.');
+  return `/Recruiting/Applications/${n}/${suffix}`;
+}
+
+// Job Board listing lifecycle (package job-board-lifecycle): POST Recruiting/Jobs/{id}/close | renew.
+export function jobLifecyclePath(id, action) {
+  const n = Number(id);
+  if (!Number.isInteger(n) || n <= 0) throw new Error('jobId must be a positive integer.');
+  if (!['close', 'renew'].includes(action)) throw new Error('action must be close or renew.');
+  return `/Recruiting/Jobs/${n}/${action}`;
+}
+
+// Body for POST Recruiting/Jobs/{id}/renew. Omit days to use the site default (RecruitingConfig.DefaultListingDays).
+export function buildRenewBody(days) {
+  if (days === undefined) return {};
+  const n = Number(days);
+  if (!Number.isInteger(n) || n < 1 || n > 365) throw new Error('days must be an integer from 1 to 365.');
+  return { days: n };
+}
+
+// Apply-if-present body for PUT /Recruiting/ApplySettings. caseTypeId 0 clears the auto-case link.
+// defaultListingDays (1-365) needs the Job Board lifecycle package (the server answers 403 otherwise).
+export function buildApplySettingsBody({ publicApply, caseTypeId, defaultListingDays } = {}) {
+  const body = {};
+  if (publicApply !== undefined) body.publicApplyEnabled = Boolean(publicApply);
+  if (caseTypeId !== undefined) {
+    const n = Number(caseTypeId);
+    if (!Number.isInteger(n) || n < 0) throw new Error('caseTypeId must be an integer >= 0 (0 clears).');
+    body.autoCreateCaseTypeId = n;
+  }
+  if (defaultListingDays !== undefined) {
+    const d = Number(defaultListingDays);
+    if (!Number.isInteger(d) || d < 1 || d > 365) throw new Error('defaultListingDays must be an integer from 1 to 365.');
+    body.defaultListingDays = d;
+  }
+  if (!Object.keys(body).length) throw new Error('Specify at least one of publicApply, caseTypeId, defaultListingDays.');
+  return body;
+}
+
+const APPLY_MODES = ['both', 'link', 'inproduct'];
+const TONES = ['friendly', 'professional', 'concise'];
+
+// Apply-if-present body for PUT /Recruiting/BotSettings (customer controls for the recruiting bot).
+export function buildBotSettingsBody(o = {}) {
+  const body = {};
+  const bools = { pageContext: 'pageContextEnabled', revealPostedDate: 'revealPostedDate', revealDescription: 'revealDescription', revealApplyLink: 'revealApplyLink', publicApply: 'publicApplyEnabled' };
+  for (const [k, field] of Object.entries(bools)) if (o[k] !== undefined) body[field] = Boolean(o[k]);
+  if (o.applyMode !== undefined) {
+    const m = String(o.applyMode).toLowerCase();
+    if (!APPLY_MODES.includes(m)) throw new Error(`applyMode must be one of: ${APPLY_MODES.join(', ')}.`);
+    body.applyMode = m;
+  }
+  if (o.tone !== undefined) {
+    const t = String(o.tone).toLowerCase();
+    if (!TONES.includes(t)) throw new Error(`tone must be one of: ${TONES.join(', ')}.`);
+    body.tone = t;
+  }
+  if (o.maxResults !== undefined) {
+    const n = Number(o.maxResults);
+    if (!Number.isInteger(n) || n < 1 || n > 10) throw new Error('maxResults must be an integer from 1 to 10.');
+    body.maxResults = n;
+  }
+  if (o.greeting !== undefined) {
+    if (String(o.greeting).length > 500) throw new Error('greeting must be 500 characters or fewer.');
+    body.greeting = String(o.greeting);
+  }
+  if (!Object.keys(body).length) throw new Error('Specify at least one bot setting.');
+  return body;
+}

package/lib/recruiting-apply.test.js

@@ -0,0 +1,51 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody, buildRenewBody, jobLifecyclePath } from './recruiting-apply.js';
+
+test('job lifecycle paths validate id and action', () => {
+  assert.equal(jobLifecyclePath(7, 'close'), '/Recruiting/Jobs/7/close');
+  assert.equal(jobLifecyclePath('9', 'renew'), '/Recruiting/Jobs/9/renew');
+  assert.throws(() => jobLifecyclePath('x', 'close'));
+  assert.throws(() => jobLifecyclePath(0, 'close'));
+  assert.throws(() => jobLifecyclePath(1, 'delete'));
+});
+
+test('renew body: omitted days uses the site default, supplied days are range-checked', () => {
+  assert.deepEqual(buildRenewBody(undefined), {});
+  assert.deepEqual(buildRenewBody(30), { days: 30 });
+  assert.deepEqual(buildRenewBody('7'), { days: 7 });
+  assert.throws(() => buildRenewBody(0));
+  assert.throws(() => buildRenewBody(366));
+  assert.throws(() => buildRenewBody(2.5));
+});
+
+test('apply settings carries defaultListingDays (1-365)', () => {
+  assert.deepEqual(buildApplySettingsBody({ defaultListingDays: 45 }), { defaultListingDays: 45 });
+  assert.throws(() => buildApplySettingsBody({ defaultListingDays: 0 }));
+  assert.throws(() => buildApplySettingsBody({ defaultListingDays: 400 }));
+});
+
+test('application paths validate id', () => {
+  assert.equal(applicationIdPath(12, 'AtsRetry'), '/Recruiting/Applications/12/AtsRetry');
+  assert.equal(applicationIdPath('5', 'Resume'), '/Recruiting/Applications/5/Resume');
+  assert.throws(() => applicationIdPath('x', 'Resume'));
+  assert.throws(() => applicationIdPath(0, 'Resume'));
+});
+
+test('apply settings body is apply-if-present', () => {
+  assert.deepEqual(buildApplySettingsBody({ publicApply: true }), { publicApplyEnabled: true });
+  assert.deepEqual(buildApplySettingsBody({ caseTypeId: 0 }), { autoCreateCaseTypeId: 0 });
+  assert.deepEqual(buildApplySettingsBody({ publicApply: false, caseTypeId: 3 }), { publicApplyEnabled: false, autoCreateCaseTypeId: 3 });
+  assert.throws(() => buildApplySettingsBody({}));
+  assert.throws(() => buildApplySettingsBody({ caseTypeId: -1 }));
+});
+
+test('bot settings body is apply-if-present and validated', () => {
+  assert.deepEqual(buildBotSettingsBody({ revealPostedDate: false }), { revealPostedDate: false });
+  assert.deepEqual(buildBotSettingsBody({ applyMode: 'LINK', tone: 'Concise', maxResults: 3, pageContext: true, publicApply: false }), { pageContextEnabled: true, publicApplyEnabled: false, applyMode: 'link', tone: 'concise', maxResults: 3 });
+  assert.throws(() => buildBotSettingsBody({}));
+  assert.throws(() => buildBotSettingsBody({ applyMode: 'x' }));
+  assert.throws(() => buildBotSettingsBody({ tone: 'angry' }));
+  assert.throws(() => buildBotSettingsBody({ maxResults: 11 }));
+  assert.throws(() => buildBotSettingsBody({ greeting: 'g'.repeat(501) }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velaro/cli",
-  "version": "1.4.89",
+  "version": "1.4.91",
   "description": "Velaro Workspace v20 — command-line interface for managing bots, knowledge base ingestion, MCP API keys, search indexes, and ops health.",
   "type": "module",
   "bin": {