karajan-code 1.11.1 → 1.13.0

package/src/orchestrator/solomon-rules.js

@@ -7,7 +7,8 @@ const DEFAULT_RULES = {
   max_files_per_iteration: 10,
   max_stale_iterations: 3,
   no_new_dependencies_without_task: true,
-  scope_guard: true
+  scope_guard: true,
+  reviewer_overreach: true
 };
 
 export function evaluateRules(context, rulesConfig = {}) {
@@ -59,6 +60,17 @@ export function evaluateRules(context, rulesConfig = {}) {
     });
   }
 
+  // Rule 5: Reviewer overreach — reviewer consistently flags out-of-scope issues
+  if (rules.reviewer_overreach && context.reviewerDemotedCount > 0) {
+    const severity = context.reviewerDemotedCount >= 3 ? "critical" : "warn";
+    alerts.push({
+      rule: "reviewer_overreach",
+      severity,
+      message: `Reviewer flagged ${context.reviewerDemotedCount} out-of-scope issue(s) that were auto-demoted by scope filter.`,
+      detail: { demotedCount: context.reviewerDemotedCount, autoApproved: context.reviewerAutoApproved || false }
+    });
+  }
+
   return {
     alerts,
     hasCritical: alerts.some(a => a.severity === "critical"),
@@ -76,9 +88,20 @@ export async function buildRulesContext({ session, task, iteration }) {
     filesChanged: 0,
     staleIterations: 0,
     newDependencies: [],
-    outOfScopeFiles: []
+    outOfScopeFiles: [],
+    reviewerDemotedCount: 0,
+    reviewerAutoApproved: false
   };
 
+  // Count reviewer scope-filter demotions from session checkpoints
+  const scopeFilterCheckpoints = (session.checkpoints || [])
+    .filter(cp => cp.stage === "reviewer-scope-filter");
+  if (scopeFilterCheckpoints.length > 0) {
+    const latest = scopeFilterCheckpoints.at(-1);
+    context.reviewerDemotedCount = latest.demoted_count || 0;
+    context.reviewerAutoApproved = latest.auto_approved || false;
+  }
+
   // Count files changed via git
   try {
     const { execaCommand } = await import("execa");

package/src/orchestrator.js

@@ -17,7 +17,9 @@ import { emitProgress, makeEvent } from "./utils/events.js";
 import { BudgetTracker, extractUsageMetrics } from "./utils/budget.js";
 import {
   prepareGitAutomation,
-  finalizeGitAutomation
+  finalizeGitAutomation,
+  earlyPrCreation,
+  incrementalPush
 } from "./git/automation.js";
 import { resolveRoleMdPath, loadFirstExisting } from "./roles/base-role.js";
 import { resolveReviewProfile } from "./review/profiles.js";
@@ -152,7 +154,8 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     last_sonar_issue_signature: null,
     sonar_repeat_count: 0,
     last_reviewer_issue_signature: null,
-    reviewer_repeat_count: 0
+    reviewer_repeat_count: 0,
+    deferred_issues: []
   };
   if (pgTaskId) sessionInit.pg_task_id = pgTaskId;
   if (pgProject) sessionInit.pg_project_id = pgProject;
@@ -287,6 +290,23 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     const plannerResult = await runPlannerStage({ config, logger, emitter, eventBase, session, plannerRole, researchContext, triageDecomposition, trackBudget });
     plannedTask = plannerResult.plannedTask;
     stageResults.planner = plannerResult.stageResult;
+
+    // BecarIA: dispatch planner comment (only on resume where PR already exists)
+    if (Boolean(config.becaria?.enabled) && session.becaria_pr_number) {
+      try {
+        const { dispatchComment } = await import("./becaria/dispatch.js");
+        const { detectRepo } = await import("./becaria/repo.js");
+        const repo = await detectRepo();
+        if (repo) {
+          const p = plannerResult.stageResult;
+          await dispatchComment({
+            repo, prNumber: session.becaria_pr_number, agent: "Planner",
+            body: `Plan: ${p?.summary || plannedTask}`,
+            becariaConfig: config.becaria
+          });
+        }
+      } catch { /* non-blocking */ }
+    }
   }
 
   const gitCtx = await prepareGitAutomation({ config, task, logger, session });
