goalbuddy 0.3.5 → 0.3.7

package/plugins/goalbuddy/skills/goalbuddy/{extend → surfaces}/local-goal-board/scripts/lib/goal-board.mjs

@@ -6,8 +6,8 @@ import { fileURLToPath } from "node:url";
 const VALID_STATUSES = new Set(["queued", "active", "blocked", "done"]);
 const COLUMN_ORDER = ["todo", "in-progress", "blocked", "completed"];
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const extensionRoot = resolve(__dirname, "../..");
-const logoAssetPath = join(extensionRoot, "assets", "goalbuddy-mark.png");
+const surfaceRoot = resolve(__dirname, "../..");
+const logoAssetPath = join(surfaceRoot, "assets", "goalbuddy-mark.png");
 
 export class GoalBoardError extends Error {
   constructor(message) {
@@ -110,7 +110,7 @@ export function normalizeTask(task, index) {
   }
 
   const id = cleanText(task.id);
-  const status = cleanText(task.status);
+  const status = normalizeTaskStatus(task.status);
   if (!id) throw new GoalBoardError(`Task ${index + 1} is missing id.`);
   if (!VALID_STATUSES.has(status)) {
     throw new GoalBoardError(`Task ${id} has unsupported status "${status}".`);
@@ -332,14 +332,222 @@ function cleanText(value) {
   return String(value ?? "").trim();
 }
 
+function normalizeTaskStatus(value) {
+  const status = cleanText(value);
+  if (status === "complete" || status === "completed") return "done";
+  return status;
+}
+
 export function parseGoalStateText(text) {
-  const lines = tokenizeYaml(text);
-  if (!lines.length) throw new GoalBoardError("Goal state is empty.");
-  const [value, nextIndex] = parseBlock(lines, 0, lines[0].indent);
-  if (nextIndex < lines.length) {
-    throw new GoalBoardError(`Could not parse line ${lines[nextIndex].number}.`);
+  try {
+    const lines = tokenizeYaml(text);
+    if (!lines.length) throw new GoalBoardError("Goal state is empty.");
+    const [value, nextIndex] = parseBlock(lines, 0, lines[0].indent);
+    if (nextIndex < lines.length) {
+      throw new GoalBoardError(`Could not parse line ${lines[nextIndex].number}.`);
+    }
+    return value;
+  } catch (error) {
+    if (error instanceof GoalBoardError && canRecoverBoardSubset(error)) {
+      return parseGoalBoardSubset(text);
+    }
+    throw error;
   }
-  return value;
+}
+
+function canRecoverBoardSubset(error) {
+  return /Could not parse line|Expected key\/value pair|Expected mapping|Block scalar YAML/.test(error.message);
+}
+
+function parseGoalBoardSubset(text) {
+  const tasks = parseTaskSubsets(text);
+  if (!tasks.length) throw new GoalBoardError("Missing non-empty tasks list.");
+  return {
+    version: parseYamlScalar(findTopLevelScalar(text, "version") || "2"),
+    goal: {
+      title: parseYamlScalar(findNestedScalar(text, "goal", "title") || "Untitled goal"),
+      slug: parseYamlScalar(findNestedScalar(text, "goal", "slug") || "untitled-goal"),
+      kind: parseYamlScalar(findNestedScalar(text, "goal", "kind") || "open_ended"),
+      tranche: parseYamlScalar(findNestedScalar(text, "goal", "tranche") || ""),
+      status: parseYamlScalar(findNestedScalar(text, "goal", "status") || "active"),
+    },
+    active_task: parseYamlScalar(findTopLevelScalar(text, "active_task") || ""),
+    tasks,
+  };
+}
+
+function parseTaskSubsets(text) {
+  const tasksText = findTopLevelSection(text, "tasks");
+  if (!tasksText) return [];
+  const taskBlocks = [];
+  let current = [];
+  for (const line of tasksText.split("\n")) {
+    if (/^  - id:/.test(line)) {
+      if (current.length) taskBlocks.push(current.join("\n"));
+      current = [line];
+    } else if (current.length) {
+      current.push(line);
+    }
+  }
+  if (current.length) taskBlocks.push(current.join("\n"));
+  return taskBlocks.map((block) => ({
+    id: parseYamlScalar(findTaskScalar(block, "id") || ""),
+    type: parseYamlScalar(findTaskScalar(block, "type") || "pm"),
+    assignee: parseYamlScalar(findTaskScalar(block, "assignee") || ""),
+    status: parseYamlScalar(findTaskScalar(block, "status") || "queued"),
+    title: parseYamlScalar(findTaskScalar(block, "title") || ""),
+    objective: parseYamlScalar(findTaskScalar(block, "objective") || ""),
+    inputs: findTaskList(block, "inputs"),
+    constraints: findTaskList(block, "constraints"),
+    expected_output: findTaskList(block, "expected_output"),
+    allowed_files: findTaskList(block, "allowed_files"),
+    verify: findTaskList(block, "verify"),
+    stop_if: findTaskList(block, "stop_if"),
+    subgoal: findTaskSubgoal(block),
+    receipt: findTaskReceipt(block),
+  }));
+}
+
+function findTopLevelScalar(text, key) {
+  return findScalar(text, new RegExp(`^${escapeRegExp(key)}:\\s*(.*?)\\s*$`, "m"));
+}
+
+function findNestedScalar(text, section, key) {
+  return findScalar(findTopLevelSection(text, section), new RegExp(`^  ${escapeRegExp(key)}:\\s*(.*?)\\s*$`, "m"));
+}
+
+function findTaskScalar(text, key) {
+  if (key === "id") return findScalar(text, /^  - id:\s*(.*?)\s*$/m);
+  return findScalar(text, new RegExp(`^    ${escapeRegExp(key)}:\\s*(.*?)\\s*$`, "m"));
+}
+
+function findScalar(text, pattern) {
+  const match = String(text || "").match(pattern);
+  return match ? match[1] : "";
+}
+
+function findTopLevelSection(text, key) {
+  const lines = String(text || "").replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex((line) => line.trim() === `${key}:`);
+  if (start === -1) return "";
+  const section = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^\S/.test(line)) break;
+    section.push(line);
+  }
+  return section.join("\n");
+}
+
+function findIndentedSection(text, key, indent) {
+  const lines = String(text || "").replace(/\r\n/g, "\n").split("\n");
+  const prefix = " ".repeat(indent);
+  const start = lines.findIndex((line) => line.trim() === `${key}:` && line.startsWith(prefix));
+  if (start === -1) return "";
+  const section = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim() && !line.startsWith(`${prefix}  `)) break;
+    section.push(line);
+  }
+  return section.join("\n");
+}
+
+function findTaskList(text, key) {
+  const inline = findTaskScalar(text, key);
+  if (inline) {
+    const parsed = parseYamlScalar(inline);
+    if (Array.isArray(parsed)) return parsed.map(cleanText).filter(Boolean);
+    return cleanText(parsed) ? [cleanText(parsed)] : [];
+  }
+  const section = findIndentedSection(text, key, 4);
+  return section
+    .split("\n")
+    .map((line) => line.match(/^      -\s*(.*?)\s*$/)?.[1] || "")
+    .map(parseYamlScalar)
+    .map(cleanText)
+    .filter(Boolean);
+}
+
+function findTaskSubgoal(text) {
+  const inline = findTaskScalar(text, "subgoal");
+  if (inline && parseYamlScalar(inline) === null) return null;
+  const section = findIndentedSection(text, "subgoal", 4);
+  if (!section) return null;
+  return {
+    status: parseYamlScalar(findScalar(section, /^      status:\s*(.*?)\s*$/m) || "active"),
+    path: parseYamlScalar(findScalar(section, /^      path:\s*(.*?)\s*$/m) || ""),
+    owner: parseYamlScalar(findScalar(section, /^      owner:\s*(.*?)\s*$/m) || ""),
+    created_from: parseYamlScalar(findScalar(section, /^      created_from:\s*(.*?)\s*$/m) || ""),
+    depth: parseYamlScalar(findScalar(section, /^      depth:\s*(.*?)\s*$/m) || "1"),
+    rollup_receipt: parseYamlScalar(findScalar(section, /^      rollup_receipt:\s*(.*?)\s*$/m) || "null"),
+  };
+}
+
+function findTaskReceipt(text) {
+  const inline = findTaskScalar(text, "receipt");
+  if (inline && parseYamlScalar(inline) === null) return null;
+  const section = findIndentedSection(text, "receipt", 4);
+  if (!section) return null;
+  return {
+    result: parseYamlScalar(findScalar(section, /^      result:\s*(.*?)\s*$/m) || ""),
+    summary: parseYamlScalar(findScalar(section, /^      summary:\s*(.*?)\s*$/m) || ""),
+    decision: parseYamlScalar(findScalar(section, /^      decision:\s*(.*?)\s*$/m) || ""),
+    note: parseYamlScalar(findScalar(section, /^      note:\s*(.*?)\s*$/m) || ""),
+    changed_files: findReceiptList(section, "changed_files"),
+    commands: findReceiptCommands(section),
+    evidence: [],
+  };
+}
+
+function findReceiptList(text, key) {
+  const section = findIndentedSection(text, key, 6);
+  return section
+    .split("\n")
+    .map((line) => line.match(/^        -\s*(.*?)\s*$/)?.[1] || "")
+    .map(parseYamlScalar)
+    .map(cleanText)
+    .filter(Boolean);
+}
+
+function findReceiptCommands(text) {
+  const section = findIndentedSection(text, "commands", 6);
+  const blocks = [];
+  let current = [];
+  for (const line of section.split("\n")) {
+    if (/^        - cmd:/.test(line)) {
+      if (current.length) blocks.push(current.join("\n"));
+      current = [line];
+    } else if (current.length) {
+      current.push(line);
+    }
+  }
+  if (current.length) blocks.push(current.join("\n"));
+  return blocks.map((block) => ({
+    cmd: parseYamlScalar(findScalar(block, /^        - cmd:\s*(.*?)\s*$/m) || ""),
+    status: parseYamlScalar(findScalar(block, /^          status:\s*(.*?)\s*$/m) || ""),
+    note: parseYamlScalar(findScalar(block, /^          note:\s*(.*?)\s*$/m) || ""),
+  }));
+}
+
+function parseYamlScalar(value) {
+  const text = stripComment(String(value ?? "")).trim();
+  if (!text) return "";
+  try {
+    return parseScalar(text);
+  } catch {
+    if (
+      (text.startsWith("\"") && text.endsWith("\"")) ||
+      (text.startsWith("'") && text.endsWith("'"))
+    ) {
+      return text.slice(1, -1);
+    }
+    return text;
+  }
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 function tokenizeYaml(text) {
@@ -1326,6 +1534,25 @@ h1 {
   font-size: 14px;
 }
 
+.board-error {
+  grid-column: 1 / -1;
+  padding: 18px;
+  border: 1px solid var(--red-border);
+  border-radius: 8px;
+  background: var(--red-bg);
+  color: var(--text);
+}
+
+.board-error h2 {
+  margin: 0 0 8px;
+  font-size: 16px;
+}
+
+.board-error p {
+  margin: 0;
+  color: var(--muted);
+}
+
 @media (prefers-reduced-motion: reduce) {
   .github-stars,
   .settings-button,
@@ -1825,6 +2052,11 @@ function renderBoard(board) {
   document.getElementById("goal-active").textContent = board.goal.activeTask || "None";
   document.getElementById("goal-updated").textContent = new Date(board.generatedAt).toLocaleTimeString();
 
+  if (board.error) {
+    boardEl.replaceChildren(renderBoardError(board.error));
+    return;
+  }
+
   const delay = movingTaskIds.size ? 260 : 0;
   window.setTimeout(() => {
     boardEl.replaceChildren(...board.columns.map(renderColumn));
@@ -1832,6 +2064,15 @@ function renderBoard(board) {
   }, delay);
 }
 
+function renderBoardError(message) {
+  const node = el("section", "board-error");
+  node.append(
+    el("h2", "", "GoalBuddy could not parse this board"),
+    el("p", "", message),
+  );
+  return node;
+}
+
 function renderBoardSwitcher(boards) {
   boardSwitcherEl.closest(".board-switcher").classList.toggle("is-empty", boards.length <= 1);
   const currentPath = normalizePath(window.location.pathname);

package/plugins/goalbuddy/skills/goalbuddy/{extend → surfaces}/local-goal-board/scripts/local-goal-board.mjs

@@ -527,9 +527,9 @@ function serveStatic(appDir, pathname, response) {
     return;
   }
 
-  const extension = cleanPath.match(/\.[^.]+$/)?.[0] || "";
+  const fileExtension = cleanPath.match(/\.[^.]+$/)?.[0] || "";
   response.writeHead(200, {
-    "Content-Type": textTypes[extension] || "application/octet-stream",
+    "Content-Type": textTypes[fileExtension] || "application/octet-stream",
     "Cache-Control": "no-store",
   });
   response.end(readFileSync(file));
@@ -580,8 +580,8 @@ function usage() {
   console.log(`GoalBuddy Local Goal Board
 
 Usage:
-  node extend/local-goal-board/scripts/local-goal-board.mjs --goal docs/goals/<slug>
-  node extend/local-goal-board/scripts/local-goal-board.mjs --goal docs/goals/<slug> --once --json
+  npx goalbuddy board docs/goals/<slug>
+  npx goalbuddy board docs/goals/<slug> --once --json
 
 Options:
   --goal <path>   Goal directory containing state.yaml.

package/plugins/goalbuddy/skills/goalbuddy/{extend → surfaces}/local-goal-board/test/local-goal-board.test.mjs

@@ -8,9 +8,9 @@ import { 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", () => {
-  const payload = createBoardPayload(resolve("extend/local-goal-board/examples/sample-goal"));
+  const payload = createBoardPayload(resolve("goalbuddy/surfaces/local-goal-board/examples/sample-goal"));
 
-  assert.equal(payload.goal.title, "Local Kanban Board Extension");
+  assert.equal(payload.goal.title, "Local Goal Board Surface");
   assert.equal(payload.goal.activeTask, "");
   assert.equal(payload.counts.total, 14);
   assert.equal(payload.counts.todo, 0);
@@ -24,7 +24,7 @@ test("normalizes a dense goal into local board columns", () => {
 });
 
 test("loads depth-1 subgoal boards into parent task payloads", () => {
-  const payload = createBoardPayload(resolve("goalbuddy/extend/local-goal-board/examples/subgoal-parent"));
+  const payload = createBoardPayload(resolve("goalbuddy/surfaces/local-goal-board/examples/subgoal-parent"));
   const parentTask = payload.tasks.find((task) => task.id === "T004");
 
   assert.equal(parentTask.subgoal.status, "active");
@@ -82,6 +82,62 @@ tasks:
   }
 });
 
+test("keeps board rendering when deep receipt YAML is malformed", () => {
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-board-subset-parser-"));
+  try {
+    const goalDir = join(root, "subset-parser");
+    mkdirSync(join(goalDir, "notes"), { recursive: true });
+    writeFileSync(join(goalDir, "state.yaml"), `version: 2
+goal:
+  title: "Subset parser"
+  slug: "subset-parser"
+  kind: specific
+  tranche: "Recover shallow board fields."
+  status: active
+active_task: T003
+checks:
+  last_verification:
+    status: pass
+    raw:
+      malformed nested checker output
+tasks:
+  - id: T001
+    type: worker
+    assignee: Worker
+    status: completed
+    objective: "Ship a completed worker slice."
+    receipt:
+      result: done
+      summary: "Worker finished."
+      raw:
+        malformed nested receipt output
+  - id: T002
+    type: judge
+    assignee: Judge
+    status: complete
+    objective: "Approve the result."
+    receipt: null
+  - id: T003
+    type: scout
+    assignee: Scout
+    status: active
+    objective: "Inspect what is left."
+    receipt: null
+`);
+
+    const payload = createBoardPayload(goalDir);
+    assert.equal(payload.goal.title, "Subset parser");
+    assert.equal(payload.goal.activeTask, "T003");
+    assert.equal(payload.counts.completed, 2);
+    assert.equal(payload.counts.inProgress, 1);
+    assert.equal(payload.tasks.find((task) => task.id === "T001").status, "done");
+    assert.equal(payload.tasks.find((task) => task.id === "T002").status, "done");
+    assert.equal(payload.tasks.find((task) => task.id === "T001").receipt.summary, "Worker finished.");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("fails loudly when a linked subgoal state file is missing", () => {
   const root = mkdtempSync(join(tmpdir(), "goalbuddy-missing-subgoal-"));
   try {
@@ -173,7 +229,7 @@ tasks:
 });
 
 test("writes a minimal GoalBuddy web app into the goal directory", () => {
-  const appDir = writeBoardApp(resolve("extend/local-goal-board/examples/sample-goal"));
+  const appDir = writeBoardApp(resolve("goalbuddy/surfaces/local-goal-board/examples/sample-goal"));
   const html = readFileSync(join(appDir, "index.html"), "utf8");
   const css = readFileSync(join(appDir, "styles.css"), "utf8");
   const js = readFileSync(join(appDir, "app.js"), "utf8");
@@ -194,6 +250,7 @@ test("writes a minimal GoalBuddy web app into the goal directory", () => {
   assert.match(css, /:root\[data-density="compact"\] \.task-card/);
   assert.match(css, /:root\[data-completed-visibility="collapse"\]/);
   assert.match(css, /\.subgoal-board/);
+  assert.match(css, /\.board-error/);
   assert.match(js, /new EventSource\("\.\/events"\)/);
   assert.match(js, /fetch\("\.\.\/api\/boards"/);
   assert.match(js, /fetch\("\.\.\/api\/settings"/);
@@ -206,6 +263,7 @@ test("writes a minimal GoalBuddy web app into the goal directory", () => {
   assert.match(js, /card\.animate/);
   assert.match(js, /highlightMovingCards/);
   assert.match(js, /renderSubgoal/);
+  assert.match(js, /renderBoardError/);
   assert.match(js, /boardOptionLabel/);
   assert.match(js, /duration: changedColumn \? 980 : 520/);
   assert.equal(logo.subarray(1, 4).toString("ascii"), "PNG");
@@ -333,22 +391,22 @@ test("advertises goalbuddy.localhost while binding to loopback", async () => {
 });
 
 test("runs when installed under a symlinked temp path", () => {
-  const root = mkdtempSync("/tmp/goalbuddy-local-board-direct-");
+  const root = mkdtempSync(join(tmpdir(), "goalbuddy-local-board-direct-"));
   try {
-    cpSync("extend/local-goal-board/scripts", join(root, "scripts"), { recursive: true });
-    cpSync("extend/local-goal-board/assets", join(root, "assets"), { recursive: true });
+    cpSync("goalbuddy/surfaces/local-goal-board/scripts", join(root, "scripts"), { recursive: true });
+    cpSync("goalbuddy/surfaces/local-goal-board/assets", join(root, "assets"), { recursive: true });
 
     const result = spawnSync(process.execPath, [
       join(root, "scripts", "local-goal-board.mjs"),
       "--goal",
-      resolve("extend/local-goal-board/examples/sample-goal"),
+      resolve("goalbuddy/surfaces/local-goal-board/examples/sample-goal"),
       "--once",
       "--json",
     ], { encoding: "utf8" });
 
     assert.equal(result.status, 0, result.stderr || result.stdout);
     const report = JSON.parse(result.stdout);
-    assert.equal(report.board.goal.title, "Local Kanban Board Extension");
+    assert.equal(report.board.goal.title, "Local Goal Board Surface");
   } finally {
     rmSync(root, { recursive: true, force: true });
   }

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

@@ -5,7 +5,7 @@ Use three generic agents. The main `/goal` thread remains PM and owns the board.
 | Agent | model_reasoning_effort | sandbox_mode | Purpose |
 |---|---:|---|---|
 | goal_scout | low | read-only | Targeted evidence mapping and candidate facts |
-| goal_worker | low | workspace-write | One bounded implementation/recovery task |
+| goal_worker | medium | workspace-write | One coherent bounded implementation/recovery slice |
 | goal_judge | high | read-only | Strategic review, escalation, completion skepticism |
 
 ## PM Thinking Policy
@@ -44,5 +44,6 @@ 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`.
+- Worker defaults to medium reasoning for implementation tasks and should complete the whole assigned slice.
 - Scout and Judge are read-only and safe to parallelize when their board inputs are clear.
-- Judge is high thinking.
+- Judge is high thinking and should choose the largest safe useful slice, not the narrowest helper.

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

@@ -15,17 +15,26 @@
 - Authority: `requested | approved | inferred | needs_approval | blocked`
 - Proof type: `test | demo | artifact | metric | review | source_backed_answer | decision`
 - Completion proof: <observable signal that closes the full original outcome>
+- Goal oracle: <live check, walkthrough, artifact, metric, source-backed answer, or decision that keeps pressure on the goal>
 - Likely misfire: <how GoalBuddy could succeed at the wrong thing>
 - Blind spots considered: <risks, unstated choices, or success dimensions surfaced during diagnostic intake>
 - Existing plan facts: <user-provided steps/files/constraints/sequencing to preserve and validate, or none>
 
+## Goal Oracle
+
+The oracle for this goal is:
+
+`<specific observable signal>`
+
+The PM must keep comparing task receipts to this oracle. Planning, discovery, a passing tiny slice, or a clean-looking board is not enough. The goal finishes only when a final Judge/PM audit maps receipts and verification back to this oracle and records `full_outcome_complete: true`.
+
 ## Goal Kind
 
 `specific | open_ended | existing_plan | recovery | audit`
 
 ## Current Tranche
 
-<What is enough for the full owner outcome, and what is the current safe slice? For execution goals, the default is continuous: discover enough evidence, choose a safe implementation slice, implement it, verify it, audit it, then immediately advance to the next safe slice until the full original outcome is complete. Plan-only or one-slice-only stopping is valid only when explicitly requested.>
+<What is enough for the full owner outcome, and what is the current largest reversible local work package? For execution goals, the default is continuous: discover enough evidence, choose a coherent work package, implement it, verify it, review only at phase/risk/final boundaries, then immediately advance to the next work package until the full original outcome is complete. Plan-only or one-package-only stopping is valid only when explicitly requested.>
 
 ## Non-Negotiable Constraints
 
@@ -37,7 +46,21 @@ Stop only when a final audit proves the full original outcome is complete.
 
 Do not stop after planning, discovery, or Judge selection if the user asked for working software or automation and a safe Worker task can be activated.
 
-Do not stop after a single verified Worker slice when the broader owner outcome still has safe local follow-up slices. After each slice audit, advance the board to the next highest-leverage safe Worker task and continue.
+Do not stop after a single verified Worker package when the broader owner outcome still has safe local follow-up work. Advance the board to the next highest-leverage safe Worker package and continue unless a phase, risk, rejected-verification, ambiguity, or final-completion review is due.
+
+Do not create one Worker/Judge pair per repeated file, table, route, or helper. Put repeated same-shape work into one Worker package and review the package as a whole.
+
+## Slice Sizing
+
+Safe means bounded, explicit, verified, and reversible. It does not mean tiny.
+
+A good task is the largest safe useful slice.
+
+Small is not the goal. Useful is the goal.
+
+A Worker should finish the whole assigned slice. A Judge should judge the whole assigned slice. A PM should reorient the board when tasks are safe but not moving the outcome.
+
+Tiny tasks are allowed when the failure is isolated, the risk is high, the scope is unknown, or the tiny task unlocks a larger slice. Tiny tasks are bad when they keep happening, do not change behavior, only add wrappers/contracts/proof files, or avoid the real milestone.
 
 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.
 
@@ -67,9 +90,9 @@ On every `/goal` continuation:
 6. Assign Scout, Judge, Worker, or PM according to the task.
 7. Write a compact task receipt.
 8. Update the board.
-9. If Judge selected a safe Worker task with `allowed_files`, `verify`, and `stop_if`, activate it and continue unless blocked.
+9. If safe local work remains, choose the next largest reversible Worker package and continue unless blocked.
 10. If a problem, suggestion, or follow-up should become a repo artifact, create an approved issue/PR or ask the operator whether to create one.
-11. Treat a slice audit as a checkpoint, not completion, unless it explicitly proves the full original outcome is complete.
+11. Review at phase, risk, rejected-verification, ambiguity, or final-completion boundaries; do not review every small Worker by habit.
 12. Finish only with a Judge/PM audit receipt that maps receipts and verification back to the original user outcome and records `full_outcome_complete: true`.
 
 Issue and PR handoffs are supporting artifacts. `state.yaml` remains authoritative, and every external artifact decision must be recorded in a task receipt.

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

@@ -9,6 +9,10 @@ goal:
   kind: open_ended # specific | open_ended | existing_plan | recovery | audit
   tranche: "<continuous execution: complete successive safe verified slices until the full original outcome is complete>"
   status: active # active | blocked | done
+  oracle:
+    signal: "<live check, walkthrough, artifact, metric, source-backed answer, or decision that proves the owner outcome>"
+    cadence: "after each Worker package and at final audit"
+    final_proof: "<receipt-backed evidence required before full_outcome_complete: true>"
   intake:
     original_request: "<shortest faithful user request>"
     interpreted_outcome: "<one sentence>"
@@ -33,6 +37,13 @@ rules:
   missing_input_or_credentials_do_not_stop_goal: true
   preserve_and_validate_existing_plan: true
   intake_misfire_must_be_audited: true
+  goal_pressure_requires_oracle: true
+  no_completion_on_weak_proof: true
+  slice_policy:
+    max_consecutive_tiny_tasks: 2
+    prefer_vertical_slices: true
+    judge_picks_largest_safe_slice: true
+    worker_completes_whole_slice: true
 
 agents:
   # installed | bundled_not_installed | missing | unknown
@@ -42,17 +53,12 @@ agents:
   judge: unknown
 
 visual_board:
-  # none | local | github_projects | both | unknown
+  # none | local | unknown
   selected: unknown
   local:
     status: not_requested # not_requested | starting | live | generated | blocked
     url: null
     command: "npx goalbuddy board docs/goals/<goal-slug>"
-  github_projects:
-    status: not_requested # not_requested | needs_approval | dry_run_ready | synced | blocked
-    url: null
-    command: "npx goalbuddy extend github-projects"
-    missing: []
 
 active_task: T001
 
@@ -88,7 +94,7 @@ tasks:
       - "T001 receipt"
     constraints:
       - "Do not implement."
-      - "Pick small reviewable work."
+      - "Pick the largest safe useful slice with clear allowed_files, verify commands, and stop conditions."
     expected_output:
       - "Decision"
       - "Exact Worker objective"

package/examples/extend-catalog-workflow/goal.md

@@ -1,53 +0,0 @@
-# Extend Catalog Workflow
-
-## Objective
-
-Design and implement Goal Maker's extension catalog workflow so optional features can move through GitHub-hosted extension metadata without requiring frequent npm package releases.
-
-## Goal Kind
-
-`open_ended`
-
-## Current Tranche
-
-Decide the product language and architecture for optional extensions, implement the first catalog-backed `extend` CLI workflow, add a visible root `extend/` surface, clean the skill/package layout, and leave a reviewable completion audit.
-
-## Non-Negotiable Constraints
-
-- `state.yaml` remains the only board truth.
-- Extensions are optional support surfaces, not the control plane.
-- Use `extend` as the repo surface and `extensions` as the item name.
-- Avoid implying bidirectional sync with external services.
-- Keep npm as the stable core; catalog entries should be updateable from GitHub.
-- Keep package-only infrastructure out of the installable skill payload.
-- Do not require provider credentials for discovery or dry-run installation.
-
-## Stop Rule
-
-Stop when the extension/catalog UX is implemented, the repo layout reflects the skill/package boundary, verification passes, and the final audit maps the shipped changes to receipts and commits.
-
-## Canonical Board
-
-Machine truth lives at:
-
-`examples/extend-catalog-workflow/state.yaml`
-
-If this charter and `state.yaml` disagree, `state.yaml` wins for task status, active task, receipts, verification freshness, and completion truth.
-
-## Run Command
-
-```text
-/goal Follow examples/extend-catalog-workflow/goal.md
-```
-
-## PM Loop
-
-On every `/goal` continuation:
-
-1. Read this charter.
-2. Read `state.yaml`.
-3. Work only on the active board task.
-4. Assign Scout, Judge, Worker, or PM according to the task.
-5. Write a compact task receipt.
-6. Update the board.
-7. Select the next active task or finish with a Judge/PM audit receipt.