diff --git a/AGENTS.md b/AGENTS.md
index f6b84eea4..72f3504ca 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -311,7 +311,7 @@ During normal plan review, an Archive sidebar tab provides the same browsing via
 | `/api/external-annotations` | POST | Add external annotations (single or batch `{ annotations: [...] }`) |
 | `/api/external-annotations` | PATCH | Update fields on a single annotation (`?id=`) |
 | `/api/external-annotations` | DELETE | Remove by `?id=`, `?source=`, or clear all |
-| `/api/agents/capabilities` | GET | Check available agent providers (claude, codex, tour) |
+| `/api/agents/capabilities` | GET | Check available agent providers (claude, codex, tour, cursor, opencode) |
 | `/api/agents/review-profiles` | GET | List launchable review profiles (enabled skills + builtin default) |
 | `/api/agents/skills` | GET | List all discovered skills for the add-a-review picker (each flagged `enabled`) |
 | `/api/agents/review-skills` | POST | Enable a skill as a review (body: `{ name }`); writes `review-skills.json` |
diff --git a/apps/pi-extension/server/agent-jobs.ts b/apps/pi-extension/server/agent-jobs.ts
index fd91d6854..2eee5b079 100644
--- a/apps/pi-extension/server/agent-jobs.ts
+++ b/apps/pi-extension/server/agent-jobs.ts
@@ -8,7 +8,10 @@
  */
 
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { spawn, execFileSync, type ChildProcess } from "node:child_process";
+import { spawn, execFileSync, execFile, type ChildProcess } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
 import {
 	type AgentJobInfo,
 	type AgentJobEvent,
@@ -21,6 +24,12 @@ import {
 	AGENT_HEARTBEAT_INTERVAL_MS,
 } from "../generated/agent-jobs.js";
 import { formatClaudeLogEvent } from "../generated/claude-review.js";
+import {
+	MARKER_ENGINES,
+	formatMarkerLogEvent,
+	type MarkerEngine,
+	type MarkerModel,
+} from "../generated/marker-review.js";
 import { json, parseBody } from "./helpers.js";
 
 // ---------------------------------------------------------------------------
@@ -32,6 +41,16 @@ const JOBS = `${BASE}/jobs`;
 const JOBS_STREAM = `${JOBS}/stream`;
 const CAPABILITIES = `${BASE}/capabilities`;
 
+// Providers whose command is owned by the server. Client-supplied argv is never
+// spawned for these — buildCommand must produce the command or the launch fails.
+const SERVER_BUILT_PROVIDERS: ReadonlySet<string> = new Set([
+	"claude",
+	"codex",
+	"tour",
+	"cursor",
+	"opencode",
+]);
+
 // ---------------------------------------------------------------------------
 // which() helper for Node.js
 // ---------------------------------------------------------------------------
@@ -54,7 +73,7 @@ export interface AgentJobHandlerOptions {
 	mode: "plan" | "review" | "annotate";
 	getServerUrl: () => string;
 	getCwd: () => string;
-	/** Server-side command builder for known providers (codex, claude, tour). */
+	/** Build the command server-side for a given provider. */
 	buildCommand?: (provider: string, config?: Record<string, unknown>) => Promise<{
 		command: string[];
 		outputPath?: string;
@@ -88,6 +107,27 @@ export interface AgentJobHandlerOptions {
 	onJobComplete?: (job: AgentJobInfo, meta: { outputPath?: string; stdout?: string; cwd?: string }) => void | Promise<void>;
 }
 
+/**
+ * Best-effort model catalog for a marker engine, spawned once. The spawn lives
+ * HERE (per-runtime — child_process execFile) rather than in marker-review.ts,
+ * which must stay Bun-free for the Pi vendor build. ASYNC so it never blocks the
+ * event loop on the /capabilities request path (a slow/hanging CLI would otherwise
+ * freeze every other in-flight request for up to the timeout). Empty when discovery
+ * fails or the CLI is unauthenticated / has no providers configured — the UI falls
+ * back to the engine's default picker. Account/config-specific, so never hardcoded.
+ */
+async function discoverMarkerModels(engine: MarkerEngine): Promise<MarkerModel[]> {
+	try {
+		const { stdout } = await execFileAsync(engine.binary, engine.modelsArgv, {
+			timeout: 5000,
+			encoding: "utf8",
+		});
+		return engine.parseModels(stdout);
+	} catch {
+		return [];
+	}
+}
+
 export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 	const { mode, getServerUrl, getCwd } = options;
 
@@ -103,11 +143,32 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 		{ id: "codex", name: "Codex CLI", available: whichCmd("codex") },
 		{ id: "tour", name: "Code Tour", available: whichCmd("claude") || whichCmd("codex") },
 	];
-	const capabilitiesResponse: AgentCapabilities = {
-		mode,
-		providers: capabilities,
-		available: capabilities.some((c) => c.available),
-	};
+	// Marker engines (Cursor, OpenCode) — same shape, one loop. Available only in
+	// review mode when the binary is on PATH (NOTE: cursor's binary is `agent`).
+	// Model catalogs are discovered LAZILY (see buildCapabilitiesResponse) so a
+	// slow/unauthenticated `<binary> models` spawn never blocks startup.
+	for (const engine of Object.values(MARKER_ENGINES)) {
+		capabilities.push({
+			id: engine.id,
+			name: engine.name,
+			available: mode === "review" && whichCmd(engine.binary),
+		});
+	}
+
+	const markerModelsCache = new Map<string, MarkerModel[]>();
+	async function buildCapabilitiesResponse(): Promise<AgentCapabilities> {
+		const providers = await Promise.all(capabilities.map(async (c) => {
+			const engine = MARKER_ENGINES[c.id as "cursor" | "opencode"];
+			if (!engine || !c.available) return c;
+			let models = markerModelsCache.get(engine.id);
+			if (!models) {
+				models = await discoverMarkerModels(engine);
+				markerModelsCache.set(engine.id, models);
+			}
+			return { ...c, models };
+		}));
+		return { mode, providers, available: providers.some((p) => p.available) };
+	}
 
 	// --- SSE broadcasting ---
 	function broadcast(event: AgentJobEvent): void {
@@ -190,31 +251,47 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 			if (spawnOptions?.cwd) jobOutputPaths.set(`${id}:cwd`, spawnOptions.cwd);
 			broadcast({ type: "job:started", job: { ...info } });
 
-			// --- Stdout capture (Claude JSONL streaming) ---
+			// --- Stdout capture (Claude/Cursor stream-json) ---
 			let stdoutBuf = "";
 			if (captureStdout && proc.stdout) {
+				// Format one complete JSONL line into a live-log delta (skip result
+				// events — handled in onJobComplete).
+				const emitLogLine = (line: string) => {
+					if (!line.trim()) return;
+					// Tour jobs with the Claude engine also stream Claude JSONL.
+					if (provider === "claude" || spawnOptions?.engine === "claude") {
+						const formatted = formatClaudeLogEvent(line);
+						if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+						return;
+					}
+					// Marker engines (Cursor, OpenCode): map their NDJSON stream events
+					// into readable log deltas via the engine's own formatter (Cursor
+					// applies the partial-output dedup rule; OpenCode reads text parts).
+					const markerEngine = MARKER_ENGINES[provider as "cursor" | "opencode"];
+					if (markerEngine) {
+						const formatted = formatMarkerLogEvent(line, markerEngine);
+						if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+						return;
+					}
+					try {
+						const event = JSON.parse(line);
+						if (event.type === 'result') return;
+					} catch { /* not JSON — forward as raw log */ }
+					broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
+				};
+				// stream-json output is NDJSON and chunk boundaries are arbitrary —
+				// carry the trailing partial line until a later chunk completes it,
+				// otherwise records split across chunks are dropped from live logs.
+				let logLineCarry = "";
 				proc.stdout.on("data", (chunk: Buffer) => {
 					const text = chunk.toString();
 					stdoutBuf += text;
-
-					// Forward JSONL lines as log events
-					const lines = text.split('\n');
-					for (const line of lines) {
-						if (!line.trim()) continue;
-						// Tour jobs with the Claude engine also stream Claude JSONL.
-						if (provider === "claude" || spawnOptions?.engine === "claude") {
-							const formatted = formatClaudeLogEvent(line);
-							if (formatted !== null) {
-								broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
-							}
-							continue;
-						}
-						try {
-							const event = JSON.parse(line);
-							if (event.type === 'result') continue;
-						} catch { /* not JSON — forward as raw log */ }
-						broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
-					}
+					const lines = (logLineCarry + text).split('\n');
+					logLineCarry = lines.pop() ?? "";
+					for (const line of lines) emitLogLine(line);
+				});
+				proc.stdout.on("end", () => {
+					if (logLineCarry) emitLogLine(logLineCarry);
 				});
 			}
 
@@ -272,8 +349,15 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 							stdout: captureStdout ? stdoutBuf : undefined,
 							cwd: jobCwd,
 						});
-					} catch {
-						// Result ingestion failure shouldn't prevent job completion broadcast
+					} catch (err) {
+						// Claude/Codex are fail-open; Cursor and OpenCode are fail-closed — an
+						// unexpected throw during prompt-enforced ingestion must fail the job,
+						// not pass it. (Their handlers normally fail by mutation and never
+						// throw; this guards future refactors.)
+						if (MARKER_ENGINES[provider as "cursor" | "opencode"]) {
+							entry.info.status = "failed";
+							entry.info.error = err instanceof Error ? err.message : `${provider} result ingestion failed`;
+						}
 					}
 				}
 				jobOutputPaths.delete(id);
@@ -350,7 +434,7 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 		): Promise<boolean> {
 			// --- GET /api/agents/capabilities ---
 			if (url.pathname === CAPABILITIES && req.method === "GET") {
-				json(res, capabilitiesResponse);
+				json(res, await buildCapabilitiesResponse());
 				return true;
 			}
 
@@ -440,6 +524,19 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 						return true;
 					}
 
+					// Fail-closed enforcement for server-owned providers: the command MUST
+					// be built server-side. Client-supplied argv is never spawned for these
+					// providers — a null/throwing builder becomes an error, not a fallback.
+					if (SERVER_BUILT_PROVIDERS.has(provider)) {
+						if (!options.buildCommand) {
+							json(res, { error: `Provider ${provider} requires server-built command` }, 400);
+							return true;
+						}
+						// Discard any client-supplied argv so a null build cleanly hits the
+						// `command.length === 0` guard below instead of falling through.
+						command = [];
+					}
+
 					// Try server-side command building for known providers
 					let captureStdout = false;
 					let stdinPrompt: string | undefined;
diff --git a/apps/pi-extension/server/serverReview.ts b/apps/pi-extension/server/serverReview.ts
index 6c4f518fa..43ee06590 100644
--- a/apps/pi-extension/server/serverReview.ts
+++ b/apps/pi-extension/server/serverReview.ts
@@ -90,6 +90,15 @@ import {
 	transformClaudeFindings,
 } from "../generated/claude-review.js";
 import { createTourSession, TOUR_EMPTY_OUTPUT_ERROR } from "../generated/tour-review.js";
