job-forge 2.14.12 → 2.14.14

package/.codex/config.toml

@@ -25,6 +25,5 @@ args = ["-y", "@razroo/gmail-mcp"]
 env = { DISABLE_HTTP = "true" }
 
 [mcp_servers.state-trace]
-command = "uvx"
-args = ["--from", "state-trace[mcp]", "state-trace-mcp"]
+command = "state-trace-mcp"
 env = { STATE_TRACE_STORAGE_PATH = ".state-trace/memory.db", STATE_TRACE_NAMESPACE = "job-forge", STATE_TRACE_CAPACITY_LIMIT = "256" }

package/.cursor/mcp.json

@@ -18,12 +18,7 @@
       }
     },
     "state-trace": {
-      "command": "uvx",
-      "args": [
-        "--from",
-        "state-trace[mcp]",
-        "state-trace-mcp"
-      ],
+      "command": "state-trace-mcp",
       "env": {
         "STATE_TRACE_STORAGE_PATH": ".state-trace/memory.db",
         "STATE_TRACE_NAMESPACE": "job-forge",

package/.cursor/rules/main.mdc

@@ -12,7 +12,7 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [H1] Max 2 parallel `task` dispatches per message. For N jobs, run `ceil(N/2)` sequential rounds of 2. A round is not complete until both subagents return a final outcome (`APPLIED`, `APPLY FAILED`, `SKIP`, `Discarded`, or a written TSV path). A `task` tool result that only gives a session id / title is a launch acknowledgement, not completion. Applies in all modes, for all user phrasings ("urgent", "apply to 10 jobs now").
   why: each subagent requires post-cleanup and racing more than 2 reliably loses at least one result. On 2026-04-25 the orchestrator launched round 2 while round 1 had only returned task ids, leaving four application subagents in flight and losing two provider recoveries
 
-- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch.
+- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch and pick a replacement from the remaining candidate list. Do not count duplicates toward a requested "apply to N jobs" total, and do not delegate obvious duplicates just so a subagent can return SKIP.
   why: 2026-04 same-day batch collision — when two batches target the same role, `npx job-forge merge` updates the existing day-file row rather than appending, so grepping day files alone misses earlier-batch applies; merged/*.tsv is the only place the breadcrumb remains
 
 - [H3] Before every batch of `task` dispatches that will use Geometra, call `geometra_list_sessions` then `geometra_disconnect({closeBrowser: true})`. Every round, no exceptions. Name this cleanup as an explicit "step 0" in your first-response plan for any multi-apply request — it is the most frequently skipped guardrail in practice, and skipping it produces cascade "Not connected" failures on the next dispatch.
@@ -56,6 +56,9 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [D6] Pick the mode from the **Routing** table below AND name it explicitly in your first response (e.g., "running auto-pipeline mode", "this is a `compare` request"). If no row matches the user's intent, ask which mode fits; do not guess.
   why: silent mode picks mis-route work (a "negotiation" question answered in `offer` mode produces the wrong report shape); naming the mode out loud makes the routing decision reviewable and gives downstream dispatches a reliable anchor
 
+- [D7] For standalone `batch` runs, prefer `batch/batch-runner.sh` instead of hand-rolling the loop. It delegates to `@razroo/iso-orchestrator`, persists workflow records in `.jobforge-runs/`, caps bundle fan-out, and mutexes state/report-number writes. Use `JOBFORGE_LEGACY_BATCH_RUNNER=1` only as a fallback.
+  why: the old Bash loop encoded resumability and parallelism manually; the iso-orchestrator path makes the durable control state inspectable and prevents report-number collisions under parallel bundles
+
 ## Procedure
 
 1. Check `cv.md`, `profile.yml`, and `portals.yml`; onboard if any file is missing.

package/.mcp.json

@@ -18,12 +18,7 @@
       }
     },
     "state-trace": {
-      "command": "uvx",
-      "args": [
-        "--from",
-        "state-trace[mcp]",
-        "state-trace-mcp"
-      ],
+      "command": "state-trace-mcp",
       "env": {
         "STATE_TRACE_STORAGE_PATH": ".state-trace/memory.db",
         "STATE_TRACE_NAMESPACE": "job-forge",

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

@@ -137,13 +137,18 @@ When the user says "apply to N jobs", "process the pipeline", or similar, execut
 
 ```
 Step 1  — Enumerate candidates
-  - Grep data/applications/$(date +%Y-%m-%d).md and the last 3 day files for status "Evaluated"
+  - Grep data/applications/*.md for status "Evaluated" without loading every file into context
   - 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.
+  - For each candidate, grep all four sources for URL and company+role:
+    data/pipeline.md, data/applications/*.md, batch/tracker-additions/*.tsv,
+    batch/tracker-additions/merged/*.tsv
+  - Drop any APPLIED / Applied match before counting toward N. Never re-apply.
+  - If a subagent later returns SKIP because it found a duplicate, treat that as
+    a missed preflight check; finish the current round, re-run dedupe, then pick
+    a replacement from the remaining candidates.
 
 Step 3  — Pre-flight cleanup (once, before the loop)
   - geometra_list_sessions()

package/AGENTS.md

@@ -7,7 +7,7 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [H1] Max 2 parallel `task` dispatches per message. For N jobs, run `ceil(N/2)` sequential rounds of 2. A round is not complete until both subagents return a final outcome (`APPLIED`, `APPLY FAILED`, `SKIP`, `Discarded`, or a written TSV path). A `task` tool result that only gives a session id / title is a launch acknowledgement, not completion. Applies in all modes, for all user phrasings ("urgent", "apply to 10 jobs now").
   why: each subagent requires post-cleanup and racing more than 2 reliably loses at least one result. On 2026-04-25 the orchestrator launched round 2 while round 1 had only returned task ids, leaving four application subagents in flight and losing two provider recoveries
 
-- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch.
+- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch and pick a replacement from the remaining candidate list. Do not count duplicates toward a requested "apply to N jobs" total, and do not delegate obvious duplicates just so a subagent can return SKIP.
   why: 2026-04 same-day batch collision — when two batches target the same role, `npx job-forge merge` updates the existing day-file row rather than appending, so grepping day files alone misses earlier-batch applies; merged/*.tsv is the only place the breadcrumb remains
 
 - [H3] Before every batch of `task` dispatches that will use Geometra, call `geometra_list_sessions` then `geometra_disconnect({closeBrowser: true})`. Every round, no exceptions. Name this cleanup as an explicit "step 0" in your first-response plan for any multi-apply request — it is the most frequently skipped guardrail in practice, and skipping it produces cascade "Not connected" failures on the next dispatch.
@@ -51,6 +51,9 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [D6] Pick the mode from the **Routing** table below AND name it explicitly in your first response (e.g., "running auto-pipeline mode", "this is a `compare` request"). If no row matches the user's intent, ask which mode fits; do not guess.
   why: silent mode picks mis-route work (a "negotiation" question answered in `offer` mode produces the wrong report shape); naming the mode out loud makes the routing decision reviewable and gives downstream dispatches a reliable anchor
 
+- [D7] For standalone `batch` runs, prefer `batch/batch-runner.sh` instead of hand-rolling the loop. It delegates to `@razroo/iso-orchestrator`, persists workflow records in `.jobforge-runs/`, caps bundle fan-out, and mutexes state/report-number writes. Use `JOBFORGE_LEGACY_BATCH_RUNNER=1` only as a fallback.
+  why: the old Bash loop encoded resumability and parallelism manually; the iso-orchestrator path makes the durable control state inspectable and prevents report-number collisions under parallel bundles
+
 ## Procedure
 
 1. Check `cv.md`, `profile.yml`, and `portals.yml`; onboard if any file is missing.

package/CLAUDE.md

@@ -7,7 +7,7 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [H1] Max 2 parallel `task` dispatches per message. For N jobs, run `ceil(N/2)` sequential rounds of 2. A round is not complete until both subagents return a final outcome (`APPLIED`, `APPLY FAILED`, `SKIP`, `Discarded`, or a written TSV path). A `task` tool result that only gives a session id / title is a launch acknowledgement, not completion. Applies in all modes, for all user phrasings ("urgent", "apply to 10 jobs now").
   why: each subagent requires post-cleanup and racing more than 2 reliably loses at least one result. On 2026-04-25 the orchestrator launched round 2 while round 1 had only returned task ids, leaving four application subagents in flight and losing two provider recoveries
 
-- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch.
+- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch and pick a replacement from the remaining candidate list. Do not count duplicates toward a requested "apply to N jobs" total, and do not delegate obvious duplicates just so a subagent can return SKIP.
   why: 2026-04 same-day batch collision — when two batches target the same role, `npx job-forge merge` updates the existing day-file row rather than appending, so grepping day files alone misses earlier-batch applies; merged/*.tsv is the only place the breadcrumb remains
 
 - [H3] Before every batch of `task` dispatches that will use Geometra, call `geometra_list_sessions` then `geometra_disconnect({closeBrowser: true})`. Every round, no exceptions. Name this cleanup as an explicit "step 0" in your first-response plan for any multi-apply request — it is the most frequently skipped guardrail in practice, and skipping it produces cascade "Not connected" failures on the next dispatch.
@@ -51,6 +51,9 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [D6] Pick the mode from the **Routing** table below AND name it explicitly in your first response (e.g., "running auto-pipeline mode", "this is a `compare` request"). If no row matches the user's intent, ask which mode fits; do not guess.
   why: silent mode picks mis-route work (a "negotiation" question answered in `offer` mode produces the wrong report shape); naming the mode out loud makes the routing decision reviewable and gives downstream dispatches a reliable anchor
 
+- [D7] For standalone `batch` runs, prefer `batch/batch-runner.sh` instead of hand-rolling the loop. It delegates to `@razroo/iso-orchestrator`, persists workflow records in `.jobforge-runs/`, caps bundle fan-out, and mutexes state/report-number writes. Use `JOBFORGE_LEGACY_BATCH_RUNNER=1` only as a fallback.
+  why: the old Bash loop encoded resumability and parallelism manually; the iso-orchestrator path makes the durable control state inspectable and prevents report-number collisions under parallel bundles
+
 ## Procedure
 
 1. Check `cv.md`, `profile.yml`, and `portals.yml`; onboard if any file is missing.

package/README.md

@@ -29,7 +29,7 @@ The scaffolded `opencode.json` already has three MCPs wired up — they launch a
 
 - **Geometra** — browser automation + PDF generation
 - **Gmail** — reads replies from recruiters
-- **state-trace** — typed working memory for cross-session context (resumed batches, recent decisions, repeated portal quirks). Spawned via `uvx`; install once with `brew install uv` (or `pipx install uv`) — no other setup.
+- **state-trace** — typed working memory for cross-session context (resumed batches, recent decisions, repeated portal quirks). Install once with `python3 -m pip install "state-trace[mcp]"`; the MCP command is `state-trace-mcp`.
 
 `npm install` also materializes symlinks for every supported agent harness — OpenCode, Cursor, Claude Code, and Codex — so you can run `opencode`, `cursor`, `claude`, or `codex` in the same project and each picks up the shared MCP config and instructions.
 
@@ -73,6 +73,7 @@ JobForge turns opencode into a full job search command center. Instead of manual
 | **Smart LinkedIn Outreach** | Reads evaluation reports to craft targeted messages using top proof points |
 | **Portal Scanner** | 45+ companies pre-configured with fuzzy dedup for reposts |
 | **Batch Processing** | Parallel evaluation with `opencode run` workers, with honest verification flagging |
+| **Durable Batch Orchestration** | `batch-runner.sh` uses `@razroo/iso-orchestrator` for resumable bundle execution, bounded fan-out, mutexed state writes, and workflow records in `.jobforge-runs/`. |
 | **Pipeline Integrity** | Automated merge, dedup, status normalization, health checks |
 | **Cost-Aware Agent Routing** | Three subagents (`@general-free`, `@general-paid`, `@glm-minimal`) with per-task tool surfaces. On OpenCode, JobForge pins all tiers to `opencode-go/deepseek-v4-flash` so application runs avoid overloaded free-model pools. See [Subagent Routing in AGENTS.md](AGENTS.md) for the task-to-agent mapping. |
 | **Trace + Telemetry** | `job-forge trace:*` exposes local OpenCode transcripts, and `job-forge telemetry:*` summarizes runs, child outcomes, provider errors, and pending tracker TSVs. |
@@ -144,6 +145,7 @@ my-search/
 ├── data/                         # applications, pipeline, scan history (personal, gitignored)
 ├── reports/                      # generated evaluation reports (personal, gitignored)
 ├── batch/{batch-input,batch-state}.tsv, tracker-additions/, logs/   # personal
+├── .jobforge-runs/                # durable batch workflow records (generated)
 ├── AGENTS.md                     # personal overrides (opencode + codex)
 ├── CLAUDE.md                     # personal overrides (Claude Code), @-imports CLAUDE.harness.md
 │
@@ -187,6 +189,7 @@ JobForge/
 ├── config/profile.example.yml    # template for consumer's profile.yml
 ├── batch/{batch-prompt.md,batch-runner.sh}   # batch orchestrator
 ├── scripts/
+│   ├── batch-orchestrator.mjs    # iso-orchestrator-backed batch control loop
 │   ├── token-usage-report.mjs    # opencode cost analyzer
 │   └── release/check-source.mjs  # version gate for npm publish
 ├── tracker-lib.mjs / merge-tracker.mjs / dedup-tracker.mjs / verify-pipeline.mjs

package/batch/README.md

@@ -6,13 +6,20 @@ The `batch/` folder holds the **parallel batch runner** for processing 10+ job U
 
 | Path | Role |
 |------|------|
-| `batch-runner.sh` | Orchestrator: parallelism, state, retries, resume |
+| `batch-runner.sh` | Compatibility entrypoint; delegates to the durable Node orchestrator by default |
 | `batch-prompt.md` | Prompt template passed to each worker (keep evaluation and scoring instructions aligned with the canonical model in [`modes/_shared.md`](../modes/_shared.md) so batch scores match single-offer runs) |
 | `README.md` | This file |
 
 ## Local-only files (gitignored when present)
 
-Per [`.gitignore`](../.gitignore): `batch-input.tsv`, `batch-state.tsv`, `logs/*`, and `tracker-additions/*.tsv`. Empty dirs (`logs/`, `tracker-additions/`) use `.gitkeep` so the tree exists in a fresh clone.
+Per [`.gitignore`](../.gitignore): `batch-input.tsv`, `batch-state.tsv`, `logs/*`, `tracker-additions/*.tsv`, and `.jobforge-runs/`. Empty dirs (`logs/`, `tracker-additions/`) use `.gitkeep` so the tree exists in a fresh clone.
+
+The default runner uses `@razroo/iso-orchestrator` through
+`scripts/batch-orchestrator.mjs`. It persists bundle steps and events in
+`.jobforge-runs/`, caps worker fan-out with `workflow.forEach`, and serializes
+state/report-number writes while parallel bundles run. Use
+`JOBFORGE_LEGACY_BATCH_RUNNER=1 ./batch/batch-runner.sh` only to fall back to
+the old shell loop.
 
 ## Input: `batch-input.tsv`
 

package/batch/batch-runner.sh

@@ -6,8 +6,24 @@ set -euo pipefail
 # tracks state in batch-state.tsv for resumability.
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-BATCH_DIR="$SCRIPT_DIR"
+PROJECT_DIR="${JOB_FORGE_PROJECT:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+
+# Default path: delegate to the durable Node orchestrator. Keep the legacy
+# shell implementation below as an escape hatch while the new runner settles.
+SOURCE="${BASH_SOURCE[0]}"
+while [[ -L "$SOURCE" ]]; do
+  SOURCE_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ "$SOURCE" != /* ]] && SOURCE="$SOURCE_DIR/$SOURCE"
+done
+HARNESS_BATCH_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+HARNESS_DIR="$(cd "$HARNESS_BATCH_DIR/.." && pwd)"
+if [[ "${JOBFORGE_LEGACY_BATCH_RUNNER:-}" != "1" && -f "$HARNESS_DIR/scripts/batch-orchestrator.mjs" ]]; then
+  export JOB_FORGE_PROJECT="$PROJECT_DIR"
+  exec node "$HARNESS_DIR/scripts/batch-orchestrator.mjs" "$@"
+fi
+
+BATCH_DIR="$PROJECT_DIR/batch"
 INPUT_FILE="$BATCH_DIR/batch-input.tsv"
 STATE_FILE="$BATCH_DIR/batch-state.tsv"
 PROMPT_FILE="$BATCH_DIR/batch-prompt.md"

package/docs/ARCHITECTURE.md

@@ -131,11 +131,11 @@ For customization (archetypes, weights, tone), start with `_shared.md` and [CUST
 The batch system processes multiple offers in parallel:
 
 ```
-batch-input.tsv    →  batch-runner.sh  →  N × opencode run workers
-(id, url, source, notes) (orchestrator)   (self-contained prompt)
-                           │
-                    batch-state.tsv
-                    (tracks progress)
+batch-input.tsv    ->  batch-runner.sh  ->  N x opencode run workers
+(id, url, source, notes) (iso-orchestrator) (self-contained prompt)
+                           |
+                    batch-state.tsv + .jobforge-runs/
+                    (progress + durable workflow record)
 ```
 
 Each worker is a headless opencode instance (`opencode run`) that receives the full `batch-prompt.md` as context. Workers produce:
@@ -143,9 +143,13 @@ Each worker is a headless opencode instance (`opencode run`) that receives the f
 - PDF
 - Tracker TSV line
 
-The orchestrator manages parallelism, state, retries, and resume.
+The orchestrator manages parallelism, state, retries, and resume. The default
+runner delegates to `scripts/batch-orchestrator.mjs`, which uses
+`@razroo/iso-orchestrator` for bounded bundle fan-out, idempotent bundle steps,
+and mutexed report-number/state writes. Set `JOBFORGE_LEGACY_BATCH_RUNNER=1`
+only if you need the old shell loop.
 
-**Local batch artifacts:** `batch/batch-input.tsv`, `batch/batch-state.tsv`, `batch/logs/`, and `batch/tracker-additions/*.tsv` are created when you run the runner; they are gitignored (with `.gitkeep` in `batch/logs/` and `batch/tracker-additions/`). A fresh clone ships `batch/batch-runner.sh` and `batch/batch-prompt.md` only until you add an input file — see [`batch/README.md`](../batch/README.md) and `batch/batch-runner.sh --help` for the TSV layout and workflow.
+**Local batch artifacts:** `batch/batch-input.tsv`, `batch/batch-state.tsv`, `batch/logs/`, `batch/tracker-additions/*.tsv`, and `.jobforge-runs/` are created when you run the runner; they are gitignored (with `.gitkeep` in `batch/logs/` and `batch/tracker-additions/`). A fresh clone ships `batch/batch-runner.sh` and `batch/batch-prompt.md` only until you add an input file — see [`batch/README.md`](../batch/README.md) and `batch/batch-runner.sh --help` for the TSV layout and workflow.
 
 ## Data Flow
 

package/docs/SETUP.md

@@ -3,7 +3,7 @@
 ## Prerequisites
 
 - [opencode](https://opencode.ai) installed and configured
-- Node.js 18+ (for the CLI, PDF generation, and tracker scripts)
+- Node.js 20.6+ (for the CLI, PDF generation, tracker scripts, and durable batch orchestration)
 - [`uv`](https://docs.astral.sh/uv/) installed (`brew install uv` on macOS, or `pipx install uv`). Used by the state-trace MCP to spawn its Python entry point on demand via `uvx`. Without `uv`, the state-trace MCP fails to start; the rest of JobForge keeps working.
 - (Optional) Go (for the dashboard TUI) — use a toolchain that satisfies the `go` directive in [`dashboard/go.mod`](../dashboard/go.mod)
 

package/iso/commands/job-forge.md

@@ -140,13 +140,18 @@ When the user says "apply to N jobs", "process the pipeline", or similar, execut
 
 ```
 Step 1  — Enumerate candidates
-  - Grep data/applications/$(date +%Y-%m-%d).md and the last 3 day files for status "Evaluated"
+  - Grep data/applications/*.md for status "Evaluated" without loading every file into context
   - 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.
+  - For each candidate, grep all four sources for URL and company+role:
+    data/pipeline.md, data/applications/*.md, batch/tracker-additions/*.tsv,
+    batch/tracker-additions/merged/*.tsv
+  - Drop any APPLIED / Applied match before counting toward N. Never re-apply.
+  - If a subagent later returns SKIP because it found a duplicate, treat that as
+    a missed preflight check; finish the current round, re-run dedupe, then pick
+    a replacement from the remaining candidates.
 
 Step 3  — Pre-flight cleanup (once, before the loop)
   - geometra_list_sessions()

package/iso/instructions.md

@@ -7,7 +7,7 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [H1] Max 2 parallel `task` dispatches per message. For N jobs, run `ceil(N/2)` sequential rounds of 2. A round is not complete until both subagents return a final outcome (`APPLIED`, `APPLY FAILED`, `SKIP`, `Discarded`, or a written TSV path). A `task` tool result that only gives a session id / title is a launch acknowledgement, not completion. Applies in all modes, for all user phrasings ("urgent", "apply to 10 jobs now").
   why: each subagent requires post-cleanup and racing more than 2 reliably loses at least one result. On 2026-04-25 the orchestrator launched round 2 while round 1 had only returned task ids, leaving four application subagents in flight and losing two provider recoveries
 
-- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch.
+- [H2] Max 1 application per company+role. Before every `apply` dispatch, grep all four sources for the URL and for `company+role`: `data/pipeline.md`, all `data/applications/*.md` day files, `batch/tracker-additions/*.tsv`, `batch/tracker-additions/merged/*.tsv`. If any source shows APPLIED / Applied, skip the dispatch and pick a replacement from the remaining candidate list. Do not count duplicates toward a requested "apply to N jobs" total, and do not delegate obvious duplicates just so a subagent can return SKIP.
   why: 2026-04 same-day batch collision — when two batches target the same role, `npx job-forge merge` updates the existing day-file row rather than appending, so grepping day files alone misses earlier-batch applies; merged/*.tsv is the only place the breadcrumb remains
 
 - [H3] Before every batch of `task` dispatches that will use Geometra, call `geometra_list_sessions` then `geometra_disconnect({closeBrowser: true})`. Every round, no exceptions. Name this cleanup as an explicit "step 0" in your first-response plan for any multi-apply request — it is the most frequently skipped guardrail in practice, and skipping it produces cascade "Not connected" failures on the next dispatch.
@@ -51,6 +51,9 @@ AI-powered job search pipeline: scans portals, evaluates offers, generates CVs v
 - [D6] Pick the mode from the **Routing** table below AND name it explicitly in your first response (e.g., "running auto-pipeline mode", "this is a `compare` request"). If no row matches the user's intent, ask which mode fits; do not guess.
   why: silent mode picks mis-route work (a "negotiation" question answered in `offer` mode produces the wrong report shape); naming the mode out loud makes the routing decision reviewable and gives downstream dispatches a reliable anchor
 
+- [D7] For standalone `batch` runs, prefer `batch/batch-runner.sh` instead of hand-rolling the loop. It delegates to `@razroo/iso-orchestrator`, persists workflow records in `.jobforge-runs/`, caps bundle fan-out, and mutexes state/report-number writes. Use `JOBFORGE_LEGACY_BATCH_RUNNER=1` only as a fallback.
+  why: the old Bash loop encoded resumability and parallelism manually; the iso-orchestrator path makes the durable control state inspectable and prevents report-number collisions under parallel bundles
+
 ## Procedure
 
 1. Check `cv.md`, `profile.yml`, and `portals.yml`; onboard if any file is missing.

package/iso/mcp.json

@@ -12,8 +12,7 @@
       }
     },
     "state-trace": {
-      "command": "uvx",
-      "args": ["--from", "state-trace[mcp]", "state-trace-mcp"],
+      "command": "state-trace-mcp",
       "env": {
         "STATE_TRACE_STORAGE_PATH": ".state-trace/memory.db",
         "STATE_TRACE_NAMESPACE": "job-forge",

package/modes/apply.md

@@ -176,7 +176,10 @@ When `location_constraints` is absent, use the prose fields:
 
 ```
 Step 1  — Build the job list (N items)
-Step 2  — Dedup: Grep data/pipeline.md + today's day file for each company+role. Drop any already APPLIED.
+Step 2  — Dedup: for each candidate, grep all four sources for the URL and for company+role:
+          data/pipeline.md, all data/applications/*.md day files,
+          batch/tracker-additions/*.tsv, batch/tracker-additions/merged/*.tsv.
+          Drop any already APPLIED before counting toward N; pick replacements from the remaining list.
 Step 3  — geometra_list_sessions() + geometra_disconnect({closeBrowser: true})  [once, before loop]
 Step 4  — For round in ceil(N/2):
             pair = jobs[round*2 : round*2 + 2]
@@ -192,7 +195,7 @@ Step 6  — Reconcile outcomes (Hard Limit #6):
 Step 7  — Summarize outcomes; do NOT auto-retry failures.
 ```
 
-If a subagent fails, report it in the summary and let the user decide whether to retry. Never auto-retry — re-running a submit step risks duplicate applications.
+If a subagent fails, report it in the summary and let the user decide whether to retry. Never auto-retry — re-running a submit step risks duplicate applications. If a subagent returns SKIP because it discovered a duplicate, treat that as a missed preflight check: finish the current round, then choose a replacement candidate only after re-running dedupe against all four sources.
 
 **Outcome routing (Hard Limit #6 in `AGENTS.md`):**
 - Subagents write `batch/tracker-additions/{num}-{slug}.tsv` — one TSV per job.

package/modes/batch.md

@@ -30,6 +30,7 @@ Each worker is a child `opencode run` with a clean 200K token context. The condu
 ## Read These Files
 
 ```
+.jobforge-runs/                  # Durable iso-orchestrator records (gitignored)
 batch/
   batch-input.tsv               # URLs (from conductor or manual)
   batch-state.tsv               # Progress (auto-generated, gitignored)
@@ -66,12 +67,19 @@ d. Execute via Bash:
 batch/batch-runner.sh [OPTIONS]
 ```
 
+`batch-runner.sh` delegates to `scripts/batch-orchestrator.mjs` by default.
+That Node runner uses `@razroo/iso-orchestrator` to persist workflow records in
+`.jobforge-runs/`, cap bundle fan-out with `workflow.forEach`, and serialize
+report-number/state writes while workers run in parallel. If a regression
+requires the old shell loop, run with `JOBFORGE_LEGACY_BATCH_RUNNER=1`.
+
 Options:
 - `--dry-run` — list pending without executing
 - `--retry-failed` — only retry failed ones
 - `--start-from N` — start from ID N
 - `--parallel N` — N workers in parallel
 - `--max-retries N` — attempts per offer (default: 2)
+- `--workflow-id ID` — durable workflow id (default: `jobforge-batch`)
 
 ## Read batch-state.tsv Format
 
@@ -85,6 +93,7 @@ id	url	status	started_at	completed_at	report_num	score	error	retries
 ## Use Resumability
 
 - If it dies → re-run → reads `batch-state.tsv` → skips completed
+- `.jobforge-runs/` keeps the durable run record, step outcomes, and bundle events
 - Lock file (`batch-runner.pid`) prevents double execution
 - Each worker is independent: failure on offer #47 does not affect the rest
 

package/opencode.json

@@ -36,9 +36,6 @@
     "state-trace": {
       "type": "local",
       "command": [
-        "uvx",
-        "--from",
-        "state-trace[mcp]",
         "state-trace-mcp"
       ],
       "environment": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-forge",
-  "version": "2.14.12",
+  "version": "2.14.14",
   "description": "AI-powered job search pipeline built on opencode",
   "type": "module",
   "bin": {
@@ -86,9 +86,10 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.6.0"
   },
   "dependencies": {
+    "@razroo/iso-orchestrator": "^0.1.0",
     "@razroo/iso-trace": "^0.4.0",
     "playwright": "^1.58.1"
   },