@tarcisiopgs/lisa 1.35.0 → 1.36.0

package/dist/{chunk-6SNT7TND.js → chunk-AFKXWCAM.js}

@@ -65,7 +65,9 @@ function parsePlanResponse(raw) {
       relevantFiles: Array.isArray(issue.relevantFiles) ? issue.relevantFiles.filter((f) => typeof f === "string") : [],
       order: typeof issue.order === "number" ? issue.order : idx + 1,
       dependsOn: Array.isArray(issue.dependsOn) ? issue.dependsOn.filter((d) => typeof d === "number") : [],
-      repo: typeof issue.repo === "string" ? issue.repo : void 0
+      repo: typeof issue.repo === "string" ? issue.repo : void 0,
+      verifyCommand: typeof issue.verifyCommand === "string" ? issue.verifyCommand : void 0,
+      doneCriteria: typeof issue.doneCriteria === "string" ? issue.doneCriteria : void 0
     };
   });
   return issues;
@@ -175,6 +177,20 @@ async function createPlanIssues(source, config, plan, workspace) {
   const orderToId = /* @__PURE__ */ new Map();
   for (const issue of sorted) {
     let description = ensureAcceptanceCriteria(issue.description, issue.acceptanceCriteria);
+    if (issue.verifyCommand) {
+      description += `
+
+## Verify Command
+
+\`\`\`bash
+${issue.verifyCommand}
+\`\`\`
+`;
+      if (issue.doneCriteria) {
+        description += `Expected: ${issue.doneCriteria}
+`;
+      }
+    }
     if (issue.dependsOn.length > 0 && !source.linkDependency) {
       const depRefs = issue.dependsOn.map((depOrder) => {
         const depId = orderToId.get(depOrder);
@@ -275,6 +291,8 @@ For each issue, provide:
 - **relevantFiles**: Array of file paths in the codebase that will be modified or created
 - **order**: Integer (1-based) \u2014 execution order based on dependencies
 - **dependsOn**: Array of order numbers this issue depends on (empty if independent)
+- **verifyCommand**: A shell command that validates the issue is complete (e.g., \`npm test\`, \`npx tsc --noEmit\`, \`curl localhost:3000/health\`)
+- **doneCriteria**: What success looks like when the verify command runs (e.g., "All tests pass", "Returns 200 OK")
 ${config.repos.length > 1 ? "- **repo**: Name of the target repository from the list above (required for multi-repo)\n" : ""}
 ## Rules
 
@@ -284,13 +302,14 @@ ${config.repos.length > 1 ? "- **repo**: Name of the target repository from the
 4. Issues MUST include test expectations in their acceptance criteria
 5. Order issues so dependencies come first (lower order = executes first)
 6. Use clear, specific titles \u2014 not vague ("Improve X" is bad, "Add rate limit middleware to /api/users" is good)
-7. Output ONLY valid JSON \u2014 no markdown code fences, no explanation text
+7. Each issue SHOULD include a verifyCommand that can programmatically validate completion
+8. Output ONLY valid JSON \u2014 no markdown code fences, no explanation text
 
 ## Output Format
 
 Respond with ONLY this JSON structure (no wrapping, no markdown):
 
-{"issues":[{"title":"...","description":"...","acceptanceCriteria":["..."],"relevantFiles":["..."],"order":1,"dependsOn":[]${config.repos.length > 1 ? ',"repo":"..."' : ""}}]}`;
+{"issues":[{"title":"...","description":"...","acceptanceCriteria":["..."],"relevantFiles":["..."],"order":1,"dependsOn":[],"verifyCommand":"...","doneCriteria":"..."${config.repos.length > 1 ? ',"repo":"..."' : ""}}]}`;
 }
 
 // src/plan/persistence.ts
@@ -404,6 +423,40 @@ Please output ONLY valid JSON with the exact structure specified above.`;
   );
 }
 
+// src/plan/waves.ts
+function buildExecutionWaves(issues) {
+  if (issues.length === 0) return [];
+  const remaining = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    remaining.set(issue.order, new Set(issue.dependsOn));
+  }
+  const waves = [];
+  while (remaining.size > 0) {
+    const wave = [];
+    for (const [order, deps] of remaining) {
+      if (deps.size === 0) {
+        wave.push(order);
+      }
+    }
+    if (wave.length === 0) {
+      waves.push([...remaining.keys()].sort((a, b) => a - b));
+      break;
+    }
+    wave.sort((a, b) => a - b);
+    waves.push(wave);
+    const assigned = new Set(wave);
+    for (const order of wave) {
+      remaining.delete(order);
+    }
+    for (const deps of remaining.values()) {
+      for (const a of assigned) {
+        deps.delete(a);
+      }
+    }
+  }
+  return waves;
+}
+
 // src/plan/wizard.ts
 async function runPlanWizard(plan, planPath, opts) {
   const workspace = opts.config.workspace;
@@ -457,17 +510,29 @@ async function runPlanWizard(plan, planPath, opts) {
 function displayPlan(plan) {
   clack.log.info(`${pc.bold("Goal:")} ${plan.goal}`);
   clack.log.info("");
+  const waves = buildExecutionWaves(plan.issues);
   const sorted = [...plan.issues].sort((a, b) => a.order - b.order);
-  for (const issue of sorted) {
-    const deps = issue.dependsOn.length > 0 ? pc.gray(` \u2192 depends on: ${issue.dependsOn.map((d) => `#${d}`).join(", ")}`) : "";
-    const repo = issue.repo ? pc.cyan(` [${issue.repo}]`) : "";
-    const files = issue.relevantFiles.length > 0 ? pc.gray(
-      `
+  for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
+    const wave = waves[waveIdx];
+    const label = wave.length > 1 ? "parallel" : "sequential";
+    clack.log.info(pc.dim(`  Wave ${waveIdx + 1} (${label}):`));
+    for (const orderNum of wave) {
+      const issue = sorted.find((i) => i.order === orderNum);
+      if (!issue) continue;
+      const deps = issue.dependsOn.length > 0 ? pc.gray(` \u2192 depends on: ${issue.dependsOn.map((d) => `#${d}`).join(", ")}`) : "";
+      const repo = issue.repo ? pc.cyan(` [${issue.repo}]`) : "";
+      const files = issue.relevantFiles.length > 0 ? pc.gray(
+        `
      Files: ${issue.relevantFiles.slice(0, 3).join(", ")}${issue.relevantFiles.length > 3 ? ` +${issue.relevantFiles.length - 3}` : ""}`
-    ) : "";
-    clack.log.info(
-      `  ${pc.yellow(String(issue.order))}. ${pc.bold(issue.title)}${repo}${deps}${files}`
-    );
+      ) : "";
+      const verify = issue.verifyCommand ? pc.gray(`
+     Verify: ${issue.verifyCommand}`) : "";
+      const criteria = issue.acceptanceCriteria.length > 0 ? pc.gray(`
+     Criteria: ${issue.acceptanceCriteria.length} item(s)`) : "";
+      clack.log.info(
+        `  ${pc.yellow(String(issue.order))}. ${pc.bold(issue.title)}${repo}${deps}${files}${criteria}${verify}`
+      );
+    }
   }
   clack.log.info("");
 }
@@ -542,15 +607,13 @@ async function reorderIssues(plan, _workspace) {
   });
   if (clack.isCancel(answer)) return;
   const newOrder = answer.split(",").map((n) => Number(n.trim()));
-  const oldOrderMap = /* @__PURE__ */ new Map();
-  for (const issue of plan.issues) {
-    oldOrderMap.set(issue.order, issue);
-  }
+  const oldToNew = /* @__PURE__ */ new Map();
   for (let i = 0; i < newOrder.length; i++) {
-    const issue = oldOrderMap.get(newOrder[i]);
-    if (issue) {
-      issue.order = i + 1;
-    }
+    oldToNew.set(newOrder[i], i + 1);
+  }
+  for (const issue of plan.issues) {
+    issue.order = oldToNew.get(issue.order) ?? issue.order;
+    issue.dependsOn = issue.dependsOn.map((d) => oldToNew.get(d) ?? d).filter((d) => d !== issue.order);
   }
   clack.log.success("Issues reordered.");
 }
@@ -582,6 +645,14 @@ function issueToMarkdown(issue) {
 `;
   md += `${issue.description}
 `;
+  if (issue.dependsOn.length > 0) {
+    md += `
+## Depends On
+
+`;
+    md += `${issue.dependsOn.join(", ")}
+`;
+  }
   if (issue.relevantFiles.length > 0) {
     md += `
 ## Relevant Files
@@ -589,6 +660,21 @@ function issueToMarkdown(issue) {
 `;
     for (const f of issue.relevantFiles) {
       md += `- ${f}
+`;
+    }
+  }
+  if (issue.verifyCommand) {
+    md += `
+## Verify
+
+`;
+    md += `\`\`\`bash
+${issue.verifyCommand}
+\`\`\`
+`;
+    if (issue.doneCriteria) {
+      md += `
+Expected: ${issue.doneCriteria}
 `;
     }
   }
@@ -599,10 +685,24 @@ function markdownToIssue(content, original) {
   const titleLine = lines.find((l) => l.startsWith("# "));
   const title = titleLine ? titleLine.replace(/^#\s+/, "").trim() : original.title;
   const titleIdx = lines.indexOf(titleLine ?? "");
+  const depsIdx = lines.findIndex((l) => l.startsWith("## Depends On"));
   const filesIdx = lines.findIndex((l) => l.startsWith("## Relevant Files"));
-  const descLines = filesIdx > 0 ? lines.slice(titleIdx + 1, filesIdx) : lines.slice(titleIdx + 1);
+  const verifyIdx = lines.findIndex((l) => l.startsWith("## Verify"));
+  const sectionBoundaries = [depsIdx, filesIdx, verifyIdx].filter((i) => i > 0);
+  const descEnd = sectionBoundaries.length > 0 ? Math.min(...sectionBoundaries) : -1;
+  const descLines = descEnd > 0 ? lines.slice(titleIdx + 1, descEnd) : lines.slice(titleIdx + 1);
   const description = descLines.join("\n").trim();
   const acceptanceCriteria = descLines.filter((l) => l.trim().startsWith("- [ ]") || l.trim().startsWith("- [x]")).map((l) => l.trim().replace(/^- \[[ x]\]\s*/, ""));
+  let dependsOn;
+  if (depsIdx > 0) {
+    const nextSection = [filesIdx, verifyIdx].filter((i) => i > depsIdx);
+    const depsEnd = nextSection.length > 0 ? Math.min(...nextSection) : lines.length;
+    const depsContent = lines.slice(depsIdx + 1, depsEnd).join(" ").trim();
+    if (depsContent) {
+      const parsed = depsContent.split(/[,\s]+/).map((s) => Number.parseInt(s.trim(), 10)).filter((n) => !Number.isNaN(n));
+      if (parsed.length > 0) dependsOn = parsed;
+    }
+  }
   const relevantFiles = [];
   if (filesIdx > 0) {
     for (let i = filesIdx + 1; i < lines.length; i++) {
@@ -614,11 +714,28 @@ function markdownToIssue(content, original) {
       }
     }
   }
+  let verifyCommand;
+  let doneCriteria;
+  if (verifyIdx > 0) {
+    const verifyLines = lines.slice(verifyIdx + 1);
+    const codeStart = verifyLines.findIndex((l) => l.trim().startsWith("```"));
+    const codeEnd = verifyLines.findIndex((l, i) => i > codeStart && l.trim().startsWith("```"));
+    if (codeStart >= 0 && codeEnd > codeStart) {
+      verifyCommand = verifyLines.slice(codeStart + 1, codeEnd).join("\n").trim();
+    }
+    const expectedLine = verifyLines.find((l) => l.trim().startsWith("Expected:"));
+    if (expectedLine) {
+      doneCriteria = expectedLine.trim().replace(/^Expected:\s*/, "");
+    }
+  }
   return {
     title,
     description: description || original.description,
     acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : original.acceptanceCriteria,
-    relevantFiles: relevantFiles.length > 0 ? relevantFiles : original.relevantFiles
+    relevantFiles: relevantFiles.length > 0 ? relevantFiles : original.relevantFiles,
+    ...dependsOn ? { dependsOn } : {},
+    ...verifyCommand ? { verifyCommand } : {},
+    ...doneCriteria ? { doneCriteria } : {}
   };
 }
 
@@ -630,6 +747,7 @@ export {
   generatePlan,
   savePlan,
   loadLatestPlan,
+  buildExecutionWaves,
   runPlanWizard,
   issueToMarkdown,
   markdownToIssue

package/dist/{chunk-BWND35E5.js → chunk-PGIXWLQT.js}

@@ -255,6 +255,7 @@ function loadConfig(cwd = process.cwd()) {
   const rawReviewMonitor = parsed.review_monitor;
   const rawReactions = parsed.reactions;
   const rawSpecCompliance = parsed.spec_compliance;
+  const rawPlanValidation = parsed.plan_validation;
   const rawProgress = parsed.progress_comments;
   const rawPr = parsed.pr;
   const config = {
@@ -309,6 +310,10 @@ function loadConfig(cwd = process.cwd()) {
       max_retries: rawSpecCompliance.max_retries,
       block_on_failure: rawSpecCompliance.block_on_failure
     } : void 0,
+    plan_validation: rawPlanValidation ? {
+      enabled: rawPlanValidation.enabled ?? false,
+      max_iterations: rawPlanValidation.max_iterations
+    } : void 0,
     progress_comments: rawProgress ? { enabled: rawProgress.enabled ?? false } : void 0,
     pr: parsePrConfig(rawPr),
     provider_options: {

package/dist/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   CliError,
+  buildExecutionWaves,
   createPlanIssues,
   generatePlan,
   loadLatestPlan,
   parseStructuredOutput,
   runPlanWizard,
   savePlan
-} from "./chunk-6SNT7TND.js";
+} from "./chunk-AFKXWCAM.js";
 import {
   detectDefaultBranch,
   detectGitRepos,
@@ -37,7 +38,7 @@ import {
   runLoop,
   saveConfig,
   validateConfig
-} from "./chunk-BWND35E5.js";
+} from "./chunk-PGIXWLQT.js";
 import {
   buildContextMdBlock,
   createProvider,
@@ -58,7 +59,8 @@ import {
   ok,
   setLogLevel,
   setOutputMode,
-  updateNotice
+  updateNotice,
+  warn
 } from "./chunk-V44FTYWZ.js";
 import "./chunk-3EOEDL3T.js";
 import {
@@ -955,6 +957,14 @@ function runAdvancedChecks(config2) {
       category: "advanced"
     });
   }
+  if (config2.plan_validation?.enabled) {
+    const maxIter = config2.plan_validation.max_iterations ?? 2;
+    results.push({
+      passed: true,
+      label: `Plan validation is enabled (max ${maxIter} iteration${maxIter !== 1 ? "s" : ""})`,
+      category: "advanced"
+    });
+  }
   if (config2.hooks) {
     for (const [name, cmd] of Object.entries(config2.hooks)) {
       if (name === "timeout" || !cmd || typeof cmd !== "string") continue;
@@ -1293,7 +1303,7 @@ var init = defineCommand5({
 // src/cli/commands/issue.ts
 import { defineCommand as defineCommand6 } from "citty";
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var issueGet = defineCommand6({
   meta: { name: "get", description: "Fetch full issue details as JSON" },
@@ -1370,7 +1380,7 @@ var issue = defineCommand6({
 import { defineCommand as defineCommand7 } from "citty";
 
 // src/plan/index.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import * as clack4 from "@clack/prompts";
 
 // src/plan/brainstorm.ts
@@ -1455,10 +1465,230 @@ ALWAYS respond with a single JSON object (no markdown fences, no extra text):
 Output ONLY the JSON object.`;
 }
 
+// src/plan/plan-checker.ts
+import { mkdtempSync as mkdtempSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3, resolve as resolve4 } from "path";
+function buildPlanValidationPrompt(goal, issues, contextMd) {
+  const contextBlock = buildContextMdBlock(contextMd);
+  const issuesBlock = issues.map((issue2) => {
+    const deps = issue2.dependsOn.length > 0 ? ` (depends on: ${issue2.dependsOn.join(", ")})` : "";
+    const verify = issue2.verifyCommand ? `
+  Verify: ${issue2.verifyCommand}` : "";
+    const done = issue2.doneCriteria ? `
+  Done: ${issue2.doneCriteria}` : "";
+    const files = issue2.relevantFiles.length > 0 ? `
+  Files: ${issue2.relevantFiles.join(", ")}` : "";
+    const criteria = issue2.acceptanceCriteria.length > 0 ? `
+  Criteria: ${issue2.acceptanceCriteria.join("; ")}` : "";
+    return `${issue2.order}. ${issue2.title}${deps}${files}${criteria}${verify}${done}`;
+  }).join("\n\n");
+  return `You are a plan quality validator. Your ONLY task is to evaluate whether an implementation plan is well-structured and complete. Do NOT modify any files or run any commands.
+
+Always respond in the same language the user wrote their goal in.
+
+## Goal
+
+${goal}
+${contextBlock}
+## Plan to Validate
+
+${issuesBlock}
+
+## Evaluation Dimensions
+
+Evaluate the plan across these 6 dimensions:
+
+1. **Requirement Coverage**: Does the plan fully address the stated goal? Are there aspects of the goal that no issue covers?
+2. **Task Atomicity**: Is each issue small enough to complete in a single AI coding session (under 1 hour)? Are any issues too broad or too granular?
+3. **Dependency Correctness**: Are dependencies properly ordered? Are there missing dependencies where one issue clearly requires another to be completed first?
+4. **File Scope**: Is the file scope per task reasonable? Do multiple issues modify the same files (merge conflict risk)?
+5. **Verification**: Does each issue have testable acceptance criteria or a verify command? Can completion be objectively determined?
+6. **Gap Detection**: Are there missing implementation steps? Would executing all issues actually achieve the goal?
+
+## Response Format
+
+Respond with ONLY a valid JSON object \u2014 no markdown fences, no explanation, no other text:
+
+{
+  "passed": true,
+  "findings": [
+    { "dimension": "requirement_coverage", "severity": "low", "description": "Minor: no logging added", "suggestion": "Consider adding a logging issue" }
+  ],
+  "refinedPlan": null
+}
+
+When "passed" is false, include a "refinedPlan" with the corrected issues:
+
+{
+  "passed": false,
+  "findings": [
+    { "dimension": "gap_detection", "severity": "high", "description": "Missing database migration step", "suggestion": "Add an issue for the migration", "issueOrder": 2 }
+  ],
+  "refinedPlan": {
+    "issues": [
+      { "title": "...", "description": "...", "acceptanceCriteria": ["..."], "relevantFiles": ["..."], "order": 1, "dependsOn": [], "verifyCommand": "...", "doneCriteria": "..." }
+    ]
+  }
+}
+
+IMPORTANT:
+- Set "passed" to false ONLY for high-severity findings that would cause implementation failure.
+- Medium and low findings are informational \u2014 the plan can still pass.
+- Do NOT create, edit, or modify any files.
+- Do NOT run any shell commands.
+- ONLY output the JSON object above.`;
+}
+function parsePlanValidationResponse(output) {
+  const jsonPatterns = [
+    /\{[\s\S]*"findings"[\s\S]*\}/,
+    /```(?:json)?\s*(\{[\s\S]*"findings"[\s\S]*\})\s*```/
+  ];
+  for (const pattern of jsonPatterns) {
+    const match = pattern.exec(output);
+    if (match) {
+      const jsonStr = match[1] ?? match[0];
+      try {
+        const parsed = JSON.parse(jsonStr);
+        if (Array.isArray(parsed.findings)) {
+          const hasHighSeverity = parsed.findings.some((f) => f.severity === "high");
+          return {
+            passed: hasHighSeverity ? false : parsed.passed !== false,
+            findings: parsed.findings,
+            refinedIssues: parseRefinedIssues(parsed)
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function parseRefinedIssues(parsed) {
+  const refined = parsed.refinedPlan;
+  if (!refined?.issues || !Array.isArray(refined.issues)) return void 0;
+  return refined.issues.filter(
+    (i) => typeof i === "object" && i !== null && typeof i.title === "string"
+  ).map((issue2, idx) => ({
+    title: String(issue2.title),
+    description: typeof issue2.description === "string" ? issue2.description : "",
+    acceptanceCriteria: Array.isArray(issue2.acceptanceCriteria) ? issue2.acceptanceCriteria.filter((c) => typeof c === "string") : [],
+    relevantFiles: Array.isArray(issue2.relevantFiles) ? issue2.relevantFiles.filter((f) => typeof f === "string") : [],
+    order: typeof issue2.order === "number" ? issue2.order : idx + 1,
+    dependsOn: Array.isArray(issue2.dependsOn) ? issue2.dependsOn.filter((d) => typeof d === "number") : [],
+    repo: typeof issue2.repo === "string" ? issue2.repo : void 0,
+    verifyCommand: typeof issue2.verifyCommand === "string" ? issue2.verifyCommand : void 0,
+    doneCriteria: typeof issue2.doneCriteria === "string" ? issue2.doneCriteria : void 0
+  }));
+}
+async function validateAndRefinePlan(goal, issues, config2) {
+  const maxIterations = config2.plan_validation?.max_iterations ?? 2;
+  const workspace = resolve4(config2.workspace);
+  const contextMd = readContext(workspace);
+  const models = resolveModels(config2);
+  const logDir = mkdtempSync2(join3(tmpdir2(), "lisa-plan-check-"));
+  const logFile = join3(logDir, "plan-check.log");
+  let currentIssues = issues;
+  const allFindings = [];
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    const prompt = buildPlanValidationPrompt(goal, currentIssues, contextMd);
+    const result = await runWithFallback(models, prompt, {
+      logFile,
+      cwd: workspace,
+      sessionTimeout: 120
+    });
+    if (!result.success) {
+      warn("Plan validation failed \u2014 skipping quality gate.");
+      break;
+    }
+    const validation = parsePlanValidationResponse(result.output);
+    if (!validation) {
+      warn("Could not parse validation response \u2014 skipping quality gate.");
+      break;
+    }
+    allFindings.push(...validation.findings);
+    if (validation.passed) {
+      ok(
+        `Plan validated (iteration ${iteration + 1}): ${validation.findings.length} finding(s).`
+      );
+      break;
+    }
+    if (validation.refinedIssues && validation.refinedIssues.length > 0) {
+      log(
+        `Plan refined (iteration ${iteration + 1}/${maxIterations}): ${validation.findings.filter((f) => f.severity === "high").length} high-severity finding(s).`
+      );
+      currentIssues = validation.refinedIssues;
+    } else {
+      warn("Validation failed but no refined plan provided \u2014 using current plan.");
+      break;
+    }
+  }
+  return { issues: currentIssues, findings: allFindings };
+}
+
+// src/plan/validate.ts
+function detectDependencyCycles(issues) {
+  const issueByOrder = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    issueByOrder.set(issue2.order, issue2);
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    adjacency.set(issue2.order, []);
+    inDegree.set(issue2.order, 0);
+  }
+  for (const issue2 of issues) {
+    for (const dep of issue2.dependsOn) {
+      if (!adjacency.has(dep)) continue;
+      adjacency.get(dep).push(issue2.order);
+      inDegree.set(issue2.order, (inDegree.get(issue2.order) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [order, degree] of inDegree) {
+    if (degree === 0) queue.push(order);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    sorted.push(node);
+    for (const neighbor of adjacency.get(node) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  if (sorted.length === issues.length) return null;
+  const sortedSet = new Set(sorted);
+  const cycleNodes = issues.filter((i) => !sortedSet.has(i.order)).map((i) => `#${i.order} "${i.title}"`);
+  return [`Circular dependency involving: ${cycleNodes.join(" -> ")}`];
+}
+function detectFileOverlaps(issues) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    for (const file of issue2.relevantFiles) {
+      const existing = fileMap.get(file);
+      if (existing) {
+        existing.push(issue2.order);
+      } else {
+        fileMap.set(file, [issue2.order]);
+      }
+    }
+  }
+  const overlaps = [];
+  for (const [file, issueOrders] of fileMap) {
+    if (issueOrders.length >= 2) {
+      overlaps.push({ file, issues: issueOrders });
+    }
+  }
+  return overlaps;
+}
+
 // src/plan/index.ts
 async function runPlan(opts) {
   const { config: config2 } = opts;
-  const workspace = resolve4(config2.workspace);
+  const workspace = resolve5(config2.workspace);
   if (opts.continueLatest) {
     const latest = loadLatestPlan(workspace);
     if (!latest)
@@ -1498,11 +1728,41 @@ async function runPlan(opts) {
       }
     }
   }
-  const issues = await generatePlan(refinedGoal, config2, { parentDescription });
+  let validatedIssues = await generatePlan(refinedGoal, config2, { parentDescription });
+  const cycles = detectDependencyCycles(validatedIssues);
+  if (cycles) {
+    warn(`Dependency cycles detected: ${cycles.join(", ")}`);
+    validatedIssues = await generatePlan(refinedGoal, config2, {
+      parentDescription,
+      feedback: `Fix dependency cycles: ${cycles.join(", ")}. Ensure no circular dependencies.`
+    });
+  }
+  const overlaps = detectFileOverlaps(validatedIssues);
+  if (overlaps.length > 0) {
+    for (const o of overlaps) {
+      clack4.log.warning(
+        `File ${o.file} touched by issues ${o.issues.join(", ")} \u2014 merge conflict risk`
+      );
+    }
+  }
+  if (config2.plan_validation?.enabled && !opts.jsonOutput) {
+    log("Validating plan quality...");
+    const { issues: validated, findings } = await validateAndRefinePlan(
+      refinedGoal,
+      validatedIssues,
+      config2
+    );
+    validatedIssues = validated;
+    for (const f of findings) {
+      if (f.severity === "high") {
+        clack4.log.warning(`[${f.dimension}] ${f.description}`);
+      }
+    }
+  }
   const plan2 = {
     goal: refinedGoal,
     sourceIssueId: opts.issueId,
-    issues,
+    issues: validatedIssues,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: "draft",
     brainstormHistory
@@ -1533,7 +1793,7 @@ async function reviewAndCreate(plan2, planPath, opts) {
     });
     if (clack4.isCancel(confirm3) || !confirm3) {
       plan2.status = "draft";
-      savePlan(resolve4(config2.workspace), plan2);
+      savePlan(resolve5(config2.workspace), plan2);
       log("Plan saved. Resume with: lisa plan --continue");
       return;
     }
@@ -1542,7 +1802,7 @@ async function reviewAndCreate(plan2, planPath, opts) {
   const createdIds = await createPlanIssues(source, config2.source_config, plan2, config2.workspace);
   plan2.status = "created";
   plan2.createdIssueIds = createdIds;
-  savePlan(resolve4(config2.workspace), plan2);
+  savePlan(resolve5(config2.workspace), plan2);
   ok(`${createdIds.length} issue${createdIds.length !== 1 ? "s" : ""} created.`);
   for (let i = 0; i < createdIds.length; i++) {
     log(`  ${plan2.issues[i].order}. ${createdIds[i]}: ${plan2.issues[i].title}`);
@@ -1555,13 +1815,15 @@ async function reviewAndCreate(plan2, planPath, opts) {
     log("Run `lisa run` when ready.");
     return;
   }
-  const { runLoop: runLoop2 } = await import("./loop-N5D27JQX.js");
+  const { runLoop: runLoop2 } = await import("./loop-732CLNLZ.js");
+  const waves = buildExecutionWaves(plan2.issues);
+  const maxWaveSize = Math.max(...waves.map((w) => w.length));
   await runLoop2(config2, {
     once: false,
     watch: false,
     limit: createdIds.length,
     dryRun: false,
-    concurrency: 1
+    concurrency: maxWaveSize > 1 ? maxWaveSize : 1
   });
 }
 
@@ -1628,7 +1890,7 @@ var plan = defineCommand7({
 });
 
 // src/cli/commands/run.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { defineCommand as defineCommand8 } from "citty";
 import pc6 from "picocolors";
 
@@ -2018,12 +2280,12 @@ Add them to your ${shell} and run: source ${shell}`));
   let onBeforeExit;
   let persistedCards;
   if (isTTY) {
-    const workspace = resolve5(merged.workspace);
+    const workspace = resolve6(merged.workspace);
     const persistence = createKanbanPersistence(workspace);
     const initialCards = persistence.load();
     persistedCards = initialCards;
     persistence.start();
-    const { registerPlanBridge } = await import("./tui-bridge-LQDYRWHY.js");
+    const { registerPlanBridge } = await import("./tui-bridge-TSGCSJV4.js");
     const cleanupPlan = registerPlanBridge(merged);
     onBeforeExit = () => {
       persistence.stop();

package/dist/{loop-N5D27JQX.js → loop-732CLNLZ.js}

@@ -3,7 +3,7 @@ import {
   checkoutBaseBranches,
   runDemoLoop,
   runLoop
-} from "./chunk-BWND35E5.js";
+} from "./chunk-PGIXWLQT.js";
 import {
   WATCH_POLL_INTERVAL_MS
 } from "./chunk-6VIN5PMW.js";

package/dist/{tui-bridge-LQDYRWHY.js → tui-bridge-TSGCSJV4.js}

@@ -6,7 +6,7 @@ import {
   markdownToIssue,
   parseStructuredOutput,
   savePlan
-} from "./chunk-6SNT7TND.js";
+} from "./chunk-AFKXWCAM.js";
 import {
   createSource,
   resolveModels,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tarcisiopgs/lisa",
-  "version": "1.35.0",
+  "version": "1.36.0",
   "description": "Autonomous issue resolver",
   "keywords": [
     "loop",