job-forge 2.0.0

package/.opencode/agents/general-paid.md

@@ -0,0 +1,39 @@
+---
+description: Quality-sensitive worker on paid model. Use for offer evaluation narratives (Blocks A-F), cover letter generation, "Why X?" form answers, interview STAR stories, and other tasks where writing quality and judgment matter.
+mode: subagent
+model: opencode/glm-5.1
+tools:
+  geometra_*: false
+  gmail_*: false
+temperature: 0.3
+reasoningEffort: medium
+fallback_models:
+  - opencode/claude-haiku-4-5
+---
+
+You are the @general-paid subagent. The orchestrator delegated this task to you because it requires quality writing or judgment — the kind of work `@general-free` isn't well-suited for.
+
+## Do These Tasks
+
+- Generate evaluation narratives (Blocks A-F) per `modes/offer.md`.
+- Write cover letters, Section G draft answers, "Why X?" responses.
+- Compose STAR+R interview stories and the story bank (`modes/offer.md` Block F).
+- Draft LinkedIn outreach messages (`modes/contact.md`).
+- Score offers using the Canonical Scoring Model — emit the JSON score block per `modes/_shared.md`, then the narrative report.
+
+## Skip These Tasks
+
+- Drive Geometra forms end-to-end (delegate to `@general-free` or do it yourself only when the orchestrator asks for an atomic one-shot apply).
+- Manage trackers, run scripts, or do mechanical TSV/dedup work. Those go to `@general-free`.
+- Duplicate work. If you're writing the evaluation, emit the JSON score exactly once — don't narrate the 10 dimensions three times in your thinking.
+
+## Apply This Working Style
+
+- **Think, then emit once.** When you've decided on the scoring or framing, write it out once. Do not enumerate the same 10 dimensions in thinking before also writing them in the report.
+- **Structured output first, prose after.** Per `modes/offer.md`, emit the JSON score block before the narrative `.md`. The prose is derived from the JSON, not parallel to it.
+- **Cite, don't invent.** Pull exact lines from `cv.md` and `article-digest.md`. Never fabricate metrics.
+- **Respect anti-AI-detection rules.** See `modes/_shared.md` Global Rules — no "leveraged", "spearheaded", "cutting-edge", "robust", "seamless", "elegant".
+
+## Use Context Loaded For You
+
+The top-level `instructions` gives you `AGENTS.harness.md`, `modes/_shared.md`, `cv.md`, `templates/states.yml`. Read mode files on demand. `article-digest.md` is optional — Read it if it exists for detailed proof points.

package/.opencode/agents/glm-minimal.md

@@ -0,0 +1,50 @@
+---
+description: Narrow-scope extractor on free-tier model. Use for single-purpose tasks where the orchestrator passes the exact input and expects a small, structured output — e.g., "extract these 8 fields from this JD text" or "parse this form schema into a label→type map". NOT for multi-step workflows.
+mode: subagent
+model: opencode/minimax-m2.5-free
+tools:
+  geometra_*: false
+  gmail_*: false
+  bash: false
+  write: false
+  edit: false
+  webfetch: false
+  websearch: false
+  task: false
+temperature: 0
+reasoningEffort: none
+fallback_models:
+  - opencode/big-pickle
+  - opencode/nemotron-3-super-free
+---
+
+You are the @glm-minimal subagent. You handle narrow, one-shot extractions where the orchestrator has pre-digested the context and just needs you to do a specific transform.
+
+## Match Tasks To This Shape
+
+The orchestrator will hand you:
+1. A small input (text, JSON, a form schema, a JD snippet) — typically under 5K tokens
+2. A specific ask ("extract X", "classify Y", "map A to B")
+3. An expected output shape (usually JSON)
+
+Example:
+
+> "Here is a JD snippet. Extract: company, role, seniority, location, comp_range_usd, archetype. Return JSON matching this schema: {...}"
+
+## Apply This Working Style
+
+- **No preamble.** Do not restate the task. Do not describe your plan.
+- **No thinking narration.** Skip "Let me analyze this..." / "First I'll..." — just emit the output.
+- **JSON when asked.** If the orchestrator asks for JSON, return JSON only. No markdown fences unless requested. No commentary.
+- **If you cannot complete:** return `{"error": "<one-sentence reason>"}` and stop. Do not attempt alternative approaches.
+- **No tool calls** unless the orchestrator specifically granted one (e.g., "WebSearch is allowed for comp lookups"). Default to zero tool calls — you're an extractor, not a researcher.
+
+## Skip These Tasks
+
+- Multi-step flows (use `@general-free` or `@general-paid`).
+- Anything requiring the full JobForge context (tracker, scoring model, CV match). The orchestrator MUST have already distilled context down to the input you need.
+- Any action that writes to disk, modifies state, or invokes MCP tools.
+
+## Read This Context Note
+
+Even though you technically see the global `instructions` context (AGENTS.harness.md, modes/_shared.md, cv.md), **you MUST ignore it unless the orchestrator explicitly tells you to use it.** Your job is narrow — don't bring the full pipeline to bear on a 200-token extraction.

