@ludecker/aaac 1.1.5 → 1.2.0

package/templates/cursor/aaac/scripts/remediation/auto-dispatch-queue-from-health.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Build dispatch-queue.yaml from Fallow health targets + campaign focus.
+ */
+import fs from "fs";
+import path from "path";
+import { campaignDir, loadCampaign } from "./lib/runner-state.mjs";
+import { loadCampaignContext, normalizeRepoPath } from "./lib/campaign-focus.mjs";
+import {
+  fetchHealthTargets,
+  filterTargetsForWaves,
+  targetToWaveIntent,
+} from "./lib/fallow-health-targets.mjs";
+import { journal } from "./lib/runner-exec.mjs";
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: null };
+  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;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("--campaign-id required");
+  process.exit(2);
+}
+
+const ctx = loadCampaignContext(args.campaignId);
+const campaign = ctx.campaign;
+const iteration = args.iteration ?? campaign.iteration ?? 0;
+const maxWaves = campaign.config?.max_waves_per_iteration ?? 3;
+
+const { targets } = fetchHealthTargets({ scope: ctx.scope, limit: 20 });
+const filtered = filterTargetsForWaves(targets, {
+  protected_paths: ctx.protected_paths,
+  defer_high_fan_in: ctx.focus.defer_high_fan_in,
+}).slice(0, maxWaves);
+
+if (filtered.length === 0) {
+  console.error("No health targets available for waves");
+  process.exit(2);
+}
+
+const lines = [
+  `# iteration ${iteration} health waves — auto from Fallow targets`,
+  `iteration: ${iteration}`,
+  `campaign_id: ${args.campaignId}`,
+  `scope: ${ctx.scope}`,
+  `intent_focus: health`,
+  "",
+  "protected_paths:",
+  ...ctx.protected_paths.map((p) => `  - ${p}`),
+  "",
+  "waves:",
+];
+
+for (let i = 0; i < filtered.length; i++) {
+  const t = filtered[i];
+  const risk = t.effort === "high" ? "medium" : "low";
+  lines.push(`- priority: ${i + 1}`);
+  lines.push(`  command: fix-module`);
+  lines.push(`  intent: ${targetToWaveIntent(t)}`);
+  lines.push(`  risk: ${risk}`);
+}
+
+const yaml = `${lines.join("\n")}\n`;
+const dest = path.join(campaignDir(args.campaignId), "dispatch-queue.yaml");
+const artifact = path.join(campaignDir(args.campaignId), "artifacts", "dispatch-queue.yaml");
+fs.writeFileSync(dest, yaml);
+fs.mkdirSync(path.dirname(artifact), { recursive: true });
+fs.writeFileSync(artifact, yaml);
+
+journal(args.campaignId, `- **Auto dispatch-queue** iter ${iteration}: ${filtered.length} health wave(s)`);
+
+console.log(JSON.stringify({ ok: true, waves: filtered.length, paths: filtered.map((t) => t.path) }));

