@plannotator/opencode 0.21.1 → 0.21.2

package/dist/embedded.js

@@ -1787,6 +1787,9 @@ function writeServerReadyMetadata(readyFile, metadata) {
   appendFileSync(readyFile, `${JSON.stringify(metadata)}
 `, "utf8");
 }
+function isCodexDesktopHost(env = process.env) {
+  return env.__CFBundleIdentifier === "com.openai.codex";
+}
 async function handleServerReady(url, isRemote, port, options = {}) {
   const readyFile = options.readyFile ?? process.env.PLANNOTATOR_READY_FILE;
   if (readyFile) {
@@ -1802,6 +1805,12 @@ async function handleServerReady(url, isRemote, port, options = {}) {
   Plannotator session ready \u2014 open on your local machine (forward port ${port} if needed):
   ${url}
 
+`);
+  } else if (isCodexDesktopHost()) {
+    process.stderr.write(`
+  Plannotator session ready:
+  ${url}
+
 `);
   }
   const skipBrowserOpen = options.skipBrowserOpen ?? process.env.PLANNOTATOR_SKIP_BROWSER_OPEN === "1";
@@ -40677,6 +40686,22 @@ function transformPlanInput(body3) {
   }
   return { annotations };
 }
+function classifyFindingPlacement(filePath, lineStart, lineEnd) {
+  const hasFile = filePath.length > 0;
+  const hasLine = typeof lineStart === "number";
+  if (hasFile && hasLine) {
+    return {
+      scope: "line",
+      filePath,
+      lineStart,
+      lineEnd: typeof lineEnd === "number" ? lineEnd : lineStart
+    };
+  }
+  if (hasFile) {
+    return { scope: "file", filePath, lineStart: 0, lineEnd: 0 };
+  }
+  return { scope: "general", filePath: "", lineStart: 0, lineEnd: 0 };
+}
 function transformReviewInput(body3) {
   const items = unwrapBody(body3);
   if ("error" in items)
@@ -40687,14 +40712,33 @@ function transformReviewInput(body3) {
     const source = requireString(obj, "source", i3);
     if (typeof source !== "string")
       return source;
-    const filePath = requireString(obj, "filePath", i3);
-    if (typeof filePath !== "string")
-      return filePath;
-    if (typeof obj.lineStart !== "number") {
-      return { error: `annotations[${i3}] missing required "lineStart" field` };
+    const scope = typeof obj.scope === "string" ? obj.scope : "line";
+    if (!VALID_SCOPES.includes(scope)) {
+      return {
+        error: `annotations[${i3}] invalid scope "${scope}". Must be one of: ${VALID_SCOPES.join(", ")}`
+      };
     }
-    if (typeof obj.lineEnd !== "number") {
-      return { error: `annotations[${i3}] missing required "lineEnd" field` };
+    let filePath = "";
+    let lineStart = 0;
+    let lineEnd = 0;
+    if (scope !== "general") {
+      const fp = requireString(obj, "filePath", i3);
+      if (typeof fp !== "string")
+        return fp;
+      filePath = fp;
+      if (scope === "line") {
+        if (typeof obj.lineStart !== "number") {
+          return { error: `annotations[${i3}] missing required "lineStart" field` };
+        }
+        if (typeof obj.lineEnd !== "number") {
+          return { error: `annotations[${i3}] missing required "lineEnd" field` };
+        }
+        lineStart = obj.lineStart;
+        lineEnd = obj.lineEnd;
+      } else {
+        lineStart = typeof obj.lineStart === "number" ? obj.lineStart : 0;
+        lineEnd = typeof obj.lineEnd === "number" ? obj.lineEnd : 0;
+      }
     }
     const side = typeof obj.side === "string" ? obj.side : "new";
     if (!VALID_SIDES.includes(side)) {
@@ -40708,12 +40752,6 @@ function transformReviewInput(body3) {
         error: `annotations[${i3}] invalid type "${type}". Must be one of: ${VALID_REVIEW_TYPES.join(", ")}`
       };
     }
-    const scope = typeof obj.scope === "string" ? obj.scope : "line";
-    if (!VALID_SCOPES.includes(scope)) {
-      return {
-        error: `annotations[${i3}] invalid scope "${scope}". Must be one of: ${VALID_SCOPES.join(", ")}`
-      };
-    }
     if (typeof obj.text !== "string" && typeof obj.suggestedCode !== "string") {
       return {
         error: `annotations[${i3}] must have at least one of: text, suggestedCode`
@@ -40724,8 +40762,8 @@ function transformReviewInput(body3) {
       type,
       scope,
       filePath,
-      lineStart: obj.lineStart,
-      lineEnd: obj.lineEnd,
+      lineStart,
+      lineEnd,
       side,
       text: typeof obj.text === "string" ? obj.text : undefined,
       suggestedCode: typeof obj.suggestedCode === "string" ? obj.suggestedCode : undefined,
@@ -40734,7 +40772,8 @@ function transformReviewInput(body3) {
       author: typeof obj.author === "string" ? obj.author : undefined,
       source,
       ...typeof obj.severity === "string" && { severity: obj.severity },
-      ...typeof obj.reasoning === "string" && { reasoning: obj.reasoning }
+      ...typeof obj.reasoning === "string" && { reasoning: obj.reasoning },
+      ...typeof obj.reviewProfileLabel === "string" && { reviewProfileLabel: obj.reviewProfileLabel }
     });
   }
   return { annotations };
@@ -40824,7 +40863,7 @@ var init_external_annotation = __esm(() => {
   VALID_PLAN_TYPES = ["DELETION", "COMMENT", "GLOBAL_COMMENT"];
   VALID_REVIEW_TYPES = ["comment", "suggestion", "concern"];
   VALID_SIDES = ["old", "new"];
-  VALID_SCOPES = ["line", "file"];
+  VALID_SCOPES = ["line", "file", "general"];
 });
 
 // ../../packages/server/external-annotations.ts
@@ -69503,10 +69542,21 @@ var init_dist8 = __esm(() => {
 // ../../packages/ai/providers/codex-sdk.ts
 var exports_codex_sdk = {};
 __export(exports_codex_sdk, {
+  shouldSkipGitRepoCheck: () => shouldSkipGitRepoCheck,
   mapCodexItem: () => mapCodexItem,
   mapCodexEvent: () => mapCodexEvent,
   CodexSDKProvider: () => CodexSDKProvider
 });
+import { execFile } from "child_process";
+import { promisify } from "util";
+async function shouldSkipGitRepoCheck(cwd, probe = execFileAsync) {
+  try {
+    const result = probe("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], { encoding: "utf8" });
+    return String((await result).stdout ?? "").trim() !== "true";
+  } catch {
+    return true;
+  }
+}
 
 class CodexSDKProvider {
   name = PROVIDER_NAME2;
@@ -69530,10 +69580,13 @@ class CodexSDKProvider {
     this.config = config;
   }
   async createSession(options) {
+    const cwd = options.cwd ?? this.config.cwd ?? process.cwd();
+    const skipGitRepoCheck = await shouldSkipGitRepoCheck(cwd);
     return new CodexSDKSession({
       ...this.baseConfig(options),
       systemPrompt: buildSystemPrompt(options.context),
-      cwd: options.cwd ?? this.config.cwd ?? process.cwd(),
+      cwd,
+      skipGitRepoCheck,
       parentSessionId: null
     });
   }
@@ -69541,10 +69594,13 @@ class CodexSDKProvider {
     throw new Error("Codex does not support session forking. " + "The endpoint layer should fall back to createSession().");
   }
   async resumeSession(sessionId) {
+    const cwd = this.config.cwd ?? process.cwd();
+    const skipGitRepoCheck = await shouldSkipGitRepoCheck(cwd);
     return new CodexSDKSession({
       ...this.baseConfig(),
       systemPrompt: null,
-      cwd: this.config.cwd ?? process.cwd(),
+      cwd,
+      skipGitRepoCheck,
       parentSessionId: null,
       resumeThreadId: sessionId
     });
@@ -69701,10 +69757,11 @@ function mapCodexItem(event, itemTextOffsets) {
       return [{ type: "unknown", raw: { eventType, item } }];
   }
 }
-var PROVIDER_NAME2 = "codex-sdk", DEFAULT_MODEL2 = "gpt-5.4", CodexClass = null, CodexSDKSession;
+var PROVIDER_NAME2 = "codex-sdk", DEFAULT_MODEL2 = "gpt-5.4", execFileAsync, CodexClass = null, CodexSDKSession;
 var init_codex_sdk = __esm(() => {
   init_base_session();
   init_provider();
+  execFileAsync = promisify(execFile);
   CodexSDKSession = class CodexSDKSession extends BaseSession {
     config;
     _codexInstance = null;
@@ -69740,6 +69797,7 @@ var init_codex_sdk = __esm(() => {
             this._thread = this._codexInstance.resumeThread(this.config.resumeThreadId, {
               model: this.config.model,
               workingDirectory: this.config.cwd,
+              skipGitRepoCheck: this.config.skipGitRepoCheck,
               sandboxMode: this.config.sandboxMode,
               ...this.config.reasoningEffort && { modelReasoningEffort: this.config.reasoningEffort }
             });
@@ -69747,6 +69805,7 @@ var init_codex_sdk = __esm(() => {
             this._thread = this._codexInstance.startThread({
               model: this.config.model,
               workingDirectory: this.config.cwd,
+              skipGitRepoCheck: this.config.skipGitRepoCheck,
               sandboxMode: this.config.sandboxMode,
               ...this.config.reasoningEffort && { modelReasoningEffort: this.config.reasoningEffort }
             });
@@ -75390,6 +75449,69 @@ var init_pr_stack = __esm(() => {
   FULL_SHA_RE = /^[0-9a-f]{40,64}$/i;
 });
 
+// ../../packages/shared/agent-jobs.ts
+function serializeAgentSSEEvent(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function isTerminalStatus(status) {
+  return status === "done" || status === "failed" || status === "killed";
+}
+function jobSource(id) {
+  return "agent-" + id.slice(0, 8);
+}
+function markJobReviewFailed(job, error) {
+  job.status = "failed";
+  job.error = error;
+}
+var AGENT_HEARTBEAT_COMMENT = `:
+
+`, AGENT_HEARTBEAT_INTERVAL_MS = 30000, REVIEW_OUTPUT_FAILED = "Review finished but produced no usable findings.";
+
+// ../../packages/shared/review-profiles.ts
+function profileHasCustomSection(profile) {
+  return !!profile && profile.id !== BUILTIN_DEFAULT_ID && profile.instructions.trim().length > 0;
+}
+function composeReviewPrompt(systemPrompt, profile, userMessage) {
+  if (profileHasCustomSection(profile)) {
+    return profile.instructions.trim() + `
+
+` + REPORTING_INSTRUCTIONS + `
+
+---
+
+` + userMessage;
+  }
+  return systemPrompt + `
+
+---
+
+` + userMessage;
+}
+var BUILTIN_DEFAULT_ID = "builtin:default", BUILTIN_DEFAULT_PROFILE, REPORTING_INSTRUCTIONS = `## Returning your findings
+
+Hand back what you found as separate findings, not as one combined report.
+
+- One finding per issue. Don't merge unrelated points into a single entry.
+- Anchor each finding where it belongs:
+  - About specific code? Give the file and the line(s), so it attaches to that spot in the diff.
+  - About a whole file? Give the file and leave the line out.
+  - A review-wide point? Leave out both the file and the line.
+- Always produce the code-specific findings first.
+- If your instructions also ask for a final verdict, summary, or overall judgment, add it as its own review-wide finding with no file and no line. The verdict is in addition to the specific findings, never a replacement for them.
+
+If the instructions above told you to produce a particular report layout or document, that was for your own reasoning. For the final result, return findings in the structure described here: the specific code findings, plus any verdict as a separate review-wide finding.`;
+var init_review_profiles = __esm(() => {
+  BUILTIN_DEFAULT_PROFILE = {
+    id: BUILTIN_DEFAULT_ID,
+    label: "Default",
+    instructions: "",
+    source: "builtin",
+    default: true
+  };
+});
+
 // ../../packages/server/path-utils.ts
 import { relative as relative7 } from "path";
 function toRelativePath2(absolutePath, cwd) {
@@ -75402,7 +75524,36 @@ function toRelativePath2(absolutePath, cwd) {
 }
 var init_path_utils = () => {};
 
+// ../../packages/server/review-findings.ts
+function transformSeverityFindings(findings, source, author, cwd, pathTransform) {
+  return findings.map((f9) => {
+    const rawFile = typeof f9.file === "string" ? f9.file : "";
+    const filePath = rawFile ? pathTransform ? pathTransform(toRelativePath2(rawFile, cwd)) : toRelativePath2(rawFile, cwd) : "";
+    const placement = classifyFindingPlacement(filePath, f9.line, f9.end_line);
+    return {
+      source,
+      filePath: placement.filePath,
+      lineStart: placement.lineStart,
+      lineEnd: placement.lineEnd,
+      type: "comment",
+      side: "new",
+      scope: placement.scope,
+      text: `[${f9.severity}] ${f9.description}`,
+      severity: f9.severity,
+      reasoning: f9.reasoning,
+      author
+    };
+  });
+}
+var init_review_findings = __esm(() => {
+  init_external_annotation();
+  init_path_utils();
+});
+
 // ../../packages/server/claude-review.ts
+function composeClaudeReviewPrompt(userMessage, reviewProfile) {
+  return composeReviewPrompt(CLAUDE_REVIEW_PROMPT, reviewProfile, userMessage);
+}
 function buildClaudeCommand(prompt, model = "claude-opus-4-7", effort) {
   const allowedTools = [
     "Agent",
@@ -75512,19 +75663,7 @@ function parseClaudeStreamOutput(stdout) {
   return null;
 }
 function transformClaudeFindings(findings, source, cwd, pathTransform) {
-  return findings.filter((f9) => f9.file && typeof f9.line === "number").map((f9) => ({
-    source,
-    filePath: pathTransform ? pathTransform(toRelativePath2(f9.file, cwd)) : toRelativePath2(f9.file, cwd),
-    lineStart: f9.line,
-    lineEnd: f9.end_line ?? f9.line,
-    type: "comment",
-    side: "new",
-    scope: "line",
-    text: `[${f9.severity}] ${f9.description}`,
-    severity: f9.severity,
-    reasoning: f9.reasoning,
-    author: "Claude Code"
-  }));
+  return transformSeverityFindings(findings, source, "Claude Code", cwd, pathTransform);
 }
 function formatClaudeLogEvent(line) {
   try {
@@ -75631,6 +75770,10 @@ Step 5: Deduplicate and rank
   - Within each severity, sort by file path and line number
 
 Step 6: Return structured JSON output matching the schema.
+  Place each finding by how specific it is: give file and line for a line-level
+  issue; give file and set line null for a whole-file issue; set file and line
+  null for a general, review-level note. Never invent a line you are unsure of \u2014
+  drop to a file or general placement instead of guessing.
   If no issues are found, return an empty findings array with zeroed summary.
 
 ## Hard constraints
@@ -75645,7 +75788,8 @@ Step 6: Return structured JSON output matching the schema.
 - Do NOT use gh pr comment or any commenting tool
 - Your only output is the structured JSON findings`;
 var init_claude_review = __esm(() => {
-  init_path_utils();
+  init_review_profiles();
+  init_review_findings();
   CLAUDE_REVIEW_SCHEMA_JSON = JSON.stringify({
     type: "object",
     properties: {
@@ -75655,9 +75799,9 @@ var init_claude_review = __esm(() => {
           type: "object",
           properties: {
             severity: { type: "string", enum: ["important", "nit", "pre_existing"] },
-            file: { type: "string" },
-            line: { type: "integer" },
-            end_line: { type: "integer" },
+            file: { type: ["string", "null"] },
+            line: { type: ["integer", "null"] },
+            end_line: { type: ["integer", "null"] },
             description: { type: "string" },
             reasoning: { type: "string" }
           },
@@ -75681,23 +75825,513 @@ var init_claude_review = __esm(() => {
   });
 });
 
-// ../../packages/shared/agent-jobs.ts
-function serializeAgentSSEEvent(event) {
-  return `data: ${JSON.stringify(event)}
-
-`;
+// ../../packages/server/marker-review.ts
+function markerOpen(nonce) {
+  return `<${MARKER_TAG}:${nonce}>`;
 }
-function isTerminalStatus(status) {
-  return status === "done" || status === "failed" || status === "killed";
+function markerClose(nonce) {
+  return `</${MARKER_TAG}:${nonce}>`;
 }
-function jobSource(id) {
-  return "agent-" + id.slice(0, 8);
+function makeMarkerNonce() {
+  return "pn" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
 }
-var AGENT_HEARTBEAT_COMMENT = `:
+function extractMarkerNonce(prompt) {
+  const m6 = new RegExp(`<${MARKER_TAG}:(pn[0-9a-f]{12})>`).exec(prompt);
+  return m6 ? m6[1] : null;
+}
+function optionalNullableInteger(value) {
+  if (value === undefined || value === null)
+    return { ok: true, value: null };
+  if (typeof value === "number" && Number.isInteger(value))
+    return { ok: true, value };
+  return { ok: false };
+}
+function optionalNullableString(value) {
+  if (value === undefined || value === null)
+    return { ok: true, value: null };
+  if (typeof value === "string")
+    return { ok: true, value };
+  return { ok: false };
+}
+function validateMarkerReviewOutput(parsed) {
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const obj = parsed;
+  if (!Array.isArray(obj.findings))
+    return null;
+  const summary = obj.summary;
+  if (!summary || typeof summary !== "object")
+    return null;
+  const s10 = summary;
+  if (typeof s10.correctness !== "string")
+    return null;
+  if (typeof s10.explanation !== "string")
+    return null;
+  if (typeof s10.confidence !== "number" || !Number.isFinite(s10.confidence))
+    return null;
+  const findings = [];
+  for (const raw2 of obj.findings) {
+    if (!raw2 || typeof raw2 !== "object")
+      return null;
+    const f9 = raw2;
+    if (typeof f9.severity !== "string" || !VALID_SEVERITIES.has(f9.severity))
+      return null;
+    if (typeof f9.description !== "string")
+      return null;
+    const file = optionalNullableString(f9.file);
+    if (!file.ok)
+      return null;
+    const line = optionalNullableInteger(f9.line);
+    if (!line.ok)
+      return null;
+    const endLine = optionalNullableInteger(f9.end_line);
+    if (!endLine.ok)
+      return null;
+    findings.push({
+      severity: f9.severity,
+      file: file.value,
+      line: line.value,
+      end_line: endLine.value,
+      description: f9.description,
+      reasoning: typeof f9.reasoning === "string" ? f9.reasoning : ""
+    });
+  }
+  return {
+    findings,
+    summary: {
+      correctness: s10.correctness,
+      explanation: s10.explanation,
+      confidence: Math.max(0, Math.min(1, s10.confidence))
+    }
+  };
+}
+function cursorIsRealAssistantDelta(event) {
+  return event.timestamp_ms !== undefined && event.model_call_id === undefined;
+}
+function cursorAssistantText(event) {
+  if (typeof event.text === "string")
+    return event.text;
+  const message = event.message;
+  const content = message?.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.filter((p2) => !!p2 && typeof p2 === "object").filter((p2) => p2.type === "text" && typeof p2.text === "string").map((p2) => p2.text).join("");
+  }
+  return "";
+}
+function cursorExtractText(event) {
+  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;
+}
+function cursorParseModels(stdout) {
+  if (!stdout)
+    return [];
+  const models = [];
+  const seen = new Set;
+  for (const rawLine of stdout.split(`
+`)) {
+    const line = rawLine.trim();
+    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;
+}
+function cursorFormatLogEvent(event) {
+  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 text2 = cursorAssistantText(event);
+      return text2 ? text2 : 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;
+  }
+}
+function cursorBuildArgv(prompt, model, cwd) {
+  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
+  ];
+}
+function opencodeExtractText(event) {
+  if (event.type === "text") {
+    const part = event.part;
+    if (typeof part?.text === "string")
+      return part.text;
+  }
+  return null;
+}
+function opencodeParseModels(stdout) {
+  if (!stdout)
+    return [];
+  const models = [];
+  const seen = new Set;
+  for (const rawLine of stdout.split(`
+`)) {
+    const id = rawLine.trim();
+    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;
+}
+function opencodeFormatLogEvent(event) {
+  const part = event.part;
+  switch (event.type) {
+    case "text": {
+      const text2 = typeof part?.text === "string" ? part.text.trim() : "";
+      return text2 ? text2 : 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:
+      return null;
+  }
+}
+function opencodeBuildArgv(prompt, model, cwd) {
+  const useModel = !!model && model.trim().length > 0;
+  return [
+    "opencode",
+    "run",
+    "--format",
+    "json",
+    "--agent",
+    "plan",
+    ...useModel ? ["--model", model] : [],
+    ...cwd ? ["--dir", cwd] : [],
+    prompt
+  ];
+}
+function reduceMarkerStream(stdout, engine) {
+  let canonicalText = "";
+  let recordCount = 0;
+  if (!stdout)
+    return { canonicalText, recordCount };
+  for (const rawLine of stdout.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    recordCount++;
+    const text2 = engine.extractText(event);
+    if (text2)
+      canonicalText += text2;
+  }
+  return { canonicalText, recordCount };
+}
+function extractLastMarkerBlock(text2, openTag, closeTag) {
+  let result = null;
+  let searchFrom = 0;
+  while (true) {
+    const open2 = text2.indexOf(openTag, searchFrom);
+    if (open2 === -1)
+      break;
+    const contentStart = open2 + openTag.length;
+    const close = text2.indexOf(closeTag, contentStart);
+    if (close === -1)
+      return null;
+    result = text2.slice(contentStart, close);
+    searchFrom = close + closeTag.length;
+  }
+  return result;
+}
+function parseMarkerStreamOutput(stdout, engine, nonce) {
+  if (!stdout || !stdout.trim())
+    return null;
+  if (!nonce)
+    return null;
+  const { canonicalText } = reduceMarkerStream(stdout, engine);
+  if (!canonicalText)
+    return null;
+  const block = extractLastMarkerBlock(canonicalText, markerOpen(nonce), markerClose(nonce));
+  if (block === null)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(block.trim());
+  } catch {
+    return null;
+  }
+  return validateMarkerReviewOutput(parsed);
+}
+function formatMarkerLogEvent(line, engine) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  return engine.formatLogEvent(event);
+}
+function buildMarkerOutputContract(nonce) {
+  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) \u2014 reproduce both
+tags EXACTLY as shown, including that id, or your findings will be discarded:
 
-`, AGENT_HEARTBEAT_INTERVAL_MS = 30000;
+${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 \u2014 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 \u2014 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 \u2014 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) \u2014 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 \u2014
+drop to a file or general placement instead of guessing. Cite file/line from the
+new (post-change) code. One finding per distinct bug \u2014 do not stack unrelated
+issues. If no issues are found, return an empty "findings" array with a valid
+summary.`;
+}
+function composeMarkerReviewPrompt(profile, userMessage, nonce) {
+  const head2 = profileHasCustomSection(profile) ? profile.instructions.trim() : MARKER_REVIEW_METHODOLOGY;
+  return head2 + `
+
+` + buildMarkerOutputContract(nonce) + `
+
+---
+
+` + userMessage;
+}
+function buildMarkerCommand(engine, prompt, model, cwd) {
+  return { command: engine.buildArgv(prompt, model, cwd) };
+}
+function transformMarkerFindings(findings, source, author, cwd, pathTransform) {
+  return transformSeverityFindings(findings, source, author, cwd, pathTransform);
+}
+var MARKER_TAG = "plannotator-review-json", VALID_SEVERITIES, CURSOR_ENGINE, OPENCODE_ENGINE, MARKER_ENGINES, 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 \u2014 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 \u2014 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 \u2014 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 \u2014 report what a maintainer would actually fix
+  important \u2014 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 \u2014 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 \u2014 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" \u2014 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.`;
+var init_marker_review = __esm(() => {
+  init_review_profiles();
+  init_review_findings();
+  VALID_SEVERITIES = new Set([
+    "important",
+    "nit",
+    "pre_existing"
+  ]);
+  CURSOR_ENGINE = {
+    id: "cursor",
+    name: "Cursor CLI",
+    binary: "agent",
+    author: "Cursor",
+    buildArgv: cursorBuildArgv,
+    extractText: cursorExtractText,
+    modelsArgv: ["models"],
+    parseModels: cursorParseModels,
+    formatLogEvent: cursorFormatLogEvent
+  };
+  OPENCODE_ENGINE = {
+    id: "opencode",
+    name: "OpenCode",
+    binary: "opencode",
+    author: "OpenCode",
+    buildArgv: opencodeBuildArgv,
+    extractText: opencodeExtractText,
+    modelsArgv: ["models"],
+    parseModels: opencodeParseModels,
+    formatLogEvent: opencodeFormatLogEvent
+  };
+  MARKER_ENGINES = {
+    cursor: CURSOR_ENGINE,
+    opencode: OPENCODE_ENGINE
+  };
+});
 
 // ../../packages/server/agent-jobs.ts
+async function discoverMarkerModels(engine) {
+  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 [];
+  }
+}
 function createAgentJobHandler(options) {
   const { mode, getServerUrl, getCwd } = options;
   const jobs = new Map;
@@ -75710,11 +76344,28 @@ function createAgentJobHandler(options) {
     { id: "codex", name: "Codex CLI", available: !!Bun.which("codex") },
     { id: "tour", name: "Code Tour", available: !!Bun.which("claude") || !!Bun.which("codex") }
   ];
-  const capabilitiesResponse = {
-    mode,
-    providers: capabilities,
-    available: capabilities.some((c2) => c2.available)
-  };
+  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;
+  async function buildCapabilitiesResponse() {
+    const providers = await Promise.all(capabilities.map(async (c2) => {
+      const engine = MARKER_ENGINES[c2.id];
+      if (!engine || !c2.available)
+        return c2;
+      let models = markerModelsCache.get(engine.id);
+      if (!models) {
+        models = await discoverMarkerModels(engine);
+        markerModelsCache.set(engine.id, models);
+      }
+      return { ...c2, models };
+    }));
+    return { mode, providers, available: providers.some((p2) => p2.available) };
+  }
   function broadcast2(event) {
     version++;
     const data = encoder2.encode(serializeAgentSSEEvent(event));
@@ -75726,8 +76377,7 @@ function createAgentJobHandler(options) {
       }
     }
   }
-  function spawnJob(provider, command, label, outputPath, spawnOptions) {
-    const id = crypto.randomUUID();
+  function spawnJob(id, provider, command, label, outputPath, spawnOptions) {
     const source = jobSource(id);
     const info = {
       id,
@@ -75745,7 +76395,9 @@ function createAgentJobHandler(options) {
       ...spawnOptions?.fastMode && { fastMode: spawnOptions.fastMode },
       ...spawnOptions?.prUrl && { prUrl: spawnOptions.prUrl },
       ...spawnOptions?.diffScope && { diffScope: spawnOptions.diffScope },
-      ...spawnOptions?.diffContext && { diffContext: spawnOptions.diffContext }
+      ...spawnOptions?.diffContext && { diffContext: spawnOptions.diffContext },
+      ...spawnOptions?.reviewProfileId && { reviewProfileId: spawnOptions.reviewProfileId },
+      ...spawnOptions?.reviewProfileLabel && { reviewProfileLabel: spawnOptions.reviewProfileLabel }
     };
     let proc = null;
     try {
@@ -75812,33 +76464,46 @@ function createAgentJobHandler(options) {
       }
       let stdoutBuf = "";
       const stdoutDone = captureStdout && proc.stdout && typeof proc.stdout !== "number" ? (async () => {
+        const emitLogLine = (line) => {
+          if (!line.trim())
+            return;
+          if (provider === "claude" || spawnOptions?.engine === "claude") {
+            const formatted = formatClaudeLogEvent(line);
+            if (formatted !== null)
+              broadcast2({ type: "job:log", jobId: id, delta: formatted + `
+` });
+            return;
+          }
+          const markerEngine = MARKER_ENGINES[provider];
+          if (markerEngine) {
+            const formatted = formatMarkerLogEvent(line, markerEngine);
+            if (formatted !== null)
+              broadcast2({ type: "job:log", jobId: id, delta: formatted + `
+` });
+            return;
+          }
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "result")
+              return;
+          } catch {}
+          broadcast2({ type: "job:log", jobId: id, delta: line + `
+` });
+        };
         try {
           const reader = proc.stdout;
+          let logLineCarry = "";
           for await (const chunk of reader) {
             const text2 = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
             stdoutBuf += text2;
-            const lines = text2.split(`
+            const lines = (logLineCarry + text2).split(`
 `);
-            for (const line of lines) {
-              if (!line.trim())
-                continue;
-              if (provider === "claude" || spawnOptions?.engine === "claude") {
-                const formatted = formatClaudeLogEvent(line);
-                if (formatted !== null) {
-                  broadcast2({ type: "job:log", jobId: id, delta: formatted + `
-` });
-                }
-                continue;
-              }
-              try {
-                const event = JSON.parse(line);
-                if (event.type === "result")
-                  continue;
-              } catch {}
-              broadcast2({ type: "job:log", jobId: id, delta: line + `
-` });
-            }
+            logLineCarry = lines.pop() ?? "";
+            for (const line of lines)
+              emitLogLine(line);
           }
+          if (logLineCarry)
+            emitLogLine(logLineCarry);
         } catch {}
       })() : Promise.resolve();
       proc.exited.then(async (exitCode) => {
@@ -75861,7 +76526,12 @@ function createAgentJobHandler(options) {
               stdout: captureStdout ? stdoutBuf : undefined,
               cwd: jobCwd
             });
-          } catch {}
+          } catch (err) {
+            if (MARKER_ENGINES[provider]) {
+              entry.info.status = "failed";
+              entry.info.error = err instanceof Error ? err.message : `${provider} result ingestion failed`;
+            }
+          }
         }
         jobOutputPaths.delete(id);
         jobOutputPaths.delete(`${id}:cwd`);
@@ -75910,7 +76580,7 @@ function createAgentJobHandler(options) {
     killAll,
     async handle(req, url, handlerOptions) {
       if (url.pathname === CAPABILITIES && req.method === "GET") {
-        return Response.json(capabilitiesResponse);
+        return Response.json(await buildCapabilitiesResponse());
       }
       if (url.pathname === JOBS_STREAM && req.method === "GET") {
         handlerOptions?.disableIdleTimeout?.();
@@ -75962,6 +76632,23 @@ function createAgentJobHandler(options) {
       if (url.pathname === JOBS && req.method === "POST") {
         try {
           const body3 = await req.json();
+          const KNOWN_JOB_FIELDS = new Set([
+            "provider",
+            "command",
+            "label",
+            "engine",
+            "model",
+            "reasoningEffort",
+            "effort",
+            "fastMode",
+            "reviewProfileId"
+          ]);
+          if (body3 && typeof body3 === "object") {
+            const unknown2 = Object.keys(body3).filter((k4) => !KNOWN_JOB_FIELDS.has(k4));
+            if (unknown2.length > 0) {
+              return Response.json({ error: `Unknown field(s): ${unknown2.join(", ")}` }, { status: 400 });
+            }
+          }
           const provider = typeof body3.provider === "string" ? body3.provider : "";
           let rawCommand = Array.isArray(body3.command) ? body3.command : [];
           let command = rawCommand.filter((c2) => typeof c2 === "string");
@@ -75971,6 +76658,13 @@ function createAgentJobHandler(options) {
           if (!cap2 || !cap2.available) {
             return Response.json({ error: `Unknown or unavailable provider: ${provider}` }, { status: 400 });
           }
+          const isServerBuiltProvider = SERVER_BUILT_PROVIDERS.has(provider);
+          if (isServerBuiltProvider) {
+            if (!options.buildCommand) {
+              return Response.json({ error: `Provider ${provider} requires server-built command` }, { status: 400 });
+            }
+            command = [];
+          }
           let captureStdout = false;
           let stdinPrompt;
           let spawnCwd;
@@ -75983,6 +76677,9 @@ function createAgentJobHandler(options) {
           let jobPrUrl;
           let jobDiffScope;
           let jobDiffContext;
+          let jobReviewProfileId;
+          let jobReviewProfileLabel;
+          const jobId = crypto.randomUUID();
           if (options.buildCommand) {
             const config = {};
             if (typeof body3.engine === "string")
@@ -75995,6 +76692,8 @@ function createAgentJobHandler(options) {
               config.effort = body3.effort;
             if (body3.fastMode === true)
               config.fastMode = true;
+            if (typeof body3.reviewProfileId === "string")
+              config.reviewProfileId = body3.reviewProfileId;
             const built = await options.buildCommand(provider, Object.keys(config).length > 0 ? config : undefined);
             if (built) {
               command = built.command;
@@ -76013,12 +76712,14 @@ function createAgentJobHandler(options) {
               jobPrUrl = built.prUrl;
               jobDiffScope = built.diffScope;
               jobDiffContext = built.diffContext;
+              jobReviewProfileId = built.reviewProfileId;
+              jobReviewProfileLabel = built.reviewProfileLabel;
             }
           }
           if (command.length === 0) {
             return Response.json({ error: 'Missing "command" array' }, { status: 400 });
           }
-          const job = spawnJob(provider, command, label, outputPath, {
+          const job = spawnJob(jobId, provider, command, label, outputPath, {
             captureStdout,
             stdinPrompt,
             cwd: spawnCwd,
@@ -76030,7 +76731,9 @@ function createAgentJobHandler(options) {
             fastMode: jobFastMode,
             prUrl: jobPrUrl,
             diffScope: jobDiffScope,
-            diffContext: jobDiffContext
+            diffContext: jobDiffContext,
+            reviewProfileId: jobReviewProfileId,
+            reviewProfileLabel: jobReviewProfileLabel
           });
           return Response.json({ job }, { status: 201 });
         } catch (err) {
@@ -76060,12 +76763,20 @@ function createAgentJobHandler(options) {
     }
   };
 }
-var BASE2 = "/api/agents", JOBS, JOBS_STREAM, CAPABILITIES;
+var BASE2 = "/api/agents", JOBS, JOBS_STREAM, CAPABILITIES, SERVER_BUILT_PROVIDERS;
 var init_agent_jobs = __esm(() => {
   init_claude_review();
+  init_marker_review();
   JOBS = `${BASE2}/jobs`;
   JOBS_STREAM = `${JOBS}/stream`;
   CAPABILITIES = `${BASE2}/capabilities`;
+  SERVER_BUILT_PROVIDERS = new Set([
+    "claude",
+    "codex",
+    "tour",
+    "cursor",
+    "opencode"
+  ]);
 });
 
 // ../../packages/server/codex-review.ts
@@ -76093,6 +76804,9 @@ async function ensureSchemaFile() {
   }
   return SCHEMA_FILE;
 }
+function composeCodexReviewPrompt(userMessage, reviewProfile) {
+  return composeReviewPrompt(CODEX_REVIEW_SYSTEM_PROMPT, reviewProfile, userMessage);
+}
 async function buildCodexCommand(options) {
   const { cwd, outputPath, prompt, model, reasoningEffort, fastMode } = options;
   const schemaPath = await ensureSchemaFile();
@@ -76159,19 +76873,25 @@ async function parseCodexOutput(outputPath) {
   }
 }
 function transformReviewFindings(findings, source, cwd, author, pathTransform) {
-  const annotations = findings.filter((f9) => f9.code_location?.absolute_file_path && typeof f9.code_location?.line_range?.start === "number" && typeof f9.code_location?.line_range?.end === "number").map((f9) => ({
-    source,
-    filePath: pathTransform ? pathTransform(toRelativePath2(f9.code_location.absolute_file_path, cwd)) : toRelativePath2(f9.code_location.absolute_file_path, cwd),
-    lineStart: f9.code_location.line_range.start,
-    lineEnd: f9.code_location.line_range.end,
-    type: "comment",
-    side: "new",
-    scope: "line",
-    text: `${f9.title}
+  const annotations = findings.map((f9) => {
+    const loc = f9.code_location;
+    const rawFile = loc && typeof loc.absolute_file_path === "string" ? loc.absolute_file_path : "";
+    const filePath = rawFile ? pathTransform ? pathTransform(toRelativePath2(rawFile, cwd)) : toRelativePath2(rawFile, cwd) : "";
+    const placement = classifyFindingPlacement(filePath, loc?.line_range?.start, loc?.line_range?.end);
+    return {
+      source,
+      filePath: placement.filePath,
+      lineStart: placement.lineStart,
+      lineEnd: placement.lineEnd,
+      type: "comment",
+      side: "new",
+      scope: placement.scope,
+      text: `${f9.title}
 
 ${f9.body}`.trim(),
-    author: author ?? "Review Agent"
-  }));
+      author: author ?? "Review Agent"
+    };
+  });
   debugLog("TRANSFORM_FINDINGS", {
     inputCount: findings.length,
     outputCount: annotations.length,
@@ -76235,6 +76955,8 @@ At the beginning of the finding title, tag the bug with priority level. For exam
 
 Additionally, include a numeric priority field in the JSON output for each finding: set "priority" to 0 for P0, 1 for P1, 2 for P2, or 3 for P3. If a priority cannot be determined, omit the field or use null.
 
+Place each finding by how specific it is. For a line-level issue, set code_location with the file and a line_range. For a whole-file issue, set code_location with the file path and line_range null. For a general, review-wide point, set code_location null. Do not invent a line range you are unsure of \u2014 drop to a whole-file or general placement instead.
+
 At the end of your findings, output an "overall correctness" verdict of whether or not the patch should be considered "correct".
 Correct implies that existing code and tests will not break, and the patch is free of bugs and other blocking issues.
 Ignore non-blocking issues such as style, formatting, typos, documentation, and other nits.
@@ -76244,6 +76966,8 @@ The finding description should be one paragraph.`;
 var init_codex_review = __esm(() => {
   init_path_utils();
   init_data_dir();
+  init_review_profiles();
+  init_external_annotation();
   DATA_DIR3 = getPlannotatorDataDir();
   DEBUG_ENABLED = !!process.env.PLANNOTATOR_DEBUG;
   DEBUG_LOG_PATH = join16(DATA_DIR3, "codex-review-debug.log");
@@ -76260,11 +76984,11 @@ var init_codex_review = __esm(() => {
             confidence_score: { type: "number" },
             priority: { type: ["integer", "null"] },
             code_location: {
-              type: "object",
+              type: ["object", "null"],
               properties: {
                 absolute_file_path: { type: "string" },
                 line_range: {
-                  type: "object",
+                  type: ["object", "null"],
                   properties: {
                     start: { type: "integer" },
                     end: { type: "integer" }
@@ -76318,20 +77042,20 @@ function buildWorkspacePromptContextLines(workspace, options = {}) {
     repoList
   ];
 }
-function buildAgentReviewUserMessageForTarget(target) {
+function buildAgentReviewUserMessageForTarget(target, contextOnly = false) {
   if (target.kind === "workspace") {
-    return buildWorkspaceReviewUserMessage(target.patch, target.workspace);
+    return buildWorkspaceReviewUserMessage(target.patch, target.workspace, contextOnly);
   }
-  return buildAgentReviewUserMessage(target.patch, target.diffType, target.options, target.kind === "pr" ? target.prMetadata : undefined);
+  return buildAgentReviewUserMessage(target.patch, target.diffType, target.options, target.kind === "pr" ? target.prMetadata : undefined, contextOnly);
 }
-function buildAgentReviewUserMessage(patch, diffType, options, prMetadata) {
+function buildAgentReviewUserMessage(patch, diffType, options, prMetadata, contextOnly = false) {
   if (prMetadata) {
     if (options?.prDiffScope === "full-stack") {
       return [
-        `Full-stack review of ${prMetadata.url}`,
+        contextOnly ? prMetadata.url : `Full-stack review of ${prMetadata.url}`,
         "",
         "This is a stacked PR. The diff below shows ALL accumulated changes from the repository default branch through this PR's head (not just this PR's own layer).",
-        "Review the complete diff for issues that span the stack.",
+        ...contextOnly ? [] : ["Review the complete diff for issues that span the stack."],
         "",
         "```diff",
         patch,
@@ -76353,10 +77077,14 @@ function buildAgentReviewUserMessage(patch, diffType, options, prMetadata) {
   }
   const instruction = getLocalDiffInstruction(diffType, options?.defaultBranch);
   if (instruction) {
+    if (contextOnly) {
+      return `Changeset: ${instruction.target}.
+${instruction.inspect}`;
+    }
     return `Review ${instruction.target}. ${instruction.inspect} Provide prioritized, actionable findings.`;
   }
   return [
-    "Review the following code changes and provide prioritized findings.",
+    contextOnly ? "Code changes:" : "Review the following code changes and provide prioritized findings.",
     "",
     "```diff",
     patch,
@@ -76364,10 +77092,9 @@ function buildAgentReviewUserMessage(patch, diffType, options, prMetadata) {
   ].join(`
 `);
 }
-function buildWorkspaceReviewUserMessage(patch, workspace) {
+function buildWorkspaceReviewUserMessage(patch, workspace, contextOnly = false) {
   return [
-    "Review the local workspace changes across multiple nested VCS repositories.",
-    "",
+    ...contextOnly ? [] : ["Review the local workspace changes across multiple nested VCS repositories.", ""],
     ...buildWorkspacePromptContextLines(workspace, { includeReportingInstruction: true }),
     "",
     "```diff",
@@ -86852,9 +87579,231 @@ var init_code_nav2 = __esm(() => {
   };
 });
 
+// ../../packages/server/review-skill-loader.ts
+import {
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync9,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync9,
+  realpathSync as realpathSync5,
+  statSync as statSync9,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join19 } from "path";
+function resolveGlobalSkillRoots() {
+  const home = process.env.HOME?.trim() || homedir3();
+  const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join19(home, ".claude");
+  const codexHome = process.env.CODEX_HOME?.trim() || join19(home, ".codex");
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join19(home, ".config");
+  const candidates = [
+    { dir: join19(claudeHome, "skills"), root: "claude" },
+    { dir: join19(codexHome, "skills"), root: "codex" },
+    { dir: join19(home, ".agents", "skills"), root: "universal" },
+    { dir: join19(configHome, "agents", "skills"), root: "universal" }
+  ];
+  const seen = new Set;
+  const roots = [];
+  for (const candidate of candidates) {
+    let key2;
+    try {
+      key2 = realpathSync5(candidate.dir);
+    } catch {
+      key2 = candidate.dir;
+    }
+    if (seen.has(key2))
+      continue;
+    seen.add(key2);
+    roots.push(candidate);
+  }
+  return roots;
+}
+function hasSkillMd(dir) {
+  try {
+    return statSync9(join19(dir, "SKILL.md")).isFile();
+  } catch {
+    return false;
+  }
+}
+function listSubdirs(dir) {
+  let entries;
+  try {
+    entries = readdirSync4(dir, { withFileTypes: true });
+  } catch (err) {
+    console.error(`[plannotator] Could not read skill root ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+  return entries.filter((e10) => e10.isDirectory() && !SKIP_DIRS.has(e10.name)).map((e10) => e10.name);
+}
+function discoverSkills() {
+  const byName = new Map;
+  const add = (dir, root3) => {
+    const name = dir.replace(/^.*[\\/]/, "");
+    if (byName.has(name))
+      return;
+    byName.set(name, {
+      name,
+      sourcePath: dir,
+      skillMdPath: join19(dir, "SKILL.md"),
+      root: root3
+    });
+  };
+  for (const { dir: rootDir, root: root3 } of resolveGlobalSkillRoots()) {
+    if (!existsSync16(rootDir))
+      continue;
+    for (const childName of listSubdirs(rootDir)) {
+      const childDir = join19(rootDir, childName);
+      if (hasSkillMd(childDir)) {
+        add(childDir, root3);
+        continue;
+      }
+      for (const grandName of listSubdirs(childDir)) {
+        const grandDir = join19(childDir, grandName);
+        if (hasSkillMd(grandDir))
+          add(grandDir, root3);
+      }
+    }
+  }
+  return [...byName.values()];
+}
+function stripFrontmatter(raw2) {
+  const text2 = raw2.replace(/^\uFEFF/, "");
+  const match = text2.match(/^---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/);
+  if (!match)
+    return text2;
+  return text2.slice(match[0].length);
+}
+function skillHasExtraFiles(sourcePath) {
+  let entries;
+  try {
+    entries = readdirSync4(sourcePath);
+  } catch {
+    return false;
+  }
+  return entries.some((name) => name !== "SKILL.md");
+}
+function skillFilesPointerLine(skillDir) {
+  return `This review skill's files (references, scripts, assets) are at: ${skillDir}
+Resolve any relative paths in the instructions below (e.g. references/, scripts/, assets/) against that absolute directory \u2014 the working directory is the repository under review, not the skill directory.`;
+}
+function readCuratedSkillNames() {
+  const path4 = join19(getPlannotatorDataDir(), "review-skills.json");
+  if (!existsSync16(path4))
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync9(path4, "utf-8"));
+  } catch (err) {
+    console.error(`[plannotator] Ignoring malformed review-skills.json: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    console.error("[plannotator] Ignoring review-skills.json: not an object.");
+    return null;
+  }
+  const { version, enabled } = parsed;
+  if (version !== 1) {
+    console.error("[plannotator] Ignoring review-skills.json: version must be 1.");
+    return null;
+  }
+  if (!Array.isArray(enabled) || !enabled.every((n2) => typeof n2 === "string")) {
+    console.error("[plannotator] Ignoring review-skills.json: `enabled` must be an array of strings.");
+    return null;
+  }
+  return new Set(enabled);
+}
+function listAllSkills() {
+  const enabled = readCuratedSkillNames() ?? new Set;
+  return discoverSkills().map((s10) => ({
+    name: s10.name,
+    root: s10.root,
+    sourcePath: s10.sourcePath,
+    enabled: enabled.has(s10.name)
+  }));
+}
+function enableReviewSkill(name) {
+  const known = new Set(discoverSkills().map((s10) => s10.name));
+  if (!known.has(name)) {
+    throw new Error(`No skill named "${name}" found in any global skill root.`);
+  }
+  const current = readCuratedSkillNames() ?? new Set;
+  current.add(name);
+  const enabled = [...current];
+  const dir = getPlannotatorDataDir();
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync6(join19(dir, "review-skills.json"), JSON.stringify({ version: 1, enabled }, null, 2) + `
+`);
+  return { enabled };
+}
+function resolveSkillProfile(skill) {
+  let raw2;
+  try {
+    raw2 = readFileSync9(skill.skillMdPath, "utf-8");
+  } catch (err) {
+    console.error(`[plannotator] Skipping review skill ${skill.name}: could not read ${skill.skillMdPath}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  const body3 = stripFrontmatter(raw2);
+  if (!body3.trim()) {
+    console.error(`[plannotator] Skipping review skill ${skill.name}: SKILL.md body is empty.`);
+    return null;
+  }
+  if (body3.length > MAX_SKILL_BODY_LEN) {
+    console.error(`[plannotator] Skipping review skill ${skill.name}: SKILL.md body exceeds ${MAX_SKILL_BODY_LEN} chars.`);
+    return null;
+  }
+  const instructions = skillHasExtraFiles(skill.sourcePath) ? `${skillFilesPointerLine(skill.sourcePath)}
+
+${body3}` : body3;
+  return {
+    id: `skill:${skill.name}`,
+    label: skill.name,
+    instructions,
+    source: "user",
+    sourcePath: skill.sourcePath
+  };
+}
+function discoverCuratedSkills() {
+  const enabled = readCuratedSkillNames();
+  if (!enabled || enabled.size === 0)
+    return [];
+  const discovered = discoverSkills();
+  const byName = new Map(discovered.map((s10) => [s10.name, s10]));
+  const curated = [];
+  for (const name of enabled) {
+    const skill = byName.get(name);
+    if (skill) {
+      curated.push(skill);
+    } else {
+      console.error(`[plannotator] Curated review skill "${name}" not found in any global skill root; skipping.`);
+    }
+  }
+  return curated;
+}
+function resolveRequestedReviewProfile(requestedProfileId) {
+  if (!requestedProfileId || requestedProfileId === BUILTIN_DEFAULT_PROFILE.id) {
+    return BUILTIN_DEFAULT_PROFILE;
+  }
+  const skill = discoverCuratedSkills().find((s10) => `skill:${s10.name}` === requestedProfileId);
+  if (!skill) {
+    throw new Error(`Review "${requestedProfileId}" is not available \u2014 it may have been renamed or removed. Pick another review.`);
+  }
+  const resolved = resolveSkillProfile(skill);
+  if (!resolved) {
+    throw new Error(`Review "${skill.name}" could not be loaded \u2014 its SKILL.md is unreadable, empty, or too large. Fix the skill or pick another review.`);
+  }
+  return resolved;
+}
+var MAX_SKILL_BODY_LEN = 20000, SKIP_DIRS;
+var init_review_skill_loader = __esm(() => {
+  init_data_dir();
+  init_review_profiles();
+  SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "__pycache__"]);
+});
+
 // ../../packages/server/review.ts
 import { basename as basename6 } from "path";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 async function startReviewServer(options) {
   const { htmlContent, origin, gitContext, sharingEnabled = true, shareBaseUrl, onReady } = options;
   let prMetadata = options.prMetadata;
@@ -86893,7 +87842,7 @@ async function startReviewServer(options) {
   const detectedCompareTarget = () => gitContext?.defaultBranch || gitContext?.compareTarget?.fallback || "main";
   let currentBase = options.initialBase || detectedCompareTarget();
   let baseEverSwitched = false;
-  const agentCwdIfExists = () => options.agentCwd && existsSync16(options.agentCwd) ? options.agentCwd : undefined;
+  const agentCwdIfExists = () => options.agentCwd && existsSync17(options.agentCwd) ? options.agentCwd : undefined;
   const resolvePRLocalCwd = (meta = prMetadata) => {
     const pool = options.worktreePool;
     if (pool && meta) {
@@ -87072,6 +88021,8 @@ async function startReviewServer(options) {
       const launchDiffType = currentDiffType;
       const launchBase = currentBase;
       const launchScope = currentPRDiffScope;
+      const requestedProfileId = typeof config?.reviewProfileId === "string" ? config.reviewProfileId : undefined;
+      const reviewProfile = resolveRequestedReviewProfile(requestedProfileId);
       let cwd;
       if (options.worktreePool && launchMetadata) {
         const checkout = await ensurePRLocalCwd(launchMetadata);
@@ -87107,37 +88058,38 @@ async function startReviewServer(options) {
           prMetadata: launchMetadata,
           config
         });
-        return built ? { ...built, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext } : built;
+        return built ? { ...built, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label } : built;
       }
+      const isCustomReview = reviewProfile.source === "user";
       const userMessage = workspacePrompt ? buildAgentReviewUserMessageForTarget({
         kind: "workspace",
         patch: launchPatch,
         workspace: workspacePrompt
-      }) : buildAgentReviewUserMessage(launchPatch, launchDiffType, userMessageOptions, launchMetadata);
+      }, isCustomReview) : buildAgentReviewUserMessage(launchPatch, launchDiffType, userMessageOptions, launchMetadata, isCustomReview);
       const jobLabel = workspacePrompt ? "Workspace Review" : "Code Review";
       if (provider === "codex") {
         const model = typeof config?.model === "string" && config.model ? config.model : undefined;
         const reasoningEffort = typeof config?.reasoningEffort === "string" && config.reasoningEffort ? config.reasoningEffort : undefined;
         const fastMode = config?.fastMode === true;
         const outputPath = generateOutputPath();
-        const prompt = CODEX_REVIEW_SYSTEM_PROMPT + `
-
----
-
-` + userMessage;
+        const prompt = composeCodexReviewPrompt(userMessage, reviewProfile);
         const command = await buildCodexCommand({ cwd, outputPath, prompt, model, reasoningEffort, fastMode });
-        return { command, outputPath, prompt, cwd, label: jobLabel, model, reasoningEffort, fastMode: fastMode || undefined, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext };
+        return { command, outputPath, prompt, cwd, label: jobLabel, model, reasoningEffort, fastMode: fastMode || undefined, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
       }
       if (provider === "claude") {
         const model = typeof config?.model === "string" && config.model ? config.model : undefined;
         const effort = typeof config?.effort === "string" && config.effort ? config.effort : undefined;
-        const prompt = CLAUDE_REVIEW_PROMPT + `
-
----
-
-` + userMessage;
+        const prompt = composeClaudeReviewPrompt(userMessage, reviewProfile);
         const { command, stdinPrompt } = buildClaudeCommand(prompt, model, effort);
-        return { command, stdinPrompt, prompt, cwd, label: jobLabel, captureStdout: true, model, effort, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext };
+        return { command, stdinPrompt, prompt, cwd, label: jobLabel, captureStdout: true, model, effort, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext, reviewProfileId: reviewProfile.id, reviewProfileLabel: reviewProfile.label };
+      }
+      const markerEngine = MARKER_ENGINES[provider];
+      if (markerEngine) {
+        const model = typeof config?.model === "string" && config.model ? config.model : undefined;
+        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;
     },
@@ -87152,41 +88104,77 @@ async function startReviewServer(options) {
         prTitle: jobPrMeta.title,
         prRepo: getDisplayRepo(jobPrMeta)
       } : jobPrUrl ? { prUrl: jobPrUrl } : {};
-      if (job.provider === "codex" && meta.outputPath) {
-        const output = await parseCodexOutput(meta.outputPath);
-        if (!output)
+      const profileLabel = job.reviewProfileId && job.reviewProfileId !== BUILTIN_DEFAULT_PROFILE.id ? job.reviewProfileLabel : undefined;
+      const ingest = (transformed, logTag) => {
+        if (transformed.length === 0)
+          return;
+        const annotations = transformed.map((a2) => ({
+          ...a2,
+          ...jobPrContext,
+          ...jobDiffScope && { diffScope: jobDiffScope },
+          ...profileLabel && { reviewProfileLabel: profileLabel }
+        }));
+        const result = externalAnnotations.addAnnotations({ annotations });
+        if ("error" in result)
+          console.error(`[${logTag}] addAnnotations error:`, result.error);
+        return result;
+      };
+      if (job.provider === "codex") {
+        const output = meta.outputPath ? await parseCodexOutput(meta.outputPath) : null;
+        if (!output) {
+          markJobReviewFailed(job, REVIEW_OUTPUT_FAILED);
           return;
+        }
         const hasBlockingFindings = output.findings.some((f9) => f9.priority !== null && f9.priority <= 1);
         job.summary = {
           correctness: hasBlockingFindings ? "Issues Found" : output.overall_correctness,
           explanation: output.overall_explanation,
           confidence: output.overall_confidence_score
         };
-        if (output.findings.length > 0) {
-          const annotations = transformReviewFindings(output.findings, job.source, cwd, "Codex", workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined).map((a2) => ({ ...a2, ...jobPrContext, ...jobDiffScope && { diffScope: jobDiffScope } }));
-          const result = externalAnnotations.addAnnotations({ annotations });
-          if ("error" in result)
-            console.error(`[codex-review] addAnnotations error:`, result.error);
+        ingest(transformReviewFindings(output.findings, job.source, cwd, "Codex", workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined), "codex-review");
+        return;
+      }
+      if (job.provider === "claude") {
+        const stdout = meta.stdout ?? "";
+        const output = parseClaudeStreamOutput(stdout);
+        if (!output) {
+          console.error(`[claude-review] Failed to parse output (${stdout.length} bytes, last 200: ${stdout.slice(-200)})`);
+          markJobReviewFailed(job, REVIEW_OUTPUT_FAILED);
+          return;
         }
+        const transformed = transformClaudeFindings(output.findings, job.source, cwd, workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined);
+        const counts = { important: 0, nit: 0, pre_existing: 0 };
+        for (const a2 of transformed)
+          counts[a2.severity]++;
+        const total = counts.important + counts.nit + counts.pre_existing;
+        job.summary = {
+          correctness: counts.important === 0 ? "Correct" : "Issues Found",
+          explanation: `${counts.important} important, ${counts.nit} nit, ${counts.pre_existing} pre-existing`,
+          confidence: total === 0 ? 1 : Math.max(0, 1 - counts.important * 0.2)
+        };
+        ingest(transformed, "claude-review");
         return;
       }
-      if (job.provider === "claude" && meta.stdout) {
-        const output = parseClaudeStreamOutput(meta.stdout);
+      const markerEngine = MARKER_ENGINES[job.provider];
+      if (markerEngine) {
+        const nonce = extractMarkerNonce(job.prompt ?? "");
+        const output = nonce && meta.stdout ? parseMarkerStreamOutput(meta.stdout, markerEngine, nonce) : null;
         if (!output) {
-          console.error(`[claude-review] Failed to parse output (${meta.stdout.length} bytes, last 200: ${meta.stdout.slice(-200)})`);
+          job.status = "failed";
+          job.error = `${markerEngine.author} review output missing or unparseable (no valid marker JSON).`;
           return;
         }
-        const total = output.summary.important + output.summary.nit + output.summary.pre_existing;
+        const hasImportant = output.findings.some((f9) => f9.severity === "important");
         job.summary = {
-          correctness: output.summary.important === 0 ? "Correct" : "Issues Found",
-          explanation: `${output.summary.important} important, ${output.summary.nit} nit, ${output.summary.pre_existing} pre-existing`,
-          confidence: total === 0 ? 1 : Math.max(0, 1 - output.summary.important * 0.2)
+          correctness: hasImportant ? "Issues Found" : "Correct",
+          explanation: output.summary.explanation,
+          confidence: output.summary.confidence
         };
-        if (output.findings.length > 0) {
-          const annotations = transformClaudeFindings(output.findings, job.source, cwd, workspace ? (filePath) => workspace.normalizeAnnotationPath(filePath) : undefined).map((a2) => ({ ...a2, ...jobPrContext, ...jobDiffScope && { diffScope: jobDiffScope } }));
-          const result = externalAnnotations.addAnnotations({ annotations });
-          if ("error" in result)
-            console.error(`[claude-review] addAnnotations error:`, result.error);
+        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;
       }
@@ -87748,6 +88736,44 @@ async function startReviewServer(options) {
           if (url.pathname === "/api/agents") {
             return handleAgents(options.opencodeClient);
           }
+          if (url.pathname === "/api/agents/review-profiles" && req.method === "GET") {
+            const body3 = {
+              profiles: [
+                {
+                  id: BUILTIN_DEFAULT_PROFILE.id,
+                  label: BUILTIN_DEFAULT_PROFILE.label,
+                  source: BUILTIN_DEFAULT_PROFILE.source,
+                  default: BUILTIN_DEFAULT_PROFILE.default
+                },
+                ...discoverCuratedSkills().map((s10) => ({
+                  id: `skill:${s10.name}`,
+                  label: s10.name,
+                  source: "user",
+                  sourcePath: s10.sourcePath
+                }))
+              ]
+            };
+            return Response.json(body3);
+          }
+          if (url.pathname === "/api/agents/skills" && req.method === "GET") {
+            return Response.json({ skills: listAllSkills() });
+          }
+          if (url.pathname === "/api/agents/review-skills" && req.method === "POST") {
+            let name;
+            try {
+              ({ name } = await req.json());
+            } catch {
+              return Response.json({ error: "Invalid JSON" }, { status: 400 });
+            }
+            if (typeof name !== "string" || name.length === 0) {
+              return Response.json({ error: "`name` is required." }, { status: 400 });
+            }
+            try {
+              return Response.json(enableReviewSkill(name));
+            } catch (err) {
+              return Response.json({ error: err instanceof Error ? err.message : "Could not enable review." }, { status: 400 });
+            }
+          }
           if (url.pathname === "/api/draft") {
             if (req.method === "POST")
               return handleDraftSave(req, draftKey);
@@ -87926,18 +88952,21 @@ var init_review = __esm(() => {
   init_agent_review_message();
   init_claude_review();
   init_tour_review();
+  init_marker_review();
   init_config2();
   init_pr();
   init_ai_runtime();
   init_browser();
   init_open_in();
   init_code_nav2();
+  init_review_skill_loader();
+  init_review_profiles();
   init_browser();
   init_shared_handlers();
 });
 
 // ../../packages/shared/annotate-reference-roots-node.ts
-import { realpathSync as realpathSync5 } from "fs";
+import { realpathSync as realpathSync6 } from "fs";
 import { dirname as dirname6 } from "path";
 function getAnnotateReferenceRootPaths(options) {
   const roots = [];
@@ -87948,7 +88977,7 @@ function getAnnotateReferenceRootPaths(options) {
     if (!roots.includes(resolved))
       roots.push(resolved);
     try {
-      const real = realpathSync5(resolved);
+      const real = realpathSync6(resolved);
       if (!roots.includes(real))
         roots.push(real);
     } catch {}
@@ -88253,11 +89282,11 @@ function shutdown() {
 var init_agent_terminal_node_sidecar = () => {};
 
 // ../../packages/server/agent-terminal-runtime.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { join as join20 } from "path";
 import { fileURLToPath } from "url";
 function getAgentTerminalManagedRuntimeDir(dataDir = getPlannotatorDataDir()) {
-  return join19(dataDir, "vendor", "agent-terminal", `webtui-${AGENT_TERMINAL_WEBTUI_VERSION}`);
+  return join20(dataDir, "vendor", "agent-terminal", `webtui-${AGENT_TERMINAL_WEBTUI_VERSION}`);
 }
 function isAgentTerminalRemoteEnabled(env = process.env) {
   return isTruthy(env.PLANNOTATOR_AGENT_TERMINAL_REMOTE);
@@ -88286,7 +89315,7 @@ function resolveBundledAgentTerminalSidecarPath(moduleUrl = import.meta.url) {
   const bundledSidecarPath = fileURLToPath(new URL("./agent-terminal-node-sidecar.mjs", moduleUrl));
   if (isBunVirtualPath(bundledSidecarPath))
     return null;
-  return existsSync17(bundledSidecarPath) ? bundledSidecarPath : null;
+  return existsSync18(bundledSidecarPath) ? bundledSidecarPath : null;
 }
 async function resolveBundledAgentTerminalRuntime(nodePath, bundledSidecarPath) {
   const webtuiCoreUrl = resolveImportUrl("@plannotator/webtui/core");
@@ -88337,9 +89366,9 @@ async function resolveManagedAgentTerminalRuntime(nodePath) {
   };
 }
 function materializeAgentTerminalSidecar(runtimeDir) {
-  mkdirSync9(runtimeDir, { recursive: true });
-  const sidecarPath = join19(runtimeDir, "agent-terminal-node-sidecar.mjs");
-  writeFileSync6(sidecarPath, agent_terminal_node_sidecar_default, "utf8");
+  mkdirSync10(runtimeDir, { recursive: true });
+  const sidecarPath = join20(runtimeDir, "agent-terminal-node-sidecar.mjs");
+  writeFileSync7(sidecarPath, agent_terminal_node_sidecar_default, "utf8");
   return sidecarPath;
 }
 function tryMaterializeAgentTerminalSidecar(runtimeDir) {
@@ -88354,11 +89383,11 @@ function tryMaterializeAgentTerminalSidecar(runtimeDir) {
   }
 }
 function readInstalledWebTuiVersion(runtimeDir) {
-  const packageJsonPath = join19(runtimeDir, "node_modules", "@plannotator", "webtui", "package.json");
-  if (!existsSync17(packageJsonPath))
+  const packageJsonPath = join20(runtimeDir, "node_modules", "@plannotator", "webtui", "package.json");
+  if (!existsSync18(packageJsonPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
     return null;
@@ -89480,7 +90509,7 @@ var init_agent_terminal = __esm(() => {
 });
 
 // ../../packages/server/annotate.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { dirname as dirname8, resolve as resolvePath4 } from "path";
 async function startAnnotateServer(options) {
   warmFileListCache(process.cwd(), "code");
@@ -89728,7 +90757,7 @@ async function startAnnotateServer(options) {
               targetPath = capability.enabled ? capability.path : initialSingleFileSourcePath;
             } else if (mode === "annotate-folder" && folderPath && typeof body3.path === "string") {
               targetPath = body3.allowMissingBase ? resolveFolderSourceFileForSave(body3.path, folderPath) : resolveFolderSourceFile(body3.path, folderPath);
-              if (body3.allowMissingBase && targetPath && !existsSync18(targetPath) && !openedSourceFilePaths.has(targetPath)) {
+              if (body3.allowMissingBase && targetPath && !existsSync19(targetPath) && !openedSourceFilePaths.has(targetPath)) {
                 targetPath = null;
               }
             }
@@ -90439,7 +91468,7 @@ function parseDiffMetadataPathLines(lines) {
 }
 
 // ../../packages/shared/review-workspace-node.ts
-import { existsSync as existsSync19, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync5 } from "fs";
 import { basename as basename7, relative as relative9, resolve as resolve10 } from "path";
 function normalizeWorkspacePath(path4) {
   return path4.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -90543,12 +91572,12 @@ function resolveWorkspaceFilePath(repos, prefixedPath) {
   return null;
 }
 function hasVcsMarker(dirPath) {
-  return VCS_MARKERS.some((marker) => existsSync19(resolve10(dirPath, marker)));
+  return VCS_MARKERS.some((marker) => existsSync20(resolve10(dirPath, marker)));
 }
 function collectWorkspaceRepos(root3, current, results) {
   let entries;
   try {
-    entries = readdirSync4(current, { withFileTypes: true });
+    entries = readdirSync5(current, { withFileTypes: true });
   } catch {
     return;
   }
@@ -90559,7 +91588,7 @@ function collectWorkspaceRepos(root3, current, results) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (SKIP_DIRS.has(entry.name))
+    if (SKIP_DIRS2.has(entry.name))
       continue;
     collectWorkspaceRepos(root3, resolve10(current, entry.name), results);
   }
@@ -90607,10 +91636,10 @@ function aggregateWorkspacePatch(repos) {
     errors: repos.flatMap((repo) => repo.error ? [`${repo.label}: ${repo.error}`] : [])
   };
 }
-var SKIP_DIRS, VCS_MARKERS;
+var SKIP_DIRS2, VCS_MARKERS;
 var init_review_workspace_node = __esm(() => {
   init_review_core();
-  SKIP_DIRS = new Set([
+  SKIP_DIRS2 = new Set([
     ".git",
     ".jj",
     "node_modules",
@@ -90951,7 +91980,7 @@ __export(exports_commands, {
   handleAnnotateLastCommand: () => handleAnnotateLastCommand,
   handleAnnotateCommand: () => handleAnnotateCommand
 });
-import { statSync as statSync9 } from "fs";
+import { statSync as statSync10 } from "fs";
 import path4 from "path";
 async function handleReviewCommand(event, deps) {
   const { client: client3, reviewHtmlContent, getSharingEnabled, getShareBaseUrl, directory } = deps;
@@ -91107,7 +92136,7 @@ async function handleAnnotateCommand(event, deps) {
     const projectRoot = agentCwd;
     const resolvedArg = resolveUserPath(filePath, projectRoot);
     try {
-      isFolder = statSync9(resolvedArg).isDirectory();
+      isFolder = statSync10(resolvedArg).isDirectory();
     } catch {}
     if (isFolder) {
       if (!hasMarkdownFiles(resolvedArg, FILE_BROWSER_EXCLUDED, /\.(mdx?|txt|html?)$/i)) {
@@ -91121,7 +92150,7 @@ async function handleAnnotateCommand(event, deps) {
       client3.app.log({ level: "info", message: `Opening annotation UI for folder ${resolvedArg}...` });
     } else if (/\.html?$/i.test(resolvedArg)) {
       try {
-        statSync9(resolvedArg);
+        statSync10(resolvedArg);
       } catch {
         client3.app.log({ level: "error", message: `File not found: ${filePath}` });
         return;