goalbuddy 0.3.7 → 0.3.9

package/goalbuddy/surfaces/local-goal-board/scripts/local-goal-board.mjs

@@ -33,6 +33,7 @@ const SETTINGS_OPTIONS = {
 const DEFAULT_BIND_HOST = "127.0.0.1";
 const DEFAULT_PUBLIC_HOST = "goalbuddy.localhost";
 const DEFAULT_PORT = 41737;
+const STATE_CHANGE_SETTLE_MS = 300;
 
 if (isDirectRun()) {
   main().catch((error) => {
@@ -228,8 +229,7 @@ export async function startBoardServer(options = {}) {
 
       const route = routeBoardRequest(url.pathname, boards, initialBoard);
       if (!route.board) {
-        response.writeHead(404);
-        response.end("Not found");
+        sendUnregisteredBoardPath(response, url.pathname, boards, baseUrl);
         return;
       }
       if (route.pathname === "/api/board") {
@@ -400,6 +400,28 @@ function routeBoardRequest(pathname, boards, initialBoard) {
   return matches[0] || { board: null, pathname };
 }
 
+function sendUnregisteredBoardPath(response, pathname, boards, baseUrl) {
+  response.writeHead(404, {
+    "Content-Type": "text/plain; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+  const registeredBoards = [...boards.values()].map((board) => {
+    const summary = boardSummary(board, baseUrl);
+    return `- ${summary.title}: ${summary.url}`;
+  });
+  response.end([
+    `GoalBuddy board path is not registered in this local hub: ${pathname}`,
+    "",
+    "This server is the GoalBuddy multi-board hub. Do not stop it just because a /<slug>/ board URL returned 404.",
+    "Start or rerun `npx goalbuddy board <goal-dir>` to register that goal on this same port, then open the printed /<slug>/ URL.",
+    "",
+    "Registered boards:",
+    registeredBoards.length ? registeredBoards.join("\n") : "- none",
+    "",
+    `Hub API: ${baseUrl}/api/boards`,
+  ].join("\n"));
+}
+
 function stripBoardPathPrefix(pathname, boardPath) {
   const prefix = boardPath.endsWith("/") ? boardPath.slice(0, -1) : boardPath;
   if (pathname === prefix) return "/";
@@ -420,7 +442,7 @@ async function readJsonRequest(request) {
 
 function watchGoal(goalDir, onChange) {
   const watchers = [];
-  const schedule = debounce(onChange, 80);
+  const schedule = debounce(onChange, STATE_CHANGE_SETTLE_MS);
   let watchedDirs = new Set();
 
   const rebuild = () => {

package/goalbuddy/surfaces/local-goal-board/test/local-goal-board.test.mjs

@@ -4,7 +4,7 @@ import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } f
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { createBoardPayload, writeBoardApp } from "../scripts/lib/goal-board.mjs";
+import { buildColumns, createBoardPayload, writeBoardApp } from "../scripts/lib/goal-board.mjs";
 import { parseArgs, startBoardServer } from "../scripts/local-goal-board.mjs";
 
 test("normalizes a dense goal into local board columns", () => {
@@ -23,6 +23,71 @@ test("normalizes a dense goal into local board columns", () => {
   assert.equal(scout.receipt.summary, "T001 completed during the progressive board motion demo.");
 });
 
+test("orders completed cards newest first while preserving queued order", () => {
+  const columns = buildColumns([
+    { id: "T001", column: "completed", status: "done" },
+    { id: "T002", column: "todo", status: "queued" },
+    { id: "T003", column: "completed", status: "done" },
+    { id: "T004", column: "todo", status: "queued" },
+  ]);
+
+  assert.deepEqual(columns.find((column) => column.id === "todo").tasks.map((task) => task.id), ["T002", "T004"]);
+  assert.deepEqual(columns.find((column) => column.id === "completed").tasks.map((task) => task.id), ["T003", "T001"]);
+});
+
+test("renders multiple active tasks in the in-progress column", () => {
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-multiple-active-"));
+  try {
+    const goalDir = join(root, "parallel-workers");
+    mkdirSync(join(goalDir, "notes"), { recursive: true });
+    writeFileSync(join(goalDir, "state.yaml"), `version: 2
+goal:
+  title: "Parallel workers"
+  slug: "parallel-workers"
+  kind: specific
+  tranche: "Render disjoint active workers."
+  status: active
+active_task: T001
+tasks:
+  - id: T001
+    type: worker
+    assignee: Worker A
+    status: active
+    objective: "Patch the board parser."
+    allowed_files:
+      - goalbuddy/surfaces/local-goal-board/scripts/lib/goal-board.mjs
+    verify:
+      - node --test goalbuddy/surfaces/local-goal-board/test/local-goal-board.test.mjs
+    stop_if:
+      - "Need files outside allowed_files."
+    receipt: null
+  - id: T002
+    type: worker
+    assignee: Worker B
+    status: active
+    objective: "Patch the board tests."
+    allowed_files:
+      - goalbuddy/surfaces/local-goal-board/test/local-goal-board.test.mjs
+    verify:
+      - node --test goalbuddy/surfaces/local-goal-board/test/local-goal-board.test.mjs
+    stop_if:
+      - "Need files outside allowed_files."
+    receipt: null
+`);
+
+    const payload = createBoardPayload(goalDir);
+    assert.equal(payload.goal.activeTask, "T001");
+    assert.equal(payload.counts.inProgress, 2);
+    assert.deepEqual(
+      payload.columns.find((column) => column.id === "in-progress").tasks.map((task) => task.id),
+      ["T001", "T002"],
+    );
+    assert.deepEqual(payload.tasks.filter((task) => task.active).map((task) => task.id), ["T001", "T002"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("loads depth-1 subgoal boards into parent task payloads", () => {
   const payload = createBoardPayload(resolve("goalbuddy/surfaces/local-goal-board/examples/subgoal-parent"));
   const parentTask = payload.tasks.find((task) => task.id === "T004");
@@ -37,10 +102,10 @@ test("loads depth-1 subgoal boards into parent task payloads", () => {
   assert.equal(parentTask.subgoal.board.tasks.find((task) => task.id === "T002").subgoal, null);
 });
 
-test("uses compact card titles while preserving full objectives", () => {
-  const root = mkdtempSync(join(tmpdir(), "goalbuddy-compact-titles-"));
+test("uses readable card titles while preserving full objectives", () => {
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-readable-titles-"));
   try {
-    const goalDir = join(root, "compact-titles");
+    const goalDir = join(root, "readable-titles");
     mkdirSync(join(goalDir, "notes"), { recursive: true });
     writeFileSync(join(goalDir, "state.yaml"), `version: 2
 goal:
@@ -70,6 +135,13 @@ tasks:
     status: queued
     objective: "This objective can stay much more detailed because it belongs in the modal, not on the card face."
     receipt: null
+  - id: T004
+    title: "Run installed-Cursor runtime proof for a named model request through the local BYOK bridge"
+    type: worker
+    assignee: Worker
+    status: queued
+    objective: "Run installed-Cursor runtime proof for a named model request through the local BYOK bridge."
+    receipt: null
 `);
 
     const payload = createBoardPayload(goalDir);
@@ -77,6 +149,10 @@ tasks:
     assert.equal(payload.tasks.find((task) => task.id === "T001").objective.includes("admin_seed_metrics.enrichment_qa"), true);
     assert.equal(payload.tasks.find((task) => task.id === "T002").title, "Implement /contacts/con_aaron_keller route");
     assert.equal(payload.tasks.find((task) => task.id === "T003").title, "Human-friendly release title");
+    assert.equal(
+      payload.tasks.find((task) => task.id === "T004").title,
+      "Run installed-Cursor runtime proof for a named model request through the local BYOK bridge",
+    );
   } finally {
     rmSync(root, { recursive: true, force: true });
   }
@@ -249,6 +325,7 @@ test("writes a minimal GoalBuddy web app into the goal directory", () => {
   assert.match(css, /:root\[data-theme="dark"\]/);
   assert.match(css, /:root\[data-density="compact"\] \.task-card/);
   assert.match(css, /:root\[data-completed-visibility="collapse"\]/);
+  assert.match(css, /-webkit-line-clamp: 5/);
   assert.match(css, /\.subgoal-board/);
   assert.match(css, /\.board-error/);
   assert.match(js, /new EventSource\("\.\/events"\)/);
@@ -448,6 +525,50 @@ test("serves board JSON and streams live state changes over SSE", async () => {
   }
 });
 
+test("coalesces transient active-task violations during multi-write transitions", async () => {
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-local-board-transition-"));
+  const goalDir = join(root, "transition-goal");
+  try {
+    mkdirSync(join(goalDir, "notes"), { recursive: true });
+    writeFileSync(join(goalDir, "state.yaml"), transitionStateYaml({
+      activeTask: "T001",
+      firstStatus: "active",
+      secondStatus: "queued",
+    }));
+
+    const server = await startBoardServer({ goalDir, host: "127.0.0.1", port: 0 });
+    try {
+      const controller = new AbortController();
+      const events = await fetch(`${server.url}events`, { signal: controller.signal });
+      assert.equal(events.status, 200);
+      const reader = events.body.getReader();
+
+      await readUntil(reader, /"activeTask":"T001"/);
+      writeFileSync(join(goalDir, "state.yaml"), transitionStateYaml({
+        activeTask: "T002",
+        firstStatus: "active",
+        secondStatus: "active",
+      }));
+      await delay(120);
+      writeFileSync(join(goalDir, "state.yaml"), transitionStateYaml({
+        activeTask: "T002",
+        firstStatus: "done",
+        secondStatus: "active",
+      }));
+
+      const update = await readUntil(reader, /"activeTask":"T002"/);
+      assert.doesNotMatch(update, /more than one active task/i);
+
+      controller.abort();
+      await reader.cancel().catch(() => {});
+    } finally {
+      await server.close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("streams parent board updates when linked child subgoal state changes", async () => {
   const root = mkdtempSync(join(tmpdir(), "goalbuddy-local-board-subgoal-live-"));
   const goalDir = join(root, "parent-goal");
@@ -558,6 +679,33 @@ test("serves multiple local boards from one shared hub URL", async () => {
   }
 });
 
+test("unregistered board paths explain hub reuse instead of stale-port cleanup", async () => {
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-local-board-unregistered-"));
+  const goalDir = join(root, "first-goal");
+  try {
+    mkdirSync(join(goalDir, "notes"), { recursive: true });
+    writeFileSync(join(goalDir, "state.yaml"), stateYaml("active", { title: "First Goal", slug: "first-goal" }));
+
+    const server = await startBoardServer({ goalDir, host: "127.0.0.1", port: 0 });
+    try {
+      const baseUrl = new URL(server.url).origin;
+      const missingResponse = await fetch(`${baseUrl}/rinova-client-revision-redesign/`);
+      assert.equal(missingResponse.status, 404);
+      const message = await missingResponse.text();
+      assert.match(message, /board path is not registered/i);
+      assert.match(message, /multi-board hub/i);
+      assert.match(message, /Do not stop it just because a \/<slug>\/ board URL returned 404/);
+      assert.match(message, /npx goalbuddy board <goal-dir>/);
+      assert.match(message, /First Goal/);
+      assert.match(message, /\/api\/boards/);
+    } finally {
+      await server.close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 async function readUntil(reader, pattern) {
   const decoder = new TextDecoder();
   let text = "";
@@ -573,6 +721,10 @@ async function readUntil(reader, pattern) {
   assert.fail(`Timed out waiting for ${pattern}. Received:\n${text}`);
 }
 
+function delay(ms) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+
 function parentWithSubgoalYaml() {
   return `version: 2
 goal:
@@ -597,6 +749,39 @@ tasks:
 `;
 }
 
+function transitionStateYaml({ activeTask, firstStatus, secondStatus }) {
+  return `version: 2
+goal:
+  title: "Transition Goal"
+  slug: "transition-goal"
+  kind: specific
+  tranche: "Verify multi-write task transition."
+  status: active
+active_task: ${activeTask}
+tasks:
+  - id: T001
+    type: scout
+    assignee: Scout
+    status: ${firstStatus}
+    objective: "Map transition."
+    receipt:
+      result: done
+      summary: "Mapped transition."
+  - id: T002
+    type: worker
+    assignee: Worker
+    status: ${secondStatus}
+    objective: "Implement transition."
+    allowed_files:
+      - goalbuddy/surfaces/local-goal-board/**
+    verify:
+      - npm run check
+    stop_if:
+      - "Need files outside allowed_files."
+    receipt: null
+`;
+}
+
 function stateYaml(status, { title = "Live board", slug = "live-board" } = {}) {
   return `version: 2
 goal:

package/goalbuddy/templates/goal.md

@@ -64,6 +64,18 @@ Tiny tasks are allowed when the failure is isolated, the risk is high, the scope
 
 Do not stop because a slice needs owner input, credentials, production access, destructive operations, or policy decisions. Mark that exact slice blocked with a receipt, create the smallest safe follow-up or workaround task, and continue all local, non-destructive work that can still move the goal toward the full outcome.
 
+If an exact human approval phrase is the only remaining blocker and no safe local work remains, ask once and stop. Preserve the exact phrase in the blocked receipt as `required_reply`, set `waiting_for_user_approval: true`, set `goal.status: blocked`, and set `active_task: null`. Do not keep posting approval prompts until the user replies.
+
+## Board Health
+
+The PM owns board health. If the board looks stale, misleading, offline, or inconsistent, run the bundled checker:
+
+```bash
+node <skill-path>/scripts/check-goal-state.mjs docs/goals/<slug>
+```
+
+If the local board is running, compare `state.yaml` to the live board API. Repair only GoalBuddy control files unless an active Worker or PM task explicitly allows product-file edits.
+
 ## Canonical Board
 
 Machine truth lives at:

package/goalbuddy/templates/state.yaml

@@ -35,6 +35,7 @@ rules:
   queued_required_worker_blocks_completion: true
   continuous_until_full_outcome: true
   missing_input_or_credentials_do_not_stop_goal: true
+  exact_human_approval_can_terminal_wait: true
   preserve_and_validate_existing_plan: true
   intake_misfire_must_be_audited: true
   goal_pressure_requires_oracle: true
@@ -58,7 +59,7 @@ visual_board:
   local:
     status: not_requested # not_requested | starting | live | generated | blocked
     url: null
-    command: "npx goalbuddy board docs/goals/<goal-slug>"
+    command: "node <skill-path>/surfaces/local-goal-board/scripts/local-goal-board.mjs --goal docs/goals/<goal-slug>"
 
 active_task: T001
 

package/internal/cli/goal-maker.mjs

@@ -49,6 +49,7 @@ const optionsWithValues = new Set([
   "--task",
   "--board",
 ]);
+const pathOptions = new Set(["--board", "--goal"]);
 
 const args = process.argv.slice(2);
 const command = args[0] === "--help" || args[0] === "-h"
@@ -111,6 +112,17 @@ async function main() {
         doctorClaude();
       }
       break;
+    case "reset":
+      if (wantsHelp()) {
+        usage();
+        break;
+      }
+      if (targetMode() !== "codex") {
+        console.error("Reset currently supports --target codex only.");
+        process.exit(2);
+      }
+      resetCodex();
+      break;
     case "check-update":
     case "update-check":
       checkUpdate();
@@ -193,6 +205,35 @@ function positionalArgs() {
   return values;
 }
 
+/**
+ * Resolve goal-related paths in raw args to absolute paths.
+ * Child processes spawned with cwd=packageRoot cannot resolve
+ * relative goal paths from the user's working directory.
+ */
+function resolveChildGoalArgs(rawArgs) {
+  const out = [];
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    const joinedMatch = [...pathOptions].find((opt) => arg.startsWith(opt + "="));
+    if (joinedMatch) {
+      const value = arg.slice(joinedMatch.length + 1);
+      out.push(`${joinedMatch}=${value ? resolve(value) : value}`);
+    } else if (pathOptions.has(arg)) {
+      out.push(arg);
+      const value = rawArgs[++index] || "";
+      out.push(value ? resolve(value) : value);
+    } else if (optionsWithValues.has(arg)) {
+      out.push(arg);
+      out.push(rawArgs[++index] || "");
+    } else if (!arg.startsWith("-")) {
+      out.push(resolve(arg));
+    } else {
+      out.push(arg);
+    }
+  }
+  return out;
+}
+
 function usage() {
   console.log(`${canonicalProductName} for Claude Code and Codex
 
@@ -203,6 +244,7 @@ Usage:
   ${canonicalCliName} update [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--json]
   ${canonicalCliName} agents [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--force]
   ${canonicalCliName} doctor [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--goal-ready]
+  ${canonicalCliName} reset --target codex [--codex-home <path>] [--json]
   ${canonicalCliName} check-update [--json]
   ${canonicalCliName} board <docs/goals/slug> [--host <host>] [--port <port>] [--once] [--json]
   ${canonicalCliName} prompt <docs/goals/slug> [--task T###] [--board <path/to/state.yaml>] [--json]
@@ -576,20 +618,36 @@ function doctor() {
   const agents = existsSync(agentsPath)
     ? readdirSync(agentsPath).filter((file) => file.startsWith("goal_") && file.endsWith(".toml"))
     : [];
-  const missingAgents = requiredAgentFiles.filter((file) => !agents.includes(file));
+  const installSurfacePresent = plugin.skill_installed || installed || legacyInstalled;
+  const residualAgents = installSurfacePresent ? [] : agents.filter((file) => requiredAgentFiles.includes(file));
+  const missingAgents = installSurfacePresent || residualAgents.length > 0
+    ? requiredAgentFiles.filter((file) => !agents.includes(file))
+    : [];
   const staleAgents = requiredAgentFiles.filter((file) => {
     const installedAgent = join(agentsPath, file);
     const bundledAgent = join(skillSource, "agents", file);
     if (!existsSync(installedAgent) || !existsSync(bundledAgent)) return false;
     return sha256(readFileSync(installedAgent)) !== sha256(readFileSync(bundledAgent));
   });
+  const runtimeState = codexInstallState({
+    plugin,
+    installed,
+    legacyInstalled,
+    residualAgents,
+    missingAgents,
+    staleAgents,
+  });
   const goalRuntime = codexGoalRuntimeStatus();
   const warnings = [];
   const errors = [];
   if (!goalRuntime.ready) {
     warnings.push("native Codex /goal runtime is not ready; run `codex login` and `codex features enable goals` before using /goal.");
   }
-  if (!plugin.skill_installed && !installed) {
+  if (runtimeState === "fully-removed") {
+    errors.push("Codex GoalBuddy is fully removed; run `npx goalbuddy --target codex` to install.");
+  } else if (runtimeState === "residual-agents-only") {
+    errors.push(`Residual GoalBuddy Codex agents remain without plugin cache/config: ${residualAgents.join(", ")}; run a GoalBuddy reset/cleanup before treating it as removed.`);
+  } else if (!plugin.skill_installed && !installed) {
     errors.push("Codex GoalBuddy plugin is not installed; run `npx goalbuddy --target codex`.");
   }
   if (plugin.skill_installed && !plugin.enabled) {
@@ -621,7 +679,9 @@ function doctor() {
     skill_path: skillPath,
     compatibility_skill_installed: legacyInstalled,
     compatibility_skill_path: legacySkillPath,
+    runtime_state: runtimeState,
     installed_agents: agents,
+    residual_agents: residualAgents,
     missing_agents: missingAgents,
     stale_agents: staleAgents,
     goal_runtime: goalRuntime,
@@ -636,6 +696,20 @@ function doctor() {
   process.exit(installOk && goalReadyOk && errors.length === 0 ? 0 : 1);
 }
 
+function codexInstallState({ plugin, installed, legacyInstalled, residualAgents, missingAgents, staleAgents }) {
+  if (residualAgents.length > 0 && !plugin.skill_installed && !installed && !legacyInstalled) {
+    return "residual-agents-only";
+  }
+  if (!plugin.skill_installed && !installed && !legacyInstalled) {
+    return "fully-removed";
+  }
+  if (staleAgents.length > 0) return "stale-agents";
+  if (missingAgents.length > 0) return "incomplete";
+  if (plugin.skill_installed && !plugin.enabled) return "disabled";
+  if ((plugin.skill_installed && plugin.enabled) || installed) return "installed";
+  return "incomplete";
+}
+
 function checkUpdate() {
   const report = updateReport();
 
@@ -661,7 +735,7 @@ function updateReport() {
     latest_version: null,
     update_available: false,
     check_status: "unknown",
-    update_command: `npx ${canonicalCliName}`,
+    update_command: detectUpdateCommand(),
   };
 
   try {
@@ -676,6 +750,23 @@ function updateReport() {
   return report;
 }
 
+function detectUpdateCommand() {
+  if (process.env.GOALBUDDY_TEST_UPDATE_COMMAND) return process.env.GOALBUDDY_TEST_UPDATE_COMMAND;
+  if (process.env.CLAUDE_PLUGIN_ROOT || normalizedPath(__dirname).includes("/.claude/")) return `/plugin update ${pluginName}@${pluginName}`;
+
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (/^pnpm\//.test(userAgent)) return `pnpm update -g ${canonicalCliName}`;
+  if (/^bun\//.test(userAgent)) return `bun update -g ${canonicalCliName}`;
+  if (process.env.MISE_EXE || process.env.MISE_SHELL || process.env.MISE_PROJECT_ROOT) return `mise upgrade npm:${canonicalCliName}`;
+  if (/^npm\//.test(userAgent)) return `npx ${canonicalCliName}@latest`;
+
+  return `use the install channel that installed ${canonicalProductName}`;
+}
+
+function normalizedPath(path) {
+  return String(path).replace(/\\/g, "/");
+}
+
 function plugin() {
   const subcommand = positional(1) || "";
   if (wantsHelp()) {
@@ -782,8 +873,95 @@ function cleanupLegacyCodexSkills() {
   return removed;
 }
 
+function resetCodex() {
+  const configPath = join(codexHome(), "config.toml");
+  const removedConfigSections = [];
+  if (existsSync(configPath)) {
+    const existing = readFileSync(configPath, "utf8");
+    let updated = existing;
+    for (const header of [`[plugins."${pluginName}@${pluginName}"]`, `[marketplaces.${pluginName}]`]) {
+      const next = removeTomlTable(updated, header);
+      if (next !== updated) {
+        removedConfigSections.push(header);
+        updated = next;
+      }
+    }
+    if (updated !== existing) writeFileSync(configPath, updated);
+  }
+
+  const removedPluginCachePaths = [];
+  const cacheRoot = pluginCacheOwnerRoot();
+  if (existsSync(cacheRoot)) {
+    rmSync(cacheRoot, { recursive: true, force: true });
+    removedPluginCachePaths.push(cacheRoot);
+  }
+
+  const removedAgents = [];
+  const agentsRoot = join(codexHome(), "agents");
+  for (const file of requiredAgentFiles) {
+    const path = join(agentsRoot, file);
+    if (!existsSync(path)) continue;
+    rmSync(path, { recursive: true, force: true });
+    removedAgents.push(path);
+  }
+
+  const removedLegacySkillPaths = cleanupLegacyCodexSkills();
+  const report = {
+    reset: true,
+    target: "codex",
+    codex_home: codexHome(),
+    config_path: configPath,
+    removed_config_sections: removedConfigSections,
+    removed_plugin_cache_paths: removedPluginCachePaths,
+    removed_agents: removedAgents,
+    removed_legacy_skill_paths: removedLegacySkillPaths,
+  };
+
+  if (hasFlag("--json")) {
+    printJson(report);
+    return report;
+  }
+
+  console.log(`Reset ${canonicalProductName} Codex-owned runtime files`);
+  console.log(`Config sections: ${removedConfigSections.length ? removedConfigSections.join(", ") : "none"}`);
+  console.log(`Plugin cache: ${removedPluginCachePaths.length ? removedPluginCachePaths.join(", ") : "none"}`);
+  console.log(`Agents: ${removedAgents.length ? removedAgents.join(", ") : "none"}`);
+  console.log(`Legacy personal skills: ${removedLegacySkillPaths.length ? removedLegacySkillPaths.join(", ") : "none"}`);
+  return report;
+}
+
+function removeTomlTable(text, header) {
+  const normalized = text.endsWith("\n") || text.length === 0 ? text : `${text}\n`;
+  const lines = normalized.split("\n");
+  const output = [];
+  let skipping = false;
+  let removed = false;
+  const descendantPrefix = `${header.slice(0, -1)}.`;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === header || trimmed.startsWith(descendantPrefix)) {
+      skipping = true;
+      removed = true;
+      continue;
+    }
+    if (skipping && /^\s*\[/.test(line)) {
+      skipping = trimmed.startsWith(descendantPrefix);
+      if (skipping) continue;
+    }
+    if (!skipping) output.push(line);
+  }
+
+  if (!removed) return text;
+  return output.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n*$/, "\n");
+}
+
+function pluginCacheOwnerRoot() {
+  return join(codexHome(), "plugins", "cache", pluginName);
+}
+
 function pluginCacheRoot(version) {
-  return join(codexHome(), "plugins", "cache", pluginName, pluginName, version);
+  return join(pluginCacheOwnerRoot(), pluginName, version);
 }
 
 function enablePluginConfig() {
@@ -913,8 +1091,9 @@ async function board() {
     process.exit(2);
   }
 
+  const absoluteGoal = resolve(goal);
   const script = ensureLocalBoardSurface();
-  const scriptArgs = [script, "--goal", goal];
+  const scriptArgs = [script, "--goal", absoluteGoal];
   for (const option of ["--host", "--port"]) {
     const value = optionValue(option);
     if (value) scriptArgs.push(option, value);
@@ -945,7 +1124,7 @@ async function prompt() {
   }
 
   const script = join(skillSource, "scripts", "render-task-prompt.mjs");
-  const scriptArgs = [script, ...args.slice(1)];
+  const scriptArgs = [script, ...resolveChildGoalArgs(args.slice(1))];
   const result = spawnSync(process.execPath, scriptArgs, {
     cwd: packageRoot,
     encoding: "utf8",
@@ -959,7 +1138,7 @@ async function prompt() {
 
 async function parallelPlan() {
   const script = join(skillSource, "scripts", "parallel-plan.mjs");
-  const scriptArgs = [script, ...args.slice(1).filter((arg) => arg !== "--parallel-plan")];
+  const scriptArgs = [script, ...resolveChildGoalArgs(args.slice(1).filter((arg) => arg !== "--parallel-plan"))];
   const result = spawnSync(process.execPath, scriptArgs, {
     cwd: packageRoot,
     encoding: "utf8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goalbuddy",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "A /goal operating loop for Codex and Claude Code: goal oracles, local boards, receipts, and verification.",
   "type": "module",
   "bin": {
@@ -9,11 +9,11 @@
   },
   "files": [
     ".agents/plugins/marketplace.json",
+    ".claude-plugin/marketplace.json",
+    "CHANGELOG.md",
     "README.md",
-    "RELEASE-0.3.5.md",
-    "RELEASE-0.3.7.md",
     "CONTRIBUTING.md",
-    "examples",
+    "docs/releases",
     "plugins/goalbuddy",
     "internal/assets",
     "internal/cli",
@@ -24,8 +24,8 @@
     "goalbuddy/templates"
   ],
   "scripts": {
-    "check": "node --check internal/cli/*.mjs goalbuddy/scripts/*.mjs && node --test internal/test/*.test.mjs",
-    "test": "node --test internal/test/*.test.mjs",
+    "check": "node --check internal/cli/*.mjs goalbuddy/scripts/*.mjs goalbuddy/surfaces/local-goal-board/scripts/*.mjs goalbuddy/surfaces/local-goal-board/scripts/lib/*.mjs && node --test internal/test/*.test.mjs goalbuddy/surfaces/local-goal-board/test/*.test.mjs",
+    "test": "node --test internal/test/*.test.mjs goalbuddy/surfaces/local-goal-board/test/*.test.mjs",
     "pack:dry-run": "npm pack --dry-run",
     "postinstall": "node internal/cli/postinstall.mjs",
     "publish:check": "node internal/cli/check-publish-version.mjs && npm run pack:dry-run",