# AGENTS.md

## Project goals

1. **Unify and systematize issue workflow** for the development team with
   minimal context usage. Issue operations are wrapped in scripts so agents
   spend tokens on the task, not on re-deriving commands and formats.
2. **Keep the tracker out of the work.** An issue is a unit of work first and a
   Gitea row second. The two are separate layers, and the first one does not
   know the second exists.
3. **Route all Gitea interaction through the `tea` CLI via scripts** instead of
   direct ad-hoc calls wherever possible. Scripts give deterministic,
   reviewable behavior; the `tea-guard` hook enforces that every `tea`
   invocation runs under the operator-pinned login.

## Layers

The hard rule of this repo. One domain, one bridge, one transport, and
knowledge flows one way only:

```
skills/issue    DOMAIN     what an issue is: format, validation, dependency graph
      ▲                    offline — no tracker, no network, stdlib imports only
      │ imports
skills/sync     BRIDGE     map.py     md <-> Gitea issue JSON, pure, no I/O
                           _gitea.py  tea api, pagination, filters, payloads
      │ imports
      ▼
skills/auth     IDENTITY   pin the login the whole tracker side runs under
      ▲                    pin.py  where the pin is and how it is found —
      │ imports            imported by _gitea.py AND by hooks/tea-guard.sh
hooks/tea-guard            so `tea` and the scripts cannot disagree

skills/use      REFERENCE  tea CLI docs for everything that is not an issue
      ▲
      │ calls
agents/         EXECUTION  tea-runner: runs the scripts, reports a receipt
```

The domain never imports its bridge: delete `skills/sync` and issues still
work. The check is mechanical — every import under the domain's `scripts/` is
stdlib, and `subprocess` is not among them:

```bash
grep -rh '^import \|^from ' skills/issue/scripts/ | sort -u
```

If a tracker concept (issue number, login, HTTP call, label color) shows up in
the domain layer, it is in the wrong place.

## Repo layout

- `skills/auth` — pin the Gitea login used by `tea` (`/tea:auth`)
  - `scripts/pin.py` — the one written copy of the pin's location and search
    order (see "The login pin" below); stdlib, no subprocess, no network
- `skills/issue` — issues as units of work (`/tea:issue`), entirely offline
  - `references/format.md` — canonical issue format; single source of truth
  - `scripts/issue.py` — domain module: slug identity, parse/render, validation,
    taxonomy, dependency graph, body checkboxes
  - `scripts/issue_new.py` — create a local issue from its type template
  - `scripts/issue_check.py` — validate against the format
  - `scripts/issue_ac.py` — list the body's checkboxes; tick one by number or
    substring, changing exactly one character of the file
  - `scripts/issue_tree.py` — draw the dependency graph
  - `scripts/issue_evict.py` — remove closed issues from the store; never an
    `origin: local` one
  - `scripts/issue_index.py` — rebuild `tmp/issues/INDEX.md`
- `skills/sync` — move issues between the local store and Gitea (`/tea:sync`)
  - `scripts/map.py` — md ↔ Gitea JSON, pure, no I/O; label colors live here
  - `scripts/_gitea.py` — transport: `tea api`, pagination, filters, label ids,
    the remote-id map, `tmp/payload/`; the login comes from `auth/pin.py`
  - `scripts/pull.py`, `push.py`, `remote.py`, `comment.py`
  - `scripts/close.py` — the state field, both ways; explicit ids only
  - `scripts/evict.py` — refresh `state:` from Gitea, then hand the decision to
    the domain's `issue_evict.run`
  - `scripts/labels.py` — put the canonical `type/*` and `severity/*` set into a
    repository; reads the domain taxonomy, never the store
- `skills/use` — `tea` CLI reference for everything that is not an issue
  (`/tea:use`); `references/tea/` holds the command docs
- `agents/tea-runner.md` — subagent on Haiku that executes the scripts and
  returns a compact receipt. Delegate batches (bulk pull, push a named set,
  bootstrap labels, rebuild the index), never the thinking: it has no `Edit`
  and no `Write`, may not `--force`, and may not decide what an issue says.
  Delegating a single call costs more than running it inline — the win is the
  loop, the retry, and the error triage.