@@ -392,6 +412,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
 
     eventBase.iteration = i;
     const iterStart = Date.now();
+    const becariaEnabled = Boolean(config.becaria?.enabled) && gitCtx?.enabled;
     logger.setContext({ iteration: i, stage: "iteration" });
 
     emitProgress(
@@ -482,6 +503,75 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
       }
       if (sonarResult.stageResult) {
         stageResults.sonar = sonarResult.stageResult;
+        // BecarIA: dispatch sonar comment
+        if (becariaEnabled && session.becaria_pr_number) {
+          try {
+            const { dispatchComment } = await import("./becaria/dispatch.js");
+            const { detectRepo } = await import("./becaria/repo.js");
+            const repo = await detectRepo();
+            if (repo) {
+              const s = sonarResult.stageResult;
+              await dispatchComment({
+                repo, prNumber: session.becaria_pr_number, agent: "Sonar",
+                body: `SonarQube scan: ${s.summary || "completed"}`,
+                becariaConfig: config.becaria
+              });
+            }
+          } catch { /* non-blocking */ }
+        }
+      }
+    }
+
+    // --- BecarIA Gateway: early PR or incremental push ---
+    if (becariaEnabled) {
+      try {
+        const { dispatchComment } = await import("./becaria/dispatch.js");
+        const { detectRepo } = await import("./becaria/repo.js");
+        const repo = await detectRepo();
+
+        if (!session.becaria_pr_number) {
+          // First iteration: commit + push + create PR
+          const earlyPr = await earlyPrCreation({ gitCtx, task, logger, session, stageResults });
+          if (earlyPr) {
+            session.becaria_pr_number = earlyPr.prNumber;
+            session.becaria_pr_url = earlyPr.prUrl;
+            session.becaria_commits = earlyPr.commits;
+            await saveSession(session);
+            emitProgress(emitter, makeEvent("becaria:pr-created", { ...eventBase, stage: "becaria" }, {
+              message: `Early PR created: #${earlyPr.prNumber}`,
+              detail: { prNumber: earlyPr.prNumber, prUrl: earlyPr.prUrl }
+            }));
+
+            // Post coder comment on new PR
+            if (repo) {
+              const commitList = earlyPr.commits.map((c) => `- \`${c.hash.slice(0, 7)}\` ${c.message}`).join("\n");
+              await dispatchComment({
+                repo, prNumber: earlyPr.prNumber, agent: "Coder",
+                body: `Iteración ${i} completada.\n\nCommits:\n${commitList}`,
+                becariaConfig: config.becaria
+              });
+            }
+          }
+        } else {
+          // Subsequent iterations: incremental push + comment
+          const pushResult = await incrementalPush({ gitCtx, task, logger, session });
+          if (pushResult) {
+            session.becaria_commits = [...(session.becaria_commits || []), ...pushResult.commits];
+            await saveSession(session);
+
+            if (repo) {
+              const feedback = session.last_reviewer_feedback || "N/A";
+              const commitList = pushResult.commits.map((c) => `- \`${c.hash.slice(0, 7)}\` ${c.message}`).join("\n");
+              await dispatchComment({
+                repo, prNumber: session.becaria_pr_number, agent: "Coder",
+                body: `Issues corregidos:\n${feedback}\n\nCommits:\n${commitList}`,
+                becariaConfig: config.becaria
+              });
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`BecarIA early PR/push failed (non-blocking): ${err.message}`);
       }
     }
 
@@ -496,7 +586,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     if (reviewerEnabled) {
       const reviewerResult = await runReviewerStage({
         reviewerRole, config, logger, emitter, eventBase, session, trackBudget,
-        iteration: i, reviewRules, task, repeatDetector, budgetSummary
+        iteration: i, reviewRules, task, repeatDetector, budgetSummary, askQuestion
       });
       if (reviewerResult.action === "pause") {
         return reviewerResult.result;
@@ -575,11 +665,74 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
             }
           }
         }
+
+        // BecarIA: dispatch solomon comment
+        if (becariaEnabled && session.becaria_pr_number) {
+          try {
+            const { dispatchComment } = await import("./becaria/dispatch.js");
+            const { detectRepo } = await import("./becaria/repo.js");
+            const repo = await detectRepo();
+            if (repo) {
+              const alerts = rulesResult.alerts || [];
+              const alertMsg = alerts.length > 0
+                ? alerts.map(a => `- [${a.severity}] ${a.message}`).join("\n")
+                : "No anomalies detected";
+              await dispatchComment({
+                repo, prNumber: session.becaria_pr_number, agent: "Solomon",
+                body: `Supervisor check iteración ${i}: ${alertMsg}`,
+                becariaConfig: config.becaria
+              });
+            }
+          } catch { /* non-blocking */ }
+        }
       } catch (err) {
         logger.warn(`Solomon rules evaluation failed: ${err.message}`);
       }
     }
 
