Parse a CV file (PDF/DOCX/MD/TXT) into a validated JSON Resume, detected sections, a parse-confidence score, and warnings.

Decompose every highlight bullet in a CV into an XYZ scaffold.

For each highlight returns: detected verb, achievement object (X), metric-present flag (Y), method clause (Z), a fill-in template, and a prompt to request a real metric when Y is absent.

NEVER fabricates metrics — only asks the candidate for real data.

Flag quantified achievements, leadership claims, named project outcomes, certifications, and awards that should be backed by a verifiable artefact.

Returns only actionable claims (needs_evidence=True). Suggests the artefact type for each (dashboard link, repo URL, credential ID, reference contact, etc.). The host LLM asks the candidate to supply the actual link — never fabricated.

Parse a CV file then render ATS-safe export artifacts.

Produces:

• ats_docx: ATS-safe single-column DOCX (proven via parse_sim round-trip)

• styled_html: Self-contained styled HTML (no external assets)

• pdf: PDF rendered from styled HTML (best-effort; skipped if weasyprint missing)

• json_resume: Structured JSON Resume (.json)

• plain_text: Flat plain-text version (.txt)

Returns a Render model with:

• files: list of RenderFile(kind, path) — all absolute paths

• ats_safe_proof: dict of {ats_id → parsability_score} from live round-trip

• warnings: any non-fatal issues (e.g. pdf_skipped)

The ats_safe_proof proves the exported DOCX is machine-readable. All artifacts are written to out_dir (or a system temp dir if omitted).

Return the currently active market profile.

Set the active market profile (e.g. 'fr', 'us') and return it.

List available market profile ids.

Simulate how an ATS parses the CV file.

Analyses the raw file structure (columns, tables, header/footer contact, file size, text density) and applies the target ATS's quirks rules to compute a parsability score (0–100) and a list of breakages with fixes.

Scan a parsed CV for content red flags.

Implements all red-flag checks from data/redflags.yaml: passive voice, duty bullets without metric/strong verb, employment gaps, job-hopping, banned buzzwords, year-only dates, unprofessional email, wrong photo for market, AI-generic phrasing, no quantification.

Build a screener simulation kit for Claude.

Produces the plain text the machine sees after ATS parsing, a fixed scoring rubric, and deterministic keyword requirements extracted from the offer. Claude then plays the AI screener on this exact text.

Generate a before/after score report.

Combines the parsability score, optional match score, and redflag count into a ScoreReport with screener_readiness tier and optional delta.

Detect adversarial tactics embedded in a submitted CV (spec §2).

Scans the CV file for three classes of adversarial content:

1. prompt_injection (CRITICAL): screener-directed imperatives in the text (EN + FR) designed to manipulate AI screeners.

2. hidden_text (CRITICAL): near-invisible text via white/near-white colour or sub-4pt font size (PDF and DOCX).

3. keyword_stuffing (HIGH): anomalous token or line repetition designed to game keyword-match scoring.

This tool ONLY detects adversarial content — it never produces it.

Compute a skill-coverage match score between a CV file and a job offer.

Remove duplicate job postings from a list.

Uses SHA-256 blocking on normalised company|city|title, then within each block merges postings where token_set_ratio(title) ≥ 85 AND dates are within ±14 calendar days (or absent). Keeps the most-complete posting.

Return the top-N offer keywords not covered by the CV, ranked by salience.

Each gap is classified as:

• "addable_honestly": term or synonym appears anywhere in CV text.

• "genuinely_missing": no trace in the CV at all.

Estimate application success probability deterministically.

Combines fit_score with recency, competition proxy, optional network proximity, and optional applicant count into a single 0–100 score with per-factor breakdown.

Unknown signals default to neutral and are flagged in notes — never fabricated.

Derive company intelligence from job postings + produce research checklist.

Only asserts facts derivable from the provided postings (open_roles_count, locations, remote_ratio, tech_tags). Everything else (Glassdoor rating, funding, layoff signals, visa sponsorship) is placed in a research_checklist with status "to_research" — never fabricated.

