refactor: split issue domain from Gitea transport

An issue was a Gitea row that happened to be cached locally: its identity
was the tracker's number (42.md), its dependencies were tracker numbers
(depends: [#12]), and a local issue existed only as a draft that push
deleted on success. Nothing could be planned or tracked without a tracker.

Split into layers, with knowledge flowing one way:

  skills/issue  DOMAIN  what an issue is: format, validation, dep graph
        ^               offline; stdlib imports only, no subprocess
        | imports
  skills/sync   BRIDGE  map.py    md <-> Gitea JSON, pure, no I/O
                        _gitea.py login pin, api, pagination, filters
  skills/use    REFERENCE  tea CLI docs for non-issue entities

skills/issue never imports skills/sync. Delete the sync layer and the
domain keeps working.

Identity is now a slug derived from the title (wire-sqlc-appclick.md) and
is stable across retitles and pushes. Tracker numbers live in a `gitea:`
field, never in a file name and never in `depends:`; the pair is indexed
in .remote.json, which is a cache over the files, not a second source of
truth.

Behavior changes:

- Pushing is additive. The file is never deleted; it gains gitea:/url:/
  synced: and origin: flips from local to gitea. `origin: local` is a
  durable state, not a pending one.
- Pushes go in topological order so dependencies get numbers first.
- The dependency graph is computed offline from `depends:` metadata; body
  prose is passed through unchanged in both directions rather than being
  rewritten between slugs and #N.
- `origin` is domain-owned (whether work exists elsewhere is a fact about
  the work); the handle and how to reach it stay with sync.

Script moves:

  issue_get.py   -> sync/pull.py
  issue_push.py  -> sync/push.py
  issue_list.py  -> sync/remote.py
  issue_index.py -> issue/issue_index.py
  _tea.py        -> split into issue/issue.py, sync/map.py, sync/_gitea.py

New: issue/issue_new.py, issue/issue_check.py, issue/issue_tree.py, and
sync/comment.py — comment posting was the last issue operation still
hand-rolled through raw `tea api`.

references/issue-format.md moves to skills/issue/references/format.md;
label hex colors move out of it into map.py, since a color is how a
tracker paints a chip, not what an issue is.

Verified: offline path end to end (new, check, tree, index, push
--dry-run) and read-only against Gitea (remote listing, pull with
mapping, comment guard). Write paths of push.py and comment.py are not
exercised here.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

skills/issue/scripts/issue_index.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+issue_index.py — rebuild tmp/issues/INDEX.md from what is on disk. Offline.
+
+A map of the local store, nothing else. The `origin` column is the only place
+the index acknowledges that a tracker exists: `local` means the issue has never
+left this machine, `gitea` means the sync layer has pushed or pulled it. Both
+are ordinary issues here.
+
+Usage:
+    issue_index.py [--out tmp/issues]
+"""
+import argparse
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import issue  # noqa: E402
+
+
+def cell(v):
+    if isinstance(v, (list, tuple)):
+        return ", ".join(str(x) for x in v) or "—"
+    v = str(v or "").strip()
+    return v.replace("|", "\\|") or "—"
+
+
+def build(root):
+    issues = issue.load_all(root)
+    rows = []
+    for i in sorted(issues):
+        iss = issues[i]
+        rest = [l for l in iss.labels if not l.startswith("type/")]
+        rows.append({
+            "id": i,
+            "state": cell(iss.state),
+            "type": cell(iss.type),
+            "labels": cell(rest),
+            "title": cell(iss.title),
+            "milestone": cell(iss.milestone),
+            "depends": cell(iss.depends),
+            "origin": cell(iss.origin),
+        })
+
+    listing = os.listdir(root) if os.path.isdir(root) else []
+    trees = sorted(f for f in listing if re.match(r'^tree-.+\.md$', f))
+
+    out = ["# Issue store", "",
+           "Every issue this project knows about. `origin: local` means it "
+           "exists nowhere else — a complete state, not a pending one. Any "
+           "other value names the tracker it also lives in; the handle is in "
+           "the file. Rebuild with `issue_index.py`.", ""]
+    if rows:
+        out += ["| id | state | type | labels | title | milestone | depends | origin |",
+                "|---|---|---|---|---|---|---|---|"]
+        out += ["| [%s](%s.md) | %s | %s | %s | %s | %s | %s | %s |" % (
+            r["id"], r["id"], r["state"], r["type"], r["labels"], r["title"],
+            r["milestone"], r["depends"], r["origin"]) for r in rows]
+    else:
+        out.append("_empty_")
+
+    if trees:
+        out += ["", "## Dependency trees", ""]
+        out += ["- [%s](%s)" % (t, t) for t in trees]
+
+    cycles = issue.find_cycles(issue.graph(issues))
+    if cycles:
+        out += ["", "## Dependency cycles", ""]
+        out += ["- %s" % " -> ".join(c) for c in cycles]
+
+    out.append("")
+    path = os.path.join(root, "INDEX.md")
+    os.makedirs(root, exist_ok=True)
+    with open(path, "w") as f:
+        f.write("\n".join(out))
+    return path, len(rows)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Rebuild the local issue index (offline)")
+    ap.add_argument("--out", default=issue.ISSUE_ROOT, help="store root (default: tmp/issues)")
+    args = ap.parse_args()
+    path, n = build(args.out)
+    print("%s — %d issue(s)" % (path, n))
+
+
+if __name__ == "__main__":
+    main()