--- name: pp-uber-jobs description: "Every public Uber job posting as one tracker-ready JSON feed with offline history, new-since diffs and a fallback when the careers site refuses. Trigger phrases: `find uber jobs in the uk`, `what uber jobs were posted this week`, `is this uber job still open`, `where is uber hiring`, `use uber-jobs`, `run uber-jobs`." author: "qazmataz" license: "Apache-2.0" argument-hint: " [args] | install cli|mcp" allowed-tools: "Read Bash" metadata: openclaw: requires: bins: - uber-jobs-pp-cli install: - kind: go bins: [uber-jobs-pp-cli] module: github.com/mvanhorn/printing-press-library/library/productivity/uber-jobs/cmd/uber-jobs-pp-cli --- # Uber Careers — Printing Press CLI ## Prerequisites: Install the CLI This skill drives the `uber-jobs-pp-cli` binary. **You must verify the CLI is installed before invoking any command from this skill.** If it is missing, install it first: 1. Install via the Printing Press installer. It defaults binaries to `$HOME/.local/bin` on macOS/Linux and `%LOCALAPPDATA%\Programs\PrintingPress\bin` on Windows: ```bash npx -y @mvanhorn/printing-press-library install uber-jobs --cli-only ``` 2. Verify: `uber-jobs-pp-cli --version` 3. Ensure the reported install directory is on `$PATH` for the agent/runtime that will invoke this skill. If the `npx` install fails (no Node, offline, etc.), fall back to a direct Go install (requires Go 1.26.6 or newer). This installs into `$GOPATH/bin` (default `$HOME/go/bin`), so add that directory to `$PATH` instead: ```bash go install github.com/mvanhorn/printing-press-library/library/productivity/uber-jobs/cmd/uber-jobs-pp-cli@latest ``` If `--version` reports "command not found" after install, the runtime cannot see the binary directory on `$PATH`. Do not proceed with skill commands until verification succeeds. Pull open Uber postings by country, team or keyword into the single envelope a job tracker already parses, keep a local history of what opened and closed, and screen descriptions for sponsorship or language disqualifiers with the matching sentence shown. When the careers site refuses a request, reads fall back to Uber's own Oracle candidate-experience API instead of returning nothing. That fallback has limits: description and job_category are null; --team, --sub-team, --contract-type, --work-pattern and the description filters have no fallback (the command exits 7 instead); neither do facets or the raw careers commands; and new does not diff saved searches that use a keyword. ## When to Use This CLI Use this CLI when an agent needs Uber's public job postings as structured data, such as building a shortlist for a market, keeping a job tracker's Uber rows current, or reporting where Uber is hiring. It never writes to Uber: sync, save, searches --delete and new write only the CLI's local store. Run sync on a schedule to build the history that check, stats and screen read offline, so repeated checks report only what changed. ## Anti-triggers Do not use this CLI for: - Applying to an Uber job or filling in an application form - Subscribing to Uber job alerts or managing a candidate profile - Job postings at any employer other than Uber - Uber rides, Uber Eats or any other Uber product API ## Unique Capabilities These capabilities aren't available in any other tool for this API. ### Local history that compounds - **`new`** — See which Uber postings appeared in or closed from a saved search since its last complete scan _Reach for this on a recurring check of a market so an agent reports only what changed instead of re-listing everything. Create the name with save first (an unknown name exits 3); the first run only takes the baseline; when the careers site refuses, saved searches with a keyword are not diffed, and ones with a work pattern exit 7 (or, in auto mode, use the last local sync)_ ```bash uber-jobs-pp-cli new uk-strategy --agent ``` - **`check`** — Report whether each known posting id is still open, closed, never seen or unknown, with the date it closed _Use this to keep tracker rows honest in one call instead of one lookup per id_ ```bash uber-jobs-pp-cli check 302906 160425 --json ``` - **`stats`** — Count open, newly posted, opened and closed Uber postings per country, team, subteam or category _Use this for a market read-out of where Uber is hiring and how fast roles turn over; opened_30d and closed_30d stay null until the local store's first complete sync is 30 days old, and are always null on a live read. In auto mode it counts from the last local sync whatever its age (meta.note gives the date)_ ```bash uber-jobs-pp-cli stats --by country --json ``` - **`save`** — Store a named set of filters so new can diff it on every later run _Use this once per recurring market check before running new_ ```bash uber-jobs-pp-cli save uk-strategy --country GBR --base-query strategy ``` - **`searches`** — Show every saved search with its filters, baseline size and last advance, or delete one by name _Use this to audit what new will diff, or to prune stale searches_ ```bash uber-jobs-pp-cli searches --json ``` ### Screening without reading every posting - **`screen`** — Keep or drop postings by phrases in their description and show the sentence each phrase matched _Use this to rule out postings that need sponsorship, relocation or a language, with the evidence sentence an agent can quote. The match is literal, so read the sentence (--verdict all) to judge negations. Check meta.source: under the Oracle fallback descriptions are null, every posting is unscreened and the default --verdict keep is empty. In auto mode it reads the last local sync whatever its age (meta.note gives the date)_ ```bash uber-jobs-pp-cli screen --country NLD --posted-within 7d --exclude "fluent Dutch" --verdict all --agent ``` ### Tracker-ready reads - **`postings`** — List Uber postings for an ISO3 market, newest first, in the single envelope a job tracker parses _Use this as the default read for any market pull; it keeps the tracker's flags and field names stable_ ```bash uber-jobs-pp-cli postings --country GBR --limit 100 --offset 0 --sort recent --json --data-source live ``` - **`get`** — Fetch one Uber posting by its id and exit not-found when the site no longer lists it _Use this when an agent has one id and needs the full posting or a reliable gone signal_ ```bash uber-jobs-pp-cli get 302906 --json ``` - **`facets`** — List the countries, teams, subteams, contract types and work patterns the careers site currently offers _Use this before filtering so team and country values match the site exactly_ ```bash uber-jobs-pp-cli facets --json ``` ## Command Reference **careers** — Raw Uber careers search and id lookup, faithful to the site API wire keys - `uber-jobs-pp-cli careers lookup` — Look up Uber careers postings by id through the site's batch lookup; unknown ids are silently dropped - `uber-jobs-pp-cli careers search` — Search Uber careers postings with the site's own query keys and page numbering **sync** — Mirror every open posting into the local store - `uber-jobs-pp-cli sync --json` — Read the whole corpus and record first_seen, last_seen and closures; `check`, `stats` and `screen` then answer offline. Run it on a schedule; a keyword-scoped or partial read never marks closures, and a fallback sync (meta.source oracle-ce) keeps stored descriptions but marks no closures and does not count as a complete sync for check, stats, screen or new ### Finding the right command When you know what you want to do but not which command does it, ask the CLI directly: ```bash uber-jobs-pp-cli which "" ``` `which` resolves a natural-language capability query to the best matching command from this CLI's curated feature index. Exit code `0` means at least one match; exit code `2` means no confident match — fall back to `--help` or use a narrower query. `--json` (and other machine formats) keep that exit-2 contract and write `{"matches":[]}` on stdout so agents can inspect the envelope without treating a miss as success. ## Recipes ### Newest postings in a market ```bash uber-jobs-pp-cli postings --country USA --limit 50 --sort recent --agent --select results.id,results.title,results.posted_on,results.location ``` Narrows a large envelope to the four fields an agent needs for a shortlist ### Postings from the last 7 days ```bash uber-jobs-pp-cli postings --country GBR --posted-within 7d --sort recent --json ``` Answers "what is new this week" without a saved search; recency comes from the true posting date ### Weekly new-since check ```bash uber-jobs-pp-cli new --all --json ``` Runs every saved search and returns what appeared or closed since each baseline ### Screen out language requirements ```bash uber-jobs-pp-cli screen --country NLD --exclude "fluent Dutch" --verdict all --json ``` Gives every Netherlands posting a keep or drop verdict and quotes the sentence each phrase matched; the match is literal, so a negation such as "no fluent Dutch needed" also drops ### Are my tracked postings still open ```bash uber-jobs-pp-cli check 302906 160425 --json ``` One call returns open, closed, never_seen or unknown for each id ### Build the local history ```bash uber-jobs-pp-cli sync --json ``` Run it daily: closures get dates, and check, stats and screen answer from the local store ## Auth Setup No account and no key are needed because the CLI reads public postings only and never signs in, applies or subscribes to alerts Run `uber-jobs-pp-cli doctor` to verify setup. ## Agent Mode Add `--agent` to any command. Expands to: `--json --compact --no-input --no-color`. Global format flags share one contract on promoted, novel, sync, and `--deliver` paths: - `--json` — one JSON document on stdout - `--compact` — keep identity/status/timestamp fields; does not change the document vs stream shape - `--csv` / `--plain` — tabular rows (collection envelopes unwrap to the row array) - `--quiet` — one identity value per row, no envelope - **Pipeable** — JSON on stdout, errors on stderr - **Filterable** — `--select` keeps a subset of fields. Dotted paths descend into nested structures; arrays traverse element-wise. Critical for keeping context small on verbose APIs: ```bash uber-jobs-pp-cli careers search --agent --select Id,Reference,Title ``` - **Previewable** — `--dry-run` shows the request without sending - **Non-interactive** — never prompts, every input is a flag - **Never writes to Uber** — read-only toward the site; `sync`, `save`, `searches --delete` and `new` write only the CLI's local store. Do not use it to apply, subscribe, or change anything on Uber ## Paths and state Agents should treat the CLI's path resolver as part of the runtime contract: - Use `--home ` for one invocation, or set `UBER_JOBS_HOME=` to relocate all four path kinds under one root. - Use per-kind env vars only when a specific kind must diverge: `UBER_JOBS_CONFIG_DIR`, `UBER_JOBS_DATA_DIR`, `UBER_JOBS_STATE_DIR`, `UBER_JOBS_CACHE_DIR`. - Resolution order is per-kind env var, `--home`, `UBER_JOBS_HOME`, XDG (`XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_STATE_HOME`, `XDG_CACHE_HOME`), then platform defaults. - `config` contains settings like `config.toml` and profiles. `data` contains `data.db`, the local posting store that `sync`, `save` and `new` write. `state` contains the machine-wide request gate, `refusals.tsv`, the `refused-.json` refusal latches, and `teach.log`. `cache` contains regenerable HTTP/cache files. - Run `uber-jobs-pp-cli doctor --fail-on warn` to surface path warnings. `agent-context` exposes a schema v4 `paths` block for agents that need the resolved dirs. - For MCP, pass relocation through the MCP host config. The MCP binary does not inherit CLI flags: ```json { "mcpServers": { "uber-jobs": { "command": "uber-jobs-pp-mcp", "env": { "UBER_JOBS_HOME": "/srv/uber-jobs" } } } } ``` Fleet precedence: an inherited per-kind env var overrides an explicit `--home` for that kind. Use `UBER_JOBS_HOME` or per-kind vars as durable fleet levers, and use `--home` only for a single invocation. Relocation is not reversible by unsetting env vars; move files manually before clearing `UBER_JOBS_HOME`, or the CLI will not find the local store left under the former root. ## Automatic learning This CLI ships a self-capturing learning loop. The CLI does its own bookkeeping: every invocation is journaled locally, a failed flag followed by a corrected retry auto-derives a `flag_alias` candidate, and a `teach` on a query family without a playbook auto-synthesizes a `playbook_candidate` from the session's journal. Your job is judgment only: `recall` first, act on surfaced candidates, `teach` the final answer, `playbook amend` when you observe a correction. You never record failures by hand. ### Step 1: `recall` before any discovery Before list/search/drill commands on a new user question, pass the question as an argv or MCP tool argument to `recall --agent`. Do not interpolate user-controlled text into a shell command line. Quoted `recall ""` breaks on an apostrophe, which is ordinary English. A quoted heredoc breaks when a body line equals the delimiter, and that delimiter is published in these docs. Write the question with a non-shell file-writing tool, then read it back as data: ```bash # Write the question verbatim with your file-writing tool (no shell involved). # Command substitution on a file only ever yields data — the shell never # parses the file's bytes as syntax. QUERY=$(cat /path/to/question.txt) uber-jobs-pp-cli recall "$QUERY" --agent ``` Prefer MCP: pass the question as the tool's query argument. `"$QUERY"` after a file read is argv-safe; putting the question itself in the command text is not. The response envelope: ```json { "query": "...", "normalized": "", "query_entities": ["..."], "found": true | false, "match_score": 0.0, "results": [ { "resource_id": "...", "resource_type": "...", "venue": "...", "confidence": 2, "entity_match": "exact|partial|unknown", "source": "taught|preseed|pattern", "warnings": ["..."] } ], "mismatches": [ /* only when --debug-mismatches */ ], "warnings": [ /* top-level */ ], "candidates": [ { "id": 12, "class": "flag_alias | playbook_candidate", "summary": "...", "sightings": 3, "last_seen": "...", "rationale": "...", "next_action": ["", "uber-jobs-pp-cli learnings confirm 12"] } ], "playbook": { "query_family": "...", "playbook": { "steps": [ { "cmd": "", "purpose": "..." } ], "entity_slots": ["$ENTITY"], "expected_tool_calls": 3 }, "slots_resolved": { "$ENTITY": { "token": "", "canonical": "" } }, "notes": "" }, "notes": "" } ``` Empty-store short-circuit: if the store has no learnings, playbooks, or candidates yet (recall finds nothing and `learnings list` and `learnings candidates` are both empty), skip recall for the rest of this session instead of taxing every query; resume recall-first once something has been taught. ### Step 2: decision tree Read `candidates`, `playbook`, `notes`, `results[0]`, and warnings in that order: ``` if Candidates present (warnings include "candidates_present"): -> candidates are try-then-confirm, never facts. Follow each candidate's two-step next_action verbatim: run the trial command first, then run `learnings confirm ` only after the trial verified the behavior. Reject a wrong candidate with `learnings reject `. -> NEVER re-teach something recall surfaced as a candidate; confirm or reject that candidate instead of teaching a duplicate. -> candidates ride alongside playbooks and resource hits, not instead of them; continue with the branches below after acting on them. if Playbook present: -> READ Playbook.notes verbatim FIRST (workarounds + gotchas the CLI surface doesn't expose) -> replay Playbook.steps in order, substituting Playbook.slots_resolved entries for the entity slot tokens. If a step's slot is unresolved, fall back to discovery for that step only. -> the Playbook's expected_tool_calls is a budget; if you find yourself running materially more, record the divergence via `uber-jobs-pp-cli playbook amend` at end-of-session. elif Notes present (no Playbook): -> read Notes verbatim before any discovery step; they carry known gotchas for this query family even when no structured choreography exists yet. elif Found AND Results[0].EntityMatch == "exact" AND Results[0].Confidence >= 2: -> skip discovery; fetch live data for Results[*].ResourceID in parallel elif Found AND Results[0].EntityMatch == "partial": -> candidate hint, NOT a hit; read the resource title to validate before trusting elif (any row in Mismatches[] when --debug-mismatches was passed): -> treat as cold start; the stored learning is for a different entity (different canonical resolved from query_entities) else: // Found == false, no playbook, no notes -> cold start; run discovery normally; teach the answer afterward (Step 4). If the family has no playbook yet, that teach auto-synthesizes a playbook candidate from this session's journal - you do not need to record one by hand. ``` Playbook and Notes are orthogonal to the per-resource path. A recall response can carry both a Playbook AND a `Results[]` hit - use both: the Playbook tells you which choreography to run; the resource hits short-circuit specific steps. Default to skipping `mismatches`; pass `--debug-mismatches` only when investigating cold-start surprises. Candidate judgment details: `learnings confirm ` prints the candidate's full payload before materializing it - check that the printed payload matches the behavior you verified. `learnings reject ` tombstones the derivation signature so the same candidate does not resurface. The envelope carries only the few candidates worth acting on now; `uber-jobs-pp-cli learnings candidates` lists the full open set. Graceful degradation: if `learnings confirm` is an unknown command, you are driving an older binary - ignore the candidates guidance and follow the rest of the protocol. ### Step 3: always read `warnings` - `low_confidence`: row exists at `confidence<2`. Treat as a hint, not a skip-discovery hit. - `resource_not_in_store`: the local store doesn't have the resource the learning points at. The match validator couldn't classify entities — direct-fetch and re-evaluate. - `cross_alias_match` (per-result): the row was taught under a different alias and matched the live query's canonical via `entity_lookups` (e.g., a "USA" teach satisfying a "United States" recall). Trust the resource_id. - `similar_shape_different_entity:` (top-level): a structurally matching row exists but its canonical entity differs from the live query's. Treated as cold start; the warning carries the conflicting canonical as a hint, but the row is NOT promoted into Results. - `ambiguous_alias` (top-level): a single query entity resolved to multiple canonicals (e.g., "Georgia" → the country GEO + a US state). Surface the ambiguity fro