@velaro/cli 1.4.90 → 1.4.92

package/bin/velaro.js

@@ -97,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';
@@ -229,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/avatar-override.js

@@ -0,0 +1,56 @@
+// Pure helpers for `velaro avatar group-override | workflow-override | effective | reset`.
+// Per-group / per-workflow avatar + backdrop overrides live in velaro-messaging (VelaroAvatarController);
+// effective = perWorkflow ?? perGroup ?? perSite. Kept dependency-free so it is unit-testable.
+
+export const BACKDROP_MODES = ['none', 'color', 'gradient', 'image'];
+
+const HEX = /^#[0-9a-fA-F]{3,8}$/;
+const GRADIENT = /^#[0-9a-fA-F]{3,8},#[0-9a-fA-F]{3,8}$/;
+const HTTPS = /^https:\/\/[^\s"'()<>\\]+$/i;
+
+/** Returns an error string or null. Mirrors AvatarExperienceSettings.ValidateBackdrop on the server. */
+export function validateBackdrop(mode, value) {
+  if (mode === undefined || mode === '') return null;
+  if (!BACKDROP_MODES.includes(mode)) return `--backdrop must be one of ${BACKDROP_MODES.join(', ')}`;
+  const v = (value ?? '').trim();
+  if (mode === 'none') return null;
+  if (mode === 'color') return HEX.test(v) ? null : '--backdrop-value must be a hex color like #1e293b';
+  if (mode === 'gradient') return GRADIENT.test(v) ? null : '--backdrop-value must be two hex colors like #1e293b,#7c3aed';
+  return v.length <= 500 && HTTPS.test(v) ? null : '--backdrop-value must be an https image URL';
+}
+
+/**
+ * Builds the PUT body. Merge by default: only flags the caller passed are sent, so changing one field never wipes the
+ * others; an empty string clears that one field back to inherit. `replace` replaces the whole override.
+ */
+export function overrideBody(argv) {
+  const body = { merge: !argv.replace };
+  const map = {
+    provider: 'providerSlug',
+    avatar: 'avatarId',
+    personality: 'personalityPresetSlug',
+    voice: 'voiceId',
+    'display-name': 'displayName',
+    backdrop: 'backgroundMode',
+    'backdrop-value': 'backgroundValue',
+  };
+  for (const [flag, key] of Object.entries(map)) {
+    if (argv[flag] !== undefined) body[key] = String(argv[flag]);
+  }
+  const err = validateBackdrop(body.backgroundMode, body.backgroundValue);
+  if (err) throw new Error(err);
+  if (body.backgroundMode === undefined && body.backgroundValue !== undefined && body.backgroundValue !== '')
+    throw new Error('--backdrop-value needs --backdrop (none | color | gradient | image)');
+  if (Object.keys(body).length === 1) throw new Error('Pass at least one of --avatar --personality --voice --display-name --backdrop --backdrop-value --provider');
+  return body;
+}
+
+/** `group` or `workflow` target path segment from the flags; exactly one is required. */
+export function scopePath(argv) {
+  const hasGroup = argv.group !== undefined;
+  const hasWorkflow = argv.workflow !== undefined;
+  if (hasGroup === hasWorkflow) throw new Error('Pass exactly one of --group <teamId> or --workflow <workflowId>');
+  const id = Number(hasGroup ? argv.group : argv.workflow);
+  if (!Number.isInteger(id) || id <= 0) throw new Error('The id must be a positive whole number');
+  return hasGroup ? `/avatar/groups/${id}` : `/avatar/workflows/${id}`;
+}

package/lib/avatar-override.test.js

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { overrideBody, scopePath, validateBackdrop } from './avatar-override.js';
+
+const TIMKEN = 'https://admin.velaro.com/avatar-backdrops/timken-hr-office.png';
+
+test('validateBackdrop accepts https images, hex colors and two-color gradients only', () => {
+  assert.equal(validateBackdrop('image', TIMKEN), null);
+  assert.match(validateBackdrop('image', 'http://admin.velaro.com/a.png'), /https/);
+  assert.match(validateBackdrop('image', 'javascript:alert(1)'), /https/);
+  assert.match(validateBackdrop('image', 'https://admin.velaro.com/a.png");background:url(//evil'), /https/);
+  assert.equal(validateBackdrop('color', '#1e293b'), null);
+  assert.match(validateBackdrop('color', 'red'), /hex/);
+  assert.equal(validateBackdrop('gradient', '#111,#222'), null);
+  assert.match(validateBackdrop('gradient', '#111'), /two hex/);
+  assert.equal(validateBackdrop('none', ''), null);
+  assert.match(validateBackdrop('sparkles', 'x'), /one of/);
+});
+
+test('overrideBody merges by default and only sends the flags that were passed', () => {
+  assert.deepEqual(overrideBody({ avatar: 'priya', backdrop: 'image', 'backdrop-value': TIMKEN }), {
+    merge: true,
+    avatarId: 'priya',
+    backgroundMode: 'image',
+    backgroundValue: TIMKEN,
+  });
+  assert.deepEqual(overrideBody({ 'display-name': '' }), { merge: true, displayName: '' }); // clears just that field
+  assert.equal(overrideBody({ avatar: 'maya', replace: true }).merge, false);
+});
+
+test('overrideBody refuses an unsafe backdrop, a value with no mode, and an empty change', () => {
+  assert.throws(() => overrideBody({ backdrop: 'image', 'backdrop-value': 'http://admin.velaro.com/a.png' }), /https/);
+  assert.throws(() => overrideBody({ 'backdrop-value': '#fff' }), /needs --backdrop/);
+  assert.throws(() => overrideBody({}), /at least one/);
+});
+
+test('scopePath needs exactly one of --group / --workflow and a positive id', () => {
+  assert.equal(scopePath({ workflow: 12 }), '/avatar/workflows/12');
+  assert.equal(scopePath({ group: 7 }), '/avatar/groups/7');
+  assert.throws(() => scopePath({}), /exactly one/);
+  assert.throws(() => scopePath({ group: 1, workflow: 2 }), /exactly one/);
+  assert.throws(() => scopePath({ group: 0 }), /positive/);
+});

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/avatar.js

@@ -1,4 +1,5 @@
-import { request } from '../api.js';
+import { request, messagingGet, messagingPut, messagingDel } from '../api.js';
+import { overrideBody, scopePath } from '../avatar-override.js';
 import { runCommand } from '../run.js';
 
 // ── velaro avatar ─────────────────────────────────────────────────────────────
@@ -104,5 +105,53 @@ export const avatarCommand = {
         console.log(`  Max TTS chars/mo: ${data.maxAvatarTtsChars}\n`);
       }),
     })
