Cline rules for Go

# Cline and Roo rules

Project rules for Cline and Roo Code in this Go repository.
Use the project's commands. Do not invent a package manager, and do not run destructive shell commands.

## Tool use

- Read the files you will change before editing them.
- Prefer a focused patch over rewriting a whole file.
- Run the test command from this file after a behavior change, or say why you could not.
- Do not delete generated folders, lockfiles, or migrations unless the task says so.

## Stack

This repository is a Go module. Format with gofmt, keep the standard library first, and pass context through exported I/O.

## Layout

- Packages are small and named for what they provide, not `util`.
- `cmd/` holds binaries. Importable code lives in other packages.
- Internal packages stay under `internal/` when the module already uses that boundary.

## Commands

- Test: `go test ./...`
- Format: `gofmt -w .`
- Vet: `go vet ./...`
- Build: `go build ./...`

Use the script the repo already defines when it differs from the command above.

## Conventions

- Run gofmt on every change. Do not hand-align code in a way gofmt will undo.
- Accept interfaces, return concrete types, unless the package already does otherwise.
- Pass `context.Context` as the first argument after the receiver on I/O that can be cancelled.
- Wrap errors with `%w` when the caller should use `errors.Is` or `errors.As`.
- Handle errors where they happen. Do not assign them to `_`.
- Exported names have a doc comment when the package is imported by other modules.

## Testing

Add or update tests when behavior changes.

Prefer table-driven tests in the same package. Cover the success path and one failure.

## Style

- Optimize for the next reader over the shortest diff.
- Comment only when the why is non-obvious.
- Name things the way neighboring files already do.
- Do not reformat code you did not change.

## Errors

- Fail at the boundary. Do not swallow errors.
- Return `error`. Wrap it with enough context to know which operation failed. Do not log and return the same error unless the caller cannot see the log.

## Scope

- Do the requested task. Do not refactor unrelated code.
- Match the rigor already in the repo. Fix what you touch.
- Ask one clarifying question only when the task cannot be finished without it. Otherwise state the assumption and continue.

## Avoid

- Do not panic for a normal error path.
- Do not start a goroutine without a way to finish it.
- Do not share a map across goroutines without synchronization.
- Do not add a framework for a handler the standard library already serves.

## Done when

- The requested behavior works.
- `gofmt` leaves the tree clean and `go test ./...` passes.
- The diff stays inside the task.
- You list anything you could not run.