463 lines
23 KiB
JavaScript
463 lines
23 KiB
JavaScript
import {
|
||
AlertTriangle, BarChart3, ClipboardCheck, FileSpreadsheet, FileText, GitCompare,
|
||
HeartPulse, LineChart, ListChecks, MessageSquareQuote, Sparkles, Target, Layers,
|
||
} from 'lucide-react';
|
||
import { bullets, compose, heading, numbered, plural, verb } from '../insights';
|
||
|
||
/**
|
||
* Employer capabilities — Overview, Candidates, Analytics.
|
||
*
|
||
* Each capability is a pure function of the fact sheet. Keeping them pure is
|
||
* what allows the same code to run against local data today and against a
|
||
* remote AI service later without the UI changing.
|
||
*/
|
||
|
||
/* ── Overview ───────────────────────────────────────────────────────────── */
|
||
|
||
const hiringSummary = (f) => {
|
||
if (!f.total) return 'Nothing in the pipeline yet. Publish a position and I will start tracking it here.';
|
||
|
||
return compose(
|
||
heading('Where hiring stands'),
|
||
bullets([
|
||
`${plural(f.total, 'applicant')} across ${plural(f.openPositions.length, 'open position')}`,
|
||
`${f.screened.length} screened · ${f.unscreened.length} awaiting a score`,
|
||
`${plural(f.interviewing.length, 'candidate')} mid-interview`,
|
||
`${plural(f.hired.length, 'hire')} averaging ${f.hiredAvgScore}/100`,
|
||
]),
|
||
'',
|
||
f.stalled.length
|
||
? `Most urgent: ${plural(f.stalled.length, 'candidate')} scored 80+ and ${verb(f.stalled.length, 'is', 'are')} still sitting at AI Screened.`
|
||
: f.unscreened.length
|
||
? `Most urgent: ${plural(f.unscreened.length, 'applicant')} ${verb(f.unscreened.length, 'has', 'have')} never been scored.`
|
||
: 'Nothing is stuck — every applicant is screened and every strong candidate has been actioned.'
|
||
);
|
||
};
|
||
|
||
const hiringHealth = (f) => {
|
||
const checks = [
|
||
{
|
||
label: 'Screening coverage',
|
||
value: `${f.standardizedPct}%`,
|
||
ok: f.standardizedPct >= 80,
|
||
note: f.standardizedPct >= 80
|
||
? 'Applicants are being scored consistently.'
|
||
: `${plural(f.unscreened.length, 'applicant')} never got a score, so those decisions are unstandardized.`,
|
||
},
|
||
{
|
||
label: 'Response speed',
|
||
value: f.timeToHire ? `${f.timeToHire}d` : '—',
|
||
ok: f.timeToHire > 0 && f.timeToHire <= 3,
|
||
note: f.timeToHire && f.timeToHire <= 3
|
||
? 'Inside the window where good candidates are still available.'
|
||
: 'Event staff accept other work within days — past 3 days you lose people.',
|
||
},
|
||
{
|
||
label: 'Quality of hire',
|
||
value: f.hiredAvgScore ? `${f.hiredAvgScore}/100` : '—',
|
||
ok: f.hiredAvgScore >= 80,
|
||
note: f.hiredAvgScore >= 80
|
||
? 'You are hiring from the top of your own pool.'
|
||
: 'Hires are scoring mid-pack — widen the funnel before lowering the bar.',
|
||
},
|
||
{
|
||
label: 'Pipeline supply',
|
||
value: `${f.openPositions.length} open`,
|
||
ok: f.starvedPositions.length === 0,
|
||
note: f.starvedPositions.length
|
||
? `${f.starvedPositions.map((p) => p.title).join(', ')} ${verb(f.starvedPositions.length, 'has', 'have')} no applicants.`
|
||
: 'Every open position has applicants.',
|
||
},
|
||
];
|
||
|
||
const passing = checks.filter((c) => c.ok).length;
|
||
|
||
return compose(
|
||
heading(`${passing} of ${checks.length} signals healthy`),
|
||
'',
|
||
checks.map((c) => `${c.ok ? '✓' : '⚠'} **${c.label}** — ${c.value}\n ${c.note}`).join('\n\n')
|
||
);
|
||
};
|
||
|
||
const pendingActions = (f) => {
|
||
const actions = [];
|
||
|
||
if (f.stalled.length) {
|
||
actions.push(`**Move your 80+ candidates.** ${f.stalled.slice(0, 3).map((a) => `${a.applicant_name} (${a.ai_score})`).join(', ')} ${verb(f.stalled.length, 'is', 'are')} screened and waiting on you.`);
|
||
}
|
||
if (f.unscreened.length) {
|
||
actions.push(`**Screen the backlog.** ${plural(f.unscreened.length, 'applicant')} ${verb(f.unscreened.length, 'has', 'have')} no score. One pass clears it.`);
|
||
}
|
||
if (f.starvedPositions.length) {
|
||
actions.push(`**Fix the postings nobody applies to.** ${f.starvedPositions.map((p) => p.title).join(' and ')} — usually pay range or reach, not the description.`);
|
||
}
|
||
if (f.unratedStaff.length) {
|
||
actions.push(`**Rate your hires.** ${plural(f.unratedStaff.length, 'person', 'people')} ${verb(f.unratedStaff.length, 'has', 'have')} no rating. Ratings sharpen future matching.`);
|
||
}
|
||
if (f.elite.length) {
|
||
actions.push(`**Reach out directly.** ${f.elite.map((p) => p.full_name).join(', ')} ${verb(f.elite.length, 'is', 'are')} Elite and ${verb(f.elite.length, 'has', 'have')} not applied to anything.`);
|
||
}
|
||
|
||
if (!actions.length) return 'Nothing pending. Everyone is screened, strong candidates are actioned, and every open role has applicants.';
|
||
|
||
return compose(heading('Pending actions'), '', numbered(actions.slice(0, 4)));
|
||
};
|
||
|
||
const hiringRisks = (f) => {
|
||
const risks = [];
|
||
|
||
if (f.singleCandidateRoles.length) {
|
||
risks.push(`**Single-candidate roles.** ${f.singleCandidateRoles.map((e) => e.posting.title).join(', ')} ${verb(f.singleCandidateRoles.length, 'rests', 'rest')} on one viable candidate. If they withdraw, the role reopens from zero.`);
|
||
}
|
||
if (f.stalled.length) {
|
||
risks.push(`**Losing strong candidates to delay.** ${plural(f.stalled.length, 'candidate')} at 80+ ${verb(f.stalled.length, 'has', 'have')} been screened but not moved. This is where good hires quietly disappear.`);
|
||
}
|
||
if (f.missingCredentials.length) {
|
||
risks.push(`**Compliance exposure.** ${plural(f.missingCredentials.length, 'scored candidate')} ${verb(f.missingCredentials.length, 'has', 'have')} no certification on file. Placing them on a role that requires one is a real liability.`);
|
||
}
|
||
if (f.narrowAvailability.length) {
|
||
risks.push(`**Availability risk.** ${plural(f.narrowAvailability.length, 'candidate')} listed one slot or none. ${verb(f.narrowAvailability.length, 'This is the placement', 'These are the placements')} most likely to fall through on the day.`);
|
||
}
|
||
if (f.starvedPositions.length) {
|
||
risks.push(`**Unfillable as posted.** ${plural(f.starvedPositions.length, 'open role')} with zero applicants after being live.`);
|
||
}
|
||
if (f.flagged.length) {
|
||
risks.push(`**Interview integrity.** ${plural(f.flagged.length, 'interview')} scored below full integrity. Worth a human re-interview before progressing.`);
|
||
}
|
||
|
||
if (!risks.length) return 'No material risks in the current pipeline: coverage is good, no role depends on a single candidate, and credentials check out.';
|
||
|
||
return compose(
|
||
heading(`${plural(risks.length, 'risk')} to watch`),
|
||
'',
|
||
numbered(risks),
|
||
'',
|
||
'_Flags to check, not conclusions. Each is a question for a human._'
|
||
);
|
||
};
|
||
|
||
/* ── Candidates ─────────────────────────────────────────────────────────── */
|
||
|
||
const resumeAnalysis = (f) => {
|
||
const subject = f.top[0];
|
||
if (!subject) return 'No scored candidates yet. Screen the pipeline and I will analyse the strongest.';
|
||
|
||
return compose(
|
||
heading(`${subject.applicant_name} — ${subject.ai_score}/100`),
|
||
`${subject.job_title} · ${plural(subject.years_experience, 'year')} experience · ${subject.english_level} English`,
|
||
'',
|
||
subject.ai_summary || '',
|
||
'',
|
||
subject.ai_strengths?.length ? compose(heading('What holds up'), bullets(subject.ai_strengths)) : '',
|
||
'',
|
||
subject.ai_gaps?.length ? compose(heading('What to probe'), bullets(subject.ai_gaps)) : '',
|
||
'',
|
||
subject.certifications?.length
|
||
? `**Credentials:** ${subject.certifications.join(', ')} — verify before the first shift. A lapsed card is the most common surprise.`
|
||
: '**No credentials on file.** Request these before scheduling.'
|
||
);
|
||
};
|
||
|
||
const candidateComparison = (f) => {
|
||
const pair = f.ranked.slice(0, 2);
|
||
if (pair.length < 2) return 'I need at least two scored candidates to compare.';
|
||
|
||
const [a, b] = pair;
|
||
const gap = a.ai_score - b.ai_score;
|
||
const dims = ['experience', 'english', 'reliability', 'certifications', 'availability'];
|
||
|
||
const rows = dims.map((dim) => {
|
||
const av = a.score_breakdown?.[dim] ?? 0;
|
||
const bv = b.score_breakdown?.[dim] ?? 0;
|
||
const lead = av === bv ? 'tied' : (av > bv ? a : b).applicant_name.split(' ')[0];
|
||
return `${dim.charAt(0).toUpperCase() + dim.slice(1)} — ${av} vs ${bv} · ${lead}`;
|
||
});
|
||
|
||
const biggest = dims.reduce((best, d) =>
|
||
Math.abs((a.score_breakdown?.[d] ?? 0) - (b.score_breakdown?.[d] ?? 0)) >
|
||
Math.abs((a.score_breakdown?.[best] ?? 0) - (b.score_breakdown?.[best] ?? 0)) ? d : best, dims[0]);
|
||
|
||
return compose(
|
||
heading(`${a.applicant_name} (${a.ai_score}) vs ${b.applicant_name} (${b.ai_score})`),
|
||
'',
|
||
bullets(rows),
|
||
'',
|
||
gap <= 3
|
||
? `Effectively tied — ${plural(gap, 'point')} apart is inside the noise. Decide on availability and the interview, not the score.`
|
||
: `${a.applicant_name} leads by ${gap}, driven mostly by ${biggest}.`
|
||
);
|
||
};
|
||
|
||
const interviewQuestions = (f) => {
|
||
const subject = f.stalled[0] || f.ranked[0];
|
||
if (!subject) return 'Screen a candidate and I will build questions around their specific gaps.';
|
||
|
||
const gaps = subject.ai_gaps || [];
|
||
|
||
return compose(
|
||
heading(`Questions for ${subject.applicant_name}`),
|
||
'Built from their gaps rather than a generic list, so the interview tests what the score could not.',
|
||
'',
|
||
numbered([
|
||
`Walk me through your busiest ${subject.job_title?.toLowerCase() || 'shift'}. What happened, and what did you decide?`,
|
||
gaps[0]
|
||
? `I noticed ${gaps[0].toLowerCase()}. How have you handled that in practice?`
|
||
: 'Tell me about a shift that went wrong. What was your part in it?',
|
||
'Something breaks mid-service and your lead is unreachable. What are your next three moves?',
|
||
subject.certifications?.length
|
||
? `Your ${subject.certifications[0]} is on file — when did you last apply it on a live shift?`
|
||
: 'Which certifications are you working toward, and why that one?',
|
||
'What does your real availability look like over the next eight weeks?',
|
||
])
|
||
);
|
||
};
|
||
|
||
const skillGapAnalysis = (f) => {
|
||
if (!f.scored.length) return 'No scored candidates yet, so there are no gaps to analyse.';
|
||
|
||
const tally = {};
|
||
f.scored.forEach((a) => (a.ai_gaps || []).forEach((gap) => {
|
||
const key = gap.replace(/^Missing certifications?:\s*/i, 'Missing credential: ');
|
||
tally[key] = (tally[key] || 0) + 1;
|
||
}));
|
||
|
||
const ranked = Object.entries(tally).sort((a, b) => b[1] - a[1]).slice(0, 5);
|
||
if (!ranked.length) return 'No recurring gaps across your scored candidates — the pool matches your postings well.';
|
||
|
||
return compose(
|
||
heading('Recurring gaps'),
|
||
'',
|
||
bullets(ranked.map(([gap, count]) => `${gap} — ${count} of ${f.scored.length}`)),
|
||
'',
|
||
f.missingCredentials.length >= 2
|
||
? `${f.missingCredentials.length} candidates are short a required credential. That is usually a posting problem: if the certification is trainable, requiring it up front filters out people you could hire this week.`
|
||
: 'Gaps are spread thin, which means your requirements are well matched to who is applying.'
|
||
);
|
||
};
|
||
|
||
const hiringRecommendation = (f) => {
|
||
if (!f.scored.length) return 'Nothing scored yet, so I have no basis for a recommendation.';
|
||
|
||
const open = (a) => !['hired', 'rejected'].includes(a.status);
|
||
const shortlist = f.ranked.filter((a) => a.ai_score >= 80 && open(a));
|
||
const interview = f.ranked.filter((a) => a.ai_score >= 60 && a.ai_score < 80 && open(a));
|
||
const pass = f.weak.filter(open);
|
||
|
||
return compose(
|
||
heading('Recommendation'),
|
||
'',
|
||
shortlist.length
|
||
? `**Shortlist** — ${shortlist.map((a) => `${a.applicant_name} (${a.ai_score})`).join(', ')}`
|
||
: '**Shortlist** — nobody currently clears 80.',
|
||
'',
|
||
interview.length ? `**Interview** — ${interview.map((a) => `${a.applicant_name} (${a.ai_score})`).join(', ')}` : '',
|
||
'',
|
||
pass.length ? `**Likely pass** — ${pass.map((a) => `${a.applicant_name} (${a.ai_score})`).join(', ')}` : '',
|
||
'',
|
||
'_A recommendation, not a decision. I score what is on file — I have not met these people._'
|
||
);
|
||
};
|
||
|
||
/* ── Analytics ──────────────────────────────────────────────────────────── */
|
||
|
||
const explainCharts = (f) => compose(
|
||
heading('What these charts are saying'),
|
||
'',
|
||
`**Pipeline Stages** — ${f.total} applied, ${f.screened.length} screened, ${f.hired.length} hired. Bars are cumulative, so "AI Screened" includes everyone who moved past it.`,
|
||
'',
|
||
`**Candidate Scores** — ${plural(f.scored.length, 'candidate')} scored, averaging ${f.avgScore}. The 80–100 bucket holds ${f.ranked.filter((a) => a.ai_score >= 80).length}; that bucket is your real hiring pool.`,
|
||
'',
|
||
`**Interview Completion** — ${f.completedInterviews.length} of ${f.interviews.length} fully scored (${f.interviewCompletion}%). Unscored means started and abandoned.`,
|
||
'',
|
||
`**Cost Saved** — $${f.costSaved.toLocaleString()}, from ${plural(f.scored.length, 'screen')} at $45 and ${plural(f.interviews.length, 'interview')} at $80. Industry per-unit costs for doing it manually, so treat it as a floor.`
|
||
);
|
||
|
||
const forecastHiring = (f) => {
|
||
const available = f.ranked.filter((a) => a.ai_score >= 60 && !['hired', 'rejected'].includes(a.status));
|
||
const conversion = f.hireRate || 14;
|
||
const expected = Math.round((available.length * conversion) / 100) || (available.length >= 3 ? 1 : 0);
|
||
const short = f.openPositions.length - expected;
|
||
|
||
return compose(
|
||
heading('Forecast'),
|
||
'',
|
||
bullets([
|
||
`${plural(available.length, 'candidate')} at 60+ still in play`,
|
||
`At your ${conversion}% hire rate that projects to about ${plural(expected, 'hire')}`,
|
||
f.timeToHire ? `At a ${f.timeToHire}-day average, those land within a week of you deciding` : 'No time-to-hire baseline yet',
|
||
`${plural(f.openPositions.length, 'open position')} to fill`,
|
||
]),
|
||
'',
|
||
short > 0
|
||
? `That leaves you roughly ${plural(short, 'role')} short. Two ways to close it: screen the ${f.unscreened.length} unscored applicants, or source directly from the ${plural(f.profiles.length, 'profile')} in the talent pool.`
|
||
: 'That covers your open roles, assuming the strong candidates do not go elsewhere first.',
|
||
'',
|
||
'_Projected from your own conversion rate, not a promise — small pools move a lot._'
|
||
);
|
||
};
|
||
|
||
const departmentInsights = (f) => {
|
||
if (!f.byRole.length) return 'No open positions to break down.';
|
||
|
||
const byCategory = {};
|
||
f.byRole.forEach((r) => {
|
||
byCategory[r.category] ||= { applied: 0, hired: 0, qualified: 0, roles: [] };
|
||
byCategory[r.category].applied += r.applied;
|
||
byCategory[r.category].hired += r.hired;
|
||
byCategory[r.category].qualified += r.qualified;
|
||
byCategory[r.category].roles.push(r.title);
|
||
});
|
||
|
||
const entries = Object.entries(byCategory).sort((a, b) => b[1].applied - a[1].applied);
|
||
const starved = entries.filter(([, d]) => d.applied === 0);
|
||
|
||
return compose(
|
||
heading('By role category'),
|
||
'',
|
||
entries.map(([category, d]) =>
|
||
`**${category}** — ${plural(d.applied, 'applicant')}, ${d.qualified} at 70+, ${plural(d.hired, 'hire')} across ${plural(d.roles.length, 'role')}`
|
||
).join('\n'),
|
||
'',
|
||
starved.length
|
||
? `${starved.map(([c]) => c).join(' and ')} ${verb(starved.length, 'is', 'are')} attracting nobody. Compare the pay range against the categories that are filling.`
|
||
: 'Every category has applicants, so your reach is working across the board.'
|
||
);
|
||
};
|
||
|
||
const generateReports = (f) => {
|
||
const stamp = f.today.toISOString().slice(0, 10);
|
||
|
||
return compose(
|
||
heading(`Hiring report — ${stamp}`),
|
||
'',
|
||
heading('Volume'),
|
||
bullets([
|
||
`${plural(f.total, 'applicant')} received`,
|
||
`${f.screened.length} screened (${f.standardizedPct}% coverage)`,
|
||
`${plural(f.interviews.length, 'AI interview')} conducted, ${f.completedInterviews.length} scored`,
|
||
`${plural(f.hired.length, 'hire')} closed`,
|
||
]),
|
||
'',
|
||
heading('Quality'),
|
||
bullets([
|
||
`Average candidate score ${f.avgScore}`,
|
||
`Average hire score ${f.hiredAvgScore}`,
|
||
`Hire rate ${f.hireRate}%`,
|
||
`Average time-to-hire ${f.timeToHire ? `${f.timeToHire} days` : 'no baseline'}`,
|
||
]),
|
||
'',
|
||
heading('Efficiency'),
|
||
bullets([
|
||
`$${f.costSaved.toLocaleString()} saved against manual screening and interviewing`,
|
||
`≈${f.hoursSaved} recruiter hours returned`,
|
||
]),
|
||
'',
|
||
heading('By role'),
|
||
bullets(f.byRole.map((r) => `${r.title} — ${r.applied} applied, ${r.qualified} at 70+, ${r.hired} hired`)),
|
||
'',
|
||
f.bottleneck
|
||
? `**Headline finding.** The ${f.bottleneck.from} → ${f.bottleneck.to} step passes only ${f.bottleneck.rate}%, losing ${plural(f.bottleneck.lost, 'candidate')}. That is the single biggest recoverable loss in the funnel.`
|
||
: '**Headline finding.** The funnel is passing through evenly with no single bottleneck.',
|
||
'',
|
||
'_Copy this into your own template — export to PDF and CSV is not wired up in this build._'
|
||
);
|
||
};
|
||
|
||
/* ── Free-text responders ───────────────────────────────────────────────── */
|
||
|
||
const has = (q, ...words) => words.some((w) => q.includes(w));
|
||
|
||
const stateOfPlay = (f) =>
|
||
`I do not have a specific read on that. What I can see: ${plural(f.total, 'applicant')} across ${plural(f.openPositions.length, 'open position')}, ${f.screened.length} screened, ${plural(f.interviewing.length, 'candidate')} interviewing, ${plural(f.hired.length, 'hire')}. Ask about any of those and I will go deeper.`;
|
||
|
||
const bottleneckAnswer = (f) => {
|
||
if (!f.bottleneck) return 'Not enough pipeline movement yet to locate a bottleneck.';
|
||
const b = f.bottleneck;
|
||
const diagnosis = {
|
||
'AI Screened': `${plural(f.unscreened.length, 'applicant')} ${verb(f.unscreened.length, 'has', 'have')} never been scored — the cheapest gap in the funnel to close.`,
|
||
Shortlisted: 'Candidates are screened but not shortlisted. Either the scores are not being read, or the bar is above what the pool can deliver.',
|
||
Interviewed: 'Shortlisted candidates are not reaching interview — usually scheduling friction rather than a decision.',
|
||
Hired: 'Interviews happen but offers are not closing. Check pay against market and how long the decision takes.',
|
||
}[b.to];
|
||
|
||
return compose(
|
||
heading(`Bottleneck: ${b.from} → ${b.to}`),
|
||
`Only ${b.rate}% pass through, losing ${plural(b.lost, 'candidate')}.`,
|
||
'',
|
||
diagnosis || '',
|
||
'',
|
||
bullets(f.transitions.map((t) => `${t.from} → ${t.to}: ${t.rate}%${t.lost ? ` (−${t.lost})` : ''}`))
|
||
);
|
||
};
|
||
|
||
export const respondOverview = (question, f) => {
|
||
const q = question.toLowerCase();
|
||
if (has(q, 'risk', 'exposure', 'worry', 'concern')) return hiringRisks(f);
|
||
if (has(q, 'attention', 'urgent', 'priorit', 'pending', 'what should i', 'next')) return pendingActions(f);
|
||
if (has(q, 'health', 'how are we', 'how is hiring', 'doing')) return hiringHealth(f);
|
||
if (has(q, 'summary', 'today', 'brief', 'catch me up', 'overview')) return hiringSummary(f);
|
||
if (has(q, 'pipeline', 'funnel', 'stuck', 'bottleneck', 'drop')) return bottleneckAnswer(f);
|
||
if (has(q, 'position', 'posting', 'role', 'opening')) return departmentInsights(f);
|
||
return stateOfPlay(f);
|
||
};
|
||
|
||
export const respondCandidates = (question, f) => {
|
||
const q = question.toLowerCase();
|
||
if (has(q, 'resume', 'résumé', 'cv', 'analyse', 'analyze')) return resumeAnalysis(f);
|
||
if (has(q, 'compare', 'versus', ' vs ', 'between')) return candidateComparison(f);
|
||
if (has(q, 'question', 'ask them', 'interview prep')) return interviewQuestions(f);
|
||
if (has(q, 'gap', 'missing', 'weakness', 'skill')) return skillGapAnalysis(f);
|
||
if (has(q, 'recommend', 'should i hire', 'who should', 'shortlist', 'pass', 'interview next')) return hiringRecommendation(f);
|
||
if (has(q, 'unscreened', 'not screened', 'pending')) {
|
||
return f.unscreened.length
|
||
? compose(
|
||
heading(`${plural(f.unscreened.length, 'applicant')} unscreened`),
|
||
'',
|
||
bullets(f.unscreened.slice(0, 8).map((a) => `${a.applicant_name} — ${a.job_title}`)),
|
||
f.unscreened.length > 8 ? `…and ${f.unscreened.length - 8} more` : ''
|
||
)
|
||
: 'Everyone has been screened.';
|
||
}
|
||
return stateOfPlay(f);
|
||
};
|
||
|
||
export const respondAnalytics = (question, f) => {
|
||
const q = question.toLowerCase();
|
||
if (has(q, 'explain', 'what does', 'mean', 'chart', 'graph')) return explainCharts(f);
|
||
if (has(q, 'forecast', 'predict', 'projection', 'will i')) return forecastHiring(f);
|
||
if (has(q, 'department', 'category', 'role', 'team')) return departmentInsights(f);
|
||
if (has(q, 'report', 'export', 'summar', 'download')) return generateReports(f);
|
||
if (has(q, 'bottleneck', 'drop', 'stuck', 'funnel', 'lose')) return bottleneckAnswer(f);
|
||
if (has(q, 'hire rate', 'conversion')) {
|
||
return `${f.hireRate}% — ${plural(f.hired.length, 'hire')} from ${plural(f.total, 'applicant')}. Healthy for event staffing; the norm sits between 2% and 8% because most applicants are never properly screened.`;
|
||
}
|
||
if (has(q, 'cost', 'saved', 'roi', 'money')) {
|
||
return `$${f.costSaved.toLocaleString()} — ${plural(f.scored.length, 'AI screen')} at the $45 a manual screen costs, plus ${plural(f.interviews.length, 'automated interview')} at $80 each. Also about ${f.hoursSaved} recruiter hours you did not spend.`;
|
||
}
|
||
return stateOfPlay(f);
|
||
};
|
||
|
||
/* ── Capability manifests ───────────────────────────────────────────────── */
|
||
|
||
export const OVERVIEW_CAPABILITIES = [
|
||
{ id: 'hiring-summary', label: 'Hiring Summary', icon: Sparkles, run: hiringSummary },
|
||
{ id: 'hiring-health', label: 'Hiring Health', icon: HeartPulse, run: hiringHealth },
|
||
{ id: 'pending-actions', label: 'Pending Actions', icon: ListChecks, run: pendingActions },
|
||
{ id: 'hiring-risks', label: 'Hiring Risks', icon: AlertTriangle, run: hiringRisks },
|
||
];
|
||
|
||
export const CANDIDATE_CAPABILITIES = [
|
||
{ id: 'resume-analysis', label: 'Resume Analysis', icon: FileText, run: resumeAnalysis },
|
||
{ id: 'candidate-comparison', label: 'Candidate Comparison', icon: GitCompare, run: candidateComparison },
|
||
{ id: 'interview-questions', label: 'Interview Question Generator', icon: MessageSquareQuote, run: interviewQuestions },
|
||
{ id: 'skill-gap', label: 'Skill Gap Analysis', icon: Target, run: skillGapAnalysis },
|
||
{ id: 'hiring-recommendation', label: 'Hiring Recommendation', icon: ClipboardCheck, run: hiringRecommendation },
|
||
];
|
||
|
||
export const ANALYTICS_CAPABILITIES = [
|
||
{ id: 'explain-charts', label: 'Explain Charts', icon: BarChart3, run: explainCharts },
|
||
{ id: 'forecast-hiring', label: 'Forecast Hiring', icon: LineChart, run: forecastHiring },
|
||
{ id: 'department-insights', label: 'Department Insights', icon: Layers, run: departmentInsights },
|
||
{ id: 'generate-reports', label: 'Generate Reports', icon: FileSpreadsheet, run: generateReports },
|
||
];
|