-    .demandCommand(1, 'Specify a subcommand: get | enable | disable | set'),
+    .command({
+      command:  'override',
+      describe: 'Set the person / personality / voice / name / backdrop for ONE group or workflow of YOUR site (perWorkflow ?? perGroup ?? perSite)',
+      builder:  y => y
+        .option('group',          { type: 'number', describe: 'Group (team) id' })
+        .option('workflow',       { type: 'number', describe: 'Workflow id (wins over its group)' })
+        .option('avatar',         { type: 'string', describe: 'Library avatar slug (see the avatar library), e.g. priya. Empty string clears.' })
+        .option('personality',    { type: 'string', describe: 'Personality preset slug. Empty string clears.' })
+        .option('voice',          { type: 'string', describe: 'ElevenLabs voice id. Empty string clears.' })
+        .option('display-name',   { type: 'string', describe: 'Visitor-facing avatar name. Empty string clears.' })
+        .option('backdrop',       { type: 'string', choices: ['none', 'color', 'gradient', 'image', ''], describe: 'Backdrop type. none = explicitly no backdrop; empty string = inherit.' })
+        .option('backdrop-value', { type: 'string', describe: 'Hex color, "#a,#b" gradient, or https image URL' })
+        .option('provider',       { type: 'string', describe: 'Provider slug (a library avatar implies velaro)' })
+        .option('replace',        { type: 'boolean', describe: 'Replace the whole override instead of changing only the flags passed' }),
+      handler:  runCommand(async argv => {
+        const base = scopePath(argv);
+        const data = await messagingPut(`${base}/override`, overrideBody(argv));
+        if (!data?.success) throw new Error(data?.error || 'Override failed');
+        const eff = await messagingGet(`${base}/effective`);
+        console.log(`
+✓ Override saved. Effective now: avatar=${eff.avatarId ?? '(default)'} backdrop=${eff.backgroundMode}${eff.backgroundValue ? ' ' + eff.backgroundValue : ''} name=${eff.displayName ?? '(AI)'} layer=${eff.layer}
+`);
+      }),
+    })
+    .command({
+      command:  'effective',
+      describe: 'Show what a group or workflow of your site gets (override fields layered over the site default)',
+      builder:  y => y
+        .option('group',    { type: 'number', describe: 'Group (team) id' })
+        .option('workflow', { type: 'number', describe: 'Workflow id' }),
+      handler:  runCommand(async argv => {
+        const eff = await messagingGet(`${scopePath(argv)}/effective`);
+        console.log(JSON.stringify(eff, null, 2));
+      }),
+    })
+    .command({
+      command:  'reset',
+      describe: 'Remove a group or workflow override (back to the next layer / site default)',
+      builder:  y => y
+        .option('group',    { type: 'number', describe: 'Group (team) id' })
+        .option('workflow', { type: 'number', describe: 'Workflow id' }),
+      handler:  runCommand(async argv => {
+        const data = await messagingDel(`${scopePath(argv)}/override`);
+        console.log(`
+✓ Reset (${data?.removed ?? 0} override removed)
+`);
+      }),
+    })
+    .demandCommand(1, 'Specify a subcommand: get | enable | disable | set | override | effective | reset'),
 };

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/migrate.js