package/templates/cursor/aaac/scripts/remediation/bootstrap-autonomous.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * Write run + campaign artifacts when autonomous mode is active.
+ * Called from init-campaign.mjs — orchestrator MUST follow bootstrap.next_action.
+ *
+ * Usage:
+ *   node bootstrap-autonomous.mjs --run-id <id> --campaign-id <id>
+ */
+import fs from "fs";
+import path from "path";
+import { REPO_ROOT, isoNow, readJson, runDir, writeJson } from "../run-engine/lib.mjs";
+import {
+  autonomousBootstrapCommands,
+  BABYSIT_SKILL,
+} from "./lib/autonomous-mode.mjs";
+import { loadRunnerState, loadYield, runnerStatePath, yieldArtifactPath } from "./lib/runner-state.mjs";
+
+function parseArgs(argv) {
+  const out = { runId: null, campaignId: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--run-id") out.runId = argv[++i];
+    else if (a === "--campaign-id") out.campaignId = argv[++i];
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.runId || !args.campaignId) {
+  console.error("bootstrap-autonomous: --run-id and --campaign-id required");
+  process.exit(2);
+}
+
+const campaignPath = path.join(
+  REPO_ROOT,
+  ".cursor/aaac/state/campaigns",
+  args.campaignId,
+  "campaign.json",
+);
+const campaign = readJson(campaignPath, null);
+if (!campaign?.config?.autonomous) {
+  console.log(JSON.stringify({ ok: true, autonomous: false, skipped: true }));
+  process.exit(0);
+}
+
+const commands = autonomousBootstrapCommands(args.runId, args.campaignId);
+const runnerState = loadRunnerState(args.campaignId);
+const yieldPayload = loadYield(args.campaignId);
+
+const bootstrap = {
+  ok: true,
+  autonomous: true,
+  autonomous_reason: campaign.config.autonomous_reason,
+  campaign_id: args.campaignId,
+  run_id: args.runId,
+  iteration: campaign.iteration,
+  satisfaction_threshold: campaign.config.satisfaction_threshold,
+  orchestrator_mode: "shell_runner_yield_watcher",
+  skill_required: BABYSIT_SKILL,
+  orchestrator_must_not: [
+    "walk_phases_manually_in_chat",
+    "end_turn_before_runner_exit_0",
+    "report_when_satisfaction_below_threshold",
+  ],
+  loop: [
+    "read_babysit_skill",
+    "runner_health_check",
+    "remediation_yield_watcher",
+    "if_exit_3_handle_yield_then_ack_yield",
+    "repeat_until_exit_0",
+  ],
+  commands,
+  runner_state_path: runnerStatePath(args.campaignId),
+  yield_path: yieldArtifactPath(args.campaignId),
+  current_runner: runnerState,
+  pending_yield: yieldPayload,
+  next_action: yieldPayload
+    ? {
+        type: "handle_yield",
+        yield_type: yieldPayload.type,
+        ack_command: `node .cursor/aaac/scripts/remediation/remediation-runner.mjs --run-id ${args.runId} --campaign-id ${args.campaignId} --ack-yield ${yieldPayload.type}`,
+      }
+    : {
+        type: "run_until_yield",
+        command: commands.runner_until_yield,
+      },
+  at: isoNow(),
+};
+
+const runArtifact = path.join(runDir(args.runId), "artifacts", "autonomous_bootstrap.json");
+writeJson(runArtifact, bootstrap);
+
+const campaignArtifact = path.join(
+  REPO_ROOT,
+  ".cursor/aaac/state/campaigns",
+  args.campaignId,
+  "autonomous-bootstrap.json",
+);
+writeJson(campaignArtifact, bootstrap);
+
+appendJournal(args.campaignId, `- **Autonomous mode** — ${campaign.config.autonomous_reason}; bootstrap written`);
+
+console.log(JSON.stringify(bootstrap));
+
+function appendJournal(campaignId, line) {
+  const journalPath = path.join(
+    REPO_ROOT,
+    ".cursor/aaac/state/campaigns",
+    campaignId,
+    "journal.md",
+  );
+  fs.appendFileSync(journalPath, `\n${line}\n`);
+}

package/templates/cursor/aaac/scripts/remediation/capture-verify-baseline.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Capture campaign verify baseline at start (before any waves).
+ *
+ * Usage:
+ *   node capture-verify-baseline.mjs --campaign-id <id> [--run-id <run_id>]
+ */
+import fs from "fs";
+import path from "path";
+import { REPO_ROOT, isoNow, readJson, writeJson, runDir } from "../run-engine/lib.mjs";
+import {
+  runVerifySteps,
+  writeVerifyLogs,
+  summarizeMetrics,
+} from "./lib/verify-metrics.mjs";
+
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, runId: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--campaign-id") out.campaignId = argv[++i];
+    else if (argv[i] === "--run-id") out.runId = argv[++i];
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("capture-verify-baseline: --campaign-id required");
+  process.exit(2);
+}
+
+const campaignDir = path.join(CAMPAIGNS_ROOT, args.campaignId);
+const baselineDir = path.join(campaignDir, "baseline");
+fs.mkdirSync(baselineDir, { recursive: true });
+
+const report = await runVerifySteps("wave");
+writeVerifyLogs(report, baselineDir, "baseline");
+
+const snapshot = {
+  captured_at: isoNow(),
+  kind: "campaign_verify_baseline",
+  summary: summarizeMetrics(report),
+  metrics: report.metrics,
+  report_path: path.join(baselineDir, "verify-baseline.json"),
+};
+
+writeJson(snapshot.report_path, report);
+writeJson(path.join(campaignDir, "verify-baseline.json"), snapshot);
+
+const campaign = readJson(path.join(campaignDir, "campaign.json"), {});
+if (campaign) {
+  campaign.verify_baseline = snapshot.summary;
+  campaign.updated_at = isoNow();
+  writeJson(path.join(campaignDir, "campaign.json"), campaign);
+}
+
+if (args.runId) {
+  writeJson(path.join(runDir(args.runId), "artifacts", "verify_baseline.json"), snapshot);
+}
+
+const journal = `\n- **Verify baseline captured** — total_errors=${snapshot.summary.total_errors} (typecheck ${snapshot.summary.layers.typecheck.error_count}, vitest ${snapshot.summary.layers.vitest.error_count})\n`;
+fs.appendFileSync(path.join(campaignDir, "journal.md"), journal);
+
+console.log(JSON.stringify({ ok: true, baseline: snapshot }));

