@ludecker/aaac 1.1.5 → 1.2.0

package/templates/cursor/aaac/scripts/remediation/compute-satisfaction.mjs

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+/**
+ * Compute satisfaction score and remediation rate for a campaign iteration.
+ * Fallow components: dead-code (actionable), dupes (clone_groups), health (score).
+ *
+ * Usage:
+ *   node compute-satisfaction.mjs --campaign-id <id> --iteration <n>
+ */
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, isoNow, readJson, writeJson } from "../run-engine/lib.mjs";
+import { resolveActionableBaseline } from "./lib/fallow-classifier.mjs";
+import {
+  improvementRate,
+  readStartBaseline,
+  reductionRate,
+  summarizeDeadCode,
+  summarizeDupes,
+  summarizeHealth,
+} from "./lib/fallow-metrics.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+
+const WEIGHTS = {
+  fallow_dead_code: 0.25,
+  fallow_dupes: 0.1,
+  fallow_health: 0.05,
+  structural_clean: 0.15,
+  unit_tests: 0.15,
+  build: 0.1,
+  e2e: 0.2,
+};
+
+/** @deprecated — use sum of effective fallow weights */
+const LEGACY_FALLOW_WEIGHT =
+  WEIGHTS.fallow_dead_code + WEIGHTS.fallow_dupes + WEIGHTS.fallow_health;
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0 };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--campaign-id") out.campaignId = argv[++i];
+    else if (argv[i] === "--iteration") out.iteration = Number(argv[++i]);
+  }
+  return out;
+}
+
+function scoreComponent(pass, partial = 0) {
+  if (pass === true) return 1;
+  if (pass === false) return 0;
+  return partial;
+}
+
+function resolveFallowStartBaseline(campaignDir, campaign) {
+  const startPath = path.join(campaignDir, "fallow-start-baseline.json");
+  const start = readJson(startPath, null);
+  if (start?.fallow_total_issues != null) {
+    return { issues: start.fallow_total_issues, source: "fallow-start-baseline.json" };
+  }
+  if (campaign?.baseline?.immutable && campaign.baseline.fallow_total_issues != null) {
+    return { issues: campaign.baseline.fallow_total_issues, source: "campaign.baseline" };
+  }
+  if (campaign?.baseline?.fallow_total_issues != null) {
+    return { issues: campaign.baseline.fallow_total_issues, source: "campaign.baseline.legacy" };
+  }
+  return { issues: null, source: "none" };
+}
+
+function loadLayerSummary(iterDir, file, summarize) {
+  const fullPath = path.join(iterDir, file);
+  if (!fs.existsSync(fullPath)) return null;
+  const payload = readJson(fullPath, {});
+  if (payload._remediation?.summary) return payload._remediation.summary;
+  return summarize(payload);
+}
+
+function normalizeWeights(weights, skipKeys = []) {
+  const active = { ...weights };
+  for (const key of skipKeys) delete active[key];
+  const sum = Object.values(active).reduce((a, b) => a + b, 0);
+  if (sum <= 0) return weights;
+  const normalized = {};
+  for (const [key, value] of Object.entries(active)) {
+    normalized[key] = value / sum;
+  }
+  return normalized;
+}
+
+function resolveVerify(iterDir) {
+  const debt = readJson(path.join(iterDir, "verify-debt.json"), null);
+  if (debt) return { verify: debt, source: "verify-debt.json" };
+  const iteration = readJson(path.join(iterDir, "verify-iteration.json"), null);
+  if (iteration) return { verify: iteration, source: "verify-iteration.json" };
+  return { verify: {}, source: "missing" };
+}
+
+function loadClassification(iterDir, campaignId, iteration) {
+  const classPath = path.join(iterDir, "fallow-classification.json");
+  if (fs.existsSync(classPath)) {
+    return readJson(classPath, null);
+  }
+  spawnSync(
+    process.execPath,
+    [
+      path.join(__dirname, "classify-fallow-issues.mjs"),
+      "--campaign-id",
+      campaignId,
+      "--iteration",
+      String(iteration),
+    ],
+    { encoding: "utf8" },
+  );
+  return readJson(classPath, null);
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("compute-satisfaction: --campaign-id required");
+  process.exit(2);
+}
+
+const campaignDir = path.join(CAMPAIGNS_ROOT, args.campaignId);
+const campaign = readJson(path.join(campaignDir, "campaign.json"));
+const iterDir = path.join(campaignDir, "iterations", String(args.iteration));
+
+const deadSummary = loadLayerSummary(iterDir, "fallow-scan.json", summarizeDeadCode) ?? {};
+const dupesSummary = loadLayerSummary(iterDir, "fallow-dupes.json", summarizeDupes);
+const healthSummary = loadLayerSummary(iterDir, "fallow-health.json", summarizeHealth);
+
+const classification = loadClassification(iterDir, args.campaignId, args.iteration);
+const { verify, source: verifySource } = resolveVerify(iterDir);
+
+const rawTotalIssues = deadSummary.total_issues ?? 0;
+const actionableTotal =
+  classification?.summary?.actionable_total ?? rawTotalIssues;
+const falsePositiveTotal = classification?.summary?.false_positive_total ?? 0;
+const reviewTotal = classification?.summary?.review_total ?? 0;
+
+const { issues: rawBaselineIssues, source: baselineSource } = resolveFallowStartBaseline(
+  campaignDir,
+  campaign,
+);
+const actionableBaseline = resolveActionableBaseline(campaignDir);
+const startActionable =
+  actionableBaseline?.actionable_total ??
+  (rawBaselineIssues != null && classification
+    ? rawBaselineIssues - (actionableBaseline?.false_positive_total ?? 0)
+    : rawBaselineIssues) ??
+  actionableTotal;
+
+const effectiveBaseline = startActionable ?? actionableTotal;
+
+const dupesBaseline = readStartBaseline(campaignDir, "fallow-start-dupes-baseline.json", "clone_groups");
+const healthBaseline = readStartBaseline(
+  campaignDir,
+  "fallow-start-health-baseline.json",
+  "health_score",
+);
+
+const currentCloneGroups = dupesSummary?.clone_groups ?? null;
+const currentHealthScore = healthSummary?.health_score ?? null;
+
+const dupesStart =
+  dupesBaseline.value ??
+  readJson(path.join(iterDir, "iteration-baseline.json"), null)?.fallow_dupes_clone_groups ??
+  currentCloneGroups;
+
+const healthStart =
+  healthBaseline.value ??
+  readJson(path.join(iterDir, "iteration-baseline.json"), null)?.fallow_health_score ??
+  currentHealthScore;
+
+const skipWeightKeys = [];
+if (dupesSummary == null || dupesStart == null || currentCloneGroups == null) {
+  skipWeightKeys.push("fallow_dupes");
+}
+if (healthSummary == null || healthStart == null || currentHealthScore == null) {
+  skipWeightKeys.push("fallow_health");
+}
+const effectiveWeights = normalizeWeights(WEIGHTS, skipWeightKeys);
+const effectiveFallowWeight =
+  (effectiveWeights.fallow_dead_code ?? 0) +
+  (effectiveWeights.fallow_dupes ?? 0) +
+  (effectiveWeights.fallow_health ?? 0);
+
+const prevEntry = readJson(path.join(campaignDir, "satisfaction-history.yaml"), { entries: [] });
+const prev = prevEntry.entries.filter((e) => e.iteration < args.iteration).pop();
+
+const iterBaseline = readJson(path.join(iterDir, "iteration-baseline.json"), null);
+const prevActionable = prev?.fallow_actionable_total ?? prev?.fallow_total_issues;
+const iterationStartActionable =
+  iterBaseline?.fallow_actionable_total ??
+  iterBaseline?.fallow_total_issues ??
+  prevActionable ??
+  effectiveBaseline;
+
+const deadCodeRate =
+  effectiveBaseline > 0
+    ? Math.max(0, (effectiveBaseline - actionableTotal) / effectiveBaseline)
+    : 1;
+
+const dupesRate =
+  dupesSummary != null && dupesStart != null && currentCloneGroups != null
+    ? (reductionRate(dupesStart, currentCloneGroups) ?? 0)
+    : null;
+const healthRate =
+  healthSummary != null && healthStart != null && currentHealthScore != null
+    ? (improvementRate(healthStart, currentHealthScore) ?? 0)
+    : null;
+
+const fallowCompositeRate =
+  effectiveFallowWeight > 0
+    ? ((deadCodeRate * (effectiveWeights.fallow_dead_code ?? 0)) +
+        (dupesRate ?? 0) * (effectiveWeights.fallow_dupes ?? 0) +
+        (healthRate ?? 0) * (effectiveWeights.fallow_health ?? 0)) /
+      effectiveFallowWeight
+    : deadCodeRate;
+
+const iterationRate =
+  iterationStartActionable > 0
+    ? Math.max(0, (iterationStartActionable - actionableTotal) / iterationStartActionable)
+    : deadCodeRate;
+
+const structuralClean =
+  (deadSummary.unresolved_imports ?? 0) === 0 && (deadSummary.circular_dependencies ?? 0) === 0;
+
+const vitestPass = verify.vitest?.status === "pass";
+const typecheckPass = verify.typecheck?.status === "pass";
+const buildPass = verify.build?.status === "pass";
+const goTestPass = verify.go_test?.status === "pass" || verify.go_test?.status === "skipped";
+const e2ePass = verify.playwright?.status === "pass";
+
+const components = {
+  fallow_dead_code: scoreComponent(null, deadCodeRate),
+  fallow_dupes: dupesRate == null ? null : scoreComponent(null, dupesRate),
+  fallow_health: healthRate == null ? null : scoreComponent(null, healthRate),
+  fallow_remediation: scoreComponent(null, fallowCompositeRate),
+  structural_clean: scoreComponent(structuralClean),
+  unit_tests: scoreComponent(vitestPass && typecheckPass),
+  build: scoreComponent(buildPass),
+  e2e: scoreComponent(e2ePass),
+};
+
+let score = 0;
+for (const [key, weight] of Object.entries(effectiveWeights)) {
+  score += (components[key] ?? 0) * weight * 100;
+}
+score = Math.round(score * 10) / 10;
+
+const entry = {
+  iteration: args.iteration,
+  at: isoNow(),
+  score,
+  rate: Math.round(fallowCompositeRate * 1000) / 1000,
+  dead_code_rate: Math.round(deadCodeRate * 1000) / 1000,
+  dupes_rate: dupesRate == null ? null : Math.round(dupesRate * 1000) / 1000,
+  health_rate: healthRate == null ? null : Math.round(healthRate * 1000) / 1000,
+  iteration_rate: Math.round(iterationRate * 1000) / 1000,
+  fallow_raw_total: rawTotalIssues,
+  fallow_actionable_total: actionableTotal,
+  fallow_false_positive_total: falsePositiveTotal,
+  fallow_review_total: reviewTotal,
+  fallow_dupes_clone_groups: currentCloneGroups,
+  fallow_dupes_duplication_percentage: dupesSummary?.duplication_percentage ?? null,
+  fallow_health_score: currentHealthScore,
+  fallow_health_functions_above_threshold: healthSummary?.functions_above_threshold ?? null,
+  fallow_start_baseline: effectiveBaseline,
+  fallow_start_baseline_raw: rawBaselineIssues,
+  fallow_dupes_start_baseline: dupesStart,
+  fallow_health_start_baseline: healthStart,
+  fallow_baseline_source: baselineSource,
+  fallow_dupes_baseline_source: dupesBaseline.source,
+  fallow_health_baseline_source: healthBaseline.source,
+  fallow_scoring_mode: "actionable_dead_code_plus_dupes_health",
+  delta_vs_baseline: actionableTotal - effectiveBaseline,
+  delta_vs_baseline_raw: rawTotalIssues - (rawBaselineIssues ?? rawTotalIssues),
+  delta_dupes_vs_baseline: currentCloneGroups - (dupesStart ?? currentCloneGroups),
+  delta_health_vs_baseline:
+    currentHealthScore != null && healthStart != null ? currentHealthScore - healthStart : null,
+  delta_vs_iteration_start: actionableTotal - iterationStartActionable,
+  delta_vs_previous: prev
+    ? actionableTotal - (prev.fallow_actionable_total ?? prev.fallow_total_issues)
+    : null,
+  e2e_pass: e2ePass,
+  vitest_pass: vitestPass,
+  typecheck_pass: typecheckPass,
+  build_pass: buildPass,
+  go_test_pass: goTestPass,
+  weights_applied: effectiveWeights,
+  weights_skipped_layers: skipWeightKeys,
+  components,
+  classification_path: path.join(iterDir, "fallow-classification.json"),
+  fallow_dupes_path: path.join(iterDir, "fallow-dupes.json"),
+  fallow_health_path: path.join(iterDir, "fallow-health.json"),
+  verify_path: path.join(
+    iterDir,
+    verifySource === "verify-debt.json" ? "verify-debt.json" : "verify-iteration.json",
+  ),
+  verify_source: verifySource,
+  /** @deprecated use fallow_actionable_total */
+  fallow_total_issues: actionableTotal,
+};
+
+writeJson(path.join(iterDir, "satisfaction.json"), entry);
+
+const history = readJson(path.join(campaignDir, "satisfaction-history.yaml"), { entries: [] });
+history.entries = history.entries.filter((e) => e.iteration !== args.iteration);
+history.entries.push(entry);
+history.entries.sort((a, b) => a.iteration - b.iteration);
+writeJson(path.join(campaignDir, "satisfaction-history.yaml"), history);
+
+if (campaign) {
+  campaign.current = {
+    fallow_total_issues: rawTotalIssues,
+    fallow_actionable_total: actionableTotal,
+    fallow_false_positive_total: falsePositiveTotal,
+    fallow_dupes_clone_groups: currentCloneGroups,
+    fallow_health_score: currentHealthScore,
+    satisfaction_score: score,
+    satisfaction_rate: entry.rate,
+    e2e_pass: e2ePass,
+    verify_status: verify.status ?? null,
+  };
+  campaign.updated_at = isoNow();
+  const threshold = campaign.config?.satisfaction_threshold ?? 85;
+  if (
+    score >= threshold &&
+    e2ePass &&
+    vitestPass &&
+    typecheckPass &&
+    buildPass &&
+    (verify.metrics?.total_errors ?? 0) === 0
+  ) {
+    campaign.status = "satisfied";
+  }
+  writeJson(path.join(campaignDir, "campaign.json"), campaign);
+}
+
+const journalLine = `- **Iteration ${args.iteration}** — satisfaction **${score}/100** (fallow composite ${(entry.rate * 100).toFixed(1)}%: dead-code ${(deadCodeRate * 100).toFixed(1)}%${dupesRate != null ? `, dupes ${(dupesRate * 100).toFixed(1)}%` : ""}${healthRate != null ? `, health ${(healthRate * 100).toFixed(1)}%` : ""}), fallow raw=${rawTotalIssues} actionable=${actionableTotal} (FP=${falsePositiveTotal})${currentCloneGroups != null ? `, dupes=${currentCloneGroups} groups` : ""}${currentHealthScore != null ? `, health=${currentHealthScore}` : ""}, E2E ${e2ePass ? "PASS" : "FAIL"}\n`;
+fs.appendFileSync(path.join(campaignDir, "journal.md"), `\n### ${entry.at}\n${journalLine}`);
+
+console.log(JSON.stringify({ ok: true, satisfaction: entry, satisfied: campaign?.status === "satisfied" }));