- `hooks/` — PreToolUse hooks: `tea-guard` blocks or rewrites `tea` invocations
  that don't use the pinned login (resolving it through `auth/pin.py`);
  `agents-sync` keeps every directory canonical (`AGENTS.md` real file,
  `CLAUDE.md` symlink to it)
- `tests/` — stdlib `unittest`, no third-party anything

## The login pin

`<project root>/.claude/settings.local.json` → `env.GITEA_LOGIN`, written by
`/tea:auth` and read at call time. **The search order is written once, in
`skills/auth/scripts/pin.py`**, and both callers import it: the transport
(`_gitea.require_login`) and the `tea-guard` hook. Neither spells the path or
the walk itself, and a test asserts they don't.

Start directories, first hit wins: `$CLAUDE_PROJECT_DIR`, then a hint the
caller supplies (the hook passes the Bash payload's `cwd`; a script passes
nothing), then the current directory. Each one is searched up its parent chain,
and then — only if that found nothing — up the parent chain of the **main
working tree of any linked worktree** met on the way, reached by reading
`gitdir:` out of a `.git` *file* and following `commondir`.

**The pin is not resolved from `__file__`, and that asymmetry with
`issue.store_root`/`_gitea.PAYLOAD_ROOT` is deliberate.**
Where an installation keeps its files is a fact about the installation; whose
login a project runs under is a fact about the project. A plugin installed
outside any repository and pointed at somebody else's tree must not answer the
second question from its own directory. So the search runs from the working
directory upward — and reaches a worktree's main checkout by asking git.

Two failures this replaces, both worth remembering: a git worktree is a
*sibling* of the main checkout, so the untracked pin is not on its parent chain
and the whole sync layer died there while `tea` in the same directory worked;
and the cure it invited — `/tea:auth` inside the worktree — writes a second
settings file into a directory that is deleted with the worktree.

## Tests

```bash
python3 -m unittest discover -s tests -v
```

Plain `unittest`; no pytest, no dependencies — the scripts under test are
stdlib-only and the tests hold the same line. `skills/*/scripts/` are not
packages, so a test that needs the domain module imports it with
`sys.path.insert`.

**A test never touches `tmp/issues/` or `tmp/payload/`.** Anything that needs a
store builds a throwaway repository in a `tempfile.TemporaryDirectory()` — a
`.git` marker, a copy of the script layers, fixture issues — and runs the real
scripts inside it as subprocesses. That is the only way to test behavior that depends on where a
script is run from, and it keeps the developer's own store out of the blast
radius.

`tmp/payload/` is in that list because `_gitea.PAYLOAD_ROOT` is resolved once,
from the module's own location: a test that stubs the transport *below* `api()`
— at `subprocess`, to exercise a non-2xx — reaches the real write. Such a test
patches `PAYLOAD_ROOT` to its own temp directory too.

## Local issue store

`tmp/issues/` (gitignored) holds **two kinds of file, and only one of them is a
store.** An `origin: local` issue lives here and nowhere else — this file *is*
the issue, and losing it loses the work. Anything with `origin: gitea` is a
**cache**: the tracker has it, this copy is a working copy, and it is deleted
the moment a push confirms the tracker is up to date.

One flat markdown file per issue, named by its slug, with one metadata field per
line so plain grep works without a parser.

- **The path is `<repo root>/tmp/issues`, resolved from `issue.py`'s own
  location, not from cwd.** `issue.store_root()` walks up from `__file__` to the
  nearest `.git` or `AGENTS.md` — so every script in both layers sees one store
  whatever directory it is run from. An explicit `--out` overrides it and is
  used exactly as typed; a relative `--out` stays relative to cwd.
- Nothing creates the store as a side effect of a write. Readers distinguish
  "does not exist" from "is empty"; only `issue_new.py` and `pull.py` create it,
  and they say so on stderr.
- Identity is the slug (`wire-sqlc-appclick.md`), never a tracker number.
  Numbers live in the `gitea:` field.
