goalbuddy 0.2.10

package/plugins/goalbuddy/skills/goalbuddy/agents/goal_judge.toml

@@ -0,0 +1,29 @@
+name = "goal_judge"
+description = "High-thinking strategic reviewer for GoalBuddy escalation: ambiguity, risky scope, source/product conflicts, safety/API/live decisions, and tranche completion."
+model_reasoning_effort = "high"
+sandbox_mode = "read-only"
+nickname_candidates = ["Judge", "Reviewer", "Architect"]
+
+developer_instructions = """
+You are Judge for GoalBuddy.
+
+Thinking level: high.
+Mode: strategic reviewer and escalation authority.
+
+Think as a skeptical staff engineer and project-management systems designer. You decide and constrain; you do not broadly implement.
+
+Use when source, tests, product behavior, API/live strategy, dirty scope, giant-file risk, safety/auth/money/persistence semantics, task priority, or completion readiness is ambiguous.
+
+Do not approve based on lots of docs or lots of tests. Require coherent receipts and current verification.
+
+Return a compact Judge receipt for the PM to paste into state.yaml:
+- result
+- decision
+- evidence
+- next_allowed_task when work may continue
+- blocked_tasks when work should not proceed
+- completion decision when auditing a tranche
+- required board updates
+
+Do not broadly implement, select the active task, or mark the goal complete yourself.
+"""

package/plugins/goalbuddy/skills/goalbuddy/agents/goal_scout.toml

@@ -0,0 +1,26 @@
+name = "goal_scout"
+description = "Read-only evidence mapper for one GoalBuddy task. Finds repo/source/spec evidence, verification commands, ambiguities, and candidate next tasks."
+model_reasoning_effort = "medium"
+sandbox_mode = "read-only"
+nickname_candidates = ["Scout", "Mapper", "Tracer"]
+
+developer_instructions = """
+You are Scout for GoalBuddy.
+
+Thinking level: medium.
+Mode: read-only evidence mapping.
+
+You are read-only. Do not edit files, stage files, run destructive commands, or claim implementation is complete.
+
+Given one active Scout task, map repo/source/spec evidence, verification commands, health signals, improvement candidates, target files, tests, and unresolved ambiguity.
+
+Return a compact Scout receipt for the PM to paste into state.yaml:
+- result
+- summary
+- evidence paths
+- note path if findings are too large for the task card
+- spawned_tasks when useful
+- ambiguity requiring Judge
+
+Do not select the active task or mark the goal complete.
+"""

package/plugins/goalbuddy/skills/goalbuddy/agents/goal_worker.toml

@@ -0,0 +1,28 @@
+name = "goal_worker"
+description = "Low-thinking bounded implementer for exactly one GoalBuddy Worker task with allowed files, verification commands, and stop conditions."
+model_reasoning_effort = "low"
+sandbox_mode = "workspace-write"
+nickname_candidates = ["Worker", "Patch", "Fixer"]
+
+developer_instructions = """
+You are Worker for GoalBuddy.
+
+Thinking level: low.
+Mode: one bounded writer.
+
+Execute exactly one active Worker task. Do not broaden scope.
+
+You may edit only the task's allowed_files. You may update only explicitly named control files if the PM included them in scope. Do not decide product behavior, retained/excluded scope, API/live/deployment strategy, architecture direction, parity, or completion readiness.
+
+Stop immediately if required evidence is missing, files outside scope are needed, source/tests/product conflict, verification fails twice, or the diff exceeds the task budget.
+
+Return a compact Worker receipt for the PM to paste into state.yaml:
+- result
+- changed_files
+- commands run with pass/fail
+- summary
+- remaining_blockers
+- needs_judge when strategy or ambiguity remains
+
+Do not select the next active task or mark the goal complete.
+"""

