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..10363f6
--- /dev/null
+++ b/.cursor/.syncignore
@@ -0,0 +1,6 @@
+# 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
diff --git a/.cursor/README.md b/.cursor/README.md
new file mode 100644
index 0000000..25761bc
--- /dev/null
+++ b/.cursor/README.md
@@ -0,0 +1,364 @@
+Complete agent-assisted development workflow for Edge repositories — slash skills with companion scripts, coding standards, review standards, and the author skill.
+
+## Installation
+
+**1. Set the required env var** in your `~/.zshrc`:
+```bash
+export GIT_BRANCH_PREFIX=yourname # e.g. jon, paul, sam — used for branch naming and PR discovery
+```
+
+**2. Install files into `~/.cursor/`:**
+```bash
+curl -sL https://github.com/EdgeApp/edge-conventions/archive/refs/heads/jon/agents.tar.gz | \
+ tar -xz --strip-components=2 -C ~/.cursor 'edge-conventions-jon-agents/.cursor' && \
+ find ~/.cursor -type f -name "*.sh" -exec chmod +x {} + && \
+ echo "✓ Installed into ~/.cursor/"
+```
+
+**3. Verify prerequisites:**
+- `gh` CLI — `gh auth login`
+- `jq` — `brew install jq`
+- `ASANA_TOKEN` env var (Asana scripts only)
+
+---
+
+## Table of Contents
+
+- [Architecture](#architecture)
+- [Skills](#skills-slash-skills)
+- [Companion Scripts](#companion-scripts)
+- [Shared Module](#shared-module-edge-repojs)
+- [Rules](#rules-mdc-files)
+- [Author Skill](#author-skill)
+- [Design Principles](#design-principles)
+
+---
+
+## Architecture
+
+```
+.cursor/
+├── skills/ # Primary slash skills (*/SKILL.md) + skill scripts
+├── scripts/ # Shared utility scripts (status dashboard, portability)
+├── commands/ # Minimal legacy command wrappers (if present)
+└── rules/ # Coding/review standards (.mdc)
+```
+
+**Separation of concerns:**
+- **Commands** (`.md`) — Define agent workflows: steps, rules, edge cases. Invoked explicitly via `/command`.
+- **Skills** (`SKILL.md`) — Primary workflow units invoked with `/skill-name` (or selected by context).
+- **Companion scripts** (`.sh`, `.js`) — Handle deterministic operations: API calls, git ops, JSON processing. Skills call scripts; scripts never call skills.
+- **Rules** (`.mdc`) — Persistent coding standards loaded on-demand by file type or command step. Two classes: **editing standards** (loaded when writing code) and **review standards** (loaded during PR review).
+
+All GitHub API operations use **`gh` CLI** (`gh api`, `gh api graphql`, `gh pr`). No raw `curl` + `$GITHUB_TOKEN`.
+
+**User-specific configuration** is driven by the `GIT_BRANCH_PREFIX` env var — set once in `.zshrc`, used by scripts for branch naming (`$GIT_BRANCH_PREFIX/feature-name`) and PR discovery. No hardcoded usernames.
+
+---
+
+## Skills (Slash Skills)
+
+### Core Implementation
+
+| Skill | Description |
+|---------|-------------|
+| [`/im`](.cursor/skills/im/SKILL.md) | Implement an Asana task or ad-hoc feature/fix with clean, structured commits |
+| [`/one-shot`](.cursor/skills/one-shot/SKILL.md) | Legacy-style one-command flow: `/asana-plan` → `/im` → `/pr-create` with default Asana attach/assign |
+| [`/pr-create`](.cursor/skills/pr-create/SKILL.md) | Create a PR from the current branch; optional Asana attach/assign flags |
+| [`/dep-pr`](.cursor/skills/dep-pr/SKILL.md) | Create dependent Asana tasks and run downstream PR workflow |
+| [`/changelog`](.cursor/skills/changelog/SKILL.md) | Update CHANGELOG.md following existing patterns |
+
+### Planning and Context
+
+| Skill | Description |
+|---------|-------------|
+| [`/asana-plan`](.cursor/skills/asana-plan/SKILL.md) | Build implementation plans from Asana tasks or text/file requirements |
+| [`/task-review`](.cursor/skills/task-review/SKILL.md) | Fetch + analyze Asana task context |
+| [`/q`](.cursor/skills/q/SKILL.md) | Answer questions before taking action |
+
+### Review and Landing
+
+| Skill | Description |
+|---------|-------------|
+| [`/pr-review`](.cursor/skills/pr-review/SKILL.md) | Review a PR against coding and review standards |
+| [`/pr-address`](.cursor/skills/pr-address/SKILL.md) | Address PR feedback with fixup commits and replies |
+| [`/pr-land`](.cursor/skills/pr-land/SKILL.md) | Land approved PRs: prepare, merge, publish, and Asana updates |
+
+### Asana and Utility
+
+| Skill | Description |
+|---------|-------------|
+| [`/asana-task-update`](.cursor/skills/asana-task-update/SKILL.md) | Generic Asana mutations (attach PR, assign, status/field updates) |
+| [`/standup`](.cursor/skills/standup/SKILL.md) | Generate daily standup from Asana + GitHub activity |
+| [`/chat-audit`](.cursor/skills/chat-audit/SKILL.md) | Audit chat sessions for workflow/rule issues |
+| [`/convention-sync`](.cursor/skills/convention-sync/SKILL.md) | Sync `~/.cursor` changes with the `edge-conventions` repo and update PR description |
+| [`/author`](.cursor/skills/author/SKILL.md) | Create/update/debug skills and related scripts/rules |
+
+---
+
+## Companion Scripts
+
+### PR Operations
+
+| Script | What it does | API |
+|--------|-------------|-----|
+| [`pr-create.sh`](.cursor/skills/pr-create/scripts/pr-create.sh) | Create PR for current branch with repo-template-aligned title/body | `gh pr create` |
+| [`pr-address.sh`](.cursor/skills/pr-address/scripts/pr-address.sh) | Fetch unresolved feedback, post replies, resolve threads, mark addressed | `gh api` REST + GraphQL |
+| [`github-pr-review.sh`](.cursor/skills/pr-review/scripts/github-pr-review.sh) | Fetch PR context (metadata + patches) and submit reviews | `gh pr view` + `gh api` REST |
+| [`github-pr-activity.sh`](.cursor/skills/standup/scripts/github-pr-activity.sh) | List PRs by activity (recent reviews, comments, CI status) | `gh api graphql` |
+
+### PR Status Dashboard
+
+| Script | What it does | API |
+|--------|-------------|-----|
+| [`pr-status-gql.sh`](.cursor/scripts/pr-status-gql.sh) | PR status with review state, CI checks, new comments (primary) | `gh api graphql` |
+| [`pr-status.sh`](.cursor/scripts/pr-status.sh) | Same as above, REST fallback | `gh api` REST |
+| [`pr-watch.sh`](.cursor/scripts/pr-watch.sh) | TUI wrapper — auto-refresh dashboard with rate limit awareness | Delegates to above |
+
+### PR Landing Pipeline (`/pr-land`)
+
+These scripts run sequentially. Each handles one phase of the landing workflow:
+
+| Script | Phase | What it does | API |
+|--------|-------|-------------|-----|
+| [`pr-land-discover.sh`](.cursor/skills/pr-land/scripts/pr-land-discover.sh) | 1: Discovery | Find all `$GIT_BRANCH_PREFIX/*` PRs with approval status | Single `gh api graphql` query |
+| [`pr-land-comments.sh`](.cursor/skills/pr-land/scripts/pr-land-comments.sh) | 2: Comment check | Detect unaddressed feedback (inline threads, review bodies, top-level comments) | `gh api graphql` per PR |
+| [`pr-land-prepare.sh`](.cursor/skills/pr-land/scripts/pr-land-prepare.sh) | 3: Prepare | Autosquash → rebase → conflict detection → verification | Git only |
+| [`verify-repo.sh`](.cursor/skills/verify-repo.sh) | 3b: Verify | CHANGELOG validation + `prepare`/`tsc`/`lint`/`test` | Git + yarn |
+| [`pr-land-merge.sh`](.cursor/skills/pr-land/scripts/pr-land-merge.sh) | 5: Merge | Sequential merge with auto-rebase, mandatory verification | `gh api` REST |
+| [`pr-land-publish.sh`](.cursor/skills/pr-land/scripts/pr-land-publish.sh) | 6: Publish | Version bump, changelog update, commit + tag (no push) | Git + npm |
+
+**Conflict handling is fully scripted:**
+- Code conflicts → skip PR, continue with remaining
+- CHANGELOG-only (including staging) → agent resolves semantically, re-runs
+
+### Chat Analysis
+
+| Script | What it does |
+|--------|-------------|
+| [`cursor-chat-extract.js`](.cursor/skills/chat-audit/scripts/cursor-chat-extract.js) | Parse Cursor chat export JSON into compact structured summary (messages, tool calls, stats) |
+
+### Asana Integration
+
+| Script | What it does | API |
+|--------|-------------|-----|
+| [`asana-get-context.sh`](.cursor/skills/asana-get-context.sh) | Fetch task details, attachments, subtasks, custom fields | Asana REST |
+| [`asana-task-update.sh`](.cursor/skills/asana-task-update/scripts/asana-task-update.sh) | Generic task updates (attach PR, assign, status, fields) | Asana REST |
+| [`asana-create-dep-task.sh`](.cursor/skills/dep-pr/scripts/asana-create-dep-task.sh) | Create dependent task in another repo's project | Asana REST |
+| [`asana-whoami.sh`](.cursor/skills/asana-whoami.sh) | Get current Asana user info | Asana REST |
+
+### Build & Deps
+
+| Script | What it does |
+|--------|-------------|
+| [`lint-commit.sh`](.cursor/skills/lint-commit.sh) | ESLint `--fix`, localize, graduate warnings, and report effective commit scope before commit |
+| [`lint-warnings.sh`](.cursor/skills/im/scripts/lint-warnings.sh) | Run `eslint --fix`, then summarize any remaining lint findings with matched fix patterns |
+| [`install-deps.sh`](.cursor/skills/install-deps.sh) | Install dependencies and run prepare script |
+| [`upgrade-dep.sh`](.cursor/skills/pr-land/scripts/upgrade-dep.sh) | Upgrade a dependency in the GUI repo |
+
+### Sync & Portability
+
+| Script | What it does |
+|--------|-------------|
+| [`convention-sync.sh`](.cursor/skills/convention-sync/scripts/convention-sync.sh) | Diff and sync `~/.cursor/` files with the edge-conventions repo |
+| [`tool-sync.sh`](.cursor/scripts/tool-sync.sh) | Sync Cursor rules, skills, and scripts to OpenCode and Claude Code formats |
+| [`port-to-opencode.sh`](.cursor/scripts/port-to-opencode.sh) | Convert Cursor `.mdc`/`.md` files to OpenCode-compatible JSON + MD mirrors |
+
+---
+
+## Dependency Graph
+
+### Skill → Skill
+
+```mermaid
+graph LR
+ asanaPlan["/asana-plan"]
+ taskReview["/task-review"]
+ im["/im"]
+ oneShot["/one-shot"]
+ depPr["/dep-pr"]
+ prCreate["/pr-create"]
+ asanaTaskUpdate["/asana-task-update"]
+ author["/author"]
+ conventionSync["/convention-sync"]
+
+ oneShot --> asanaPlan
+ oneShot --> im
+ oneShot --> prCreate
+ asanaPlan --> taskReview
+ im --> asanaPlan
+ depPr --> prCreate
+ prCreate --> asanaTaskUpdate
+ author --> conventionSync
+```
+
+Skills with no skill dependencies:
+
+- `/asana-task-update`
+- `/task-review`
+- `/q`
+- `/pr-review`
+- `/pr-address`
+- `/pr-land`
+- `/standup`
+- `/chat-audit`
+- `/changelog`
+- `/convention-sync`
+
+### Full Skill/Script Dependency Graph
+
+Top-to-bottom organization: skill layer, skill-specific scripts, shared scripts.
+
+```mermaid
+graph TD
+ subgraph skillLayer [Skills]
+ im["/im"]
+ oneShot["/one-shot"]
+ asanaPlan["/asana-plan"]
+ taskReview["/task-review"]
+ depPr["/dep-pr"]
+ prCreate["/pr-create"]
+ asanaTaskUpdate["/asana-task-update"]
+ prLand["/pr-land"]
+ prReview["/pr-review"]
+ prAddress["/pr-address"]
+ standup["/standup"]
+ chatAudit["/chat-audit"]
+ conventionSync["/convention-sync"]
+ author["/author"]
+ q["/q"]
+ changelog["/changelog"]
+ end
+
+ subgraph skillScripts [Skill Scripts]
+ prCreateSh["pr-create.sh"]
+ prAddressSh["pr-address.sh"]
+ prReviewSh["github-pr-review.sh"]
+ depTaskSh["asana-create-dep-task.sh"]
+ asanaTaskUpdateSh["asana-task-update.sh"]
+ prLandDisc["pr-land-discover.sh"]
+ prLandCmts["pr-land-comments.sh"]
+ prLandPrep["pr-land-prepare.sh"]
+ prLandMerge["pr-land-merge.sh"]
+ prLandPublish["pr-land-publish.sh"]
+ prLandExtract["pr-land-extract-asana-task.sh"]
+ standupAsana["asana-standup.sh"]
+ standupGh["github-pr-activity.sh"]
+ chatExtract["cursor-chat-extract.js"]
+ conventionSyncSh["convention-sync.sh"]
+ generateClaude["generate-claude-md.sh"]
+ lintWarn["lint-warnings.sh"]
+ end
+
+ subgraph sharedScripts [Shared Scripts]
+ lintCommit["lint-commit.sh"]
+ verifyRepo["verify-repo.sh"]
+ asanaGetContext["asana-get-context.sh"]
+ asanaWhoAmI["asana-whoami.sh"]
+ installDeps["install-deps.sh"]
+ edgeRepo["edge-repo.js"]
+ end
+
+ oneShot --> asanaPlan
+ oneShot --> im
+ oneShot --> prCreate
+ asanaPlan --> taskReview
+ im --> asanaPlan
+ depPr --> prCreate
+ prCreate --> asanaTaskUpdate
+ author --> conventionSync
+
+ prCreate --> prCreateSh
+ prCreate --> verifyRepo
+ prCreate --> asanaTaskUpdateSh
+ im --> lintWarn
+ im --> lintCommit
+ im --> verifyRepo
+ im --> installDeps
+ depPr --> depTaskSh
+ depPr --> asanaGetContext
+ asanaTaskUpdate --> asanaTaskUpdateSh
+ taskReview --> asanaGetContext
+ prAddress --> prAddressSh
+ prAddress --> lintCommit
+ prReview --> prReviewSh
+ prLand --> prLandDisc
+ prLand --> prLandCmts
+ prLand --> prLandPrep
+ prLand --> prLandMerge
+ prLand --> prLandPublish
+ prLand --> prLandExtract
+ prLand --> asanaTaskUpdateSh
+ prLand --> verifyRepo
+ standup --> standupAsana
+ standup --> standupGh
+ chatAudit --> chatExtract
+ conventionSync --> conventionSyncSh
+ conventionSync --> generateClaude
+
+ depTaskSh --> asanaWhoAmI
+ depTaskSh --> asanaTaskUpdateSh
+ asanaTaskUpdateSh --> asanaWhoAmI
+ standupAsana --> asanaWhoAmI
+ prLandPrep --> edgeRepo
+ prLandMerge --> edgeRepo
+ prLandPublish --> edgeRepo
+```
+
+---
+
+## Shared Module: `edge-repo.js`
+
+[`edge-repo.js`](.cursor/skills/pr-land/scripts/edge-repo.js) eliminates duplication across the `pr-land-*` scripts. Exports:
+
+| Function | Purpose |
+|----------|---------|
+| `getRepoDir(repo)` | Resolve local checkout path (`~/git/`, `~/projects/`, `~/code/`) |
+| `getUpstreamBranch(repo)` | `origin/develop` for GUI, `origin/master` for everything else |
+| `runGit(args, cwd, opts)` | Safe `spawnSync` wrapper with `GIT_EDITOR=true` |
+| `parseConflictFiles(output)` | Extract conflicting file paths from rebase output |
+| `isChangelogOnly(files)` | Check if all conflicts are in CHANGELOG.md |
+| `runVerification(repoDir, baseRef, opts)` | Run the full verify script with scoped lint (supports `{requireChangelog: true}`) |
+| `ghApi(endpoint, opts)` | `gh api` wrapper with method, body, paginate, jq support |
+| `ghGraphql(query, vars)` | `gh api graphql` wrapper with typed variable injection |
+
+---
+
+## Rules (`.mdc` files)
+
+| Rule | Activation | Purpose |
+|------|-----------|---------|
+| [`typescript-standards.mdc`](.cursor/rules/typescript-standards.mdc) | Loaded before editing `.ts`/`.tsx` files | TypeScript + React coding standards for **editing** (includes `simple-selectors` rule, descriptive variable names, biggystring arithmetic) |
+| [`review-standards.mdc`](.cursor/rules/review-standards.mdc) | Loaded by `/pr-review` command | ~50 review-specific diagnostic rules extracted from PR history |
+| [`load-standards-by-filetype.mdc`](.cursor/rules/load-standards-by-filetype.mdc) | Always applied | Auto-loads language-specific standards before editing |
+| [`fix-workflow-first.mdc`](.cursor/rules/fix-workflow-first.mdc) | Always applied | Fix command/skill definitions before patching downstream symptoms |
+| [`answer-questions-first.mdc`](.cursor/rules/answer-questions-first.mdc) | Always applied | Detect `?` in user messages → answer before acting; loads active command context to evaluate workflow gaps |
+| [`no-format-lint.mdc`](.cursor/rules/no-format-lint.mdc) | Always applied | Don't manually fix formatting — auto-format on agent finish handles it |
+| [`eslint-warnings.mdc`](.cursor/rules/eslint-warnings.mdc) | `.ts`/`.tsx` files | ESLint warning handling patterns |
+
+**Editing vs. review separation**: `typescript-standards` contains rules for writing code (prefer `useHandler`, use `InteractionManager`, descriptive variable names, biggystring for numeric calculations). `review-standards` contains diagnostic patterns for catching bugs during review (null `tokenId` fallback, stack trace preservation, module-level cache bugs, etc.). Both are loaded together during `/pr-review`; only `typescript-standards` is loaded during editing.
+
+---
+
+## Author Skill
+
+| Skill | Purpose |
+|-------|---------|
+| [`author/SKILL.md`](.cursor/skills/author/SKILL.md) | Meta-skill for creating/maintaining skills, scripts, and rules. Enforces XML format, `scripts-over-reasoning`, `gh-cli-over-curl`, dependency-audit requirements before script add/update/remove, and convention-sync/CLAUDE sync post-authoring behavior. |
+
+---
+
+## Design Principles
+
+1. **Scripts over reasoning** — Deterministic operations (API calls, git, JSON) go in companion scripts, not inline in commands.
+2. **`gh` CLI over `curl`** — All GitHub API calls use `gh api` / `gh api graphql`. Handles auth, pagination, API versioning automatically.
+3. **GraphQL over REST** — Fetch only required fields in a single request where possible. Fall back to REST only when GraphQL doesn't expose the needed data (e.g., file patches).
+4. **DRY shared modules** — Common utilities extracted into `edge-repo.js` rather than duplicated across scripts.
+5. **XML format** — Skills use XML structure (``, ``, ``) for reliable LLM instruction-following.
+6. **Standards-first** — Load coding standards before writing or reviewing any code.
+7. **Fix workflow first** — When behavior is wrong, fix the command/skill definition, not the downstream symptom.
+8. **No hardcoded usernames** — All user-specific values come from `GIT_BRANCH_PREFIX` env var, set once in `.zshrc`.
+9. **Minimize context** — Script output must be compact and structured. Never return raw API responses. Every token costs context.
+10. **Small-model conventions** — High-frequency skills that run on faster/cheaper models use verbatim bash, file-over-args, inline guardrails, and explicit parallel instructions for reliability.
+11. **Knowledge base over crawling** — Maintain curated knowledge files (e.g., `eslint-warnings.mdc`) instead of having the agent crawl/grep for information repeatedly. Pre-indexed knowledge reduces tool calls and context consumption.
+12. **Continuous improvement** — Workflows feed back into their own knowledge. PR review feedback updates `review-standards.mdc`, addressed warnings update `eslint-warnings.mdc`, and chat audits surface rule gaps. Each cycle reduces repetitive context gathering by the agent and repetitive review by humans.
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*
+
+