claude-code-arcane 1.4.0 → 2.0.0

package/skills/job-scrape/scripts/linkedin_search.py

@@ -0,0 +1,428 @@
+"""
+linkedin_search.py - Search jobs on LinkedIn's public jobs-guest endpoints.
+
+Any country/region plus remote. No authentication, no API key, no dependencies
+beyond the Python 3 standard library.
+
+Usage:
+    python linkedin_search.py search -l "<place>" [flags]
+    python linkedin_search.py detail <id|url> [--format json|plain]
+
+Ported from the TypeScript CLI vendored from MadsLorentzen/ai-job-search: skill
+scripts run in the user's project without a build step, and TypeScript there
+means requiring Node 24+ for native type stripping (see docs/coding-standards.md).
+
+Personal use only. This reads LinkedIn's public job pages; automated access is
+against LinkedIn's Terms of Service, so keep volume low and do not use it
+commercially or for bulk data collection. Run it on your own responsibility.
+
+Errors go to stderr as {"error": "...", "code": "..."} with exit code 1;
+non-fatal diagnostics use the same shape with a "warning" key.
+"""
+
+import argparse
+import html
+import json
+import random
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+SEARCH_URL = "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search"
+DETAIL_URL = "https://www.linkedin.com/jobs-guest/jobs/api/jobPosting"
+
+UA = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+)
+
+# Below this size a response is empty/an error page, not a markup change.
+MARKUP_SANITY_BYTES = 5000
+
+MAX_RETRIES = 6
+JOBAGE_ALL = 9999
+
+
+def write_error(error, code):
+    sys.stderr.write(json.dumps({"error": error, "code": code}) + "\n")
+
+
+def write_warning(warning, code):
+    """Non-fatal diagnostic on stderr. Same JSON-line shape, `warning` key."""
+    sys.stderr.write(json.dumps({"warning": warning, "code": code}) + "\n")
+
+
+def html_fetch(url):
+    """Fetch HTML with exponential backoff on 429/5xx. Returns "" on a 404."""
+    delay = 0.5
+    for attempt in range(MAX_RETRIES + 1):
+        request = urllib.request.Request(
+            url,
+            headers={
+                "User-Agent": UA,
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+                "X-Requested-With": "XMLHttpRequest",
+            },
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=30) as response:
+                return response.read().decode("utf-8", errors="replace")
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                return ""
+            retryable = e.code == 429 or e.code >= 500
+            if not retryable or attempt == MAX_RETRIES:
+                raise RuntimeError(f"Request failed: {e.code} {e.reason}") from None
+            time.sleep(delay + random.random() * 0.5)
+            delay = min(delay * 2, 8)
+    raise RuntimeError("Request failed after max retries")
+
+
+def unescape(markup):
+    """
+    html.unescape plus &nbsp; -> plain space. U+00A0 is invisible in a diff and
+    breaks keyword matching downstream, which is the whole point of pulling the JD.
+    """
+    return html.unescape(markup).replace("\xa0", " ")
+
+
+def strip_tags(markup):
+    return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", markup)).strip()
+
+
+def clean(markup):
+    return unescape(strip_tags(markup))
+
+
+CARD_SPLIT_RE = re.compile(r'data-entity-urn="urn:li:jobPosting:')
+CARD_ID_RE = re.compile(r"^(\d+)")
+CARD_LINK_RE = re.compile(r'class="base-card__full-link[^"]*"[^>]*href="([^"]+)"', re.I)
+CARD_TITLE_RE = re.compile(r'class="base-search-card__title"[^>]*>(.*?)</h3>', re.I | re.S)
+CARD_SR_ONLY_RE = re.compile(r'class="sr-only"[^>]*>(.*?)</span>', re.I | re.S)
+CARD_SUBTITLE_RE = re.compile(r'class="base-search-card__subtitle"[^>]*>(.*?)</h4>', re.I | re.S)
+CARD_HREF_RE = re.compile(r'href="([^"]+)"', re.I)
+CARD_LOCATION_RE = re.compile(r'class="job-search-card__location"[^>]*>(.*?)</span>', re.I | re.S)
+CARD_DATE_RE = re.compile(r'class="job-search-card__listdate[^"]*"[^>]*datetime="([^"]+)"', re.I)
+
+
+def parse_job_cards(markup):
+    """
+    Parse the search response: a flat list of <li> job cards. We split on the
+    job-posting URN and parse each chunk independently so one malformed card
+    cannot break the rest.
+    """
+    results = []
+
+    for chunk in CARD_SPLIT_RE.split(markup)[1:]:
+        id_match = CARD_ID_RE.match(chunk)
+        if not id_match:
+            continue
+        job_id = id_match.group(1)
+
+        # Full link + title (title lives in the sr-only span or the <h3> title).
+        link_match = CARD_LINK_RE.search(chunk)
+        url = unescape(link_match.group(1)).split("?")[0] if link_match else ""
+
+        title = None
+        h3 = CARD_TITLE_RE.search(chunk)
+        if h3:
+            title = clean(h3.group(1))
+        if not title:
+            sr = CARD_SR_ONLY_RE.search(chunk)
+            if sr:
+                title = clean(sr.group(1))
+        if not title:
+            continue
+
+        # Company (subtitle <h4> with optional inner <a>).
+        company = None
+        company_url = None
+        sub = CARD_SUBTITLE_RE.search(chunk)
+        if sub:
+            href = CARD_HREF_RE.search(sub.group(1))
+            if href:
+                company_url = unescape(href.group(1)).split("?")[0]
+            company = clean(sub.group(1)) or None
+
+        # Location + date.
+        loc = CARD_LOCATION_RE.search(chunk)
+        location = (clean(loc.group(1)) or None) if loc else None
+        date_match = CARD_DATE_RE.search(chunk)
+
+        results.append(
+            {
+                "id": job_id,
+                "title": title,
+                "company": company,
+                "companyUrl": company_url,
+                "location": location,
+                "date": date_match.group(1) if date_match else None,
+                "url": url or f"https://www.linkedin.com/jobs/view/{job_id}",
+            }
+        )
+
+    # Regex parsing degrades silently when LinkedIn changes its markup: a page
+    # full of content yields zero cards, which reads exactly like "no job matches
+    # the query". Warn so the caller can tell the two apart.
+    if not results and len(markup) > MARKUP_SANITY_BYTES:
+        write_warning(
+            f"parsed 0 job cards out of a {len(markup)}-byte response; "
+            "LinkedIn markup may have changed",
+            "NO_CARDS_PARSED",
+        )
+
+    return results
+
+
+DETAIL_TITLE_RE = re.compile(
+    r'class="(?:top-card-layout__title|topcard__title)[^"]*"[^>]*>(.*?)</h[12]>', re.I | re.S
+)
+DETAIL_ORG_RE = re.compile(
+    r'class="topcard__org-name-link[^"]*"[^>]*href="([^"]+)"[^>]*>(.*?)</a>', re.I | re.S
+)
+DETAIL_LOCATION_RE = re.compile(
+    r'class="topcard__flavor topcard__flavor--bullet"[^>]*>(.*?)</span>', re.I | re.S
+)
+DETAIL_DESC_RE = re.compile(
+    r'class="(?:show-more-less-html__markup|description__text[^"]*)"[^>]*>(.*?)</div>', re.I | re.S
+)
+DETAIL_CRITERIA_RE = re.compile(
+    r'class="description__job-criteria-subheader"[^>]*>(.*?)</h3>'
+    r'.*?class="description__job-criteria-text[^"]*"[^>]*>(.*?)</span>',
+    re.I | re.S,
+)
+DETAIL_APPLY_RE = re.compile(r'class="topcard__link[^"]*"[^>]*href="([^"]+)"', re.I)
+BR_RE = re.compile(r"<\s*br\s*/?>", re.I)
+BLOCK_END_RE = re.compile(r"</(p|li|ul|ol|div|h\d)>", re.I)
+
+
+def parse_job_detail(markup, job_id):
+    """Parse the single-job detail page."""
+    title_match = DETAIL_TITLE_RE.search(markup)
+    org_match = DETAIL_ORG_RE.search(markup)
+    company = (clean(org_match.group(2)) or None) if org_match else None
+    company_url = unescape(org_match.group(1)).split("?")[0] if org_match else None
+
+    loc_match = DETAIL_LOCATION_RE.search(markup)
+    location = (clean(loc_match.group(1)) or None) if loc_match else None
+
+    # Rich description block. Keep paragraph/line breaks as newlines.
+    description = None
+    desc_match = DETAIL_DESC_RE.search(markup)
+    if desc_match:
+        with_breaks = BLOCK_END_RE.sub("\n", BR_RE.sub("\n", desc_match.group(1)))
+        description = re.sub(r"\n{3,}", "\n\n", unescape(strip_tags(with_breaks))).strip() or None
+
+    # Job-criteria items: subheader label -> text value.
+    criteria = {
+        clean(label).lower(): clean(value)
+        for label, value in DETAIL_CRITERIA_RE.findall(markup)
+    }
+
+    apply_match = DETAIL_APPLY_RE.search(markup)
+
+    return {
+        "id": job_id,
+        "title": clean(title_match.group(1)) if title_match else "(untitled)",
+        "company": company,
+        "companyUrl": company_url,
+        "location": location,
+        "date": None,
+        "url": f"https://www.linkedin.com/jobs/view/{job_id}",
+        "description": description,
+        "seniority": criteria.get("seniority level"),
+        "employmentType": criteria.get("employment type"),
+        "jobFunction": criteria.get("job function"),
+        "industries": criteria.get("industries"),
+        "applyUrl": unescape(apply_match.group(1)).split("?")[0] if apply_match else None,
+    }
+
+
+def jobage_to_tpr(days):
+    """Convert a job-age in days to LinkedIn's f_TPR seconds value."""
+    if not days or days <= 0 or days >= JOBAGE_ALL:
+        return None
+    return f"r{days * 86400}"
+
+
+def work_type_flag(mode):
+    """Workplace-type flag: on-site=1, remote=2, hybrid=3."""
+    return {"remote": "2", "hybrid": "3", "onsite": "1", "on-site": "1"}.get((mode or "").lower())
+
+
+def normalize_id(value):
+    """
+    Accept a raw job ID, a job-view URL, or a job URN. The ID may be followed by
+    a slash as well as a query string: the share button yields URLs shaped like
+    `/jobs/view/<id>/?refId=...`, so anchoring on `?` alone rejects the most
+    common paste.
+    """
+    urn = re.search(r"urn:li:jobPosting:(\d+)", value)
+    if urn:
+        return urn.group(1)
+    url = re.search(r"-(\d{6,})(?:[/?]|$)", value) or re.search(r"/(\d{6,})(?:[/?]|$)", value)
+    if url:
+        return url.group(1)
+    if re.fullmatch(r"\d{6,}", value):
+        return value
+    return None
+
+
+def build_search_url(args):
+    params = []
+    if args.query:
+        params.append(("keywords", args.query))
+    if args.location:
+        params.append(("location", args.location))
+    tpr = jobage_to_tpr(args.jobage)
+    if tpr:
+        params.append(("f_TPR", tpr))
+    work_type = work_type_flag(args.remote)
+    if work_type:
+        params.append(("f_WT", work_type))
+    params.append(("start", str((args.page - 1) * 10)))
+    return f"{SEARCH_URL}?{urllib.parse.urlencode(params)}"
+
+
+def render_table(cards):
+    if not cards:
+        return "No results."
+    header = (
+        "ID".ljust(11) + " " + "TITLE".ljust(42) + " " + "COMPANY".ljust(26) + " "
+        + "LOCATION".ljust(24) + " DATE"
+    )
+    rows = [
+        f"{c['id']:<11} {(c['title'] or '')[:42]:<42} {(c['company'] or '-')[:26]:<26} "
+        f"{(c['location'] or '-')[:24]:<24} {c['date'] or '-'}"
+        for c in cards
+    ]
+    return "\n".join([header, "-" * len(header), *rows])
+
+
+def render_plain(cards):
+    return "\n\n".join(
+        f"{c['title']}\n  {c['company'] or '-'} · {c['location'] or '-'} · {c['date'] or '-'}\n"
+        f"  id: {c['id']}\n  {c['url']}"
+        for c in cards
+    )
+
+
+def run_search(args):
+    try:
+        cards = parse_job_cards(html_fetch(build_search_url(args)))
+        if args.limit is not None and args.limit >= 0:
+            cards = cards[: args.limit]
+
+        if args.format == "table":
+            sys.stdout.write(render_table(cards) + "\n")
+        elif args.format == "plain":
+            sys.stdout.write(render_plain(cards) + "\n")
+        else:
+            payload = {"meta": {"count": len(cards), "page": args.page}, "results": cards}
+            sys.stdout.write(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+        return 0
+    except Exception as e:
+        write_error(str(e), "SEARCH_FAILED")
+        return 1
+
+
+def run_detail(args):
+    job_id = normalize_id(args.id)
+    if not job_id:
+        write_error(f'Could not parse a job ID from "{args.id}"', "BAD_ID")
+        return 1
+    try:
+        markup = html_fetch(f"{DETAIL_URL}/{job_id}")
+        if not markup:
+            write_error("Job not found", "NOT_FOUND")
+            return 1
+        job = parse_job_detail(markup, job_id)
+
+        if args.format == "plain":
+            lines = [
+                job["title"],
+                f"{job['company'] or '-'} · {job['location'] or '-'}",
+                "",
+                f"Seniority: {job['seniority']}" if job["seniority"] else "",
+                f"Employment: {job['employmentType']}" if job["employmentType"] else "",
+                f"Function: {job['jobFunction']}" if job["jobFunction"] else "",
+                f"Industries: {job['industries']}" if job["industries"] else "",
+                "",
+                job["description"] or "(no description)",
+                "",
+                f"URL: {job['url']}",
+                f"Apply: {job['applyUrl']}" if job["applyUrl"] else "",
+            ]
+            sys.stdout.write("\n".join(line for line in lines if line != "") + "\n")
+        else:
+            sys.stdout.write(json.dumps(job, indent=2, ensure_ascii=False) + "\n")
+        return 0
+    except Exception as e:
+        write_error(str(e), "DETAIL_FAILED")
+        return 1
+
+
+class JsonErrorParser(argparse.ArgumentParser):
+    """Keep the CLI's error contract: a JSON line on stderr and exit code 1."""
+
+    def error(self, message):
+        code = "NO_LOCATION" if "location" in message and "required" in message else "BAD_ARG"
+        write_error(message, code)
+        raise SystemExit(1)
+
+
+def build_parser():
+    parser = JsonErrorParser(
+        prog="linkedin_search.py",
+        description="Search jobs on LinkedIn (any country/region, plus remote). "
+        "Personal use only - uses LinkedIn's public pages; keep volume low (LinkedIn ToS).",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    search = sub.add_parser("search", help="search job postings")
+    search.add_argument("-l", "--location", required=True,
+                        help='REQUIRED. e.g. "Berlin, Germany", "Spain", "Remote"')
+    search.add_argument("-q", "--query", help="keywords (job title, skill, or role)")
+    search.add_argument("--jobage", type=int, default=JOBAGE_ALL,
+                        help="posted within N days: 1, 7, 14, 30. Default: all")
+    search.add_argument("--remote", choices=["remote", "hybrid", "onsite", "on-site"],
+                        help="filter by workplace type")
+    search.add_argument("--page", type=int, default=1, help="1-indexed page (10 results/page)")
+    search.add_argument("-n", "--limit", type=int,
+                        help="cap results emitted (client-side; 0 emits none)")
+    search.add_argument("--format", choices=["json", "table", "plain"], default="json")
+    search.set_defaults(func=run_search)
+
+    detail = sub.add_parser("detail", help="full detail of one posting")
+    detail.add_argument("id", help="job ID, jobs/view URL (with or without trailing slash), or URN")
+    detail.add_argument("--format", choices=["json", "plain"], default="json")
+    detail.set_defaults(func=run_detail)
+
+    return parser
+
+
+def force_utf8_streams():
+    """
+    On Windows stdout defaults to cp1252, so a bullet or an accent in a JD raises
+    UnicodeEncodeError the moment output is piped to a file. Node writes UTF-8
+    unconditionally; Python has to be told.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8")
+
+
+def main():
+    force_utf8_streams()
+    args = build_parser().parse_args()
+    if getattr(args, "page", 1) < 1:
+        args.page = 1
+    sys.exit(args.func(args))
+
+
+if __name__ == "__main__":
+    main()

package/skills/job-search/SKILL.md

@@ -7,7 +7,7 @@ user-invocable: true
 allowed-tools: Read, Glob, Grep, Write, Edit, WebFetch, WebSearch
 ---
 
-# Job Search — Búsqueda, scoring y plan
+# Job Search - Búsqueda, scoring y plan
 
 Encontrás ofertas, las **scoreás** contra el perfil del usuario, priorizás, y armás un **plan de búsqueda de 7 días** con objetivos diarios. Alimentás el workspace con notas de aplicación y empresa para que el resto del flujo (`/cv-tailor`, `/cover-letter`, etc.) las consuma.
 
@@ -18,45 +18,48 @@ Encontrás ofertas, las **scoreás** contra el perfil del usuario, priorizás, y
 
 ## Modos
 
-### `search <query>` — Encontrar ofertas
+### `search <query>` - Encontrar ofertas
+
+> Si el skill `job-scrape` está instalado, para corridas recurrentes preferí `/job-scrape`: usa CLIs locales (LinkedIn + GetOnBoard) con dedup entre corridas. Este modo queda para búsquedas puntuales o fuentes que los CLIs no cubren.
+
 1. **Sourcing.** Conseguir ofertas frescas que matcheen el perfil (rol + stack + modalidad + mercado). Dos caminos:
-   - **Apify MCP (opcional).** Si hay un MCP de Apify conectado, podés usar un actor de scraping de LinkedIn Jobs para traer ofertas estructuradas. Ejemplo de pedido: *"Scrapeá LinkedIn jobs para [rol] posteadas en los últimos 7 días en empresas de 50–5000 empleados; filtrá por match con mi background en [dominio]; devolvé tabla rankeada con empresa, rol, ubicación, salario, fecha de posteo y fit score 1–10 basado en mi resume; marcá el top 10 para aplicar hoy."* Buscá el actor con ToolSearch (`apify`) si el MCP está presente. **⚠️ OBLIGATORIO: antes de invocar Apify, mostrá el warning de abajo y pedí confirmación explícita.**
+   - **Apify MCP (opcional).** Si hay un MCP de Apify conectado, podés usar un actor de scraping de LinkedIn Jobs para traer ofertas estructuradas. Ejemplo de pedido: *"Scrapeá LinkedIn jobs para [rol] posteadas en los últimos 7 días en empresas de 50-5000 empleados; filtrá por match con mi background en [dominio]; devolvé tabla rankeada con empresa, rol, ubicación, salario, fecha de posteo y fit score 1-10 basado en mi resume; marcá el top 10 para aplicar hoy."* Buscá el actor con ToolSearch (`apify`) si el MCP está presente. **⚠️ OBLIGATORIO: antes de invocar Apify, mostrá el warning de abajo y pedí confirmación explícita.**
    - **WebSearch/WebFetch (default recomendado).** Camino sin Apify: buscar en job boards (muchos con feed/API pública: WeWorkRemotely, RemoteOK, etc.) y fetchear los JDs. Es el default seguro y gratis.
 
-> ### ⚠️ Warning Apify — mostralo SIEMPRE antes de usar esta parte
+> ### ⚠️ Warning Apify - mostralo SIEMPRE antes de usar esta parte
 >
 > Antes de correr cualquier actor de Apify (especialmente scraping de LinkedIn), presentá estos puntos al usuario y esperá confirmación explícita. No invoques Apify "en silencio".
 >
 > 1. **No es gratis.** Apify cobra por uso (compute units / por resultado); un scrape grande consume crédito. El tier free es limitado.
 > 2. **Scrapear LinkedIn viola sus Términos de Servicio.** LinkedIn detecta y bloquea scraping activamente y puede **restringir o banear la cuenta**. La legalidad de scrapear datos públicos está en zona gris (caso hiQ vs LinkedIn); el riesgo de ToS/cuenta es real y es del usuario, no de Apify. Preferir actors sobre **job boards públicos** antes que LinkedIn directo; si igual se scrapea LinkedIn, hacerlo de forma consciente y no con una cuenta crítica.
-> 3. **El API token de Apify es sensible.** Autoriza correr actors (y gastar el plan) en nombre del usuario. Mantenerlo seguro; no exponerlo ni commitearlo. (Apify no recolecta conversaciones/tokens y trata a los actors como no confiables: les da un proxy y no les entrega las credenciales — un actor malicioso puede usar las tools habilitadas pero no exfiltrar el token.)
+> 3. **El API token de Apify es sensible.** Autoriza correr actors (y gastar el plan) en nombre del usuario. Mantenerlo seguro; no exponerlo ni commitearlo. (Apify no recolecta conversaciones/tokens y trata a los actors como no confiables: les da un proxy y no les entrega las credenciales - un actor malicioso puede usar las tools habilitadas pero no exfiltrar el token.)
 > 4. **Calidad/estabilidad variable.** Los scrapers de LinkedIn se rompen seguido; los resultados pueden venir incompletos o desactualizados.
 >
 > Si el usuario no confirma, usá el camino WebSearch/WebFetch.
 2. Para cada oferta candidata: extraer rol, empresa, stack, modalidad, ubicación, rango salarial, link, fecha de cierre.
 3. Scorear (ver rúbrica) y filtrar por el umbral del perfil.
-4. Crear nota en `03-Aplicaciones/` (template `Aplicacion`, estado `interesado`, con `score`) + nota en `04-Empresas/` (template `Empresa`) por cada una sobre el umbral.
+4. Crear nota en `03-Aplicaciones/` (template `Aplicacion`, estado `interesado`, con `match_score`) + nota en `04-Empresas/` (template `Empresa`) por cada una sobre el umbral.
 5. Actualizar el `00-Dashboard.md` con las activas por prioridad, marcando el **top 10 para hoy**.
 
-### `score <job-url>` — Scorear una oferta puntual
+### `score <job-url>` - Scorear una oferta puntual
 1. WebFetch del JD.
-2. Aplicar la rúbrica contra el perfil → score 0–100 + breakdown + recomendación (aplicar / borderline / skip).
+2. Aplicar la rúbrica contra el perfil → score 0-100 + breakdown + recomendación (aplicar / borderline / skip).
 3. Si pasa, crear las notas como arriba.
 
-### `plan` — Plan de búsqueda de 7 días
+### `plan` - Plan de búsqueda de 7 días
 Generar un plan accionable con objetivos diarios. Ejemplo de esqueleto (ajustar al estado del usuario):
 
-- **Día 1 — Base.** Perfil maestro + perfiles por rol al día; LinkedIn optimizado (`/linkedin-optimize`).
-- **Día 2 — Sourcing.** Buscar y scorear 15–20 ofertas; quedarte con las ≥ umbral.
-- **Día 3 — Research.** Empresas + contactos objetivo de las top.
-- **Día 4 — Aplicaciones tanda 1.** CV custom + cover letter para las 5 de mayor prioridad (`/cv-tailor`, `/cv-ats-export`, `/cover-letter`).
-- **Día 5 — Outreach.** Mensajes a recruiters/hiring managers de las top (`/cold-outreach`).
-- **Día 6 — Aplicaciones tanda 2** + follow-ups de la tanda 1.
-- **Día 7 — Review.** Métricas (aplicadas / respuestas / entrevistas), ajustar perfil/CV según señales, planear próxima semana.
+- **Día 1 - Base.** Perfil maestro + perfiles por rol al día; LinkedIn optimizado (`/linkedin-optimize`).
+- **Día 2 - Sourcing.** Buscar y scorear 15-20 ofertas; quedarte con las ≥ umbral.
+- **Día 3 - Research.** Empresas + contactos objetivo de las top.
+- **Día 4 - Aplicaciones tanda 1.** CV custom + cover letter para las 5 de mayor prioridad (`/cv-tailor`, `/cv-ats-export`, `/cover-letter`).
+- **Día 5 - Outreach.** Mensajes a recruiters/hiring managers de las top (`/cold-outreach`).
+- **Día 6 - Aplicaciones tanda 2** + follow-ups de la tanda 1.
+- **Día 7 - Review.** Métricas (aplicadas / respuestas / entrevistas), ajustar perfil/CV según señales, planear próxima semana.
 
 ## Rúbrica de scoring
 
-Ver `references/scoring-rubric.md`. En resumen, score ponderado 0–100 sobre:
+Ver `references/scoring-rubric.md`. En resumen, score ponderado 0-100 sobre:
 - Match de stack/skills (peso alto)
 - Seniority correcto (penalizar over/under-qualified)
 - Modalidad y mercado/elegibilidad (remoto, zona horaria, visa)
@@ -68,14 +71,14 @@ Umbral default ≥75 (configurable en el frontmatter del perfil, campo `match_sc
 
 ## Tracking
 
-- Estados de aplicación: `interesado` → `aplicado` → `en proceso` → `entrevista` → `oferta` / `rechazado` / `descartado`.
+- Estados de aplicación: `interesado` → `aplicado` → `entrevista` → `oferta`, y cierres: `contratado` / `rechazado` / `sin_respuesta` / `declinada` / `descartado` (los registra `/job-outcome`).
 - Mantener el `00-Dashboard.md` como vista única: activas por prioridad, próximas entrevistas, qué cierra pronto, a seguir esta semana.
 
 ## Reglas
 
 - No aplicar a todo: el umbral existe para concentrar esfuerzo donde hay match real.
 - Marcar gaps con honestidad al scorear (no inflar el match).
-- Respetar elegibilidad (visa/zona horaria) — un score alto con bloqueo de elegibilidad no sirve.
+- Respetar elegibilidad (visa/zona horaria) - un score alto con bloqueo de elegibilidad no sirve.
 - No guardar datos sensibles de recruiters en remotos sin confirmación.
 
 ## Handoff

package/skills/job-search/references/scoring-rubric.md

@@ -1,6 +1,6 @@
 # Job Scoring Rubric
 
-Score ponderado 0–100 para decidir dónde invertir esfuerzo. El objetivo no es aplicar a todo: es concentrarte en ofertas con match real. Umbral default **≥75** (configurable por perfil en `match_score_minimo`).
+Score ponderado 0-100 para decidir dónde invertir esfuerzo. El objetivo no es aplicar a todo: es concentrarte en ofertas con match real. Umbral default **≥75** (configurable por perfil en `match_score_minimo`).
 
 ## Dimensiones y pesos (default)
 
@@ -13,12 +13,12 @@ Score ponderado 0–100 para decidir dónde invertir esfuerzo. El objetivo no es
 | **Empresa/cultura/etapa** | 10 | Encaje con preferencia (startup vs enterprise, producto vs consultora, valores). |
 | **Calidad de la oferta** | 10 | Claridad del JD, recencia (fresca > vieja), pocos aplicantes, proceso definido. |
 
-Sumá las dimensiones → score 0–100.
+Sumá las dimensiones → score 0-100.
 
 ## Ajustes / banderas
 
-- **Frase gatillo positiva** (ej. "code-forward", "high autonomy", stack que amás): +2–5 si refuerza tu fit.
-- **Red flag en el JD** (ego, "rockstar", scope imposible, "trabajamos como familia"): −5–10 y nota de cautela.
+- **Frase gatillo positiva** (ej. "code-forward", "high autonomy", stack que amás): +2-5 si refuerza tu fit.
+- **Red flag en el JD** (ego, "rockstar", scope imposible, "trabajamos como familia"): −5-10 y nota de cautela.
 - **Cierre inminente:** no cambia el score, pero sube la **prioridad** de acción.
 - **Elegibilidad bloqueada** (visa que no tenés, zona horaria incompatible obligatoria): cap el score a <50 aunque el resto sea perfecto.
 
@@ -27,17 +27,17 @@ Sumá las dimensiones → score 0–100.
 | Score | Acción |
 |---|---|
 | **≥85** | Prioridad alta. Aplicar con CV custom + cover letter + outreach. |
-| **75–84** | Aplicar; CV custom sí, outreach si hay contacto fácil. |
-| **60–74** | Borderline. Aplicar solo si hay tiempo o un ángulo fuerte (referido). |
+| **75-84** | Aplicar; CV custom sí, outreach si hay contacto fácil. |
+| **60-74** | Borderline. Aplicar solo si hay tiempo o un ángulo fuerte (referido). |
 | **<60** | Skip salvo razón estratégica. |
 
 ## Prioridad (distinta del score)
 
 `prioridad` en el frontmatter combina score + urgencia + elegibilidad:
 - **alta:** score ≥85, o ≥75 con cierre inminente / referido caliente.
-- **media:** 75–84 sin urgencia.
+- **media:** 75-84 sin urgencia.
 - **baja:** borderline o a la espera de validar requisitos.
 
 ## Registro
 
-Guardá el `score` en el frontmatter de la nota de `03-Aplicaciones/` y reflejá las activas en `00-Dashboard.md` agrupadas por prioridad. Anotá el breakdown si el score fue borderline — ayuda a decidir y a re-evaluar después.
+Guardá el `score` en el frontmatter de la nota de `03-Aplicaciones/` y reflejá las activas en `00-Dashboard.md` agrupadas por prioridad. Anotá el breakdown si el score fue borderline - ayuda a decidir y a re-evaluar después.

package/skills/job-upskill/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: job-upskill
+description: "Aggregate skill gaps across all scored job applications, weigh them by lost match points, and build a prioritized study plan with real resources. Triggers: analizar mis gaps, plan de estudio, que me falta aprender, upskill, en que skills invertir, gaps de las postulaciones, heatmap de skills."
+argument-hint: "[url | nota de aplicación]"
+category: "career"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Write, Bash, WebFetch, WebSearch
+---
+
+# /job-upskill - Análisis de gaps y plan de estudio
+
+Detecta qué skills te están costando puntos de match en las ofertas reales y arma un plan de estudio priorizado. Adaptado del /upskill de MadsLorentzen/ai-job-search: en vez de un CSV, la evidencia sale del frontmatter y las secciones de las notas de `03-Aplicaciones/` del career workspace (rutas relativas al workspace: `--workspace`, env `CAREER_WORKSPACE`, o `./career-workspace/`).
+
+Argumento: `$ARGUMENTS` (vacío = modo agregado; URL o nota = modo targeted)
+
+## Modo agregado (sin argumento)
+
+1. **Recolectar evidencia.** Grep de `match_score:` en `03-Aplicaciones/*.md` (excluir `_index`; aceptar también el campo legacy `score:` de notas viejas). De cada nota leer: `match_score`, `estado`, `perfil`, y los gaps mencionados en las secciones "Match con mi perfil" / "Gaps reales" y los gaps reconocidos en `## Notas`.
+
+2. **Canonicalizar.** Unificar sinónimos antes de agregar ("AWS" = "Amazon Web Services"; "K8s" = "Kubernetes"; "GCP" = "Google Cloud"). Un término canónico por gap.
+
+3. **Ponderar.** `peso(gap) = Σ (100 - match_score)/100` sobre las notas que lo mencionan (la frecuencia queda implícita en la suma). Boost x1.5 por cada nota con `estado: rechazado` que lo mencione (señal real de mercado). Ofertas con score bajo exponen más gaps y pesan más.
+
+4. **Clasificar** cada gap: `[tooling]` (frameworks, infra, CI/CD), `[domain]` (industria, arquitectura), `[soft]` (comunicación, liderazgo, idiomas), `[credential]` (títulos, certificaciones).
+
+5. **Heatmap.** Ordenar por peso y cortar en Critical / High / Medium / Low por cuartiles (documentar los umbrales usados en el reporte). Mostrar el heatmap en el chat antes de seguir.
+
+6. **Plan de estudio** solo para Critical y High (sumar Medium si hay menos de 5 gaps):
+   - WebSearch por gap **incluyendo el año actual** en la query (ej. "best NestJS course 2026").
+   - 2-3 recursos reales por gap, priorizando gratuitos/oficiales/hands-on. **Nunca inventar recursos: solo citar lo encontrado en resultados reales.**
+   - Horas estimadas a proficiencia útil (rangos realistas, ej. "~20h") considerando la base existente del perfil (no arrancar de cero si ya hay fundamentos).
+   - Secuenciar por ROI (peso/horas) y dependencias (prerequisitos primero, quick wins temprano).
+
+7. **Reporte** en `07-Recursos/Upskill - YYYY-MM-DD.md`, previo approval del usuario sobre el heatmap:
+   - Frontmatter: `tipo: upskill`, `fecha`, `aplicaciones_analizadas` (número), `perfiles` (lista).
+   - Heatmap con peso y clasificación por gap.
+   - Evidencia: por cada gap Critical/High, wikilinks a las notas de aplicación que lo mencionan.
+   - Plan de estudio secuenciado con recursos, horas y dependencias.
+   - Si existe un reporte anterior en `07-Recursos/`, sección "Desde el último reporte": gaps cerrados vs nuevos.
+
+8. **No edita** notas de aplicaciones, perfiles ni dashboard. Solo crea el reporte.
+
+## Modo targeted (`/job-upskill <url|nota>`)
+
+1. Obtener el JD: nota existente → leer su "Match con mi perfil"; URL → `detail` del script que corresponda (`.claude/skills/job-scrape/scripts/getonbrd_search.py` o `linkedin_search.py`; si job-scrape no está instalado, WebFetch).
+2. Comparar contra el perfil de `01-Perfiles/` que corresponda: gaps solo de esa oferta, clasificados.
+3. Mini-plan: 1-2 recursos por gap (WebSearch, año actual), horas estimadas.
+4. **Responder en el chat.** Guardar como `07-Recursos/Upskill - YYYY-MM-DD - <Empresa>.md` solo si el usuario lo pide (no llenar Recursos de reportes de una sola oferta).
+
+## Reglas
+
+- Nunca fabricar recursos ni estadísticas; todo sale de WebSearch real o de las notas.
+- Reporte en el idioma de las notas del workspace, sin guiones largos, con wikilinks a las notas fuente.
+- Los gaps `[credential]` (ej. título universitario) se reportan pero no entran al plan de estudio salvo pedido explícito (son decisiones de otra escala, no items de estudio semanal).
+
+## Handoff
+
+Reporte COMPLETE en `07-Recursos/`. Retomar el pipeline con `/job-aplicar` en las ofertas abiertas, o `/job-scrape` para una corrida nueva apuntando a los gaps que ya se están cerrando.

package/skills/linkedin-optimize/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: linkedin-optimize
-description: "Optimize a LinkedIn profile to attract recruiters and rank in search — headline, About, experience with KPIs, keywords, value proposition and a 30-second pitch. No LinkedIn Premium needed. Triggers: optimizar LinkedIn, mejorar perfil LinkedIn, headline LinkedIn, about LinkedIn, LinkedIn para reclutadores, LinkedIn SEO, pitch profesional."
+description: "Optimize a LinkedIn profile to attract recruiters and rank in search - headline, About, experience with KPIs, keywords, value proposition and a 30-second pitch. No LinkedIn Premium needed. Triggers: optimizar LinkedIn, mejorar perfil LinkedIn, headline LinkedIn, about LinkedIn, LinkedIn para reclutadores, LinkedIn SEO, pitch profesional."
 argument-hint: "[section | full] (paste your current profile)"
 category: "career"
 user-invocable: true
 allowed-tools: Read, Glob, Grep, Write, Edit
 ---
 
-# LinkedIn Optimize — Perfil que atrae oportunidades
+# LinkedIn Optimize - Perfil que atrae oportunidades
 
 Optimizás un perfil de LinkedIn para que (1) ranquee en las búsquedas de recruiters y (2) convenza al humano que lo abre. Trabajás contra el **perfil maestro** (`01-Perfiles/`) y lo que el usuario pega de su perfil actual.
 
@@ -31,8 +31,8 @@ Cubrí estas siete (el usuario puede pedir una con `[section]` o todas con `full
 - Las keywords del headline pesan fuerte en el ranking de búsqueda.
 
 ### 2. About (sección "Acerca de")
-- Primera 2–3 líneas son las que se ven sin "ver más": que enganchen.
-- Estructura: gancho → qué hacés y para quién → 2–3 logros con número → stack/keywords → CTA suave.
+- Primera 2-3 líneas son las que se ven sin "ver más": que enganchen.
+- Estructura: gancho → qué hacés y para quién → 2-3 logros con número → stack/keywords → CTA suave.
 - Primera persona, tono humano, escaneable (párrafos cortos o bullets).
 
 ### 3. Experiencia con KPIs
@@ -70,7 +70,7 @@ LinkedIn en **inglés** si apuntás a roles internacionales (mayor alcance), esp
 
 ## Reglas
 
-- No inventar logros ni métricas — todo debe ser defendible.
+- No inventar logros ni métricas - todo debe ser defendible.
 - Keywords naturales, no stuffing.
 - Recordar que no se puede acceder/editar LinkedIn: el output es para copiar/pegar.