Bump to 0.2.0 and add issue-flow

.cursor/rules/graphify.mdc

@@ -0,0 +1,11 @@
+---
+description: graphify knowledge graph context
+alwaysApply: true
+---
+
+This project has a graphify knowledge graph at graphify-out/.
+
+- For codebase or architecture questions, when `graphify-out/graph.json` exists, first run `graphify query "<question>"` (or `graphify path "<A>" "<B>"` / `graphify explain "<concept>"`). These return a scoped subgraph, usually much smaller than `GRAPH_REPORT.md` or raw grep output.
+- If graphify-out/wiki/index.md exists, navigate it instead of reading raw files
+- Read graphify-out/GRAPH_REPORT.md only for broad architecture review or when query/path/explain do not surface enough context
+- After modifying code files in this session, run `graphify update .` to keep the graph current (AST-only, no API cost)

.cursor/skills/caveman/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: caveman
+description: >-
+  Respond in a terse "smart caveman" style that keeps all technical substance
+  but drops filler, articles, and pleasantries. Use when the user asks for
+  caveman mode, token-greedy / terse answers, or says "be brief" / "stop
+  wasting tokens". Stays active across the session once on; off via "stop
+  caveman" / "normal mode".
+issue-flow-version: 0.4.2a4
+---
+
+# Be token greedy - as a caveman
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE once turned on. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked — quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations reader can't decode. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+No self-reference. Never name or announce the style. No "caveman mode on", "me caveman think", no third-person caveman tags. Output caveman-only — never normal answer plus "Caveman:" recap. Exception: user explicitly ask what the mode is.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+English only. Caveman applies to English output; do not garble other languages.
+
+## Intensity
+
+Single level: **full**. Classic caveman — every rule above applies at full strength; there is no milder setting.
+
+Example — "Why React component re-render?"
+- "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+
+Example — "Explain database connection pooling."
+- "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+
+## Auto-Clarity
+
+Drop caveman when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g., `"migrate table drop column backup first"` — order unclear without articles/conjunctions)
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Mode persist until changed or session end.

