@calltelemetry/openclaw-linear 0.7.1 → 0.8.1

package/src/pipeline/pipeline.ts

@@ -60,15 +60,15 @@ interface PromptTemplates {
 
 const DEFAULT_PROMPTS: PromptTemplates = {
   worker: {
-    system: "You are implementing a Linear issue. Post an implementation summary as a Linear comment when done. DO NOT mark the issue as Done.",
-    task: "Implement issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}",
+    system: "You are a coding worker implementing a Linear issue. Your ONLY job is to write code and return a text summary. Do NOT attempt to update, close, comment on, or modify the Linear issue. Do NOT mark the issue as Done.",
+    task: "Implement issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}\n\nImplement the solution, run tests, commit your work, and return a text summary.",
   },
   audit: {
     system: "You are an independent auditor. The Linear issue body is the SOURCE OF TRUTH. Worker comments are secondary evidence.",
     task: 'Audit issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}\n\nReturn JSON verdict: {"pass": true/false, "criteria": [...], "gaps": [...], "testResults": "..."}',
   },
   rework: {
-    addendum: "PREVIOUS AUDIT FAILED (attempt {{attempt}}). Gaps:\n{{gaps}}\n\nAddress these specific issues.",
+    addendum: "PREVIOUS AUDIT FAILED (attempt {{attempt}}). Gaps:\n{{gaps}}\n\nAddress these specific issues. Preserve correct code from prior attempts.",
   },
 };
 
@@ -88,12 +88,11 @@ function mergePromptLayers(base: PromptTemplates, overlay: Partial<PromptTemplat
 }
 
 /**
- * Load global prompts (layers 1+2: hardcoded defaults + global promptsPath override).
- * Cached after first load.
+ * Load and parse the raw prompts YAML file (global promptsPath or sidecar).
+ * Returns the parsed object, or null if no file found.
+ * Shared by both pipeline and planner prompt loaders.
  */
-function loadGlobalPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
-  if (_cachedGlobalPrompts) return _cachedGlobalPrompts;
-
+export function loadRawPromptYaml(pluginConfig?: Record<string, unknown>): Record<string, any> | null {
   try {
     const customPath = pluginConfig?.promptsPath as string | undefined;
     let raw: string;
@@ -108,9 +107,23 @@ function loadGlobalPrompts(pluginConfig?: Record<string, unknown>): PromptTempla
       raw = readFileSync(join(pluginRoot, "prompts.yaml"), "utf-8");
     }
 
-    const parsed = parseYaml(raw) as Partial<PromptTemplates>;
-    _cachedGlobalPrompts = mergePromptLayers(DEFAULT_PROMPTS, parsed);
+    return parseYaml(raw) as Record<string, any>;
   } catch {
+    return null;
+  }
+}
+
+/**
+ * Load global prompts (layers 1+2: hardcoded defaults + global promptsPath override).
+ * Cached after first load.
+ */
+function loadGlobalPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
+  if (_cachedGlobalPrompts) return _cachedGlobalPrompts;
+
+  const parsed = loadRawPromptYaml(pluginConfig);
+  if (parsed) {
+    _cachedGlobalPrompts = mergePromptLayers(DEFAULT_PROMPTS, parsed as Partial<PromptTemplates>);
+  } else {
     _cachedGlobalPrompts = DEFAULT_PROMPTS;
   }
 
@@ -188,7 +201,7 @@ export function buildWorkerTask(
     worktreePath,
     tier: "",
     attempt: String(opts?.attempt ?? 0),
-    gaps: opts?.gaps?.join("\n- ") ?? "",
+    gaps: opts?.gaps?.length ? "- " + opts.gaps.join("\n- ") : "",
   };
 
   let task = renderTemplate(prompts.worker.task, vars);
@@ -332,7 +345,12 @@ export async function triggerAudit(
   };
 
   // Build audit prompt from YAML templates