package/plugins/goalbuddy/skills/goalbuddy/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "GoalBuddy"
+  short_description: "Diagnose intent before making reliable goal boards."
+  default_prompt: "Use goalbuddy to run diagnostic intake on my rough or detailed goal. If the goal is vague or improvement-oriented, ask one guided question at a time, surface likely blind spots, and do not create files until intent, proof, scope, and board handling are clear or explicitly defaulted. If it is clear or already planned, prepare or repair goal.md, state.yaml, and notes/, then print the /goal Follow command instead of starting /goal automatically."
+policy:
+  allow_implicit_invocation: true

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

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+const statePath = process.argv[2];
+
+if (!statePath) {
+  console.error("Usage: node scripts/check-goal-state.mjs docs/goals/<slug>/state.yaml");
+  process.exit(2);
+}
+
+if (!existsSync(statePath)) {
+  console.error(JSON.stringify({ ok: false, errors: [`state file not found: ${statePath}`], warnings: [] }, null, 2));
+  process.exit(1);
+}
+
+const root = dirname(statePath);
+const text = readFileSync(statePath, "utf8");
+const errors = [];
+const warnings = [];
+
+function clean(value) {
+  if (value === undefined || value === null) return null;
+  const cleaned = value.replace(/#.*/, "").trim().replace(/^[\'\"]|[\'\"]$/g, "");
+  if (cleaned === "" || cleaned === "null") return null;
+  if (cleaned === "true") return true;
+  if (cleaned === "false") return false;
+  if (/^\d+$/.test(cleaned)) return Number(cleaned);
+  return cleaned;
+}
+
+function topScalar(key) {
+  const match = text.match(new RegExp(`^${key}:\\s*(.*?)\\s*$`, "m"));
+  return match ? clean(match[1]) : null;
+}
+
+function nestedScalar(section, key) {
+  const lines = text.split(/\r?\n/);
+  let inSection = false;
+  for (const line of lines) {
+    if (new RegExp(`^${section}:\\s*$`).test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^\S/.test(line)) break;
+    if (inSection) {
+      const match = line.match(new RegExp(`^\\s{2}${key}:\\s*(.*?)\\s*$`));
+      if (match) return clean(match[1]);
+    }
+  }
+  return null;
+}
+
+function sectionText(section) {
+  const lines = text.split(/\r?\n/);
+  const start = lines.findIndex((line) => new RegExp(`^${section}:\\s*$`).test(line));
+  if (start === -1) return "";
+  const collected = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\S/.test(lines[i])) break;
+    collected.push(lines[i]);
+  }
+  return collected.join("\n");
+}
+
+function parseTasks() {
+  const body = sectionText("tasks");
+  if (!body) return [];
+  const lines = body.split(/\r?\n/);
+  const tasks = [];
+  let current = null;
+  let currentLines = [];
+
+  function finish() {
+    if (!current) return;
+    current.raw = currentLines.join("\n");
+    tasks.push(current);
+  }
+
+  for (const line of lines) {
+    const idMatch = line.match(/^\s{2}-\s+id:\s*(.+?)\s*$/);
+    if (idMatch) {
+      finish();
+      current = { id: clean(idMatch[1]) };
+      currentLines = [line];
+      continue;
+    }
+    if (current) currentLines.push(line);
+  }
+  finish();
+  return tasks.map((task) => ({
+    ...task,
+    type: taskScalar(task, "type"),
+    assignee: taskScalar(task, "assignee"),
+    status: taskScalar(task, "status"),
+    objective: taskScalar(task, "objective"),
+    allowedFiles: taskList(task, "allowed_files"),
+    verify: taskList(task, "verify"),
+    stopIf: taskList(task, "stop_if"),
+    receipt: taskReceipt(task),
+  }));
+}
+
+function taskScalar(task, key) {
+  const match = task.raw.match(new RegExp(`^\\s{4}${key}:\\s*(.*?)\\s*$`, "m"));
+  return match ? clean(match[1]) : null;
+}
+
+function taskList(task, key) {
+  const lines = task.raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => new RegExp(`^\\s{4}${key}:\\s*$`).test(line));
+  if (start === -1) return [];
+  const values = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s{4}\S/.test(lines[i])) break;
+    const item = lines[i].match(/^\s{6}-\s*(.+?)\s*$/);
+    if (item) values.push(clean(item[1]));
+  }
+  return values.filter((value) => value !== null);
+}
+
+function taskReceipt(task) {
+  const lines = task.raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^\s{4}receipt:\s*/.test(line));
+  if (start === -1) return { present: false, value: null, raw: "" };
+
+  const inline = clean(lines[start].replace(/^\s{4}receipt:\s*/, ""));
+  if (inline === null && !/^(\s{6}|\s{8})/.test(lines[start + 1] || "")) {
+    return { present: true, value: null, raw: "" };
+  }
+
+  const receiptLines = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s{4}\S/.test(lines[i])) break;
+    receiptLines.push(lines[i]);
+  }
+  const raw = receiptLines.join("\n");
+  return {
+    present: true,
+    value: inline || "object",
+    raw,
+    has: (key) => new RegExp(`^\\s{6}${key}:`, "m").test(raw),
+    list: (key) => receiptList(raw, key),
+    commandStatuses: () => receiptCommandStatuses(raw),
+    scalar: (key) => {
+      const match = raw.match(new RegExp(`^\\s{6}${key}:\\s*(.*?)\\s*$`, "m"));
+      return match ? clean(match[1]) : null;
+    },
+  };
+}
+
+function receiptList(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => new RegExp(`^\\s{6}${key}:\\s*$`).test(line));
+  if (start === -1) return [];
+  const values = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s{6}\S/.test(lines[i])) break;
+    const item = lines[i].match(/^\s{8}-\s*(.+?)\s*$/);
+    if (item) values.push(clean(item[1]));
+  }
+  return values.filter((value) => value !== null);
+}
+
+function receiptCommandStatuses(raw) {
+  return [...raw.matchAll(/^\s{10}status:\s*(.*?)\s*$/gm)]
+    .map((match) => clean(match[1]))
+    .filter((value) => value !== null);
+}
+
+function rootEntryErrors() {
+  const allowed = new Set(["goal.md", "state.yaml", "notes"]);
+  const unexpected = [];
+  for (const entry of readdirSync(root).filter((item) => item !== ".DS_Store")) {
+    const path = join(root, entry);
+    const stats = statSync(path);
+    if (!allowed.has(entry)) {
+      unexpected.push(entry);
+    } else if (entry === "notes" && !stats.isDirectory()) {
+      unexpected.push("notes (must be a directory)");
+    } else if (entry !== "notes" && !stats.isFile()) {
+      unexpected.push(`${entry} (must be a file)`);
+    }
+  }
+  return unexpected;
+}
+
+const version = topScalar("version");
+const goalStatus = nestedScalar("goal", "status");
+const activeTask = topScalar("active_task");
+const installedAgents = ["scout", "worker", "judge"].map((agent) => ({
+  agent,
+  status: nestedScalar("agents", agent),
+}));
+const continuousUntilFullOutcome = nestedScalar("rules", "continuous_until_full_outcome") === true;
+const missingInputOrCredentialsDoNotStopGoal =
+  nestedScalar("rules", "missing_input_or_credentials_do_not_stop_goal") === true;
+const legacySignals = [
+  /^gate:\s*$/m,
+  /^artifact_policy:\s*$/m,
+  /^active_unit:/m,
+  /^evidence\.jsonl/m,
+].some((pattern) => pattern.test(text)) || ["units", "artifacts", "evidence.jsonl"].some((entry) => existsSync(join(root, entry)));
+
+if (version !== 2) {
+  if (legacySignals) {
+    errors.push("legacy v1 goal state detected; GoalBuddy v2 requires version: 2 with a task board. Create a new v2 goal or migrate manually.");
+  } else {
+    errors.push("state.yaml must declare version: 2");
+  }
+}
+
+if (!["active", "blocked", "done"].includes(goalStatus)) {
+  errors.push(`goal.status must be active, blocked, or done; got ${goalStatus || "<missing>"}`);
+}
+
+for (const { agent, status } of installedAgents) {
+  if (status !== "installed") {
+    errors.push(`agents.${agent} must be installed; got ${status || "<missing>"}`);
+  }
+}
+
+if (!existsSync(join(root, "goal.md"))) errors.push("missing goal.md");
+if (!existsSync(join(root, "notes")) || !statSync(join(root, "notes")).isDirectory()) {
+  errors.push("missing notes/ directory");
+}
+
+const unexpected = rootEntryErrors();
+if (unexpected.length > 0) {
+  errors.push(`unexpected root entries; v2 goal roots may contain only goal.md, state.yaml, and notes/: ${unexpected.join(", ")}`);
+}
+
+const tasks = parseTasks();
+const ids = new Set();
+for (const task of tasks) {
+  if (!task.id || !/^T\d{3}$/.test(task.id)) errors.push(`task id must use T### format; got ${task.id || "<missing>"}`);
+  if (ids.has(task.id)) errors.push(`duplicate task id: ${task.id}`);
+  ids.add(task.id);
+  if (!["scout", "judge", "worker", "pm"].includes(task.type)) {
+    errors.push(`task ${task.id} type must be scout, judge, worker, or pm`);
+  }
+  if (!["Scout", "Judge", "Worker", "PM"].includes(task.assignee)) {
+    errors.push(`task ${task.id} assignee must be Scout, Judge, Worker, or PM`);
+  }
+  const expectedAssignee = {
+    scout: "Scout",
+    judge: "Judge",
+    worker: "Worker",
+    pm: "PM",
+  }[task.type];
+  if (expectedAssignee && task.assignee !== expectedAssignee) {
+    errors.push(`task ${task.id} assignee must be ${expectedAssignee} for type ${task.type}`);
+  }
+  if (!["queued", "active", "blocked", "done"].includes(task.status)) {
+    errors.push(`task ${task.id} status must be queued, active, blocked, or done`);
+  }
+  if (!task.objective) errors.push(`task ${task.id} missing objective`);
+}
+
+if (tasks.length === 0) errors.push("tasks must contain at least one task");
+
+const activeTasks = tasks.filter((task) => task.status === "active");
+if (goalStatus === "done") {
+  if (activeTasks.length !== 0) errors.push("done goals must not have an active task");
+  if (activeTask !== null) errors.push("done goals must set active_task: null");
+  const unfinishedWorkers = tasks
+    .filter((task) => task.type === "worker" && ["queued", "active"].includes(task.status))
+    .map((task) => task.id);
+  if (unfinishedWorkers.length > 0) {
+    errors.push(`done goals must not leave queued or active Worker tasks: ${unfinishedWorkers.join(", ")}`);
+  }
+} else if (goalStatus === "blocked") {
+  if (activeTasks.length > 1) errors.push("blocked goals may have at most one active task");
+  if (continuousUntilFullOutcome && missingInputOrCredentialsDoNotStopGoal) {
+    errors.push("continuous goals must keep goal.status active; missing input or credentials should block specific tasks, not the whole goal");
+  }
+} else if (activeTasks.length !== 1) {
+  errors.push(`exactly one active task is required while goal.status is active; found ${activeTasks.length}`);
+}
+
+if (activeTasks.length === 1 && activeTask !== activeTasks[0].id) {
+  errors.push(`active_task must point to active task ${activeTasks[0].id}; got ${activeTask || "null"}`);
+}
+if (activeTask && !ids.has(activeTask)) errors.push(`active_task points to unknown task: ${activeTask}`);
+
+for (const task of tasks) {
+  const hasReceipt = task.receipt.present && task.receipt.value !== null;
+  const receiptResult = hasReceipt ? task.receipt.scalar("result") : null;
+  if (task.status === "done" && !hasReceipt) {
+    errors.push(`done task ${task.id} missing receipt`);
+  }
+  if (task.status === "done" && hasReceipt && receiptResult !== "done") {
+    errors.push(`done task ${task.id} receipt must include result: done`);
+  }
+  if (task.status === "blocked" && !hasReceipt) {
+    errors.push(`blocked task ${task.id} missing receipt`);
+  }
+  if (task.type === "worker" && task.status === "active") {
+    if (task.allowedFiles.length === 0) errors.push(`active Worker task ${task.id} must include allowed_files`);
+    if (task.verify.length === 0) errors.push(`active Worker task ${task.id} must include verify`);
+    if (task.stopIf.length === 0) errors.push(`active Worker task ${task.id} must include stop_if`);
+  }
+  if (task.type === "worker" && task.status === "done" && hasReceipt) {
+    for (const key of ["changed_files", "commands", "summary"]) {
+      if (!task.receipt.has(key)) errors.push(`Worker receipt for ${task.id} missing ${key}`);
+    }
+    const changedFiles = task.receipt.list("changed_files");
+    for (const changedFile of changedFiles) {
+      if (!task.allowedFiles.includes(changedFile)) {
+        errors.push(`Worker receipt for ${task.id} changed file outside allowed_files: ${changedFile}`);
+      }
+    }
+    const commandStatuses = task.receipt.commandStatuses();
+    if (task.receipt.has("commands") && commandStatuses.length === 0) {
+      errors.push(`Worker receipt for ${task.id} commands must include status fields`);
+    }
+    for (const status of commandStatuses) {
+      if (status !== "pass") {
+        errors.push(`Worker receipt for ${task.id} has non-passing command status: ${status}`);
+      }
+    }
+  }
+  if (task.type === "scout" && task.status === "done" && hasReceipt) {
+    if (!task.receipt.has("summary")) errors.push(`Scout receipt for ${task.id} missing summary`);
+    if (!task.receipt.has("evidence") && !task.receipt.has("note")) {
+      errors.push(`Scout receipt for ${task.id} must include evidence or note`);
+    }
+  }
+  if (task.type === "judge" && task.status === "done" && hasReceipt && !task.receipt.has("decision")) {
+    errors.push(`Judge receipt for ${task.id} missing decision`);
+  }
+}
+
+if (goalStatus === "done") {
+  const finalAudit = tasks.some((task) => {
+    if (!["judge", "pm"].includes(task.type) || task.status !== "done") return false;
+    if (!task.receipt.present || task.receipt.value === null) return false;
+    const decision = task.receipt.scalar("decision");
+    return decision === "complete" || decision === "done";
+  });
+  if (!finalAudit) {
+    errors.push("completion requires a final done Judge or PM audit receipt with decision: complete");
+  }
+  if (continuousUntilFullOutcome) {
+    const finalFullOutcomeAudit = tasks.some((task) => {
+      if (!["judge", "pm"].includes(task.type) || task.status !== "done") return false;
+      if (!task.receipt.present || task.receipt.value === null) return false;
+      const decision = task.receipt.scalar("decision");
+      const fullOutcomeComplete = task.receipt.scalar("full_outcome_complete");
+      return (decision === "complete" || decision === "done") && fullOutcomeComplete === true;
+    });
+    if (!finalFullOutcomeAudit) {
+      errors.push("continuous goals require a final done Judge or PM audit receipt with full_outcome_complete: true before goal.status: done");
+    }
+  }
+}
+
+const result = {
+  ok: errors.length === 0,
+  version,
+  state_path: statePath,
+  goal_status: goalStatus,
+  active_task: activeTask,
+  task_count: tasks.length,
+  errors,
+  warnings,
+};
+
+console.log(JSON.stringify(result, null, 2));
+process.exit(result.ok ? 0 : 1);

