diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
new file mode 100644
index 0000000..7b819b6
--- /dev/null
+++ b/.claude/CLAUDE.md
@@ -0,0 +1,138 @@
+# Global Rules
+
+# Auto-generated from ~/.cursor/rules/ (alwaysApply: true files only).
+# Do not edit manually. Re-generate via convention-sync.
+
+---
+
+## answer-questions-first
+
+# Answer Questions Before Acting
+
+Before using any code editing tools, scan the user's message for `?` characters and determine if it's a question.
+
+- **Ignore** `?` inside code, URLs or query parameters (e.g. `?param=x`, `?key=value` , `const x = ifTrue ? 'yes' : 'no'`)
+- **Treat all other `?`** as question statements, if they appear to be questions.
+
+If questions are detected:
+
+1. Read `~/.cursor/skills/q/SKILL.md` and follow its workflow to answer every question.
+2. **Workflow context**: If a skill was invoked earlier in this conversation, note which one. When a question or critique references agent behavior from that execution, load the skill definition before answering and evaluate whether the skill should have governed that behavior. If it should have but didn't, that's a workflow gap — treat it as the primary concern per `fix-workflow-first.mdc`.
+3. Do **not** edit files, create files, or run mutating commands until the user responds.
+4. Only proceed with implementation after the user permits it in a follow-up message.
+
+---
+
+## load-standards-by-filetype
+
+Load language-specific coding standards before editing or investigating lint/type errors in files, without redundant reads.
+
+
+Before using any code editing tool on a file OR investigating lint/type errors in that file type, check if the matching standards rule is already present in `cursor_rules_context`. Only read the rule file if it is NOT already in context.
+If the rule is not in context, read it using the Read tool and follow its contents BEFORE making the edit or investigating the error.
+
+
+
+
+| File glob | Standards file |
+|---|----|
+| `**/*.ts`,`**/*.tsx` | `~/.cursor/rules/typescript-standards.mdc` |
+
+
+
+---
+
+## no-format-lint
+
+# No Manual Formatting or Lint Fixing
+
+- Do NOT run `yarn lint`, `yarn fix`, `yarn verify`, or any lint/format shell commands unless explicitly asked.
+- Do NOT manually fix formatting issues (whitespace, quotes, semicolons, trailing commas, line length). The `lint-commit.sh` script runs `eslint --fix` (including Prettier) before each commit.
+- Only use `ReadLints` to check for logical or type errors, not formatting. If the only lint errors are formatting-related, ignore them.
+- Focus tokens on correctness and logic, not style.
+
+---
+
+## workflow-halt-on-error
+
+
+
+All workflow-related skill definitions (`*.md` / `SKILL.md`) and workflow companion scripts (`*.sh`) are sourced from `~/.cursor/`. When executing skills, prefer explicit `~/.cursor/...` paths and do not assume repo-local workflow files unless the skill explicitly points to one.
+
+When a skill mentions a script path, resolve it under `~/.cursor/skills//scripts/` unless the skill explicitly specifies an absolute path elsewhere. Do not assume repo-relative `scripts/` paths without verifying the skill directory contents.
+
+When ANY shell command fails (non-zero exit code) while executing an active skill workflow, a delegated subskill from that workflow, or a companion-script step required by that workflow (except where explicitly allowed by `auto-fix-verification-failures` or `companion-script-nonzero-contracts`):
+1. **STOP** — do not retry, work around, substitute, or continue the workflow.
+2. **Report** — show the user the exact command, exit code, and error output.
+3. **Diagnose** — classify the failure: missing tool (`command not found`), wrong path, permissions, or logic error.
+4. **Evaluate workflow** — if the failure reveals a gap in a skill definition, follow the fix-workflow-first rules below.
+5. **Wait** — do not resume until the user responds.
+
+
+When a workflow gap is discovered in an active skill definition:
+1. **Stop immediately** — do not continue the current task or apply any workaround.
+2. **Identify the root cause** in the skill (`.cursor/skills/*/SKILL.md`) definition.
+3. **Propose the fix** to the user and wait for approval before proceeding.
+4. **Fix the skill** using `/author` after approval.
+5. **Resume the original task** only after the skill is updated.
+
+Fixing the skill takes **absolute priority** over all other actions — including workarounds, continuing the original task, or applying temporary fixes. Do NOT apply workarounds or manual fixes before proposing the skill update. The correct sequence is: identify gap → propose fix → get approval → apply fix → then resume original task. This applies to all workflow issues — missed steps, incorrect output, wrong tool usage, shell failures, formatting problems, etc. The skill is the source of truth; patching around it creates drift.
+
+
+These workflow halt rules are for skill-driven execution, especially hands-off/orchestrated skills and their dependencies. They do not automatically apply to ad hoc exploration, incidental verification, or low-risk authoring work unless that command is part of an active skill contract.
+
+Exception to `halt-on-error`: For verification/code-quality failures where diagnostics are explicit and local, continue automatically with bounded remediation.
+
+Allowed auto-fix scope:
+- TypeScript/compiler failures (`tsc`) with clear file/line diagnostics
+- Lint failures (`eslint`) with clear file/line diagnostics
+- Test failures (`jest`/`yarn test`) when stack traces or assertion output identify failing test files
+- `verify-repo.sh` code-step failures that resolve to one of the above
+
+Required behavior:
+1. Briefly log rationale: failure type, affected files, and why scope is unambiguous.
+2. Apply the minimal fix in the failing repo.
+3. Re-run the failing verification step.
+4. Limit to 2 remediation attempts; if still failing or scope expands, fall back to `halt-on-error`.
+
+Never auto-fix:
+- Missing tools/auth (`command not found`, `PROMPT_GH_AUTH`)
+- Wrong path/permissions
+- Companion script contract/usage failures
+- Unexpected exit codes from orchestrator scripts
+- Any failure requiring destructive operations or workflow bypasses
+
+
+Respect documented companion script exit-code contracts. Non-zero does NOT always mean fatal.
+
+For `~/.cursor/skills/im/scripts/lint-warnings.sh`:
+- `0` = no remaining lint findings after auto-fix
+- `1` = remaining lint findings after auto-fix (expected actionable state)
+- `2` = execution error (fatal)
+
+Required behavior:
+1. If exit `1`, continue workflow by fixing the remaining lint findings before implementation.
+2. If the script auto-fixes pre-existing lint issues, commit those changes in a separate lint-fix commit immediately before feature commits, even if no findings remain.
+3. If exit `2`, apply `halt-on-error`.
+
+
+Do NOT silently substitute an alternative tool or approach when a command fails. If `rg` is not found, do not fall back to `grep`. If a script exits non-zero, do not manually replicate what the script does. The failure is the signal — report it.
+
+
+
+
+
+Scan the user's message for `/word` tokens. A token is a **command invocation** when ALL of:
+- `/word` is preceded by whitespace, a newline, or is at the start of the message
+- `word` contains only lowercase letters and hyphens (e.g., `/im`, `/pr-create`, `/author`)
+- `/word` is NOT inside a file path, URL, or code block
+
+When detected:
+1. Read `~/.cursor/skills//SKILL.md` and follow it immediately.
+2. If the file does not exist, inform the user: "Skill `/` not found in `~/.cursor/skills/`."
+
+**Ignore `/`** in: file paths (`/Users/...`, `~/...`), URLs (`https://...`), mid-word (`and/or`), backticks/code blocks.
+
+
+
+
diff --git a/.claude/skills b/.claude/skills
new file mode 120000
index 0000000..8574c4f
--- /dev/null
+++ b/.claude/skills
@@ -0,0 +1 @@
+../.cursor/skills
\ No newline at end of file
diff --git a/.cursor/.syncignore b/.cursor/.syncignore
new file mode 100644
index 0000000..8eaf885
--- /dev/null
+++ b/.cursor/.syncignore
@@ -0,0 +1,18 @@
+# Files to exclude from convention-sync (one glob per line)
+# Patterns match against relative paths like: commands/foo.sh, rules/bar.mdc
+
+# WIP commands
+commands/hudl.md
+commands/github-pr-hudl.sh
+
+# --- Maestro flows -----------------------------------------------------------
+# The build-and-test harness ships ONE canonical, reusable flow a fresh machine
+# needs — capture-buy-quote.sh defaults to skills/build-and-test/maestro/
+# buy-quote-input.yaml — so buy-quote*.yaml MUST keep syncing.
+#
+# Task/feature-specific flows an agent authors mid-run (e.g. the Maya swap-*
+# flows) are GUI dev artifacts, NOT agent conventions. Keep them LOCALLY for
+# reuse, but never push them to the agent repo. Until the orchestration
+# "where do per-task yamls live" strategy is finalized, list those task-flow
+# families here so the leak can't recur.
+skills/build-and-test/maestro/swap-*.yaml
diff --git a/.cursor/commands/github-pr-hudl.sh b/.cursor/commands/github-pr-hudl.sh
new file mode 100755
index 0000000..2ec3db7
--- /dev/null
+++ b/.cursor/commands/github-pr-hudl.sh
@@ -0,0 +1,389 @@
+#!/usr/bin/env bash
+# github-pr-hudl.sh — Fetch comprehensive GitHub PR activity for a given day.
+# Detects multiple action categories for HUDL standup generation.
+#
+# Categories:
+# - created: PRs created by user on target date
+# - committed: PRs where user pushed commits on target date
+# - addressed: PRs with commits after receiving review comments
+# - reviewed: PRs by others that user reviewed on target date
+# - commented: PRs where user posted comments on target date
+# - approved: PRs that have approval (for Goals Today)
+# - blocked: PRs blocked by CI or changes requested (for Handoffs)
+# - open_prs: All open PRs for debug section
+#
+# Usage:
+# github-pr-hudl.sh [--date YYYY-MM-DD]
+#
+# Requires: gh CLI authenticated, ASANA_TOKEN for cross-referencing
+#
+# Output: JSON with date, username, day_label, and category arrays
+set -euo pipefail
+
+TARGET_DATE=""
+while [[ $# -gt 0 ]]; do
+ case "$1" in
+ --date) TARGET_DATE="$2"; shift 2 ;;
+ *) echo "Unknown: $1" >&2; exit 1 ;;
+ esac
+done
+
+if ! command -v gh &>/dev/null; then
+ echo "Error: gh CLI not installed" >&2; exit 1
+fi
+if ! gh auth status &>/dev/null 2>&1; then
+ echo "PROMPT_GH_AUTH" >&2; exit 2
+fi
+
+USERNAME=$(gh api user --jq '.login')
+ASANA_TOKEN="${ASANA_TOKEN:-}"
+
+export TARGET_DATE USERNAME ASANA_TOKEN
+
+python3 - << 'PYEOF'
+import json, os, re, subprocess, sys, urllib.request, urllib.error
+from datetime import date, timedelta
+
+USERNAME = os.environ["USERNAME"]
+TARGET_DATE_STR = os.environ.get("TARGET_DATE", "")
+ASANA_TOKEN = os.environ.get("ASANA_TOKEN", "")
+
+today = date.today()
+
+if TARGET_DATE_STR:
+ # Explicit date: use single day
+ target_start = date.fromisoformat(TARGET_DATE_STR)
+ target_end = target_start
+ day_label = target_start.strftime("%A")
+else:
+ # Default: from last workday until now
+ if today.weekday() == 0: # Monday
+ target_start = today - timedelta(days=3) # Friday
+ target_end = today
+ day_label = "since Friday"
+ else:
+ target_start = today - timedelta(days=1) # Yesterday
+ target_end = today
+ day_label = "since yesterday"
+
+TARGET_START_STR = target_start.isoformat()
+TARGET_END_STR = target_end.isoformat()
+
+
+def gh_graphql(query, variables):
+ args = ["gh", "api", "graphql", "-f", f"query={query}"]
+ for k, v in variables.items():
+ args.extend(["-f", f"{k}={v}"])
+ result = subprocess.run(args, capture_output=True, text=True)
+ if result.returncode != 0:
+ print(f"GH_ERROR: {result.stderr[:300]}", file=sys.stderr)
+ return {"data": {"search": {"nodes": []}}}
+ parsed = json.loads(result.stdout)
+ if "errors" in parsed:
+ print(f"GQL_ERROR: {json.dumps(parsed['errors'][:2])}", file=sys.stderr)
+ return parsed
+
+
+def extract_asana_gid(body):
+ if not body:
+ return None
+ m = re.search(r'asana\.com/\S*/(\d{10,})', body)
+ return m.group(1) if m else None
+
+
+def fetch_asana_status(gid):
+ """Fetch Asana task status via API."""
+ if not ASANA_TOKEN or not gid:
+ return None
+ try:
+ req = urllib.request.Request(
+ f"https://app.asana.com/api/1.0/tasks/{gid}?opt_fields=custom_fields.gid,custom_fields.display_value",
+ headers={"Authorization": f"Bearer {ASANA_TOKEN}"}
+ )
+ with urllib.request.urlopen(req, timeout=5) as resp:
+ data = json.loads(resp.read())
+ for f in data.get("data", {}).get("custom_fields", []):
+ if f.get("gid") == "1190660107346181": # Status field
+ return f.get("display_value")
+ except Exception as e:
+ print(f"ASANA_ERROR: {e}", file=sys.stderr)
+ return None
+
+
+# --- Main GraphQL query for user's activity ---
+QUERY_USER_PRS = """
+query($search: String!) {
+ search(query: $search, type: ISSUE, first: 100) {
+ nodes {
+ ... on PullRequest {
+ number
+ title
+ url
+ body
+ state
+ createdAt
+ repository { nameWithOwner }
+ reviews(last: 50) {
+ nodes {
+ author { login }
+ state
+ submittedAt
+ }
+ }
+ commits(last: 50) {
+ nodes {
+ commit {
+ committedDate
+ author { user { login } }
+ }
+ }
+ }
+ comments(last: 50) {
+ nodes {
+ author { login }
+ createdAt
+ }
+ }
+ reviewThreads(first: 50) {
+ nodes {
+ comments(first: 10) {
+ nodes {
+ author { login }
+ createdAt
+ }
+ }
+ }
+ }
+ reviewDecision
+ statusCheckRollup {
+ state
+ }
+ }
+ }
+ }
+}
+"""
+
+# Search 1: User's own PRs (open or recently updated)
+search_authored = f"is:pr author:{USERNAME} updated:>={TARGET_START_STR} sort:updated"
+authored_raw = gh_graphql(QUERY_USER_PRS, {"search": search_authored})
+
+# Search 2: PRs reviewed by user
+search_reviewed = f"is:pr reviewed-by:{USERNAME} -author:{USERNAME} updated:>={TARGET_START_STR} sort:updated"
+reviewed_raw = gh_graphql(QUERY_USER_PRS, {"search": search_reviewed})
+
+# Search 3: PRs where user commented
+search_commented = f"is:pr commenter:{USERNAME} -author:{USERNAME} updated:>={TARGET_START_STR} sort:updated"
+commented_raw = gh_graphql(QUERY_USER_PRS, {"search": search_commented})
+
+search_count = 0
+for raw in [authored_raw, reviewed_raw, commented_raw]:
+ search_count += len(raw.get("data", {}).get("search", {}).get("nodes", []))
+
+print(f"Searched {search_count} PR candidates", file=sys.stderr)
+
+# --- Process authored PRs ---
+created = []
+committed = []
+addressed = []
+approved = []
+blocked = []
+open_prs = []
+
+seen_prs = set()
+
+for node in authored_raw.get("data", {}).get("search", {}).get("nodes", []):
+ if not node or "number" not in node:
+ continue
+
+ pr_key = f"{node['repository']['nameWithOwner']}#{node['number']}"
+ if pr_key in seen_prs:
+ continue
+ seen_prs.add(pr_key)
+
+ asana_gid = extract_asana_gid(node.get("body"))
+ asana_status = fetch_asana_status(asana_gid) if asana_gid else None
+
+ pr_entry = {
+ "pr_number": node["number"],
+ "pr_title": node["title"],
+ "pr_url": node["url"],
+ "repo": node["repository"]["nameWithOwner"],
+ "asana_gid": asana_gid,
+ "asana_status": asana_status,
+ }
+
+ # Check if created within target window
+ created_at = (node.get("createdAt") or "")[:10]
+ if TARGET_START_STR <= created_at <= TARGET_END_STR:
+ created.append(pr_entry)
+
+ # Check for human reviews before target window
+ has_prior_review = False
+ for r in (node.get("reviews") or {}).get("nodes", []):
+ if not r or not r.get("author"):
+ continue
+ reviewer = r["author"].get("login", "")
+ if reviewer == USERNAME or "[bot]" in reviewer:
+ continue
+ submitted = (r.get("submittedAt") or "")[:10]
+ if submitted < TARGET_START_STR and r.get("state") in ("CHANGES_REQUESTED", "COMMENTED"):
+ has_prior_review = True
+ break
+
+ # Check for commits within target window
+ commits_in_window = []
+ for c in (node.get("commits") or {}).get("nodes", []):
+ commit = (c or {}).get("commit", {})
+ committed_date = (commit.get("committedDate") or "")[:10]
+ commit_user = ((commit.get("author") or {}).get("user") or {}).get("login", "")
+ if TARGET_START_STR <= committed_date <= TARGET_END_STR and commit_user == USERNAME:
+ commits_in_window.append(commit)
+
+ if commits_in_window:
+ entry_with_count = {**pr_entry, "commit_count": len(commits_in_window)}
+ # Only count as addressed/committed if PR wasn't created in window
+ if not (TARGET_START_STR <= created_at <= TARGET_END_STR):
+ if has_prior_review:
+ addressed.append(entry_with_count)
+ else:
+ committed.append(entry_with_count)
+
+ # Track open PRs for debug and blocked/approved analysis
+ if node.get("state") == "OPEN":
+ review_decision = node.get("reviewDecision")
+ ci_state = (node.get("statusCheckRollup") or {}).get("state")
+
+ # Determine status summary
+ status_parts = []
+ if review_decision:
+ status_parts.append(review_decision.lower().replace("_", " "))
+ if ci_state:
+ status_parts.append(f"CI: {ci_state.lower()}")
+ if asana_status:
+ status_parts.append(f"Asana: {asana_status}")
+
+ open_prs.append({
+ **pr_entry,
+ "review_decision": review_decision,
+ "ci_state": ci_state,
+ "status_summary": ", ".join(status_parts) if status_parts else "open"
+ })
+
+ # Check if approved (GitHub approved OR Asana Publish Needed)
+ if review_decision == "APPROVED" or asana_status == "Publish Needed":
+ approved.append(pr_entry)
+
+ # Check if blocked
+ if ci_state == "FAILURE":
+ blocked.append({**pr_entry, "block_reason": "ci_failure", "detail": "CI failing"})
+ elif review_decision == "CHANGES_REQUESTED":
+ # Find who requested changes
+ changers = []
+ for r in (node.get("reviews") or {}).get("nodes", []):
+ if r and r.get("state") == "CHANGES_REQUESTED":
+ author = (r.get("author") or {}).get("login", "")
+ if author and author not in changers:
+ changers.append(author)
+ blocked.append({
+ **pr_entry,
+ "block_reason": "changes_requested",
+ "detail": ", ".join(changers) if changers else "reviewer"
+ })
+
+# --- Process reviewed PRs ---
+reviewed = []
+for node in reviewed_raw.get("data", {}).get("search", {}).get("nodes", []):
+ if not node or "number" not in node:
+ continue
+
+ pr_key = f"{node['repository']['nameWithOwner']}#{node['number']}"
+ if pr_key in seen_prs:
+ continue
+ seen_prs.add(pr_key)
+
+ # Find user's review within target window
+ review_state = None
+ for r in (node.get("reviews") or {}).get("nodes", []):
+ if not r or not r.get("author"):
+ continue
+ if r["author"].get("login") != USERNAME:
+ continue
+ submitted = (r.get("submittedAt") or "")[:10]
+ if TARGET_START_STR <= submitted <= TARGET_END_STR:
+ review_state = r.get("state", "COMMENTED")
+ break
+
+ if review_state:
+ reviewed.append({
+ "pr_number": node["number"],
+ "pr_title": node["title"],
+ "pr_url": node["url"],
+ "repo": node["repository"]["nameWithOwner"],
+ "asana_gid": extract_asana_gid(node.get("body")),
+ "review_state": review_state,
+ })
+
+# --- Process commented PRs ---
+commented_list = []
+for node in commented_raw.get("data", {}).get("search", {}).get("nodes", []):
+ if not node or "number" not in node:
+ continue
+
+ pr_key = f"{node['repository']['nameWithOwner']}#{node['number']}"
+ if pr_key in seen_prs:
+ continue
+ seen_prs.add(pr_key)
+
+ # Check for comments by user on target date
+ has_comment = False
+
+ # Issue comments
+ for c in (node.get("comments") or {}).get("nodes", []):
+ if not c:
+ continue
+ author = (c.get("author") or {}).get("login", "")
+ created = (c.get("createdAt") or "")[:10]
+ if author == USERNAME and TARGET_START_STR <= created <= TARGET_END_STR:
+ has_comment = True
+ break
+
+ # Review thread comments
+ if not has_comment:
+ for thread in (node.get("reviewThreads") or {}).get("nodes", []):
+ for c in (thread.get("comments") or {}).get("nodes", []):
+ if not c:
+ continue
+ author = (c.get("author") or {}).get("login", "")
+ created = (c.get("createdAt") or "")[:10]
+ if author == USERNAME and TARGET_START_STR <= created <= TARGET_END_STR:
+ has_comment = True
+ break
+ if has_comment:
+ break
+
+ if has_comment:
+ commented_list.append({
+ "pr_number": node["number"],
+ "pr_title": node["title"],
+ "pr_url": node["url"],
+ "repo": node["repository"]["nameWithOwner"],
+ "asana_gid": extract_asana_gid(node.get("body")),
+ })
+
+print(json.dumps({
+ "date_start": TARGET_START_STR,
+ "date_end": TARGET_END_STR,
+ "day_label": day_label,
+ "username": USERNAME,
+ "search_count": search_count,
+ "created": created,
+ "committed": committed,
+ "addressed": addressed,
+ "reviewed": reviewed,
+ "commented": commented_list,
+ "approved": approved,
+ "blocked": blocked,
+ "open_prs": open_prs,
+}, indent=2))
+PYEOF
diff --git a/.cursor/commands/hudl.md b/.cursor/commands/hudl.md
new file mode 100644
index 0000000..adf630a
--- /dev/null
+++ b/.cursor/commands/hudl.md
@@ -0,0 +1,229 @@
+Generate a daily HUDL document from GitHub PR activity, upload to a single persistent private gist.
+
+
+PR names are the clickable link: `[{title}]({url})`. Never add a separate URL.
+All HUDL files go into ONE gist with description "HUDL Notes". Create on first run, add files on subsequent runs. Never overwrite — append a suffix (`-1`, `-2`, etc.) if the filename exists.
+Delete the local file after successful gist upload.
+Set `block_until_ms: 120000` for the companion script.
+PRs with Asana GIDs in body should have their Asana status fetched to determine true workflow status.
+
+
+
+Run the companion script:
+
+```bash
+~/.cursor/commands/github-pr-hudl.sh
+```
+
+If the user supplies a specific date, pass `--date YYYY-MM-DD`.
+
+Capture stdout (JSON) and stderr (diagnostics) separately.
+
+
+
+The JSON output has these fields:
+- `date_start`, `date_end`: The time window (e.g., Friday to Monday for Monday HUDL)
+- `day_label`: Display label (e.g., "since Friday" or "since yesterday")
+
+And these arrays:
+- `created`: PRs created within window
+- `committed`: PRs where user pushed commits within window
+- `addressed`: PRs with commits after receiving review comments
+- `reviewed`: PRs by others that user reviewed
+- `commented`: PRs where user posted comments
+- `approved`: PRs that have approval (for Goals Today)
+- `blocked`: PRs blocked by CI failure or changes requested (for Handoffs)
+- `open_prs`: All open PRs for debug section
+
+Each entry has: `pr_number`, `pr_title`, `pr_url`, `repo`, `asana_gid` (nullable), `asana_status` (nullable), plus action-specific fields.
+
+
+
+Build the markdown file with EXACTLY the structure below. Every heading, bullet, and blank line matters.
+
+
+Line 1 of the file. Use `date_end` from the JSON for the header date.
+
+```
+# HUDL Notes — {full_weekday_name} {full_month_name} {day}, {year}
+```
+
+Example: `# HUDL Notes — Monday February 17, 2026`
+
+
+
+```
+## Accomplishments {day_label}
+```
+
+Use `day_label` from the JSON (either `"yesterday"` or `"Friday"`).
+
+Categorize each PR into exactly ONE subsection based on its PRIMARY action. Determine the primary action using this priority (highest first):
+
+1. `created` → goes in **PR'd**
+2. `addressed` → goes in **Addressed PR Comments**
+3. `reviewed` → goes in **Reviewed PRs**
+4. `committed` or `commented` → goes in **General**
+
+A PR appears in only ONE subsection — the highest-priority one that matches.
+
+**Subsection: PR'd** — include only if at least one PR qualifies.
+
+```
+### PR'd
+
+- [{pr_title}]({pr_url}) ({repo})
+```
+
+One bullet per PR. No action text — the heading says it.
+
+**Subsection: Addressed PR Comments** — include only if at least one PR qualifies.
+
+```
+### Addressed PR Comments
+
+- [{pr_title}]({pr_url}) ({repo})
+```
+
+**Subsection: Reviewed PRs** — include only if at least one PR qualifies.
+
+```
+### Reviewed PRs
+
+- [{pr_title}]({pr_url}) ({repo}) — approved
+```
+
+Append the review verdict in lowercase after ` — `. Map `review_state`:
+- `APPROVED` → `approved`
+- `CHANGES_REQUESTED` → `changes requested`
+- `COMMENTED` → `commented`
+
+**Subsection: General** — include only if at least one PR qualifies.
+
+```
+### General
+
+- [{pr_title}]({pr_url}) ({repo}) — Committed: 3 commits
+```
+
+Format each action type:
+- `committed` → `Committed: {commit_count} commits`
+- `commented` → `Commented`
+
+If a PR has multiple actions in General, join with `; `.
+
+**Omit any subsection that would have zero bullets.**
+
+
+
+```
+## Goals Today
+```
+
+List PRs from the `approved` array (PRs that are approved and ready to merge/publish):
+
+```
+- Publish [{pr_title}]({pr_url})
+```
+
+After all approved items (or immediately if there are none), add one blank bullet for the user to fill in:
+
+```
+-
+```
+
+
+
+```
+## Handoffs
+```
+
+Group entries from the `blocked` array by block reason.
+
+**CI Failures** — if any PR has `block_reason=ci_failure`:
+
+```
+### Blocked by CI
+
+- [{pr_title}]({pr_url}) — CI failing
+```
+
+**Changes Requested** — if any PR has `block_reason=changes_requested`:
+
+```
+### Changes Requested
+
+- [{pr_title}]({pr_url}) — {reviewer} requested changes
+```
+
+If the blocked array is completely empty, write:
+
+```
+None
+```
+
+
+
+Add a horizontal rule, then a collapsed details block.
+
+```
+---
+
+Debug: {N} open PRs
+
+```
+
+Where `{N}` is the length of the `open_prs` array.
+
+For each entry in `open_prs`, write:
+
+```
+- [{pr_title}]({pr_url}) — {status_summary}
+```
+
+Where `status_summary` includes: review state, CI status, Asana status (if present).
+
+End with search stats and close the details tag:
+
+```
+
+*Searched {search_count} PRs*
+
+