-  const auditPrompt = buildAuditTask(issue, dispatch.worktreePath, pluginConfig);
+  // For multi-repo dispatches, render worktreePath as a list of repo→path mappings
+  const effectiveAuditPath = dispatch.worktrees
+    ? dispatch.worktrees.map(w => `${w.repoName}: ${w.path}`).join("\n")
+    : dispatch.worktreePath;
+
+  const auditPrompt = buildAuditTask(issue, effectiveAuditPath, pluginConfig);
 
   // Set Linear label
   await linearApi.emitActivity(dispatch.agentSessionId ?? "", {
@@ -444,6 +462,11 @@ export async function processVerdict(
   const verdict = parseVerdict(auditOutput);
   if (!verdict) {
     api.logger.warn(`${TAG} could not parse audit verdict from output (${auditOutput.length} chars)`);
+    // Post comment so user knows what happened
+    await linearApi.createComment(
+      dispatch.issueId,
+      `## Audit Inconclusive\n\nThe auditor's response couldn't be parsed as a verdict. **Retrying automatically** — this usually resolves itself.\n\n**If it keeps happening:** \`openclaw openclaw-linear prompts validate\`\n\n**Status:** Retrying audit now. No action needed.`,
+    ).catch((err) => api.logger.error(`${TAG} failed to post inconclusive comment: ${err}`));
     // Treat unparseable verdict as failure
     await handleAuditFail(hookCtx, dispatch, {
       pass: false,
@@ -527,7 +550,7 @@ async function handleAuditPass(
   const summaryExcerpt = summary ? `\n\n**Summary:**\n${summary.slice(0, 2000)}` : "";
   await linearApi.createComment(
     dispatch.issueId,
-    `## Audit Passed\n\n**Criteria verified:**\n${criteriaList}\n\n**Tests:** ${verdict.testResults || "N/A"}${summaryExcerpt}\n\n---\n*Attempt ${dispatch.attempt + 1} — audit passed. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+    `## Done\n\nThis issue has been implemented and verified.\n\n**What was checked:**\n${criteriaList}\n\n**Test results:** ${verdict.testResults || "N/A"}${summaryExcerpt}\n\n---\n*Completed on attempt ${dispatch.attempt + 1}.*\n\n**Next steps:**\n- Review the code: \`cd ${dispatch.worktreePath}\`\n- View artifacts: \`ls ${dispatch.worktreePath}/.claw/\`\n- Create a PR from the worktree branch if one wasn't opened automatically`,
   ).catch((err) => api.logger.error(`${TAG} failed to post audit pass comment: ${err}`));
 
   api.logger.info(`${TAG} audit PASSED — dispatch completed (attempt ${dispatch.attempt})`);
@@ -603,7 +626,7 @@ async function handleAuditFail(
     const gapsList = verdict.gaps.map((g) => `- ${g}`).join("\n");
     await linearApi.createComment(
       dispatch.issueId,
-      `## Audit Failed — Escalating\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}**\n\n**Gaps:**\n${gapsList}\n\n**Tests:** ${verdict.testResults || "N/A"}\n\n---\n*Max rework attempts reached. Needs human review. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+      `## Needs Your Help\n\nAll ${nextAttempt} attempts failed. The agent couldn't resolve these issues on its own.\n\n**What went wrong:**\n${gapsList}\n\n**Test results:** ${verdict.testResults || "N/A"}\n\n---\n\n**What you can do:**\n1. **Clarify requirements** — update the issue body with more detail, then re-assign to try again\n2. **Fix it manually** — the agent's work is in the worktree: \`cd ${dispatch.worktreePath}\`\n3. **Force retry** — \`/dispatch retry ${dispatch.issueIdentifier}\`\n4. **View logs** — worker output: \`.claw/worker-*.md\`, audit verdicts: \`.claw/audit-*.json\``,
     ).catch((err) => api.logger.error(`${TAG} failed to post escalation comment: ${err}`));
 
     api.logger.warn(`${TAG} audit FAILED ${nextAttempt}x — escalating to human`);
@@ -647,7 +670,7 @@ async function handleAuditFail(
   const gapsList = verdict.gaps.map((g) => `- ${g}`).join("\n");
   await linearApi.createComment(
     dispatch.issueId,
-    `## Audit Failed — Rework\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}**\n\n**Gaps:**\n${gapsList}\n\n**Tests:** ${verdict.testResults || "N/A"}\n\n---\n*Reworking: addressing gaps above.*`,
+    `## Needs More Work\n\nThe audit found gaps. **Retrying now** — the worker gets the feedback below as context.\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}** — ${maxAttempts + 1 - nextAttempt > 0 ? `${maxAttempts + 1 - nextAttempt} more ${maxAttempts + 1 - nextAttempt === 1 ? "retry" : "retries"} if this fails too` : "this is the last attempt"}.\n\n**What needs fixing:**\n${gapsList}\n\n**Test results:** ${verdict.testResults || "N/A"}\n\n**Status:** Worker is restarting with the gaps above as context. No action needed unless all retries fail.`,
   ).catch((err) => api.logger.error(`${TAG} failed to post rework comment: ${err}`));
 
   api.logger.info(`${TAG} audit FAILED — rework attempt ${nextAttempt}/${maxAttempts + 1}`);
@@ -716,7 +739,12 @@ export async function spawnWorker(
   };
 
   // Build worker prompt from YAML templates
-  const workerPrompt = buildWorkerTask(issue, dispatch.worktreePath, {
+  // For multi-repo dispatches, render worktreePath as a list of repo→path mappings
+  const effectiveWorkerPath = dispatch.worktrees
+    ? dispatch.worktrees.map(w => `${w.repoName}: ${w.path}`).join("\n")
+    : dispatch.worktreePath;
+
+  const workerPrompt = buildWorkerTask(issue, effectiveWorkerPath, {
     attempt: dispatch.attempt,
     gaps: opts?.gaps,
     pluginConfig,
@@ -798,8 +826,9 @@ export async function spawnWorker(
 
     await linearApi.createComment(
       dispatch.issueId,
-      `## Watchdog Kill\n\nAgent killed by inactivity watchdog (no I/O for ${thresholdSec}s). ` +
-      `Automatic retry also failed.\n\n---\n*Needs human review. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+      `## Agent Timed Out\n\nThe agent stopped responding for over ${thresholdSec}s. It was automatically restarted, but the retry also timed out.\n\n` +
+      `**What you can do:**\n1. **Try again** — re-assign this issue or \`/dispatch retry ${dispatch.issueIdentifier}\`\n2. **Break it down** — if it keeps timing out, split into smaller issues\n3. **Increase timeout** — set \`inactivitySec\` higher in your agent profile\n\n` +
+      `**Logs:** \`${dispatch.worktreePath}/.claw/log.jsonl\` (look for \`"phase": "watchdog"\`)\n\n**Current status:** Stuck — waiting for you.`,
     ).catch(() => {});
 
     await hookCtx.notify("watchdog_kill", {

package/src/pipeline/planner.test.ts

@@ -16,6 +16,17 @@ vi.mock("../api/linear-api.js", () => ({}));
 
 vi.mock("openclaw/plugin-sdk", () => ({}));
 
+// Mock CLI tool runners for cross-model review
+vi.mock("../tools/claude-tool.js", () => ({
+  runClaude: vi.fn().mockResolvedValue({ success: true, output: "Claude review feedback" }),
+}));
+vi.mock("../tools/codex-tool.js", () => ({
+  runCodex: vi.fn().mockResolvedValue({ success: true, output: "Codex review feedback" }),
+}));
+vi.mock("../tools/gemini-tool.js", () => ({
+  runGemini: vi.fn().mockResolvedValue({ success: true, output: "Gemini review feedback" }),
+}));
+
 const mockLinearApi = {
   getProject: vi.fn().mockResolvedValue({
     id: "proj-1",
@@ -61,7 +72,13 @@ vi.mock("../tools/planner-tools.js", () => ({
 // Imports (AFTER mocks)
 // ---------------------------------------------------------------------------
 
-import { initiatePlanningSession, handlePlannerTurn, runPlanAudit } from "./planner.js";
+import {
+  initiatePlanningSession,
+  handlePlannerTurn,
+  runPlanAudit,
+  runCrossModelReview,
+  resolveReviewModel,
+} from "./planner.js";
 import {
   registerPlanningSession,
   updatePlanningSession,
@@ -73,6 +90,9 @@ import {
   clearActivePlannerContext,
   auditPlan,
 } from "../tools/planner-tools.js";
+import { runClaude } from "../tools/claude-tool.js";
+import { runCodex } from "../tools/codex-tool.js";
+import { runGemini } from "../tools/gemini-tool.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -230,47 +250,31 @@ describe("handlePlannerTurn", () => {
     );
   });
 
-  it("detects finalize plan intent and triggers audit instead of regular turn", async () => {
-    const ctx = createCtx();
-    const session = createSession();
-
-    await handlePlannerTurn(ctx, session, {
-      issueId: "issue-1",
-      commentBody: "finalize plan",
-      commentorName: "Tester",
-    });
+  // Note: finalize/abandon intent detection has moved to webhook.ts via
+  // intent-classify.ts. handlePlannerTurn is now a pure "continue planning"
+  // function that always runs the agent.
+});
 
-    // Audit path: auditPlan is called, runAgent is NOT called
-    expect(auditPlan).toHaveBeenCalled();
-    expect(runAgentMock).not.toHaveBeenCalled();
-  });
+// ---------------------------------------------------------------------------
+// runPlanAudit
+// ---------------------------------------------------------------------------
 
-  it("detects abandon intent and ends session as abandoned", async () => {
+describe("runPlanAudit", () => {
+  it("transitions to plan_review on passing audit", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
     const ctx = createCtx();
     const session = createSession();
 
-    await handlePlannerTurn(ctx, session, {
-      issueId: "issue-1",
-      commentBody: "abandon",
-      commentorName: "Tester",
-    });
+    await runPlanAudit(ctx, session);
 
-    expect(endPlanningSession).toHaveBeenCalledWith(
+    expect(updatePlanningSession).toHaveBeenCalledWith(
       "proj-1",
-      "abandoned",
+      { status: "plan_review" },
       undefined,
     );
-    // Should NOT run the agent
-    expect(runAgentMock).not.toHaveBeenCalled();
   });
-});
-
-// ---------------------------------------------------------------------------
-// runPlanAudit
-// ---------------------------------------------------------------------------
 
-describe("runPlanAudit", () => {
-  it("posts success comment on passing audit", async () => {
+  it("posts 'Passed Checks' comment on passing audit", async () => {
     vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
     const ctx = createCtx();
     const session = createSession();
@@ -279,24 +283,46 @@ describe("runPlanAudit", () => {
 
     expect(mockLinearApi.createComment).toHaveBeenCalledWith(
       "issue-1",
-      expect.stringContaining("Approved"),
+      expect.stringContaining("Plan Passed Checks"),
     );
   });
 
-  it("ends session as approved on pass", async () => {
+  it("runs cross-model review automatically on passing audit", async () => {
     vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
     const ctx = createCtx();
     const session = createSession();
 
     await runPlanAudit(ctx, session);
 
-    expect(endPlanningSession).toHaveBeenCalledWith(
-      "proj-1",
-      "approved",
-      undefined,
+    // Default review model is "gemini" (since no primary model configured)
+    expect(runGemini).toHaveBeenCalled();
+  });
+
+  it("runs planner agent with review prompt including cross-model feedback", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    // Agent should run with a review prompt
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("Plan Review"),
+      }),
     );
   });
 
+  it("does NOT end session as approved on passing audit (waits for user approval)", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(endPlanningSession).not.toHaveBeenCalled();
+  });
+
   it("posts problems on failing audit", async () => {
     vi.mocked(auditPlan).mockReturnValue({
       pass: false,
@@ -314,7 +340,7 @@ describe("runPlanAudit", () => {
     );
   });
 
-  it("does NOT end session as approved on fail", async () => {
+  it("does NOT transition to plan_review on failing audit", async () => {
     vi.mocked(auditPlan).mockReturnValue({
       pass: false,
       problems: ["No estimates"],
@@ -325,10 +351,103 @@ describe("runPlanAudit", () => {
 
     await runPlanAudit(ctx, session);
 
-    expect(endPlanningSession).not.toHaveBeenCalledWith(
+    expect(updatePlanningSession).not.toHaveBeenCalledWith(
       "proj-1",
-      "approved",
+      { status: "plan_review" },
       expect.anything(),
     );
   });
+
+  it("includes warnings in success comment when present", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: true,
+      problems: [],
+      warnings: ["PROJ-3 has no acceptance criteria"],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("PROJ-3 has no acceptance criteria"),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveReviewModel
+// ---------------------------------------------------------------------------
+
+describe("resolveReviewModel", () => {
+  it("returns 'codex' when primary model is claude-based", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "anthropic/claude-sonnet-4" } } },
+    } as any)).toBe("codex");
+  });
+
+  it("returns 'gemini' when primary model is codex-based", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "openai/codex-3" } } },
+    } as any)).toBe("gemini");
+  });
+
+  it("returns 'codex' when primary model is gemini-based", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "google/gemini-2" } } },
+    } as any)).toBe("codex");
+  });
+
+  it("returns 'gemini' when no primary model configured", () => {
+    expect(resolveReviewModel({})).toBe("gemini");
+  });
+
+  it("respects explicit plannerReviewModel config override", () => {
+    expect(resolveReviewModel({
+      plannerReviewModel: "gemini",
+      agents: { defaults: { model: { primary: "anthropic/claude-sonnet-4" } } },
+    } as any)).toBe("gemini");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runCrossModelReview
+// ---------------------------------------------------------------------------
+
+describe("runCrossModelReview", () => {
+  it("calls the correct CLI runner for the specified model", async () => {
+    const api = createApi();
+
+    await runCrossModelReview(api, "claude", "test snapshot");
+    expect(runClaude).toHaveBeenCalled();
+
+    vi.clearAllMocks();
+    await runCrossModelReview(api, "codex", "test snapshot");
+    expect(runCodex).toHaveBeenCalled();
+
+    vi.clearAllMocks();
+    await runCrossModelReview(api, "gemini", "test snapshot");
+    expect(runGemini).toHaveBeenCalled();
+  });
+
+  it("returns review output on success", async () => {
+    const api = createApi();
+    const result = await runCrossModelReview(api, "claude", "test snapshot");
+    expect(result).toBe("Claude review feedback");
+  });
+
+  it("returns graceful fallback on failure", async () => {
+    vi.mocked(runClaude).mockResolvedValueOnce({ success: false, error: "timeout" } as any);
+    const api = createApi();
+    const result = await runCrossModelReview(api, "claude", "test snapshot");
+    expect(result).toContain("review failed");
+  });
+
+  it("returns graceful fallback on exception", async () => {
+    vi.mocked(runClaude).mockRejectedValueOnce(new Error("network error"));
+    const api = createApi();
+    const result = await runCrossModelReview(api, "claude", "test snapshot");
+    expect(result).toContain("review unavailable");
+  });
 });

package/src/pipeline/planner.ts

@@ -6,11 +6,8 @@
  * - handlePlannerTurn: processes each user comment during planning
  * - runPlanAudit: validates the plan before finalizing
  */
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parseYaml } from "yaml";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { loadRawPromptYaml } from "./pipeline.js";
 import type { LinearAgentApi } from "../api/linear-api.js";
 import { runAgent } from "../agent/agent.js";
 import {
@@ -26,6 +23,9 @@ import {
   buildPlanSnapshot,
   auditPlan,
 } from "../tools/planner-tools.js";
+import { runClaude } from "../tools/claude-tool.js";
+import { runCodex } from "../tools/codex-tool.js";
+import { runGemini } from "../tools/gemini-tool.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -42,6 +42,7 @@ interface PlannerPrompts {
   interview: string;
   audit_prompt: string;
   welcome: string;
+  review: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -54,32 +55,19 @@ function loadPlannerPrompts(pluginConfig?: Record<string, unknown>): PlannerProm
     interview: "Project: {{projectName}}\n\nPlan:\n{{planSnapshot}}\n\nUser said: {{userMessage}}\n\nContinue planning.",
     audit_prompt: "Run audit_plan for {{projectName}}.",
     welcome: "Entering planning mode for **{{projectName}}**. What are the main feature areas?",
+    review: "Plan for {{projectName}} passed checks. {{reviewModel}} recommends:\n{{crossModelFeedback}}\n\nReview and suggest changes, then invite the user to approve.",
   };
 
-  try {
-    const customPath = pluginConfig?.promptsPath as string | undefined;
-    let raw: string;
-
-    if (customPath) {
-      const resolved = customPath.startsWith("~")
-        ? customPath.replace("~", process.env.HOME ?? "")
-        : customPath;
-      raw = readFileSync(resolved, "utf-8");
-    } else {
-      const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
-      raw = readFileSync(join(pluginRoot, "prompts.yaml"), "utf-8");
-    }
-
-    const parsed = parseYaml(raw) as any;
-    if (parsed?.planner) {
-      return {
-        system: parsed.planner.system ?? defaults.system,
-        interview: parsed.planner.interview ?? defaults.interview,
-        audit_prompt: parsed.planner.audit_prompt ?? defaults.audit_prompt,
-        welcome: parsed.planner.welcome ?? defaults.welcome,
-      };
-    }
-  } catch { /* use defaults */ }
+  const parsed = loadRawPromptYaml(pluginConfig);
+  if (parsed?.planner) {
+    return {
+      system: parsed.planner.system ?? defaults.system,
+      interview: parsed.planner.interview ?? defaults.interview,
+      audit_prompt: parsed.planner.audit_prompt ?? defaults.audit_prompt,
+      welcome: parsed.planner.welcome ?? defaults.welcome,
+      review: parsed.planner.review ?? defaults.review,
+    };
+  }
 
   return defaults;
 }
@@ -142,35 +130,19 @@ export async function initiatePlanningSession(
 // Interview turn
 // ---------------------------------------------------------------------------
 
-const FINALIZE_PATTERN = /\b(finalize\s+plan|finalize|done\s+planning|approve\s+plan|plan\s+looks\s+good)\b/i;
-const ABANDON_PATTERN = /\b(abandon|cancel\s+planning|stop\s+planning|exit\s+planning)\b/i;
-
+/**
+ * Handle a planning conversation turn. Intent detection (finalize/abandon)
+ * is handled by the webhook via intent-classify.ts before calling this function.
+ * This is a pure "continue planning" function.
+ */
 export async function handlePlannerTurn(
   ctx: PlannerContext,
   session: PlanningSession,
   input: { issueId: string; commentBody: string; commentorName: string },
-  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
 
-  // Detect finalization intent
-  if (FINALIZE_PATTERN.test(input.commentBody)) {
-    await runPlanAudit(ctx, session, { onApproved: opts?.onApproved });
-    return;
-  }
-
-  // Detect abandon intent
-  if (ABANDON_PATTERN.test(input.commentBody)) {
-    await endPlanningSession(session.projectId, "abandoned", configPath);
-    await linearApi.createComment(
-      session.rootIssueId,
-      `Planning mode ended for **${session.projectName}**. Session abandoned.`,
-    );
-    api.logger.info(`Planning: session abandoned for ${session.projectName}`);
-    return;
-  }
-
   // Increment turn count
   const newTurnCount = session.turnCount + 1;
   await updatePlanningSession(session.projectId, { turnCount: newTurnCount }, configPath);
@@ -204,6 +176,8 @@ export async function handlePlannerTurn(
     linearApi,
     projectId: session.projectId,
     teamId: session.teamId,
+    api,
+    pluginConfig,
   });
 
   try {
@@ -235,7 +209,6 @@ export async function handlePlannerTurn(
 export async function runPlanAudit(
   ctx: PlannerContext,
   session: PlanningSession,
-  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
@@ -247,26 +220,63 @@ export async function runPlanAudit(
   const result = auditPlan(issues);
 
   if (result.pass) {
-    // Build final summary
+    // Transition to plan_review (not approved yet — cross-model review first)
+    await updatePlanningSession(session.projectId, { status: "plan_review" }, configPath);
+
     const snapshot = buildPlanSnapshot(issues);
     const warningsList = result.warnings.length > 0
       ? `\n\n**Warnings:**\n${result.warnings.map((w) => `- ${w}`).join("\n")}`
       : "";
 
+    // Determine review model and post "running review" message
+    const reviewModel = resolveReviewModel(pluginConfig);
+    const reviewModelName = reviewModel.charAt(0).toUpperCase() + reviewModel.slice(1);
+
     await linearApi.createComment(
       session.rootIssueId,
-      `## Plan Approved\n\n` +
-      `The plan for **${session.projectName}** passed all checks.\n\n` +
-      `**${issues.length} issues** created with valid dependency graph.${warningsList}\n\n` +
-      `### Final Plan\n${snapshot}\n\n` +
-      `---\n*Planning mode complete. Project is ready for implementation dispatch.*`,
+      `## Plan Passed Checks\n\n` +
+      `**${issues.length} issues** with valid dependency graph.${warningsList}\n\n` +
+      `Let me have **${reviewModelName}** audit this and make recommendations.`,
     );
 
-    await endPlanningSession(session.projectId, "approved", configPath);
-    api.logger.info(`Planning: session approved for ${session.projectName}`);
+    // Run cross-model review
+    const crossReview = await runCrossModelReview(api, reviewModel, snapshot, pluginConfig);
+
+    // Run planner agent with review prompt + cross-model feedback
+    const prompts = loadPlannerPrompts(pluginConfig);
+    const reviewPrompt = renderTemplate(prompts.review, {
+      projectName: session.projectName,
+      planSnapshot: snapshot,
+      issueCount: String(issues.length),
+      reviewModel: reviewModelName,
+      crossModelFeedback: crossReview,
+    });
+
+    const agentId = (pluginConfig?.defaultAgentId as string) ?? "default";
+
+    setActivePlannerContext({
+      linearApi,
+      projectId: session.projectId,
+      teamId: session.teamId,
+      api,
+      pluginConfig,
+    });
 
-    // Trigger DAG-based dispatch if callback provided
-    opts?.onApproved?.(session.projectId);
+    try {
+      const agentResult = await runAgent({
+        api,
+        agentId,
+        sessionId: `planner-${session.rootIdentifier}-review`,
+        message: `${prompts.system}\n\n${reviewPrompt}`,
+      });
+      if (agentResult.output) {
+        await linearApi.createComment(session.rootIssueId, agentResult.output);
+      }
+    } finally {
+      clearActivePlannerContext();
+    }
+
+    api.logger.info(`Planning: entered plan_review for ${session.projectName} (reviewed by ${reviewModelName})`);
   } else {
     // Post problems and keep planning
     const problemsList = result.problems.map((p) => `- ${p}`).join("\n");
@@ -285,3 +295,41 @@ export async function runPlanAudit(
     api.logger.info(`Planning: audit failed for ${session.projectName} (${result.problems.length} problems)`);
   }
 }
+
+// ---------------------------------------------------------------------------
+// Cross-model review
+// ---------------------------------------------------------------------------
+
+export async function runCrossModelReview(
+  api: OpenClawPluginApi,
+  model: "claude" | "codex" | "gemini",
+  planSnapshot: string,
+  pluginConfig?: Record<string, unknown>,
+): Promise<string> {
+  const prompt = `You are reviewing a project plan. Analyze it and suggest specific improvements.\n\n${planSnapshot}\n\nFocus on: missing acceptance criteria, dependency gaps, estimation accuracy, testability, and edge cases. Reference specific issue identifiers. Be concise and actionable.`;
+
+  try {
+    const runner = model === "claude" ? runClaude
+      : model === "codex" ? runCodex
+      : runGemini;
+    const result = await runner(api, { prompt } as any, pluginConfig);
+    return result.success ? (result.output ?? "(no feedback)") : `(${model} review failed: ${result.error})`;
+  } catch (err) {
+    api.logger.warn(`Cross-model review failed: ${err}`);
+    return "(cross-model review unavailable)";
+  }
+}
+
+export function resolveReviewModel(pluginConfig?: Record<string, unknown>): "claude" | "codex" | "gemini" {
+  // User override in config
+  const configured = (pluginConfig as any)?.plannerReviewModel as string | undefined;
+  if (configured && ["claude", "codex", "gemini"].includes(configured)) {
+    return configured as "claude" | "codex" | "gemini";
+  }
+  // Always the complement of the user's primary model
+  const currentModel = (pluginConfig as any)?.agents?.defaults?.model?.primary as string ?? "";
+  if (currentModel.includes("claude") || currentModel.includes("anthropic")) return "codex";
+  if (currentModel.includes("codex") || currentModel.includes("openai")) return "gemini";
+  if (currentModel.includes("gemini") || currentModel.includes("google")) return "codex";
+  return "gemini"; // Kimi, Mistral, other, or unconfigured → Gemini reviews
+}