package/plugins/goalbuddy/skills/goalbuddy/scripts/install-agents.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceDir = resolve(__dirname, "../agents");
+const destDir = resolve(process.argv[2] || ".codex/agents");
+const force = process.argv.includes("--force");
+
+if (!existsSync(sourceDir)) {
+  console.error(`agent definitions not found: ${sourceDir}`);
+  process.exit(1);
+}
+
+mkdirSync(destDir, { recursive: true });
+
+const files = readdirSync(sourceDir).filter((f) => f.endsWith(".toml") && !f.includes("config-snippet"));
+for (const file of files) {
+  const src = join(sourceDir, file);
+  const dest = join(destDir, file);
+  if (existsSync(dest) && !force) {
+    console.log(`skip existing ${dest} (use --force to overwrite)`);
+    continue;
+  }
+  copyFileSync(src, dest);
+  console.log(`installed ${dest}`);
+}

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

@@ -0,0 +1,48 @@
+# GoalBuddy Agents
+
+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_worker | low | workspace-write | One bounded implementation/recovery task |
+| goal_judge | high | read-only | Strategic review, escalation, completion skepticism |
+
+## PM Thinking Policy
+
+The main `/goal` thread is the PM. It owns board truth, chooses active tasks, and decides when receipts are sufficient.
+
+| Goal mode | PM thinking |
+|---|---:|
+| specific, bounded | medium |
+| open-ended | high |
+| recovery | high |
+| audit | high |
+| high-risk or multi-day final audit | xhigh optional |
+
+Do not use `xhigh` by default. Use it only when a wrong board, scope, or completion decision would be materially more expensive than latency and cost.
+
+Tasks may include optional `reasoning_hint: default | low | medium | high | xhigh`. Treat it as PM guidance, not permission to widen scope.
+
+Recommended project config:
+
+```toml
+[agents]
+max_threads = 4
+max_depth = 1
+job_max_runtime_seconds = 1800
+```
+
+Install:
+
+```bash
+mkdir -p .codex/agents
+cp .codex/skills/goalbuddy/agents/goal_*.toml .codex/agents/
+```
+
+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.
+- Judge is high thinking.