- `origin: local` is a complete state, not a draft: an issue that never leaves
  this machine is valid and finished. It is not a *durable* state, though —
  pushing ends it, and the local file goes with it.
- **A successful push deletes the local file** (`<id>.md` and
  `<id>.comments.md`), and prints the number and URL the issue now lives at.
  `--update` too: one rule, no exception. What is in the store is what has not
  left. Get it back with `pull.py <n>` — which brings its blockers back with it:
  a pull returns the unit of work, not one row of it. `--no-deps` narrows it to
  the one issue, and the cost of the default is in `pull.py`'s docstring.
- Deletion happens only after a confirmed tracker response and only after
  `.remote.json` has been written. Network down, non-2xx, an answer that does
  not carry the right number: the file stays and the run stops. A never-pushed
  `origin: local` issue is never touched by any of this.
- The slug survives the round trip because it goes up in the body as
  `<!-- tea:id … -->` (`map.with_id_marker`) and is indexed by number in
  `tmp/issues/.remote.json`. A rename in the web UI, a lost `.remote.json`, a
  fresh clone, another machine — the file comes back under the same name and
  every `depends:` that points at it still resolves.
- `.remote.json` is therefore no longer "an index over the files": it is the
  local number → slug ledger, its entries outlive the files they name, and
  nothing prunes them. It is still recoverable — from the markers in Gitea, not
  from the files. **Eviction does not prune it either**, for the same reason a
  push does not: an evicted issue is in exactly the state a pushed one is.
- **A closed issue is evicted, not archived.** `issue_evict.py` removes
  `<id>.md` and every sidecar under that slug for anything that is `state:
  closed` **and** carries an `origin:` naming a tracker, then rebuilds
  `INDEX.md`. `--dry-run` prints and writes nothing. **`origin: local` is never
  evicted, in any state, not even when named on the command line** — that file
  *is* the issue and nothing can fetch it back.
- **Eviction lives in the domain** (`skills/issue/scripts/issue_evict.py`),
  because its two inputs — `state:` and `origin:` — are domain fields and the
  answer is already on disk. No network, no login, no `tea`.
  `skills/sync/scripts/evict.py` is the bridge form: it refreshes `state:` from
  the tracker first (a local `state:` is only as fresh as the last pull) and then
  calls `issue_evict.run`. One implementation of "what may be evicted", in the
  layer that owns the fields it reads. Same gate as push, one step earlier: a
  failed or unconfirmed tracker answer evicts nothing at all.
- **Pull by number fetches an issue in any state — a number is a number.** An
  address is not a query: `pull.py 42` puts a closed issue on disk exactly as it
  always has, and so does `#42`, `owner/repo#42`, or its URL. Only filter mode
  (`--milestone`, `--label`, `-q`) leaves closed issues out. Eviction does not
  revoke this: a closed issue pulled after a cleanup lands on disk again, and
  that is the tracker answering what it was asked, not a regression. Evict it
  again when you are done with it.
- Pulling overwrites the body — a fetch, not a merge. It is also how a pushed
  issue comes back at all.
- No drift tracking, and now nothing to track: there is no second copy to
  diverge from. `synced:` tells you how old your working copy is.

## Request payloads

`tmp/payload/` (gitignored) holds the JSON bodies `tea api -d @file` was given,
one file per named request, kept after the call for a retry or a post-mortem.
It is **not a store and holds nobody's only copy** — deleting it costs nothing.

- One directory for every caller, resolved from `_gitea.py`'s own location, so
  which command wrote a body does not change where it landed. `_gitea.api` takes no directory argument; that it once did
  is exactly how a label bootstrap came to create `tmp/issues/`.
- It is created lazily, by the first write of a run, and only then: a `--dry-run`
  or a run with nothing to send leaves no directory behind.
- **A scratchpad may never sit inside a store.** Store contents are the thing
  being tracked; request bodies are debris of the transport. When the two share
  a path, an operation that touches no issue at all still materializes the issue
  store, and the operator's `ls tmp/issues` starts lying about what exists.