jananthan30/resume-builder/tailor-resume

Tailor Resume Only — Native Four-Role Team

Optimize and tailor the resume using concurrent shell and file operations for speed. Target: Evidence Match ≥ 75% with zero must-haves lacking evidence, using AUTHENTIC content. Evidence Match reports which of the job's requirements the resume actually evidences, quoting the exact excerpt behind each; legacy ATS/HR scores are diagnostic only.

Job Description

The user provides the target job description when invoking this skill; treat that text as the exact JD throughout.

CANDIDATE-FIT PREFLIGHT (MANDATORY FIRST GATE)

Before scorer startup, research, resume development, any role/native-team invocation, output/application-directory creation, DOCX generation, or tracker work, resolve master_resume_path from config.json and put this exact job description in a private temporary UTF-8 file. Screen only that configured master resume—never a previously tailored resume. Generate one safe run_id, one safe case_id, and one strict ISO as_of_date, then run:

python candidate_fit_preflight.py --resume <configured-master-resume> --job-description <private-exact-JD.txt> --run-id <run_id> --case-id <case_id> --as-of-date <YYYY-MM-DD> --json

Require exit 0 and a valid candidate-fit-policy-v3 report bound to the same IDs, date, master SHA-256, and exact-JD SHA-256. Canonically hash it as candidate_fit_report_digest. Continue only with exact threshold 70.0, score at least 70, trustworthy extraction, zero hard knockouts, passed: true, and no codes. Exit 1, a score below 70 (including 60–69), or any hard knockout is REJECTED:CANDIDATE_FIT; create no application directory, draft, DOCX, or tracker row and invoke no role or native team. Exit 2 or an unavailable, malformed, stale, non-canonical, or digest-mismatched report is FAILED:CANDIDATE_FIT_PREFLIGHT and fails closed. There is no automatic or manual workflow bypass. ATS and HR baselines are separate advisory diagnostics and cannot override this gate.

Instructions

You are the coordinator, not the resume author. The user has provided a job description. Execute the following phases, keeping independent scoring and file work concurrent where safe.

NATIVE RESUME TEAM (mandatory)

Only after candidate fit passes, read the resume-team skill (skills/resume-team/SKILL.md), run its host preflight, and invoke native_resume_team.py for the current host with the same run/case IDs, as_of_date, exact private JD file, and a prospective non-existing output path. Do not create the path first. Do not manually reproduce the role sequence for a publishable draft. The runtime runs resume-researcher -> resume-writer -> resume-auditor, then resume-editor only after FAIL, followed by a fresh Auditor. It validates handoff digests, parents, distinct identities, and replay state and allows at most two Editor corrections. The coordinator must not author or silently repair resume prose. Require macOS or Linux; Windows preflight fails closed with POSIX_RUNTIME_REQUIRED.

For Codex only, omit model flags by default because the hardened subprocess ignores user configuration and transient parent-session settings; do not claim an inherited profile, model, or Ultra setting. Add --model <exact-model> and/or --reasoning-effort ultra only when explicitly requested. There is no runtime profile option, and Claude must not receive Codex-only pins.

Accept the resume-team-result/v2 runtime result only on exit 0, terminal_class: PUBLISHED, and an independent SHA-256 match between final_draft_digest and the published resume.md. Require candidate_fit_report and candidate_fit_report_digest to exactly match the independently validated preflight. This is only an authorized, digest-verified Markdown draft-stage artifact—not a completed resume package. This skill must still create and verify the resume DOCX, update and verify the tracker, clean up only after those gates, and complete its final report before reporting package completion.

If the runtime's defense-in-depth recomputation returns REJECTED:CANDIDATE_FIT or FAILED:CANDIDATE_FIT_PREFLIGHT, require the prospective output path to remain absent and stop without any role result, finalization, or fallback draft.

The PUBLISHED result must also contain an inline resume-team-final-receipt/v2 authorization_receipt, its authorization_receipt_digest, and a durable authorization_receipt_path. Resolve it against the output directory when relative and require its resolved parent to equal the resolved output directory. Read only a regular, non-symlink JSON file; validate schemas/resume-team-final-receipt.schema.json, recompute its canonical digest, and match both receipt fields. Require matching run/case IDs; require the receipt's candidate-fit report and digest to match the runtime and independent preflight; and bind draft_digest and verified_target_digest to final_draft_digest and the independently hashed resume.md. Recompute source_digest from the current configured master and job_description_digest from the fixed sibling job_description.txt; require a SHA-256 Researcher artifact and distinct same-host native Researcher/Auditor identities. Require exact auditor_attestation with a native agent ID, SHA-256 artifact digest, PASS verdict, and the same draft digest. Require exact authorization_report with the same draft, passed: true, no codes, and exactly three ordered named PASS votes—evidence, human_voice, canonical_integrity—with no codes, the same draft, and distinct invocation IDs. Its canonical digest must equal authorization_digest, and vote_invocation_ids must equal the vote IDs in order. Require a publication ID. Fail closed on any missing, malformed, stale, or mismatched value, and preserve the durable sidecar during cleanup.

