goalbuddy 0.3.2 → 0.3.6

package/goalbuddy/scripts/check-goal-state.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join, resolve, sep } from "node:path";
 
 const statePath = process.argv[2];
+const isChildCheck = process.argv.includes("--child");
 
 if (!statePath) {
   console.error("Usage: node scripts/check-goal-state.mjs docs/goals/<slug>/state.yaml");
@@ -98,6 +100,7 @@ function parseTasks() {
     verify: taskList(task, "verify"),
     stopIf: taskList(task, "stop_if"),
     receipt: taskReceipt(task),
+    subgoal: taskSubgoal(task),
   }));
 }
 
@@ -149,6 +152,32 @@ function taskReceipt(task) {
   };
 }
 
+function taskSubgoal(task) {
+  const lines = task.raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^\s{4}subgoal:\s*/.test(line));
+  if (start === -1) return { present: false };
+
+  const subgoalLines = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s{4}\S/.test(lines[i])) break;
+    subgoalLines.push(lines[i]);
+  }
+  const raw = subgoalLines.join("\n");
+  const scalar = (key) => {
+    const match = raw.match(new RegExp(`^\\s{6}${key}:\\s*(.*?)\\s*$`, "m"));
+    return match ? clean(match[1]) : null;
+  };
+
+  return {
+    present: true,
+    raw,
+    status: scalar("status"),
+    path: scalar("path"),
+    owner: scalar("owner"),
+    depth: scalar("depth"),
+  };
+}
+
 function receiptList(raw, key) {
   const lines = raw.split(/\r?\n/);
   const start = lines.findIndex((line) => new RegExp(`^\\s{6}${key}:\\s*$`).test(line));
@@ -169,16 +198,16 @@ function receiptCommandStatuses(raw) {
 }
 
 function rootEntryErrors() {
-  const allowed = new Set(["goal.md", "state.yaml", "notes", ".goalbuddy-board"]);
+  const allowed = new Set(["goal.md", "state.yaml", "notes", ".goalbuddy-board", "subgoals"]);
   const unexpected = [];
   for (const entry of readdirSync(root).filter((item) => item !== ".DS_Store")) {
     const path = join(root, entry);
     const stats = statSync(path);
     if (!allowed.has(entry)) {
       unexpected.push(entry);
-    } else if ((entry === "notes" || entry === ".goalbuddy-board") && !stats.isDirectory()) {
+    } else if ((entry === "notes" || entry === ".goalbuddy-board" || entry === "subgoals") && !stats.isDirectory()) {
       unexpected.push(`${entry} (must be a directory)`);
-    } else if (entry !== "notes" && entry !== ".goalbuddy-board" && !stats.isFile()) {
+    } else if (!["notes", ".goalbuddy-board", "subgoals"].includes(entry) && !stats.isFile()) {
       unexpected.push(`${entry} (must be a file)`);
     }
   }
@@ -241,7 +270,7 @@ if (!existsSync(join(root, "notes")) || !statSync(join(root, "notes")).isDirecto
 
 const unexpected = rootEntryErrors();
 if (unexpected.length > 0) {
-  errors.push(`unexpected root entries; v2 goal roots may contain only goal.md, state.yaml, notes/, and .goalbuddy-board/: ${unexpected.join(", ")}`);
+  errors.push(`unexpected root entries; v2 goal roots may contain only goal.md, state.yaml, notes/, subgoals/, and .goalbuddy-board/: ${unexpected.join(", ")}`);
 }
 
 const tasks = parseTasks();
@@ -298,6 +327,10 @@ if (activeTasks.length === 1 && activeTask !== activeTasks[0].id) {
 if (activeTask && !ids.has(activeTask)) errors.push(`active_task points to unknown task: ${activeTask}`);
 
 for (const task of tasks) {
+  if (task.subgoal.present) {
+    validateSubgoal(task);
+  }
+
   const hasReceipt = task.receipt.present && task.receipt.value !== null;
   const receiptResult = hasReceipt ? task.receipt.scalar("result") : null;
   if (task.status === "done" && !hasReceipt) {
@@ -319,8 +352,11 @@ for (const task of tasks) {
       if (!task.receipt.has(key)) errors.push(`Worker receipt for ${task.id} missing ${key}`);
     }
     const changedFiles = task.receipt.list("changed_files");
+    if (changedFiles.length === 0) {
+      errors.push(`Worker receipt for ${task.id} changed_files must list at least one file`);
+    }
     for (const changedFile of changedFiles) {
-      if (!task.allowedFiles.includes(changedFile)) {
+      if (!matchesAllowedFile(changedFile, task.allowedFiles)) {
         errors.push(`Worker receipt for ${task.id} changed file outside allowed_files: ${changedFile}`);
       }
     }
@@ -333,6 +369,9 @@ for (const task of tasks) {
         errors.push(`Worker receipt for ${task.id} has non-passing command status: ${status}`);
       }
     }
+    if (task.receipt.scalar("needs_judge") === true) {
+      warnings.push(`Worker receipt for ${task.id} requests legacy needs_judge; GoalBuddy now lets the PM continue by default and reviews only at phase, risk, ambiguity, rejected-verification, or final-completion boundaries`);
+    }
   }
   if (task.type === "scout" && task.status === "done" && hasReceipt) {
     if (!task.receipt.has("summary")) errors.push(`Scout receipt for ${task.id} missing summary`);
@@ -345,6 +384,153 @@ for (const task of tasks) {
   }
 }
 
+warnings.push(...microSliceWarnings(tasks, activeTask, goalStatus));
+
+function validateSubgoal(task) {
+  if (isChildCheck) {
+    errors.push(`child task ${task.id} must not contain a nested subgoal`);
+    return;
+  }
+
+  if (!["active", "blocked", "done"].includes(task.subgoal.status)) {
+    errors.push(`task ${task.id} subgoal.status must be active, blocked, or done; got ${task.subgoal.status || "<missing>"}`);
+  }
+  if (task.subgoal.depth !== 1) {
+    errors.push(`task ${task.id} subgoal.depth must be 1; got ${task.subgoal.depth || "<missing>"}`);
+  }
+  if (!task.subgoal.path) {
+    errors.push(`task ${task.id} subgoal.path is required`);
+    return;
+  }
+
+  const rootPath = resolve(root);
+  const childStatePath = resolve(rootPath, task.subgoal.path);
+  if (childStatePath !== rootPath && !childStatePath.startsWith(`${rootPath}${sep}`)) {
+    errors.push(`task ${task.id} subgoal.path must stay inside the goal root: ${task.subgoal.path}`);
+    return;
+  }
+  if (basename(childStatePath) !== "state.yaml") {
+    errors.push(`task ${task.id} subgoal.path must point to a state.yaml file`);
+    return;
+  }
+  if (!existsSync(childStatePath)) {
+    errors.push(`task ${task.id} subgoal state file not found: ${task.subgoal.path}`);
+    return;
+  }
+
+  const result = spawnSync(process.execPath, [process.argv[1], childStatePath, "--child"], {
+    encoding: "utf8",
+  });
+  let report = null;
+  try {
+    report = JSON.parse(result.stdout);
+  } catch {
+    errors.push(`task ${task.id} subgoal checker produced invalid output for ${task.subgoal.path}`);
+    return;
+  }
+  if (result.status !== 0 || !report.ok) {
+    for (const childError of report.errors || ["unknown child state error"]) {
+      errors.push(`task ${task.id} subgoal invalid: ${childError}`);
+    }
+  }
+}
+
+function microSliceWarnings(tasks, activeTaskId, goalStatus) {
+  const found = [];
+  const guidance = "Board may be micro-slicing. Prefer the largest safe useful slice.";
+  const doneTasks = tasks.filter((task) => task.status === "done");
+  const workerTasks = tasks.filter((task) => task.type === "worker");
+  const recentTinyWorkers = workerTasks.slice(-5).filter((task) => isTinyTask(task));
+  const firstMilestoneComplete = nestedScalar("goal", "first_milestone_complete") === true;
+
+  if (recentTinyWorkers.length >= 3) {
+    found.push(`${guidance} Three recent Worker tasks look tiny.`);
+  }
+
+  for (const task of tasks) {
+    if (task.type === "judge" && /pick small reviewable work|select one narrow next task/i.test(task.raw)) {
+      found.push(`${guidance} Judge instructions still ask for small or narrow work.`);
+      break;
+    }
+  }
+
+  if (goalStatus !== "active" || !activeTaskId) return [...new Set(found)];
+  const activeIndex = tasks.findIndex((task) => task.id === activeTaskId);
+  if (activeIndex === -1) return [...new Set(found)];
+  const active = tasks[activeIndex];
+  if (active.type === "worker") {
+    if (doneTasks.length >= 10 && active.allowedFiles.length > 0 && active.allowedFiles.length <= 2) {
+      found.push(`${guidance} Active Worker ${active.id} has only ${active.allowedFiles.length} allowed_files after ${doneTasks.length} completed tasks.`);
+    }
+    if (firstMilestoneComplete && isTinyTask(active)) {
+      found.push(`${guidance} The first milestone is complete, so the active Worker should move toward the next real milestone.`);
+    }
+    if (isMicroWorkerTask(active)) {
+      found.push(`${guidance} Active Worker ${active.id} looks like another helper-sized slice.`);
+    }
+  }
+  if (active.type !== "judge") return [...new Set(found)];
+
+  let pairs = 0;
+  for (let index = activeIndex; index > 0; index -= 2) {
+    const judge = tasks[index];
+    const worker = tasks[index - 1];
+    if (!isMicroJudgeForWorker(judge, worker)) break;
+    pairs += 1;
+  }
+  if (pairs >= 2) {
+    found.push(`${guidance} Micro Worker/Judge loop detected ending at ${active.id}.`);
+  }
+  return [...new Set(found)];
+}
+
+function isMicroJudgeForWorker(judge, worker) {
+  if (!judge || !worker) return false;
+  if (judge.type !== "judge" || worker.type !== "worker") return false;
+  if (!["active", "queued", "done"].includes(judge.status) || worker.status !== "done") return false;
+  const objective = String(judge.objective || "").toLowerCase();
+  return objective.includes(worker.id.toLowerCase()) && /audit|review|approve/.test(objective) && isMicroWorkerTask(worker);
+}
+
+function isMicroWorkerTask(task) {
+  if (!task || task.type !== "worker") return false;
+  const objective = String(task.objective || "").toLowerCase();
+  if (/collapsed|batch|package|tranche/.test(objective)) return false;
+  return /one narrow|single helper|one helper|per[- ]helper|per[- ]table|projection helper/.test(objective);
+}
+
+function isTinyTask(task) {
+  if (!task) return false;
+  const text = [task.objective, task.raw, task.receipt?.raw].join(" ").toLowerCase();
+  if (/collapsed|batch|package|tranche|vertical slice|milestone/.test(text)) return false;
+  return /\b(tiny|narrow|single helper|one helper|projection helper|projection function|contract file|read-only proof|doc note|validator|validation wrapper|pure helper|caller-input)\b/.test(text);
+}
+
+function matchesAllowedFile(file, allowedFiles) {
+  return allowedFiles.some((pattern) => globMatch(pattern, file));
+}
+
+function globMatch(pattern, file) {
+  const normalizedPattern = normalizePathPattern(pattern);
+  const normalizedFile = normalizePathPattern(file);
+  if (normalizedPattern === normalizedFile) return true;
+  const token = "__GOALBUDDY_GLOBSTAR__";
+  const regexSource = escapeRegExp(normalizedPattern)
+    .replace(/\*\*/g, token)
+    .replace(/\*/g, "[^/]*")
+    .replace(new RegExp(token, "g"), ".*");
+  const regex = new RegExp(`^${regexSource}$`);
+  return regex.test(normalizedFile);
+}
+
+function normalizePathPattern(value) {
+  return String(value || "").replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+
 if (goalStatus === "done") {
   const finalAudit = tasks.some((task) => {
     if (!["judge", "pm"].includes(task.type) || task.status !== "done") return false;

package/goalbuddy/scripts/parallel-plan.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { childBoardPaths, loadBoard, parseArgs, resolveBoardPath, selectTask } from "./render-task-prompt.mjs";
+
+if (isDirectRun()) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const plan = createParallelPlan(options);
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log(formatPlan(plan));
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+export function createParallelPlan(options) {
+  const rootBoardPath = resolveBoardPath(options);
+  const boards = [loadBoard(rootBoardPath)];
+  for (const childPath of childBoardPaths(boards[0])) {
+    if (existsSync(childPath)) boards.push(loadBoard(childPath));
+  }
+
+  const candidates = boards.map((board) => candidateForBoard(board));
+  const workerCandidates = candidates.filter((candidate) => candidate.role === "worker");
+  return {
+    root_board_path: rootBoardPath,
+    mutated: false,
+    spawned_agents: false,
+    candidates: candidates.map((candidate) => ({
+      ...candidate,
+      safe_to_parallelize: isSafeCandidate(candidate, workerCandidates),
+      reason: safetyReason(candidate, workerCandidates),
+      render_prompt_command: promptCommand(candidate),
+    })),
+  };
+}
+
+function candidateForBoard(board) {
+  const task = selectTask(board);
+  const role = normalizeRole(task.type);
+  return {
+    board_path: board.path,
+    task_id: task.id,
+    role,
+    recommended_agent: role === "scout" ? "goal_scout" : role === "judge" ? "goal_judge" : role === "worker" ? "goal_worker" : "PM",
+    reasoning_hint: reasoningHint(task, role),
+    allowed_files: Array.isArray(task.allowed_files) ? task.allowed_files.map(String) : [],
+  };
+}
+
+function isSafeCandidate(candidate, workers) {
+  if (candidate.role === "scout" || candidate.role === "judge") return true;
+  if (candidate.role !== "worker") return false;
+  if (workers.length < 2) return false;
+  if (candidate.allowed_files.length === 0) return false;
+  return workers
+    .filter((worker) => worker !== candidate)
+    .every((worker) => worker.allowed_files.length > 0 && areDisjoint(candidate.allowed_files, worker.allowed_files));
+}
+
+function safetyReason(candidate, workers) {
+  if (candidate.role === "scout") return "Scout is read-only.";
+  if (candidate.role === "judge") return "Judge is read-only.";
+  if (candidate.role !== "worker") return "PM tasks mutate board truth and should stay serial.";
+  if (candidate.allowed_files.length === 0) return "Worker has no allowed_files, so write scope is unknown.";
+  const overlapping = workers
+    .filter((worker) => worker !== candidate)
+    .filter((worker) => worker.allowed_files.length === 0 || !areDisjoint(candidate.allowed_files, worker.allowed_files));
+  if (overlapping.length === 0) return workers.length > 1 ? "Worker write scope is disjoint from other active Workers." : "Only one active Worker candidate; parallel Worker safety needs a disjoint peer.";
+  return `Worker write scope overlaps or cannot be compared with ${overlapping.map((worker) => `${relative(process.cwd(), worker.board_path)}:${worker.task_id}`).join(", ")}.`;
+}
+
+function promptCommand(candidate) {
+  return `goalbuddy prompt --board ${quote(candidate.board_path)} --task ${candidate.task_id}`;
+}
+
+function areDisjoint(left, right) {
+  return left.every((leftPattern) => right.every((rightPattern) => !patternsOverlap(leftPattern, rightPattern)));
+}
+
+function patternsOverlap(left, right) {
+  const a = normalizePattern(left);
+  const b = normalizePattern(right);
+  const aHasGlob = hasGlob(a);
+  const bHasGlob = hasGlob(b);
+  if (a === b) return true;
+  if (a.endsWith("/**") && b.startsWith(a.slice(0, -3))) return true;
+  if (b.endsWith("/**") && a.startsWith(b.slice(0, -3))) return true;
+  if (!aHasGlob && !bHasGlob) return false;
+  if (!aHasGlob) return globToRegExp(b).test(a);
+  if (!bHasGlob) return globToRegExp(a).test(b);
+  if (hasUnsupportedGlob(a) || hasUnsupportedGlob(b)) return literalPrefixesMayOverlap(a, b);
+  return literalPrefixesMayOverlap(a, b);
+}
+
+function literalPrefixesMayOverlap(left, right) {
+  const a = literalPrefix(left);
+  const b = literalPrefix(right);
+  if (!a || !b) return true;
+  return a.startsWith(b) || b.startsWith(a);
+}
+
+function literalPrefix(pattern) {
+  const match = /[*?[\]]/.exec(pattern);
+  return match ? pattern.slice(0, match.index) : pattern;
+}
+
+function hasUnsupportedGlob(pattern) {
+  return /[\[\]]/.test(pattern);
+}
+
+function globToRegExp(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      source += ".*";
+      index += 1;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function hasGlob(pattern) {
+  return /[*?[\]]/.test(pattern);
+}
+
+function normalizePattern(pattern) {
+  return String(pattern || "").replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function normalizeRole(value) {
+  const role = String(value || "pm").toLowerCase();
+  return ["scout", "judge", "worker", "pm"].includes(role) ? role : "pm";
+}
+
+function reasoningHint(task, role) {
+  const hint = String(task.reasoning_hint || "").toLowerCase();
+  if (["low", "medium", "high", "xhigh"].includes(hint)) return hint;
+  if (role === "judge") return "high";
+  return "low";
+}
+
+function quote(value) {
+  return JSON.stringify(resolve(value));
+}
+
+function formatPlan(plan) {
+  const lines = [
+    "GoalBuddy parallel plan",
+    "",
+    `Root board: ${plan.root_board_path}`,
+    "Mutates state: no",
+    "Spawns agents: no",
+    "",
+  ];
+  for (const candidate of plan.candidates) {
+    lines.push(
+      `${candidate.board_path}:${candidate.task_id}`,
+      `- role: ${candidate.role}`,
+      `- recommended_agent: ${candidate.recommended_agent}`,
+      `- reasoning_hint: ${candidate.reasoning_hint}`,
+      `- safe_to_parallelize: ${candidate.safe_to_parallelize}`,
+      `- reason: ${candidate.reason}`,
+      `- render_prompt_command: ${candidate.render_prompt_command}`,
+      "",
+    );
+  }
+  return lines.join("\n").trimEnd();
+}
+
+function isDirectRun() {
+  return process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}