+    // --- BecarIA Gateway: dispatch review result ---
+    if (becariaEnabled && session.becaria_pr_number) {
+      try {
+        const { dispatchReview, dispatchComment } = await import("./becaria/dispatch.js");
+        const { detectRepo } = await import("./becaria/repo.js");
+        const repo = await detectRepo();
+        if (repo) {
+          const bc = config.becaria;
+          // Formal review (APPROVE / REQUEST_CHANGES)
+          if (review.approved) {
+            await dispatchReview({
+              repo, prNumber: session.becaria_pr_number,
+              event: "APPROVE", body: review.summary || "Approved", agent: "Reviewer", becariaConfig: bc
+            });
+          } else {
+            const blocking = review.blocking_issues?.map((x) => `- ${x.id || "ISSUE"} [${x.severity || ""}] ${x.description}`).join("\n") || "";
+            await dispatchReview({
+              repo, prNumber: session.becaria_pr_number,
+              event: "REQUEST_CHANGES",
+              body: blocking || review.summary || "Changes requested",
+              agent: "Reviewer", becariaConfig: bc
+            });
+          }
+
+          // Detailed comment
+          const status = review.approved ? "APPROVED" : "REQUEST_CHANGES";
+          const blocking = review.blocking_issues?.map((x) => `- ${x.id || "ISSUE"} [${x.severity || ""}] ${x.description}`).join("\n") || "";
+          const suggestions = review.non_blocking_suggestions?.map((s) => `- ${typeof s === "string" ? s : `${s.id || ""} ${s.description || s}`}`).join("\n") || "";
+          let reviewBody = `Review iteración ${i}: ${status}`;
+          if (blocking) reviewBody += `\n\n**Blocking:**\n${blocking}`;
+          if (suggestions) reviewBody += `\n\n**Suggestions:**\n${suggestions}`;
+          await dispatchComment({
+            repo, prNumber: session.becaria_pr_number, agent: "Reviewer",
+            body: reviewBody, becariaConfig: bc
+          });
+
+          logger.info(`BecarIA: dispatched review for PR #${session.becaria_pr_number}`);
+        }
+      } catch (err) {
+        logger.warn(`BecarIA dispatch failed (non-blocking): ${err.message}`);
+      }
+    }
+
     if (review.approved) {
       session.reviewer_retry_count = 0;
 
@@ -599,6 +752,22 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         }
         if (testerResult.stageResult) {
           stageResults.tester = testerResult.stageResult;
+          // BecarIA: dispatch tester comment
+          if (becariaEnabled && session.becaria_pr_number) {
+            try {
+              const { dispatchComment } = await import("./becaria/dispatch.js");
+              const { detectRepo } = await import("./becaria/repo.js");
+              const repo = await detectRepo();
+              if (repo) {
+                const t = testerResult.stageResult;
+                await dispatchComment({
+                  repo, prNumber: session.becaria_pr_number, agent: "Tester",
+                  body: `Tests: ${t.summary || "completed"}`,
+                  becariaConfig: config.becaria
+                });
+              }
+            } catch { /* non-blocking */ }
+          }
         }
       }
 
