goalbuddy 0.2.10

package/goal-maker/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; Goal Maker 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/goal-maker/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/goal-maker/templates/agents.md

@@ -0,0 +1,48 @@
+# Goal Maker 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/goal-maker/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/goal-maker/templates/goal-prompt.txt

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

package/goal-maker/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 Goal Maker 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/goal-maker/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>"
+```

package/goal-maker/templates/state.yaml

@@ -0,0 +1,125 @@
+# Goal Maker v2 state.yaml
+# Board truth lives here. goal.md is the editable charter; notes/ holds long receipts only.
+
+version: 2
+
+goal:
+  title: "<Goal title>"
+  slug: "<goal-slug>"
+  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
+  intake:
+    original_request: "<shortest faithful user request>"
+    interpreted_outcome: "<one sentence>"
+    input_shape: vague # vague | specific | existing_plan | recovery | audit
+    audience: unknown
+    authority: requested # requested | approved | inferred | needs_approval | blocked
+    proof_type: artifact # test | demo | artifact | metric | review | source_backed_answer | decision
+    completion_proof: "<observable signal that proves the full original outcome is complete>"
+    likely_misfire: "<how Goal Maker could succeed at the wrong thing>"
+    blind_spots_considered: []
+    existing_plan_facts: []
+
+rules:
+  pm_owns_state: true
+  one_active_task: true
+  max_write_workers: 1
+  no_implementation_without_worker_or_pm_task: true
+  no_completion_without_judge_or_pm_audit: true
+  planning_is_not_completion: true
+  queued_required_worker_blocks_completion: true
+  continuous_until_full_outcome: true
+  missing_input_or_credentials_do_not_stop_goal: true
+  preserve_and_validate_existing_plan: true
+  intake_misfire_must_be_audited: true
+
+agents:
+  scout: installed
+  worker: installed
+  judge: installed
+
+active_task: T001
+
+tasks:
+  - id: T001
+    type: scout
+    assignee: Scout
+    status: active
+    reasoning_hint: default # default | low | medium | high | xhigh
+    objective: "Map repo purpose, architecture, verification commands, health signals, and improvement candidates."
+    inputs:
+      - README.md
+      - package.json
+      - docs
+      - tests
+    constraints:
+      - "Read-only."
+      - "Do not edit implementation files."
+      - "Prefer concrete file-path evidence over generic advice."
+    expected_output:
+      - "Repo map"
+      - "Verification commands"
+      - "Ranked improvement candidates"
+      - "Candidate next tasks"
+    receipt: null
+  - id: T002
+    type: judge
+    assignee: Judge
+    status: queued
+    reasoning_hint: default
+    objective: "Review Scout findings and choose the first safe implementation task."
+    inputs:
+      - "T001 receipt"
+    constraints:
+      - "Do not implement."
+      - "Pick small reviewable work."
+    expected_output:
+      - "Decision"
+      - "Exact Worker objective"
+      - "allowed_files"
+      - "verify"
+      - "stop_if"
+      - "Blocked or deferred tasks"
+    receipt: null
+  - id: T003
+    type: worker
+    assignee: Worker
+    status: queued
+    reasoning_hint: default
+    objective: "Execute the first safe implementation task selected by Judge."
+    allowed_files: []
+    verify: []
+    stop_if:
+      - "Need files outside allowed_files."
+      - "Behavior is ambiguous."
+      - "Verification fails twice."
+    receipt: null
+  - id: T999
+    type: judge
+    assignee: Judge
+    status: queued
+    reasoning_hint: default
+    objective: "Audit whether the implemented slice satisfies the original user outcome for this tranche."
+    inputs:
+      - "All done task receipts"
+      - "Last verification"
+      - "Current dirty diff"
+    constraints:
+      - "Do not implement."
+      - "Reject completion if required Worker work is still queued or active."
+      - "Reject completion if the broader original outcome still has safe local follow-up slices."
+      - "Reject stopping only because a slice needs owner input, credentials, production access, destructive operations, or policy decisions."
+    expected_output:
+      - "complete | not_complete"
+      - "full_outcome_complete: true | false"
+      - "missing evidence"
+      - "next task if not complete"
+    receipt: null
+
+checks:
+  dirty_fingerprint: unknown
+  last_verification:
+    result: unknown
+    task: null
+    commands: []