@@ -9,7 +9,8 @@ export const migrateCommand = {
       .command(migrateExportCommand)
       .command(migrateLivefluenceCommand)
       .command(migrateUrlRulesCommand)
-      .demandCommand(1, 'Specify a subcommand: export, livefluence, url-rules'),
+      .command(migrateTeamsCommand)
+      .demandCommand(1, 'Specify a subcommand: export, livefluence, url-rules, teams'),
   handler: () => {},
 };
 
@@ -21,9 +22,13 @@ const migrateExportCommand = {
   builder:  (y) =>
     y
       .positional('v10SiteId', { type: 'number', describe: 'V10 site ID to export from' })
-      .option('v20-site-id',   { type: 'number', alias: 's', describe: 'V20 site ID for auto-matching teams/AI configs' }),
+      .option('v20-site-id',   { type: 'number', alias: 's', describe: 'V20 site ID for auto-matching teams/AI configs' })
+      .option('include-non-routing', { type: 'boolean', default: false, describe: 'Also include v10 rules with IsRouting=false (group-assignment rules)' }),
   handler:  runCommand(async (argv) => {
-    const qs = argv['v20-site-id'] ? `?v20SiteId=${argv['v20-site-id']}` : '';
+    const params = [];
+    if (argv['v20-site-id']) params.push(`v20SiteId=${argv['v20-site-id']}`);
+    if (argv['include-non-routing']) params.push('includeNonRouting=true');
+    const qs = params.length ? `?${params.join('&')}` : '';
     const data = await get(`/DatabaseTool/V10Export/${argv.v10SiteId}${qs}`);
 
     console.log(`\n${'─'.repeat(60)}`);
@@ -78,7 +83,9 @@ const migrateLivefluenceCommand = {
       .option('v10-site-id',  { type: 'number',  alias: 'v', describe: 'V10 (Livefluence) site ID', demandOption: true })
       .option('v20-site-id',  { type: 'number',  alias: 's', describe: 'V20 destination site ID', demandOption: true })
       .option('dry-run',      { type: 'boolean', default: false, describe: 'Preview without creating' })
-      .option('enable',       { type: 'boolean', default: false, describe: 'Enable created workflows immediately (default: disabled)' })
+      .option('enable',       { type: 'boolean', default: false, describe: 'Enable created workflows immediately (default: disabled; workflows with unconverted v10 terms always stay disabled)' })
+      .option('include-non-routing', { type: 'boolean', default: false, describe: 'Also migrate v10 rules with IsRouting=false (group-assignment rules)' })
+      .option('route-bot-groups-to-team', { type: 'boolean', default: false, describe: 'Route to the v20 team named after the v10 group even if the group had a v10 bot' })
       .option('team-map',     { type: 'string',  describe: 'JSON: [{"v10GroupId":1,"v20TeamId":5},...]  override auto-resolution for teams' })
       .option('ai-config-map',{ type: 'string',  describe: 'JSON: [{"v10GroupId":2,"v20AiConfigId":3},...] override auto-resolution for AI configs' }),
   handler:  runCommand(async (argv) => {
@@ -90,6 +97,8 @@ const migrateLivefluenceCommand = {
       v20SiteId,
       dryRun: argv['dry-run'],
       enable: argv.enable,
+      includeNonRouting:    argv['include-non-routing'],
+      routeBotGroupsToTeam: argv['route-bot-groups-to-team'],
       teamMappings:     argv['team-map']      ? JSON.parse(argv['team-map'])       : [],
       aiConfigMappings: argv['ai-config-map'] ? JSON.parse(argv['ai-config-map'])  : [],
     };
@@ -111,6 +120,8 @@ const migrateLivefluenceCommand = {
         if (item.v2AiConfigId)  console.log(`       → AI Config id=${item.v2AiConfigId}`);
         if (item.v2TeamId)      console.log(`       → Team id=${item.v2TeamId}`);
         if (item.v10Expression) console.log(`       V10 expression: ${item.v10Expression}`);
+        if (item.conditionGroups !== undefined) console.log(`       v20 condition groups (OR): ${item.conditionGroups}`);
+        for (const u of item.unconverted ?? []) console.log(`       ⚠ not converted: ${u}`);
         console.log('');
       }
     }
@@ -127,8 +138,7 @@ const migrateLivefluenceCommand = {
     console.log(`  ${result.message}`);
     if (!argv['dry-run'] && result.created > 0) {
       console.log(`\n  ⚠ All workflows created DISABLED — review conditions in the canvas then enable.`);
-      console.log(`    Note: V10 routing expressions were NOT auto-converted.`);
-      console.log(`    Add conditions manually in the Workflows canvas (Phase 3 trigger node).`);
+      console.log(`    Country and URL terms are converted; terms marked 'not converted' need manual canvas conditions.`);
     }
     console.log(`${'─'.repeat(60)}\n`);
   }),
@@ -157,3 +167,31 @@ const migrateUrlRulesCommand = {
     console.log(`\n  ${result.dryRun ? 'DRY RUN: ' : ''}created ${result.created}, skipped ${result.skipped}`);
   }),
 };
+
+// -- copy v10 groups to v20 teams (v10 read-only) ------------------------------
+
+const migrateTeamsCommand = {
+  command:  'teams',
+  describe: 'Copy v10 (Livefluence) groups to v20 teams on a site (v10 is read-only; idempotent by name)',
+  builder:  (y) =>
+    y
+      .option('v10-site-id', { type: 'number',  alias: 'v', describe: 'V10 (Livefluence) site ID', demandOption: true })
+      .option('v20-site-id', { type: 'number',  alias: 's', describe: 'V20 destination site ID', demandOption: true })
+      .option('groups',      { type: 'string',  describe: 'Comma-separated group names to copy (default: every non-deleted v10 group). "Default Group" maps to the site default team.' })
+      .option('dry-run',     { type: 'boolean', default: false, describe: 'Preview without creating' }),
+  handler:  runCommand(async (argv) => {
+    const body = {
+      v10SiteId: argv['v10-site-id'],
+      v20SiteId: argv['v20-site-id'],
+      dryRun:    argv['dry-run'],
+      groupNames: argv.groups ? argv.groups.split(',').map(g => g.trim()).filter(Boolean) : [],
+    };
+    const result = await post('/DatabaseTool/V10CreateTeams', body);
+    console.log(`\n  ${result.dryRun ? 'DRY RUN - ' : ''}v10 site ${body.v10SiteId} -> v20 site ${body.v20SiteId}\n`);
+    for (const t of result.teams ?? []) {
+      const members = t.v10Members !== undefined ? `  (v10 members: ${t.v10Members})` : '';
+      console.log(`  ${t.status.padEnd(24)} ${t.name}${t.teamId ? `  [team id=${t.teamId}]` : ''}${members}`);
+    }
+    console.log('\n  Members are not copied; assign v20 agents to the new teams.\n');
+  }),
+};

package/lib/commands/recruiting.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from 'fs';
 import { messagingGet, messagingPost, messagingPut, messagingDel, getCredentials } from '../api.js';
 import { runCommand } from '../run.js';
-import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody } from '../recruiting-apply.js';
+import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody, buildHostedBody, buildJobPayBody, buildRenewBody, jobLifecyclePath, jobPayPath } from '../recruiting-apply.js';
 
 // -- velaro recruiting --------------------------------------------------------
 // CLI surface for the Recruiting Bot: job-feed sync (JSON/XML/RSS/Indeed/