@@ -615,6 +784,22 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         }
         if (securityResult.stageResult) {
           stageResults.security = securityResult.stageResult;
+          // BecarIA: dispatch security comment
+          if (becariaEnabled && session.becaria_pr_number) {
+            try {
+              const { dispatchComment } = await import("./becaria/dispatch.js");
+              const { detectRepo } = await import("./becaria/repo.js");
+              const repo = await detectRepo();
+              if (repo) {
+                const s = securityResult.stageResult;
+                await dispatchComment({
+                  repo, prNumber: session.becaria_pr_number, agent: "Security",
+                  body: `Security scan: ${s.summary || "completed"}`,
+                  becariaConfig: config.becaria
+                });
+              }
+            } catch { /* non-blocking */ }
+          }
         }
       }
 
@@ -649,14 +834,17 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         }
       }
 
+      const deferredIssues = session.deferred_issues || [];
       emitProgress(
         emitter,
         makeEvent("session:end", { ...eventBase, stage: "done" }, {
-          message: "Session approved",
-          detail: { approved: true, iterations: i, stages: stageResults, git: gitResult, budget: budgetSummary() }
+          message: deferredIssues.length > 0
+            ? `Session approved (${deferredIssues.length} deferred issue(s) tracked as tech debt)`
+            : "Session approved",
+          detail: { approved: true, iterations: i, stages: stageResults, git: gitResult, budget: budgetSummary(), deferredIssues }
         })
       );
-      return { approved: true, sessionId: session.id, review, git: gitResult };
+      return { approved: true, sessionId: session.id, review, git: gitResult, deferredIssues };
     }
 
     session.last_reviewer_feedback = review.blocking_issues

package/src/prompts/coder.js

@@ -29,7 +29,7 @@ const SERENA_INSTRUCTIONS = [
   "Fall back to reading files only when Serena tools are not sufficient."
 ].join("\n");
 
-export function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false }) {
+export function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, deferredContext = null }) {
   const sections = [
     serenaEnabled ? SUBAGENT_PREAMBLE_SERENA : SUBAGENT_PREAMBLE,
     `Task:\n${task}`,
@@ -65,5 +65,9 @@ export function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary =
     sections.push(`Reviewer blocking feedback:\n${reviewerFeedback}`);
   }
 
+  if (deferredContext) {
+    sections.push(deferredContext);
+  }
+
   return sections.join("\n\n");
 }

package/src/prompts/reviewer.js

