Apply - Single Job or Batch Queue

Two modes, one shared apply loop:

• Single-job (argument is a URL or pasted job page): fit review → user "yes" → apply one.
• Batch (no argument): drain /api/queue/pending → score → ranked table approval → apply all.

User approves once up front. No per-job confirmation after that.

Setup

Follow ../../shared/setup.md to load profile, resume, credentials.

JOBPILOT_API="${JOBPILOT_API:-https://jobpilot.suxrobgm.net}"

Read autoApply for config (defaults applied per field):

For ATS portals (Greenhouse, Lever, Workday, etc.) the apply step lands on a domain that isn't in /api/job-boards; the job-worker handles login/registration there per ../../shared/auth.md.

Phase 0: Dispatch

• Argument is campaign <campaign-id> → re-apply mode: set CAMPAIGN_ID=<campaign-id>, set config.maxApplications = null (unlimited - the user hand-selected these jobs), skip Phases 1-4, and run the Phase 5 loop over its current approved jobs. (The campaign viewer - or the rescan-skipped skill - promotes the chosen skipped/failed jobs to approved before injecting this.)
• Any other argument present → Phase 1 (single-job).
• No argument → Phase 2 (batch).

Phase 1: Single-Job Mode

If the argument is pasted content (HTML / text), extract description, Apply URL, company, title. If no Apply URL can be found, stop: "I need either a job URL or content with a visible Apply link."

1.1 Fit Review

URL input → delegate to the job-worker subagent with mode:"review" so the posting snapshot stays out of this conversation: { "mode":"review", "url":"<job-url>", "resumeId":"<primary-or-empty>" }. Use its returned matchScore/strongMatches/partialMatches/gaps/blockers/visaRisk/verdict to fill the review below; keep its digest as DIGEST for 1.4.

Pasted input → parse the fields yourself (the content is already in hand), build the digest (../../shared/digest-schema.md), and POST /api/score-fit for the score. Keep the digest in DIGEST=... for 1.4.

## Job Fit Review: [Title] at [Company]

**Match Score: X/100**

**Strong Matches:** [skill - evidence]
**Partial Matches:** [skill - what's adjacent]
**Gaps:** [skill - what's missing]
**Visa/Sponsorship Risk:** [if mentioned]
**Verdict:** [1-2 sentence recommendation]

Ask: "Want me to proceed with the application?" - yes/go continue, anything else stop.

1.2 Dedupe Check

URL_ENCODED=$(jq -rn --arg v "<job-url>" '$v|@uri')
TITLE_ENCODED=$(jq -rn --arg v "<title>" '$v|@uri')
COMPANY_ENCODED=$(jq -rn --arg v "<company>" '$v|@uri')
curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" "$JOBPILOT_API/api/applied/check?url=$URL_ENCODED&title=$TITLE_ENCODED&company=$COMPANY_ENCODED"

If .applied === true, surface the match (title + company + appliedAt + .match.kind) and ask whether to proceed anyway. Stop on no.

1.3 Create Campaign-of-1

CAMPAIGN=$(curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" -X POST "$JOBPILOT_API/api/campaigns" \
  -H 'content-type: application/json' \
  -d "$(jq -n --arg query "<title> at <company>" \
    '{query:$query, source:"apply", config:{maxApplications:1}}')")
CAMPAIGN_ID=$(echo "$CAMPAIGN" | jq -r '.campaignId')

1.4 Add the Job

JOB_KEY=$(date -u +%s)-single
curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" -X POST "$JOBPILOT_API/api/campaigns/$CAMPAIGN_ID/jobs" \
  -H 'content-type: application/json' \
  -d "$(jq -n --arg key "$JOB_KEY" --arg title "<title>" --arg company "<company>" \
    --arg location "<location>" --arg url "<job-url>" --arg board "<board>" \
    --arg matchReason "<one-line verdict>" --argjson score <0-100> \
    --arg digest "$DIGEST" --arg desc "<posting text>" \
    '{key:$key, title:$title, company:$company, location:$location, url:$url, board:$board, matchScore:$score, matchReason:$matchReason, status:"approved", digest:$digest, description:$desc}')"

Keep $CAMPAIGN_ID and $JOB_KEY. Live view: $JOBPILOT_WEB/campaigns/<CAMPAIGN_ID>. Jump to Phase 5.

Phase 2: Batch Mode

2.1 Pull Queue

curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" "$JOBPILOT_API/api/queue/pending"

data is [{ id, url, note, status }]. If empty, tell user to open $JOBPILOT_WEB/queue to add URLs and stop. Otherwise: "Found N URLs in the queue. Visiting each to gather details..."

2.2 Create Campaign

CAMPAIGN=$(curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" -X POST "$JOBPILOT_API/api/campaigns" \
  -H 'content-type: application/json' \
  -d '{"query":"apply queue","source":"apply","config":{"minScore":6,"maxApplications":10}}')
CAMPAIGN_ID=$(echo "$CAMPAIGN" | jq -r '.campaignId')

Phase 3: Visit and Score (Batch Only)

For each queue URL:

3.1 Pre-dedupe (no tab)

URL_ENCODED=$(jq -rn --arg v "<job-url>" '$v|@uri')
curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" "$JOBPILOT_API/api/applied/check?url=$URL_ENCODED"

If applied, mark the queue entry consumed, create the Job as pending, then POST its /result with outcome:"skipped", skipReason:"Already applied (<kind>)"; continue without spawning a worker.

3.2 Score (delegate to job-worker)

Delegate the visit + score to the job-worker subagent - it opens its own tab, reads the posting, fuzzy-dedupes by title+company, scores, applies eligibility (../../shared/eligibility.md), and saves the Job row itself (so the full posting/digest never enters this conversation). One worker at a time. Input JSON:

{ "mode": "score", "campaignId": "<CAMPAIGN_ID>", "jobKey": "<entry-id>", "url": "<job-url>",
  "board": "<domain>", "minMatchScore": <minMatchScore>, "resumeId": "<RESUME_ID>" }

It returns { outcome:"scored", jobKey, title, company, location, matchScore, confidence, eligible, skipReason, matchReason }. Collect these summaries for the ranked table (Phase 4) - the worker has already written each Job as pending (eligible) or skipped (with skipReason).

Phase 4: Batch Confirmation (Batch Only)

Auto mode (confirmMode: "auto" AND every qualified job ≥ threshold): PATCH all to approved, go to Phase 5.

Batch mode (default): present ranked table.

## Batch Apply

Visited <total> jobs. <qualified> qualify (score >= minMatchScore/100).

| # | Score  | Title | Company | Location | Board |
|---|--------|-------|---------|----------|-------|

**Commands:** "go" | "go 1,3,5" | "remove 3" | "details 2" | "stop"

Use PATCH only for approval; record every skip through /result:

• go → all qualified to approved
• go N,M → selected to approved; rest to skipped ("Not selected by user")
• remove N → that job to skipped ("Removed by user"); re-present table
• stop → POST /api/campaigns/$CAMPAIGN_ID/status with {status:"paused", actor:"user", reason:"Stopped from the terminal"} and stop

curl -fsS -H "authorization: Bearer $JOBPILOT_API_TOKEN" -X PATCH "$JOBPILOT_API/api/campaigns/$CAMPAIGN_ID/jobs/<key>" \
  -H 'content-type: application/json' -d '{"status":"approved"}'

Phase 5: Apply Loop

For each `approve