package/plugins/goalbuddy/skills/goalbuddy/templates/goal-prompt.txt

@@ -0,0 +1 @@
+/goal Follow docs/goals/<slug>/goal.md.

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

@@ -0,0 +1,71 @@
+# <Goal Title>
+
+## Objective
+
+<User-editable objective. Keep this bounded to the current tranche, not an infinite mission.>
+
+## Original Request
+
+<Shortest faithful copy of what the user asked for. Preserve user-provided plan details here or summarize them under Intake Summary.>
+
+## Intake Summary
+
+- Input shape: `vague | specific | existing_plan | recovery | audit`
+- Audience: <beneficiary or unknown>
+- 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>
+- 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 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.>
+
+## Non-Negotiable Constraints
+
+- <Constraint, safety rule, compatibility rule, or owner preference.>
+
+## Stop Rule
+
+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 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.
+
+## Canonical Board
+
+Machine truth lives at:
+
+`docs/goals/<slug>/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 docs/goals/<slug>/goal.md.
+```
+
+## PM Loop
+
+On every `/goal` continuation:
+
+1. Read this charter.
+2. Read `state.yaml`.
+3. Re-check the intake: original request, input shape, authority, proof, blind spots, existing plan facts, and likely misfire.
+4. Work only on the active board task.
+5. Assign Scout, Judge, Worker, or PM according to the task.
+6. Write a compact task receipt.
+7. Update the board.
+8. If Judge selected a safe Worker task with `allowed_files`, `verify`, and `stop_if`, activate it and continue unless blocked.
+9. Treat a slice audit as a checkpoint, not completion, unless it explicitly proves the full original outcome is complete.
+10. 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`.

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

@@ -0,0 +1,22 @@
+# <Task ID>: <Note Title>
+
+Task: `<T###>`
+Kind: `scout | judge | pm`
+Status: `current | superseded | blocked`
+
+## Summary
+
+<One paragraph the board receipt can point to.>
+
+## Details
+
+- <Evidence, decision, or context too large for an inline receipt.>
+
+## Board Receipt Snippet
+
+```yaml
+receipt:
+  result: done
+  note: notes/<task-id>-<slug>.md
+  summary: "<compact result>"
+```