package/templates/cursor/aaac/scripts/remediation/capture-wave-snapshot.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Snapshot verify metrics immediately before a cleanup wave executes.
+ *
+ * Usage:
+ *   node capture-wave-snapshot.mjs --campaign-id <id> --iteration <n> --wave-index <w>
+ */
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, isoNow, writeJson } from "../run-engine/lib.mjs";
+import { summarizeMetrics } from "./lib/verify-metrics.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+const VERIFY_SCRIPT = path.join(__dirname, "verify-remediation-iteration.mjs");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0, waveIndex: 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]);
+    else if (argv[i] === "--wave-index") out.waveIndex = Number(argv[++i]);
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("capture-wave-snapshot: --campaign-id required");
+  process.exit(2);
+}
+
+spawnSync(
+  process.execPath,
+  [
+    VERIFY_SCRIPT,
+    "--campaign-id",
+    args.campaignId,
+    "--iteration",
+    String(args.iteration),
+    "--mode",
+    "wave",
+    "--label",
+    `pre-wave-${args.waveIndex}`,
+  ],
+  { encoding: "utf8" },
+);
+
+const iterDir = path.join(
+  CAMPAIGNS_ROOT,
+  args.campaignId,
+  "iterations",
+  String(args.iteration),
+);
+const prePath = path.join(iterDir, `wave-${args.waveIndex}-pre.json`);
+const verifyPath = path.join(iterDir, "verify-wave.json");
+
+let report = null;
+try {
+  report = JSON.parse(fs.readFileSync(verifyPath, "utf8"));
+} catch {
+  console.error("capture-wave-snapshot: missing verify-wave.json");
+  process.exit(2);
+}
+
+const snapshot = {
+  captured_at: isoNow(),
+  kind: "pre_wave",
+  wave_index: args.waveIndex,
+  iteration: args.iteration,
+  summary: summarizeMetrics(report),
+  metrics: report.metrics,
+};
+writeJson(prePath, snapshot);
+fs.copyFileSync(verifyPath, path.join(iterDir, `wave-${args.waveIndex}-pre-verify.json`));
+
+console.log(JSON.stringify({ ok: true, snapshot_path: prePath, summary: snapshot.summary }));

package/templates/cursor/aaac/scripts/remediation/check-swarm-raw.template.json

@@ -0,0 +1,26 @@
+{
+  "campaign_id": "campaign_EXAMPLE",
+  "iteration": 0,
+  "collected_at": "ISO8601",
+  "agents": [
+    {
+      "agent_id": "remediation-check-app-inventory",
+      "command_mirror": "check-app",
+      "answer": "partial",
+      "confidence": "high",
+      "false_positives": [
+        {
+          "path": "src/hooks/useCryptoPriceWorker.ts",
+          "export_name": null,
+          "reason": "worker_hook_runtime",
+          "evidence": "src/hooks/useCryptoPriceWorker.ts:1"
+        }
+      ],
+      "protected_paths": ["src/hooks/useCryptoPriceWorker.ts"],
+      "do_not_delete": [],
+      "safe_to_fix": [],
+      "findings": [],
+      "gaps": []
+    }
+  ]
+}