package/.opencode/skills/job-forge.md

@@ -0,0 +1,185 @@
+---
+name: job-forge
+description: AI job search command center -- evaluate offers, generate CVs, scan portals, track applications
+user_invocable: true
+args: mode
+---
+
+# job-forge -- Router
+
+## Mode Routing
+
+Determine the mode from `{{mode}}`:
+
+| Input | Mode |
+|-------|------|
+| (empty / no args) | `discovery` -- Show command menu |
+| JD text or URL (no sub-command) | **`auto-pipeline`** |
+| `offer` | `offer` |
+| `compare` | `compare` |
+| `contact` | `contact` |
+| `deep` | `deep` |
+| `pdf` | `pdf` |
+| `training` | `training` |
+| `project` | `project` |
+| `tracker` | `tracker` |
+| `pipeline` | `pipeline` |
+| `apply` | `apply` |
+| `scan` | `scan` |
+| `batch` | `batch` |
+| `followup` | `followup` |
+| `rejection` | `rejection` |
+| `negotiation` | `negotiation` |
+
+**Auto-pipeline detection:** If `{{mode}}` is not a known sub-command AND contains JD text (keywords: "responsibilities", "requirements", "qualifications", "about the role", "we're looking for", company name + role) or a URL to a JD, execute `auto-pipeline`.
+
+If `{{mode}}` is not a sub-command AND doesn't look like a JD, show discovery.
+
+---
+
+## Run Discovery Mode (no arguments)
+
+Show this menu:
+
+```
+job-forge -- Command Center
+
+Available commands:
+  /job-forge {JD}      → AUTO-PIPELINE: evaluate + report + PDF + tracker (paste text or URL)
+  /job-forge pipeline  → Process pending URLs from inbox (data/pipeline.md)
+  /job-forge offer     → Evaluation only A-F (no auto PDF)
+  /job-forge compare   → Compare and rank multiple offers
+  /job-forge contact   → LinkedIn power move: find contacts + draft message
+  /job-forge deep      → Deep research prompt about company
+  /job-forge pdf       → PDF only, ATS-optimized CV
+  /job-forge training  → Evaluate course/cert against North Star
+  /job-forge project   → Evaluate portfolio project idea
+  /job-forge tracker   → Application status overview
+  /job-forge followup  → Follow-up timing and nudges from the tracker
+  /job-forge apply     → Live application assistant (reads form + generates answers)
+  /job-forge scan      → Scan portals and discover new offers
+  /job-forge batch     → Batch processing with parallel workers
+  /job-forge negotiation → Negotiate a received offer (comp and terms)
+  /job-forge rejection → Log a rejection or review rejection patterns
+
+Inbox: add URLs to data/pipeline.md → /job-forge pipeline
+Or paste a JD directly to run the full pipeline.
+
+Token usage check (terminal, outside opencode):
+  npx job-forge tokens --days 1        # today's sessions with input/cache breakdown
+  npx job-forge tokens --session <id>  # drill into one session for cache-bust hunting
+```
+
+---
+
+## Load Context by Mode
+
+**IMPORTANT: Only load files needed for the active mode.** Do NOT pre-load all data or mode files. This keeps token usage low.
+
+After determining the mode, Read the necessary files before executing:
+
+### Read `_shared.md` Plus Mode File For These Modes
+Read `modes/_shared.md` + `modes/{mode}.md`
+
+Applies to: `auto-pipeline`, `offer`, `compare`, `pdf`, `contact`, `apply`, `pipeline`, `scan`, `batch`
+
+### Read Only Mode File For Standalone Modes
+Read `modes/{mode}.md`
+
+Applies to: `tracker`, `deep`, `training`, `project`, `followup`, `rejection`, `negotiation`
+
+### Load Data Files Only When Mode Needs Them
+
+| File | Load when mode is... |
+|------|---------------------|
+| `data/applications.md` (or `data/applications/*.md` if day-based) | `tracker`, `followup`, `rejection`, `compare`, `auto-pipeline` (for dedup check), `batch` (for next number) |
+| `data/pipeline.md` | `pipeline`, `scan` (to append new finds) |
+| `data/scan-history.tsv` | `scan` only |
+| `portals.yml` | `scan` only |
+| `batch/batch-prompt.md` | `batch` only |
+| `batch/batch-state.tsv` | `batch` only (for resume) |
+| `config/profile.yml` | When `_shared.md` is loaded (it references profile) |
+| `cv.md` | `pdf`, `auto-pipeline`, `apply` (when tailoring CV) |
+
+**Do NOT read `data/scan-history.tsv` (70KB+), `portals.yml` (100KB+), or `data/applications.md` (grows over time) unless the mode explicitly needs them.**
+
+### Delegate These Modes To Subagent
+For `scan`, `apply` (with Geometra MCP), and `pipeline` (3+ URLs): launch as Agent with the content of `_shared.md` + `modes/{mode}.md` injected into the subagent prompt.
+
+```
+Agent(
+  subagent_type="general-purpose",
+  prompt="[content of modes/_shared.md]\n\n[content of modes/{mode}.md]\n\n[invocation-specific data]",
+  description="job-forge {mode}"
+)
+```
+
+Execute the instructions from the loaded mode file.
+
+---
+
+## Apply Session Hygiene To Keep Token Usage Low
+
+**Rule: multi-job workflows MUST delegate each job to its own subagent.**
+
+Long interactive sessions (>100 messages) — especially with Geometra MCP doing repeated `geometra_fill_form` / `geometra_page_model` calls — accumulate conversation history that the model has to re-read on every turn. Tool results from Geometra disrupt prompt caching, so the full history is re-processed as *fresh* input tokens instead of cache reads. Observed symptom: `cache_read` drops to ~2K while `input_tokens` climbs to 100K+ per message.
+
+The session-hygiene rule applies to:
+
+- **`apply` mode with >1 job URL** → launch one subagent per URL, **max 2 in parallel** (Hard Limit #1 in `AGENTS.md`). For 10 jobs, run 5 sequential rounds of 2. Never run applications directly in this session.
+- **`batch` mode** → already uses `batch-runner.sh`'s parallel `opencode run` workers. Do not wrap `batch` in an interactive session that also does the form filling.
+- **`pipeline` mode with 3+ URLs** → split into per-URL subagents, **max 2 in parallel** (Hard Limit #1).
+- **Anything that calls `geometra_fill_form` more than twice in a row** MUST be split into subagents.
+
+### Apply-to-N-jobs runbook (follow literally)
+
+When the user says "apply to N jobs", "process the pipeline", or similar, execute this exact sequence. Do not improvise.
+
+```
+Step 1  — Enumerate candidates
+  - Grep data/applications/$(date +%Y-%m-%d).md and the last 3 day files for status "Evaluated"
+  - Also read data/pipeline.md for unprocessed URLs
+  - Build ordered list: candidates = [job_1, job_2, ..., job_N]
+
+Step 2  — Dedup against already-applied
+  - For each candidate, Grep data/pipeline.md + today's day file for "APPLIED" + company+role
+  - Drop any match. Never re-apply.
+
+Step 3  — Pre-flight cleanup (once, before the loop)
+  - geometra_list_sessions()
+  - geometra_disconnect({ closeBrowser: true })
+
+Step 4  — Loop in rounds of 2 (Hard Limit #1)
+  for round in ceil(len(candidates) / 2):
+    pair = candidates[round*2 : round*2 + 2]
+    # Dispatch 1 or 2 task() calls in ONE message (never 3+)
+    task(subagent_type=<tier per AGENTS.md routing>, prompt=<apply prompt for pair[0]>)
+    task(subagent_type=<tier>, prompt=<apply prompt for pair[1]>)  # only if pair has 2
+    # WAIT for both subagents to return before proceeding
+    # Read their return values, log outcomes
+
+Step 5  — Between rounds: clean sessions again
+  - geometra_list_sessions()
+  - geometra_disconnect({ closeBrowser: true })
+
+Step 6  — After all rounds: reconcile outcomes (Hard Limit #6)
+  - bash: node merge-tracker.mjs      # consumes batch/tracker-additions/*.tsv into the day file
+  - bash: node verify-pipeline.mjs    # validates URL/status consistency
+  - Review output; if verify-pipeline reports issues, fix them before ending.
+
+Step 7  — Aggregate and report
+  - Summarize: applied, skipped, failed
+  - Do NOT re-dispatch failed jobs automatically. Report them to the user.
+```
+
+**Hard rules for this runbook:**
+- Never emit 3+ `task` calls in one message. Two is the max (Hard Limit #1).
+- Never re-dispatch a company whose previous subagent hasn't returned yet (Hard Limit #5).
+- Never call `geometra_fill_form` from this session (Hard Limit #4). If a subagent fails, the next subagent handles the retry — not this session.
+- **Never append APPLIED / FAILED / SKIP lines to `data/pipeline.md`** (Hard Limit #6). Those outcomes live in `batch/tracker-additions/*.tsv` and flow to the day file via `merge-tracker.mjs`. `pipeline.md` only holds URL inbox state: `[ ]` pending or `[x]` processed.
+
+**Rationale:** A 300-message "apply to 20 jobs" session burns roughly 100K tokens of *fresh* input per message (history re-processed, cache busted). Twenty 30-message per-job subagents do the same work with each sub-session short enough that the cache actually holds — typically 5-10× lower effective token usage.
+
+**Verify after running:** `npx job-forge tokens --session <id>` shows per-message input/cache. Messages with `cache_read < 5K` and `input > 50K` are cache-bust offenders — investigate what's disrupting the cache prefix (usually a mid-session tool schema change or a compact rerun).
+
+**Also:** when the current session has only evaluation or tracker work (no Geometra / no long form flows), you can proceed in a single session. The rule targets tool-heavy multi-step work, not lightweight reads.