+import {
+	MARKER_ENGINES,
+	composeMarkerReviewPrompt,
+	buildMarkerCommand,
+	parseMarkerStreamOutput,
+	transformMarkerFindings,
+	makeMarkerNonce,
+	extractMarkerNonce,
+} from "../generated/marker-review.js";
 import {
 	WorkspaceReviewSession,
 	type WorkspaceDiffType,
@@ -588,6 +597,24 @@ export async function startReviewServer(options: {
 				return { command, stdinPrompt, prompt, cwd, label: jobLabel, captureStdout: true, model, effort, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
 			}
 
+			// Marker engines (Cursor, OpenCode) — one branch, same shape as Claude.
+			// Neither CLI has a schema flag, so composeMarkerReviewPrompt ALWAYS
+			// appends the marker-block output contract (even for a custom profile —
+			// it's the only thing that makes their prose output parseable). The
+			// engine's buildArgv passes the prompt as the trailing positional arg and
+			// threads the spawn cwd (--workspace for Cursor, --dir for OpenCode).
+			// captureStdout is required: the marker block comes back on stdout NDJSON.
+			const markerEngine = MARKER_ENGINES[provider as "cursor" | "opencode"];
+			if (markerEngine) {
+				const model = typeof config?.model === "string" && config.model ? config.model : undefined;
+				// Per-job nonce embedded in the marker contract; recovered from job.prompt
+				// at parse time so echoed/quoted bare tags can't be mistaken for the payload.
+				const nonce = makeMarkerNonce();
+				const prompt = composeMarkerReviewPrompt(reviewProfile, userMessage, nonce);
+				const { command } = buildMarkerCommand(markerEngine, prompt, model, cwd);
+				return { command, prompt, cwd, label: jobLabel, captureStdout: true, model, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
+			}
+
 			return null;
 		},
 
@@ -612,7 +639,7 @@ export async function startReviewServer(options: {
 			// Map findings onto annotations and ingest. Shared by both engine branches;
 			// no-ops on an empty set so a clean (zero-finding) review stays "done".
 			const ingest = <T extends object>(transformed: readonly T[], logTag: string) => {
-				if (transformed.length === 0) return;
+				if (transformed.length === 0) return undefined;
 				const annotations = transformed.map((a) => ({
 					...a,
 					...jobPrContext,
@@ -621,6 +648,7 @@ export async function startReviewServer(options: {
 				}));
 				const result = externalAnnotations.addAnnotations({ annotations });
 				if ("error" in result) console.error(`[${logTag}] addAnnotations error:`, result.error);
+				return result;
 			};
 
 			if (job.provider === "codex") {
@@ -682,6 +710,56 @@ export async function startReviewServer(options: {
 				return;
 			}
 
+			// --- Marker path (Cursor, OpenCode) ---
+			// FAIL-CLOSED: marker output is prompt-enforced (no schema flag), so any
+			// missing/malformed/schema/transform/insertion failure must MUTATE the job
+			// to failed — NEVER throw (agent-jobs.ts swallows throws, silently leaving
+			// an exit-0 job marked done). Mirrors the Tour fail-closed pattern below.
+			// Findings carry nullable file/line, classified into line/whole-file/
+			// general by transformMarkerFindings — nothing is dropped (same as Claude).
+			const markerEngine = MARKER_ENGINES[job.provider as "cursor" | "opencode"];
+			if (markerEngine) {
+				// Recover the per-job nonce embedded in the prompt; without it no block
+				// can be trusted, so parse fails closed below.
+				const nonce = extractMarkerNonce(job.prompt ?? "");
+				const output = nonce && meta.stdout ? parseMarkerStreamOutput(meta.stdout, markerEngine, nonce) : null;
+				if (!output) {
+					job.status = "failed";
+					job.error = `${markerEngine.author} review output missing or unparseable (no valid marker JSON).`;
+					return;
+				}
+
+				// Derive the verdict from finding severities (like Claude) rather than
+				// trusting the model's free-form `correctness` string. Marker engines
+				// have no schema flag, so a model value like "not correct" would be
+				// stored verbatim and the detail panel (any string containing "correct"
+				// except "incorrect" → green) would invert the displayed result.
+				const hasImportant = output.findings.some((f) => f.severity === "important");
+				job.summary = {
+					correctness: hasImportant ? "Issues Found" : "Correct",
+					explanation: output.summary.explanation,
+					confidence: output.summary.confidence,
+				};
+
+				// Reuse the shared ingest() decoration; add a fail-closed check on result.
+				const result = ingest(
+					transformMarkerFindings(
+						output.findings,
+						job.source,
+						markerEngine.author,
+						cwd,
+						workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined,
+					),
+					`${markerEngine.id}-review`,
+				);
+				if (result && "error" in result) {
+					job.status = "failed";
+					job.error = `${markerEngine.author} annotation insertion failed: ${result.error}`;
+					return;
+				}
+				return;
+			}
+
 			if (job.provider === "tour") {
 				const { summary } = await tour.onJobComplete({ job, meta });
 				if (summary) {
diff --git a/apps/pi-extension/vendor.sh b/apps/pi-extension/vendor.sh
index c6f71aef2..a78493a03 100755
--- a/apps/pi-extension/vendor.sh
+++ b/apps/pi-extension/vendor.sh
@@ -13,7 +13,7 @@ for f in feedback-templates prompts review-core diff-paths cli-pagination jj-cor
 done
 
 # Vendor review agent modules from packages/server/ — rewrite imports for generated/ layout
-for f in agent-review-message codex-review claude-review path-utils review-skill-loader; do
+for f in agent-review-message codex-review claude-review review-findings marker-review path-utils review-skill-loader; do
   src="../../packages/server/$f.ts"
   printf '// @generated — DO NOT EDIT. Source: packages/server/%s.ts\n' "$f" | cat - "$src" \
     | sed 's|from "./vcs"|from "./review-core.js"|' \
diff --git a/packages/review-editor/dock/panels/ReviewAgentJobDetailPanel.tsx b/packages/review-editor/dock/panels/ReviewAgentJobDetailPanel.tsx
index cafd28d37..a0cdc547e 100644
--- a/packages/review-editor/dock/panels/ReviewAgentJobDetailPanel.tsx
+++ b/packages/review-editor/dock/panels/ReviewAgentJobDetailPanel.tsx
@@ -352,7 +352,7 @@ function ProviderPill({ provider, engine, model }: { provider: string; engine?:
     const engineLabel = engine === 'codex' ? 'Codex' : 'Claude';
     label = model && engine !== 'codex' ? `Tour · ${engineLabel} ${model.charAt(0).toUpperCase() + model.slice(1)}` : `Tour · ${engineLabel}`;
   } else {
-    label = provider === 'claude' ? 'Claude' : provider === 'codex' ? 'Codex' : 'Shell';
+    label = provider === 'claude' ? 'Claude' : provider === 'codex' ? 'Codex' : provider === 'cursor' ? 'Cursor' : provider === 'opencode' ? 'OpenCode' : 'Shell';
   }
   return (
     <span className={`text-[10px] font-semibold uppercase tracking-wider px-1.5 py-0.5 rounded ${
diff --git a/packages/server/agent-jobs.ts b/packages/server/agent-jobs.ts
index 40b5b2693..e735d85c3 100644
--- a/packages/server/agent-jobs.ts
+++ b/packages/server/agent-jobs.ts
@@ -9,6 +9,12 @@
  */
 
 import { formatClaudeLogEvent } from "./claude-review";
+import {
+  MARKER_ENGINES,
+  formatMarkerLogEvent,
+  type MarkerEngine,
+  type MarkerModel,
+} from "./marker-review";
 import {
   type AgentJobInfo,
   type AgentJobEvent,
@@ -46,6 +52,16 @@ const JOBS = `${BASE}/jobs`;
 const JOBS_STREAM = `${JOBS}/stream`;
 const CAPABILITIES = `${BASE}/capabilities`;
 
+// Providers whose command is owned by the server. Client-supplied argv is never
+// spawned for these — buildCommand must produce the command or the launch fails.
+const SERVER_BUILT_PROVIDERS: ReadonlySet<string> = new Set([
+  "claude",
+  "codex",
+  "tour",
+  "cursor",
+  "opencode",
+]);
+
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -99,6 +115,32 @@ export interface AgentJobHandlerOptions {
   onJobComplete?: (job: AgentJobInfo, meta: { outputPath?: string; stdout?: string; cwd?: string }) => void | Promise<void>;
 }
 
+
+/**
+ * Best-effort model catalog for a marker engine, spawned once. The spawn lives
+ * HERE (per-runtime — Bun.spawn) rather than in marker-review.ts, which must stay
+ * Bun-free for the Pi vendor build. ASYNC so it never blocks the event loop on
+ * the /capabilities request path (a slow/hanging CLI would otherwise freeze every
+ * other in-flight request for up to the timeout). Empty when discovery fails or
+ * the CLI is unauthenticated / has no providers configured — the UI falls back to
+ * the engine's default picker. Account/config-specific, so never hardcoded.
+ */
+async function discoverMarkerModels(engine: MarkerEngine): Promise<MarkerModel[]> {
+  try {
+    const proc = Bun.spawn([engine.binary, ...engine.modelsArgv], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: 5000,
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) return [];
+    return engine.parseModels(stdout);
+  } catch {
+    return [];
+  }
+}
+
 export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJobHandler {
   const { mode, getServerUrl, getCwd } = options;
 
@@ -109,17 +151,39 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJob
   const encoder = new TextEncoder();
   let version = 0;
 
-  // --- Capability detection (run once) ---
+  // --- Capability detection: binaries are probed once at construction; marker
+  // model catalogs are discovered LAZILY (see buildCapabilitiesResponse) so a
+  // slow/unauthenticated `<binary> models` spawn never blocks review-server
+  // startup — it runs at most once, on the first /capabilities request. ---
   const capabilities: AgentCapability[] = [
     { id: "claude", name: "Claude Code", available: !!Bun.which("claude") },
     { id: "codex", name: "Codex CLI", available: !!Bun.which("codex") },
     { id: "tour", name: "Code Tour", available: !!Bun.which("claude") || !!Bun.which("codex") },
   ];
-  const capabilitiesResponse: AgentCapabilities = {
-    mode,
-    providers: capabilities,
-    available: capabilities.some((c) => c.available),
-  };
+  // Marker engines (Cursor, OpenCode) — same shape, one loop. Available only in
+  // review mode when the binary is on PATH (NOTE: cursor's binary is `agent`).
+  for (const engine of Object.values(MARKER_ENGINES)) {
+    capabilities.push({
+      id: engine.id,
+      name: engine.name,
+      available: mode === "review" && !!Bun.which(engine.binary),
+    });
+  }
+
+  const markerModelsCache = new Map<string, MarkerModel[]>();
+  async function buildCapabilitiesResponse(): Promise<AgentCapabilities> {
+    const providers = await Promise.all(capabilities.map(async (c) => {
+      const engine = MARKER_ENGINES[c.id as "cursor" | "opencode"];
+      if (!engine || !c.available) return c;
+      let models = markerModelsCache.get(engine.id);
+      if (!models) {
+        models = await discoverMarkerModels(engine);
+        markerModelsCache.set(engine.id, models);
+      }
+      return { ...c, models };
+    }));
+    return { mode, providers, available: providers.some((p) => p.available) };
+  }
 
   // --- SSE broadcasting ---
   function broadcast(event: AgentJobEvent): void {
@@ -241,32 +305,46 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJob
       let stdoutBuf = "";
       const stdoutDone = (captureStdout && proc.stdout && typeof proc.stdout !== "number")
         ? (async () => {
+            // Format one complete JSONL line into a live-log delta (skip result
+            // events — those are handled in onJobComplete).
+            const emitLogLine = (line: string) => {
+              if (!line.trim()) return;
+              // Claude: format JSONL into readable text. Tour jobs with the
+              // Claude engine also stream Claude JSONL, so key off engine too.
+              if (provider === "claude" || spawnOptions?.engine === "claude") {
+                const formatted = formatClaudeLogEvent(line);
+                if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+                return;
+              }
+              // Marker engines (Cursor, OpenCode): map their NDJSON stream events
+              // into readable log deltas via the engine's own formatter (Cursor
+              // applies the partial-output dedup rule; OpenCode reads text parts).
+              const markerEngine = MARKER_ENGINES[provider as "cursor" | "opencode"];
+              if (markerEngine) {
+                const formatted = formatMarkerLogEvent(line, markerEngine);
+                if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+                return;
+              }
+              try {
+                const event = JSON.parse(line);
+                if (event.type === 'result') return;
+              } catch { /* not JSON — forward as raw log */ }
+              broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
+            };
             try {
               const reader = proc!.stdout as unknown as AsyncIterable<Uint8Array>;
+              // stream-json output is NDJSON and chunk boundaries are arbitrary —
+              // carry the trailing partial line until a later chunk completes it,
+              // otherwise records split across chunks are dropped from live logs.
+              let logLineCarry = "";
               for await (const chunk of reader) {
                 const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
                 stdoutBuf += text;
-
-                // Forward JSONL lines as log events (skip result events)
-                const lines = text.split('\n');
-                for (const line of lines) {
-                  if (!line.trim()) continue;
-                  // Claude: format JSONL into readable text. Tour jobs with the
-                  // Claude engine also stream Claude JSONL, so key off engine too.
-                  if (provider === "claude" || spawnOptions?.engine === "claude") {
-                    const formatted = formatClaudeLogEvent(line);
-                    if (formatted !== null) {
-                      broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
-                    }
-                    continue;
-                  }
-                  try {
-                    const event = JSON.parse(line);
-                    if (event.type === 'result') continue; // handled in onJobComplete
-                  } catch { /* not JSON — forward as raw log */ }
-                  broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
-                }
+                const lines = (logLineCarry + text).split('\n');
+                logLineCarry = lines.pop() ?? "";
+                for (const line of lines) emitLogLine(line);
               }
+              if (logLineCarry) emitLogLine(logLineCarry);
             } catch {
               // Stream closed
             }
@@ -299,8 +377,17 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJob
               stdout: captureStdout ? stdoutBuf : undefined,
               cwd: jobCwd,
             });
-          } catch {
-            // Result ingestion failure shouldn't prevent job completion broadcast
+          } catch (err) {
+            // Claude/Codex are fail-open: an ingestion error is logged but does
+            // not change the terminal state. Cursor and OpenCode are fail-closed
+            // — their findings are prompt-enforced, so an unexpected throw here
+            // must surface as a failed job rather than a green one. (Their
+            // handlers normally fail by mutation and never throw; this guards
+            // future refactors.)
+            if (MARKER_ENGINES[provider as "cursor" | "opencode"]) {
+              entry.info.status = "failed";
+              entry.info.error = err instanceof Error ? err.message : `${provider} result ingestion failed`;
+            }
           }
         }
         jobOutputPaths.delete(id);
@@ -370,7 +457,7 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJob
     ): Promise<Response | null> {
       // --- GET /api/agents/capabilities ---
       if (url.pathname === CAPABILITIES && req.method === "GET") {
-        return Response.json(capabilitiesResponse);
+        return Response.json(await buildCapabilitiesResponse());
       }
 
       // --- SSE stream ---
@@ -467,6 +554,22 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions): AgentJob
             );
           }
 
+          // Fail-closed enforcement for server-owned providers: the command MUST
+          // be built server-side. Client-supplied argv is never spawned for these
+          // providers — a null/throwing builder becomes an error, not a fallback.
+          const isServerBuiltProvider = SERVER_BUILT_PROVIDERS.has(provider);
+          if (isServerBuiltProvider) {
+            if (!options.buildCommand) {
+              return Response.json(
+                { error: `Provider ${provider} requires server-built command` },
+                { status: 400 },
+              );
+            }
+            // Discard any client-supplied argv so a null build cleanly hits the
+            // `command.length === 0` guard below instead of falling through.
+            command = [];
+          }
+
           // Try server-side command building for known providers
           let captureStdout = false;
           let stdinPrompt: string | undefined;
diff --git a/packages/server/claude-review.ts b/packages/server/claude-review.ts
index a996e043f..28fe57aef 100644
--- a/packages/server/claude-review.ts
+++ b/packages/server/claude-review.ts
@@ -1,9 +1,13 @@
-import { toRelativePath } from "./path-utils";
 import {
   composeReviewPrompt,
   type ResolvedReviewProfile,
 } from "@plannotator/shared/review-profiles";
-import { classifyFindingPlacement } from "@plannotator/shared/external-annotation";
+import {
+  transformSeverityFindings,
+  type ReviewSeverity,
+  type ReviewFinding,
+  type ReviewAnnotationInput,
+} from "./review-findings";
 
 /**
  * Claude Code Review Agent — prompt, command builder, and JSONL output parser.
@@ -21,16 +25,10 @@ import { classifyFindingPlacement } from "@plannotator/shared/external-annotatio
 // Types
 // ---------------------------------------------------------------------------
 
-export type ClaudeSeverity = "important" | "nit" | "pre_existing";
-
-export interface ClaudeFinding {
-  severity: ClaudeSeverity;
-  file?: string | null;      // null for a general (review-level) comment
-  line?: number | null;      // null for a whole-file or general comment
-  end_line?: number | null;
-  description: string;
-  reasoning: string;
-}
+// Claude findings ARE review findings — reuse the one shared shape from
+// review-findings.ts rather than keeping a byte-identical copy that can drift.
+export type ClaudeSeverity = ReviewSeverity;
+export type ClaudeFinding = ReviewFinding;
 
 export interface ClaudeReviewOutput {
   findings: ClaudeFinding[];
@@ -313,42 +311,10 @@ export function transformClaudeFindings(
   source: string,
   cwd?: string,
   pathTransform?: (path: string) => string,
-): Array<{
-  source: string;
-  filePath: string;
-  lineStart: number;
-  lineEnd: number;
-  type: string;
-  side: string;
-  scope: string;
-  text: string;
-  severity: ClaudeSeverity;
-  reasoning: string;
-  author: string;
-}> {
-  // Route every finding by what it carries — nothing is dropped. A finding
-  // with no usable file becomes a general comment; with a file but no line, a
-  // whole-file comment; otherwise a line comment.
-  return findings.map(f => {
-    const rawFile = typeof f.file === "string" ? f.file : "";
-    const filePath = rawFile
-      ? (pathTransform ? pathTransform(toRelativePath(rawFile, cwd)) : toRelativePath(rawFile, cwd))
-      : "";
-    const placement = classifyFindingPlacement(filePath, f.line, f.end_line);
-    return {
-      source,
-      filePath: placement.filePath,
-      lineStart: placement.lineStart,
-      lineEnd: placement.lineEnd,
-      type: "comment",
-      side: "new",
-      scope: placement.scope,
-      text: `[${f.severity}] ${f.description}`,
-      severity: f.severity,
-      reasoning: f.reasoning,
-      author: "Claude Code",
-    };
-  });
+): ReviewAnnotationInput[] {
+  // Routing (line / whole-file / general) is shared with the marker engines in
+  // review-findings.ts — nothing is dropped; only the author differs.
+  return transformSeverityFindings(findings, source, "Claude Code", cwd, pathTransform);
 }
 
 // ---------------------------------------------------------------------------
diff --git a/packages/server/marker-review.test.ts b/packages/server/marker-review.test.ts
new file mode 100644
index 000000000..f46e120d7
--- /dev/null
+++ b/packages/server/marker-review.test.ts
@@ -0,0 +1,443 @@
+import { describe, expect, test } from "bun:test";
+import {
+  markerOpen,
+  markerClose,
+  makeMarkerNonce,
+  extractMarkerNonce,
+  buildMarkerOutputContract,
+  MARKER_ENGINES,
+  buildMarkerCommand,
+  reduceMarkerStream,
+  parseMarkerStreamOutput,
+  formatMarkerLogEvent,
+  transformMarkerFindings,
+  validateMarkerReviewOutput,
+  composeMarkerReviewPrompt,
+  type MarkerEngine,
+  type MarkerFinding,
+  type MarkerReviewOutput,
+} from "./marker-review";
+import type { ResolvedReviewProfile } from "@plannotator/shared/review-profiles";
+
+const cursor = MARKER_ENGINES.cursor;
+const opencode = MARKER_ENGINES.opencode;
+
+// A fixed, valid nonce (pn + 12 hex) for deterministic tests.
+const NONCE = "pn0123456789ab";
+const OPEN = markerOpen(NONCE);
+const CLOSE = markerClose(NONCE);
+
+// ---------------------------------------------------------------------------
+// NDJSON builders, mirroring each engine's real stream shape.
+// ---------------------------------------------------------------------------
+
+function ndjson(obj: unknown): string {
+  return JSON.stringify(obj) + "\n";
+}
+
+/** Cursor: a real partial-output assistant delta (timestamp_ms, no model_call_id). */
+function cursorDelta(text: string, ts = 1): string {
+  return ndjson({ type: "assistant", timestamp_ms: ts, message: { content: text } });
+}
+/** Cursor: a duplicate flush (model_call_id present) — must be skipped. */
+function cursorDuplicate(text: string, ts = 1): string {
+  return ndjson({ type: "assistant", timestamp_ms: ts, model_call_id: "call_1", message: { content: text } });
+}
+/** OpenCode: a finalized text part (the only events carrying assistant text). */
+function opencodeText(text: string): string {
+  return ndjson({ type: "text", timestamp: 1, sessionID: "s1", part: { type: "text", text, time: { start: 1, end: 2 } } });
+}
+
+function markerBlock(payload: unknown): string {
+  return `${OPEN}\n${JSON.stringify(payload, null, 2)}\n${CLOSE}`;
+}
+
+function chunkify(s: string, parts: number): string[] {
+  const size = Math.ceil(s.length / parts);
+  const out: string[] = [];
+  for (let i = 0; i < s.length; i += size) out.push(s.slice(i, i + size));
+  return out;
+}
+
+const validReview: MarkerReviewOutput = {
+  findings: [
+    {
+      file: "packages/server/review.ts",
+      line: 123,
+      end_line: 130,
+      severity: "important",
+      description: "Null deref on the unhappy path.",
+      reasoning: "The guard above only covers the happy path.",
+    },
+  ],
+  summary: { correctness: "Issues Found", explanation: "One important issue.", confidence: 0.85 },
+};
+
+// ===========================================================================
+// buildArgv — both descriptors
+// ===========================================================================
+
+describe("buildMarkerCommand: cursor", () => {
+  test("uses the `agent` binary, read-only flags, prompt as trailing argv", () => {
+    const { command } = buildMarkerCommand(cursor, "review this", "gpt-5", "/repo");
+    expect(command[0]).toBe("agent");
+    expect(command).toContain("-p");
+    expect(command[command.indexOf("--mode") + 1]).toBe("ask");
+    expect(command[command.indexOf("--sandbox") + 1]).toBe("enabled");
+    expect(command).not.toContain("--force");
+    expect(command).not.toContain("--yolo");
+    expect(command).toContain("--trust");
+    expect(command[command.indexOf("--output-format") + 1]).toBe("stream-json");
+    expect(command).toContain("--stream-partial-output");
+    expect(command[command.indexOf("--workspace") + 1]).toBe("/repo");
+    expect(command[command.indexOf("--model") + 1]).toBe("gpt-5");
+    expect(command[command.length - 1]).toBe("review this");
+  });
+
+  test("omits --model for Auto/empty/undefined; --workspace when no cwd", () => {
+    expect(buildMarkerCommand(cursor, "p", "Auto", "/repo").command).not.toContain("--model");
+    expect(buildMarkerCommand(cursor, "p", "", "/repo").command).not.toContain("--model");
+    expect(buildMarkerCommand(cursor, "p", undefined, "/repo").command).not.toContain("--model");
+    expect(buildMarkerCommand(cursor, "p").command).not.toContain("--workspace");
+  });
+});
+
+describe("buildMarkerCommand: opencode", () => {
+  test("uses `opencode run --format json --agent plan`, prompt trailing", () => {
+    const { command } = buildMarkerCommand(opencode, "review this", "opencode/glm-5.1", "/repo");
+    expect(command[0]).toBe("opencode");
+    expect(command[1]).toBe("run");
+    expect(command[command.indexOf("--format") + 1]).toBe("json");
+    expect(command[command.indexOf("--agent") + 1]).toBe("plan");
+    expect(command[command.indexOf("--dir") + 1]).toBe("/repo");
+    expect(command[command.indexOf("--model") + 1]).toBe("opencode/glm-5.1");
+    expect(command).not.toContain("--dangerously-skip-permissions");
+    expect(command[command.length - 1]).toBe("review this");
+  });
+
+  test("omits --model when empty; --dir when no cwd", () => {
+    expect(buildMarkerCommand(opencode, "p", "", "/repo").command).not.toContain("--model");
+    expect(buildMarkerCommand(opencode, "p").command).not.toContain("--dir");
+  });
+});
+
+// ===========================================================================
+// parseModels — both descriptors
+// ===========================================================================
+
+describe("parseModels: cursor", () => {
+  test("parses `id - Label` lines, skips header/tip, dedupes", () => {
+    const out = [
+      "Available models",
+      "",
+      "auto - Auto",
+      "gpt-5.2 - GPT-5.2",
+      "claude-opus-4-8-thinking-high - Opus 4.8 1M Thinking",
+      "auto - Auto Again",
+      "Tip: use --model <id> to switch.",
+    ].join("\n");
+    expect(cursor.parseModels(out)).toEqual([
+      { id: "auto", label: "Auto" },
+      { id: "gpt-5.2", label: "GPT-5.2" },
+      { id: "claude-opus-4-8-thinking-high", label: "Opus 4.8 1M Thinking" },
+    ]);
+  });
+
+  test("returns [] for unauthenticated / empty output", () => {
+    expect(cursor.parseModels("No models available for this account.")).toEqual([]);
+    expect(cursor.parseModels("")).toEqual([]);
+  });
+});
+
+describe("parseModels: opencode", () => {
+  test("parses provider/model lines (incl. nested slashes), dedupes, skips junk", () => {
+    const out = ["opencode/big-pickle", "openrouter/deepseek/deepseek-chat-v3", "opencode/big-pickle", "", "Some header line"].join("\n");
+    expect(opencode.parseModels(out)).toEqual([
+      { id: "opencode/big-pickle", label: "opencode/big-pickle" },
+      { id: "openrouter/deepseek/deepseek-chat-v3", label: "openrouter/deepseek/deepseek-chat-v3" },
+    ]);
+  });
+
+  test("returns [] for empty / no provider lines", () => {
+    expect(opencode.parseModels("")).toEqual([]);
+    expect(opencode.parseModels("No models configured")).toEqual([]);
+  });
+});
+
+// ===========================================================================
+// reduceMarkerStream / extractText — both descriptors
+// ===========================================================================
+
+describe("reduceMarkerStream: cursor", () => {
+  test("reconstructs canonical text regardless of chunk boundaries", () => {
+    const stdout =
+      ndjson({ type: "system", subtype: "init", model: "Auto" }) +
+      cursorDelta("Looking at ") +
+      cursorDelta("the diff.") +
+      ndjson({ type: "result", result: " Done." });
+
+    expect(reduceMarkerStream(stdout, cursor).canonicalText).toBe("Looking at the diff. Done.");
+    for (const parts of [2, 3, 7, stdout.length]) {
+      const rejoined = chunkify(stdout, parts).join("");
+      expect(reduceMarkerStream(rejoined, cursor).canonicalText).toBe("Looking at the diff. Done.");
+    }
+  });
+
+  test("filters duplicate flushes (model_call_id present), skips malformed", () => {
+    const stdout = cursorDelta("real ") + cursorDuplicate("DUP") + "not json\n" + cursorDelta("text");
+    const { canonicalText, recordCount } = reduceMarkerStream(stdout, cursor);
+    expect(canonicalText).toBe("real text");
+    expect(canonicalText).not.toContain("DUP");
+    expect(recordCount).toBe(3); // malformed line not counted
+  });
+});
+
+describe("reduceMarkerStream: opencode", () => {
+  test("concatenates type:text part.text, ignores tool/step events", () => {
+    const stdout =
+      opencodeText("Looking at ") +
+      ndjson({ type: "tool_use", sessionID: "s1", part: { type: "tool", tool: "read", state: { status: "completed" } } }) +
+      opencodeText("the diff.") +
+      ndjson({ type: "step_finish", sessionID: "s1", part: { type: "step-finish" } });
+    expect(reduceMarkerStream(stdout, opencode).canonicalText).toBe("Looking at the diff.");
+  });
+
+  test("survives chunk-joined buffer and malformed lines", () => {
+    const stdout = opencodeText("a") + "not json\n" + opencodeText("b");
+    expect(reduceMarkerStream(stdout, opencode).canonicalText).toBe("ab");
+  });
+});
+
+// ===========================================================================
+// parseMarkerStreamOutput — NDJSON split, last block wins, failure → null
+// ===========================================================================
+
+describe("parseMarkerStreamOutput: last block wins, chunk-safe", () => {
+  test("cursor: extracts the LAST complete marker block across messages", () => {
+    const stale = { findings: [], summary: { correctness: "Correct", explanation: "draft", confidence: 0.1 } };
+    const stdout =
+      cursorDelta("Draft:\n" + markerBlock(stale) + "\n") +
+      cursorDelta("Final:\n" + markerBlock(validReview));
+    const out = parseMarkerStreamOutput(stdout, cursor, NONCE);
+    expect(out!.summary.correctness).toBe("Issues Found");
+    expect(out!.findings).toHaveLength(1);
+  });
+
+  test("opencode: a single block split across text parts + raw chunks parses", () => {
+    const full = "Commentary first.\n" + markerBlock(validReview);
+    const half = Math.floor(full.length / 2);
+    const stdout = opencodeText(full.slice(0, half)) + opencodeText(full.slice(half));
+    const out = parseMarkerStreamOutput(chunkify(stdout, 9).join(""), opencode, NONCE);
+    expect(out!.findings).toHaveLength(1);
+  });
+});
+
+describe("parseMarkerStreamOutput: failure modes → null", () => {
+  test("cursor: missing / unclosed / malformed-JSON / schema-invalid / empty", () => {
+    expect(parseMarkerStreamOutput(cursorDelta("no marker here"), cursor, NONCE)).toBeNull();
+    expect(parseMarkerStreamOutput(cursorDelta(`${OPEN}\n{"findings":[]`), cursor, NONCE)).toBeNull();
+    expect(parseMarkerStreamOutput(cursorDelta(`${OPEN}\n{ bad json }\n${CLOSE}`), cursor, NONCE)).toBeNull();
+    const badSeverity = { findings: [{ file: "x.ts", line: 1, severity: "blocker", description: "d", reasoning: "" }], summary: { correctness: "x", explanation: "y", confidence: 1 } };
+    expect(parseMarkerStreamOutput(cursorDelta(markerBlock(badSeverity)), cursor, NONCE)).toBeNull();
+    expect(parseMarkerStreamOutput("", cursor, NONCE)).toBeNull();
+    expect(parseMarkerStreamOutput("   \n  ", cursor, NONCE)).toBeNull();
+  });
+
+  test("cursor: a complete block followed by a truncated block fails closed (no stale fallback)", () => {
+    // Model emitted a draft block, then started a replacement that got cut off.
+    // We must NOT silently return the earlier block.
+    const stdout = cursorDelta(
+      "Draft:\n" + markerBlock(validReview) + "\nFinal:\n" + `${OPEN}\n{"findings":[`,
+    );
+    expect(parseMarkerStreamOutput(stdout, cursor, NONCE)).toBeNull();
+  });
+
+  test("cursor: bare static sentinels in prose don't corrupt extraction (real-run regression)", () => {
+    // Reproduces the live failure: reviewing this module, Composer's prose quoted
+    // the bare `<plannotator-review-json>` tag (no nonce) BEFORE its real payload.
+    // The static parser latched onto that mention; the nonce makes it inert.
+    const bareOpen = "<plannotator-review-json>";
+    const bareClose = "</plannotator-review-json>";
+    const stdout = cursorDelta(
+      `Findings are extracted from a ${bareOpen} marker block; see ${bareClose}.\n` +
+        "Here is my review.\n" +
+        markerBlock(validReview) +
+        "\nTo run the full panel, switch to Agent mode.",
+    );
+    const out = parseMarkerStreamOutput(stdout, cursor, NONCE);
+    expect(out!.summary.correctness).toBe("Issues Found");
+    expect(out!.findings).toHaveLength(1);
+  });
+
+  test("nonce: makeMarkerNonce round-trips through a composed prompt; wrong/absent nonce fails closed", () => {
+    const nonce = makeMarkerNonce();
+    expect(nonce).toMatch(/^pn[0-9a-f]{12}$/);
+    const prompt = composeMarkerReviewPrompt(undefined, "review the diff", nonce);
+    expect(extractMarkerNonce(prompt)).toBe(nonce);
+    expect(extractMarkerNonce("no marker here")).toBeNull();
+    // A payload tagged with the real nonce parses only under that nonce.
+    const stdout = cursorDelta(`${markerOpen(nonce)}\n${JSON.stringify(validReview)}\n${markerClose(nonce)}`);
+    expect(parseMarkerStreamOutput(stdout, cursor, nonce)!.findings).toHaveLength(1);
+    expect(parseMarkerStreamOutput(stdout, cursor, "pnffffffffffff")).toBeNull();
+    expect(parseMarkerStreamOutput(stdout, cursor, "")).toBeNull();
+  });
+
+  test("opencode: missing summary field → null; valid empty findings accepted", () => {
+    const missingSummary = { findings: [], summary: { correctness: "x", explanation: "y" } };
+    expect(parseMarkerStreamOutput(opencodeText(markerBlock(missingSummary)), opencode, NONCE)).toBeNull();
+    const clean = { findings: [], summary: { correctness: "Correct", explanation: "ok", confidence: 1 } };
+    const out = parseMarkerStreamOutput(opencodeText(markerBlock(clean)), opencode, NONCE);
+    expect(out!.findings).toEqual([]);
+  });
+});
+
+// ===========================================================================
+// validateMarkerReviewOutput — nullable placement schema (mirrors Claude)
+// ===========================================================================
+
+describe("validateMarkerReviewOutput: nullable file/line/end_line", () => {
+  test("accepts a line finding, a whole-file finding (line null), and a general note (file+line null)", () => {
+    const out = validateMarkerReviewOutput({
+      findings: [
+        { file: "a.ts", line: 5, end_line: 5, severity: "important", description: "line issue", reasoning: "r" },
+        { file: "a.ts", line: null, end_line: null, severity: "nit", description: "whole-file", reasoning: "r" },
+        { file: null, line: null, end_line: null, severity: "nit", description: "general note", reasoning: "r" },
+        // Absent placement fields are equivalent to null.
+        { severity: "nit", description: "general via omission", reasoning: "r" },
+      ],
+      summary: { correctness: "Issues Found", explanation: "e", confidence: 0.5 },
+    });
+    expect(out).not.toBeNull();
+    expect(out!.findings).toHaveLength(4);
+    expect(out!.findings[1].line).toBeNull();
+    expect(out!.findings[2].file).toBeNull();
+    expect(out!.findings[3].file).toBeNull();
+    expect(out!.findings[3].line).toBeNull();
+  });
+
+  test("rejects non-object, missing findings array, bad severity, wrong placement type", () => {
+    expect(validateMarkerReviewOutput(null)).toBeNull();
+    expect(validateMarkerReviewOutput({ summary: { correctness: "c", explanation: "e", confidence: 1 } })).toBeNull();
+    expect(validateMarkerReviewOutput({ findings: [{ severity: "high", description: "d" }], summary: { correctness: "c", explanation: "e", confidence: 1 } })).toBeNull();
+    // line must be number|null — a string is invalid.
+    expect(validateMarkerReviewOutput({ findings: [{ file: "a", line: "x", severity: "important", description: "d" }], summary: { correctness: "c", explanation: "e", confidence: 1 } })).toBeNull();
+  });
+
+  test("defaults reasoning to empty string", () => {
+    const out = validateMarkerReviewOutput({
+      findings: [{ file: "a.ts", line: 5, severity: "nit", description: "d" }],
+      summary: { correctness: "Issues Found", explanation: "e", confidence: 0.5 },
+    });
+    expect(out!.findings[0].reasoning).toBe("");
+  });
+});
+
+// ===========================================================================
+// formatMarkerLogEvent — both descriptors
+// ===========================================================================
+
+describe("formatMarkerLogEvent", () => {
+  test("cursor: init / delta / tool_call / result; skips dup, flush, malformed", () => {
+    expect(formatMarkerLogEvent(ndjson({ type: "system", subtype: "init", model: "Auto", session_id: "s1" }).trim(), cursor)).toContain("model=Auto");
+    expect(formatMarkerLogEvent(cursorDelta("hello").trim(), cursor)).toBe("hello");
+    expect(formatMarkerLogEvent(ndjson({ type: "tool_call", subtype: "completed", name: "read_file" }).trim(), cursor)).toBe("[read_file] completed");
+    expect(formatMarkerLogEvent(ndjson({ type: "result", duration_ms: 42 }).trim(), cursor)).toContain("42ms");
+    expect(formatMarkerLogEvent(cursorDuplicate("dup").trim(), cursor)).toBeNull();
+    expect(formatMarkerLogEvent(ndjson({ type: "assistant", message: { content: "FULL FLUSH" } }).trim(), cursor)).toBeNull();
+    expect(formatMarkerLogEvent("not json", cursor)).toBeNull();
+  });
+
+  test("opencode: text / tool_use / error; skips step, malformed", () => {
+    expect(formatMarkerLogEvent(opencodeText("hello").trim(), opencode)).toBe("hello");
+    expect(formatMarkerLogEvent(ndjson({ type: "tool_use", part: { type: "tool", tool: "read", state: { status: "completed" } } }).trim(), opencode)).toBe("[read] completed");
+    expect(formatMarkerLogEvent(ndjson({ type: "error", error: {} }).trim(), opencode)).toContain("[error]");
+    expect(formatMarkerLogEvent(ndjson({ type: "step_start", part: { type: "step-start" } }).trim(), opencode)).toBeNull();
+    expect(formatMarkerLogEvent("not json", opencode)).toBeNull();
+  });
+});
+
+// ===========================================================================
+// transformMarkerFindings — classifyFindingPlacement; nothing dropped
+// ===========================================================================
+
+describe("transformMarkerFindings: line/file/general, nothing dropped", () => {
+  const findings: MarkerFinding[] = [
+    { file: "/repo/packages/server/review.ts", line: 10, end_line: 12, severity: "important", description: "line bug", reasoning: "r" },
+    { file: "/repo/packages/server/review.ts", line: null, end_line: null, severity: "nit", description: "whole-file note", reasoning: "r" },
+    { file: null, line: null, end_line: null, severity: "nit", description: "general note", reasoning: "r" },
+  ];
+
+  test("cursor: produces line/file/general placements with author Cursor", () => {
+    const out = transformMarkerFindings(findings, "agent-x", cursor.author, "/repo");
+    expect(out).toHaveLength(3); // nothing dropped
+
+    const [line, file, general] = out;
+    expect(line.scope).toBe("line");
+    expect(line.filePath).toBe("packages/server/review.ts");
+    expect(line.lineStart).toBe(10);
+    expect(line.lineEnd).toBe(12);
+    expect(line.author).toBe("Cursor");
+    expect(line.text).toBe("[important] line bug");
+
+    expect(file.scope).toBe("file");
+    expect(file.filePath).toBe("packages/server/review.ts");
+    expect(file.lineStart).toBe(0);
+
+    expect(general.scope).toBe("general");
+    expect(general.filePath).toBe("");
+  });
+
+  test("opencode: same placements with author OpenCode; path transform applied", () => {
+    const out = transformMarkerFindings(findings, "src", opencode.author, "/repo", (p) => p ? `child/${p}` : p);
+    expect(out[0].author).toBe("OpenCode");
+    expect(out[0].filePath).toBe("child/packages/server/review.ts");
+    // general note has no file → transform receives "" and placement stays general
+    expect(out[2].scope).toBe("general");
+  });
+
+  test("defaults lineEnd to lineStart when end_line absent on a line finding", () => {
+    const f: MarkerFinding[] = [{ file: "/repo/a.ts", line: 7, severity: "nit", description: "d", reasoning: "" }];
+    expect(transformMarkerFindings(f, "src", cursor.author, "/repo")[0].lineEnd).toBe(7);
+  });
+});
+
+// ===========================================================================
+// composeMarkerReviewPrompt — contract ALWAYS appended (default AND custom)
+// ===========================================================================
+
+describe("composeMarkerReviewPrompt", () => {
+  const userMessage = "Review the diff for branch X.";
+
+  test("default profile: methodology + contract + user message", () => {
+    const prompt = composeMarkerReviewPrompt(undefined, userMessage, NONCE);
+    expect(prompt).toContain("# Code Review");
+    expect(prompt).toContain(buildMarkerOutputContract(NONCE));
+    expect(prompt).toContain(OPEN);
+    expect(prompt.endsWith(userMessage)).toBe(true);
+  });
+
+  test("builtin:default profile behaves like no profile (contract present)", () => {
+    const builtin: ResolvedReviewProfile = { id: "builtin:default", label: "Default", instructions: "", source: "builtin", default: true };
+    const prompt = composeMarkerReviewPrompt(builtin, userMessage, NONCE);
+    expect(prompt).toContain("# Code Review");
+    expect(prompt).toContain(buildMarkerOutputContract(NONCE));
+  });
+
+  test("custom profile REPLACES methodology but KEEPS the output contract", () => {
+    const custom: ResolvedReviewProfile = {
+      id: "user:security",
+      label: "Security",
+      instructions: "ONLY look for SQL injection and auth bypasses.",
+      source: "user",
+    };
+    const prompt = composeMarkerReviewPrompt(custom, userMessage, NONCE);
+    expect(prompt).toContain("ONLY look for SQL injection and auth bypasses.");
+    // Custom instructions replace the default methodology...
+    expect(prompt).not.toContain("You are a senior engineer reviewing a code change.");
+    // ...but the marker contract is still appended — it's the only thing that
+    // makes marker output parseable.
+    expect(prompt).toContain(buildMarkerOutputContract(NONCE));
+    expect(prompt).toContain(OPEN);
+    expect(prompt.endsWith(userMessage)).toBe(true);
+  });
+});
diff --git a/packages/server/marker-review.ts b/packages/server/marker-review.ts
new file mode 100644
index 000000000..90bb6068f
--- /dev/null
+++ b/packages/server/marker-review.ts
@@ -0,0 +1,823 @@
+import {
+  profileHasCustomSection,
+  type ResolvedReviewProfile,
+} from "@plannotator/shared/review-profiles";
+import {
+  transformSeverityFindings,
+  type ReviewSeverity,
+  type ReviewFinding,
+  type ReviewAnnotationInput,
+} from "./review-findings";
+
+/**
+ * Marker Review Engines — the shared machinery for review CLIs that expose NO
+ * schema-validation flag, so their final review output is prose. Cursor (the
+ * `agent` binary) and OpenCode (`opencode run`) are the two. Because they can't
+ * be told to emit validated structured output, they are instead told to emit a
+ * marker-delimited JSON block, and we extract the LAST complete block from the
+ * reconstructed canonical text.
+ *
+ * Everything else — the finding model (nullable file/line/end_line, classified
+ * into line/whole-file/general by classifyFindingPlacement), custom review
+ * profiles, and the transform into external annotations — is IDENTICAL to
+ * Claude/Codex. The ONLY per-engine differences are captured in the
+ * `MarkerEngine` descriptor: the binary, how to build argv, how to pull text
+ * out of one stream event, how to discover models, and how to format a live log
+ * line. There is exactly ONE copy of every shared piece below.
+ *
+ * PI-SAFETY: This file is vendored into the Pi (Node) build via vendor.sh, so it
+ * MUST contain ZERO Bun.* / Bun-only APIs. The model-discovery SPAWN lives in
+ * each runtime's agent-jobs adapter; this module only provides parseModels +
+ * buildArgv + modelsArgv (pure data/functions).
+ */
+
+// ---------------------------------------------------------------------------
+// Per-job marker — the JSON payload is delimited by tags carrying a random,
+// per-job nonce: <plannotator-review-json:NONCE> … </plannotator-review-json:NONCE>.
+//
+// Why the nonce: in review mode the diff (and the model's own prose) is
+// untrusted text that routinely contains the bare string "plannotator-review-json"
+// — e.g. when reviewing this very module, or when the model echoes the contract
+// example. A static tag let those echoed mentions be mistaken for the real
+// delimiter, so extraction grabbed prose instead of the payload and valid
+// reviews failed. The nonce is generated at prompt-build time, embedded in the
+// output contract the model copies, and recovered from the stored prompt at
+// parse time, so only the model's genuine payload can match.
+// ---------------------------------------------------------------------------
+
+const MARKER_TAG = "plannotator-review-json";
+
+/** Open delimiter for a job's nonce. */
+export function markerOpen(nonce: string): string {
+  return `<${MARKER_TAG}:${nonce}>`;
+}
+/** Close delimiter for a job's nonce. */
+export function markerClose(nonce: string): string {
+  return `</${MARKER_TAG}:${nonce}>`;
+}
+
+/** Generate an unguessable per-job marker nonce (matches html-assets token style). */
+export function makeMarkerNonce(): string {
+  return "pn" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+}
+
+/**
+ * Recover the nonce embedded in a composed prompt's marker contract. Returns
+ * null when absent — the parser then fails closed, since no payload can be
+ * trusted without the expected delimiter.
+ */
+export function extractMarkerNonce(prompt: string): string | null {
+  const m = new RegExp(`<${MARKER_TAG}:(pn[0-9a-f]{12})>`).exec(prompt);
+  return m ? m[1] : null;
+}
+
+// ---------------------------------------------------------------------------
+// Finding model — IDENTICAL to ClaudeFinding: nullable file/line/end_line so a
+// finding can be a line issue (file + line), a whole-file issue (file, line
+// null), or a general review-level note (both null). Nothing is dropped.
+// ---------------------------------------------------------------------------
+
+// Marker findings ARE review findings — reuse the one shared shape from
+// review-findings.ts (this module already imports its transform) rather than
+// keeping a byte-identical copy that could silently diverge.
+export type MarkerSeverity = ReviewSeverity;
+export type MarkerFinding = ReviewFinding;
+
+export interface MarkerReviewSummary {
+  correctness: string;
+  explanation: string;
+  confidence: number;
+}
+
+export interface MarkerReviewOutput {
+  findings: MarkerFinding[];
+  summary: MarkerReviewSummary;
+}
+
+const VALID_SEVERITIES: ReadonlySet<string> = new Set([
+  "important",
+  "nit",
+  "pre_existing",
+]);
+
+// ---------------------------------------------------------------------------
+// Schema validator — hand-rolled (no Ajv): marker output is prompt-enforced, so
+// validation is the floor that turns prose back into a trusted object. Mirrors
+// the claude-review.ts schema, which uses type [string,null] for file/line/
+// end_line: a missing or null placement is VALID (whole-file / general note).
+// Empty findings are valid as long as the JSON is valid and the summary is.
+// ---------------------------------------------------------------------------
+
+/**
+ * Read a line coordinate that may be a finite integer, null, or absent. The
+ * marker block is prompt-enforced, so a fractional/NaN/Infinity line is garbage
+ * we will not trust as an annotation coordinate — it is rejected here.
+ */
+function optionalNullableInteger(value: unknown): { ok: true; value: number | null } | { ok: false } {
+  if (value === undefined || value === null) return { ok: true, value: null };
+  if (typeof value === "number" && Number.isInteger(value)) return { ok: true, value };
+  return { ok: false };
+}
+
+/** Read a value that may be a string, null, or absent — anything else is invalid. */
+function optionalNullableString(value: unknown): { ok: true; value: string | null } | { ok: false } {
+  if (value === undefined || value === null) return { ok: true, value: null };
+  if (typeof value === "string") return { ok: true, value };
+  return { ok: false };
+}
+
+/**
+ * Validate a parsed object against the marker review schema. Returns the typed
+ * output, or null if the shape is invalid. file/line/end_line are nullable —
+ * absent or null is accepted (whole-file or general findings).
+ */
+export function validateMarkerReviewOutput(parsed: unknown): MarkerReviewOutput | null {
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed as Record<string, unknown>;
+
+  if (!Array.isArray(obj.findings)) return null;
+
+  const summary = obj.summary;
+  if (!summary || typeof summary !== "object") return null;
+  const s = summary as Record<string, unknown>;
+  if (typeof s.correctness !== "string") return null;
+  if (typeof s.explanation !== "string") return null;
+  if (typeof s.confidence !== "number" || !Number.isFinite(s.confidence)) return null;
+
+  const findings: MarkerFinding[] = [];
+  for (const raw of obj.findings) {
+    if (!raw || typeof raw !== "object") return null;
+    const f = raw as Record<string, unknown>;
+
+    if (typeof f.severity !== "string" || !VALID_SEVERITIES.has(f.severity)) return null;
+    if (typeof f.description !== "string") return null;
+
+    const file = optionalNullableString(f.file);
+    if (!file.ok) return null;
+    const line = optionalNullableInteger(f.line);
+    if (!line.ok) return null;
+    const endLine = optionalNullableInteger(f.end_line);
+    if (!endLine.ok) return null;
+
+    findings.push({
+      severity: f.severity as MarkerSeverity,
+      file: file.value,
+      line: line.value,
+      end_line: endLine.value,
+      description: f.description,
+      reasoning: typeof f.reasoning === "string" ? f.reasoning : "",
+    });
+  }
+
+  return {
+    findings,
+    summary: {
+      correctness: s.correctness,
+      explanation: s.explanation,
+      // Clamp to [0,1] — the model occasionally reports out-of-range confidence.
+      confidence: Math.max(0, Math.min(1, s.confidence)),
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// MarkerEngine descriptor — the ONLY per-engine surface. Six fields.
+// ---------------------------------------------------------------------------
+
+export interface MarkerModel {
+  id: string;
+  label: string;
+}
+
+/** One parsed stream event, opaque to the shared reducer (each engine reads it). */
+export type MarkerStreamEvent = Record<string, unknown>;
+
+export interface MarkerEngine {
+  /** Stable engine id — also the provider id used by the server. */
+  id: "cursor" | "opencode";
+  /** Display name for the capabilities/provider listing (e.g. "Cursor CLI"). */
+  name: string;
+  /** The CLI binary to spawn (NOTE: cursor's binary is `agent`). */
+  binary: string;
+  /** Author string stamped on every annotation this engine produces. */
+  author: string;
+  /** Build the full argv (binary + flags + trailing prompt) for a review run. */
+  buildArgv: (prompt: string, model?: string, cwd?: string) => string[];
+  /** Pull readable text out of one parsed stream event, or null if none. */
+  extractText: (event: MarkerStreamEvent) => string | null;
+  /** Argv (after the binary) for model discovery, e.g. ["models"]. */
+  modelsArgv: string[];
+  /** Parse the model-discovery stdout into a catalog. */
+  parseModels: (stdout: string) => MarkerModel[];
+  /** Format one stream line for the live log, or null to skip it. */
+  formatLogEvent: (event: MarkerStreamEvent) => string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Cursor engine helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * A Cursor partial-output assistant event is a real new text delta only when
+ * `timestamp_ms` is present AND `model_call_id` is absent. Every other assistant
+ * flush is a duplicate re-emission (pre-tool-call flush or end-of-turn flush).
+ */
+function cursorIsRealAssistantDelta(event: MarkerStreamEvent): boolean {
+  return event.timestamp_ms !== undefined && event.model_call_id === undefined;
+}
+
+/** Pull readable text out of a Cursor assistant event's content (string or parts). */
+function cursorAssistantText(event: MarkerStreamEvent): string {
+  if (typeof event.text === "string") return event.text;
+  const message = event.message as { content?: unknown } | undefined;
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((p): p is { type?: string; text?: string } => !!p && typeof p === "object")
+      .filter((p) => p.type === "text" && typeof p.text === "string")
+      .map((p) => p.text as string)
+      .join("");
+  }
+  return "";
+}
+
+/**
+ * Cursor `extractText` for the canonical-text reducer: append a real new delta
+ * (timestamp_ms present, model_call_id absent). The no-timestamp branch KEEPS
+ * the end-of-turn flush — it covers both partial-streaming-disabled output (the
+ * full message arrives once) and the enabled-mode final flush, and is a
+ * parse-robustness safety net (extractLastMarkerBlock takes the LAST block, so a
+ * duplicate is harmless). result events carry the final text too.
+ *
+ * This is deliberately MORE lenient than cursorFormatLogEvent, which drops the
+ * flush so live logs don't repeat the whole assistant output. Do not unify them.
+ */
+function cursorExtractText(event: MarkerStreamEvent): string | null {
+  if (event.type === "assistant") {
+    if (event.timestamp_ms !== undefined) {
+      if (cursorIsRealAssistantDelta(event)) return cursorAssistantText(event);
+      return null;
+    }
+    if (event.model_call_id === undefined) return cursorAssistantText(event);
+    return null;
+  }
+  if (event.type === "result") {
+    if (typeof event.result === "string") return event.result;
+    if (typeof event.text === "string") return event.text;
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Parse `agent models` / `agent --list-models` output into a model catalog. The
+ * CLI prints one model per line as `<id> - <Label>`, wrapped by an "Available
+ * models" header and a "Tip: ..." footer. Returns [] when no model lines are
+ * present (e.g. unauthenticated: "No models available...").
+ */
+function cursorParseModels(stdout: string): MarkerModel[] {
+  if (!stdout) return [];
+  const models: MarkerModel[] = [];
+  const seen = new Set<string>();
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    // `id - Label` — id is a single whitespace-free token; the separator is
+    // " - " with surrounding spaces (model ids contain hyphens but never " - ").
+    const match = /^(\S+)\s+-\s+(.+)$/.exec(line);
+    if (!match) continue;
+    const id = match[1];
+    const label = match[2].trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    models.push({ id, label });
+  }
+  return models;
+}
+
+/**
+ * Format one Cursor `stream-json` event for the LiveLogViewer. Applies the same
+ * partial-output dedup rule as the reducer: an assistant delta is shown only
+ * when `timestamp_ms` is present and `model_call_id` is absent.
+ */
+function cursorFormatLogEvent(event: MarkerStreamEvent): string | null {
+  switch (event.type) {
+    case "system": {
+      if (event.subtype === "init") {
+        const model = typeof event.model === "string" ? event.model : undefined;
+        const sessionId = typeof event.session_id === "string" ? event.session_id : undefined;
+        const bits = ["[init]"];
+        if (model) bits.push(`model=${model}`);
+        if (sessionId) bits.push(`session=${sessionId}`);
+        return bits.join(" ");
+      }
+      return null;
+    }
+    case "assistant": {
+      if (!cursorIsRealAssistantDelta(event)) return null;
+      const text = cursorAssistantText(event);
+      return text ? text : null;
+    }
+    case "tool_call": {
+      const name = typeof event.name === "string" ? event.name : "tool";
+      if (event.subtype === "completed") {
+        return `[${name}] completed`;
+      }
+      const args =
+        typeof event.args === "string"
+          ? event.args.slice(0, 100)
+          : event.args !== undefined
+            ? JSON.stringify(event.args).slice(0, 100)
+            : "";
+      return `[${name}] ${args}`.trimEnd();
+    }
+    case "result": {
+      const duration =
+        typeof event.duration_ms === "number" ? `${event.duration_ms}ms` : undefined;
+      const requestId = typeof event.request_id === "string" ? event.request_id : undefined;
+      const bits = ["[result]"];
+      if (duration) bits.push(duration);
+      if (requestId) bits.push(`request=${requestId}`);
+      return bits.length > 1 ? bits.join(" ") : null;
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Build the `agent -p` command. NOTE the binary is `agent`, NOT `cursor`.
+ *
+ * Read-only posture comes entirely from `--mode ask` + `--sandbox enabled` and
+ * the absence of `--force`/`--yolo`. `--trust` is required in headless print
+ * mode: without it Cursor stops on an interactive workspace-trust prompt that a
+ * background job can never answer. The prompt is the trailing positional arg —
+ * `agent` reads task text from argv, not stdin. `--model` is omitted when the
+ * model is `Auto`/empty so Cursor uses its default model selection. `--workspace`
+ * is set to the launch cwd when provided.
+ */
+function cursorBuildArgv(prompt: string, model?: string, cwd?: string): string[] {
+  // `auto` is Cursor's default model id — omit --model so the CLI chooses.
+  const useModel = !!model && model.toLowerCase() !== "auto";
+  return [
+    "agent",
+    "-p",
+    "--mode",
+    "ask",
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--trust",
+    ...(cwd ? ["--workspace", cwd] : []),
+    "--sandbox",
+    "enabled",
+    ...(useModel ? ["--model", model] : []),
+    // Prompt is the trailing positional arg — agent reads it from argv, not stdin.
+    prompt,
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// OpenCode engine helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * OpenCode `extractText`: the assistant text arrives in `type: "text"` events
+ * carrying `part.text` (each finalized once). No partial-output dedup is needed —
+ * just return the text part. tool_use / step_start / step_finish / reasoning /
+ * error events carry no review text.
+ */
+function opencodeExtractText(event: MarkerStreamEvent): string | null {
+  if (event.type === "text") {
+    const part = event.part as { text?: unknown } | undefined;
+    if (typeof part?.text === "string") return part.text;
+  }
+  return null;
+}
+
+/**
+ * Parse `opencode models` output into a model catalog. The CLI prints one model
+ * id per line as `provider/model`. Returns [] when there are no model lines
+ * (e.g. unauthenticated / no providers configured).
+ */
+function opencodeParseModels(stdout: string): MarkerModel[] {
+  if (!stdout) return [];
+  const models: MarkerModel[] = [];
+  const seen = new Set<string>();
+  for (const rawLine of stdout.split("\n")) {
+    const id = rawLine.trim();
+    // A model id is `provider/model` and may carry extra `/` segments (e.g.
+    // OpenRouter's `openrouter/deepseek/deepseek-chat-v3`): a leading provider,
+    // a slash, then a non-empty remainder, all whitespace-free.
+    if (!id || /\s/.test(id) || !/^[^/\s]+\/\S+$/.test(id)) continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    models.push({ id, label: id });
+  }
+  return models;
+}
+
+/**
+ * Format one `opencode run --format json` event for the LiveLogViewer. Returns a
+ * human-readable string, or null if the event should be skipped.
+ */
+function opencodeFormatLogEvent(event: MarkerStreamEvent): string | null {
+  const part = event.part as
+    | { text?: unknown; tool?: unknown; state?: { status?: unknown } }
+    | undefined;
+  switch (event.type) {
+    case "text": {
+      const text = typeof part?.text === "string" ? part.text.trim() : "";
+      return text ? text : null;
+    }
+    case "tool_use": {
+      const tool = typeof part?.tool === "string" ? part.tool : "tool";
+      const status = typeof part?.state?.status === "string" ? part.state.status : "";
+      return `[${tool}] ${status}`.trimEnd();
+    }
+    case "error": {
+      return "[error] session error";
+    }
+    default:
+      // step_start / step_finish / reasoning — skipped for live logs.
+      return null;
+  }
+}
+
+/**
+ * Build the `opencode run` command.
+ *
+ * `--format json` emits NDJSON events we capture on stdout. `--agent plan` is
+ * OpenCode's read-oriented agent — a sensible default for review (it does not
+ * edit). `--dir <cwd>` matches the spawn cwd. The message (prompt) is the
+ * trailing positional arg. `--model` is `provider/model` and is omitted when
+ * empty so OpenCode uses the configured default.
+ */
+function opencodeBuildArgv(prompt: string, model?: string, cwd?: string): string[] {
+  const useModel = !!model && model.trim().length > 0;
+  return [
+    "opencode",
+    "run",
+    "--format",
+    "json",
+    "--agent",
+    "plan",
+    ...(useModel ? ["--model", model] : []),
+    ...(cwd ? ["--dir", cwd] : []),
+    // Message (prompt) is the trailing positional arg.
+    prompt,
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// The two descriptors + registry.
+// ---------------------------------------------------------------------------
+
+const CURSOR_ENGINE: MarkerEngine = {
+  id: "cursor",
+  name: "Cursor CLI",
+  binary: "agent",
+  author: "Cursor",
+  buildArgv: cursorBuildArgv,
+  extractText: cursorExtractText,
+  modelsArgv: ["models"],
+  parseModels: cursorParseModels,
+  formatLogEvent: cursorFormatLogEvent,
+};
+
+const OPENCODE_ENGINE: MarkerEngine = {
+  id: "opencode",
+  name: "OpenCode",
+  binary: "opencode",
+  author: "OpenCode",
+  buildArgv: opencodeBuildArgv,
+  extractText: opencodeExtractText,
+  modelsArgv: ["models"],
+  parseModels: opencodeParseModels,
+  formatLogEvent: opencodeFormatLogEvent,
+};
+
+export const MARKER_ENGINES: Record<"cursor" | "opencode", MarkerEngine> = {
+  cursor: CURSOR_ENGINE,
+  opencode: OPENCODE_ENGINE,
+};
+
+// ---------------------------------------------------------------------------
+// Stream reduction — line-buffered NDJSON reducer, shared across engines.
+// ---------------------------------------------------------------------------
+
+export interface MarkerStreamReduction {
+  /** Canonical assistant/result text — the substrate for marker extraction. */
+  canonicalText: string;
+  /** Number of NDJSON records that parsed successfully. */
+  recordCount: number;
+}
+
+/**
+ * Reduce a complete NDJSON stdout buffer into canonical text by calling the
+ * engine's `extractText` on every parsed record.
+ *
+ * Critically line-buffered: only complete lines (terminated by `\n`) are parsed.
+ * A trailing partial line with no newline is treated as complete (the process
+ * has exited by the time this runs on the accumulated buffer), but mid-stream
+ * chunk boundaries never corrupt a record because the whole buffer is joined
+ * before splitting on newlines.
+ */
+export function reduceMarkerStream(stdout: string, engine: MarkerEngine): MarkerStreamReduction {
+  let canonicalText = "";
+  let recordCount = 0;
+
+  if (!stdout) return { canonicalText, recordCount };
+
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    let event: MarkerStreamEvent;
+    try {
+      event = JSON.parse(line) as MarkerStreamEvent;
+    } catch {
+      continue; // not a complete/valid NDJSON record — skip
+    }
+    recordCount++;
+
+    const text = engine.extractText(event);
+    if (text) canonicalText += text;
+  }
+
+  return { canonicalText, recordCount };
+}
+
+// ---------------------------------------------------------------------------
+// Marker-block parsing — reduce → take the LAST complete marker block → parse →
+// schema-validate. Returns null on any failure (caller fails the job).
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the content of the LAST complete marker block from canonical text.
+ * The open/close tags carry the job nonce, so bare `plannotator-review-json`
+ * mentions in the diff or the model's prose (which lack the nonce) are ignored
+ * rather than mistaken for delimiters.
+ */
+export function extractLastMarkerBlock(text: string, openTag: string, closeTag: string): string | null {
+  let result: string | null = null;
+  let searchFrom = 0;
+
+  while (true) {
+    const open = text.indexOf(openTag, searchFrom);
+    if (open === -1) break;
+    const contentStart = open + openTag.length;
+    const close = text.indexOf(closeTag, contentStart);
+    // A dangling opener (no matching close) almost always means the model's
+    // final block was truncated mid-stream. Fail closed — return null — rather
+    // than silently falling back to an earlier (draft, or echoed prompt-example)
+    // block, which would mark a truncated review green with the wrong findings.
+    if (close === -1) return null;
+    result = text.slice(contentStart, close);
+    searchFrom = close + closeTag.length;
+  }
+
+  return result;
+}
+
+/**
+ * Parse a marker engine's NDJSON stdout into a validated review output.
+ *
+ * Pipeline: line-buffered NDJSON reduce → reconstruct canonical text → take the
+ * LAST complete marker block → JSON.parse → schema-validate. Returns null on
+ * ANY failure (missing marker, malformed JSON, schema mismatch) so the caller
+ * can fail the job.
+ */
+export function parseMarkerStreamOutput(stdout: string, engine: MarkerEngine, nonce: string): MarkerReviewOutput | null {
+  if (!stdout || !stdout.trim()) return null;
+  if (!nonce) return null; // no expected nonce → cannot trust any block
+
+  const { canonicalText } = reduceMarkerStream(stdout, engine);
+  if (!canonicalText) return null;
+
+  const block = extractLastMarkerBlock(canonicalText, markerOpen(nonce), markerClose(nonce));
+  if (block === null) return null;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(block.trim());
+  } catch {
+    return null;
+  }
+
+  return validateMarkerReviewOutput(parsed);
+}
+
+// ---------------------------------------------------------------------------
+// Live log formatter — parse one NDJSON line, hand the event to the engine.
+// ---------------------------------------------------------------------------
+
+/**
+ * Format one NDJSON line for the LiveLogViewer using the engine's per-event
+ * formatter. Returns a human-readable string, or null if the line should be
+ * skipped (unparseable or not log-worthy).
+ */
+export function formatMarkerLogEvent(line: string, engine: MarkerEngine): string | null {
+  let event: MarkerStreamEvent;
+  try {
+    event = JSON.parse(line) as MarkerStreamEvent;
+  } catch {
+    return null;
+  }
+  return engine.formatLogEvent(event);
+}
+
+// ---------------------------------------------------------------------------
+// Review prompt — investigation-first methodology (shared with Cursor/OpenCode
+// today, byte-identical) split from the marker-block output contract so a custom
+// review profile can replace the methodology while the contract — the only thing
+// that makes marker output parseable — is ALWAYS appended.
+// ---------------------------------------------------------------------------
+
+export const MARKER_REVIEW_METHODOLOGY = `# Code Review
+
+## Your role
+You are a senior engineer reviewing a code change. Find the bugs a maintainer
+would fix before merging — logic errors, regressions, broken edge cases,
+security holes with a real exploit path, data-loss risks. You are not a linter
+or style checker. Optimize for findings that get resolved, not for volume: a
+few real, well-evidenced bugs beat a long list of nits.
+
+## Method — investigate before you report
+You have tools. Use them. Do not judge the diff in isolation:
+  - Read the full function and module around each change, not just the hunk.
+  - Trace call sites and data flow to see how the changed code is actually used.
+  - Read any repo guidance and honor it if present: AGENTS.md, CLAUDE.md,
+    REVIEW.md, and any rules files at the repo root and in the directories
+    you're reviewing. Treat these as authoritative for this repo and respect any
+    skip/ignore rules they define.
+  - Before reporting, check whether the issue is already handled elsewhere (a
+    guard, try/catch, fallback, type guarantee).
+  - Look at sibling code and tests: is the pattern you're flagging used safely
+    elsewhere? Is the failure path you fear already covered?
+
+## What to look for
+  - Correctness: logic errors, regressions, broken edge cases, off-by-one,
+    wrong results, build/type breakage.
+  - Robustness: unhandled errors on realistic paths, resource/process leaks,
+    races with observable consequences, state left inconsistent on failure.
+  - Security (only when the change introduces it): execution of
+    user/client-controlled input, trusting unvalidated external or model
+    output, weakened trust/read-only guarantees, newly exposed surfaces.
+  - Contracts & attribution: wrong file/line/path mapping, scope confusion, or a
+    change to one side of a contract (types, API shape, parallel
+    implementations) without the matching change on the other side.
+  - Clear, citable violations of the repo guidance files above.
+
+## Validate every finding
+Confirm each candidate is real by tracing the actual code path. If you can't
+show how it triggers, drop it — prefer silence over a false positive. The
+confirmation you write becomes the \`reasoning\` field: what triggers it, what
+breaks, and why it isn't already handled.
+
+## Severity — report what a maintainer would actually fix
+  important — should be fixed before merge: data loss, silent wrong results,
+    security with an exploit path, crashes/leaks, contract drift that breaks a
+    real consumer, fail-open where it must fail-closed.
+
+  nit — minor and non-blocking: a real but low-impact edge case, missing
+    handling on an unlikely path, a robustness gap with an easy workaround.
+
+  pre_existing — a genuine bug in surrounding code NOT introduced by this
+    change. Only flag when it directly affects the changed code path.
+
+## Do NOT report
+  - Formatting, naming, or style preferences (unless a repo guideline requires).
+  - "Consider adding tests" — unless the change adds non-trivial logic with no
+    test coverage at all.
+  - Hypothetical problems needing exotic conditions with no real code path.
+  - Speculative refactors or "this could be cleaner" outside the change's scope.
+
+## Hard constraints
+- This is a read-only review. Do NOT modify files.
+- Do NOT post any comments to GitHub or GitLab. Do NOT use gh pr comment, glab,
+  or any commenting tool.
+- Never approve or block the change. Your only output is findings.`;
+
+export function buildMarkerOutputContract(nonce: string): string {
+  return `## Output contract
+Your only machine-readable output is a single marker-delimited JSON block.
+Any natural-language commentary you write must come BEFORE the final marker
+block. Emit the block exactly once, as the last thing in your response. The
+opening and closing tags carry a session id (after the colon) — reproduce both
+tags EXACTLY as shown, including that id, or your findings will be discarded:
+
+${markerOpen(nonce)}
+{
+  "findings": [
+    {
+      "file": "packages/server/review.ts",
+      "line": 123,
+      "end_line": 123,
+      "severity": "important",
+      "description": "The issue...",
+      "reasoning": "Why this is a real issue..."
+    }
+  ],
+  "summary": {
+    "correctness": "Issues Found",
+    "explanation": "One important issue was found.",
+    "confidence": 0.85
+  }
+}
+${markerClose(nonce)}
+
+Schema:
+- findings: array of objects, each with
+  - file: string or null — path as shown in the diff. Use null for a general,
+    review-level note that isn't about any one file.
+  - line: integer or null — start line, post-change numbering. Give a line for a
+    line-level issue; use null for a whole-file issue or a general note.
+  - end_line: integer or null — end line; equal to line for a single line, null
+    when line is null.
+  - severity: one of "important", "nit", "pre_existing"
+  - description: string (one paragraph) — state the IMPACT (what breaks, for
+    whom) and the TRIGGER (when it happens); suggest a minimal fix if obvious
+  - reasoning: string (how the issue was confirmed)
+- summary: object with
+  - correctness: string ("Correct" or "Issues Found")
+  - explanation: string (one sentence)
+  - confidence: number between 0 and 1
+
+Place each finding by how specific it is: give file AND line for a line-level
+issue; give file with line null for a whole-file issue; set both file and line
+null for a general, review-level note. Never invent a line you are unsure of —
+drop to a file or general placement instead of guessing. Cite file/line from the
+new (post-change) code. One finding per distinct bug — do not stack unrelated
+issues. If no issues are found, return an empty "findings" array with a valid
+summary.`;
+}
+
+/**
+ * Compose a marker engine's review prompt.
+ *
+ * A custom review profile REPLACES the methodology (its own instructions take
+ * over). But unlike Claude/Codex — which use a native schema flag — marker
+ * engines have NO schema flag, so the marker output contract is the ONLY thing
+ * that makes their output parseable. It is therefore ALWAYS appended, even for a
+ * custom profile. (This is why we do NOT call composeReviewPrompt directly: that
+ * helper REPLACES the whole system prompt for custom profiles, which would strip
+ * our contract.)
+ *
+ * The contract embeds `nonce` in its marker tags; the caller must generate it
+ * with makeMarkerNonce() and recover it with extractMarkerNonce() at parse time.
+ *
+ *   <methodology OR custom profile instructions>
+ *   <marker output contract (nonce-tagged)>
+ *   ---
+ *   <user message>
+ */
+export function composeMarkerReviewPrompt(
+  profile: ResolvedReviewProfile | undefined,
+  userMessage: string,
+  nonce: string,
+): string {
+  const head = profileHasCustomSection(profile)
+    ? (profile as ResolvedReviewProfile).instructions.trim()
+    : MARKER_REVIEW_METHODOLOGY;
+  return head + "\n\n" + buildMarkerOutputContract(nonce) + "\n\n---\n\n" + userMessage;
+}
+
+// ---------------------------------------------------------------------------
+// Command builder
+// ---------------------------------------------------------------------------
+
+export interface MarkerCommandResult {
+  command: string[];
+}
+
+/** Build the full argv for a review run with the given engine. */
+export function buildMarkerCommand(
+  engine: MarkerEngine,
+  prompt: string,
+  model?: string,
+  cwd?: string,
+): MarkerCommandResult {
+  return { command: engine.buildArgv(prompt, model, cwd) };
+}
+
+// ---------------------------------------------------------------------------
+// Finding transform — marker findings → external annotations. IDENTICAL logic
+// to transformClaudeFindings (classifyFindingPlacement; nothing dropped); only
+// the author differs, supplied by the engine descriptor.
+// ---------------------------------------------------------------------------
+
+export type MarkerReviewAnnotationInput = ReviewAnnotationInput;
+
+/** Transform marker findings into the external annotation format. */
+export function transformMarkerFindings(
+  findings: MarkerFinding[],
+  source: string,
+  author: string,
+  cwd?: string,
+  pathTransform?: (path: string) => string,
+): MarkerReviewAnnotationInput[] {
+  // Routing (line / whole-file / general) is shared with Claude in
+  // review-findings.ts — nothing is dropped; only the author differs per engine.
+  return transformSeverityFindings(findings, source, author, cwd, pathTransform);
+}
diff --git a/packages/server/review-findings.ts b/packages/server/review-findings.ts
new file mode 100644
index 000000000..7c8e5d7ba
--- /dev/null
+++ b/packages/server/review-findings.ts
@@ -0,0 +1,74 @@
+import { classifyFindingPlacement } from "@plannotator/shared/external-annotation";
+import { toRelativePath } from "./path-utils";
+
+/**
+ * Shared review-finding model + transform.
+ *
+ * Claude and the marker engines (Cursor/OpenCode) all emit findings with the
+ * same shape — `{ severity, file?, line?, end_line?, description, reasoning }`,
+ * nullable file/line — and turn them into annotations the same way (relative
+ * path → classifyFindingPlacement → line/whole-file/general). This is the one
+ * canonical place for that, so a placement/annotation fix lands once.
+ *
+ * (Codex is NOT here: its findings carry a different shape — priority +
+ * code_location — and it maps separately.)
+ */
+
+export type ReviewSeverity = "important" | "nit" | "pre_existing";
+
+export interface ReviewFinding {
+  severity: ReviewSeverity;
+  file?: string | null; // null for a general (review-level) comment
+  line?: number | null; // null for a whole-file or general comment
+  end_line?: number | null;
+  description: string;
+  reasoning: string;
+}
+
+export interface ReviewAnnotationInput {
+  source: string;
+  filePath: string;
+  lineStart: number;
+  lineEnd: number;
+  type: string;
+  side: string;
+  scope: string;
+  text: string;
+  severity: ReviewSeverity;
+  reasoning: string;
+  author: string;
+}
+
+/**
+ * Transform severity-style findings into annotation inputs. Routes each finding
+ * by what it carries — nothing is dropped: file+line → line comment; file only
+ * → whole-file comment; neither → general (review-level) comment.
+ */
+export function transformSeverityFindings(
+  findings: ReviewFinding[],
+  source: string,
+  author: string,
+  cwd?: string,
+  pathTransform?: (path: string) => string,
+): ReviewAnnotationInput[] {
+  return findings.map((f) => {
+    const rawFile = typeof f.file === "string" ? f.file : "";
+    const filePath = rawFile
+      ? (pathTransform ? pathTransform(toRelativePath(rawFile, cwd)) : toRelativePath(rawFile, cwd))
+      : "";
+    const placement = classifyFindingPlacement(filePath, f.line, f.end_line);
+    return {
+      source,
+      filePath: placement.filePath,
+      lineStart: placement.lineStart,
+      lineEnd: placement.lineEnd,
+      type: "comment",
+      side: "new",
+      scope: placement.scope,
+      text: `[${f.severity}] ${f.description}`,
+      severity: f.severity,
+      reasoning: f.reasoning,
+      author,
+    };
+  });
+}
diff --git a/packages/server/review.ts b/packages/server/review.ts
index fe65c9010..9e6309621 100644
--- a/packages/server/review.ts
+++ b/packages/server/review.ts
@@ -58,6 +58,15 @@ import {
   transformClaudeFindings,
 } from "./claude-review";
 import { createTourSession, TOUR_EMPTY_OUTPUT_ERROR } from "./tour/tour-review";
+import {
+  MARKER_ENGINES,
+  composeMarkerReviewPrompt,
+  buildMarkerCommand,
+  parseMarkerStreamOutput,
+  transformMarkerFindings,
+  makeMarkerNonce,
+  extractMarkerNonce,
+} from "./marker-review";
 import { loadConfig, saveConfig, detectGitUser, getServerConfig } from "./config";
 import { type PRMetadata, type PRReviewFileComment, type PRStackTree, type PRListItem, fetchPR, fetchPRFileContent, fetchPRContext, submitPRReview, fetchPRViewedFiles, markPRFilesViewed, fetchPRStack, fetchPRList, getPRUser, parsePRUrl, prRefFromMetadata, isSameProject, getDisplayRepo, getMRLabel, getMRNumberLabel } from "./pr";
 import { AI_QUERY_ENDPOINT, createAIRuntime } from "./ai-runtime";
@@ -558,6 +567,24 @@ export async function startReviewServer(
         return { command, stdinPrompt, prompt, cwd, label: jobLabel, captureStdout: true, model, effort, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
       }
 
+      // Marker engines (Cursor, OpenCode) — one branch, same shape as Claude.
+      // Neither CLI has a schema flag, so composeMarkerReviewPrompt ALWAYS
+      // appends the marker-block output contract (even for a custom profile —
+      // it's the only thing that makes their prose output parseable). The
+      // engine's buildArgv passes the prompt as the trailing positional arg and
+      // threads the spawn cwd (--workspace for Cursor, --dir for OpenCode).
+      // captureStdout is required: the marker block comes back on stdout NDJSON.
+      const markerEngine = MARKER_ENGINES[provider as "cursor" | "opencode"];
+      if (markerEngine) {
+        const model = typeof config?.model === "string" && config.model ? config.model : undefined;
+        // Per-job nonce embedded in the marker contract; recovered from job.prompt
+        // at parse time so echoed/quoted bare tags can't be mistaken for the payload.
+        const nonce = makeMarkerNonce();
+        const prompt = composeMarkerReviewPrompt(reviewProfile, userMessage, nonce);
+        const { command } = buildMarkerCommand(markerEngine, prompt, model, cwd);
+        return { command, prompt, cwd, label: jobLabel, captureStdout: true, model, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
+      }
+
       return null;
     },
 
@@ -582,7 +609,7 @@ export async function startReviewServer(
       // Map findings onto annotations and ingest. Shared by both engine branches;
       // no-ops on an empty set so a clean (zero-finding) review stays "done".
       const ingest = <T extends object>(transformed: readonly T[], logTag: string) => {
-        if (transformed.length === 0) return;
+        if (transformed.length === 0) return undefined;
         const annotations = transformed.map((a) => ({
           ...a,
           ...jobPrContext,
@@ -591,6 +618,7 @@ export async function startReviewServer(
         }));
         const result = externalAnnotations.addAnnotations({ annotations });
         if ("error" in result) console.error(`[${logTag}] addAnnotations error:`, result.error);
+        return result;
       };
 
       // --- Codex path ---
@@ -656,6 +684,57 @@ export async function startReviewServer(
         return;
       }
 
+      // --- Marker path (Cursor, OpenCode) ---
+      // FAIL-CLOSED: marker output is prompt-enforced (no schema flag), so any
+      // missing/malformed/schema/transform/insertion failure must MUTATE the job
+      // to failed — NEVER throw (agent-jobs.ts swallows throws, silently leaving
+      // an exit-0 job marked done). Mirrors the Tour fail-closed pattern below.
+      // Findings carry nullable file/line, classified into line/whole-file/
+      // general by transformMarkerFindings — nothing is dropped (same as Claude).
+      const markerEngine = MARKER_ENGINES[job.provider as "cursor" | "opencode"];
+      if (markerEngine) {
+        // Recover the per-job nonce embedded in the prompt; without it no block
+        // can be trusted, so parse fails closed below.
+        const nonce = extractMarkerNonce(job.prompt ?? "");
+        const output = nonce && meta.stdout ? parseMarkerStreamOutput(meta.stdout, markerEngine, nonce) : null;
+        if (!output) {
+          job.status = "failed";
+          job.error = `${markerEngine.author} review output missing or unparseable (no valid marker JSON).`;
+          return;
+        }
+
+        // Derive the verdict from finding severities (like Claude) rather than
+        // trusting the model's free-form `correctness` string. Marker engines
+        // have no schema flag, so a model value like "not correct" would be
+        // stored verbatim and the detail panel (any string containing "correct"
+        // except "incorrect" → green) would invert the displayed result.
+        const hasImportant = output.findings.some((f) => f.severity === "important");
+        job.summary = {
+          correctness: hasImportant ? "Issues Found" : "Correct",
+          explanation: output.summary.explanation,
+          confidence: output.summary.confidence,
+        };
+
+        // Reuse the shared ingest() decoration (PR context, diff scope, profile
+        // label); marker engines add a fail-closed check on the returned result.
+        const result = ingest(
+          transformMarkerFindings(
+            output.findings,
+            job.source,
+            markerEngine.author,
+            cwd,
+            workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined,
+          ),
+          `${markerEngine.id}-review`,
+        );
+        if (result && "error" in result) {
+          job.status = "failed";
+          job.error = `${markerEngine.author} annotation insertion failed: ${result.error}`;
+          return;
+        }
+        return;
+      }
+
       // --- Tour path ---
       if (job.provider === "tour") {
         const { summary } = await tour.onJobComplete({ job, meta });
diff --git a/packages/shared/agent-jobs.ts b/packages/shared/agent-jobs.ts
index a97e980f9..874cb97a4 100644
--- a/packages/shared/agent-jobs.ts
+++ b/packages/shared/agent-jobs.ts
@@ -85,6 +85,13 @@ export interface AgentCapability {
   id: string;
   name: string;
   available: boolean;
+  /**
+   * Provider-discovered model catalog (currently only Cursor). Best-effort and
+   * account-specific — populated from the provider CLI at capability-detection
+   * time, empty when discovery fails or the CLI is unauthenticated. The UI
+   * drives its model picker from this instead of a hardcoded list.
+   */
+  models?: { id: string; label: string }[];
 }
 
 export interface AgentCapabilities {
diff --git a/packages/shared/review-profiles.ts b/packages/shared/review-profiles.ts
index 4ec6541ef..04cfb005a 100644
--- a/packages/shared/review-profiles.ts
+++ b/packages/shared/review-profiles.ts
@@ -77,7 +77,7 @@ export const BUILTIN_DEFAULT_PROFILE: ResolvedReviewProfile = {
  * isn't the reserved built-in default. The default (or any instruction-less
  * profile) falls back to the provider prompt, keeping it byte-for-byte today's.
  */
-function profileHasCustomSection(profile: ResolvedReviewProfile | undefined): boolean {
+export function profileHasCustomSection(profile: ResolvedReviewProfile | undefined): boolean {
   return (
     !!profile &&
     profile.id !== BUILTIN_DEFAULT_ID &&
diff --git a/packages/ui/components/AgentsTab.tsx b/packages/ui/components/AgentsTab.tsx
index 37d5729bd..c513307d8 100644
--- a/packages/ui/components/AgentsTab.tsx
+++ b/packages/ui/components/AgentsTab.tsx
@@ -18,9 +18,9 @@ import type { AgentJobInfo, AgentCapabilities } from '../types';
 import { isTerminalStatus } from '@plannotator/shared/agent-jobs';
 import { cn } from '../lib/utils';
 import { ReviewAgentsIcon } from './ReviewAgentsIcon';
-import { ClaudeIcon, CodexIcon } from './icons/AgentIcons';
+import { ClaudeIcon, CodexIcon, CursorIcon, OpenCodeIcon } from './icons/AgentIcons';
 import { useAgentSettings } from '../hooks/useAgentSettings';
-import type { AgentEngine, AgentMode } from '../hooks/useAgentSettings';
+import type { AgentEngine, AgentMode, ReviewEngine } from '../hooks/useAgentSettings';
 
 // --- Agent option catalogs (shared across review + tour engine dropdowns) ---
 
@@ -71,6 +71,22 @@ const TOUR_CLAUDE_MODELS: Array<{ value: string; label: string }> = [
   { value: 'opus', label: 'Opus (thorough)' },
 ];
 
+// Fallback Cursor model catalog (just `auto`). The real, account-specific list
+// is discovered server-side via `agent models` and delivered on the cursor
+// capability; the component prefers that and only falls back to this when the
+// server reports no models (e.g. unauthenticated CLI). Used by formatModel for
+// job-card labels where the live list isn't threaded.
+const CURSOR_MODELS: Array<{ value: string; label: string }> = [
+  { value: 'auto', label: 'Auto' },
+];
+
+// Fallback OpenCode model catalog. The real list is discovered server-side via
+// `opencode models` and delivered on the opencode capability; empty value means
+// "use OpenCode's configured default".
+const OPENCODE_MODELS: Array<{ value: string; label: string }> = [
+  { value: '', label: 'Default' },
+];
+
 const MODE_LABEL: Record<AgentMode, string> = {
   review: 'Code Review',
   tour: 'Code Tour',
@@ -86,6 +102,23 @@ const ENGINE_ICON: Record<AgentEngine, React.FC<{ className?: string }>> = {
   codex: CodexIcon,
 };
 
+// Review-only label map. Keeps Tour's narrow AgentEngine maps valid while the
+// review surface offers the wider set (Cursor/OpenCode).
+const REVIEW_ENGINE_LABEL: Record<ReviewEngine, string> = {
+  claude: 'Claude',
+  codex: 'Codex',
+  cursor: 'Cursor',
+  opencode: 'OpenCode',
+};
+
+// Review-only icon map — the wide set. Tour keeps the narrow ENGINE_ICON.
+const REVIEW_ENGINE_ICON: Record<ReviewEngine, React.FC<{ className?: string }>> = {
+  claude: ClaudeIcon,
+  codex: CodexIcon,
+  cursor: CursorIcon,
+  opencode: OpenCodeIcon,
+};
+
 interface AgentsTabProps {
   jobs: AgentJobInfo[];
   capabilities: AgentCapabilities | null;
@@ -154,6 +187,8 @@ function catalogLabel(list: Array<{ value: string; label: string }>, value: stri
 }
 
 function formatModel(provider: string, engine: string | undefined, model: string): string {
+  if (provider === 'cursor') return catalogLabel(CURSOR_MODELS, model);
+  if (provider === 'opencode') return model ? model : 'Default';
   if (provider === 'codex' || engine === 'codex') return catalogLabel(CODEX_MODELS, model);
   if (provider === 'tour' && engine === 'claude') return catalogLabel(TOUR_CLAUDE_MODELS, model);
   return catalogLabel(CLAUDE_MODELS, model);
@@ -520,6 +555,8 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     codexModel,
     codexReasoning,
     codexFast,
+    cursorModel,
+    opencodeModel,
     tourClaudeModel,
     tourClaudeEffort,
     tourCodexModel,
@@ -534,6 +571,8 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     setCodexModel,
     setCodexReasoning,
     setCodexFast,
+    setCursorModel,
+    setOpencodeModel,
     setTourClaudeModel,
     setTourClaudeEffort,
     setTourCodexModel,
@@ -569,7 +608,27 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
   const claudeAvailable = capabilities?.providers.some((p) => p.id === 'claude' && p.available) ?? false;
   const codexAvailable = capabilities?.providers.some((p) => p.id === 'codex' && p.available) ?? false;
   const tourAvailable = capabilities?.providers.some((p) => p.id === 'tour' && p.available) ?? false;
-
+  const cursorAvailable = capabilities?.providers.some((p) => p.id === 'cursor' && p.available) ?? false;
+  const opencodeAvailable = capabilities?.providers.some((p) => p.id === 'opencode' && p.available) ?? false;
+
+  // Cursor's model catalog is account-specific and discovered server-side, so
+  // prefer the live list from the capability; fall back to `auto`-only when the
+  // server reports none (e.g. unauthenticated CLI).
+  const cursorModels = useMemo<Array<{ value: string; label: string }>>(() => {
+    const discovered = capabilities?.providers.find((p) => p.id === 'cursor')?.models ?? [];
+    const opts = discovered.map((m) => ({ value: m.id, label: m.label }));
+    return opts.length > 0 ? opts : CURSOR_MODELS;
+  }, [capabilities]);
+
+  // OpenCode models discovered server-side via `opencode models`; prepend the
+  // "Default" option so the user can leave the model to OpenCode's config.
+  const opencodeModels = useMemo<Array<{ value: string; label: string }>>(() => {
+    const discovered = capabilities?.providers.find((p) => p.id === 'opencode')?.models ?? [];
+    const opts = discovered.map((m) => ({ value: m.id, label: m.label }));
+    return opts.length > 0 ? [...OPENCODE_MODELS, ...opts] : OPENCODE_MODELS;
+  }, [capabilities]);
+
+  // Tour engines (narrow union). Cursor is NOT included here — it is review-only.
   const availableEngines = useMemo<AgentEngine[]>(() => {
     const engines: AgentEngine[] = [];
     if (claudeAvailable) engines.push('claude');
@@ -577,15 +636,28 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     return engines;
   }, [claudeAvailable, codexAvailable]);
 
+  // Review engines (wide union) = tour engines + cursor/opencode when available.
+  const availableReviewEngines = useMemo<ReviewEngine[]>(() => {
+    const engines: ReviewEngine[] = [...availableEngines];
+    if (cursorAvailable) engines.push('cursor');
+    if (opencodeAvailable) engines.push('opencode');
+    return engines;
+  }, [availableEngines, cursorAvailable, opencodeAvailable]);
+
   const availableModes = useMemo<AgentMode[]>(() => {
     const modes: AgentMode[] = [];
-    if (availableEngines.length > 0) modes.push('review');
+    if (availableReviewEngines.length > 0) modes.push('review');
     if (tourAvailable && availableEngines.length > 0) modes.push('tour');
     return modes;
-  }, [availableEngines.length, tourAvailable]);
+  }, [availableReviewEngines.length, availableEngines.length, tourAvailable]);
 
   const firstAvailableEngine = availableEngines[0] ?? null;
+  const firstAvailableReviewEngine = availableReviewEngines[0] ?? null;
   const engineAvailable = (engine: AgentEngine) => engine === 'claude' ? claudeAvailable : codexAvailable;
+  const reviewEngineAvailable = (engine: ReviewEngine) =>
+    engine === 'cursor' ? cursorAvailable
+      : engine === 'opencode' ? opencodeAvailable
+      : engineAvailable(engine);
 
   // Reconcile mode + engine choices against live capabilities. Runs when
   // capabilities change or the stored selection becomes invalid.
@@ -594,13 +666,17 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     if (!selectedMode || !availableModes.includes(selectedMode)) {
       setSelectedMode(availableModes[0]);
     }
-    if (!firstAvailableEngine) return;
-    if (!engineAvailable(reviewEngine)) setReviewEngine(firstAvailableEngine);
-    if (!engineAvailable(tourEngine)) setTourEngine(firstAvailableEngine);
+    if (firstAvailableReviewEngine && !reviewEngineAvailable(reviewEngine)) {
+      setReviewEngine(firstAvailableReviewEngine);
+    }
+    if (firstAvailableEngine && !engineAvailable(tourEngine)) {
+      setTourEngine(firstAvailableEngine);
+    }
   }, [
     capabilities,
     availableModes,
     firstAvailableEngine,
+    firstAvailableReviewEngine,
     selectedMode,
     reviewEngine,
     tourEngine,
@@ -609,6 +685,26 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     setTourEngine,
   ]);
 
+  // Reconcile the saved Cursor/OpenCode model against the live catalog: a
+  // persisted id can go stale after an account switch or discovery loss, and
+  // posting it would fail the launch. Collapse it to the first option (auto/
+  // Default) when it's no longer offered.
+  useEffect(() => {
+    // Only once the engine is actually available — before capabilities load,
+    // cursorModels is just the fallback, and reconciling here would wipe a valid
+    // saved model before the live catalog arrives.
+    if (!cursorAvailable) return;
+    if (!cursorModels.some((m) => m.value === cursorModel)) {
+      setCursorModel(cursorModels[0]?.value ?? 'auto');
+    }
+  }, [cursorAvailable, cursorModels, cursorModel, setCursorModel]);
+  useEffect(() => {
+    if (!opencodeAvailable) return;
+    if (!opencodeModels.some((m) => m.value === opencodeModel)) {
+      setOpencodeModel(opencodeModels[0]?.value ?? '');
+    }
+  }, [opencodeAvailable, opencodeModels, opencodeModel, setOpencodeModel]);
+
   // Annotation counts per job source
   const annotationCounts = useMemo(() => {
     const counts = new Map<string, number>();
@@ -643,13 +739,32 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     : 'builtin:default';
 
   type LaunchParams = Parameters<typeof onLaunch>[0];
-  const buildReviewLaunch = (engine: AgentEngine): LaunchParams => {
+  const buildReviewLaunch = (engine: ReviewEngine): LaunchParams => {
     // Carry the chosen review only when it is a custom one. Absent → the server
     // resolves to the built-in default.
     const review = effectiveReviewProfileId !== 'builtin:default' ? { reviewProfileId: effectiveReviewProfileId } : {};
     if (engine === 'claude') {
       return { provider: 'claude', label: 'Code Review', model: claudeModel, effort: claudeEffort, ...review };
     }
+    if (engine === 'cursor') {
+      // Omission ⇒ auto: drop the model client-side when it's `auto` so the POST
+      // carries no model and the server lets Cursor pick its default.
+      return {
+        provider: 'cursor',
+        label: 'Code Review',
+        ...(cursorModel && cursorModel.toLowerCase() !== 'auto' ? { model: cursorModel } : {}),
+        ...review,
+      };
+    }
+    if (engine === 'opencode') {
+      // Empty model ⇒ OpenCode's configured default; only send a real model id.
+      return {
+        provider: 'opencode',
+        label: 'Code Review',
+        ...(opencodeModel ? { model: opencodeModel } : {}),
+        ...review,
+      };
+    }
     return {
       provider: 'codex',
       label: 'Code Review',
@@ -674,7 +789,7 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
   // Default pick has nothing to resolve, so it never waits.
   const reviewReady = profilesLoaded || reviewProfileId === 'builtin:default';
   const canLaunch = selectedMode === 'review'
-    ? engineAvailable(reviewEngine) && reviewReady
+    ? reviewEngineAvailable(reviewEngine) && reviewReady
     : selectedMode === 'tour'
       ? tourAvailable && engineAvailable(tourEngine)
       : false;
@@ -692,23 +807,34 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
     </div>
   );
 
-  const renderEngineSelect = (value: AgentEngine, onChange: (engine: AgentEngine) => void) => {
-    const StaticIcon = ENGINE_ICON[value];
+  // Icon-button engine row, shared by Tour (narrow claude/codex set) and Review
+  // (wide claude/codex/cursor/opencode set). The caller passes the engine list
+  // plus its icon/label maps so the same control renders four equal options for
+  // Review exactly as it renders two for Tour.
+  function renderEngineSelect<E extends string>(
+    value: E,
+    onChange: (engine: E) => void,
+    engines: E[],
+    iconMap: Record<E, React.FC<{ className?: string }>>,
+    labelMap: Record<E, string>,
+    configLabel: string = 'Engine',
+  ) {
+    const StaticIcon: React.FC<{ className?: string }> = iconMap[value];
     return (
-      <ConfigRow label="Engine" stacked>
-        {availableEngines.length > 1 ? (
+      <ConfigRow label={configLabel} stacked>
+        {engines.length > 1 ? (
           // Tap an agent's mark to pick it — no dropdown.
           <div className="flex items-center gap-1.5">
-            {availableEngines.map((engine) => {
-              const Icon = ENGINE_ICON[engine];
+            {engines.map((engine) => {
+              const Icon: React.FC<{ className?: string }> = iconMap[engine];
               const selected = value === engine;
               return (
                 <button
                   key={engine}
                   type="button"
                   onClick={() => onChange(engine)}
-                  title={ENGINE_LABEL[engine]}
-                  aria-label={ENGINE_LABEL[engine]}
+                  title={labelMap[engine]}
+                  aria-label={labelMap[engine]}
                   aria-pressed={selected}
                   className={cn(
                     'flex h-9 w-9 items-center justify-center rounded-lg border transition-all',
@@ -723,11 +849,33 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
             })}
           </div>
         ) : (
-          renderStaticChoice(ENGINE_LABEL[value], <StaticIcon className="h-4 w-4" />)
+          renderStaticChoice(labelMap[value], <StaticIcon className="h-4 w-4" />)
         )}
       </ConfigRow>
     );
-  };
+  }
+
+  // Cursor and OpenCode share the same review config: an "experimental" note and
+  // a single model picker driven by their live (or fallback) catalog.
+  const renderMarkerEngineConfig = (
+    model: string,
+    models: Array<{ value: string; label: string }>,
+    setModel: (value: string) => void,
+  ) => (
+    <>
+      <div className="flex items-center gap-1.5 text-[10px] text-amber-600 dark:text-amber-400">
+        <span className="rounded bg-amber-500/10 px-1 py-px font-medium">experimental</span>
+        <span className="text-muted-foreground/50">Findings are prompt-enforced</span>
+      </div>
+      <ConfigRow label="Model" stacked>
+        {models.length > 1 ? (
+          <SelectMenu value={model} options={models} onChange={setModel} />
+        ) : (
+          renderStaticChoice(catalogLabel(models, model))
+        )}
+      </ConfigRow>
+    </>
+  );
 
   return (
     <div className="flex flex-col h-full">
@@ -756,6 +904,16 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
 
             {selectedMode === 'review' && (
               <>
+                {/* Provider (engine) picker — icon-button row over the wide set
+                    (claude/codex/cursor/opencode), above the review selector. */}
+                {renderEngineSelect(
+                  reviewEngine,
+                  setReviewEngine,
+                  availableReviewEngines,
+                  REVIEW_ENGINE_ICON,
+                  REVIEW_ENGINE_LABEL,
+                  'Provider',
+                )}
                 <ConfigRow label="Review" stacked>
                   <SelectMenu
                     value={effectiveReviewProfileId}
@@ -764,7 +922,6 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
                     footerAction={{ label: 'Add new review', onClick: () => setAddReviewOpen(true) }}
                   />
                 </ConfigRow>
-                {renderEngineSelect(reviewEngine, setReviewEngine)}
                 {reviewEngine === 'claude' && (
                   <>
                     <ConfigRow label="Model" stacked>
@@ -788,12 +945,14 @@ export const AgentsTab: React.FC<AgentsTabProps> = ({
                     </ConfigRow>
                   </>
                 )}
+                {reviewEngine === 'cursor' && renderMarkerEngineConfig(cursorModel, cursorModels, setCursorModel)}
+                {reviewEngine === 'opencode' && renderMarkerEngineConfig(opencodeModel, opencodeModels, setOpencodeModel)}
               </>
             )}
 
             {selectedMode === 'tour' && (
               <>
-                {renderEngineSelect(tourEngine, setTourEngine)}
+                {renderEngineSelect(tourEngine, setTourEngine, availableEngines, ENGINE_ICON, ENGINE_LABEL)}
                 <ConfigRow label="Model" stacked>
                   <SelectMenu
                     value={tourEngine === 'claude' ? tourClaudeModel : tourCodexModel}
diff --git a/packages/ui/components/icons/AgentIcons.tsx b/packages/ui/components/icons/AgentIcons.tsx
index 4c55ef2b4..b34d16bc8 100644
--- a/packages/ui/components/icons/AgentIcons.tsx
+++ b/packages/ui/components/icons/AgentIcons.tsx
@@ -18,3 +18,25 @@ const CODEX_DATA_URI =
 export function CodexIcon({ className }: { className?: string }) {
   return <img src={CODEX_DATA_URI} className={className} alt="" aria-hidden="true" draggable={false} />;
 }
+
+// Cursor brand mark — from packages/ui/components/icons/app/cursor.svg
+// (black rounded square + white cursor facet).
+export function CursorIcon({ className }: { className?: string }) {
+  return (
+    <svg viewBox="0 0 40 40" className={className} xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
+      <path d="M28.375 4H11.625C7.41383 4 4 7.41383 4 11.625V28.375C4 32.5862 7.41383 36 11.625 36H28.375C32.5862 36 36 32.5862 36 28.375V11.625C36 7.41383 32.5862 4 28.375 4Z" fill="#000" />
+      <path d="M29.6214 14.2072L20.9502 9.12249C20.6718 8.95917 20.3282 8.95917 20.0498 9.12249L11.3786 14.2072C11.1445 14.3445 11 14.5984 11 14.8733V25.1267C11 25.4012 11.1445 25.6555 11.3786 25.7928L20.0498 30.8775C20.3282 31.0408 20.6718 31.0408 20.9502 30.8775L29.6214 25.7928C29.8555 25.6555 30 25.4016 30 25.1267V14.8733C30 14.5988 29.8555 14.3445 29.6214 14.2072ZM29.0767 15.2843L20.706 30.0101C20.6494 30.1093 20.5 30.0688 20.5 29.9538V20.3115C20.5 20.1189 20.3986 19.9407 20.2342 19.8439L12.0124 15.0226C11.9147 14.9651 11.9546 14.8134 12.0678 14.8134H28.8093C29.047 14.8134 29.1956 15.0751 29.0767 15.2843Z" fill="#fff" />
+    </svg>
+  );
+}
+
+// OpenCode brand mark — extracted from apps/marketing/public/assets/icon-opencode-dark.svg
+// (same vector ProviderIcons.tsx uses; currentColor so it adapts to theme).
+export function OpenCodeIcon({ className }: { className?: string }) {
+  return (
+    <svg viewBox="0 0 32 32" className={className} xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
+      <path d="M3 32V0h26v32zM22 7H10v18h12z" fill="currentColor" />
+      <path d="M10 13h12v12H10z" fill="currentColor" opacity={0.4} />
+    </svg>
+  );
+}
diff --git a/packages/ui/hooks/useAgentSettings.ts b/packages/ui/hooks/useAgentSettings.ts
index 67ed839ea..f362e0138 100644
--- a/packages/ui/hooks/useAgentSettings.ts
+++ b/packages/ui/hooks/useAgentSettings.ts
@@ -13,6 +13,13 @@ export const DEFAULT_TOUR_CLAUDE_EFFORT = 'medium';
 export const DEFAULT_TOUR_CODEX_MODEL = 'gpt-5.3-codex';
 export const DEFAULT_TOUR_CODEX_REASONING = 'medium';
 export const DEFAULT_TOUR_CODEX_FAST = false;
+// `auto` is Cursor's own default model id (from `agent models`); lowercase so it
+// matches the discovered catalog and the buildCursorCommand omit-`--model` check.
+export const DEFAULT_CURSOR_MODEL = 'auto';
+
+// OpenCode has no `auto` pseudo-model; empty string means "use OpenCode's
+// configured default" and buildOpencodeCommand omits `--model` for it.
+export const DEFAULT_OPENCODE_MODEL = '';
 
 interface ClaudeSection {
   model: string;
@@ -24,16 +31,31 @@ interface CodexSection {
   perModel: Record<string, { reasoning: string; fast: boolean }>;
 }
 
+// Cursor/OpenCode have no per-model sub-settings (no effort/reasoning), so a
+// flat { model } section is enough — deliberately simpler than Claude/Codex.
+interface CursorSection {
+  model: string; // 'auto' or a discovered model id
+}
+
+interface OpencodeSection {
+  model: string; // '' (default) or a discovered provider/model id
+}
+
 export type AgentMode = 'review' | 'tour';
 export type AgentEngine = 'claude' | 'codex';
+// Review-only engine union. Tour stays on the narrow AgentEngine so its
+// exhaustive Record<AgentEngine, ...> maps remain valid without change.
+export type ReviewEngine = AgentEngine | 'cursor' | 'opencode';
 
 interface AgentSettingsState {
   selectedMode?: AgentMode;
-  reviewEngine: AgentEngine;
+  reviewEngine: ReviewEngine;
   reviewProfileId: string;
   tourEngine: AgentEngine;
   claude: ClaudeSection;
   codex: CodexSection;
+  cursor: CursorSection;
+  opencode: OpencodeSection;
   tourClaude: ClaudeSection;
   tourCodex: CodexSection;
 }
@@ -45,6 +67,8 @@ const initialState: AgentSettingsState = {
   tourEngine: 'claude',
   claude: { model: DEFAULT_CLAUDE_MODEL, perModel: {} },
   codex: { model: DEFAULT_CODEX_MODEL, perModel: {} },
+  cursor: { model: DEFAULT_CURSOR_MODEL },
+  opencode: { model: DEFAULT_OPENCODE_MODEL },
   tourClaude: { model: DEFAULT_TOUR_CLAUDE_MODEL, perModel: {} },
   tourCodex: { model: DEFAULT_TOUR_CODEX_MODEL, perModel: {} },
 };
@@ -72,6 +96,12 @@ function parseEngine(value: unknown): AgentEngine {
   return value === 'codex' ? 'codex' : 'claude';
 }
 
+function parseReviewEngine(value: unknown): ReviewEngine {
+  if (value === 'cursor') return 'cursor';
+  if (value === 'opencode') return 'opencode';
+  return parseEngine(value);
+}
+
 function parseMode(value: unknown): AgentMode | undefined {
   if (value === 'review' || value === 'tour') return value;
   return undefined;
@@ -84,7 +114,7 @@ function readCookie(): AgentSettingsState {
     const parsed = JSON.parse(raw);
     return {
       selectedMode: parseMode(parsed.selectedMode) ?? initialState.selectedMode,
-      reviewEngine: parseEngine(parsed.reviewEngine),
+      reviewEngine: parseReviewEngine(parsed.reviewEngine),
       reviewProfileId: typeof parsed.reviewProfileId === 'string' ? parsed.reviewProfileId : 'builtin:default',
       tourEngine: parseEngine(parsed.tourEngine),
       claude: {
@@ -95,6 +125,12 @@ function readCookie(): AgentSettingsState {
         model: typeof parsed.codex?.model === 'string' ? parsed.codex.model : DEFAULT_CODEX_MODEL,
         perModel: sanitizeCodexPerModel(parsed.codex?.perModel),
       },
+      cursor: {
+        model: typeof parsed.cursor?.model === 'string' ? parsed.cursor.model : DEFAULT_CURSOR_MODEL,
+      },
+      opencode: {
+        model: typeof parsed.opencode?.model === 'string' ? parsed.opencode.model : DEFAULT_OPENCODE_MODEL,
+      },
       tourClaude: {
         model: typeof parsed.tourClaude?.model === 'string' ? parsed.tourClaude.model : DEFAULT_TOUR_CLAUDE_MODEL,
         perModel: parsed.tourClaude?.perModel ?? {},
@@ -120,7 +156,7 @@ export function useAgentSettings() {
     setState((s) => ({ ...s, selectedMode: mode }));
   }, []);
 
-  const setReviewEngine = useCallback((engine: AgentEngine) => {
+  const setReviewEngine = useCallback((engine: ReviewEngine) => {
     setState((s) => ({ ...s, reviewEngine: engine }));
   }, []);
 
@@ -162,6 +198,14 @@ export function useAgentSettings() {
     setState((s) => ({ ...s, codex: { ...s.codex, model } }));
   }, []);
 
+  const setCursorModel = useCallback((model: string) => {
+    setState((s) => ({ ...s, cursor: { ...s.cursor, model } }));
+  }, []);
+
+  const setOpencodeModel = useCallback((model: string) => {
+    setState((s) => ({ ...s, opencode: { ...s.opencode, model } }));
+  }, []);
+
   const patchCodex = useCallback(
     (
       section: 'codex' | 'tourCodex',
@@ -231,6 +275,8 @@ export function useAgentSettings() {
     codexModel: state.codex.model,
     codexReasoning,
     codexFast,
+    cursorModel: state.cursor.model,
+    opencodeModel: state.opencode.model,
     tourClaudeModel: state.tourClaude.model,
     tourClaudeEffort,
     tourCodexModel: state.tourCodex.model,
@@ -245,6 +291,8 @@ export function useAgentSettings() {
     setCodexModel,
     setCodexReasoning,
     setCodexFast,
+    setCursorModel,
+    setOpencodeModel,
     setTourClaudeModel,
     setTourClaudeEffort,
     setTourCodexModel,