.cursor/skills/gh-ci/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: gh-ci
+description: >-
+  Use GitHub CLI to snapshot or wait on CI for a pull request or workflow run.
+  Prefer gh pr checks / gh pr checks --watch; fall back to gh run list and
+  gh run watch when PR checks are empty or unavailable. Use when waiting for
+  CI, checking if checks are green, Actions are pending/failed, or the user
+  mentions gh run watch / gh pr checks / "CI green".
+issue-flow-version: 0.4.2a4
+---
+
+# gh-ci — wait on GitHub CI with `gh`
+
+Teach agents the concrete `gh` commands for **listing** and **watching** CI.
+Always pass `--repo <owner/repo>` (never rely on `gh`'s cwd default).
+
+## Primary (PR-attached checks)
+
+Prefer these when a pull request number is known (usual `/iflow-close` path):
+
+```bash
+# One-shot snapshot — exit 0 means green (or all pass / skipping)
+gh pr checks <number> --repo <owner/repo>
+
+# Wait until checks finish (or fail-fast on red)
+gh pr checks <number> --repo <owner/repo> --watch --fail-fast
+```
+
+**Budget:** honour **15 minutes** wall-clock for any
+`--watch` (from `[issueflow].checks_watch_minutes` /
+`ISSUEFLOW_CHECKS_WATCH_MINUTES`, default 15). `gh` has no max-duration flag —
+the agent stops the watch when the cap hits.
+
+## Fallback (workflow runs)
+
+When `gh pr checks` returns empty, cannot resolve checks, or there is no PR yet
+but a workflow run id is known:
+
+```bash
+gh run list --repo <owner/repo> --limit 10
+gh run watch <run-id> --repo <owner/repo>
+```
+
+Optional: `gh run view <run-id> --repo <owner/repo> --log-failed` after a red
+run to surface failing job logs.
+
+## Semantics
+
+| Result | Meaning | Agent action |
+|--------|---------|--------------|
+| Exit 0 / all `pass` or `skipping` | CI green | Proceed (merge, report green, etc.) |
+| Fail / `--fail-fast` | CI red | Stop hands-off paths; report failing check/run URLs |
+| Still pending past budget | Unknown | Do not hang; report pending and follow the calling skill (e.g. close yolo may fall back to `--auto`) |
+
+## Where this fits
+
+- **`/iflow-close`** owns the merge / yolo watch-then-merge sequence; this skill
+  is the shared cheatsheet for the CI commands themselves.
+- Design record: `.issueflows/04-designs-and-guides/gh-list-and-watch.md`
+  (issues #172, #220).

.cursor/skills/grill-me/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: grill-me
+description: >-
+  Interview the user relentlessly about a plan or design until every branch of
+  the decision tree is resolved, then feed the conclusions into the issue plan.
+  Use when the user wants to stress-test a plan, asks to "grill me", or during
+  /iflow-plan when grilling is turned on. Off via "stop grilling" / "normal mode".
+issue-flow-version: 0.4.2a4
+---
+
+# Grill me — relentless planning interview
+
+Interview the user about every aspect of the plan until you reach a shared,
+unambiguous understanding. Walk down each branch of the design tree, resolving
+dependencies between decisions one at a time. The goal is to surface hidden
+assumptions and edge cases **before** they get encoded in code or written into
+`.issueflows/01-current-issues/issue<N>_plan.md`.
+
+## When to use
+
+- The user asks to be grilled / stress-tested ("grill me", "poke holes in this").
+- During `/iflow-plan`, when grilling is active (see *Activation* below), to
+  pressure-test the approach before the plan file is drafted.
+
+## How to grill
+
+- **One question at a time.** Never batch questions. Wait for the answer before
+  moving to the next branch.
+- **Always recommend an answer.** For each question, give your recommended option
+  and a one-line rationale, so the user can accept quickly or push back.
+- **Explore before asking.** If a question can be answered by reading the code,
+  the issue text, or `.issueflows/04-designs-and-guides/`, explore first
+  and confirm what you found instead of asking the user to do your homework.
+- **Follow the decision tree.** Resolve upstream decisions before the ones that
+  depend on them; let earlier answers prune later branches.
+- **Stay on scope.** Grill the issue at hand. Park genuinely separate concerns as
+  follow-up notes rather than expanding the interview indefinitely.
+- **Know when to stop.** End when every open branch is resolved (or explicitly
+  deferred) and you can restate the plan without ambiguity. Summarize the agreed
+  decisions so they can flow straight into the plan.
+
+## Activation
+
+This skill is **dormant by default**: it engages only when the user asks for it
+("grill me") or when a project turns it on for planning.
+
+Turn it off again for the rest of a session with **"stop grilling"** or
+**"normal mode"**. (To make grilling on by default during planning for this
+project, set `grill_me_default = true` under `[issueflow]` in
+`.issueflows/config.toml` and re-run `issue-flow update`.)
+
+
+## Boundaries
+
+- Grilling is a **planning** aid: it questions and aligns, it does not write code.
+- Hand the agreed decisions to `/iflow-plan` so they land in `issue<N>_plan.md`;
+  implementation still goes through `/iflow-build`.

.cursor/skills/iflow-archive/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: iflow-archive
+description: >-
+  Condense old solved issue groups into one dated summary file, then delete
+  the originals. Destructive, one consolidated confirm.
+disable-model-invocation: true
+issue-flow-version: 0.4.2a4
+---
+
+# issue-flow — archive solved issues (`/iflow-archive`)
+
+Follow this skill to **shrink the solved-issues archive**:
+old `issue<N>_*` groups under `.issueflows/03-solved-issues/` are
+summarised into one dated markdown file and the originals are deleted (they
+stay recoverable through git history).
+
+Do **not** use this to park or close an active issue — that is `/iflow-pause` / `/iflow-close`. This skill only touches `.issueflows/03-solved-issues/`.
+
+## Input
+
+- **(nothing)** — smart default: propose archiving every solved group **except the 5 most recent** (highest issue numbers).
+- **`keep <K>`** — same, but keep the `<K>` most recent groups instead.
+- **an explicit list** (e.g. `12 13 24`) — archive exactly those issues.
+- **`all`** — archive every solved group.
+
+
+**Invoke:** type `iflow archive` in chat, or `/iflow-archive` from the slash menu (`iflow-archive` also works).
+
+
+
+
+### MODEL & EXECUTION DIRECTIVE
+
+
+**Profile: reasoning** — Prioritize deep thinking and careful trade-offs over speed or token economy.
+
+In Cursor: switch to a thinking-capable model before invoking this step (not Auto-only).
+
+
+
+Keep scope tight to what this step requires.
+
+
+
+## Instructions
+
+> **CLI fast path (optional).** If the `issue-flow` CLI is on `PATH`, the
+> mechanical deletion step has a deterministic shortcut:
+> `issue-flow agent archive <N> [<N> ...]` (add `--dry-run` to preview,
+> `--json` for a machine-readable object). It removes the chosen groups'
+> files and reports the pre-archive HEAD sha — you still select candidates,
+> confirm with the user, and write the summary file yourself. The CLI is
+> optional: if it is missing or errors, fall back to the manual instructions
+> below.
+
+1. **Preflight.** Require a **clean working tree** (`git status --porcelain`); if dirty, **stop** and ask the user to commit or stash first — the recovery ref is only meaningful when the deletion lands as its own commit. Capture the pre-archive ref: `git rev-parse HEAD`.
+
+2. **Select candidates.** List every `issue<N>_*` group in `.issueflows/03-solved-issues/` with its number and title (from the `# Issue #N: <title>` heading of `issue<N>_original.md`). Apply the input rule (default: all except the 5 most recent by issue number). Show the resulting candidate list — number, title, file names — and let the user add/remove issues.
+
+3. **Consolidated confirm** (destructive — written in normal prose, never shortened). One prompt covering exactly: which issues get summarised, that their files will be **deleted**, and that recovery relies on git history via the recorded ref. Do not proceed without a clear yes.
+
+4. **Summarise (before deleting).** Append to `.issueflows/03-solved-issues/YYYY-MM-DD_archived_issues.md` (today's date; create the file if missing). Structure:
+
+   ```markdown
+   # Archived issues — YYYY-MM-DD
+
+   Pre-archive git ref: `<sha>`
+   Recover any archived file with `git show <sha>:<path>` (or browse `git log -- <path>`).
+
+   ## Issue #<N>: <title>
+
+   - Source: <GitHub issue URL, from the original file>
+   - Archived files: issue<N>_original.md, issue<N>_plan.md, issue<N>_status.md
+   - Summary: 2–4 sentences distilled from the original / plan / status files —
+     what the issue was, what was done, and the outcome.
+   ```
+
+   One `## Issue` section per archived issue. If the dated file already exists (same-day rerun), append a `---` separator followed by a fresh `Pre-archive git ref:` line for this run, then the new issue sections. The dated filename deliberately does **not** match `issue<N>_*`, so it never interferes with issue grouping.
+
+5. **Delete.** Remove the archived groups' files — CLI fast path (`issue-flow agent archive ...`), or manually `git rm .issueflows/03-solved-issues/issue<N>_*` per issue.
+
+6. **Commit offer.** Propose a single commit, e.g. `chore(iflow): archive <count> solved issues (pre-archive ref <short-sha>)`, including the new/updated dated file and the deletions. Ask before committing; never push from this skill.
+
+7. **Report.** Summarise: how many issues were archived, the dated file path, the pre-archive ref, and the one-line recovery recipe.
+
+## Constraints
+
+- **Off-path.** Never auto-dispatch from `/iflow`, `/iflow-build`, or `/iflow-close`. The user opts in explicitly.
+- **Destructive, so gated.** Never delete anything before the consolidated confirm in step 3, and never delete files that were not summarised in step 4.
+- Only `.issueflows/03-solved-issues/` is touched — never `01-current-issues/`, `02-partly-solved-issues/`, `00-tools/`, or `04-designs-and-guides/`.
+- Requires a clean working tree; the deletion should land as its own commit so `git show <ref>:<path>` recovery always works.
+- Summaries are interpretive (agent judgment); the CLI only ever does the mechanical deletion.