package/templates/cursor/aaac/scripts/remediation/classify-fallow-issues.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Classify Fallow scan findings and persist actionable vs false-positive SSOT.
+ *
+ * Usage:
+ *   node classify-fallow-issues.mjs --campaign-id <id> --iteration <n> [--save-actionable-baseline]
+ */
+import fs from "fs";
+import path from "path";
+import { REPO_ROOT, isoNow, readJson, writeJson } from "../run-engine/lib.mjs";
+import { classifyFallowScan, loadFpRules } from "./lib/fallow-classifier.mjs";
+
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0, saveActionableBaseline: false };
+  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 === "--save-actionable-baseline") out.saveActionableBaseline = true;
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("classify-fallow-issues: --campaign-id required");
+  process.exit(2);
+}
+
+const campaignDir = path.join(CAMPAIGNS_ROOT, args.campaignId);
+const iterDir = path.join(campaignDir, "iterations", String(args.iteration));
+const scanPath = path.join(iterDir, "fallow-scan.json");
+const scan = readJson(scanPath, null);
+
+if (!scan) {
+  console.error(`classify-fallow-issues: missing ${scanPath}`);
+  process.exit(2);
+}
+
+const classification = classifyFallowScan({
+  scan,
+  campaignDir,
+  rules: loadFpRules(),
+});
+
+const outPath = path.join(iterDir, "fallow-classification.json");
+writeJson(outPath, classification);
+
+const actionableBaselinePath = path.join(campaignDir, "fallow-start-actionable-baseline.json");
+if (args.saveActionableBaseline && !fs.existsSync(actionableBaselinePath)) {
+  writeJson(actionableBaselinePath, {
+    actionable_total: classification.summary.actionable_total,
+    raw_total: classification.summary.raw_total,
+    false_positive_total: classification.summary.false_positive_total,
+    recorded_at: isoNow(),
+    immutable: true,
+    source: "classify-fallow-issues",
+    iteration: args.iteration,
+  });
+}
+
+const campaign = readJson(path.join(campaignDir, "campaign.json"), null);
+if (campaign) {
+  campaign.current = campaign.current ?? {};
+  campaign.current.fallow_raw_total = classification.summary.raw_total;
+  campaign.current.fallow_actionable_total = classification.summary.actionable_total;
+  campaign.current.fallow_false_positive_total = classification.summary.false_positive_total;
+  campaign.updated_at = isoNow();
+  writeJson(path.join(campaignDir, "campaign.json"), campaign);
+}
+
+const journal = `\n- **Fallow classified** iter ${args.iteration}: raw=${classification.summary.raw_total}, actionable=${classification.summary.actionable_total}, false_positive=${classification.summary.false_positive_total}, review=${classification.summary.review_total}\n`;
+fs.appendFileSync(path.join(campaignDir, "journal.md"), journal);
+
+console.log(JSON.stringify({ ok: true, classification: classification.summary, path: outPath }));