@@ -16,8 +16,11 @@ import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody } from
 //   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/PUT Recruiting/Hosted { enabled?, regenerateSlug? } ; POST Recruiting/Hosted/FeedKey/Rotate ; PUT Recruiting/Jobs/{id}/Pay -> hosted job pages (package job-board-hosted, 403 without it)
 //   GET    Recruiting/Applications                     -> candidateApplication[]
-//   GET    Recruiting/Applications/AtsFailures; POST Recruiting/Applications/{id}/AtsRetry; PUT Recruiting/ApplySettings { publicApplyEnabled?, autoCreateCaseTypeId? }; GET Recruiting/Applications/{id}/Resume (binary)
+//   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';
@@ -72,7 +75,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('');
 }
@@ -82,6 +86,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}` : '';
 }
@@ -91,6 +96,59 @@ 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 jobsPayHandler(argv) {
+  const r = await messagingPut(jobPayPath(argv.jobId), buildJobPayBody({ min: argv.min, max: argv.max, currency: argv.currency, period: argv.period, clear: argv.clear }));
+  console.log(`\n${GRN}OK${RST} Job listing ${r.id} pay: ${r.display || '(not stated)'} (source: ${r.salarySource || 'none'}).\n`);
+}
+
+function printHosted(r) {
+  console.log(`\n${BOLD}Job Board hosted pages${RST}`);
+  if (!r.entitled) {
+    console.log(`  Package:  not included (the hosted pages, sitemap and feeds are off; admin calls return 403)\n`);
+    return;
+  }
+  console.log(`  Package:      ${GRN}included${RST}`);
+  console.log(`  Published:    ${r.enabled ? `${GRN}yes${RST}` : 'no (every hosted link answers 404)'}`);
+  console.log(`  Open listings:${' '}${r.liveListings ?? 0}`);
+  if (r.boardUrl) {
+    console.log(`  Board link:   ${r.boardUrl}`);
+    console.log(`  Sitemap:      ${r.sitemapUrl}`);
+    console.log(`  Indeed feed:  ${r.indeedFeedUrl}`);
+    console.log(`  Google feed:  ${r.googleFeedUrl}`);
+    console.log(`  ${DIM}The feed URLs contain a secret key; treat them like a password.${RST}`);
+  }
+  console.log(`  Apply form:   ${r.publicApplyEnabled ? 'on' : 'off (candidates are sent to each listing\'s apply link)'}${r.publicApplyEnabled && r.eeocSelfIdAvailable ? ', with voluntary EEO self-ID' : ''}\n`);
+}
+
+async function hostedHandler(argv) {
+  const body = buildHostedBody({ enabled: argv.enabled, regenerateLink: argv.regenerateLink });
+  const r = Object.keys(body).length ? await messagingPut('/Recruiting/Hosted', body) : await messagingGet('/Recruiting/Hosted');
+  printHosted(r);
+}
+
+async function hostedRotateKeyHandler() {
+  const r = await messagingPost('/Recruiting/Hosted/FeedKey/Rotate', {});
+  console.log(`\n${GRN}OK${RST} Feed key rotated; the previous Indeed and Google feed URLs no longer work.`);
+  printHosted(r);
+}
+
 async function applicationsListHandler() {
   const apps = await messagingGet('/Recruiting/Applications');
   if (!Array.isArray(apps) || !apps.length) {
@@ -152,8 +210,8 @@ async function botSettingsHandler(argv) {
 }
 
 async function applySettingsHandler(argv) {
-  const r = await messagingPut('/Recruiting/ApplySettings', buildApplySettingsBody({ publicApply: argv.publicApply, caseTypeId: argv.caseTypeId }));
-  console.log(`\n${GRN}OK${RST} Apply settings: publicApplyEnabled=${r.publicApplyEnabled}, autoCreateCaseTypeId=${r.autoCreateCaseTypeId ?? '(none)'}\n`);
+  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.
@@ -216,19 +274,65 @@ 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:  'pay <jobId>',
+      describe: 'Set or clear the pay range shown on the hosted page and in its structured data. Needs the Job Board hosted pages package',
+      builder:  (y2) => y2
+        .positional('jobId', { describe: 'Job listing ID', type: 'number' })
+        .option('min',      { describe: 'Minimum (or only) amount', type: 'number' })
+        .option('max',      { describe: 'Maximum amount (optional)', type: 'number' })
+        .option('currency', { describe: '3-letter ISO currency (default USD)', type: 'string' })
+        .option('period',   { describe: 'Hour | Day | Week | Month | Year', type: 'string' })
+        .option('clear',    { describe: 'Remove the stated pay', type: 'boolean' }),
+      handler:  runCommand(jobsPayHandler),
+    })
     .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 | pay | delete'),
   handler: () => {},
 };
 
+const hostedCommand = {
+  command:  'hosted',
+  describe: 'Hosted public job pages: show or change the board settings (needs the Job Board hosted pages package)',
+  builder:  (y) => y
+    .option('enabled',         { describe: 'Publish (true) or unpublish (false) the hosted pages, sitemap and feeds', type: 'boolean' })
+    .option('regenerate-link', { describe: 'Issue a NEW opaque board link; every old hosted URL answers 404 (administrators)', type: 'boolean' })
+    .command({
+      command:  'rotate-key',
+      describe: 'Rotate the outbound feed key; the old Indeed and Google feed URLs stop working (administrators)',
+      handler:  runCommand(hostedRotateKeyHandler),
+    }),
+  handler: runCommand(hostedHandler),
+};
+
 const applicationsCommand = {
   command:  'applications <subcommand>',
   describe: 'List candidate applications or export EEOC voluntary self-ID data',
@@ -262,7 +366,8 @@ const applicationsCommand = {
       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('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({
@@ -453,10 +558,11 @@ export const recruitingCommand = {
     .command(syncCommand)
     .command(configCommand)
     .command(jobsCommand)
+    .command(hostedCommand)
     .command(applicationsCommand)
     .command(sourcesCommand)
     .command(pipelineCommand)
-    .demandCommand(1, 'Specify a recruiting subcommand: sync | config | jobs | applications | sources | pipeline')
+    .demandCommand(1, 'Specify a recruiting subcommand: sync | config | jobs | hosted | applications | sources | pipeline')
     .strict(),
   handler: () => {},
 };

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', '/avatar/groups', '/avatar/workflows', '/avatar/group-overrides'];
 
 test('messaging-only routes are never called through the admin api helpers', () => {
   const offenders = [];

package/lib/recruiting-apply.js

@@ -8,8 +8,63 @@ export function applicationIdPath(id, suffix) {
   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}`;