@@ -26,6 +26,8 @@ export function buildReviewerPrompt({ task, diff, reviewRules, mode, serenaEnabl
   const sections = [
     serenaEnabled ? SUBAGENT_PREAMBLE_SERENA : SUBAGENT_PREAMBLE,
     `You are a code reviewer in ${mode} mode.`,
+    "CRITICAL SCOPE RULE: Only review changes that are part of the diff below. Do NOT flag issues in unchanged code, missing features planned for future tasks, or improvements outside the scope of this task. If the diff is correct for what the task asks, approve it — even if the broader codebase has other issues.",
+    "Only block approval for issues IN THE DIFF that are bugs, security vulnerabilities, or clear violations of the review rules.",
     "Return only one valid JSON object and nothing else.",
     "JSON schema:",
     '{"approved":boolean,"blocking_issues":[{"id":string,"severity":"critical|high|medium|low","file":string,"line":number,"description":string,"suggested_fix":string}],"non_blocking_suggestions":[string],"summary":string,"confidence":number}'

package/src/review/scope-filter.js

@@ -0,0 +1,153 @@
+/**
+ * Scope filter — auto-defers reviewer blocking issues that reference
+ * files NOT present in the diff.  This prevents reviewer scope drift
+ * (flagging missing features, unchanged code, future tasks) from
+ * stalling the pipeline.
+ *
+ * Deferred issues are NOT forgotten — they are tracked in the session
+ * as technical debt that should be resolved in future iterations or
+ * follow-up tasks.  The coder and planner receive context about what
+ * was deferred and why.
+ */
+
+/**
+ * Extract the set of changed file paths from a unified diff string.
+ */
+export function extractDiffFiles(diff) {
+  const files = new Set();
+  for (const line of (diff || "").split("\n")) {
+    // Match "+++ b/path" lines in unified diff
+    const m = line.match(/^\+\+\+ b\/(.+)/);
+    if (m) files.add(m[1]);
+  }
+  return files;
+}
+
+/**
+ * Determine whether a blocking issue is within scope of the diff.
+ *
+ * An issue is considered IN scope when:
+ * - It has no `file` field (general concern about the diff)
+ * - Its `file` matches one of the changed files (exact or suffix match)
+ * - It references a pattern present in the diff content itself
+ *
+ * An issue is OUT of scope when:
+ * - It explicitly references a file NOT in the diff
+ */
+export function isIssueInScope(issue, diffFiles, diffContent) {
+  const file = (issue.file || "").trim();
+
+  // No file specified — the reviewer is commenting on the diff generally
+  if (!file) return true;
+
+  // Direct match
+  if (diffFiles.has(file)) return true;
+
+  // Suffix match (reviewer might use full path vs relative)
+  for (const df of diffFiles) {
+    if (df.endsWith(file) || file.endsWith(df)) return true;
+  }
+
+  // Check if the file path appears anywhere in the diff content
+  // (covers cases where the file is referenced in imports/requires)
+  if (diffContent && diffContent.includes(file)) return true;
+
+  return false;
+}
+
+/**
+ * Filter a review result, demoting out-of-scope blocking issues to
+ * non-blocking suggestions.
+ *
+ * Returns { review, demoted, deferred, allDemoted } where:
+ * - review: the filtered review (may flip approved to true)
+ * - demoted: array of original issues that were demoted
+ * - deferred: structured deferred issues with metadata for session tracking
+ * - allDemoted: true if ALL blocking issues were out of scope
+ */
+export function filterReviewScope(review, diff) {
+  if (!review || review.approved) {
+    return { review, demoted: [], deferred: [], allDemoted: false };
+  }
+
+  const diffFiles = extractDiffFiles(diff);
+
+  // If we can't parse diff files, don't filter (safety)
+  if (diffFiles.size === 0) {
+    return { review, demoted: [], deferred: [], allDemoted: false };
+  }
+
+  const inScope = [];
+  const demoted = [];
+
+  for (const issue of review.blocking_issues || []) {
+    if (isIssueInScope(issue, diffFiles, diff)) {
+      inScope.push(issue);
+    } else {
+      demoted.push(issue);
+    }
+  }
+
+  if (demoted.length === 0) {
+    return { review, demoted: [], deferred: [], allDemoted: false };
+  }
+
+  const demotedSuggestions = demoted.map(
+    (issue) => `[auto-demoted] ${issue.file || "unknown"}: ${issue.description || issue.id || "no description"}`
+  );
+
+  const filtered = {
+    ...review,
+    blocking_issues: inScope,
+    non_blocking_suggestions: [
+      ...(review.non_blocking_suggestions || []),
+      ...demotedSuggestions
+    ]
+  };
+
+  // If no in-scope blocking issues remain, auto-approve
+  const allDemoted = inScope.length === 0;
+  if (allDemoted) {
+    filtered.approved = true;
+    filtered.summary = `${review.summary || ""} [Auto-approved: ${demoted.length} out-of-scope issue(s) demoted to suggestions]`.trim();
+  }
+
+  // Build structured deferred issues for session tracking
+  const deferred = demoted.map((issue) => ({
+    id: issue.id || null,
+    file: issue.file || null,
+    severity: issue.severity || "medium",
+    description: issue.description || "no description",
+    suggested_fix: issue.suggested_fix || null,
+    deferred_at: new Date().toISOString(),
+    reason: "out_of_scope"
+  }));
+
+  return { review: filtered, demoted, deferred, allDemoted };
+}
+
+/**
+ * Build a human-readable summary of deferred issues for injection
+ * into coder/planner prompts so they are aware of the tech debt.
+ */
+export function buildDeferredContext(deferredIssues) {
+  if (!deferredIssues?.length) return "";
+
+  const lines = [
+    "## Deferred reviewer concerns (technical debt)",
+    "The following issues were flagged by the reviewer but deferred because they are outside the current diff scope.",
+    "You do NOT need to fix them now, but be aware of them:",
+    ""
+  ];
+
+  for (const issue of deferredIssues) {
+    const file = issue.file ? `\`${issue.file}\`` : "general";
+    const fix = issue.suggested_fix ? ` — Suggestion: ${issue.suggested_fix}` : "";
+    lines.push(`- [${issue.severity}] ${file}: ${issue.description}${fix}`);
+  }
+
+  lines.push("");
+  lines.push("If your current changes naturally address any of these, great. Otherwise, they will be tracked for future resolution.");
+
+  return lines.join("\n");
+}

package/src/roles/coder-role.js

@@ -17,8 +17,8 @@ export class CoderRole extends BaseRole {
   }
 
   async execute(input) {
-    const { task, reviewerFeedback, sonarSummary, onOutput } = typeof input === "string"
-      ? { task: input, reviewerFeedback: null, sonarSummary: null, onOutput: null }
+    const { task, reviewerFeedback, sonarSummary, deferredContext, onOutput } = typeof input === "string"
+      ? { task: input, reviewerFeedback: null, sonarSummary: null, deferredContext: null, onOutput: null }
       : input || {};
 
     const provider = resolveProvider(this.config);
@@ -28,6 +28,7 @@ export class CoderRole extends BaseRole {
       task: task || this.context?.task || "",
       reviewerFeedback: reviewerFeedback || null,
       sonarSummary: sonarSummary || null,
+      deferredContext: deferredContext || null,
       coderRules: this.instructions,
       methodology: this.config?.development?.methodology || "tdd",
       serenaEnabled: Boolean(this.config?.serena?.enabled)

package/templates/roles/coder.md

@@ -7,9 +7,20 @@ You are the **Coder** in a multi-role AI pipeline. Your job is to write code and
 - Follow TDD methodology when `methodology=tdd` is configured.
 - Write tests BEFORE implementation when using TDD.
 - Keep changes minimal and focused on the task.
+- "Minimal" means no unnecessary changes — it does NOT mean avoiding new files. If the task requires creating new files (pages, components, modules, tests), you MUST create them. Updating references/links without creating the actual files is an incomplete implementation.
 - Do not modify code unrelated to the task.
+- Before creating a new utility or helper, check if a similar one already exists in the codebase. Reuse existing code over creating duplicates.
 - Follow existing code conventions and patterns in the repository.
 
+## Task completeness
+
+Before reporting done, verify that ALL parts of the task are addressed:
+- Re-read the task description and acceptance criteria.
+- Check every requirement — if the task says "create pages X and Y", both must exist.
+- If the task lists multiple deliverables, each one must be implemented, not just some.
+- Run the test suite after implementation to verify nothing is broken.
+- An incomplete implementation is worse than an error — never report success if parts are missing.
+
 ## File modification safety
 
 - NEVER overwrite existing files entirely. Always make targeted, minimal edits.
@@ -18,13 +29,6 @@ You are the **Coder** in a multi-role AI pipeline. Your job is to write code and
 - If unintended changes are detected, revert immediately with `git checkout -- <file>`.
 - Pay special attention to CSS, HTML, and config files where full rewrites destroy prior work.
 
-## Multi-agent environment
-
-- Multiple developers and AI agents may be committing and modifying code simultaneously.
-- ALWAYS run `git fetch origin main` and check recent commits before starting work.
-- Before pushing or merging, rebase on the latest main: `git rebase origin/main`.
-- Create a dedicated branch per task and merge via PR, never push directly to main.
-
 ## Output format
 
 Return a JSON object:

package/templates/roles/planner.md

@@ -20,6 +20,8 @@ You are the **Planner** in a multi-role AI pipeline. Your job is to create an im
 ## Rules
 
 - Each step should be small and independently verifiable.
+- Steps must list ALL files involved: both files to modify AND new files to create. If a step requires creating a new file, list it explicitly in the `files` array.
+- The plan must cover ALL requirements from the task. Re-read the task description before finalizing — if something is mentioned in the task, it must appear in a step.
 - Identify the testing strategy (unit, integration, E2E).
 - Consider backward compatibility.
 - Reference research findings when available.

package/templates/roles/refactorer.md

@@ -5,7 +5,7 @@ You are the **Refactorer** in a multi-role AI pipeline. Your job is to improve c
 ## Constraints
 
 - Do NOT change any observable behavior or API contracts.
-- Do NOT expand the scope of changes beyond what was already modified.
+- Focus on the files that were already modified in this session. You may create new files when extracting code (e.g., extracting a helper to a new module), but do not refactor unrelated parts of the codebase.
 - Keep all existing tests passing — run tests after every change.
 - Follow existing code conventions and patterns in the repository.
 - Do NOT add new features or fix unrelated bugs.

package/templates/roles/reviewer.md

@@ -2,6 +2,12 @@
 
 You are the **Reviewer** in a multi-role AI pipeline. Your job is to review code changes against task requirements and quality standards.
 
+## Scope constraint
+
+- **ONLY review files present in the diff.** Do not flag issues in files that were not changed.
+- If you notice problems in untouched files, mention them as `non_blocking_suggestions` with a note that they are outside the current scope — never as `blocking_issues`.
+- Your job is to review THIS change, not audit the entire codebase.
+
 ## Review priorities (in order)
 
 1. **Security** — vulnerabilities, exposed secrets, injection vectors
@@ -13,9 +19,10 @@ You are the **Reviewer** in a multi-role AI pipeline. Your job is to review code
 ## Rules
 
 - Focus on security, correctness, and tests first.
-- Only raise blocking issues for concrete production risks.
+- Only raise blocking issues for concrete production risks in the changed files.
 - Keep non-blocking suggestions separate.
 - Style preferences NEVER block approval.
+- Confidence threshold: reject only if < 0.70.
 
 ## File overwrite detection (BLOCKING)
 
@@ -31,7 +38,7 @@ Return a strict JSON object:
   "result": {
     "approved": true,
     "blocking_issues": [],
-    "suggestions": ["Optional improvement ideas"],
+    "non_blocking_suggestions": ["Optional improvement ideas"],
     "confidence": 0.95
   },
   "summary": "Approved: all changes look correct and well-tested"
@@ -45,9 +52,9 @@ When rejecting:
   "result": {
     "approved": false,
     "blocking_issues": [
-      { "file": "src/foo.js", "line": 42, "severity": "critical", "issue": "SQL injection vulnerability" }
+      { "id": "R-1", "file": "src/foo.js", "line": 42, "severity": "critical", "description": "SQL injection vulnerability", "suggested_fix": "Use parameterized queries instead of string concatenation" }
     ],
-    "suggestions": [],
+    "non_blocking_suggestions": [],
     "confidence": 0.9
   },
   "summary": "Rejected: 1 critical security issue found"

package/templates/workflows/automerge.yml

@@ -0,0 +1,30 @@
+# Auto-merge PRs approved by BecarIA reviewer.
+# Merges when becaria-reviewer[bot] approves and all checks pass.
+
+name: Auto-merge (BecarIA)
+
+on:
+  pull_request_review:
+    types: [submitted]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  automerge:
+    if: >
+      github.event.review.state == 'approved' &&
+      contains(github.event.review.user.login, 'becaria-reviewer')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Enable auto-merge
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.pulls.merge({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.pull_request.number,
+              merge_method: 'squash'
+            });