@tritard/waterbrother 0.14.21 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.14.21",
+  "version": "0.15.0",
   "description": "Waterbrother: Grok-powered coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/scorecard.js

@@ -4,11 +4,25 @@ import crypto from "node:crypto";
 
 const MAX_INDEX_ENTRIES = 200;
 const MAX_CALIBRATION_CHARS = 2000;
+const MAX_GLOBAL_CALIBRATION_CHARS = 800;
 
 function scorecardsDir(cwd) {
   return path.join(cwd, ".waterbrother", "memory", "scorecards");
 }
 
+function globalScorecardsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path.join(home, ".waterbrother", "global-scorecards");
+}
+
+function globalIndexPath() {
+  return path.join(globalScorecardsDir(), "index.json");
+}
+
+function globalScorecardPath(id) {
+  return path.join(globalScorecardsDir(), `${id}.json`);
+}
+
 function indexPath(cwd) {
   return path.join(scorecardsDir(cwd), "index.json");
 }
@@ -285,11 +299,12 @@ async function writeIndex(cwd, index) {
 }
 
 export async function saveScorecard({ cwd, scorecard }) {
+  // Save to project
   await fs.mkdir(scorecardsDir(cwd), { recursive: true });
   await fs.writeFile(scorecardPath(cwd, scorecard.id), `${JSON.stringify(scorecard, null, 2)}\n`, "utf8");
 
   const index = await readIndex(cwd);
-  index.unshift({
+  const entry = {
     id: scorecard.id,
     taskName: scorecard.taskName,
     scope: scorecard.scope,
@@ -297,9 +312,24 @@ export async function saveScorecard({ cwd, scorecard }) {
     composite: scorecard.scores.composite,
     precision: scorecard.precision,
     timestamp: scorecard.timestamp
-  });
+  };
+  index.unshift(entry);
   if (index.length > MAX_INDEX_ENTRIES) index.length = MAX_INDEX_ENTRIES;
   await writeIndex(cwd, index);
+
+  // Save to global store (cross-project learning)
+  try {
+    const gDir = globalScorecardsDir();
+    await fs.mkdir(gDir, { recursive: true });
+    await fs.writeFile(globalScorecardPath(scorecard.id), `${JSON.stringify(scorecard, null, 2)}\n`, "utf8");
+
+    let gIndex = [];
+    try { gIndex = JSON.parse(await fs.readFile(globalIndexPath(), "utf8")); } catch {}
+    if (!Array.isArray(gIndex)) gIndex = [];
+    gIndex.unshift({ ...entry, project: path.basename(cwd) });
+    if (gIndex.length > MAX_INDEX_ENTRIES) gIndex.length = MAX_INDEX_ENTRIES;
+    await fs.writeFile(globalIndexPath(), `${JSON.stringify(gIndex, null, 2)}\n`, "utf8");
+  } catch {}
 }
 
 export async function findRelevantScorecards({ cwd, filePatterns = [], limit = 10 }) {
@@ -369,6 +399,94 @@ export function suggestAutonomyForScope(scorecards) {
   return "scoped";
 }
 
+// --- Global scorecards (cross-project learning) ---
+
+export async function loadGlobalScorecards({ limit = 20 } = {}) {
+  const gDir = globalScorecardsDir();
+  try {
+    const raw = await fs.readFile(path.join(gDir, "index.json"), "utf8");
+    const index = JSON.parse(raw);
+    if (!Array.isArray(index)) return [];
+    const cards = [];
+    for (const entry of index.slice(0, limit)) {
+      try {
+        const data = await fs.readFile(globalScorecardPath(entry.id), "utf8");
+        cards.push({ ...JSON.parse(data), _project: entry.project });
+      } catch {}
+    }
+    return cards;
+  } catch {
+    return [];
+  }
+}
+
+export function buildGlobalCalibrationBlock(globalCards) {
+  if (!globalCards || globalCards.length < 3) return "";
+
+  const lines = ["Cross-project patterns (from your build history):"];
+  let chars = lines[0].length;
+
+  // Aggregate stats
+  const totalBuilds = globalCards.length;
+  const avgComposite = globalCards.reduce((s, c) => s + (c.scores?.composite || 0), 0) / totalBuilds;
+
+  // Find recurring blind spots across projects
+  const allFindings = {};
+  const allConcerns = {};
+  const attrSums = { plan: 0, execution: 0, verification: 0, sentinel: 0 };
+  const attrCounts = { plan: 0, execution: 0, verification: 0, sentinel: 0 };
+
+  for (const sc of globalCards) {
+    for (const f of (sc.outcomes?.quality?.findings || [])) {
+      allFindings[f] = (allFindings[f] || 0) + 1;
+    }
+    for (const c of (sc.outcomes?.sentinel?.concerns || [])) {
+      // Generalize concern — strip file-specific details
+      const generic = c.replace(/[`'"]\S+[`'"]/g, "...").replace(/\b\w+\.(js|ts|py|jsx|tsx|vue)\b/g, "...");
+      allConcerns[generic] = (allConcerns[generic] || 0) + 1;
+    }
+    if (sc.attribution) {
+      for (const key of Object.keys(attrSums)) {
+        if (sc.attribution[key] !== null && sc.attribution[key] !== undefined) {
+          attrSums[key] += sc.attribution[key];
+          attrCounts[key]++;
+        }
+      }
+    }
+  }
+
+  const line1 = `${totalBuilds} builds across projects, avg composite: ${avgComposite.toFixed(2)}`;
+  lines.push(line1);
+  chars += line1.length;
+
+  // Weakest stage globally
+  const attrAvgs = {};
+  for (const key of Object.keys(attrSums)) {
+    if (attrCounts[key] > 0) attrAvgs[key] = attrSums[key] / attrCounts[key];
+  }
+  const stages = Object.entries(attrAvgs).sort((a, b) => a[1] - b[1]);
+  if (stages.length > 0 && stages[0][1] < 0.5) {
+    const line = `Global weak stage: ${stages[0][0]} (avg ${stages[0][1].toFixed(2)}) — consistently underperforms across projects.`;
+    if (chars + line.length <= MAX_GLOBAL_CALIBRATION_CHARS) { lines.push(line); chars += line.length; }
+  }
+
+  // Recurring quality issues
+  const recurring = Object.entries(allFindings).filter(([, c]) => c >= 2).sort((a, b) => b[1] - a[1]).slice(0, 3);
+  if (recurring.length > 0) {
+    const line = `Recurring quality issues: ${recurring.map(([f, c]) => `${f} (${c}x)`).join(", ")}`;
+    if (chars + line.length <= MAX_GLOBAL_CALIBRATION_CHARS) { lines.push(line); chars += line.length; }
+  }
+
+  // Recurring sentinel concerns
+  const recurringConcerns = Object.entries(allConcerns).filter(([, c]) => c >= 2).sort((a, b) => b[1] - a[1]).slice(0, 2);
+  if (recurringConcerns.length > 0) {
+    const line = `Recurring sentinel flags: ${recurringConcerns.map(([c, n]) => `${c.slice(0, 60)} (${n}x)`).join("; ")}`;
+    if (chars + line.length <= MAX_GLOBAL_CALIBRATION_CHARS) { lines.push(line); chars += line.length; }
+  }
+
+  return lines.join("\n");
+}
+
 // --- Layer 2: Context injection ---
 
 export function buildCalibrationBlock(scorecards) {

package/src/voice.js

@@ -714,14 +714,20 @@ export async function setupVoice(onStatus) {
           playArgs = [mp3Path];
         } else if (process.platform === "win32") {
           // Use sox to play the audio — it's already installed for recording
-          if (soxPath) {
-            playCmd = soxPath;
-            playArgs = [mp3Path, "-d"];
-          } else {
-            // Fallback: PowerShell Start-Process to open in default player
-            playCmd = "powershell.exe";
-            playArgs = ["-NoProfile", "-Command", `Start-Process "${mp3Path}" -Wait`];
-          }
+          // Use PowerShell to play MP3 via Windows Media Player COM
+          const psScript = `
+$wmp = New-Object -ComObject WMPlayer.OCX
+$wmp.URL = "${mp3Path.replace(/\\/g, "\\\\")}"
+$wmp.controls.play()
+Start-Sleep -Milliseconds 500
+while($wmp.playState -eq 3){ Start-Sleep -Milliseconds 200 }
+$wmp.close()
+`.trim();
+          const psPath = path.join(tmpDir, `tts-${ts}.ps1`);
+          await fs.writeFile(psPath, psScript);
+          cleanupFiles.push(psPath);
+          playCmd = "powershell.exe";
+          playArgs = ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", psPath];
         } else {
           playCmd = "mpv";
           playArgs = ["--no-video", "--really-quiet", mp3Path];

package/src/workflow.js

@@ -16,7 +16,7 @@ import {
 } from "./frontend.js";
 import { runPlannerPass, formatPlanForExecutor, formatPlanForDisplay } from "./planner.js";
 import { runVerificationPass, formatVerifierResults, hasFailures } from "./verifier.js";
-import { computeScorecard, saveScorecard, findRelevantScorecards, buildCalibrationBlock, generatePredictions } from "./scorecard.js";
+import { computeScorecard, saveScorecard, findRelevantScorecards, buildCalibrationBlock, generatePredictions, loadGlobalScorecards, buildGlobalCalibrationBlock } from "./scorecard.js";
 
 export async function runBuildWorkflow({
   agent,
@@ -40,6 +40,12 @@ export async function runBuildWorkflow({
         predictions = generatePredictions(relevantCards);
       }
     }
+    // Global calibration — cross-project learning
+    const globalCards = await loadGlobalScorecards({ limit: 20 });
+    const globalBlock = buildGlobalCalibrationBlock(globalCards);
+    if (globalBlock) {
+      calibrationBlock = calibrationBlock ? `${calibrationBlock}\n\n${globalBlock}` : globalBlock;
+    }
   } catch {}
 
   // Planner/Executor split: if plannerModel is configured, run planner first