package/templates/cursor/aaac/scripts/remediation/debt-sweep-gate.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * Strict debt sweep — mandatory phase after cleanup waves.
+ * Loops remediator-gate --mode debt until all layers pass or max rounds exhausted.
+ *
+ * Exit codes:
+ *   0 — debt sweep complete (strict pass)
+ *   1 — blocked (max rounds exhausted)
+ *   3 — remediate required (agent must fix and re-run with --round N --attempt M+1)
+ *
+ * Usage:
+ *   node debt-sweep-gate.mjs --campaign-id <id> --iteration <n> \
+ *     [--run-id <run_id>] [--round <n>] [--attempt <n>]
+ */
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, isoNow, readJson, writeJson, runDir } from "../run-engine/lib.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+const REMEDIATOR_GATE = path.join(__dirname, "remediator-gate.mjs");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0, runId: null, round: 1, attempt: 1 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--campaign-id") out.campaignId = argv[++i];
+    else if (a === "--iteration") out.iteration = Number(argv[++i]);
+    else if (a === "--run-id") out.runId = argv[++i];
+    else if (a === "--round") out.round = Number(argv[++i]);
+    else if (a === "--attempt") out.attempt = Number(argv[++i]);
+  }
+  return out;
+}
+
+function campaignDir(id) {
+  return path.join(CAMPAIGNS_ROOT, id);
+}
+
+function appendJournal(campaignId, text) {
+  fs.appendFileSync(path.join(campaignDir(campaignId), "journal.md"), text);
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("debt-sweep-gate: --campaign-id required");
+  process.exit(2);
+}
+
+const campaignPath = path.join(campaignDir(args.campaignId), "campaign.json");
+const campaign = readJson(campaignPath, {});
+const maxRounds = campaign?.config?.max_debt_sweep_rounds ?? 10;
+const iterDir = path.join(campaignDir(args.campaignId), "iterations", String(args.iteration));
+fs.mkdirSync(iterDir, { recursive: true });
+
+const statePath = path.join(iterDir, "debt-sweep-state.json");
+let sweepState = readJson(statePath, {
+  status: "running",
+  round: args.round,
+  attempts_by_round: {},
+  started_at: isoNow(),
+});
+
+const gateArgs = [
+  REMEDIATOR_GATE,
+  "--campaign-id",
+  args.campaignId,
+  "--iteration",
+  String(args.iteration),
+  "--mode",
+  "debt",
+  "--attempt",
+  String(args.attempt),
+];
+if (args.runId) gateArgs.push("--run-id", args.runId);
+
+const result = spawnSync(process.execPath, gateArgs, { encoding: "utf8" });
+let payload = null;
+try {
+  payload = JSON.parse(result.stdout.trim().split("\n").pop());
+} catch {
+  console.error("debt-sweep-gate: failed to parse remediator-gate output");
+  process.exit(2);
+}
+
+const roundKey = String(args.round);
+sweepState.attempts_by_round[roundKey] = sweepState.attempts_by_round[roundKey] ?? [];
+sweepState.attempts_by_round[roundKey].push({
+  attempt: args.attempt,
+  at: isoNow(),
+  exit_code: result.status,
+  action: payload.action,
+});
+sweepState.round = args.round;
+sweepState.updated_at = isoNow();
+
+if (result.status === 0 && (payload.action === "promote" || payload.action === "promote_wave")) {
+  sweepState.status = "complete";
+  sweepState.completed_at = isoNow();
+  writeJson(statePath, sweepState);
+
+  if (campaign) {
+    campaign.debt_sweep = {
+      status: "complete",
+      iteration: args.iteration,
+      round: args.round,
+      completed_at: isoNow(),
+    };
+    campaign.updated_at = isoNow();
+    writeJson(campaignPath, campaign);
+  }
+
+  appendJournal(args.campaignId, `- Debt sweep **COMPLETE** iter ${args.iteration} round ${args.round}\n`);
+
+  const output = {
+    action: "debt_sweep_complete",
+    status: "pass",
+    round: args.round,
+    attempt: args.attempt,
+    sweep_state_path: statePath,
+    verify_path: payload.verify_path,
+  };
+  if (args.runId) {
+    writeJson(path.join(runDir(args.runId), "artifacts", "debt_sweep.json"), output);
+  }
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+if (result.status === 3) {
+  writeJson(statePath, sweepState);
+  const output = {
+    ...payload,
+    debt_sweep_round: args.round,
+    max_debt_sweep_rounds: maxRounds,
+    campaign_must_continue: true,
+    orchestrator_must_not_stop: true,
+    retry_command: `node .cursor/aaac/scripts/remediation/debt-sweep-gate.mjs --campaign-id ${args.campaignId} --iteration ${args.iteration} --round ${args.round} --attempt ${args.attempt + 1}${args.runId ? ` --run-id ${args.runId}` : ""}`,
+  };
+  appendJournal(
+    args.campaignId,
+    `- Debt sweep round ${args.round} attempt ${args.attempt}: **remediate** — continue loop\n`,
+  );
+  if (args.runId) {
+    writeJson(path.join(runDir(args.runId), "artifacts", "debt_sweep_handoff.json"), output);
+  }
+  console.log(JSON.stringify(output));
+  process.exit(3);
+}
+
+if (result.status === 1) {
+  if (args.round < maxRounds) {
+    sweepState.status = "running";
+    writeJson(statePath, sweepState);
+    const nextRound = args.round + 1;
+    const output = {
+      action: "debt_sweep_next_round",
+      status: "fail",
+      round: args.round,
+      next_round: nextRound,
+      max_debt_sweep_rounds: maxRounds,
+      campaign_must_continue: true,
+      message: `Round ${args.round} blocked — starting round ${nextRound}`,
+      retry_command: `node .cursor/aaac/scripts/remediation/debt-sweep-gate.mjs --campaign-id ${args.campaignId} --iteration ${args.iteration} --round ${nextRound} --attempt 1${args.runId ? ` --run-id ${args.runId}` : ""}`,
+    };
+    appendJournal(args.campaignId, `- Debt sweep round ${args.round} blocked — advancing to round ${nextRound}\n`);
+    console.log(JSON.stringify(output));
+    process.exit(3);
+  }
+
+  sweepState.status = "blocked";
+  sweepState.blocked_at = isoNow();
+  writeJson(statePath, sweepState);
+
+  if (campaign) {
+    campaign.debt_sweep = { status: "blocked", iteration: args.iteration, round: args.round };
+    campaign.status = "blocked";
+    campaign.updated_at = isoNow();
+    writeJson(campaignPath, campaign);
+  }
+
+  const output = {
+    action: "debt_sweep_blocked",
+    status: "fail",
+    reason: "max_debt_sweep_rounds_exhausted",
+    round: args.round,
+    max_debt_sweep_rounds: maxRounds,
+    campaign_must_continue: false,
+    payload,
+  };
+  appendJournal(args.campaignId, `- Debt sweep **BLOCKED** after ${maxRounds} rounds\n`);
+  if (args.runId) {
+    writeJson(path.join(runDir(args.runId), "artifacts", "debt_sweep.json"), output);
+  }
+  console.log(JSON.stringify(output));
+  process.exit(1);
+}
+
+console.error("debt-sweep-gate: unexpected remediator exit", result.status);
+process.exit(2);

package/templates/cursor/aaac/scripts/remediation/dispatch-rules.json

@@ -0,0 +1,44 @@
+{
+  "version": 1,
+  "description": "Validator failure → remediator command dispatch (SSOT for /remediate-app)",
+  "defaults": {
+    "max_remediator_attempts_per_wave": 3,
+    "max_remediator_attempts_per_iteration": 3,
+    "max_remediator_attempts_per_debt_round": 3,
+    "max_debt_sweep_rounds": 10,
+    "wave_gate_mode": "regression"
+  },
+  "layers": {
+    "typecheck": {
+      "command": "fix-module",
+      "level": "code",
+      "intent_template": "TypeScript type-check failed during remediation campaign {campaign_id} iter {iteration} wave {wave_index} attempt {attempt}. Fix compiler errors without widening types unsafely. Output:\n{evidence}"
+    },
+    "vitest": {
+      "command": "fix-module",
+      "level": "test",
+      "intent_template": "Unit tests failed during remediation campaign {campaign_id} iter {iteration} wave {wave_index} attempt {attempt}. Fix production code or test expectations as appropriate. Output:\n{evidence}"
+    },
+    "go_test": {
+      "command": "fix-module",
+      "level": "code",
+      "intent_template": "Go tests failed during remediation campaign {campaign_id} iter {iteration} wave {wave_index} attempt {attempt}. Fix failing packages. Output:\n{evidence}"
+    },
+    "build": {
+      "command": "fix-module",
+      "level": "code",
+      "intent_template": "Production build failed during remediation campaign {campaign_id} iter {iteration} attempt {attempt}. Fix build errors and broken imports. Output:\n{evidence}"
+    },
+    "playwright": {
+      "command": "fix-bug",
+      "level": "code",
+      "intent_template": "Playwright E2E failed during campaign {campaign_id} iter {iteration} attempt {attempt}. Fix runtime/module/navigation regressions. Output:\n{evidence}"
+    },
+    "playwright_infra": {
+      "command": null,
+      "level": "infrastructure",
+      "handoff": "Start dev server (see project.config.json remediation.verify.dev_server) then re-run remediator-gate"
+    }
+  },
+  "evidence_priority": ["typecheck", "build", "vitest", "go_test", "playwright"]
+}

package/templates/cursor/aaac/scripts/remediation/fallow-fp-rules.json

@@ -0,0 +1,87 @@
+{
+  "version": 1,
+  "description": "SSOT rules for classifying Fallow findings before remediation scoring and wave planning",
+  "sources": {
+    "fallowrc": "frontend/.fallowrc.json",
+    "campaign_registry": "fallow-false-positives.yaml"
+  },
+  "path_globs": [
+    {
+      "id": "fallowrc_dynamically_loaded",
+      "glob": "from_fallowrc_dynamicallyLoaded",
+      "classification": "false_positive",
+      "reason": "dynamically_loaded_entry_point"
+    },
+    {
+      "id": "worker_hooks",
+      "glob": "src/hooks/*Worker*.ts",
+      "classification": "false_positive",
+      "reason": "worker_hook_runtime"
+    },
+    {
+      "id": "overlay_renderer_barrels",
+      "glob": "src/overlays/renderers/*/index.ts",
+      "classification": "false_positive",
+      "reason": "overlay_renderer_barrel"
+    }
+  ],
+  "path_regex": [
+    {
+      "id": "overlay_integration",
+      "pattern": "^src/overlays/integration/",
+      "classification": "review",
+      "reason": "overlay_integration_runtime"
+    },
+    {
+      "id": "lazy_route",
+      "pattern": "\\.lazy\\.(tsx?|jsx?)$",
+      "classification": "review",
+      "reason": "lazy_route_entry"
+    }
+  ],
+  "issue_heuristics": {
+    "unused_file": [
+      {
+        "id": "runtime_visibility_note",
+        "action_note_contains": "runtime functionality not visible to static analysis",
+        "classification": "review",
+        "reason": "runtime_visibility_risk"
+      }
+    ],
+    "unused_export": [
+      {
+        "id": "barrel_index_reexport",
+        "path_suffix": "/index.ts",
+        "is_re_export": true,
+        "classification": "review",
+        "reason": "barrel_reexport_facade"
+      },
+      {
+        "id": "barrel_index_any",
+        "path_suffix": "/index.ts",
+        "classification": "review",
+        "reason": "barrel_public_api"
+      }
+    ],
+    "unused_types": [
+      {
+        "id": "type_in_barrel",
+        "path_suffix": "/index.ts",
+        "classification": "review",
+        "reason": "barrel_type_facade"
+      }
+    ],
+    "unused_class_members": [
+      {
+        "id": "ws_shared_base_public_api",
+        "path_suffix": "websocketService.shared.ts",
+        "classification": "false_positive",
+        "reason": "base_class_public_api_inherited_by_subclasses"
+      }
+    ]
+  },
+  "scoring": {
+    "actionable_classifications": ["true_positive", "review"],
+    "excluded_from_satisfaction": ["false_positive"]
+  }
+}