CLI command reference¶
Auto-generated from zero ... --help. For agent workflows and MCP usage, see
MCP connector docs and
SKILL.md.
zero¶
Usage: zero [OPTIONS] COMMAND [ARGS]...
Zero Hiring — AI-powered candidate screening.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --version -v Show version and exit. │
│ --quiet Suppress spinners and progress output. │
│ --json Emit machine-readable JSON on stdout. Human prose (progress, prompts, banners) is routed to stderr. Errors become {"error": {"code": ..., "message": ...}} on stdout │
│ with non-zero exit. │
│ --envelope Wrap --json output as {"schema_version": "1", "data": ...}. Off by default for backward compat with consumers that expect bare arrays/objects. │
│ --install-completion Install completion for the current shell. │
│ --show-completion Show completion for the current shell, to copy it or customize the installation. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ login Log in or sign up. Uses device code flow by default. │
│ whoami Show current login status. │
│ help Show this help message and exit (alias for `--help`). │
│ logout Log out: revoke the CLI token server-side, then remove local credentials. │
│ update Download the latest standalone CLI binary into ~/.zerohiring/bin/zero. │
│ hire Open a new role. │
│ status Check your jobs and pipeline. │
│ candidates View candidates for a job. │
│ invite Invite candidates for AI interviews. │
│ results View interview results. │
│ offers Inspect and manage offer letters. │
│ close Legacy alias for sending a candidate offer. │
│ team Manage team members. │
│ demo Demo mode — simulate the hiring pipeline. │
│ jobs List and switch between jobs. │
│ billing View billing and spend. │
│ clients Manage RPO clients. │
│ outreach Multi-step candidate outreach sequences. │
│ sourcing Search sourced candidates and add them to jobs. │
│ pipeline Run and inspect end-to-end hiring pipeline runs. │
│ payments Refund charges (approval-gated). │
│ interviews Schedule and manage human (hiring-manager) interviews. │
│ hiring-flow Configure the hiring pipeline stages (stage plan) for a role. │
│ changelog See what's new on the platform. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
billing¶
Usage: zero billing [OPTIONS] COMMAND [ARGS]...
View billing and spend.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ docs Print local billing command and spend-safety notes. │
│ show One-screen view of spend across all your jobs. │
│ costs Line-itemized per-tenant vendor cost sheet for one calendar month. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
billing costs¶
Usage: zero billing costs [OPTIONS]
Line-itemized per-tenant vendor cost sheet for one calendar month.
Joins sourcing usage, interview vendor costs, an agent-inference cost
placeholder, and payment charges into one call (ZER-668) -- no manual
joining of separate usage/billing endpoints required.
This hits an admin-only endpoint gated by the shared backend system key,
not a regular per-employer `zero login` token: it can read any tenant's
spend, not just the caller's own employer. Configure
ZEROHIRING_API_KEY to the system key when running this as an internal
tool. Cost lines with no configured $ rate (sourcing, agent inference)
come back as `cost_usd: null` with an explanatory note rather than being
silently omitted -- see `cost_note` / `note` fields in --json output.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected if not passed) │
│ * --month <str> Calendar month to report on, YYYY-MM (e.g. 2026-06) [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
billing docs¶
Usage: zero billing docs [OPTIONS]
Print local billing command and spend-safety notes.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
billing show¶
Usage: zero billing show [OPTIONS]
One-screen view of spend across all your jobs.
Shows charged open/close fees per job plus employer totals, pulled from
the `job_payments` ledger. If the employer hasn't paid anything
yet, the backend returns `source=estimate` and we print a banner so
the user isn't misled into thinking we have real billing data.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates¶
Usage: zero candidates [OPTIONS] COMMAND [ARGS]...
View candidates for a job.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List all candidates for a job with scores and rankings. │
│ search Search ALL of the employer's candidates across every job and integration. │
│ detail Show detailed info for a specific candidate, including full parsed │
│ resume (contact, experience, education, skills, languages, certs) and │
│ the excerpts that explain the candidate's ranking. │
│ reject Reject a candidate. │
│ discard Discard a sourced candidate from active sourcing and stop outreach. │
│ export Export everything on file for a candidate (GDPR Art. 15 / 20). │
│ delete Erase ALL personal data for a candidate (GDPR Art. 17 right to erasure). │
│ hire Send an offer. Candidate signature triggers hired status and billing. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates delete¶
Usage: zero candidates delete [OPTIONS] {applicant_id}
Erase ALL personal data for a candidate (GDPR Art. 17 right to erasure).
IRREVERSIBLE. Deletes the applicant together with their applications,
interviews, transcripts, recordings, and derived embeddings across every
store. There is no undo and no soft-delete — unlike `jobs delete`, this
is a hard erasure intended to satisfy a right-to-be-forgotten request.
Requires the explicit `--confirm` flag; without it the command refuses to
act.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * applicant_id <str> Applicant UUID to erase (the `applicant_id` field from `candidates detail --json`). [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --confirm Required. Confirms the IRREVERSIBLE erasure of all data for this candidate. │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates detail¶
Usage: zero candidates detail [OPTIONS] [candidate_number]
Show detailed info for a specific candidate, including full parsed resume (contact, experience, education, skills, languages, certs) and the excerpts that explain the candidate's ranking.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ candidate_number <str> Candidate number (1-based) or application UUID │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates discard¶
Usage: zero candidates discard [OPTIONS] {candidate_ref}
Discard a sourced candidate from active sourcing and stop outreach.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * candidate_ref <str> Candidate name, email, number, or application UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> Optional note stored on the discarded sourced application. │
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --yes -y Skip the confirmation prompt │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates export¶
Usage: zero candidates export [OPTIONS] {applicant_id}
Export everything on file for a candidate (GDPR Art. 15 / 20).
Produces a machine-readable subject-access / portability bundle for one
applicant: identity, applications, interviews, transcripts, scores, and
resume references. Use this to fulfil a data-subject access or portability
request.
The bundle contains sensitive candidate PII. Write it to a secure location,
hand only the relevant subset to the requesting data subject, and delete
your local copy once the request is fulfilled — do not leave export files
lying around or paste them into an LLM context you don't control.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * applicant_id <str> Applicant UUID (the `applicant_id` field from `candidates detail --json`). [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --output -o <str> Write the export bundle to this file instead of stdout. │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates hire¶
Usage: zero candidates hire [OPTIONS] {candidate_ref}
Send an offer. Candidate signature triggers hired status and billing.
Refused with HTTP 409 (code `hire_requires_candidate_contact`) if
there is no recorded evidence this candidate has ever engaged with us
(no direct application, no reply to outreach, no interview they
engaged with) -- a deliberate backend guard, not a transient error.
There is no flag to override it; contact must be recorded first.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * candidate_ref <str> Candidate number (from 'zero candidates list') or application UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --expect-id <str> Assert the resolved job matches this UUID or short ID │
│ --expect-title <str> Assert the resolved job's title contains this substring (case-insensitive) │
│ --idempotency-key <str> Retry key retained for backward compatibility; offer signing triggers billing. │
│ --compensation <str> Offer compensation text │
│ --start-date <str> Offer start date │
│ --location <str> Offer work location │
│ --employment-type <str> Offer employment type │
│ --notes <str> Additional offer notes │
│ --force Allow sending an offer even when another offer for this role is still in flight. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates list¶
Usage: zero candidates list [OPTIONS] [job_id]
List all candidates for a job with scores and rankings.
By default prints one compact line per candidate. Pass `--resume` to
also render each candidate's full parsed resume inline — useful when
you want to evaluate the pool in a single call instead of running
`candidates detail` N times. `--json` always returns parsed data
regardless of `--resume`.
Power-user flags (`--min-score`, `--max-score`, `--skill`, `--search`,
`--sort`, `--order`, `--limit`) are applied client-side over the full
payload so you can pipe `--json` through jq if you need something more
specific than these flags offer.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --resume -r Include full parsed resume data for each candidate (contact, experience, education, skills, excerpts). │
│ --min-score <float> Only show candidates with score >= N. │
│ --max-score <float> Only show candidates with score <= N. │
│ --skill <str> Case-insensitive substring match against resume summary + excerpts (repeatable; all must match). │
│ --search <str> Case-insensitive substring match over name + summary + excerpts. │
│ --sort <str> Sort by: score | name | applied_at. │
│ --order <str> Sort order: asc | desc (default: desc). [default: desc] │
│ --limit <int> Maximum number of candidates to show (applied after filters+sort). │
│ --json Raw JSON output (always includes parsed_resume and relevant_resume_excerpts) │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates reject¶
Usage: zero candidates reject [OPTIONS] {candidate_ref}
Reject a candidate.
Sets the application's status to `rejected`. The optional `--reason`
is persisted to `applications.rejection_reason` for audit purposes.
This is a per-candidate action. Hiring another candidate does not
automatically reject the rest of the pool.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * candidate_ref <str> Candidate number (from 'zero candidates list') or application UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> Reason for rejection (persisted to applications.rejection_reason for audit). │
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --yes -y Skip the confirmation prompt │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
candidates search¶
Usage: zero candidates search [OPTIONS] {query}
Search ALL of the employer's candidates across every job and integration.
Unlike `candidates list`, which is scoped to one job, this searches the
employer's entire candidate pool (applied, sourced, and ATS-synced) by
name, email, title, skills, and resume content. The backend runs a
hybrid semantic + keyword search server-side (the query embedding
happens on the backend) -- this command only forwards the free text.
There is no `--employer-id` flag on this command and none is ever sent
to the backend: the employer scope is derived entirely from the
authenticated CLI token (`require_employer_access` pins CLI callers to
their own employer).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * query <str> Free-text search over name, email, title, skills, and resume content. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --source <str> Filter by source: applied | sourced | ats. │
│ --page <int> Page number. [default: 1] │
│ --limit <int> Results per page (max 100). [default: 20] │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
changelog¶
Usage: zero changelog [OPTIONS] COMMAND [ARGS]...
See what's new on the platform.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ show Show recent releases, merged across the whole platform (backend + client). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
changelog show¶
Usage: zero changelog show [OPTIONS]
Show recent releases, merged across the whole platform (backend + client).
Always reads the live merged feed from `GET /api/v1/changelog` at call
time -- this deliberately has no local cache and no snapshot baked into
a prompt or SKILL.md, because the release cadence would make either one
stale within a day. Do NOT filter on a release's `highlight` field: it
only controls whether the in-app "What's New" modal auto-opens, not
whether the release shipped -- 93 of 102 backend releases are
`highlight: false`, so filtering on it would hide nearly everything.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --since <str> ISO date (e.g. 2026-07-01). Keep releases dated on/after this day. │
│ --limit <int> Max number of releases to return, most recent first. [default: 10] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients¶
Usage: zero clients [OPTIONS] COMMAND [ARGS]...
Manage RPO clients.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List all RPO clients for the current employer. │
│ add Add a new RPO client. │
│ show Show details for a single RPO client. │
│ remove Remove an RPO client (soft delete). │
│ profile Read the caller's OWN saved company profile. Writes nothing. │
│ generate-company-info Draft a company description/FAQ text (`company_information`) from a │
│ website. Makes no write -- this only generates; save the result with │
│ `confirm-company-profile --company-information`. │
│ propose-company-profile Preview a company profile before saving it. │
│ confirm-company-profile Save the company profile staged by propose-company-profile. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients add¶
Usage: zero clients add [OPTIONS]
Add a new RPO client.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --name <str> Client company name [required] │
│ --email <str> Client contact email │
│ --website <str> Client website URL │
│ --company-info <str> Company background / information for AI context │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients confirm-company-profile¶
Usage: zero clients confirm-company-profile [OPTIONS]
Save the company profile staged by propose-company-profile.
Call this only immediately after propose-company-profile and an
explicit, unambiguous yes to the previewed values, in the same
conversation turn. The backend resolves the employer from the caller's
own identity (X-User-Id) -- there is no --employer-id flag here and
none should be added; this command only ever writes the caller's own
company profile, never another employer's.
A verbal "yeah, that's right" from the operator is not itself a save --
the write only happens when this call actually executes and succeeds.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --company-name <str> Company name to save [required] │
│ * --website-url <str> Company website URL to save [required] │
│ --company-information <str> Company description/FAQ text (what the AI interviewer uses to answer candidate questions about the company). Optional and independent of the name/website │
│ propose-then-confirm discipline above -- this is Zero's own read of public content (see `generate-company-info`), not something the operator dictates word │
│ for word, so it doesn't need the same exact-preview confirmation. Omit it to leave company_information untouched. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients generate-company-info¶
Usage: zero clients generate-company-info [OPTIONS]
Draft a company description/FAQ text (`company_information`) from a website. Makes no write -- this only generates; save the result with `confirm-company-profile --company-information`.
Scrapes the given URL and runs it through the hosted generator (the
same one the employer dashboard's onboarding wizard uses). Best-effort:
a thin wrapper, no local fallback if the backend call fails.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --website-url <str> Company website URL to generate a description from [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients list¶
Usage: zero clients list [OPTIONS]
List all RPO clients for the current employer.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients profile¶
Usage: zero clients profile [OPTIONS]
Read the caller's OWN saved company profile. Writes nothing.
ZER-2462/ZER-2463: never ask the operator to (re)supply a company name,
website, or description before checking whether it's already on file --
that is the same "asking for a value you can already read" mistake as
inviting a candidate whose email is already on the application record.
Call this first, every time first contact comes up (including on a
later, separate conversation with the same employer): only ask for, or
regenerate, whatever comes back empty.
Implemented as a PATCH to `/api/clients/company-profile` with an empty
body. The backend documents this as a deliberate no-op read (a caller
with no fields to change still gets the current row back, no special
case needed) -- so this never writes and never touches `updated_at`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients propose-company-profile¶
Usage: zero clients propose-company-profile [OPTIONS]
Preview a company profile before saving it.
Makes no backend call and saves nothing. Show this preview to the
operator once, in your own words, and get an explicit yes before
calling confirm-company-profile. Don't restate values you already
showed them earlier in the same reply -- this command only echoes
back what you passed in.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --company-name <str> Company name to preview [required] │
│ * --website-url <str> Company website URL to preview [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients remove¶
Usage: zero clients remove [OPTIONS] {client_id}
Remove an RPO client (soft delete).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * client_id <str> Client UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --yes -y Skip confirmation │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
clients show¶
Usage: zero clients show [OPTIONS] {client_id}
Show details for a single RPO client.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * client_id <str> Client UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
close¶
Usage: zero close [OPTIONS] COMMAND [ARGS]...
Legacy alias for sending a candidate offer.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ run Send an offer. Candidate signature triggers hired status and billing. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
close run¶
Usage: zero close run [OPTIONS] [job_id]
Send an offer. Candidate signature triggers hired status and billing.
Refused with HTTP 409 (code `hire_requires_candidate_contact`) if
there is no recorded evidence this candidate has ever engaged with us
(no direct application, no reply to outreach, no interview they
engaged with) -- a deliberate backend guard, not a transient error.
There is no flag to override it; contact must be recorded first.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --candidate <str> Candidate number (1-based) or application UUID │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --expect-id <str> Assert the resolved job matches this UUID or short ID │
│ --expect-title <str> Assert the resolved job's title contains this substring (case-insensitive) │
│ --idempotency-key <str> Retry key retained for backward compatibility; offer signing triggers billing. │
│ --compensation <str> Offer compensation text │
│ --start-date <str> Offer start date │
│ --location <str> Offer work location │
│ --employment-type <str> Offer employment type │
│ --notes <str> Additional offer notes │
│ --force Allow sending an offer even when another offer for this role is still in flight. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo¶
Usage: zero demo [OPTIONS] COMMAND [ARGS]...
Demo mode — simulate the hiring pipeline.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --keep Retain the demo job instead of soft-deleting it. │
│ --title <str> Title for the demo job. [default: Demo Role [auto]] │
│ --employer-id <str> Employer UUID to run the demo under (defaults to your logged-in employer). Lets an admin-authed session drive a freshly provisioned org without changing the local │
│ login. │
│ --json Emit a structured JSON result. │
│ --quiet Suppress spinner output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ run Run a full demo: create job → seed candidates → simulate interviews → summary. │
│ seed Seed a job with demo candidates (resumes only, no interviews yet). │
│ interviews Simulate AI interviews for demo candidates in a job. │
│ populate Realistically populate a job's demo pipeline in one call. │
│ mode Turn demo tenant mode on or off for an employer. │
│ login Manage a demo org's shareable login (ZER-1192). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo interviews¶
Usage: zero demo interviews [OPTIONS] [job_id]
Simulate AI interviews for demo candidates in a job.
Interviews every seeded candidate by default. Pass one or more
``--application-ids`` to interview only a subset, leaving the rest at
"applied" — combine with ``zero candidates reject`` on a couple of the
interviewed candidates to get a realistic mix of applied / interviewed
/ rejected stages rather than a pipeline where everyone ends up
interviewed.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --application-ids <str> Application UUID(s) to interview (repeat the flag for multiple). Omit to interview every seeded candidate for the job. Use this to leave some candidates at │
│ 'applied' for a realistic pipeline-stage spread (ZER-1216) instead of every seeded candidate ending up interviewed — get UUIDs from 'zero candidates list <job_id>'. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo login¶
Usage: zero demo login [OPTIONS] COMMAND [ARGS]...
Manage a demo org's shareable login (ZER-1192).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ create Mint (or rotate) a ready-to-use employer-owner login for a demo tenant. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo login create¶
Usage: zero demo login create [OPTIONS]
Mint (or rotate) a ready-to-use employer-owner login for a demo tenant.
Returns generated ``{email, password, login_url}`` credentials that can be
handed directly to a customer -- no team invite, no email verification
click-through, no onboarding wizard. Only works for employers flagged
``is_demo=true`` (400 otherwise). Safe to call again for the same
employer: it rotates the password on the existing minted login instead
of creating a second account.
Distinct from ``team invite`` (ZER-1185), which stays the way to add
*named* internal people (presenters, sales) to a demo org -- this mints
the single generic login that becomes the customer handoff.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Demo employer UUID to mint (or rotate) a login for (defaults to your logged-in employer). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo mode¶
Usage: zero demo mode [OPTIONS] [on|off]
Turn demo tenant mode on or off for an employer.
Demo mode suppresses charges, cold outreach, and real sourcing
for this employer. It never deletes data: seeded/demo rows created while
demo mode was on stay permanently excluded from analytics and billing via
their own row markers, even after this is turned off.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * [on|off] <str> Target state: 'on' or 'off'. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID to toggle (defaults to your logged-in employer). Lets an admin-authed session flip demo mode on a freshly provisioned org. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo populate¶
Usage: zero demo populate [OPTIONS] {job_id}
Realistically populate a job's demo pipeline in one call.
Unlike ``demo seed`` (always exactly 5 candidates, no-op on repeat
calls), this asks the backend to build out a fuller, more
realistic-looking pipeline -- candidates across stages, scores, and
interview activity -- sized by ``--scale``.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID to populate with a demo pipeline. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --scale <str> Populate scale: one of auto, high, mid, senior. [default: auto] │
│ --json Raw JSON output │
│ --quiet Suppress spinner output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo run¶
Usage: zero demo run [OPTIONS]
Run a full demo: create job → seed candidates → simulate interviews → summary.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --keep Retain the demo job instead of soft-deleting it. │
│ --title <str> Title for the demo job. [default: Demo Role [auto]] │
│ --employer-id <str> Employer UUID to run the demo under (defaults to your logged-in employer). Lets an admin-authed session drive a freshly provisioned org without changing the local │
│ login. │
│ --json Emit a structured JSON result. │
│ --quiet Suppress spinner output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
demo seed¶
Usage: zero demo seed [OPTIONS] [job_id]
Seed a job with demo candidates (resumes only, no interviews yet).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
help¶
Usage: zero help [OPTIONS]
Show this help message and exit (alias for `--help`).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hire¶
Usage: zero hire [OPTIONS] COMMAND [ARGS]...
Open a new role.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ run Open a new role — guided flow with AI and payment. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hire run¶
Usage: zero hire run [OPTIONS]
Open a new role — guided flow with AI and payment.
Power-user flags (`--salary`, `--remote`, `--skills`, `--seniority`,
`--experience-years`, `--tags`) and `--description` are passed as
source material to the backend JD generator. `--use-description-as-jd`
preserves only already-formatted HTML JDs; plain text is still formatted
with AI.
`--remote` also sets the structured `is_remote` field, and
`--location-street/-locality/-region/-postal-code/-country` and
`--salary-min/-max/-currency/-period` (ZER-1083 phase 2) feed the
structured Google-for-Jobs fields on the created job. The four salary
flags are required to actually open a role (ZER-2420): interactive runs
prompt for them, and `--yes`/`--json` runs must pass all four or the
command errors before creating anything. The location flags stay
optional, but for non-remote roles, once any of them is set the backend
requires country plus locality-or-region (422 otherwise). In interactive
mode (no `--yes`), the guided flow prompts for these after asking whether
the role is remote.
`--stage-plan-json` threads an approved hiring flow (see `hiring-flow
draft`/`hiring-flow show`) into job creation atomically; its
resume_assessment stage governs the job's auto-invite threshold. Omit
it to get the backend's default plan, or set/change it afterwards with
`hiring-flow set <job_id>`.
`--dry-run` generates the JD (when one isn't supplied) and prints the
job payload as JSON without creating a payable job. It does not trigger
payment and does not POST to `/api/jobs`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --title -t <str> Job title │
│ --description -d <str> Hiring brief or source notes for the AI-generated JD. Use --use-description-as-jd only for an already-formatted final JD. │
│ --location -l <str> Job location (e.g. 'Remote, US') │
│ --employment-type <str> Employment type (e.g. 'Full-time') │
│ --salary <str> Salary or salary range (e.g. '$150k-$180k'). │
│ --remote --no-remote Flag the role as fully remote. Feeds the JD generator and also sets the structured is_remote field (Google for Jobs jobLocationType: │
│ TELECOMMUTE), skipping the physical-address prompt below. Prompts interactively if omitted (defaults to false with --yes). │
│ --location-street <str> Street address. Always optional. │
│ --location-locality <str> City/locality for the structured public listing. For non-remote roles, required (with --location-country) once any structured location field is │
│ set, unless --location-region is given instead. │
│ --location-region <str> State/region/province. May substitute for --location-locality. │
│ --location-postal-code <str> Postal/ZIP code. Always optional. │
│ --location-country <str> Two-letter ISO 3166-1 country code (e.g. 'US'). For non-remote roles, required together with --location-locality or --location-region once any │
│ structured location field is set. │
│ --salary-min <float> Structured minimum base salary for the public listing (distinct from --salary's freeform text). Required to open a role (ZER-2420): │
│ --salary-min, --salary-max, --salary-currency and --salary-period must all be set. Interactive runs prompt for them; with --yes/--json, pass │
│ all four. Use `zero internal ai suggest-salary` during intake if the operator has no range in mind. │
│ --salary-max <float> Structured maximum base salary. Must be >= --salary-min. Required to open a role (ZER-2420): --salary-min, --salary-max, --salary-currency and │
│ --salary-period must all be set. Interactive runs prompt for them; with --yes/--json, pass all four. Use `zero internal ai suggest-salary` │
│ during intake if the operator has no range in mind. │
│ --salary-currency <str> Three-letter ISO 4217 currency code (e.g. 'USD'). Required to open a role (ZER-2420): --salary-min, --salary-max, --salary-currency and │
│ --salary-period must all be set. Interactive runs prompt for them; with --yes/--json, pass all four. Use `zero internal ai suggest-salary` │
│ during intake if the operator has no range in mind. │
│ --salary-period <str> Pay period: one of YEAR, MONTH, WEEK, DAY, HOUR. Required to open a role (ZER-2420): --salary-min, --salary-max, --salary-currency and │
│ --salary-period must all be set. Interactive runs prompt for them; with --yes/--json, pass all four. Use `zero internal ai suggest-salary` │
│ during intake if the operator has no range in mind. │
│ --skills <str> Comma-separated list of required skills. │
│ --seniority <str> Seniority level (e.g. 'Senior', 'Staff'). │
│ --experience-years <int> Minimum years of experience. │
│ --tags <str> Comma-separated freeform tags. │
│ --client-id <str> RPO client UUID to create this role under. │
│ --role-summary-json <str> Structured role intake as a JSON object (must include 'title'). Threaded into both JD generation and job creation so the JD, the job, and any │
│ pipeline brief trace back to the same confirmed intake. Assemble this from the operator's answers before opening the role. │
│ --stage-plan-json <str> Approved hiring flow (stage plan) to persist atomically with the job -- either a bare JSON array of stage objects, or a full {"stages": [...], │
│ "source": "..."} object, e.g. the output of `hiring-flow draft` (optionally edited). Its resume_assessment stage governs the job's auto-invite │
│ threshold. Optional; omit to get the backend's default plan (or set/change it later with `hiring-flow set`). │
│ --dry-run Generate the JD and return JSON without creating a payable job. │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --skip-payment Skip payment (for testing) │
│ --yes -y Auto-confirm all prompts (non-interactive) │
│ --demo Demo/testing shortcut: implies --skip-payment --yes │
│ --force Create the job even if a recent active job with the same title exists. │
│ --yes-duplicate Skip the duplicate-title check entirely (implied by --force). │
│ --idempotency-key <str> Retry key for safe role-open payment creation. │
│ --use-description-as-jd Preserve --description directly only when it is already a polished HTML JD. Plain text is still formatted with AI. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hiring-flow¶
Usage: zero hiring-flow [OPTIONS] COMMAND [ARGS]...
Configure the hiring pipeline stages (stage plan) for a role.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ show Show the saved hiring flow (stage plan) for a job. │
│ draft Draft a stage plan with AI. Stateless -- does not save anything. │
│ set Save the hiring flow (stage plan) for a job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hiring-flow draft¶
Usage: zero hiring-flow draft [OPTIONS]
Draft a stage plan with AI. Stateless -- does not save anything.
Present the draft to the operator (stages + rationales; note it is
fully automated by default) before saving it with `hiring-flow set`
or threading it into `hire run --stage-plan-json`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --role-summary-json <str> Structured role intake as a JSON object (must include 'title'), same shape as `hire run --role-summary-json`. Tailors the draft; omit for the fully-automated │
│ smart default. │
│ --job-title <str> Job title, used when no --role-summary-json is given. │
│ --feedback <str> Freeform feedback to steer the draft (e.g. after showing a prior draft to the operator). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hiring-flow set¶
Usage: zero hiring-flow set [OPTIONS] {job_id}
Save the hiring flow (stage plan) for a job.
Enabling the resume_assessment stage syncs its `config.threshold` into
the job's real auto-invite gate; disabling it sets the gate to 0.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --stages-json <str> Either a bare JSON array of stage objects, or a full {"stages": [...], "source": "...", "reference_check": {...}} object (e.g. an edited `hiring-flow draft` │
│ output). │
│ [required] │
│ --source <str> Plan source: ai, manual, or default (default: manual). │
│ --reference-check-json <str> Reference-check config, e.g. '{"enabled": true, "count": 2}' (count 1-5, default 2). Overrides any reference_check already present in --stages-json. If │
│ neither is given, the job's existing saved reference_check is preserved as-is -- omitting this flag does NOT disable an already-configured reference check. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
hiring-flow show¶
Usage: zero hiring-flow show [OPTIONS] {job_id}
Show the saved hiring flow (stage plan) for a job.
Returns the fully-automated smart default (resume gate -> AI
interview) if the job has no saved plan yet.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal¶
Usage: zero internal [OPTIONS] COMMAND [ARGS]...
Internal/advanced commands.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ configure Manually configure API credentials. │
│ jobs Manage jobs. │
│ applications Manage applications. │
│ interviews Manage interviews. │
│ employers Manage employers. │
│ applicants Manage applicants. │
│ ai AI-powered generation tools. │
│ files Upload files. │
│ jenny Debug Jenny live-call transcripts and chat logs (dev/staging only). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal ai¶
Usage: zero internal ai [OPTIONS] COMMAND [ARGS]...
AI-powered generation tools.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ generate-jd Generate or refine a job description using AI. │
│ generate-questions Generate or refine interview questions using AI. │
│ extract-skills Extract skills from a job description. │
│ suggest-salary Compute a recommended salary range for a role (ZER-2467). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal ai extract-skills¶
Usage: zero internal ai extract-skills [OPTIONS]
Extract skills from a job description.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --description -d <str> Job description text [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal ai generate-jd¶
Usage: zero internal ai generate-jd [OPTIONS]
Generate or refine a job description using AI.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --title -t <str> Job title [required] │
│ --skills <str> Required skills │
│ --company <str> Company name │
│ --feedback <str> Refinement feedback │
│ --role-summary-json <str> Structured role intake as a JSON object (must include 'title'). Folded into the JD source material so the JD matches the confirmed intake. │
│ --markdown Convert the generated JD from HTML to Markdown before printing (ZER-2468). Use this when the draft is going straight into a chat reply -- Jenny's chat │
│ renderer deliberately refuses raw HTML, so paste the Markdown form, never the raw job_description field. `--json` still returns the original HTML unless this │
│ is also set; the job-creation path (hire run) is unaffected -- it always stores the generator's real HTML output. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal ai generate-questions¶
Usage: zero internal ai generate-questions [OPTIONS]
Generate or refine interview questions using AI.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --title -t <str> Job title [required] │
│ --skills <str> Required skills │
│ --company <str> Company name │
│ --feedback <str> Refinement feedback │
│ --structured Return structured screening question objects alongside legacy text. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal ai suggest-salary¶
Usage: zero internal ai suggest-salary [OPTIONS]
Compute a recommended salary range for a role (ZER-2467).
Product decision, verbatim (Alan): don't make salary optional -- compute
it and propose it. Returns an ESTIMATE for the operator to react to
(accept / give a different number / not disclose), never something to
present as market data Zero measured -- there is no benchmark data
source behind this, it's an LLM estimate. When the response's
`disclosure_required` is true, the "don't disclose" option is not legally
available for that posting; say so instead of silently omitting salary.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --title -t <str> Job title [required] │
│ * --location -l <str> Job location [required] │
│ --seniority <str> Seniority level (e.g. 'Senior', 'Staff'). │
│ --employment-type <str> Employment type (e.g. 'Full-time'). │
│ --company-context <str> Short company context (stage, size, industry) to refine the estimate. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applicants¶
Usage: zero internal applicants [OPTIONS] COMMAND [ARGS]...
Manage applicants.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ create Create (or get) an applicant by email. │
│ update-phone Update an existing applicant phone number. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applicants create¶
Usage: zero internal applicants create [OPTIONS]
Create (or get) an applicant by email.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --email <str> Applicant email [required] │
│ * --first-name <str> First name [required] │
│ * --last-name <str> Last name [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applicants update-phone¶
Usage: zero internal applicants update-phone [OPTIONS]
Update an existing applicant phone number.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --phone <str> New candidate phone number [required] │
│ --email <str> Applicant email │
│ --application-id <str> Application UUID │
│ --job-id <str> Optional job UUID to disambiguate by role │
│ --employer-id <str> Employer UUID │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applications¶
Usage: zero internal applications [OPTIONS] COMMAND [ARGS]...
Manage applications.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List applications, optionally filtered by job or status. │
│ create Create a new application (with optional resume). │
│ rank Manually set an application's ranking. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applications create¶
Usage: zero internal applications create [OPTIONS]
Create a new application (with optional resume).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --applicant-id <str> Applicant UUID [required] │
│ * --job-id <str> Job UUID [required] │
│ --resume <str> Path to resume file │
│ --resume-url <str> URL to resume │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applications list¶
Usage: zero internal applications list [OPTIONS]
List applications, optionally filtered by job or status.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --job-id <str> Filter by job UUID │
│ --status <str> Filter by status │
│ --page <int> Page number [default: 1] │
│ --limit <int> Results per page [default: 20] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal applications rank¶
Usage: zero internal applications rank [OPTIONS] {application_id}
Manually set an application's ranking.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * application_id <str> Application UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --ranking -r <int> New ranking position [required] │
│ * --reason <str> Reason for ranking change [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal configure¶
Usage: zero internal configure [OPTIONS]
Manually configure API credentials.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --api-url <str> [default: https://dev.api.zerohiring.com] │
│ * --api-key <str> [required] │
│ --employer-id <str> │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal employers¶
Usage: zero internal employers [OPTIONS] COMMAND [ARGS]...
Manage employers.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ create Create a new employer account. │
│ analytics Get analytics for an employer. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal employers analytics¶
Usage: zero internal employers analytics [OPTIONS] {employer_id}
Get analytics for an employer.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * employer_id <str> Employer UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --start-date <str> Start date (ISO format) │
│ --end-date <str> End date (ISO format) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal employers create¶
Usage: zero internal employers create [OPTIONS]
Create a new employer account.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --email <str> Employer email [required] │
│ * --first-name <str> First name [required] │
│ * --last-name <str> Last name [required] │
│ * --company <str> Company name [required] │
│ --demo --no-demo Provision as a demo tenant (employers.is_demo=true): charges, cold outreach, and real sourcing are suppressed for this employer; demo-seeded rows stay │
│ permanently excluded from analytics/billing even after demo mode is turned off. Toggle later with `zero demo mode on|off --employer-id`. │
│ [default: no-demo] │
│ --logo-url <str> Company logo URL (optional) │
│ --website-url <str> Company website URL (optional) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal files¶
Usage: zero internal files [OPTIONS] COMMAND [ARGS]...
Upload files.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ upload Upload a file to S3. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal files upload¶
Usage: zero internal files upload [OPTIONS] {file}
Upload a file to S3.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * file <str> Path to file [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --folder <str> Target folder (resumes, avatars, etc.) [default: resumes] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews¶
Usage: zero internal interviews [OPTIONS] COMMAND [ARGS]...
Manage interviews.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ create Create a new interview, or trigger a reference check. │
│ create-reference Create a reference record for a candidate's application. │
│ test Create an employer preview interview and print the launch URL. │
│ results Get results for a completed interview. │
│ trigger-call Trigger an outbound phone call for an interview. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews create¶
Usage: zero internal interviews create [OPTIONS]
Create a new interview, or trigger a reference check.
Same candidate-contact-evidence gate as `manage_candidates` hire/invite
actions applies here: with `--use-case reference`, the backend returns
HTTP 409 (`reference_request_requires_candidate_contact`) if there is no
recorded evidence this candidate has ever engaged with us. That is a
deliberate refusal, not a transient error -- there is no override flag.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --interview-type <str> Interview type (e.g. realtime, video, four_models) [required] │
│ * --applicant-id <str> Applicant UUID [required] │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ * --job-id <str> Job UUID [required] │
│ --application-id <str> Application UUID │
│ --avatar-id <str> Avatar ID │
│ --is-test --no-is-test Mark as test/preview interview [default: no-is-test] │
│ --use-case <str> interview (default) or reference -- reference triggers a reference-check call/interview instead of a candidate interview; requires --reference-id from │
│ `interviews create-reference`. │
│ [default: interview] │
│ --reference-id <str> Reference record ID (from `interviews create-reference`). Required when --use-case reference. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews create-reference¶
Usage: zero internal interviews create-reference [OPTIONS]
Create a reference record for a candidate's application.
Returns a `reference_id` -- pass it to `interviews create --use-case
reference --reference-id <id>` to actually trigger the reference-check
call/interview. This step alone does not contact the reference or the
candidate.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --application-id <str> Application UUID [required] │
│ * --job-id <str> Job UUID [required] │
│ * --name <str> Reference's full name [required] │
│ * --email <str> Reference's email address [required] │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --custom-questions <str> Optional free-text custom questions for the reference │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews results¶
Usage: zero internal interviews results [OPTIONS] {interview_id}
Get results for a completed interview.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews test¶
Usage: zero internal interviews test [OPTIONS]
Create an employer preview interview and print the launch URL.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --job-id,--job <str> Job UUID [required] │
│ --interview-type <str> Test interview type: video or audio [default: video] │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal interviews trigger-call¶
Usage: zero internal interviews trigger-call [OPTIONS] {interview_id}
Trigger an outbound phone call for an interview.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny¶
Usage: zero internal jenny [OPTIONS] COMMAND [ARGS]...
Debug Jenny live-call transcripts and chat logs (dev/staging only).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ calls Jenny live voice/video call debugging. │
│ chats Jenny text-chat conversation debugging. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny calls¶
Usage: zero internal jenny calls [OPTIONS] COMMAND [ARGS]...
Jenny live voice/video call debugging.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List Jenny live voice/video calls for an employer (dev/staging only). │
│ show Show a Jenny live call's metadata and transcript (dev/staging only). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny calls list¶
Usage: zero internal jenny calls list [OPTIONS]
List Jenny live voice/video calls for an employer (dev/staging only).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer <str> Employer UUID (auto-detected from login) │
│ --limit <int> Max rows to return [default: 50] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny calls show¶
Usage: zero internal jenny calls show [OPTIONS] {call_id}
Show a Jenny live call's metadata and transcript (dev/staging only).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * call_id <str> Live-call UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny chats¶
Usage: zero internal jenny chats [OPTIONS] COMMAND [ARGS]...
Jenny text-chat conversation debugging.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List Jenny text-chat conversations for an employer (dev/staging only). │
│ show Show a Jenny text-chat conversation and its messages (dev/staging only). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny chats list¶
Usage: zero internal jenny chats list [OPTIONS]
List Jenny text-chat conversations for an employer (dev/staging only).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer <str> Employer UUID (auto-detected from login) │
│ --limit <int> Max rows to return [default: 50] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jenny chats show¶
Usage: zero internal jenny chats show [OPTIONS] {conversation_id}
Show a Jenny text-chat conversation and its messages (dev/staging only).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * conversation_id <str> Conversation UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs¶
Usage: zero internal jobs [OPTIONS] COMMAND [ARGS]...
Manage jobs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List jobs for an employer. │
│ get Get details for a single job. │
│ create Create a new job. │
│ update Update a job (only provided fields are changed). │
│ delete Soft-delete a job by UUID (no confirmation — intended for scripting). │
│ parse-jd Check a job description for completeness. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs create¶
Usage: zero internal jobs create [OPTIONS]
Create a new job.
The four salary flags are mandatory (ZER-2420): they are kept as
``Optional`` typer options only so all of the missing ones are named in
one actionable, JSON-coded ``missing_salary`` error (see
``validate_structured_salary``) instead of typer's one-flag-at-a-time
usage error.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ * --title -t <str> Job title [required] │
│ * --description -d <str> Job description [required] │
│ --active --no-active Whether the job is active [default: active] │
│ --custom-questions <str> Custom interview questions │
│ --screening-questions-json <str> Structured screening questions as JSON, e.g. '[{"text":"Can you work UTC hours?","order":1,"source":"jenny"}]'. 'source' is optional │
│ but if set must be one of ['ai', 'ats', 'jenny', 'legacy', 'manual'] — any other value is rejected client-side before it reaches the │
│ backend (ZER-1154: unrecognized 'source' values used to be silently dropped, persisting an empty question list with no error). │
│ --employer-information <str> Company info for candidates │
│ --location <str> Job location │
│ --employment-type <str> Employment type (full-time, part-time, etc.) │
│ --is-remote --no-is-remote Whether the role is fully remote (Google for Jobs jobLocationType: TELECOMMUTE). When true, the structured physical-address fields │
│ below are not required. │
│ [default: no-is-remote] │
│ --location-street <str> Street address. Always optional. │
│ --location-locality <str> City/locality. For non-remote roles, required (together with --location-country) once any structured location field is set, unless │
│ --location-region is given instead. │
│ --location-region <str> State/region/province. May substitute for --location-locality. │
│ --location-postal-code <str> Postal/ZIP code. Always optional. │
│ --location-country <str> Two-letter ISO 3166-1 country code (e.g. 'US'). For non-remote roles, required together with --location-locality or --location-region │
│ once any structured location field is set. 422 from the backend if omitted when required, or not 2 letters. │
│ --salary-min <float> Minimum base salary. Required on job creation (ZER-2420): the backend rejects a new job unless --salary-min, --salary-max, │
│ --salary-currency and --salary-period are all set. Use `zero internal ai suggest-salary` during intake if the operator has no range in │
│ mind. │
│ --salary-max <float> Maximum base salary. Must be >= --salary-min. Required on job creation (ZER-2420): the backend rejects a new job unless --salary-min, │
│ --salary-max, --salary-currency and --salary-period are all set. Use `zero internal ai suggest-salary` during intake if the operator │
│ has no range in mind. │
│ --salary-currency <str> Three-letter ISO 4217 currency code (e.g. 'USD'). Required on job creation (ZER-2420): the backend rejects a new job unless │
│ --salary-min, --salary-max, --salary-currency and --salary-period are all set. Use `zero internal ai suggest-salary` during intake if │
│ the operator has no range in mind. │
│ --salary-period <str> Pay period: one of YEAR, MONTH, WEEK, DAY, HOUR. Required on job creation (ZER-2420): the backend rejects a new job unless │
│ --salary-min, --salary-max, --salary-currency and --salary-period are all set. Use `zero internal ai suggest-salary` during intake if │
│ the operator has no range in mind. │
│ --client-id <str> RPO client UUID to create this job under │
│ --role-summary-json <str> Structured role intake as a JSON object (must include 'title'). Persisted on the job under additional_data['role_summary']. │
│ --interview-language <str> Language the AI interviewer conducts this job's interviews in: 'en' (default) or 'pl'. 422 from the backend on other values. │
│ --use-description-as-jd Preserve --description directly only when it is already a polished HTML JD. Plain text is still formatted with AI. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs delete¶
Usage: zero internal jobs delete [OPTIONS] {job_id}
Soft-delete a job by UUID (no confirmation — intended for scripting).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs get¶
Usage: zero internal jobs get [OPTIONS] {job_id}
Get details for a single job.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs list¶
Usage: zero internal jobs list [OPTIONS]
List jobs for an employer.
A single page never implies completeness: pass --all (or read the
printed/JSON pagination facts) before concluding a job does not exist.
Rows carry ``description_chars`` rather than the description body. A row
with ``description_omitted: true`` HAS a description -- it just is not in
this payload. Use --search to match on description text server-side,
``zero jobs show <job>`` to read one, or --with-description to opt the
whole list back in.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --status <str> Filter by status │
│ --search <str> Search term, matched server-side against job title, DESCRIPTION text, and location. This is the supported way to answer 'which of my roles mention X?' without │
│ pulling description bodies into the response. │
│ --client-id <str> Filter by RPO client UUID │
│ --with-description Include each job's full description body. Off by default: descriptions average ~4 kB, so a few dozen jobs is enough to blow past an agent's tool-result limit. │
│ Prefer --search, or `zero jobs show <job>` for a single description. │
│ --page <int> Page number [default: 1] │
│ --limit <int> Results per page [default: 20] │
│ --all Auto-paginate and return every job (up to 500 rows) instead of a single page. Overrides --page/--limit. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs parse-jd¶
Usage: zero internal jobs parse-jd [OPTIONS]
Check a job description for completeness.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --description -d <str> Job description text [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
internal jobs update¶
Usage: zero internal jobs update [OPTIONS] {job_id}
Update a job (only provided fields are changed).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * job_id <str> Job UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --title -t <str> New title │
│ --description -d <str> New description │
│ --active --no-active Not supported: the update endpoint deliberately excludes `active` (ZER-561), so passing this always errors before any request is sent. │
│ See `zero internal jobs delete` for the closest existing lever (soft-delete, not deactivate). │
│ --custom-questions <str> Custom interview questions │
│ --screening-questions-json <str> Structured screening questions as JSON, e.g. '[{"text":"Can you work UTC hours?","order":1,"source":"jenny"}]'. 'source' is optional but │
│ if set must be one of ['ai', 'ats', 'jenny', 'legacy', 'manual'] — any other value is rejected client-side before it reaches the backend │
│ (ZER-1154: unrecognized 'source' values used to be silently dropped, persisting an empty question list with no error). │
│ --employer-information <str> Company info for candidates │
│ --location <str> Job location │
│ --is-remote --no-is-remote Whether the role is fully remote (Google for Jobs jobLocationType: TELECOMMUTE). Omit to leave unchanged. When set true, the structured │
│ physical-address fields below are not required. │
│ --location-street <str> Street address. Always optional. │
│ --location-locality <str> City/locality. For non-remote roles, required (together with --location-country) once any structured location field is set on this call, │
│ unless --location-region is given instead. │
│ --location-region <str> State/region/province. May substitute for --location-locality. │
│ --location-postal-code <str> Postal/ZIP code. Always optional. │
│ --location-country <str> Two-letter ISO 3166-1 country code (e.g. 'US'). For non-remote roles, required together with --location-locality or --location-region │
│ once any structured location field is set on this call. 422 from the backend if omitted when required, or not 2 letters. │
│ --salary-min <float> Minimum base salary. Optional on update; omit to leave unchanged. │
│ --salary-max <float> Maximum base salary. Must be >= --salary-min. │
│ --salary-currency <str> Three-letter ISO 4217 currency code (e.g. 'USD'). Required together with --salary-period once --salary-min or --salary-max is set on this │
│ call; 422 from the backend otherwise. │
│ --salary-period <str> Pay period: one of YEAR, MONTH, WEEK, DAY, HOUR. Required together with --salary-currency once --salary-min or --salary-max is set on │
│ this call. │
│ --interview-language <str> Language the AI interviewer conducts this job's interviews in: 'en' (default) or 'pl'. 422 from the backend on other values. │
│ --use-description-as-jd Preserve --description directly only when it is already a polished HTML JD. Plain text is still formatted with AI. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews¶
Usage: zero interviews [OPTIONS] COMMAND [ARGS]...
Schedule and manage human (hiring-manager) interviews.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ create Create a human interview for an application. │
│ list List human interviews, newest first (soonest-first with --upcoming). │
│ show Show a human interview, including proposed/selected slots. │
│ propose-slots Propose (or replace) slots on an interview and email the candidate. │
│ reschedule Reschedule a scheduled (or awaiting_candidate) interview with new slots. │
│ cancel Cancel a human interview from any non-terminal status. │
│ complete Mark a scheduled interview as completed. │
│ availability Check Google Calendar availability for an interviewer. │
│ feedback Leave candidate feedback tied to this interview. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews availability¶
Usage: zero interviews availability [OPTIONS]
Check Google Calendar availability for an interviewer.
Returns free 30-min-aligned slots inside business hours over the next
N days (default 7), pulled from the interviewer's connected Google
Calendar via freebusy. If neither --interviewer-user-id nor
--interviewer-email resolves a connected calendar, `connected` comes
back false -- propose times manually instead, or ask the interviewer
to connect Google Calendar in Company Settings. Feed the returned
start times straight into `interviews create --slot` or `interviews
propose-slots --slot`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --interviewer-user-id <str> Platform user UUID whose calendar to check. │
│ --interviewer-email <str> Ad-hoc interviewer email whose calendar to check. Use --interviewer-user-id when the interviewer is a platform member/reviewer; falls back to │
│ the acting user's own calendar when neither is set. │
│ --duration <int range> [5<=x<=480] Duration in minutes, 5-480 (default 45). │
│ --days <int range> [1<=x<=30] How many days ahead to search (default 7). │
│ --timezone <str> IANA timezone to display suggested times in, e.g. America/New_York (default UTC). │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews cancel¶
Usage: zero interviews cancel [OPTIONS] {interview_id}
Cancel a human interview from any non-terminal status.
Notifies the candidate (and the interviewer too, if it was scheduled).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> Reason for cancellation (audit trail, shown to the candidate). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews complete¶
Usage: zero interviews complete [OPTIONS] {interview_id}
Mark a scheduled interview as completed.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews create¶
Usage: zero interviews create [OPTIONS]
Create a human interview for an application.
Requires --interviewer-user-id OR --interviewer-email. Only one active
(non-terminal) human interview is allowed per application at a time;
the backend returns a conflict if one already exists. Once that
interview reaches a terminal status (completed, cancelled, declined,
expired), creating another succeeds and starts the next round -- the
backend auto-increments a `round` number per application, returned on
`interviews show`/`interviews list --json`. The job's `human_interview`
stage config may separately carry an advisory `expected_rounds`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --application-id <str> Application UUID. [required] │
│ --interviewer-user-id <str> Platform user UUID to interview (member or reviewer). │
│ --interviewer-email <str> Ad-hoc interviewer email. Use with --interviewer-name, or instead of --interviewer-user-id. │
│ --interviewer-name <str> Ad-hoc interviewer display name. │
│ --title <str> Interview title (default: 'Interview'). │
│ --duration <int range> [5<=x<=480] Duration in minutes, 5-480 (default 45). │
│ --location-type <str> video, phone, or onsite (default video). │
│ --location-details <str> Meeting URL, phone note, or physical address. │
│ --timezone <str> IANA timezone, e.g. America/New_York (default UTC). │
│ --message <str> Optional note shown to the candidate. │
│ --slot <str> Proposed start time, ISO8601 with timezone (repeatable, max 5). Passing any slots proposes them immediately and emails the candidate │
│ (status -> awaiting_candidate); omit to create in pending_slots and propose later with `interviews propose-slots`. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews feedback¶
Usage: zero interviews feedback [OPTIONS] {interview_id}
Leave candidate feedback tied to this interview.
Provide --rating and/or --note (at least one is required). Looks up the
interview's application_id automatically.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --rating <int range> [1<=x<=5] Rating 1-5. │
│ --note <str> Free-text feedback note. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews list¶
Usage: zero interviews list [OPTIONS]
List human interviews, newest first (soonest-first with --upcoming).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job-id <str> Filter by job UUID. │
│ --application-id <str> Filter by application UUID. │
│ --status <str> Filter by status: awaiting_candidate, cancelled, completed, declined, expired, pending_slots, scheduled. │
│ --upcoming Only scheduled interviews with a future start time, soonest first. │
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews propose-slots¶
Usage: zero interviews propose-slots [OPTIONS] {interview_id}
Propose (or replace) slots on an interview and email the candidate.
Allowed from pending_slots, awaiting_candidate, declined, or expired.
Any previously proposed (not yet selected) slots are withdrawn. Moves
the interview to awaiting_candidate.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --slot <str> Proposed start time, ISO8601 with timezone (repeatable, 1-5). [required] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews reschedule¶
Usage: zero interviews reschedule [OPTIONS] {interview_id}
Reschedule a scheduled (or awaiting_candidate) interview with new slots.
Clears any existing selection, notifies the candidate of the change plus
the new slots, and moves the interview back to awaiting_candidate.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --slot <str> New proposed start time, ISO8601 with timezone (repeatable, 1-5). [required] │
│ --reason <str> Reason for the reschedule (shown to the candidate). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
interviews show¶
Usage: zero interviews show [OPTIONS] {interview_id}
Show a human interview, including proposed/selected slots.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
invite¶
Usage: zero invite [OPTIONS] COMMAND [ARGS]...
Invite candidates for AI interviews.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ send Invite candidates to AI interviews for a job. │
│ cancel Cancel a pending interview invite (revert primitive, ZER-660). │
│ manual Manually invite candidates by email (not from existing applicant pool). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
invite cancel¶
Usage: zero invite cancel [OPTIONS] {interview_id}
Cancel a pending interview invite (revert primitive, ZER-660).
Only valid while the interview is still in `invited` status --
started, finished, or already-cancelled interviews are rejected by
the backend with a 409.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * interview_id <str> Interview UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> Reason for cancellation (audit trail). │
│ --employer-id <str> Employer UUID (auto-detected from login). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
invite manual¶
Usage: zero invite manual [OPTIONS]
Manually invite candidates by email (not from existing applicant pool).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --job-id <str> Job UUID [required] │
│ * --email <str> Candidate email (repeatable) [required] │
│ * --first-name <str> First name (one per email) [required] │
│ * --last-name <str> Last name (one per email) [required] │
│ --phone <str> Candidate phone for AI Telephony invites (repeatable, E.164 preferred) │
│ --interview-type <str> Interview type (realtime, phone_call, video, telephony, ai_telephony) [default: realtime] │
│ --avatar-id <str> Video avatar UUID. Defaults to Jenny's video avatar for video interviews. │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
invite send¶
Usage: zero invite send [OPTIONS] [job_id]
Invite candidates to AI interviews for a job.
Use --demo to simulate interviews instantly (creates completed results).
Use --candidate to invite specific candidates by number or UUID.
Bulk selection (mutually exclusive with each other, but all compose
with `--candidate` being absent): `--top N`, `--min-score X`, `--all`.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --candidate <str> Candidate number (1-based) or application UUID (repeatable) │
│ --top <int> Invite the top N candidates by score (highest first). │
│ --min-score <float> Invite every candidate with score >= N. │
│ --all Invite every candidate who hasn't already been interviewed. │
│ --interview-type <str> Interview type (realtime, phone_call, video, telephony, ai_telephony) [default: realtime] │
│ --avatar-id <str> Video avatar UUID. Defaults to Jenny's video avatar for video interviews. │
│ --demo Demo mode: simulate interviews instantly instead of sending real invites │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs¶
Usage: zero jobs [OPTIONS] COMMAND [ARGS]...
List and switch between jobs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List all your jobs (sorted by creation date, newest first). │
│ current Print the resolved current job and where the pointer came from. │
│ use Switch to a different job (makes it the default for all commands). │
│ show Show full details for a job: JD, status, applicant count, dashboard URL. │
│ delete Delete a job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs current¶
Usage: zero jobs current [OPTIONS]
Print the resolved current job and where the pointer came from.
Useful when debugging a shared-token setup: you can see at a glance
whether the selection is coming from ``ZERO_JOB_ID``, local config, or a
legacy server-side value.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs delete¶
Usage: zero jobs delete [OPTIONS] {JOB_REF}
Delete a job.
This soft-deletes the job: it is removed from all listings and cannot be
interacted with, but existing applications and interview records are
retained in the database for audit purposes.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * JOB_REF <str> Short ID, full UUID, 1-based list number (deprecated), or title substring [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --yes -y Skip the confirmation prompt │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --expect-id <str> Assert the resolved job matches this UUID or short ID │
│ --expect-title <str> Assert the resolved job's title contains this substring (case-insensitive) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs list¶
Usage: zero jobs list [OPTIONS]
List all your jobs (sorted by creation date, newest first).
All filters compose (``--mine --tag backend --since 2026-04-01``). When
``--json`` is passed, the payload after filtering/sorting is printed
(enriched with the derived ``short_id``) so scripts can keep reading it.
Rows carry ``description_chars`` rather than the description body. A row
with ``description_omitted: true`` HAS a description -- it just is not in
this payload; read it with ``zero jobs show <job>``. ``--with-description``
opts the whole list back in, at the size cost described on that flag.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --active-only Show only active jobs │
│ --mine Show only jobs you created. Requires the backend to expose `created_by_user_id` (ZER-563); if it doesn't, a warning is printed to stderr and all employer jobs are │
│ shown. │
│ --tag <str> Filter to jobs tagged [<name>] in the title (case-insensitive). │
│ --since <str> ISO date (e.g. 2026-04-01). Keep jobs created on/after this date. │
│ --search <str> Case-insensitive substring match on job title or location. This filter runs locally and does NOT look inside job descriptions -- to search description text use │
│ `zero internal jobs list --search <term>`, which matches server-side. │
│ --with-description Include each job's full description body. Off by default: descriptions average ~4 kB, so a few dozen jobs is enough to blow past an agent's tool-result limit. │
│ Prefer `zero jobs show <job>` for one description, or `zero internal jobs list --search <term>` to find jobs by description text. │
│ --client-id <str> Filter to jobs belonging to an RPO client UUID. │
│ --sort <str> Sort by: created, title, applicants, status. │
│ --order <str> Sort direction: asc, desc. Only used with --sort. [default: desc] │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs show¶
Usage: zero jobs show [OPTIONS] [job_ref]
Show full details for a job: JD, status, applicant count, dashboard URL.
If the job is unpaid we also surface the short payment link (so the user
can finish activating the role without having to dig through email).
Defaults to the currently-selected job when no argument is given.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_ref <str> Job number (from 'zero jobs list') or job UUID. Defaults to current job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
jobs use¶
Usage: zero jobs use [OPTIONS] {JOB_REF}
Switch to a different job (makes it the default for all commands).
Prefer short IDs (printed by ``zero jobs list``) — they're derived from
the UUID and stay stable even when jobs are added or deleted. Numeric
list positions and title substrings still work, but positions shift and
substrings can match multiple jobs; scripts should use short IDs or UUIDs.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * JOB_REF <str> Short ID (from 'zero jobs list'), full UUID, 1-based list number (deprecated), or case-insensitive title substring [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --expect-id <str> Assert the resolved job matches this UUID or short ID │
│ --expect-title <str> Assert the resolved job's title contains this substring (case-insensitive) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
login¶
Usage: zero login [OPTIONS]
Log in or sign up. Uses device code flow by default.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --app-url <str> Override app URL (e.g. http://localhost:3300 for local testing) │
│ --browser Use browser callback flow instead of device code │
│ --token <str> Log in with an API token directly │
│ --no-wait Print device code and exit without waiting (for non-interactive use) │
│ --complete <str> Complete a pending device code login with the given session ID │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
logout¶
Usage: zero logout [OPTIONS]
Log out: revoke the CLI token server-side, then remove local credentials.
Best-effort: if the backend revocation fails (network error, already-revoked
token, etc.) we still wipe the local config so the CLI appears logged out.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
offers¶
Usage: zero offers [OPTIONS] COMMAND [ARGS]...
Inspect and manage offer letters.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List offers. Not yet supported by the backend. │
│ show Show a single offer by ID. │
│ cancel Withdraw an in-flight offer. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
offers cancel¶
Usage: zero offers cancel [OPTIONS] {offer_id}
Withdraw an in-flight offer.
Cancels the SignWell document and emails the candidate that the offer
has been withdrawn. Only valid while the offer is in `sent` status.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * offer_id <str> Offer UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> Reason for cancellation (audit trail). │
│ --yes -y Skip the confirmation prompt. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
offers list¶
Usage: zero offers list [OPTIONS]
List offers. Not yet supported by the backend.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job <str> Job UUID to filter offers by. │
│ --status <str> Status to filter offers by (e.g. sent, signed). │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
offers show¶
Usage: zero offers show [OPTIONS] {offer_id}
Show a single offer by ID.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * offer_id <str> Offer UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach¶
Usage: zero outreach [OPTIONS] COMMAND [ARGS]...
Multi-step candidate outreach sequences.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ enroll Enroll a shortlisted candidate into an outreach sequence. │
│ cancel Cancel an outreach enrollment (revert primitive, ZER-660). │
│ stats Show a sequence-level engagement rollup (sent/opened/clicked/replied). │
│ sequences Create and manage outreach sequences. │
│ enrollments View and control per-candidate enrollments. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach cancel¶
Usage: zero outreach cancel [OPTIONS] {enrollment_id}
Cancel an outreach enrollment (revert primitive, ZER-660).
Unlike ``outreach enrollments stop``, this is the support/ops-facing
"undo" for an enrollment: it works on `active` or `paused`
enrollments and can optionally burn bridges so the same candidate is
never re-enrolled into the same sequence/job again. Mirrors the
``offers cancel`` shape (top-level verb on the group's Typer app).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * enrollment_id <str> Enrollment UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login). │
│ --reason <str> Reason for cancellation (audit trail, max 2000 chars). │
│ --burn-bridges Also block this candidate from being re-enrolled into this sequence/job in the future (outreach_do_not_contact). │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enroll¶
Usage: zero outreach enroll [OPTIONS] {shortlist_id}
Enroll a shortlisted candidate into an outreach sequence.
The candidate's email + personalization fields are snapshotted server-
side, so the sequence keeps working even if the underlying sourced
profile is later refreshed.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * shortlist_id <str> Shortlist entry UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --sequence <str> Sequence UUID to enroll into. [required] │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments¶
Usage: zero outreach enrollments [OPTIONS] COMMAND [ARGS]...
View and control per-candidate enrollments.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List enrollments, optionally filtered by sequence and/or status. │
│ pause Pause an enrollment — no further steps will send until resumed. │
│ resume Resume a previously paused enrollment. │
│ stop Permanently stop an enrollment. Terminal — not reversible via │
│ ``resume`` (enroll the candidate again if you really need to restart). │
│ stop-by-candidate Stop future outreach for a sourced candidate without discarding them. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments list¶
Usage: zero outreach enrollments list [OPTIONS]
List enrollments, optionally filtered by sequence and/or status.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --sequence <str> Filter by sequence UUID. │
│ --status <str> Filter by status: active | paused | replied | stopped | completed. │
│ --limit <int range> [1<=x<=500] [default: 100] │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments pause¶
Usage: zero outreach enrollments pause [OPTIONS] {enrollment_id}
Pause an enrollment — no further steps will send until resumed.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * enrollment_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments resume¶
Usage: zero outreach enrollments resume [OPTIONS] {enrollment_id}
Resume a previously paused enrollment.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * enrollment_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments stop¶
Usage: zero outreach enrollments stop [OPTIONS] {enrollment_id}
Permanently stop an enrollment. Terminal — not reversible via ``resume`` (enroll the candidate again if you really need to restart).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * enrollment_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach enrollments stop-by-candidate¶
Usage: zero outreach enrollments stop-by-candidate [OPTIONS] {candidate_ref}
Stop future outreach for a sourced candidate without discarding them.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * candidate_ref <str> Candidate name, email, number, or application UUID [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences¶
Usage: zero outreach sequences [OPTIONS] COMMAND [ARGS]...
Create and manage outreach sequences.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ example-steps Print a working 3-step Day 0/3/7 starter template. │
│ create Create a multi-step sequence from a JSON step file or inline JSON. │
│ list List outreach sequences for the current employer. │
│ show Show a sequence's header and steps. │
│ activate Activate a sequence so it can accept new enrollments. │
│ deactivate Deactivate a sequence. Existing enrollments keep running; new │
│ enrollments are rejected until re-activated. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences activate¶
Usage: zero outreach sequences activate [OPTIONS] {sequence_id}
Activate a sequence so it can accept new enrollments.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * sequence_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences create¶
Usage: zero outreach sequences create [OPTIONS]
Create a multi-step sequence from a JSON step file or inline JSON.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --name <str> Human-readable name for the sequence. [required] │
│ --from-file <str> Path to a JSON file with the step list. Use '-' to read from stdin. │
│ --steps-json,--steps <str> Inline JSON array or {'steps': [...]} object. Prefer this for MCP/Jenny. │
│ --description <str> Optional internal description. │
│ --job <str> Scope this sequence to a job UUID (optional). │
│ --sender-email <str> From-address (stubbed; falls back to platform sender). │
│ --sender-name <str> From-name. │
│ --reply-to <str> Reply-To address for candidate replies. │
│ --employer-id <str> Employer UUID (auto-detected from login). │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences deactivate¶
Usage: zero outreach sequences deactivate [OPTIONS] {sequence_id}
Deactivate a sequence. Existing enrollments keep running; new enrollments are rejected until re-activated.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * sequence_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences example-steps¶
Usage: zero outreach sequences example-steps [OPTIONS]
Print a working 3-step Day 0/3/7 starter template.
Pipe this straight into a file and then into ``sequences create``:
zero outreach sequences example-steps --json > steps.json
zero outreach sequences create --name 'Founder intro' --from-file steps.json
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output (convenient for `... > steps.json`). │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences list¶
Usage: zero outreach sequences list [OPTIONS]
List outreach sequences for the current employer.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job <str> Filter by job UUID (still shows employer-wide sequences too). │
│ --limit <int range> [1<=x<=500] [default: 100] │
│ --employer-id <str> Employer UUID (auto-detected). │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach sequences show¶
Usage: zero outreach sequences show [OPTIONS] {sequence_id}
Show a sequence's header and steps.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * sequence_id <str> Sequence UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected). │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
outreach stats¶
Usage: zero outreach stats [OPTIONS] {sequence_id}
Show a sequence-level engagement rollup (sent/opened/clicked/replied).
Aggregates client-side over all enrollments for the sequence — the
backend already returns per-enrollment engagement counts in the list
endpoint, so a dedicated stats endpoint isn't needed yet.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * sequence_id <str> Sequence UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
payments¶
Usage: zero payments [OPTIONS] COMMAND [ARGS]...
Refund charges (approval-gated).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ refund Refund a charge (revert primitive, ZER-660). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
payments refund¶
Usage: zero payments refund [OPTIONS] {charge_id}
Refund a charge (revert primitive, ZER-660).
This is irreversible real-money movement. Beyond the ordinary
confirmation prompt (skippable with --yes/--force), this command
ALWAYS interactively prompts for a human approver name/handle and
sends it to the backend as `approved_by` -- the backend itself
rejects the request with 400 if `approved_by` is missing or blank,
and the CLI enforces the same rule client-side before ever making
the request (see `_prompt_refund_approval`).
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * charge_id <str> Payment charge ID for the role-open or close fee to refund. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login). │
│ --reason <str> Reason for the refund (audit trail). │
│ --yes,--force -y Skip the ordinary 'are you sure?' confirmation. Does NOT skip the mandatory human-approval capture below -- refunds always require a live human to type their │
│ name/handle, even with --yes/--force. │
│ --json Raw JSON output. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline¶
Usage: zero pipeline [OPTIONS] COMMAND [ARGS]...
Run and inspect end-to-end hiring pipeline runs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ run Create a pipeline run for a job. │
│ status Show one pipeline run. │
│ list List recent pipeline runs. │
│ advance Advance a pipeline run after approval. │
│ autopilot Show or set Autopilot (experimental) for the employer. │
│ abort Abort a pipeline run. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline abort¶
Usage: zero pipeline abort [OPTIONS] {run_id}
Abort a pipeline run.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * run_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --reason <str> │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline advance¶
Usage: zero pipeline advance [OPTIONS] {run_id}
Advance a pipeline run after approval.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * run_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --approve <str> Approve the current phase. │
│ --reject <str> Reject the current phase and abort. │
│ --reason <str> │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline autopilot¶
Usage: zero pipeline autopilot [OPTIONS]
Show or set Autopilot (experimental) for the employer.
Autopilot lets the pipeline advance the reversible sourcing and shortlist
phases without a human. The job-description approval, outbound sending and
the hire decision always stay human-gated -- the JD approval because it is
the contractual record of what the client signed off (ZER-1879).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --on --off Enable or disable Autopilot. Omit to show the current setting. │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline list¶
Usage: zero pipeline list [OPTIONS]
List recent pipeline runs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Filter to a job UUID. │
│ --limit <int range> [1<=x<=250] [default: 50] │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline run¶
Usage: zero pipeline run [OPTIONS]
Create a pipeline run for a job.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --brief <str> Hiring brief or run note. │
│ --sequence <str> Default outreach sequence UUID for this run. │
│ --employer-id <str> │
│ --idempotency-key <str> Accepted for agent retry contracts; ignored until backend idempotency lands. │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
pipeline status¶
Usage: zero pipeline status [OPTIONS] {run_id}
Show one pipeline run.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * run_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
results¶
Usage: zero results [OPTIONS] COMMAND [ARGS]...
View interview results.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ show Show interview results and scores for all candidates in a job. │
│ detail Show detailed interview results for a specific candidate. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
results detail¶
Usage: zero results detail [OPTIONS] [candidate]
Show detailed interview results for a specific candidate.
`--output csv|tsv|ndjson|json` flattens the transcript into rows so
the detail view is as pipeable as `results show`. CSV/TSV columns
track `rank` (1-based question index), `name` (candidate),
`resume_score` (empty for detail rows), `interview_score` (overall score),
`application_id` — plus extra `question`/`answer`/`question_score` columns
tacked on the end so you don't lose the text payload.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ candidate <str> Candidate number (1-based) or interview UUID (shows top candidate if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted) │
│ --json Raw JSON output │
│ --output <str> Structured output format: csv | tsv | ndjson | json (flattens answers into rows). │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
results show¶
Usage: zero results show [OPTIONS] [job_id]
Show interview results and scores for all candidates in a job.
`--output csv|tsv|ndjson|json` emits a flat, machine-friendly view
with columns: rank, name, resume_score, interview_score,
application_id. This is the recommended way to pipe results into a
spreadsheet or downstream tool.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ job_id <str> Job UUID (uses current job if omitted) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --json Raw JSON output │
│ --output <str> Structured output format: csv | tsv | ndjson | json. CSV is the default export format. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing¶
Usage: zero sourcing [OPTIONS] COMMAND [ARGS]...
Search sourced candidates and add them to jobs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ search Run a natural-language people search. │
│ status Show the status of an async sourcing search job. │
│ show Replay a saved sourcing search. │
│ add Add a sourced profile to the current job's applicants list. │
│ invite Promote a shortlisted sourced profile into an AI interview invite. │
│ shortlist Legacy alias for adding sourced candidates to jobs. │
│ applicants Promote sourced candidates into job applicants. │
│ test-candidate Create safe test sourced candidates. │
│ demo-candidates Create deterministic fake sourced candidates. │
│ experimental Experimental paper-mining sourcing (sources researchers from academic papers). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing add¶
Usage: zero sourcing add [OPTIONS] {profile_id}
Add a sourced profile to the current job's applicants list.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * profile_id <str> Sourced profile UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing applicants¶
Usage: zero sourcing applicants [OPTIONS] COMMAND [ARGS]...
Promote sourced candidates into job applicants.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ add Add a sourced profile to the current job's applicants list. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing applicants add¶
Usage: zero sourcing applicants add [OPTIONS] {profile_id}
Add a sourced profile to the current job's applicants list.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * profile_id <str> Sourced profile UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing demo-candidates¶
Usage: zero sourcing demo-candidates [OPTIONS] COMMAND [ARGS]...
Create deterministic fake sourced candidates.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ add Create or reuse the fixed five fake sourced candidates for a job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing demo-candidates add¶
Usage: zero sourcing demo-candidates add [OPTIONS]
Create or reuse the fixed five fake sourced candidates for a job.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing experimental¶
Usage: zero sourcing experimental [OPTIONS] COMMAND [ARGS]...
Experimental paper-mining sourcing (sources researchers from academic papers).
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ search Run the experimental paper-mining sourcing pipeline for the linked job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing experimental search¶
Usage: zero sourcing experimental search [OPTIONS] [emphasis]
Run the experimental paper-mining sourcing pipeline for the linked job.
Mines recent academic papers relevant to the job's field, ranks the
authoring researchers by citation velocity, enriches their contact
details, and adds them as sourced candidates on the job. Experimental:
contact-data coverage varies by field, unlike standard `sourcing search`.
The backend runs this asynchronously and returns a search_job_id. Pass
--wait to poll until the saved search_id is ready.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ emphasis <str> Optional emphasis to sharpen the academic search (the linked job's description is always used). │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --limit <int range> [x>=1] [default: 10] │
│ --wait Poll until the background search completes. │
│ --poll-interval <float range> [0.5<=x<=10.0] [default: 2.0] │
│ --wait-timeout <float range> [x>=5.0] Seconds to keep polling with --wait before giving up and returning the search_job_id to poll manually (default 180). Set this below your own │
│ caller's timeout: the search keeps running either way. │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing invite¶
Usage: zero sourcing invite [OPTIONS] {shortlist_id}
Promote a shortlisted sourced profile into an AI interview invite.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * shortlist_id <str> Shortlist UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --email <str> [required] │
│ * --first-name <str> [required] │
│ * --last-name <str> [required] │
│ --interview-type <str> [default: realtime] │
│ --avatar-id <str> │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing search¶
Usage: zero sourcing search [OPTIONS] {query}
Run a natural-language people search.
The backend runs searches asynchronously and returns a search_job_id.
Pass --wait to poll until the saved search_id is ready, optionally with
--wait-timeout to cap how long that poll blocks.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * query <str> Natural-language candidate search. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --limit <int range> [x>=1] [default: 50] │
│ --depth <str> cheap or deep ranking. [default: cheap] │
│ --location <str> Explicit country, city, or region constraint from the user's request (repeatable; overrides job-derived sourcing location). │
│ --real In dev/staging, bypass demo candidates and run a small live provider search. │
│ --source-more Continue the latest successful search for the linked job. Use only when the user explicitly asks for more candidates. │
│ --query-only,--exact-query Use only the provided query for provider filters. Keep the linked job for ranking/attribution, but do not reuse prior source-more │
│ filters. │
│ --wait Poll until the background search completes. │
│ --poll-interval <float range> [0.5<=x<=10.0] [default: 2.0] │
│ --wait-timeout <float range> [x>=5.0] Seconds to keep polling with --wait before giving up and returning the search_job_id to poll manually (default 180). Set this │
│ below your own caller's timeout: the search keeps running either way. │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing shortlist¶
Usage: zero sourcing shortlist [OPTIONS] COMMAND [ARGS]...
Legacy alias for adding sourced candidates to jobs.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ add Legacy alias for adding a sourced profile to applicants. │
│ list Legacy command removed: use `zero candidates list --source sourced`. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing shortlist add¶
Usage: zero sourcing shortlist add [OPTIONS] {profile_id}
Legacy alias for adding a sourced profile to applicants.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * profile_id <str> Sourced profile UUID. [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing shortlist list¶
Usage: zero sourcing shortlist list [OPTIONS]
Legacy command removed: use `zero candidates list --source sourced`.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ --status <str> │
│ --limit <int range> [1<=x<=500] [default: 100] │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing show¶
Usage: zero sourcing show [OPTIONS] {search_id}
Replay a saved sourcing search.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * search_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing status¶
Usage: zero sourcing status [OPTIONS] {search_job_id}
Show the status of an async sourcing search job.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * search_job_id <str> [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing test-candidate¶
Usage: zero sourcing test-candidate [OPTIONS] COMMAND [ARGS]...
Create safe test sourced candidates.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ add Create or reuse a sourced-style test candidate for a job. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
sourcing test-candidate add¶
Usage: zero sourcing test-candidate add [OPTIONS]
Create or reuse a sourced-style test candidate for a job.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --job -j <str> Job UUID (uses current job if omitted). │
│ * --email <str> Safe test candidate email [required] │
│ * --phone <str> Safe test candidate phone [required] │
│ --first-name <str> First name [default: Jenny] │
│ --last-name <str> Last name [default: Outreach Test Candidate] │
│ --current-title <str> Current title [default: Junior Sales Representative] │
│ --current-company <str> Current company [default: Demo Candidate Co] │
│ --location <str> Candidate location [default: Remote] │
│ --employer-id <str> │
│ --json │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
status¶
Usage: zero status [OPTIONS] COMMAND [ARGS]...
Check your jobs and pipeline.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ show Show all your jobs with applicant counts and progress. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
status show¶
Usage: zero status show [OPTIONS]
Show all your jobs with applicant counts and progress.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected) │
│ --active-only Drop inactive rows. Does NOT restrict to jobs you created; use --mine for that. │
│ --mine Show only jobs you created. Requires the backend to expose `created_by_user_id` (ZER-563); if it doesn't, a warning is printed to stderr and all employer jobs are │
│ shown. │
│ --tag <str> Filter to jobs tagged [<name>] in the title (case-insensitive). │
│ --since <str> ISO date (e.g. 2026-04-01). Keep jobs created on/after this date. │
│ --search <str> Case-insensitive substring match on job title. │
│ --sort <str> Sort by: created, title, applicants, status. │
│ --order <str> Sort direction: asc, desc. Only used with --sort. [default: desc] │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
team¶
Usage: zero team [OPTIONS] COMMAND [ARGS]...
Manage team members.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ list List team members for an employer. │
│ add Backward-compatible alias for ``team invite``. │
│ invite Send a team invitation email. │
│ remove Remove a team member from an employer. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
team add¶
Usage: zero team add [OPTIONS]
Backward-compatible alias for ``team invite``.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --email <str> Email of user to add [required] │
│ --employer-id <str> Deprecated; invitations use the employer bound to your login. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
team invite¶
Usage: zero team invite [OPTIONS]
Send a team invitation email.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * --email <str> Email of user to invite [required] │
│ --employer-id <str> Target employer UUID (ZER-1185). Defaults to your own employer when omitted. Only an allowlisted demo-admin may target a different employer, and only when it's │
│ flagged is_demo=true (e.g. inviting a presenter to a demo org created via `demo account`/MCP) -- anyone else passing a non-own employer gets a 403 from the backend. │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
team list¶
Usage: zero team list [OPTIONS]
List team members for an employer.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
team remove¶
Usage: zero team remove [OPTIONS] {user_id}
Remove a team member from an employer.
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ * user_id <str> User UUID to remove [required] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --employer-id <str> Employer UUID (auto-detected from login) │
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
update¶
Usage: zero update [OPTIONS]
Download the latest standalone CLI binary into ~/.zerohiring/bin/zero.
Re-run this after releases to replace stale PyInstaller installs. Also
removes broken legacy ``zerohiring`` pip shims that shadow the real CLI.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --force Re-download the latest binary even if the running version matches. │
│ --json Emit machine-readable JSON. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
whoami¶
Usage: zero whoami [OPTIONS]
Show current login status.
Hits the backend `/api/cli-auth/whoami` endpoint so the answer reflects
the *actual* identity of the stored token — not whatever got cached in
the local config file. This matters because a stale `employer_id` in
`~/.zerohiring/config.json` previously made it look like the CLI was
acting on one account while actually hitting another.
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --json Raw JSON output │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