Fetch all live jobs from a Greenhouse job board (no auth required).

Fetch all published postings from a Lever company page (no auth required).

Fetch all listed jobs from an Ashby job board (no auth required).

Fetch all open offers from a Recruitee company page (no auth required).

Fetch all published jobs from a Workable account (no auth required for public listings).

Fetch all public postings from SmartRecruiters Posting API (no auth required).

Fetch all remote jobs from RemoteOK API (no auth required; attribution: remoteok.com).

Returns: SourceResult with all normalised job postings.

Fetch remote jobs from Remotive API, optionally filtered by search query.

Fetch all jobs from the Arbeitnow public job board (no auth required).

Returns: SourceResult with all normalised job postings.

Fetch jobs from France Travail (Pôle Emploi) API v2.

Requires env: FRANCE_TRAVAIL_ID, FRANCE_TRAVAIL_SECRET

Fetch jobs from Adzuna (19 countries).

Requires env: ADZUNA_APP_ID, ADZUNA_APP_KEY

Fetch jobs from JSearch (RapidAPI) — aggregates LinkedIn/Indeed/Glassdoor legally.

Requires env: JSEARCH_RAPIDAPI_KEY

Fetch US federal jobs from USAJobs.gov.

Requires env: USAJOBS_KEY, USAJOBS_EMAIL

Fetch UK jobs from Reed.co.uk.

Requires env: REED_KEY

Fetch jobs from The Muse.

Optional env: THEMUSE_KEY (works without key but rate-limited).

Fetch jobs from Jooble international aggregator.

Requires env: JOOBLE_KEY

Fetch companies likely to hire from La Bonne Boîte (hidden job market).

La Bonne Boîte surfaces companies likely to recruit in a given ROME code and commune, even when they have published no formal job offer. Each result is a JobPosting with a (marché caché) title prefix.

Requires env: FRANCE_TRAVAIL_ID, FRANCE_TRAVAIL_SECRET Scope: api_labonneboitev1 (partner must subscribe in the FT developer portal)

NOTE: scope acceptance requires partner subscription to the La Bonne Boîte product. Live verification of the endpoint and scope is needed before production use — see project report.

Fetch jobs from Careerjet public API (international job aggregator).

Optional env: CAREERJET_AFFID — affiliate ID for higher rate limits. Works without it in some locales (reduced results possible).

Fetch and aggregate jobs from multiple keyless providers concurrently.

Network failures per provider are silently dropped (not raised).

Returns: Flat list of all collected JobPosting objects across all providers.

Search across the maximum number of job sources for maximum breadth.

Fans out across all boards in the built-in known_boards.yaml registry (greenhouse/lever/ashby/recruitee tokens) plus optionally any keyed providers whose env vars are set (france_travail/adzuna/jsearch).

Results are deduplicated, query-filtered, and sorted by date descending.

Take a snapshot of current job postings for a keyless provider.

Writes a JSON file containing the list of current source_ids to out_path. Use monitor_diff later to detect new postings.

Detect new job postings since a previous snapshot.

Fetches current postings for the provider+key and compares source_ids against the previously saved snapshot at prev_path.

Parse a user-pasted text block to identify a recruiter.

Operates ONLY on the provided text — never fetches any URL. Accepts LinkedIn profile text copy-pasted by the user, email signatures, or company "team" page text.

Score a recruiter's fit against a target job/company context.

Find or guess a recruiter's email.

If DROPCONTACT_KEY env var is set, calls Dropcontact API (CNIL-audited). Otherwise generates a pattern guess (status="guessed_unverified"). Status "verified" is ONLY set when Dropcontact confirms.

Draft an outreach message scaffold for a recruiter.

French drafts include a mandatory RGPD opt-out line.

Persist a recruiter+contact record to a local JSON store.

Records are always tagged pii=true with retention_max_years=3 (CNIL).

Find warm introduction paths to a target company.

Operates ONLY on the user-provided connections list. NO LinkedIn traversal, NO external lookups.