+}
+
+// Job Board hosted pages (package job-board-hosted): PUT Recruiting/Jobs/{id}/Pay.
+export function jobPayPath(id) {
+  const n = Number(id);
+  if (!Number.isInteger(n) || n <= 0) throw new Error('jobId must be a positive integer.');
+  return `/Recruiting/Jobs/${n}/Pay`;
+}
+
+const PAY_PERIODS = ['Hour', 'Day', 'Week', 'Month', 'Year'];
+
+// Body for PUT Recruiting/Jobs/{id}/Pay. { clear: true } removes the stated pay; otherwise min + period are required
+// (max optional, currency defaults to USD). A manual value is never overwritten by a feed sync.
+export function buildJobPayBody({ min, max, currency, period, clear } = {}) {
+  if (clear) return { clear: true };
+  const lo = Number(min);
+  if (min === undefined || !Number.isFinite(lo) || lo <= 0) throw new Error('min must be a number greater than 0 (or pass clear).');
+  const body = { salaryMin: lo };
+  if (max !== undefined) {
+    const hi = Number(max);
+    if (!Number.isFinite(hi) || hi < lo) throw new Error('max must be a number greater than or equal to min.');
+    body.salaryMax = hi;
+  }
+  const cur = String(currency ?? 'USD').trim().toUpperCase();
+  if (!/^[A-Z]{3}$/.test(cur)) throw new Error('currency must be a 3-letter ISO code such as USD.');
+  body.salaryCurrency = cur;
+  const per = PAY_PERIODS.find((p) => p.toLowerCase() === String(period ?? '').trim().toLowerCase());
+  if (!per) throw new Error(`period must be one of: ${PAY_PERIODS.join(', ')}.`);
+  body.salaryPeriod = per;
+  return body;
+}
+
+// Apply-if-present body for PUT Recruiting/Hosted: { enabled?, regenerateSlug? }. Omit both to only read the settings.
+export function buildHostedBody({ enabled, regenerateLink } = {}) {
+  const body = {};
+  if (enabled !== undefined) body.enabled = Boolean(enabled);
+  if (regenerateLink) body.regenerateSlug = true;
+  return body;
+}
+
+// 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.
-export function buildApplySettingsBody({ publicApply, caseTypeId } = {}) {
+// 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) {
@@ -17,7 +72,12 @@ export function buildApplySettingsBody({ publicApply, caseTypeId } = {}) {
     if (!Number.isInteger(n) || n < 0) throw new Error('caseTypeId must be an integer >= 0 (0 clears).');
     body.autoCreateCaseTypeId = n;
   }
-  if (!Object.keys(body).length) throw new Error('Specify at least one of publicApply, caseTypeId.');
+  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;
 }
 

