Skip to content

AI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary

feat: surface hiring signals from jobs pages

Trevin Chowa0f778989311
diff --git a/CONCEPTS.md b/CONCEPTS.md
index 2a4a4628..d2849559 100644
--- a/CONCEPTS.md
+++ b/CONCEPTS.md
@@ -16,6 +16,12 @@ The Python script (`scripts/last30days.py`) the Skill's SKILL.md invokes to do t
The agent runtime that loads Skills and invokes them on the user's behalf. Claude Code is the most common Harness for this Skill but not the only one — Codex, Cursor, GitHub Copilot, Gemini CLI, and the rest of the Agent Skills ecosystem also count. "Multi-harness" describes a Skill that works correctly across every Harness it installs into; features written without multi-harness awareness (e.g., engine flags with no SKILL.md integration, or paths hardcoded to one Harness's install layout) regress on Harnesses other than the one they were tested against.
+## Research concepts
+
+### Hiring Signals
+
+Evidence-backed interpretation of current public job postings as indicators of a company's focus, priority shifts, or investment areas. Hiring Signals describe strategic leaning, not exact roadmap predictions, and are weighted by company size because a role at an early-stage startup carries more company-level signal than a scattered role at a large enterprise.
+
## Distribution
### Beta channel
diff --git a/CONFIGURATION.md b/CONFIGURATION.md
index 41b6e8e6..5002a585 100644
--- a/CONFIGURATION.md
+++ b/CONFIGURATION.md
@@ -64,6 +64,7 @@ The project-scoped file is the cleanest pattern for **per-client setups**: drop
| TruthSocial | `TRUTHSOCIAL_TOKEN` | TruthSocial items | yes |
| Web search | one of: `BRAVE_API_KEY`, `EXA_API_KEY`, `SERPER_API_KEY`, `PARALLEL_API_KEY` | `--auto-resolve` and Step 2 supplements | Brave has a free tier; native WebSearch on Claude Code / Codex / Gemini works as a fallback |
| Perplexity Deep Research | `OPENROUTER_API_KEY` | `--deep-research` flag (~$0.90/query) | no |
+| Jobs / careers pages | none for public ATS pages; web backend improves fallback discovery | `--hiring-signals` and strong Hiring Signals in standard company reports | yes |
| Apify (alternate scraper) | `APIFY_API_TOKEN` | fallback for Reddit/TikTok/Instagram when ScrapeCreators is exhausted | yes (limited) |
**Example `.env` skeleton** (placeholders only - replace with your own values):
@@ -133,6 +134,18 @@ Visible quality difference between hosts with vs without a configured backend. I
---
+### `--hiring-signals` flag
+
+Use `--hiring-signals` for a focused company hiring-signal report:
+
+```bash
+python3 skills/last30days/scripts/last30days.py "Listen Labs" --hiring-signals
+```
+
+The engine treats public jobs/careers postings as evidence of focus or priority shifts, not exact roadmap predictions. Standard company runs may include Hiring Signals automatically when multiple current roles support the same interpretation; weak or unavailable hiring evidence is omitted.
+
+---
+
## Trend monitoring (`--store` + watchlist + briefings)
The default behavior - one slug-named file per topic, overwritten on rerun - is the snapshot mode. For continuous monitoring, the repo ships three components most users miss:
diff --git a/README.md b/README.md
index 18bc474b..c2829551 100644
--- a/README.md
+++ b/README.md
@@ -83,6 +83,8 @@ The synthesis ranks by what real people actually engaged with. Social relevancy,
**Before a meeting.** `/last30days Peter Steinberger` - joined OpenAI's Codex team, fighting Anthropic's ban on third-party agents, 23 PRs merged at 85% merge rate on GitHub, building LobsterOS for cross-device agent control. r/ClaudeCode: "Ever since OpenClaw released, it was widely known that if you run it through anything other than the API, you were gonna get banned eventually" (227 upvotes). That's not on LinkedIn.
+**To read hiring signals.** `/last30days Listen Labs --hiring-signals` - current jobs and careers pages become cited evidence for focus shifts: hiring into enterprise security, customer success, infrastructure, or product expansion. The report says what the hiring appears to signal, not what the roadmap will ship.
+
**When something drops.** `/last30days Kanye West` - UK blocked his visa, Wireless Festival canceled, sponsors fled. But BULLY debuted #2 on Billboard. Fantano came back from his "Yay sabbatical" to review it (653K views). SoFi Homecoming brought out Lauryn Hill and Travis Scott for 44 songs. Polymarket: "Will Kanye tweet again?" 86% Yes. 23 Reddit threads, 17 YouTube videos, 86K upvotes.
**To compare tools.** `/last30days OpenClaw vs Hermes vs Paperclip` - "These aren't competitors, they're layers." OpenClaw is the executor (351K GitHub stars, live), Hermes is the self-improving brain (31K stars), Paperclip is the org chart (49K stars). Star counts pulled live from the GitHub API, not stale blog posts. Side-by-side table with architecture, memory, security, best-for. Per @IMJustinBrooke: "OpenClaw = Charmander, Hermes = Charizard."
diff --git a/skills/last30days/SKILL.md b/skills/last30days/SKILL.md
index 910b4ba0..29deb391 100644
--- a/skills/last30days/SKILL.md
+++ b/skills/last30days/SKILL.md
@@ -56,6 +56,7 @@ metadata:
- social-media
- analysis
- web-search
+ - hiring-signals
- ai-skill
- clawhub
---
@@ -332,6 +333,7 @@ Common patterns:
- If yt-dlp is installed (check `which yt-dlp`): add YouTube
- If SCRAPECREATORS_API_KEY is set: add TikTok, Instagram, Threads (suppress any of these via EXCLUDE_SOURCES)
- If SCRAPECREATORS_API_KEY is set and the user explicitly requested pinterest for this query (e.g. via `--search=pinterest`): add Pinterest
+- If the user asks for hiring signals, jobs pages, careers pages, focus shifts from hiring, or competitor hiring, add Jobs
- If BSKY_HANDLE and BSKY_APP_PASSWORD are set: add Bluesky
- If OPENROUTER_API_KEY is set and INCLUDE_SOURCES contains perplexity: add Perplexity
- If EXCLUDE_SOURCES is set (comma-separated, case-insensitive): drop any matching source from the list above before displaying
@@ -661,6 +663,7 @@ Topic A (the main topic, first in the vs-string) uses outer `--x-handle`, `--x-r
- `--competitors-list="A,B,C"` - minimum escape hatch; names only, no per-entity targeting. Peer sub-runs fall back to planner defaults (visibly thinner data).
- `--competitors-plan '{entity: {x_handle, subreddits, github_user, github_repos, context}}'` - full per-entity targeting; implies vs-mode; preferred.
- `--polymarket-keywords "kw1,kw2"` - disambiguate Polymarket for ambiguous single-token topics ("Warriors" → `nba,gsw,golden-state`).
+- `--hiring-signals` - deep-dive into public jobs/careers evidence for company focus signals. Use signal language only: leaning into, investing in, increasing focus, priority shift. Do NOT claim exact roadmap predictions from job postings.
**Why --competitors-plan over --competitors-list:** without per-entity handles/subs, peer sub-runs run with deterministic single-word planner queries and produce visibly thinner evidence than the main topic. The Resolved Entities block in stdout makes the gap visible — dashes for a peer = you skipped its Step 0.55.
@@ -668,6 +671,12 @@ Topic A (the main topic, first in the vs-string) uses outer `--x-handle`, `--x-r
**Output:** one `{slug}-raw.md` per entity in `--save-dir` plus the merged comparison on stdout. Synthesis contract identical to the vs-mode protocol above.
+### Hiring Signals mode (`--hiring-signals`)
+
+Use `--hiring-signals` when the user asks what a company's jobs page, careers page, LinkedIn jobs, or competitor hiring suggests about strategic focus. This is strongest for early-stage startups and weaker for large companies, where many unrelated roles are hiring noise.
+
+The output must distinguish evidence from interpretation. Good: "3 current roles mention SSO, SOC 2, and procurement workflows, which signals increased enterprise-readiness focus." Bad: "They will ship enterprise SSO next quarter." In standard `/last30days Company` runs, include Hiring Signals only when the engine surfaces a strong signal; otherwise omit the topic entirely.
+
---
## Step 0.55: Pre-Research Intelligence (resolve communities + handles)
diff --git a/skills/last30days/scripts/last30days.py b/skills/last30days/scripts/last30days.py
index 26996529..b2904f91 100644
--- a/skills/last30days/scripts/last30days.py
+++ b/skills/last30days/scripts/last30days.py
@@ -255,6 +255,8 @@ def build_parser() -> argparse.ArgumentParser:
help="Web search backend (default: auto, tries Brave then Exa then Serper then Parallel)")
parser.add_argument("--deep-research", action="store_true",
help="Use Perplexity Deep Research (~$0.90/query) for in-depth analysis. Requires OPENROUTER_API_KEY.")
+ parser.add_argument("--hiring-signals", action="store_true",
+ help="Analyze public jobs/careers postings as evidence-backed company focus signals.")
parser.add_argument("--plan", help="JSON query plan (skips internal LLM planner). Can be a JSON string or a file path.")
parser.add_argument("--save-suffix", help="Suffix for saved output filename (e.g., 'gemini' → kanye-west-raw-gemini.md)")
parser.add_argument("--subreddits", help="Comma-separated subreddit names to search (e.g., SaaS,Entrepreneur)")
@@ -752,6 +754,7 @@ def main() -> int:
lookback_days=args.lookback_days,
github_user=github_user,
github_repos=github_repos,
+ hiring_signals_mode=args.hiring_signals,
)
r.artifacts["resolved"] = {
"entity": topic,
@@ -879,6 +882,7 @@ def main() -> int:
github_repos=kwargs["github_repos"],
web_backend=args.web_backend,
lookback_days=args.lookback_days,
+ hiring_signals_mode=args.hiring_signals,
internal_subrun=True,
)
report.artifacts["resolved"] = resolved_effective
@@ -928,40 +932,42 @@ def main() -> int:
)
sys.stderr.flush()
- # Show quality nudge if applicable
- try:
- from lib import quality_nudge
- # Populate transcript-fetch ratio so quality_nudge can detect the
- # degraded-YouTube failure mode (videos returned but transcripts
- # silently failed - typically a stale yt-dlp binary).
- youtube_items = report.items_by_source.get("youtube") or []
- instagram_items = report.items_by_source.get("instagram") or []
- research_results = {
- "youtube_videos_count": len(youtube_items),
- "youtube_transcripts_count": sum(
- 1 for it in youtube_items
- if (it.metadata.get("transcript_highlights") or it.metadata.get("transcript_snippet"))
- ),
- "youtube_error": report.errors_by_source.get("youtube"),
- "x_error": report.errors_by_source.get("x"),
- # Captions-disabled videos can never produce a transcript regardless
- # of yt-dlp version; subtract them from the degraded-ratio
- # denominator so a single uploader-disabled video does not trip the
- # "stale yt-dlp" nudge.
- "youtube_captions_disabled_count": sum(
- 1 for it in youtube_items if it.metadata.get("captions_disabled")
- ),
- # Track Instagram returned-zero-items so quality_nudge can detect
- # the silent-failure case (SC configured but the v2 reels endpoint
- # 500'd through both the original query and the hashtag retry).
- "instagram_items_count": len(instagram_items),
- }
- quality = quality_nudge.compute_quality_score(config, research_results)
- if quality.get("nudge_text"):
- sys.stderr.write(f"\n{quality['nudge_text']}\n")
- sys.stderr.flush()
- except Exception:
- pass
+ # Show quality nudge if applicable. Explicit hiring-signal runs are
+ # intentionally jobs-focused, so generic source setup advice is noise.
+ if not args.hiring_signals:
+ try:
+ from lib import quality_nudge
+ # Populate transcript-fetch ratio so quality_nudge can detect the
+ # degraded-YouTube failure mode (videos returned but transcripts
+ # silently failed - typically a stale yt-dlp binary).
+ youtube_items = report.items_by_source.get("youtube") or []
+ instagram_items = report.items_by_source.get("instagram") or []
+ research_results = {
+ "youtube_videos_count": len(youtube_items),
+ "youtube_transcripts_count": sum(
+ 1 for it in youtube_items
+ if (it.metadata.get("transcript_highlights") or it.metadata.get("transcript_snippet"))
+ ),
+ "youtube_error": report.errors_by_source.get("youtube"),
+ "x_error": report.errors_by_source.get("x"),
+ # Captions-disabled videos can never produce a transcript regardless
+ # of yt-dlp version; subtract them from the degraded-ratio
+ # denominator so a single uploader-disabled video does not trip the
+ # "stale yt-dlp" nudge.
+ "youtube_captions_disabled_count": sum(
+ 1 for it in youtube_items if it.metadata.get("captions_disabled")
+ ),
+ # Track Instagram returned-zero-items so quality_nudge can detect
+ # the silent-failure case (SC configured but the v2 reels endpoint
+ # 500'd through both the original query and the hashtag retry).
+ "instagram_items_count": len(instagram_items),
+ }
+ quality = quality_nudge.compute_quality_score(config, research_results)
+ if quality.get("nudge_text"):
+ sys.stderr.write(f"\n{quality['nudge_text']}\n")
+ sys.stderr.flush()
+ except Exception:
+ pass
fun_level = config.get("FUN_LEVEL", "medium").lower()
# Comparison HTML is the one case where the saved file's title and content
diff --git a/skills/last30days/scripts/lib/hiring_signals.py b/skills/last30days/scripts/lib/hiring_signals.py
new file mode 100644
index 00000000..63378d35
--- /dev/null
+++ b/skills/last30days/scripts/lib/hiring_signals.py
@@ -0,0 +1,203 @@
+"""Hiring Signals analysis from normalized jobs SourceItems."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from typing import Any
+
+from . import schema
+
+
+THEME_KEYWORDS: dict[str, tuple[str, ...]] = {
+ "enterprise readiness": (
+ "enterprise", "soc 2", "sso", "security", "compliance", "procurement",
+ "admin", "governance", "audit",
+ ),
+ "go-to-market": (
+ "sales", "account executive", "customer success", "solutions", "partnership",
+ "revenue", "demand generation", "marketing",
+ ),
+ "ai and machine learning": (
+ "machine learning", "ml", "ai", "llm", "model", "research scientist",
+ "applied scientist", "data scientist",
+ ),
+ "infrastructure and reliability": (
+ "infrastructure", "platform", "devops", "sre", "reliability", "cloud",
+ "distributed systems", "backend",
+ ),
+ "product expansion": (
+ "product manager", "product designer", "growth", "activation", "mobile",
+ "frontend", "design",
+ ),
+ "data and analytics": (
+ "data", "analytics", "business intelligence", "warehouse", "etl",
+ "insights",
+ ),
+}
+
+SENIORITY_TERMS = ("head of", "director", "vp", "principal", "staff", "lead", "founding")
+
+
+def analyze(
+ items: list[schema.SourceItem],
+ *,
+ explicit: bool,
+ topic: str = "",
+) -> dict[str, Any]:
+ """Return a structured Hiring Signals summary for report artifacts."""
+ if not items:
+ return {
+ "mode": "explicit" if explicit else "standard",
+ "company_size_tier": "unknown",
+ "include": False,
+ "signals": [],
+ "omitted_reason": "no current public jobs evidence found",
+ }
+
+ size_tier = infer_company_size(items, topic=topic)
+ themes = _theme_items(items)
+ signals = [_build_signal(theme, theme_items, size_tier) for theme, theme_items in themes.items()]
+ signals = [signal for signal in signals if signal["evidence_count"] > 0]
+ signals.sort(key=lambda s: (s["confidence_score"], s["evidence_count"]), reverse=True)
+
+ include = bool(signals) if explicit else any(_passes_standard_threshold(signal, size_tier) for signal in signals)
+ if not explicit:
+ signals = [signal for signal in signals if _passes_standard_threshold(signal, size_tier)]
+
+ return {
+ "mode": "explicit" if explicit else "standard",
+ "company_size_tier": size_tier,
+ "include": include,
+ "signals": signals,
+ "omitted_reason": "" if include else _omitted_reason(items, size_tier, signals),
+ }
+
+
+def infer_company_size(items: list[schema.SourceItem], *, topic: str = "") -> str:
+ """Infer a coarse company-size tier from jobs evidence."""
+ text = " ".join(
+ " ".join([
+ item.title,
+ item.body[:1000],
+ str(item.metadata.get("company_size") or ""),
+ str(item.metadata.get("source_domain") or ""),
+ topic,
+ ])
+ for item in items
+ ).lower()
+ count = len(items)
+ if re.search(r"\b(apple|uber|google|microsoft|amazon|meta|netflix)\b", text):
+ return "mega-cap"
+ if count >= 200 or re.search(r"\b(global|fortune 500|thousands of employees)\b", text):
+ return "large-enterprise"
+ if count >= 35 or re.search(r"\b(series [cd]|public company)\b", text):
+ return "growth"
+ if count <= 12 or re.search(r"\b(founding|seed|series a|early[- ]stage|startup)\b", text):
+ return "startup"
+ return "mid-market"
+
+
+def _theme_items(items: list[schema.SourceItem]) -> dict[str, list[schema.SourceItem]]:
+ themed: dict[str, list[schema.SourceItem]] = defaultdict(list)
+ for item in items:
+ text = f"{item.title} {item.body}".lower()
+ matched = False
+ for theme, keywords in THEME_KEYWORDS.items():
+ if any(keyword in text for keyword in keywords):
+ themed[theme].append(item)
+ matched = True
+ if not matched:
+ dept = str(item.metadata.get("department") or item.container or "").strip().lower()
+ fallback = dept or "general hiring"
+ themed[fallback].append(item)
+ return dict(themed)
+
+
+def _build_signal(theme: str, items: list[schema.SourceItem], size_tier: str) -> dict[str, Any]:
+ titles = [item.title for item in items if item.title]
+ departments = [
+ str(item.metadata.get("department") or item.container or "").strip()
+ for item in items
+ if str(item.metadata.get("department") or item.container or "").strip()
+ ]
+ senior_roles = [
+ title for title in titles
+ if any(term in title.lower() for term in SENIORITY_TERMS)
+ ]
+ score = _confidence_score(len(items), len(set(departments)), len(senior_roles), size_tier)
+ evidence = [
+ {
+ "title": item.title,
+ "url": item.url,
+ "department": item.metadata.get("department") or item.container or "",
+ "published_at": item.published_at,
+ }
+ for item in items[:5]
+ ]
+ return {
+ "theme": theme,
+ "interpretation": _interpretation(theme),
+ "confidence": _confidence_label(score),
+ "confidence_score": score,
+ "evidence_count": len(items),
+ "departments": [name for name, _count in Counter(departments).most_common(3)],
+ "senior_roles": senior_roles[:3],
+ "evidence": evidence,
+ }
+
+
+def _confidence_score(count: int, department_count: int, senior_count: int, size_tier: str) -> int:
+ score = count * 18 + min(department_count, 3) * 6 + senior_count * 8
+ if size_tier == "startup":
+ score += 20
+ elif size_tier == "mid-market":
+ score += 10
+ elif size_tier == "growth":
+ score -= 5
+ elif size_tier == "large-enterprise":
+ score -= 25
+ elif size_tier == "mega-cap":
+ score -= 40
+ return max(0, min(100, score))
+
+
+def _passes_standard_threshold(signal: dict[str, Any], size_tier: str) -> bool:
+ thresholds = {
+ "startup": (2, 50),
+ "mid-market": (3, 58),
+ "growth": (4, 65),
+ "large-enterprise": (6, 78),
+ "mega-cap": (8, 86),
+ "unknown": (3, 62),
+ }
+ min_count, min_score = thresholds.get(size_tier, thresholds["unknown"])
+ return signal["evidence_count"] >= min_count and signal["confidence_score"] >= min_score
+
+
+def _confidence_label(score: int) -> str:
+ if score >= 75:
+ return "high"
+ if score >= 50:
+ return "medium"
+ return "low"
+
+
+def _interpretation(theme: str) -> str:
+ if theme == "general hiring":
+ return "hiring activity is visible, but the priority signal is diffuse"
+ return f"appears to be increasing focus on {theme}"
+
+
+def _omitted_reason(
+ items: list[schema.SourceItem],
+ size_tier: str,
+ signals: list[dict[str, Any]],
+) -> str:
+ if not items:
+ return "no current public jobs evidence found"
+ if size_tier in {"large-enterprise", "mega-cap"}:
+ return "jobs evidence is too diffuse for the inferred company size"
+ if not signals:
+ return "jobs evidence did not cluster into a clear signal"
+ return "jobs evidence is too thin for standard-report inclusion"
diff --git a/skills/last30days/scripts/lib/jobs.py b/skills/last30days/scripts/lib/jobs.py
new file mode 100644
index 00000000..1a320288
--- /dev/null
+++ b/skills/last30days/scripts/lib/jobs.py
@@ -0,0 +1,206 @@
+"""Public jobs/careers retrieval for Hiring Signals."""
+
+from __future__ import annotations
+
+import re
+from html import unescape
+from typing import Any
+
+from . import grounding, http
+
+
+ATS_PROVIDER_GREENHOUSE = "greenhouse"
+
+
+def search_jobs(
+ company: str,
+ date_range: tuple[str, str],
+ config: dict[str, Any],
+ *,
+ depth: str = "default",
+ web_backend: str = "auto",
+ explicit: bool = False,
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+ """Fetch public job postings for a company.
+
+ The first pass uses predictable public ATS endpoints. Generic web search is
+ only a fallback because web snippets are weaker evidence than structured
+ job posts.
+ """
+ company = company.strip()
+ if not company:
+ return [], {}
+
+ items: list[dict[str, Any]] = []
+ attempted: list[str] = []
+ for token in _greenhouse_board_tokens(company):
+ attempted.append(f"greenhouse:{token}")
+ try:
+ gh_items = search_greenhouse_board(token)
+ except http.HTTPError as exc:
+ if exc.status_code in {400, 401, 403, 404}:
+ continue
+ raise
+ if gh_items:
+ items.extend(gh_items)
+ break
+
+ if not items:
+ fallback_items, artifact = search_jobs_web(
+ company, date_range, config, backend=web_backend,
+ )
+ items.extend(fallback_items)
+ if artifact:
+ artifact.setdefault("attempted", attempted)
+ return items, artifact
+
+ return items, {
+ "label": "jobs",
+ "company": company,
+ "attempted": attempted,
+ "resultCount": len(items),
+ "explicit": explicit,
+ }
+
+
+def search_greenhouse_board(board_token: str) -> list[dict[str, Any]]:
+ """Return jobs from Greenhouse's public Job Board API."""
+ url = f"https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs"
+ data = http.get(url, params={"content": "true"}, timeout=15, retries=2)
+ jobs = data.get("jobs") if isinstance(data, dict) else []
+ if not isinstance(jobs, list):
+ return []
+ return [
+ _greenhouse_job_to_item(job, board_token)
+ for job in jobs
+ if isinstance(job, dict)
+ ]
+
+
+def search_jobs_web(
+ company: str,
+ date_range: tuple[str, str],
+ config: dict[str, Any],
+ *,
+ backend: str = "auto",
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+ """Fallback to configured web search for public careers/jobs pages."""
+ if backend == "none":
+ return [], {}
+ query = f'{company} careers jobs hiring'
+ raw_items, artifact = grounding.web_search(query, date_range, config, backend=backend)
+ items: list[dict[str, Any]] = []
+ for index, raw in enumerate(raw_items):
+ if not isinstance(raw, dict):
+ continue
+ title = str(raw.get("title") or "").strip()
+ url = str(raw.get("url") or "").strip()
+ snippet = str(raw.get("snippet") or "").strip()
+ if not _looks_like_jobs_page(title, url, snippet):
+ continue
+ items.append({
+ "id": raw.get("id") or f"JW{index + 1}",
+ "title": title,
+ "url": url,
+ "description": snippet,
+ "date": raw.get("date"),
+ "date_confidence": raw.get("date_confidence") or "low",
+ "provider": "web",
+ "source_domain": raw.get("source_domain"),
+ "relevance": raw.get("relevance", 0.45),
+ "why_relevant": "Public careers/jobs web result",
+ })
+ artifact = dict(artifact or {})
+ artifact.update({"label": "jobs-web", "company": company, "resultCount": len(items)})
+ return items, artifact
+
+
+def parse_greenhouse_response(payload: dict[str, Any], board_token: str = "") -> list[dict[str, Any]]:
+ """Parse a Greenhouse jobs payload for tests and callers with cached data."""
+ jobs = payload.get("jobs") if isinstance(payload, dict) else []
+ if not isinstance(jobs, list):
+ return []
+ return [
+ _greenhouse_job_to_item(job, board_token)
+ for job in jobs
+ if isinstance(job, dict)
+ ]
+
+
+def _greenhouse_job_to_item(job: dict[str, Any], board_token: str) -> dict[str, Any]:
+ departments = [
+ str(dept.get("name") or "").strip()
+ for dept in (job.get("departments") or [])
+ if isinstance(dept, dict) and str(dept.get("name") or "").strip()
+ ]
+ offices = [
+ str(office.get("name") or office.get("location") or "").strip()
+ for office in (job.get("offices") or [])
+ if isinstance(office, dict) and str(office.get("name") or office.get("location") or "").strip()
+ ]
+ location = ""
+ if isinstance(job.get("location"), dict):
+ location = str(job["location"].get("name") or "").strip()
+ description = _clean_html(str(job.get("content") or ""))
+ return {
+ "id": f"GH{job.get('id') or job.get('internal_job_id') or board_token}",
+ "title": str(job.get("title") or "").strip(),
+ "url": str(job.get("absolute_url") or "").strip(),
+ "description": description,
+ "date": _date_part(job.get("updated_at")),
+ "date_confidence": "high" if job.get("updated_at") else "low",
+ "provider": ATS_PROVIDER_GREENHOUSE,
+ "board_token": board_token,
+ "department": departments[0] if departments else "",
+ "departments": departments,
+ "location": location,
+ "offices": offices,
+ "relevance": 0.75,
+ "why_relevant": "Public Greenhouse job posting",
+ }
+
+
+def _greenhouse_board_tokens(company: str) -> list[str]:
+ base = _company_slug(company)
+ if not base:
+ return []
+ suffixes = ("", "careers", "jobs")
+ candidates = [base]
+ for suffix in suffixes[1:]:
+ candidates.append(f"{base}{suffix}")
+ compact = re.sub(r"(inc|labs|ai|hq|app|tech)$", "", base)
+ if compact and compact != base:
+ candidates.append(compact)
+ deduped: list[str] = []
+ for token in candidates:
+ if token and token not in deduped:
+ deduped.append(token)
+ return deduped[:4]
+
+
+def _company_slug(company: str) -> str:
+ text = company.lower()
+ text = re.sub(r"\b(inc|inc\.|llc|ltd|corp|corporation|company|co\.)\b", "", text)
+ return re.sub(r"[^a-z0-9]+", "", text).strip()
+
+
+def _date_part(value: Any) -> str | None:
+ text = str(value or "")
+ if not text:
+ return None
+ match = re.search(r"\d{4}-\d{2}-\d{2}", text)
+ return match.group(0) if match else None
+
+
+def _clean_html(value: str) -> str:
+ value = unescape(value)
+ value = re.sub(r"<br\s*/?>", "\n", value, flags=re.I)
+ value = re.sub(r"</p\s*>", "\n", value, flags=re.I)
+ value = re.sub(r"<[^>]+>", " ", value)
+ value = re.sub(r"\s+", " ", value)
+ return value.strip()
+
+
+def _looks_like_jobs_page(title: str, url: str, snippet: str) -> bool:
+ haystack = " ".join([title, url, snippet]).lower()
+ return bool(re.search(r"\b(careers?|jobs?|job openings?|hiring|greenhouse|lever|ashby|workable)\b", haystack))
diff --git a/skills/last30days/scripts/lib/normalize.py b/skills/last30days/scripts/lib/normalize.py
index b8035d35..61fc3521 100644
--- a/skills/last30days/scripts/lib/normalize.py
+++ b/skills/last30days/scripts/lib/normalize.py
@@ -54,6 +54,7 @@ def normalize_source_items(
"xiaohongshu": _normalize_grounding,
"github": _normalize_github,
"perplexity": _normalize_grounding,
+ "jobs": _normalize_jobs,
}
normalizer = normalizers.get(source)
if normalizer is None:
@@ -237,6 +238,45 @@ def _normalize_x(
)
+def _normalize_jobs(
+ source: str,
+ item: dict[str, Any],
+ index: int,
+ from_date: str,
+ to_date: str,
+) -> schema.SourceItem:
+ description = str(item.get("description") or item.get("snippet") or "").strip()
+ title = str(item.get("title") or "").strip()
+ department = str(item.get("department") or "").strip()
+ location = str(item.get("location") or "").strip()
+ body = "\n".join(part for part in [title, department, location, description] if part)
+ provider = str(item.get("provider") or "").strip()
+ return _source_item(
+ item_id=str(item.get("id") or f"J{index + 1}"),
+ source=source,
+ title=title or f"Job posting {index + 1}",
+ body=body,
+ url=str(item.get("url") or ""),
+ author=provider or None,
+ container=department or None,
+ published_at=item.get("date"),
+ date_confidence=_date_confidence(item, from_date, to_date),
+ engagement={"open_roles": 1},
+ relevance_hint=item.get("relevance", 0.65),
+ why_relevant=str(item.get("why_relevant") or "Public job posting"),
+ snippet=description[:500],
+ metadata={
+ "provider": provider,
+ "department": department,
+ "departments": item.get("departments") or ([department] if department else []),
+ "location": location,
+ "offices": item.get("offices") or [],
+ "board_token": item.get("board_token") or "",
+ "source_domain": item.get("source_domain") or _domain_from_url(str(item.get("url") or "")) or "",
+ },
+ )
+
+
def _normalize_youtube(
source: str,
item: dict[str, Any],
diff --git a/skills/last30days/scripts/lib/pipeline.py b/skills/last30days/scripts/lib/pipeline.py
index 491432cb..c482a694 100644
--- a/skills/last30days/scripts/lib/pipeline.py
+++ b/skills/last30days/scripts/lib/pipeline.py
@@ -21,7 +21,9 @@ from . import (
github,
grounding,
hackernews,
+ hiring_signals,
instagram,
+ jobs,
normalize,
perplexity,
pinterest,
@@ -63,7 +65,7 @@ SEARCH_ALIAS = {
"xquik": "xquik",
}
-MAX_SOURCE_FETCHES: dict[str, int] = {"x": 2}
+MAX_SOURCE_FETCHES: dict[str, int] = {"x": 2, "jobs": 1}
MOCK_AVAILABLE_SOURCES = [
"reddit",
@@ -83,6 +85,7 @@ MOCK_AVAILABLE_SOURCES = [
"pinterest",
"xquik",
"digg",
+ "jobs",
]
@@ -118,6 +121,8 @@ def available_sources(config: dict[str, Any], requested_sources: list[str] | Non
available.append("truthsocial")
if config.get("BRAVE_API_KEY") or config.get("EXA_API_KEY") or config.get("SERPER_API_KEY") or config.get("PARALLEL_API_KEY"):
available.append("grounding")
+ if requested_sources and "jobs" in requested_sources:
+ available.append("jobs")
# Perplexity Sonar: opt-in additive source via INCLUDE_SOURCES=perplexity
include_sources = (config.get("INCLUDE_SOURCES") or "").lower().split(",")
if config.get("OPENROUTER_API_KEY") and (
@@ -190,6 +195,7 @@ def run(
lookback_days: int = 30,
github_user: str | None = None,
github_repos: list[str] | None = None,
+ hiring_signals_mode: bool = False,
internal_subrun: bool = False,
) -> schema.Report:
settings = DEPTH_SETTINGS[depth]
@@ -200,6 +206,8 @@ def run(
runtime = providers.mock_runtime(config, depth)
reasoning_provider = None
available = list(requested_sources or MOCK_AVAILABLE_SOURCES)
+ if not requested_sources and not hiring_signals_mode and not _company_topic_likely(topic):
+ available = [source for source in available if source != "jobs"]
else:
runtime, reasoning_provider = providers.resolve_runtime(config, depth)
available = available_sources(config, requested_sources)
@@ -209,21 +217,32 @@ def run(
available = [s for s in available if s != "grounding"]
elif web_backend in ("brave", "exa", "serper", "parallel") and "grounding" not in available:
available.append("grounding")
+ if (hiring_signals_mode or _company_topic_likely(topic)) and "jobs" not in available:
+ available.append("jobs")
+ if hiring_signals_mode:
+ config = dict(config)
+ config["_hiring_signals_mode"] = True
+ if not requested_sources:
+ available = ["jobs"]
if not available:
raise RuntimeError("No sources are available for this run.")
+ planner_requested_sources = requested_sources
+ if hiring_signals_mode and not planner_requested_sources:
+ planner_requested_sources = ["jobs"]
+
if external_plan:
# External plan provided (e.g., from Claude Code via --plan flag).
# Parse it through the same sanitizer to validate structure.
plan = planner._sanitize_plan(
- external_plan, topic, available, requested_sources, depth,
+ external_plan, topic, available, planner_requested_sources, depth,
)
plan_source = "external"
else:
plan = planner.plan_query(
topic=topic,
available_sources=available,
- requested_sources=requested_sources,
+ requested_sources=planner_requested_sources,
depth=depth,
provider=None if mock else reasoning_provider,
model=None if mock else runtime.planner_model,
@@ -246,6 +265,7 @@ def run(
for sq in plan.subqueries:
if "grounding" not in sq.sources:
sq.sources.append("grounding")
+ _ensure_jobs_in_plan(plan, available, explicit=hiring_signals_mode, topic=topic)
# Always-on planner trace. Emits one summary line plus one per subquery
# so retrieval-breadth failures like the 2026-04-19 Hermes Agent Use Cases
@@ -455,6 +475,14 @@ def run(
if bundle.items_by_source.get(source):
del bundle.errors_by_source[source]
+ hiring_summary = _apply_hiring_signal_gate(
+ bundle,
+ explicit=hiring_signals_mode,
+ topic=topic,
+ )
+ if hiring_summary:
+ bundle.artifacts["hiring_signals"] = hiring_summary
+
items_by_source = _finalize_items_by_source(bundle.items_by_source, topic=topic, config=config)
candidates = weighted_rrf(bundle.items_by_source_and_query, plan, pool_limit=settings["pool_limit"])
ranked_candidates = rerank.rerank_candidates(
@@ -514,7 +542,8 @@ def _normalize_score_dedupe(
)
prepared_query = relevance.PreparedQuery(ranking_query)
normalized = signals.annotate_stream(normalized, prepared_query, freshness_mode)
- normalized = signals.prune_low_relevance(normalized)
+ if source != "jobs":
+ normalized = signals.prune_low_relevance(normalized)
normalized = dedupe.dedupe_items(normalized)
for item in normalized:
item.snippet = snippet.extract_best_snippet(item, prepared_query)
@@ -552,6 +581,63 @@ def _finalize_items_by_source(
return finalized
+def _apply_hiring_signal_gate(
+ bundle: schema.RetrievalBundle,
+ *,
+ explicit: bool,
+ topic: str,
+) -> dict[str, Any] | None:
+ jobs_items = bundle.items_by_source.get("jobs") or []
+ if not jobs_items:
+ if explicit:
+ return hiring_signals.analyze([], explicit=True, topic=topic)
+ return None
+
+ summary = hiring_signals.analyze(jobs_items, explicit=explicit, topic=topic)
+ if not explicit and not summary.get("include"):
+ bundle.items_by_source.pop("jobs", None)
+ for key in list(bundle.items_by_source_and_query):
+ if key[1] == "jobs":
+ del bundle.items_by_source_and_query[key]
+ return summary
+
+
+def _ensure_jobs_in_plan(
+ plan: schema.QueryPlan,
+ available: list[str],
+ *,
+ explicit: bool,
+ topic: str,
+) -> None:
+ if "jobs" not in available:
+ return
+ if not (explicit or _company_topic_likely(topic)):
+ return
+ if "jobs" not in plan.source_weights:
+ plan.source_weights["jobs"] = 1.0
+ for subquery in plan.subqueries:
+ if "jobs" not in subquery.sources:
+ subquery.sources.append("jobs")
+
+
+def _company_topic_likely(topic: str) -> bool:
+ text = topic.strip()
+ if not text:
+ return False
+ lower = text.lower()
+ if " vs " in lower or " versus " in lower:
+ return True
+ if "?" in text or len(text.split()) > 4:
+ return False
+ generic = {
+ "how", "what", "why", "best", "top", "tutorial", "guide", "prompts",
+ "news", "latest", "ideas", "examples",
+ }
+ if any(word in generic for word in lower.split()):
+ return False
+ return bool(text[:1].isupper() or len(text.split()) == 1)
+
+
def _warnings(
items_by_source: dict[str, list[schema.SourceItem]],
candidates: list[schema.Candidate],
@@ -869,6 +955,15 @@ def _retrieve_stream(
if source == "grounding":
return grounding.web_search(
subquery.search_query, date_range, config, backend=web_backend)
+ if source == "jobs":
+ return jobs.search_jobs(
+ raw_topic or topic or subquery.search_query,
+ date_range,
+ config,
+ depth=depth,
+ web_backend=web_backend,
+ explicit=bool(config.get("_hiring_signals_mode")),
+ )
if source == "reddit":
# Use raw_topic so expand_reddit_queries() generates diverse variants
# from the original user topic, not the planner's narrowed search_query.
@@ -1127,6 +1222,35 @@ def _mock_stream_results(source: str, subquery: schema.SubQuery) -> tuple[list[d
"why_relevant": "Mock Digg cluster",
},
],
+ "jobs": [
+ {
+ "id": "J1",
+ "title": "Founding Enterprise Solutions Engineer",
+ "url": "https://boards.greenhouse.io/example/jobs/1",
+ "description": (
+ f"Work with enterprise customers on SSO, SOC 2, security, "
+ f"and procurement workflows for {subquery.search_query}."
+ ),
+ "department": "Sales",
+ "location": "San Francisco, CA",
+ "date": dates.get_date_range(4)[0],
+ "provider": "mock",
+ "relevance": 0.8,
+ "why_relevant": "Mock public job posting",
+ },
+ {
+ "id": "J2",
+ "title": "Security Platform Engineer",
+ "url": "https://boards.greenhouse.io/example/jobs/2",
+ "description": "Build enterprise security, audit, and admin workflows.",
+ "department": "Engineering",
+ "location": "Remote",
+ "date": dates.get_date_range(6)[0],
+ "provider": "mock",
+ "relevance": 0.78,
+ "why_relevant": "Mock public job posting",
+ },
+ ],
}
if source == "grounding":
return payloads.get(source, []), {
diff --git a/skills/last30days/scripts/lib/planner.py b/skills/last30days/scripts/lib/planner.py
index 35646f46..dd3cb8ac 100644
--- a/skills/last30days/scripts/lib/planner.py
+++ b/skills/last30days/scripts/lib/planner.py
@@ -20,7 +20,7 @@ ALLOWED_INTENTS = {
ALLOWED_CLUSTER_MODES = {"none", "story", "workflow", "market", "debate"}
QUICK_SOURCE_PRIORITY = {
"factual": ["hackernews", "reddit", "x", "xquik", "youtube"],
- "product": ["youtube", "reddit", "x", "xquik", "tiktok"],
+ "product": ["jobs", "youtube", "reddit", "x", "xquik", "tiktok"],
"concept": ["hackernews", "reddit", "x", "xquik", "youtube"],
"opinion": ["reddit", "x", "xquik", "youtube", "hackernews"],
"how_to": ["youtube", "reddit", "x", "xquik", "hackernews"],
@@ -30,7 +30,7 @@ QUICK_SOURCE_PRIORITY = {
}
SOURCE_PRIORITY = {
"factual": ["hackernews", "reddit", "x", "youtube"],
- "product": ["youtube", "reddit", "x", "tiktok", "hackernews"],
+ "product": ["jobs", "youtube", "reddit", "x", "tiktok", "hackernews"],
"concept": ["hackernews", "reddit", "x", "youtube"],
"opinion": ["reddit", "x", "youtube", "hackernews"],
"how_to": ["youtube", "reddit", "x", "hackernews"],
@@ -73,6 +73,7 @@ SOURCE_CAPABILITIES = {
"github": {"discussion", "link"},
"grounding": {"web", "reference", "link"},
"perplexity": {"web", "reference", "analysis"},
+ "jobs": {"jobs", "company_signal", "link"},
}
DEFAULT_INTENT_CAPABILITIES = {
"comparison": {"discussion", "video", "web", "reference", "social", "link", "market"},
@@ -532,6 +533,10 @@ def _default_source_weights(intent: str, sources: list[str]) -> dict[str, float]
for source, bonus in {"reddit": 0.8, "x": 0.5}.items():
if source in base:
base[source] += bonus
+ elif intent == "product":
+ for source, bonus in {"jobs": 0.8, "youtube": 0.5}.items():
+ if source in base:
+ base[source] += bonus
return base
diff --git a/skills/last30days/scripts/lib/render.py b/skills/last30days/scripts/lib/render.py
index a89fb8fa..2e38d083 100644
--- a/skills/last30days/scripts/lib/render.py
+++ b/skills/last30days/scripts/lib/render.py
@@ -70,6 +70,7 @@ SOURCE_LABELS = {
"github": "GitHub",
"digg": "Digg",
"perplexity": "Perplexity",
+ "jobs": "Jobs",
}
@@ -135,6 +136,10 @@ def render_compact(report: schema.Report, cluster_limit: int = 8, fun_level: str
# block below) vs "synthesize from" (this block).
lines.append("<!-- EVIDENCE FOR SYNTHESIS: read this, do not emit verbatim. Transform into `What I learned:` prose per LAW 2. -->")
lines.append("")
+ hiring_block = _render_hiring_signals(report)
+ if hiring_block:
+ lines.extend(hiring_block)
+ lines.append("")
lines.append("## Ranked Evidence Clusters")
lines.append("")
candidate_by_id = {candidate.candidate_id: candidate for candidate in report.ranked_candidates}
@@ -210,6 +215,10 @@ def render_for_html(
]
if synthesis_md:
lines.extend(["", synthesis_md.strip()])
+ else:
+ hiring_block = _render_hiring_signals(report)
+ if hiring_block:
+ lines.extend(["", *hiring_block])
# Data quality warnings are NOT rendered into the HTML artifact. The HTML
# is meant to be shared (Slack, email, Notion); recipients haven't asked
# for technical commentary about how the run was produced. Generators see
@@ -842,7 +851,7 @@ def render_full(report: schema.Report) -> str:
lines.append("## All Items by Source")
lines.append("")
source_order = ["reddit", "x", "youtube", "tiktok", "instagram", "threads", "pinterest",
- "hackernews", "bluesky", "truthsocial", "polymarket", "grounding", "xiaohongshu", "github", "digg", "perplexity"]
+ "hackernews", "bluesky", "truthsocial", "polymarket", "grounding", "xiaohongshu", "github", "digg", "perplexity", "jobs"]
for source in source_order:
items = report.items_by_source.get(source, [])
if not items:
@@ -961,6 +970,51 @@ def render_context(report: schema.Report, cluster_limit: int = 6) -> str:
return "\n".join(lines).strip() + "\n"
+def _render_hiring_signals(report: schema.Report) -> list[str]:
+ summary = report.artifacts.get("hiring_signals")
+ if not isinstance(summary, dict):
+ return []
+ signals = summary.get("signals") or []
+ include = bool(summary.get("include"))
+ mode = summary.get("mode") or "standard"
+ if not include and mode != "explicit":
+ return []
+
+ out = [
+ "## Hiring Signals",
+ "",
+ (
+ f"- Mode: {mode}; company-size tier: "
+ f"{summary.get('company_size_tier') or 'unknown'}"
+ ),
+ ]
+ if not signals:
+ reason = summary.get("omitted_reason") or "no reliable hiring signal found"
+ out.append(f"- No reliable hiring signal found: {reason}.")
+ return out
+
+ out.append(
+ "- Interpret these as focus or priority signals, not exact roadmap predictions."
+ )
+ for signal in signals[:4]:
+ evidence = signal.get("evidence") or []
+ out.append(
+ f"- {signal.get('theme', 'hiring theme')}: "
+ f"{signal.get('interpretation', 'possible hiring focus')} "
+ f"(confidence: {signal.get('confidence', 'low')}; "
+ f"evidence: {signal.get('evidence_count', len(evidence))} roles)"
+ )
+ for item in evidence[:3]:
+ title = item.get("title") or "Job posting"
+ url = item.get("url") or ""
+ dept = item.get("department") or ""
+ date = item.get("published_at") or "date unknown"
+ link = f"[{title}]({url})" if url else title
+ detail = " | ".join(part for part in [dept, date] if part)
+ out.append(f" - {link}" + (f" ({detail})" if detail else ""))
+ return out
+
+
def _render_candidate(candidate: schema.Candidate, prefix: str) -> list[str]:
primary = schema.candidate_primary_item(candidate)
detail_parts = [
diff --git a/skills/last30days/scripts/lib/signals.py b/skills/last30days/scripts/lib/signals.py
index d2a34261..02eb7d3a 100644
--- a/skills/last30days/scripts/lib/signals.py
+++ b/skills/last30days/scripts/lib/signals.py
@@ -20,6 +20,7 @@ SOURCE_QUALITY = {
"polymarket": 0.5,
"instagram": 0.58,
"tiktok": 0.58,
+ "jobs": 0.72,
}
diff --git a/tests/test_cli_hiring_signals.py b/tests/test_cli_hiring_signals.py
new file mode 100644
index 00000000..d066ce15
--- /dev/null
+++ b/tests/test_cli_hiring_signals.py
@@ -0,0 +1,26 @@
+import unittest
+
+import last30days as cli
+
+
+def _parse(*argv: str):
+ parser = cli.build_parser()
+ args, _extra = parser.parse_known_args(argv)
+ return args
+
+
+class HiringSignalsCliTests(unittest.TestCase):
+ def test_hiring_signals_default_disabled(self):
+ args = _parse("Listen Labs")
+ self.assertFalse(args.hiring_signals)
+
+ def test_hiring_signals_flag_enabled(self):
+ args = _parse("Listen Labs", "--hiring-signals")
+ self.assertTrue(args.hiring_signals)
+
+ def test_jobs_search_source_is_valid(self):
+ self.assertEqual(["jobs"], cli.parse_search_flag("jobs"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_hiring_signals.py b/tests/test_hiring_signals.py
new file mode 100644
index 00000000..5f517b3e
--- /dev/null
+++ b/tests/test_hiring_signals.py
@@ -0,0 +1,50 @@
+import unittest
+
+from lib import hiring_signals, schema
+
+
+def job(title: str, body: str, department: str = "Engineering") -> schema.SourceItem:
+ return schema.SourceItem(
+ item_id=title,
+ source="jobs",
+ title=title,
+ body=body,
+ url=f"https://example.com/jobs/{title.replace(' ', '-').lower()}",
+ container=department,
+ published_at="2026-06-01",
+ date_confidence="high",
+ metadata={"department": department},
+ )
+
+
+class HiringSignalsTests(unittest.TestCase):
+ def test_startup_cluster_surfaces_in_standard_mode(self):
+ items = [
+ job("Founding Enterprise Solutions Engineer", "SSO SOC 2 procurement enterprise", "Sales"),
+ job("Security Platform Engineer", "enterprise security audit admin", "Engineering"),
+ ]
+ summary = hiring_signals.analyze(items, explicit=False, topic="Listen Labs")
+ self.assertTrue(summary["include"])
+ self.assertEqual("startup", summary["company_size_tier"])
+ self.assertEqual("enterprise readiness", summary["signals"][0]["theme"])
+
+ def test_mega_cap_scattered_roles_do_not_surface_standard_mode(self):
+ items = [
+ job("Retail Associate", "store operations", "Retail"),
+ job("iOS Engineer", "mobile app", "Engineering"),
+ job("Finance Analyst", "planning", "Finance"),
+ ]
+ summary = hiring_signals.analyze(items, explicit=False, topic="Apple")
+ self.assertFalse(summary["include"])
+ self.assertEqual("mega-cap", summary["company_size_tier"])
+ self.assertIn("too diffuse", summary["omitted_reason"])
+
+ def test_explicit_mode_keeps_low_confidence_signal(self):
+ items = [job("Customer Success Manager", "support enterprise customers", "Success")]
+ summary = hiring_signals.analyze(items, explicit=True, topic="Acme")
+ self.assertTrue(summary["include"])
+ self.assertEqual("low", summary["signals"][0]["confidence"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_hiring_signals_normalize.py b/tests/test_hiring_signals_normalize.py
new file mode 100644
index 00000000..6f9a3822
--- /dev/null
+++ b/tests/test_hiring_signals_normalize.py
@@ -0,0 +1,35 @@
+import unittest
+
+from lib import normalize
+
+
+class HiringSignalsNormalizeTests(unittest.TestCase):
+ def test_normalize_jobs_source_item(self):
+ items = normalize.normalize_source_items(
+ "jobs",
+ [
+ {
+ "id": "J1",
+ "title": "Enterprise Security Engineer",
+ "description": "Build SSO and SOC 2 controls.",
+ "url": "https://example.com/jobs/1",
+ "department": "Engineering",
+ "location": "Remote",
+ "date": "2026-06-01",
+ "provider": "greenhouse",
+ }
+ ],
+ "2026-05-16",
+ "2026-06-16",
+ )
+ self.assertEqual(1, len(items))
+ item = items[0]
+ self.assertEqual("jobs", item.source)
+ self.assertEqual("Enterprise Security Engineer", item.title)
+ self.assertEqual("Engineering", item.container)
+ self.assertEqual("greenhouse", item.author)
+ self.assertEqual("Remote", item.metadata["location"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_jobs_source.py b/tests/test_jobs_source.py
new file mode 100644
index 00000000..22ed184d
--- /dev/null
+++ b/tests/test_jobs_source.py
@@ -0,0 +1,46 @@
+import unittest
+from unittest.mock import patch
+
+from lib import jobs
+
+
+class JobsSourceTests(unittest.TestCase):
+ def test_parse_greenhouse_response_preserves_core_fields(self):
+ payload = {
+ "jobs": [
+ {
+ "id": 123,
+ "title": "Enterprise Security Engineer",
+ "updated_at": "2026-06-01T10:00:00-05:00",
+ "absolute_url": "https://boards.greenhouse.io/acme/jobs/123",
+ "content": "<p>Build SSO and SOC 2 workflows.</p>",
+ "location": {"name": "Remote"},
+ "departments": [{"name": "Engineering"}],
+ "offices": [{"name": "US"}],
+ }
+ ]
+ }
+ parsed = jobs.parse_greenhouse_response(payload, board_token="acme")
+ self.assertEqual(1, len(parsed))
+ item = parsed[0]
+ self.assertEqual("Enterprise Security Engineer", item["title"])
+ self.assertEqual("2026-06-01", item["date"])
+ self.assertEqual("Engineering", item["department"])
+ self.assertIn("SSO", item["description"])
+ self.assertEqual("greenhouse", item["provider"])
+
+ @patch("lib.jobs.http.get")
+ def test_greenhouse_404_degrades_to_empty(self, mock_get):
+ mock_get.side_effect = jobs.http.HTTPError("missing", status_code=404)
+ items, artifact = jobs.search_jobs(
+ "MissingCo",
+ ("2026-05-16", "2026-06-16"),
+ {},
+ web_backend="none",
+ )
+ self.assertEqual([], items)
+ self.assertEqual(0, artifact["resultCount"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_pipeline_v3.py b/tests/test_pipeline_v3.py
index ce4101da..dcc4afa4 100644
--- a/tests/test_pipeline_v3.py
+++ b/tests/test_pipeline_v3.py
@@ -78,6 +78,81 @@ class PipelineV3Tests(unittest.TestCase):
# error when its required backend key is unset.
self.assertIn("grounding", report.errors_by_source)
+ def test_hiring_signals_mode_enables_jobs_source_in_mock_run(self):
+ report = pipeline.run(
+ topic="Listen Labs",
+ config={"LAST30DAYS_REASONING_PROVIDER": "gemini"},
+ depth="quick",
+ requested_sources=["jobs"],
+ mock=True,
+ hiring_signals_mode=True,
+ )
+ self.assertIn("jobs", report.items_by_source)
+ self.assertIn("hiring_signals", report.artifacts)
+ self.assertTrue(report.artifacts["hiring_signals"]["include"])
+
+ def test_hiring_signals_mode_defaults_to_jobs_source(self):
+ report = pipeline.run(
+ topic="Listen Labs",
+ config={"LAST30DAYS_REASONING_PROVIDER": "gemini"},
+ depth="quick",
+ mock=True,
+ hiring_signals_mode=True,
+ )
+ self.assertEqual(["jobs"], sorted(report.items_by_source))
+ self.assertTrue(report.artifacts["hiring_signals"]["include"])
+
+ def test_standard_company_run_fetches_jobs_for_signal_gate(self):
+ report = pipeline.run(
+ topic="Listen Labs",
+ config={"LAST30DAYS_REASONING_PROVIDER": "gemini"},
+ depth="quick",
+ mock=True,
+ )
+ self.assertIn("jobs", report.items_by_source)
+ self.assertIn("hiring_signals", report.artifacts)
+
+ def test_standard_mock_run_does_not_add_jobs_for_generic_topic(self):
+ report = pipeline.run(
+ topic="how to deploy on Fly.io",
+ config={"LAST30DAYS_REASONING_PROVIDER": "gemini"},
+ depth="quick",
+ mock=True,
+ )
+ self.assertNotIn("jobs", report.items_by_source)
+ self.assertNotIn("hiring_signals", report.artifacts)
+
+ def test_standard_mode_omits_weak_large_company_jobs_signal(self):
+ with patch("lib.pipeline._retrieve_stream") as mock_retrieve:
+ def fake_retrieve(**kwargs):
+ if kwargs["source"] == "jobs":
+ return (
+ [
+ {
+ "id": "J1",
+ "title": "Retail Associate",
+ "description": "Store operations",
+ "url": "https://example.com/jobs/1",
+ "department": "Retail",
+ "date": "2026-06-01",
+ "provider": "mock",
+ }
+ ],
+ {},
+ )
+ return pipeline._mock_stream_results(kwargs["source"], kwargs["subquery"])
+
+ mock_retrieve.side_effect = fake_retrieve
+ report = pipeline.run(
+ topic="Apple",
+ config={"LAST30DAYS_REASONING_PROVIDER": "gemini"},
+ depth="quick",
+ requested_sources=["jobs"],
+ mock=True,
+ )
+ self.assertNotIn("jobs", report.items_by_source)
+ self.assertFalse(report.artifacts["hiring_signals"]["include"])
+
class TestSourceFetchCap(unittest.TestCase):
"""X source fetch count must be capped by MAX_SOURCE_FETCHES."""
@@ -87,6 +162,10 @@ class TestSourceFetchCap(unittest.TestCase):
self.assertIn("x", pipeline.MAX_SOURCE_FETCHES)
self.assertEqual(pipeline.MAX_SOURCE_FETCHES["x"], 2)
+ def test_jobs_capped_in_max_source_fetches(self):
+ self.assertIn("jobs", pipeline.MAX_SOURCE_FETCHES)
+ self.assertEqual(pipeline.MAX_SOURCE_FETCHES["jobs"], 1)
+
def test_cap_logic_limits_source_submissions(self):
"""Verify the cap logic skips submissions beyond the limit."""
cap = pipeline.MAX_SOURCE_FETCHES.get("x", float("inf"))
diff --git a/tests/test_planner_v3.py b/tests/test_planner_v3.py
index 53848466..d9c39da3 100644
--- a/tests/test_planner_v3.py
+++ b/tests/test_planner_v3.py
@@ -208,6 +208,19 @@ class PlannerV3Tests(unittest.TestCase):
self.assertIn("youtube", sources)
self.assertIn("reddit", sources)
+ def test_product_plan_can_include_jobs_source(self):
+ plan = planner.plan_query(
+ topic="Listen Labs features",
+ available_sources=["reddit", "youtube", "jobs", "hackernews"],
+ requested_sources=None,
+ depth="default",
+ provider=None,
+ model=None,
+ )
+ self.assertEqual("product", plan.intent)
+ self.assertIn("jobs", plan.subqueries[0].sources)
+ self.assertGreater(plan.source_weights["jobs"], plan.source_weights["youtube"])
+
def test_prediction_includes_tiktok_and_instagram(self):
"""TikTok and Instagram are no longer excluded from prediction intent."""
plan = planner.plan_query(
diff --git a/tests/test_render_hiring_signals.py b/tests/test_render_hiring_signals.py
new file mode 100644
index 00000000..232961da
--- /dev/null
+++ b/tests/test_render_hiring_signals.py
@@ -0,0 +1,91 @@
+import unittest
+
+from lib import render, schema
+
+
+class RenderHiringSignalsTests(unittest.TestCase):
+ def test_render_hiring_signals_block_with_citations(self):
+ report = schema.Report(
+ topic="Listen Labs",
+ range_from="2026-05-16",
+ range_to="2026-06-16",
+ generated_at="2026-06-16T00:00:00Z",
+ provider_runtime=schema.ProviderRuntime("mock", "mock", "mock"),
+ query_plan=schema.QueryPlan(
+ intent="product",
+ freshness_mode="balanced_recent",
+ cluster_mode="none",
+ raw_topic="Listen Labs",
+ subqueries=[],
+ source_weights={},
+ ),
+ clusters=[],
+ ranked_candidates=[],
+ items_by_source={},
+ errors_by_source={},
+ artifacts={
+ "hiring_signals": {
+ "mode": "standard",
+ "company_size_tier": "startup",
+ "include": True,
+ "signals": [
+ {
+ "theme": "enterprise readiness",
+ "interpretation": "appears to be increasing focus on enterprise readiness",
+ "confidence": "medium",
+ "evidence_count": 2,
+ "evidence": [
+ {
+ "title": "Enterprise Security Engineer",
+ "url": "https://example.com/jobs/1",
+ "department": "Engineering",
+ "published_at": "2026-06-01",
+ }
+ ],
+ }
+ ],
+ }
+ },
+ )
+ block = "\n".join(render._render_hiring_signals(report))
+ self.assertIn("Hiring Signals", block)
+ self.assertIn("[Enterprise Security Engineer](https://example.com/jobs/1)", block)
+ self.assertIn("not exact roadmap predictions", block)
+ html_md = render.render_for_html(report)
+ self.assertIn("Hiring Signals", html_md)
+ self.assertIn("[Enterprise Security Engineer](https://example.com/jobs/1)", html_md)
+
+ def test_standard_mode_omits_weak_signal(self):
+ report = schema.Report(
+ topic="Apple",
+ range_from="2026-05-16",
+ range_to="2026-06-16",
+ generated_at="2026-06-16T00:00:00Z",
+ provider_runtime=schema.ProviderRuntime("mock", "mock", "mock"),
+ query_plan=schema.QueryPlan(
+ intent="product",
+ freshness_mode="balanced_recent",
+ cluster_mode="none",
+ raw_topic="Apple",
+ subqueries=[],
+ source_weights={},
+ ),
+ clusters=[],
+ ranked_candidates=[],
+ items_by_source={},
+ errors_by_source={},
+ artifacts={
+ "hiring_signals": {
+ "mode": "standard",
+ "company_size_tier": "mega-cap",
+ "include": False,
+ "signals": [],
+ "omitted_reason": "jobs evidence is too diffuse",
+ }
+ },
+ )
+ self.assertEqual([], render._render_hiring_signals(report))
+
+
+if __name__ == "__main__":
+ unittest.main()