package/templates/cursor/aaac/scripts/remediation/classify-verify-failure.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * Classify verify-remediation report failures → fix-module / fix-bug handoffs.
+ *
+ * Usage:
+ *   node classify-verify-failure.mjs --report <path> --campaign-id <id> [--iteration n] [--wave-index n] [--attempt n]
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, readJson } from "../run-engine/lib.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RULES_PATH = path.join(__dirname, "dispatch-rules.json");
+
+function parseArgs(argv) {
+  const out = {
+    reportPath: null,
+    campaignId: "",
+    iteration: 0,
+    waveIndex: null,
+    attempt: 1,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--report") out.reportPath = argv[++i];
+    else if (a === "--campaign-id") out.campaignId = argv[++i];
+    else if (a === "--iteration") out.iteration = Number(argv[++i]);
+    else if (a === "--wave-index") out.waveIndex = Number(argv[++i]);
+    else if (a === "--attempt") out.attempt = Number(argv[++i]);
+  }
+  return out;
+}
+
+function loadRules() {
+  return readJson(RULES_PATH, { layers: {}, evidence_priority: [] });
+}
+
+function readLogFile(logPath) {
+  if (!logPath || !fs.existsSync(logPath)) return "";
+  try {
+    return fs.readFileSync(logPath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function evidenceText(step) {
+  if (!step) return "";
+  const fromLog = readLogFile(step.log_path);
+  if (fromLog) return fromLog;
+  return [
+    step.stdout_full,
+    step.stderr_full,
+    step.stderr_tail,
+    step.stdout_tail,
+    step.detail,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function extractFilePaths(text) {
+  const paths = new Set();
+  const patterns = [
+    /(?:frontend|backend)\/[^\s:'"]+\.(?:tsx?|jsx?|go)/g,
+    /src\/[^\s:'"]+\.(?:tsx?|jsx?)/g,
+    /internal\/[^\s:'"]+\.go/g,
+    /[^\s('"]+\.(?:test|spec)\.(?:tsx?|jsx?)/g,
+  ];
+  for (const re of patterns) {
+    for (const m of text.matchAll(re)) {
+      paths.add(m[0].replace(/^[('"]+/, ""));
+    }
+  }
+  return [...paths];
+}
+
+function inferDomain(layer, evidence, ruleDomain) {
+  const paths = extractFilePaths(evidence);
+  if (paths.some((p) => p.startsWith("backend/") || p.includes("/internal/") || p.endsWith(".go"))) {
+    return "backend";
+  }
+  if (paths.some((p) => p.startsWith("frontend/") || p.startsWith("src/"))) {
+    return "frontend";
+  }
+  return ruleDomain ?? "frontend";
+}
+
+function pickCommand(layer, rule, evidence) {
+  if (layer === "playwright" && /frontend not reachable|launch via/i.test(evidence)) {
+    return { command: null, level: "infrastructure", handoff: rule.layers?.playwright_infra?.handoff ?? "/launch-se100" };
+  }
+  if (layer === "playwright" && /does not provide an export|Failed to fetch dynamically imported module|Cannot find module/i.test(evidence)) {
+    return { command: rule.module_import_command ?? "fix-module", level: "code" };
+  }
+  if (layer === "vitest" && /\.(test|spec)\.(tsx?|jsx?)/.test(evidence) && !/src\/(?!.*\.test\.)/.test(evidence.split("\n")[0] ?? "")) {
+    return { command: rule.test_file_command ?? rule.command, level: "test" };
+  }
+  return { command: rule.command, level: rule.level ?? "code" };
+}
+
+function fillTemplate(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? ""));
+}
+
+function classifyReport(report, ctx) {
+  const rules = loadRules();
+  const failedLayers = rules.evidence_priority.filter((layer) => report[layer]?.status === "fail");
+  const handoffs = [];
+
+  for (const layer of failedLayers) {
+    const rule = rules.layers[layer];
+    if (!rule) continue;
+    const evidence = evidenceText(report[layer]);
+    const picked = pickCommand(layer, rule, evidence);
+    if (picked.level === "infrastructure") {
+      handoffs.push({
+        layer,
+        level: "infrastructure",
+        command: null,
+        domain: null,
+        intent: null,
+        handoff: picked.handoff,
+        evidence: evidence.slice(0, 16000),
+        evidence_truncated: evidence.length > 16000,
+        log_path: report[layer]?.log_path ?? null,
+        file_paths: extractFilePaths(evidence),
+      });
+      continue;
+    }
+    const domain = inferDomain(layer, evidence, rule.domain);
+    const intent = fillTemplate(rule.intent_template, {
+      campaign_id: ctx.campaignId,
+      iteration: ctx.iteration,
+      wave_index: ctx.waveIndex ?? "n/a",
+      attempt: ctx.attempt,
+      evidence: evidence.slice(0, 16000),
+    });
+    handoffs.push({
+      layer,
+      level: picked.level,
+      command: picked.command,
+      domain,
+      intent,
+      slash_command: `/${picked.command} ${domain} "${intent.replace(/"/g, '\\"').slice(0, 500)}…"`,
+      evidence: evidence.slice(0, 16000),
+      evidence_truncated: evidence.length > 16000,
+      log_path: report[layer]?.log_path ?? null,
+      file_paths: extractFilePaths(evidence),
+    });
+  }
+
+  return {
+    status: handoffs.length ? "fail" : "pass",
+    failed_layers: failedLayers,
+    handoffs,
+    primary: handoffs.find((h) => h.command) ?? handoffs[0] ?? null,
+  };
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.reportPath) {
+  console.error("classify-verify-failure: --report required");
+  process.exit(2);
+}
+
+const report = readJson(args.reportPath, null);
+if (!report) {
+  console.error(`classify-verify-failure: cannot read report ${args.reportPath}`);
+  process.exit(2);
+}
+
+const classification = classifyReport(report, args);
+console.log(JSON.stringify({ ok: true, classification }));
+process.exit(classification.status === "pass" ? 0 : 1);