package/lib/recruiting-apply.test.js

@@ -1,6 +1,29 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody } from './recruiting-apply.js';
+import { applicationIdPath, buildApplySettingsBody, buildBotSettingsBody, buildHostedBody, buildJobPayBody, buildRenewBody, jobLifecyclePath, jobPayPath } 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');
@@ -26,3 +49,30 @@ test('bot settings body is apply-if-present and validated', () => {
   assert.throws(() => buildBotSettingsBody({ maxResults: 11 }));
   assert.throws(() => buildBotSettingsBody({ greeting: 'g'.repeat(501) }));
 });
+
+// -- Job Board hosted pages (Stage 2) -----------------------------------------
+
+test('job pay path validates the id', () => {
+  assert.equal(jobPayPath(7), '/Recruiting/Jobs/7/Pay');
+  assert.throws(() => jobPayPath('x'));
+  assert.throws(() => jobPayPath(0));
+});
+
+test('job pay body: range, currency default and period are validated like the server', () => {
+  assert.deepEqual(buildJobPayBody({ min: 50000, max: 70000, period: 'year' }), { salaryMin: 50000, salaryMax: 70000, salaryCurrency: 'USD', salaryPeriod: 'Year' });
+  assert.deepEqual(buildJobPayBody({ min: '18.5', currency: 'cad', period: 'HOUR' }), { salaryMin: 18.5, salaryCurrency: 'CAD', salaryPeriod: 'Hour' });
+  assert.deepEqual(buildJobPayBody({ clear: true }), { clear: true });
+  assert.throws(() => buildJobPayBody({ period: 'Year' }));
+  assert.throws(() => buildJobPayBody({ min: 0, period: 'Year' }));
+  assert.throws(() => buildJobPayBody({ min: 10, max: 5, period: 'Year' }));
+  assert.throws(() => buildJobPayBody({ min: 10, currency: 'US', period: 'Year' }));
+  assert.throws(() => buildJobPayBody({ min: 10, period: 'Fortnight' }));
+  assert.throws(() => buildJobPayBody({ min: 10 }));
+});
+
+test('hosted body is apply-if-present; no flags means read-only', () => {
+  assert.deepEqual(buildHostedBody({}), {});
+  assert.deepEqual(buildHostedBody({ enabled: true }), { enabled: true });
+  assert.deepEqual(buildHostedBody({ enabled: false }), { enabled: false });
+  assert.deepEqual(buildHostedBody({ regenerateLink: true }), { regenerateSlug: true });
+});

package/package.json

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