Score the intro value of a NetworkPath (0–1).

Draft an introduction request scaffold.

French drafts include a mandatory opt-out line.

Resolve the best apply URL and channel for a job posting.

Implements the apply-at-source principle: candidates apply at the employer's own ATS, never via LinkedIn/Indeed/Glassdoor aggregator pages.

No network calls are made.

Build a PrefillPlan by mapping resume data to common ATS form fields.

Sensitive fields (password, card, SSN, IBAN, DOB) are NEVER in fields. They are listed in excluded_sensitive for auditability.

Add or replace a QueueItem in the batch-apply queue.

If an item with the same job_id already exists it is replaced.

Return all items in the batch-apply queue.

Approve a batch of queue items (prepared → approved).

Draft a polite follow-up message scaffold for an application.

Sending is always human-confirmed (Phase 4b). No network calls.

Preview or perform ONE browser step on an employer ATS form.

SAFETY RULES enforced in code (non-negotiable):

• classify_sensitive_field() is called BEFORE any fill().

• is_payment_url() blocks the step if the URL is a payment page.

• is_login_context() blocks the step if a login wall is detected.

• confirm=False (default) returns a preview with requires_confirm=True. Only confirm=True actually performs the step.

• NEVER auto-fills passwords, card numbers, CVC/CVV, IBAN, SSN, 2FA.

apply-at-source: use only on employer ATS pages, never on LinkedIn/Indeed.

Build an honest cover-letter scaffold from a CV file and a job posting.

HONESTY: why_me bullets come ONLY from the candidate's real CV. why_them is a clearly-marked [à compléter: …] placeholder — the host LLM fills it using actual company research. Nothing is invented.

No network calls. Deterministic.

Answer a screening question factually from the CV, or flag needs_human.

HONESTY rules (non-negotiable):

• Work authorization / visa / sponsorship → needs_human=True, answer=None.

• Salary expectations → needs_human=True, answer=None.

• Relocation / notice / availability / start date → needs_human=True.

• "Why this company/role" → needs_human=True.

• Unknown questions → needs_human=True. Only factual, derivable answers are returned with source="derived_from_cv".

No network calls. Deterministic.

Submit ATS applications for approved queue items via the user's own Chrome.

SAFETY RULES enforced in code (non-negotiable):

• ONLY items with status=="approved" are attempted (queue_approve first).

• is_payment_url() → item stopped, never submitted.

• is_login_context() → item stopped as "needs_manual_login".

• classify_sensitive_field() on any prefill field → item skipped.

• confirm_send=False (default) → dry-run, nothing submitted. Only confirm_send=True actually submits.

Track (insert or update) an Application in the CRM.

Transition an Application to a new stage.

Appends a history entry with timestamp (and optional note).

Return all tracked Applications, optionally filtered by stage.

Compute conversion funnel statistics over a list of Applications.

Compute interview and offer rates by source_channel.

Report which competencies have at least one story and which are gaps.

Compare an offer amount to benchmark P50 and P75.

Build a structured research scaffold for interview preparation.

PURE — no network, no LLM. Returns a CompanyBrief with [TO_RESEARCH] placeholders and a research checklist to fill before the interview.

Add a STAR+E story to the local JSON story bank.

Validates STAR structure (situation, task, action, result must be non-empty). Raises ValueError if validation fails.

Return stories that cover a given competency (partial/case-insensitive match).

Return interview questions for a role family and kind.

Evaluate a mock interview answer deterministically.

Checks STAR structure, quantification, I/we ratio, duration (~130 wpm), and returns a scored MockEval with feedback.

Generate a post-interview thank-you message scaffold.

Generate a post-interview debrief Markdown template.

Return a sourced salary benchmark for a role/seniority/region.

Uses the bundled salary_benchmarks.yaml dataset. Returns the closest match with approximate=True and a note if an exact match is absent.

Build a counter-offer message scaffold (FR or EN register).

Compute annualised total compensation breakdown.

Generate a competing-offer negotiation script.