goalbuddy 0.3.1 → 0.3.5

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);
+}

package/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/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/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

package/internal/cli/goal-maker.mjs

@@ -52,6 +52,8 @@ const optionsWithValues = new Set([
   "--port",
   "--source",
   "--target",
+  "--task",
+  "--board",
 ]);
 
 const args = process.argv.slice(2);
@@ -116,6 +118,12 @@ async function main() {
     case "board":
       await board();
       break;
+    case "prompt":
+      await prompt();
+      break;
+    case "parallel-plan":
+      await parallelPlan();
+      break;
     case "help":
     case "--help":
     case "-h":
@@ -191,6 +199,8 @@ Usage:
   ${canonicalCliName} extend install --all [--catalog-url <url-or-path>] [--dry-run] [--force] [--json]
   ${canonicalCliName} extend doctor [<id>] [--codex-home <path>] [--json]
   ${canonicalCliName} board <docs/goals/slug> [--catalog-url <url-or-path>] [--host <host>] [--port <port>] [--once] [--json]
+  ${canonicalCliName} prompt <docs/goals/slug> [--task T###] [--board <path/to/state.yaml>] [--json]
+  ${canonicalCliName} parallel-plan <docs/goals/slug> [--json]
 
 Targets: by default, install/update prepares both Codex (~/.codex) and Claude Code (~/.claude). Use --target codex or --target claude to limit the command.
 
@@ -713,13 +723,15 @@ function installPlugin({ quiet = false } = {}) {
     throw new Error(`Failed to add Codex plugin marketplace: ${firstLine(marketplace.stderr || marketplace.stdout)}`);
   }
 
+  const legacySkillPaths = legacyCodexSkillRoots();
   const existingPluginSkillPath = installedPluginSkillRoot();
-  const preservedExtensions = preserveInstalledExtensions([existingPluginSkillPath], { tempRoot: dirname(pluginCachePath) });
+  const preservedExtensions = preserveInstalledExtensions([existingPluginSkillPath, ...legacySkillPaths], { tempRoot: dirname(pluginCachePath) });
   mkdirSync(dirname(pluginCachePath), { recursive: true });
   rmSync(pluginCachePath, { recursive: true, force: true });
   cpSync(pluginSource, pluginCachePath, { recursive: true });
   restoreInstalledExtensions(pluginSkillPath, preservedExtensions.tempPath);
   cleanupPreservedExtensions([preservedExtensions.tempPath]);
+  const removedLegacySkillPaths = cleanupLegacyCodexSkills();
   const configPath = enablePluginConfig();
 
   const report = {
@@ -732,6 +744,7 @@ function installPlugin({ quiet = false } = {}) {
     cache_path: pluginCachePath,
     config_path: configPath,
     preserved_extensions: preservedExtensions.ids,
+    removed_legacy_skill_paths: removedLegacySkillPaths,
   };
 
   if (hasFlag("--json") && !quiet) {
@@ -748,6 +761,9 @@ function installPlugin({ quiet = false } = {}) {
   if (report.preserved_extensions.length) {
     console.log(`Preserved extensions: ${report.preserved_extensions.join(", ")}`);
   }
+  if (report.removed_legacy_skill_paths.length) {
+    console.log(`Removed legacy personal skills: ${report.removed_legacy_skill_paths.join(", ")}`);
+  }
   console.log("");
   console.log("Restart Codex, then use:");
   console.log(`  $${canonicalSkillName}`);
@@ -758,6 +774,20 @@ function installPlugin({ quiet = false } = {}) {
   return report;
 }
 
+function legacyCodexSkillRoots() {
+  return [installedSkillRoot(), legacyInstalledSkillRoot()];
+}
+
+function cleanupLegacyCodexSkills() {
+  const removed = [];
+  for (const path of legacyCodexSkillRoots()) {
+    if (!existsSync(path)) continue;
+    rmSync(path, { recursive: true, force: true });
+    removed.push(path);
+  }
+  return removed;
+}
+
 function pluginCacheRoot(version) {
   return join(codexHome(), "plugins", "cache", pluginName, pluginName, version);
 }
@@ -941,6 +971,39 @@ async function board() {
   process.exit(result.status ?? 1);
 }
 
+async function prompt() {
+  if (hasFlag("--parallel-plan")) {
+    await parallelPlan();
+    return;
+  }
+
+  const script = join(skillSource, "scripts", "render-task-prompt.mjs");
+  const scriptArgs = [script, ...args.slice(1)];
+  const result = spawnSync(process.execPath, scriptArgs, {
+    cwd: packageRoot,
+    encoding: "utf8",
+    env: process.env,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) throw result.error;
+  process.exit(result.status ?? 1);
+}
+
+async function parallelPlan() {
+  const script = join(skillSource, "scripts", "parallel-plan.mjs");
+  const scriptArgs = [script, ...args.slice(1).filter((arg) => arg !== "--parallel-plan")];
+  const result = spawnSync(process.execPath, scriptArgs, {
+    cwd: packageRoot,
+    encoding: "utf8",
+    env: process.env,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) throw result.error;
+  process.exit(result.status ?? 1);
+}
+
 async function ensureLocalBoardExtension() {
   const id = "local-goal-board";
   const script = join(extensionTarget(id), "scripts", "local-goal-board.mjs");
@@ -1240,6 +1303,7 @@ function installedPluginSkillRoot() {
   const versions = readdirSync(root, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
     .map((entry) => entry.name)
+    .filter(isSupportedVersion)
     .sort(compareVersions)
     .reverse();
   for (const version of versions) {
@@ -1403,9 +1467,9 @@ function preserveInstalledExtensions(targets, { tempRoot = "" } = {}) {
     if (!target) continue;
     const source = join(target, "extend");
     if (!existsSync(source)) continue;
-    mkdirSync(tempPath, { recursive: true });
     for (const entry of readdirSync(source, { withFileTypes: true })) {
       if (bundledCoreExtensionIds.has(entry.name)) continue;
+      mkdirSync(tempPath, { recursive: true });
       const from = join(source, entry.name);
       const to = join(tempPath, entry.name);
       cpSync(from, to, { recursive: true, force: true });
@@ -1639,6 +1703,10 @@ function normalizeVersion(value) {
   return `${Number(match[1])}.${Number(match[2])}.${Number(match[3])}`;
 }
 
+function isSupportedVersion(value) {
+  return /^v?\d+\.\d+\.\d+(?:[-+].*)?$/.test(String(value).trim());
+}
+
 function compareVersions(left, right) {
   const leftParts = normalizeVersion(left).split(".").map((part) => Number.parseInt(part, 10) || 0);
   const rightParts = normalizeVersion(right).split(".").map((part) => Number.parseInt(part, 10) || 0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goalbuddy",
-  "version": "0.3.1",
-  "description": "A /goal operating system for Codex and Claude Code: Scout/Judge/Worker boards with visual board surfaces, receipts, and verification.",
+  "version": "0.3.5",
+  "description": "A /goal operating system for Codex and Claude Code: subgoals, parallel-agent-ready boards, dark mode, receipts, and verification.",
   "type": "module",
   "bin": {
     "goalbuddy": "internal/cli/goal-maker.mjs",
@@ -10,6 +10,7 @@
   "files": [
     ".agents/plugins/marketplace.json",
     "README.md",
+    "RELEASE-0.3.5.md",
     "CONTRIBUTING.md",
     "examples",
     "plugins/goalbuddy",

package/plugins/goalbuddy/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "goalbuddy",
-  "version": "0.3.1",
-  "description": "Turn broad Claude Code work into verified GoalBuddy boards with Scout, Judge, Worker, visual boards, and receipts.",
+  "version": "0.3.5",
+  "description": "Turn broad Claude Code work into verified GoalBuddy boards with subgoals, parallel-agent-ready handoffs, dark mode, and receipts.",
   "author": {
     "name": "tolibear",
     "email": "support@tolibear.com",

package/plugins/goalbuddy/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "goalbuddy",
-  "version": "0.3.1",
-  "description": "Turn broad Codex and Claude Code work into verified GoalBuddy boards with Scout, Judge, Worker, visual boards, and receipts.",
+  "version": "0.3.5",
+  "description": "Turn broad Codex and Claude Code work into verified GoalBuddy boards with subgoals, parallel-agent-ready handoffs, dark mode, and receipts.",
   "author": {
     "name": "tolibear",
     "email": "support@tolibear.com",
@@ -24,8 +24,8 @@
   "skills": "./skills/",
   "interface": {
     "displayName": "GoalBuddy",
-    "shortDescription": "Turn broad Codex or Claude Code work into verified Scout/Judge/Worker boards",
-    "longDescription": "GoalBuddy packages a structured goal workflow for broad, long-running, or ambiguous engineering work in Codex or Claude Code. It creates durable goal charters, task boards, visual board surfaces, receipts, verification gates, extension handoffs, and compatibility guidance for teams moving from goal-maker.",
+    "shortDescription": "Verified goal boards with subgoals, parallel-agent-ready handoffs, and dark mode",
+    "longDescription": "GoalBuddy packages a structured goal workflow for broad, long-running, or ambiguous engineering work in Codex or Claude Code. It creates durable goal charters, task boards, optional depth-1 subgoals, visual board surfaces, parallel-agent-ready handoffs, receipts, verification gates, extension handoffs, and compatibility guidance for teams moving from goal-maker.",
     "developerName": "tolibear",
     "category": "Coding",
     "capabilities": [