@mhingston5/lasso 0.1.0

package/src/planner/template-rules.ts

@@ -0,0 +1,183 @@
+import type { ExtractionResult, WorkflowTemplate } from "./types.js";
+
+export function classifyTemplate(brief: string): WorkflowTemplate {
+  const lower = brief.toLowerCase();
+  
+  // Strong PR-specific indicators (without overlap)
+  const prIndicators = [
+    "pull request",
+    "pr review",
+    "pr merge",
+    "review the pr",
+    "merge the pr",
+    " pr ",
+    "source branch",
+    "target branch"
+  ];
+  
+  // Strong patch-specific indicators
+  const patchIndicators = [
+    "patch validation",
+    ".patch",
+    ".diff",
+    "baseline",
+    "reproduce"
+  ];
+  
+  const hasPrSignals = prIndicators.some(indicator => lower.includes(indicator));
+  const hasPatchSignals = patchIndicators.some(indicator => lower.includes(indicator));
+  
+  // If both or neither, it's ambiguous
+  if (hasPrSignals && hasPatchSignals) {
+    return "ambiguous";
+  }
+  
+  if (hasPrSignals) {
+    return "pr-review-merge";
+  }
+  
+  if (hasPatchSignals) {
+    return "patch-validation";
+  }
+  
+  // If no strong signals, it's a custom workflow
+  return "custom";
+}
+
+export function extractFields(brief: string): ExtractionResult {
+  const template = classifyTemplate(brief);
+  const result: ExtractionResult = { template };
+  
+  // Extract repo path
+  result.repoPath = extractRepoPath(brief);
+  
+  if (template === "pr-review-merge") {
+    result.sourceBranch = extractField(brief, ["source branch", "sourceBranch", "source:", "from branch"]);
+    result.targetBranch = extractField(brief, ["target branch", "targetBranch", "target:", "to branch", "into branch"]);
+    result.verificationCommands = extractCommands(brief, ["verification", "verify", "test"]);
+    result.reviewInstructions = extractReviewInstructions(brief);
+  } else if (template === "patch-validation") {
+    result.baselineRef = extractField(brief, ["baseline", "baselineRef", "base:", "baseline:"]);
+    result.candidateBranch = extractField(brief, ["candidate branch", "candidateBranch", "candidate:", "fix branch"]);
+    result.patchFilePath = extractPatchFile(brief);
+    result.reproduceCommands = extractCommands(brief, ["reproduce", "repro"]);
+    result.verificationCommands = extractCommands(brief, ["verification", "verify", "test"]);
+    result.reviewInstructions = extractReviewInstructions(brief);
+    result.approvalRequired = extractApprovalFlag(brief);
+  }
+  
+  return result;
+}
+
+function extractRepoPath(brief: string): string | undefined {
+  // Look for explicit repo path patterns
+  const patterns = [
+    /repoPath:\s*["']?([^"'\s\n]+)["']?/i,
+    /repo:\s*["']?([^"'\s\n]+)["']?/i,
+    /repository:\s*["']?([^"'\s\n]+)["']?/i,
+    /path:\s*["']?([A-Za-z]:[\\/][^"'\s\n]+|\/[^"'\s\n]+)["']?/i
+  ];
+  
+  for (const pattern of patterns) {
+    const match = brief.match(pattern);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  
+  return undefined;
+}
+
+function extractField(brief: string, keywords: string[]): string | undefined {
+  for (const keyword of keywords) {
+    const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const separatorPattern = keyword.endsWith(":") ? "\\s*" : "\\s*[:\\s]+";
+    const pattern = new RegExp(`${escapedKeyword}${separatorPattern}["']?([^"'\\s\\n,;]+)["']?`, "i");
+    const match = brief.match(pattern);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  return undefined;
+}
+
+function extractPatchFile(brief: string): string | undefined {
+  // Look for .patch or .diff file mentions
+  const patchPattern = /["']?([^\s"']+\.(?:patch|diff))["']?/i;
+  const match = brief.match(patchPattern);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return undefined;
+}
+
+function extractCommands(brief: string, keywords: string[]): string[] | undefined {
+  const commandsSet = new Set<string>();
+  
+  for (const keyword of keywords) {
+    const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Look for commands after keyword with various formats
+    const patterns = [
+      new RegExp(`${escapedKeyword}\\s+commands?:\\s*\\[([^\\]]+)\\]`, "i"),
+      new RegExp(`${escapedKeyword}\\s+commands?:\\s*["']([^"']+)["']`, "i"),
+      new RegExp(`${escapedKeyword}:\\s*\\[([^\\]]+)\\]`, "i")
+    ];
+    
+    for (const pattern of patterns) {
+      const match = brief.match(pattern);
+      if (match && match[1]) {
+        const cmdList = match[1]
+          .split(/,\s*/)
+          .map(cmd => cmd.trim().replace(/^["']|["']$/g, ''))
+          .filter(cmd => cmd.length > 0);
+        cmdList.forEach(cmd => commandsSet.add(cmd));
+      }
+    }
+  }
+  
+  const commands = Array.from(commandsSet);
+  return commands.length > 0 ? commands : undefined;
+}
+
+function extractReviewInstructions(brief: string): string | undefined {
+  const patterns = [
+    /reviewInstructions:\s*["']([^"']+)["']/i,
+    /review instructions:\s*["']([^"']+)["']/i,
+    /instructions:\s*["']([^"']+)["']/i
+  ];
+  
+  for (const pattern of patterns) {
+    const match = brief.match(pattern);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  
+  // If not explicitly provided, use a generic fallback only if we have other fields
+  return undefined;
+}
+
+function extractApprovalFlag(brief: string): boolean | undefined {
+  const lower = brief.toLowerCase();
+  
+  // Explicit approval signals (case insensitive)
+  if (
+    lower.includes("approval required") || 
+    lower.includes("approvalrequired: true") || 
+    lower.includes("needs approval")
+  ) {
+    return true;
+  }
+  
+  // Explicit no-approval signals
+  if (
+    lower.includes("no approval") || 
+    lower.includes("approvalrequired: false") || 
+    lower.includes("auto approve")
+  ) {
+    return false;
+  }
+  
+  // Default: undefined (let synthesize determine based on template)
+  return undefined;
+}

package/src/planner/types.ts

@@ -0,0 +1,42 @@
+import type { ReferenceWorkflowRequest } from "../reference/catalog.js";
+import type { parsePromptOrSkill } from "../synthesis/skill-parser.js";
+import type { buildTaskGraph } from "../synthesis/graph-builder.js";
+import type { analyzeRisks } from "../synthesis/risk-analyzer.js";
+import type { synthesizePolicy } from "../synthesis/policy-builder.js";
+
+export type PlannerResult =
+  | { 
+      status: "draft_request"; 
+      workflow: string;
+      request: ReferenceWorkflowRequest;
+      rationale: string[];
+      warnings: string[];
+    }
+  | { 
+      status: "needs_clarification"; 
+      candidateWorkflow?: string;
+      reasons: string[]; 
+      missingFields: string[]; 
+      guidance: string[];
+    };
+
+export type WorkflowTemplate = "patch-validation" | "pr-review-merge" | "custom" | "ambiguous";
+
+export interface ExtractionResult {
+  template: WorkflowTemplate;
+  repoPath?: string;
+  // pr-review-merge fields
+  sourceBranch?: string;
+  targetBranch?: string;
+  // patch-validation fields
+  baselineRef?: string;
+  candidateBranch?: string;
+  patchFilePath?: string;
+  reproduceCommands?: string[];
+  verificationCommands?: string[];
+  reviewInstructions?: string;
+  approvalRequired?: boolean;
+}
+
+// Re-export synthesis types that planner users may need
+export type { parsePromptOrSkill, buildTaskGraph, analyzeRisks, synthesizePolicy };

package/src/reference/catalog.ts

@@ -0,0 +1,128 @@
+import type { HarnessSpec } from "../spec/types.js";
+import { buildPatchValidationHarnessSpec } from "./patch-validation.js";
+import { buildPrReviewMergeHarnessSpec } from "./pr-review-merge.js";
+import type { LocalCandidateSource, LocalPatchValidationBundle, LocalPrBundle } from "./types.js";
+
+export type ReferenceWorkflowRequest =
+  | { workflow: "pr-review-merge"; input: LocalPrBundle }
+  | { workflow: "patch-validation"; input: LocalPatchValidationBundle }
+  | { workflow: string; input: Record<string, unknown> };
+
+export function parseWorkflowRequest(args: string): ReferenceWorkflowRequest {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    throw new Error("Usage: /lasso:<compile|run> <workflow request JSON>");
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("Invalid workflow request JSON");
+  }
+
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Invalid workflow request shape");
+  }
+
+  const record = parsed as Record<string, unknown>;
+
+  if ("workflow" in record) {
+    const workflow = record.workflow;
+
+    if (workflow === "pr-review-merge") {
+      if (!isPrBundleInput(record.input)) {
+        throw new Error("Invalid pr-review-merge input");
+      }
+      return { workflow: "pr-review-merge", input: record.input };
+    }
+
+    if (workflow === "patch-validation") {
+      if (!isPatchValidationInput(record.input)) {
+        throw new Error("Invalid patch-validation input");
+      }
+      return { workflow: "patch-validation", input: record.input };
+    }
+
+    // Generic fallback for arbitrary workflow families
+    if (typeof workflow === "string" && workflow.trim().length > 0) {
+      const input = record.input;
+      if (!input || typeof input !== "object") {
+        throw new Error(`Invalid input for workflow: ${workflow}`);
+      }
+      return { workflow, input: input as Record<string, unknown> };
+    }
+
+    throw new Error(`Unknown workflow: ${String(workflow)}`);
+  }
+
+  // Legacy raw LocalPrBundle shorthand for pr-review-merge
+  if (isLocalPrBundle(record)) {
+    return { workflow: "pr-review-merge", input: record };
+  }
+
+  throw new Error("Invalid workflow request shape");
+}
+
+export function buildReferenceHarnessSpec(request: ReferenceWorkflowRequest): HarnessSpec {
+  if (request.workflow === "pr-review-merge") {
+    return buildPrReviewMergeHarnessSpec(request.input as LocalPrBundle);
+  }
+  if (request.workflow === "patch-validation") {
+    return buildPatchValidationHarnessSpec(request.input as LocalPatchValidationBundle);
+  }
+  // Generic fallback for custom workflows
+  const entryId = `${request.workflow}-entry`;
+  return {
+    name: request.workflow,
+    graph: {
+      entryNodeId: entryId,
+      nodes: [{
+        id: entryId,
+        label: `Execute ${request.workflow}`,
+        kind: "tool",
+        tool: "echo",
+        args: [`Running ${request.workflow} workflow`],
+      }],
+      edges: [],
+    },
+  };
+}
+
+function isLocalPrBundle(value: Record<string, unknown>): value is LocalPrBundle {
+  return (
+    typeof value.repoPath === "string"
+    && typeof value.sourceBranch === "string"
+    && typeof value.targetBranch === "string"
+    && typeof value.reviewInstructions === "string"
+    && Array.isArray(value.verificationCommands)
+    && value.verificationCommands.every(c => typeof c === "string")
+  );
+}
+
+function isPrBundleInput(value: unknown): value is LocalPrBundle {
+  if (!value || typeof value !== "object") return false;
+  return isLocalPrBundle(value as Record<string, unknown>);
+}
+
+function isPatchValidationInput(value: unknown): value is LocalPatchValidationBundle {
+  if (!value || typeof value !== "object") return false;
+  const r = value as Record<string, unknown>;
+  return (
+    typeof r.repoPath === "string"
+    && typeof r.baselineRef === "string"
+    && isCandidateSource(r.candidateSource)
+    && Array.isArray(r.reproduceCommands)
+    && r.reproduceCommands.every(c => typeof c === "string")
+    && Array.isArray(r.verificationCommands)
+    && r.verificationCommands.every(c => typeof c === "string")
+    && typeof r.reviewInstructions === "string"
+    && typeof r.approvalRequired === "boolean"
+  );
+}
+
+function isCandidateSource(value: unknown): value is LocalCandidateSource {
+  if (!value || typeof value !== "object") return false;
+  const r = value as Record<string, unknown>;
+  return typeof r.value === "string" && (r.kind === "branch" || r.kind === "patchFile");
+}

package/src/reference/patch-validation-strategies.ts

@@ -0,0 +1,170 @@
+import type { LocalCandidateSource, LocalPatchValidationBundle } from "./types.js";
+
+// ============================================================================
+// Node ID constants
+// ============================================================================
+
+export const patchValidationNodeIds = {
+  runBaseline: "run-baseline",
+  gateNotReproduced: "gate-not-reproduced",
+  applyCandidate: "apply-candidate",
+  gateApplyFailed: "gate-apply-failed",
+  runCandidateReproduce: "run-candidate-reproduce",
+  gateCandidateStillFails: "gate-candidate-still-fails",
+  runVerification: "run-verification",
+  gateCandidateVerification: "gate-candidate-verification",
+  summarise: "summarise",
+  humanApprove: "human-approve",
+  checkHumanApproval: "check-human-approval",
+  validatedFix: "validated-fix",
+  notReproduced: "not-reproduced",
+  applyFailed: "apply-failed",
+  candidateFailed: "candidate-failed",
+  rejected: "rejected",
+} as const;
+
+// ============================================================================
+// Bash tool builders
+// ============================================================================
+
+/**
+ * Runs the reproduce commands on the baseline ref.
+ * Emits { reproduced: true } when they fail (expected baseline signal)
+ * and { reproduced: false } when they unexpectedly pass on the baseline.
+ *
+ * Precondition: `bundle.baselineRef` must resolve cleanly in the repo.
+ * A checkout failure is a hard setup/precondition error — the tool exits
+ * non-zero and aborts the workflow rather than routing to a terminal node.
+ */
+export function buildBaselineReproduceTool(bundle: LocalPatchValidationBundle) {
+  const lines = [
+    `git checkout ${shellQuote(bundle.baselineRef)} >/dev/null 2>&1 || exit 1`,
+    "reproduced=true",
+    ...bundle.reproduceCommands.flatMap(cmd => [
+      `if (${cmd}) >/dev/null 2>&1; then`,
+      "  reproduced=false",
+      "fi",
+    ]),
+    `printf '%s\\n' "{\\"reproduced\\":$reproduced}"`,
+  ];
+
+  return buildBashTool(lines.join("\n"), bundle.repoPath);
+}
+
+/** Applies the candidate source (branch checkout or patch application) to the repo.
+ * Emits { applied: true } on success, { applied: false, reason: "..." } on failure.
+ */
+export function buildApplyCandidateTool(bundle: LocalPatchValidationBundle) {
+  const lines = [
+    `if ! git checkout ${shellQuote(bundle.baselineRef)} >/dev/null 2>&1; then`,
+    `  printf '%s\\n' ${shellQuote(JSON.stringify({ applied: false, reason: "baseline checkout failed" }))}`,
+    "  exit 0",
+    "fi",
+    ...buildCandidateApplicationLines(bundle.candidateSource),
+  ];
+
+  return buildBashTool(lines.join("\n"), bundle.repoPath);
+}
+
+function buildCandidateApplicationLines(source: LocalCandidateSource): string[] {
+  if (source.kind === "branch") {
+    return [
+      `if git checkout ${shellQuote(source.value)} >/dev/null 2>&1; then`,
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ applied: true }))}`,
+      "else",
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ applied: false, reason: "branch checkout failed" }))}`,
+      "fi",
+    ];
+  }
+
+  return [
+    `if git apply ${shellQuote(source.value)} >/dev/null 2>&1; then`,
+    `  printf '%s\\n' ${shellQuote(JSON.stringify({ applied: true }))}`,
+    "else",
+    `  printf '%s\\n' ${shellQuote(JSON.stringify({ applied: false, reason: "patch apply failed" }))}`,
+    "fi",
+  ];
+}
+
+/** Reruns the reproduce commands after the candidate has been applied.
+ * Emits { reproduced: false } when the bug is fixed, { reproduced: true } when it still fails.
+ */
+export function buildCandidateReproduceTool(bundle: LocalPatchValidationBundle) {
+  const lines = [
+    "reproduced=false",
+    ...bundle.reproduceCommands.flatMap(cmd => [
+      `if ! (${cmd}) >/dev/null 2>&1; then`,
+      "  reproduced=true",
+      "fi",
+    ]),
+    `printf '%s\\n' "{\\"reproduced\\":$reproduced}"`,
+  ];
+
+  return buildBashTool(lines.join("\n"), bundle.repoPath);
+}
+
+/** Runs verification commands (regression guard) after the candidate is applied.
+ * Emits { passed: true } when all pass, { passed: false, command: "..." } on first failure.
+ */
+export function buildVerificationTool(bundle: LocalPatchValidationBundle) {
+  const lines = [
+    ...bundle.verificationCommands.flatMap(cmd => [
+      `if ! (${cmd}) >/dev/null 2>&1; then`,
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ passed: false, command: cmd }))}`,
+      "  exit 0",
+      "fi",
+    ]),
+    `printf '%s\\n' ${shellQuote(JSON.stringify({ passed: true }))}`,
+  ];
+
+  return buildBashTool(lines.join("\n"), bundle.repoPath);
+}
+
+// ============================================================================
+// Condition helpers
+// ============================================================================
+
+/** True when baseline reproduction produced { reproduced: true }. */
+export function buildBaselineReproducedCondition(): string {
+  return `${patchValidationNodeIds.runBaseline}.reproduced`;
+}
+
+/** True when candidate application produced { applied: true }. */
+export function buildCandidateAppliedCondition(): string {
+  return `${patchValidationNodeIds.applyCandidate}.applied`;
+}
+
+/** True when candidate reproduction produced { reproduced: false } (bug no longer reproduces). */
+export function buildCandidateFixedCondition(): string {
+  return `!${patchValidationNodeIds.runCandidateReproduce}.reproduced`;
+}
+
+/** True when verification produced { passed: true }. */
+export function buildVerificationPassedCondition(): string {
+  return `${patchValidationNodeIds.runVerification}.passed`;
+}
+
+/** True when human approval produced { approved: true }. */
+export function buildHumanApprovedCondition(): string {
+  return `${patchValidationNodeIds.humanApprove}.approved`;
+}
+
+// ============================================================================
+// Internal helpers
+// ============================================================================
+
+function buildBashTool(script: string, cwd: string) {
+  return {
+    tool: "bash",
+    args: ["-lc", script],
+    cwd,
+  };
+}
+
+function shellQuote(value: string): string {
+  if (/^[A-Za-z0-9_./:=+-]+$/.test(value)) {
+    return value;
+  }
+
+  return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}

package/src/reference/patch-validation.ts

@@ -0,0 +1,174 @@
+import type { HarnessSpec } from "../spec/types.js";
+import {
+  buildApplyCandidateTool,
+  buildBaselineReproducedCondition,
+  buildBaselineReproduceTool,
+  buildCandidateAppliedCondition,
+  buildCandidateFixedCondition,
+  buildCandidateReproduceTool,
+  buildHumanApprovedCondition,
+  buildVerificationPassedCondition,
+  buildVerificationTool,
+  patchValidationNodeIds,
+} from "./patch-validation-strategies.js";
+import type { LocalPatchValidationBundle } from "./types.js";
+
+export function buildPatchValidationHarnessSpec(bundle: LocalPatchValidationBundle): HarnessSpec {
+  if (bundle.reproduceCommands.length === 0) {
+    throw new Error("Patch validation requires at least one reproduce command");
+  }
+
+  if (bundle.verificationCommands.length === 0) {
+    throw new Error("Patch validation requires at least one verification command");
+  }
+
+  const ids = patchValidationNodeIds;
+
+  const afterVerification = bundle.approvalRequired ? ids.summarise : ids.validatedFix;
+
+  return {
+    name: "patch-validation",
+    executionPolicy: {
+      timeout: 300,
+    },
+    humanPolicy: {
+      defaultTimeout: 300,
+    },
+    observabilityPolicy: {
+      tracing: true,
+      logLevel: "info",
+    },
+    graph: {
+      entryNodeId: ids.runBaseline,
+      nodes: [
+        {
+          id: ids.runBaseline,
+          label: "Run baseline reproduction",
+          kind: "tool",
+          ...buildBaselineReproduceTool(bundle),
+        },
+        {
+          id: ids.gateNotReproduced,
+          kind: "condition",
+          condition: buildBaselineReproducedCondition(),
+          thenNodeId: ids.applyCandidate,
+          elseNodeId: ids.notReproduced,
+        },
+        {
+          id: ids.applyCandidate,
+          label: "Apply candidate",
+          kind: "tool",
+          ...buildApplyCandidateTool(bundle),
+        },
+        {
+          id: ids.gateApplyFailed,
+          kind: "condition",
+          condition: buildCandidateAppliedCondition(),
+          thenNodeId: ids.runCandidateReproduce,
+          elseNodeId: ids.applyFailed,
+        },
+        {
+          id: ids.runCandidateReproduce,
+          label: "Rerun reproduction on candidate",
+          kind: "tool",
+          ...buildCandidateReproduceTool(bundle),
+        },
+        {
+          id: ids.gateCandidateStillFails,
+          kind: "condition",
+          condition: buildCandidateFixedCondition(),
+          thenNodeId: ids.runVerification,
+          elseNodeId: ids.candidateFailed,
+        },
+        {
+          id: ids.runVerification,
+          label: "Run verification commands",
+          kind: "tool",
+          ...buildVerificationTool(bundle),
+        },
+        {
+          id: ids.gateCandidateVerification,
+          kind: "condition",
+          condition: buildVerificationPassedCondition(),
+          thenNodeId: afterVerification,
+          elseNodeId: ids.candidateFailed,
+        },
+        ...(bundle.approvalRequired
+          ? [
+              {
+                id: ids.summarise,
+                kind: "llm" as const,
+                provider: "anthropic",
+                model: "claude-sonnet",
+                prompt: buildSummaryPrompt(bundle),
+              },
+              {
+                id: ids.humanApprove,
+                kind: "human" as const,
+                prompt: `Review the patch-validation summary produced by the '${ids.summarise}' step (available in workflow state as '${ids.summarise}.summary') and approve or reject the candidate fix.\n\nInstructions: ${bundle.reviewInstructions}`,
+                interactionType: "approval" as const,
+              },
+              {
+                id: ids.checkHumanApproval,
+                kind: "condition" as const,
+                condition: buildHumanApprovedCondition(),
+                thenNodeId: ids.validatedFix,
+                elseNodeId: ids.rejected,
+              },
+            ]
+          : []),
+        {
+          id: ids.validatedFix,
+          kind: "subworkflow",
+          specRef: ids.validatedFix,
+        },
+        {
+          id: ids.notReproduced,
+          kind: "subworkflow",
+          specRef: ids.notReproduced,
+        },
+        {
+          id: ids.applyFailed,
+          kind: "subworkflow",
+          specRef: ids.applyFailed,
+        },
+        {
+          id: ids.candidateFailed,
+          kind: "subworkflow",
+          specRef: ids.candidateFailed,
+        },
+        ...(bundle.approvalRequired
+          ? [
+              {
+                id: ids.rejected,
+                kind: "subworkflow" as const,
+                specRef: ids.rejected,
+              },
+            ]
+          : []),
+      ],
+      edges: [
+        { from: ids.runBaseline, to: ids.gateNotReproduced },
+        { from: ids.applyCandidate, to: ids.gateApplyFailed },
+        { from: ids.runCandidateReproduce, to: ids.gateCandidateStillFails },
+        { from: ids.runVerification, to: ids.gateCandidateVerification },
+        ...(bundle.approvalRequired
+          ? [
+              { from: ids.summarise, to: ids.humanApprove },
+              { from: ids.humanApprove, to: ids.checkHumanApproval },
+            ]
+          : []),
+      ],
+    },
+  };
+}
+
+function buildSummaryPrompt(bundle: LocalPatchValidationBundle): string {
+  return [
+    "Summarise the patch-validation run and return JSON with a single string field `summary`.",
+    `Repository: ${bundle.repoPath}`,
+    `Baseline ref: ${bundle.baselineRef}`,
+    `Candidate source: ${JSON.stringify(bundle.candidateSource)}`,
+    `Instructions: ${bundle.reviewInstructions}`,
+  ].join("\n");
+}