Draft-stage publication requires a final Auditor PASS plus three independent exit-0 votes on the exact same final digest: evidence_audit.py, human_voice_audit.py, and resume_integrity_audit.py. Scores are advisory and cannot override these gates.

Authorization is byte-specific and immutable. Once the runtime publishes the authorized draft, the coordinator, scorers, and audits must not edit, rewrite, normalize, format, or otherwise alter resume.md. Any desired change invalidates the run and requires a complete new resume-team/v2 sequence under a fresh run_id; never reuse its handoffs, role outputs, Auditor verdict, votes, or digest. All writing guidance in this skill is for native role agents in a fresh run, not the coordinator.

PHASE 0: SCORER SERVER PRE-FLIGHT

Check if the scorer server is running:

curl -s http://localhost:8100/health

• If server responds with {"status":"ok",...}: Proceed immediately (scoring calls will take <2s each).
• If server NOT running: Start it in background:

Start this as a background shell session from the repo root:
cd "." && python scorer_server.py --port 8100

Then retry /health up to 45 seconds (models take ~30s to load). Once healthy, proceed.

• Fallback: If server can't start after 45s, fall back to CLI pattern (python ats_scorer.py --score ... --json).

PHASE 1: READ-ONLY MASTER/JD PLANNING

The candidate-fit gate is already complete. Keep the configured master resume as the sole base and factual source; do not search for or use a prior tailored resume.

• Read the configured master for canonical job titles, dates, companies,

education, certifications, publications, and memberships.

• Extract company and role only to derive a prospective sanitized

applications/{CompanyName} - {JobTitle}/ path. Require it not to exist; do not create it or save the JD there.

• Complete read-only JD planning for the fresh native run. Planning cannot alter or

waive the passing candidate-fit report.

PHASE 2: NATIVE TEAM, THEN ADVISORY BASE SCORING

Invoke the mandatory native runtime first with the exact private JD, prospective non-existing output path, and the same run_id, case_id, and as_of_date used for preflight. The runtime independently recomputes candidate fit before it creates the output directory or invokes Researcher. Require the runtime report and digest to exactly match the independently validated preflight.

Only after an authorized PUBLISHED result has been verified may ATS/HR base scoring run. Score the configured master resume, never a previous tailored resume. These scores are advisory and needed only for the final comparison report.

Background Task A — Combined Base Score (ATS + HR):

Run in a background shell session named `base-scorer` if available:
curl -s -X POST http://localhost:8100/score/both -H "Content-Type: application/json" -d "{\"resume_path\": \"{configured_master_resume_path}\", \"jd_path\": \"applications/{folder}/job_description.txt\"}"

Fallback (if server not running): Run python ats_scorer.py --score ... --json and python hr_scorer.py --score ... --json against the configured master and exact fixed JD as separate shell scoring commands.

NATIVE RESUME TEAM — Invoke the mandatory runtime above. It atomically writes the authorized resume.md; do not write or save the role output again. Independently recompute the published file's SHA-256 and require it to equal final_draft_digest. Record this as draft-stage authorization only, not package completion.

The runtime has already published resume.md; never save, rewrite, normalize, or otherwise alter it.

CRITICAL .md FORMATTING RULE: Do NOT use ** (markdown bold asterisks) anywhere in resume.md files. Write metrics and text as plain text (e.g., "11,300+ ICU stays" not "11,300+ ICU stays"). The DOCX generator handles bold formatting automatically — asterisks in .md files cause display issues.

PHASE 3: PARALLEL TAILORED SCORING (launch both simultaneously)

Once the runtime-published resume.md and its receipt are verified, run tailored scoring in a background shell session:

Task C0a — Confirm the gaps only the applicant can resolve (ask BEFORE writing):

Step 1 — get the questions. --interactive needs a real terminal and exits 2 here; ask in the conversation instead.

python -c "
import json
from evidence_engine.audit import ResultCache
from evidence_engine.engine import match_resume_to_job
from evidence_engine.questions import build_questions
jd = open('applications/{folder}/job_description.txt').read()
r = match_resume_to_job('{configured_master_resume_path}', jd, cache=ResultCache())
print(json.dumps({'resume_sha256': r.resume_sha256, 'job_sha256': r.job_sha256,
                  'questions': [q.model_dump() for q in build_questions(r)]}, indent=2))
"

No questions means no gaps worth interrupting for — skip to Task C1.

Step 2 — put each question to the applicant and wait. One at a time, in their own words, showing why_it_matters. Offer exactly yes / no / not sure. On a "yes", ask briefly where they did it.

Never answer on the applicant's behalf and never infer an answer from the resume — the resume is precisely what failed to establish it. If they do not respond, the gap stays unresolved; silence is not a "no".

Step 3 — write the answers to a file, one object per answer, copying both digests verbatim from Step 1:

cat > "applications/{folder}/gap_answers.json" <<'JSON'
[
  {"requirement_id": "R2", "answer": "yes", "detail": "Ran vendor oversight at Acme for 3 years",
   "resume_sha256": "<from step 1>", "job_sha256": "<from step 1>"}
]
JSON

answer is yes, no, or unsure. The digests bind an answer to this exact resume and job, so a "yes" from another application cannot be replayed here.

Step 4 — apply them: