goalbuddy 0.3.2 → 0.3.5

package/plugins/goalbuddy/skills/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);
+}

package/plugins/goalbuddy/skills/goalbuddy/scripts/render-task-prompt.mjs

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseGoalStateText } from "../extend/local-goal-board/scripts/lib/goal-board.mjs";
+
+const ROLE_DEFAULTS = {
+  scout: { agent: "goal_scout", reasoning: "low", sandbox: "read-only" },
+  judge: { agent: "goal_judge", reasoning: "high", sandbox: "read-only" },
+  worker: { agent: "goal_worker", reasoning: "low", sandbox: "workspace-write" },
+  pm: { agent: "PM", reasoning: "medium", sandbox: "workspace-write" },
+};
+
+if (isDirectRun()) {
+  try {
+    const result = renderTaskPrompt(parseArgs(process.argv.slice(2)));
+    if (result.json) {
+      console.log(JSON.stringify(result.payload, null, 2));
+    } else {
+      console.log(formatPrompt(result.payload));
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+export function renderTaskPrompt(options) {
+  const boardPath = resolveBoardPath(options);
+  const board = loadBoard(boardPath);
+  const task = selectTask(board, options.taskId);
+  const role = normalizeRole(task.type);
+  const defaults = ROLE_DEFAULTS[role] || ROLE_DEFAULTS.pm;
+  const reasoning = normalizeReasoning(task.reasoning_hint, defaults.reasoning);
+  const warnings = promptWarnings(board, task);
+
+  return {
+    json: options.json,
+    payload: {
+      metadata: {
+        recommended_agent: defaults.agent,
+        recommended_reasoning: reasoning,
+        sandbox: defaults.sandbox,
+        fork_context_allowed: role !== "worker",
+        board_path: board.path,
+        child_board_paths: childBoardPaths(board),
+        warnings,
+      },
+      task: {
+        id: task.id,
+        type: role,
+        assignee: task.assignee || defaults.agent,
+        status: task.status,
+        objective: task.objective || "",
+        inputs: stringList(task.inputs),
+        constraints: stringList(task.constraints),
+        allowed_files: stringList(task.allowed_files),
+        verify: stringList(task.verify),
+        stop_if: stringList(task.stop_if),
+        reasoning_hint: task.reasoning_hint || null,
+        expected_output: stringList(task.expected_output),
+      },
+      receipt_schema: receiptSchema(role),
+    },
+  };
+}
+
+export function parseArgs(args) {
+  const options = { goalRoot: "", boardPath: "", taskId: "", json: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--task") {
+      options.taskId = args[++index] || "";
+    } else if (arg.startsWith("--task=")) {
+      options.taskId = arg.slice("--task=".length);
+    } else if (arg === "--board") {
+      options.boardPath = args[++index] || "";
+    } else if (arg.startsWith("--board=")) {
+      options.boardPath = arg.slice("--board=".length);
+    } else if (arg === "--parallel-plan") {
+      options.parallelPlan = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    } else if (!options.goalRoot) {
+      options.goalRoot = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+  if (!options.goalRoot && !options.boardPath) {
+    throw new Error("Usage: goalbuddy prompt <goal-root> [--task T###] [--board path/to/state.yaml]");
+  }
+  return options;
+}
+
+export function loadBoard(boardPath) {
+  if (!existsSync(boardPath)) throw new Error(`state file not found: ${boardPath}`);
+  const document = parseGoalStateText(readFileSync(boardPath, "utf8"));
+  if (!document || Number(document.version) !== 2) {
+    throw new Error(`unsupported GoalBuddy state version in ${boardPath}`);
+  }
+  if (!Array.isArray(document.tasks)) throw new Error(`state file has no tasks: ${boardPath}`);
+  return {
+    path: boardPath,
+    root: dirname(boardPath),
+    document,
+    tasks: document.tasks,
+    goal: document.goal || {},
+    activeTask: document.active_task || "",
+  };
+}
+
+export function resolveBoardPath(options) {
+  const candidate = options.boardPath || options.goalRoot;
+  if (!candidate) throw new Error("Missing goal root or board path.");
+  const resolved = resolve(candidate);
+  if (basename(resolved) === "state.yaml") return resolved;
+  return resolve(resolved, "state.yaml");
+}
+
+export function selectTask(board, taskId = "") {
+  const id = taskId || board.activeTask;
+  if (!id) throw new Error(`No task selected and active_task is empty in ${board.path}`);
+  const task = board.tasks.find((candidate) => candidate?.id === id);
+  if (!task) throw new Error(`Task ${id} not found in ${board.path}`);
+  return task;
+}
+
+export function childBoardPaths(board) {
+  return board.tasks
+    .map((task) => task?.subgoal?.path)
+    .filter(Boolean)
+    .map((childPath) => resolve(board.root, childPath));
+}
+
+function promptWarnings(board, task) {
+  const warnings = [];
+  const role = normalizeRole(task.type);
+  if (task.id !== board.activeTask) warnings.push(`Task ${task.id} is not the active task on this board.`);
+  if (role === "worker") {
+    if (stringList(task.allowed_files).length === 0) warnings.push(`Worker task ${task.id} has no allowed_files.`);
+    if (stringList(task.verify).length === 0) warnings.push(`Worker task ${task.id} has no verify commands.`);
+    if (stringList(task.stop_if).length === 0) warnings.push(`Worker task ${task.id} has no stop_if conditions.`);
+  }
+  for (const candidate of board.tasks) {
+    if (candidate?.subgoal && Number(candidate.subgoal.depth) !== 1) {
+      warnings.push(`Task ${candidate.id} has subgoal.depth ${candidate.subgoal.depth || "<missing>"}; only depth 1 is supported.`);
+    }
+  }
+  return warnings;
+}
+
+function normalizeRole(value) {
+  const role = String(value || "pm").toLowerCase();
+  return ROLE_DEFAULTS[role] ? role : "pm";
+}
+
+function normalizeReasoning(value, fallback) {
+  const hint = String(value || "").toLowerCase();
+  if (["low", "medium", "high", "xhigh"].includes(hint)) return hint;
+  return fallback;
+}
+
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((item) => item !== null && item !== undefined).map(String) : [];
+}
+
+function receiptSchema(role) {
+  if (role === "worker") {
+    return {
+      result: "done | blocked",
+      changed_files: [],
+      commands: [{ cmd: "<command>", status: "pass | fail | not_run" }],
+      summary: "<=120 words",
+      remaining_blockers: [],
+      needs_judge: false,
+    };
+  }
+  if (role === "judge") {
+    return {
+      result: "done | blocked",
+      decision: "approve_next | reject_next | approve_subgoal | reject_subgoal | not_complete | complete",
+      evidence: [],
+      next_allowed_task: null,
+      blocked_tasks: [],
+      required_board_updates: [],
+    };
+  }
+  return {
+    result: "done | blocked",
+    summary: "<=120 words",
+    evidence: [],
+    facts: [],
+    contradictions: [],
+    ambiguity_requiring_judge: [],
+  };
+}
+
+function formatPrompt(payload) {
+  const lines = [
+    "GoalBuddy task prompt",
+    "",
+    "Metadata:",
+    `- recommended_agent: ${payload.metadata.recommended_agent}`,
+    `- recommended_reasoning: ${payload.metadata.recommended_reasoning}`,
+    `- sandbox: ${payload.metadata.sandbox}`,
+    `- fork_context_allowed: ${payload.metadata.fork_context_allowed}`,
+    `- board_path: ${payload.metadata.board_path}`,
+  ];
+  if (payload.metadata.child_board_paths.length) {
+    lines.push("- child_board_paths:");
+    for (const path of payload.metadata.child_board_paths) lines.push(`  - ${path}`);
+  }
+  if (payload.metadata.warnings.length) {
+    lines.push("- warnings:");
+    for (const warning of payload.metadata.warnings) lines.push(`  - ${warning}`);
+  }
+
+  lines.push(
+    "",
+    "Task:",
+    `- id: ${payload.task.id}`,
+    `- type: ${payload.task.type}`,
+    `- assignee: ${payload.task.assignee}`,
+    `- status: ${payload.task.status}`,
+    `- objective: ${payload.task.objective}`,
+  );
+  addList(lines, "inputs", payload.task.inputs);
+  addList(lines, "constraints", payload.task.constraints);
+  addList(lines, "allowed_files", payload.task.allowed_files);
+  addList(lines, "verify", payload.task.verify);
+  addList(lines, "stop_if", payload.task.stop_if);
+  addList(lines, "expected_output", payload.task.expected_output);
+  lines.push("", "Expected receipt JSON shape:", JSON.stringify(payload.receipt_schema, null, 2));
+  return lines.join("\n");
+}
+
+function addList(lines, label, values) {
+  if (!values.length) return;
+  lines.push(`- ${label}:`);
+  for (const value of values) lines.push(`  - ${value}`);
+}
+
+function isDirectRun() {
+  return process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}

package/plugins/goalbuddy/skills/goalbuddy/templates/agents.md

@@ -4,7 +4,7 @@ Use three generic agents. The main `/goal` thread remains PM and owns the board.
 
 | Agent | model_reasoning_effort | sandbox_mode | Purpose |
 |---|---:|---|---|
-| goal_scout | medium | read-only | Evidence mapping and candidate tasks |
+| goal_scout | low | read-only | Targeted evidence mapping and candidate facts |
 | goal_worker | low | workspace-write | One bounded implementation/recovery task |
 | goal_judge | high | read-only | Strategic review, escalation, completion skepticism |
 
@@ -44,5 +44,5 @@ Rules:
 
 - Only the PM loop chooses active tasks, marks tasks done, or completes the goal.
 - Keep at most one write-capable Worker active unless disjoint write scopes are explicit in `state.yaml`.
-- Scout and Judge are read-only.
+- Scout and Judge are read-only and safe to parallelize when their board inputs are clear.
 - Judge is high thinking.

package/plugins/goalbuddy/skills/goalbuddy/templates/state.yaml

@@ -109,6 +109,14 @@ tasks:
       - "Need files outside allowed_files."
       - "Behavior is ambiguous."
       - "Verification fails twice."
+    # Optional depth-1 child board promoted by PM when a task needs bounded branching work:
+    # subgoal:
+    #   status: active # active | blocked | done
+    #   path: subgoals/T003-child/state.yaml
+    #   owner: Worker
+    #   created_from: T003
+    #   depth: 1
+    #   rollup_receipt: null
     receipt: null
   - id: T999
     type: judge